class CV_EXPORTS MatExpr;
class CV_EXPORTS MatOp_Base;
-class CV_EXPORTS VectorArg;
class CV_EXPORTS MatArg;
class CV_EXPORTS MatConstIterator;
Custom array allocator
*/
-class CV_EXPORTS ArrayAllocator
+class CV_EXPORTS MatAllocator
{
public:
- ArrayAllocator() {}
- virtual ~ArrayAllocator() {}
+ MatAllocator() {}
+ virtual ~MatAllocator() {}
virtual void allocate(int dims, const int* sizes, int type, int*& refcount,
uchar*& datastart, uchar*& data, size_t* step) = 0;
virtual void deallocate(int* refcount, uchar* datastart, uchar* data) = 0;
uchar* datalimit;
//! custom allocator
- ArrayAllocator* allocator;
+ MatAllocator* allocator;
struct CV_EXPORTS MSize
{
MStep step;
};
-
+
/*!
Random Number Generator
uint64 state;
};
+
+
+
/*!
Termination criteria in iterative algorithms
//! converts elliptic arc to a polygonal curve
CV_EXPORTS void ellipse2Poly( Point center, Size axes, int angle,
- int arcStart, int arcEnd, int delta, CV_OUT vector<Point>& pts );
+ int arcStart, int arcEnd, int delta,
+ CV_OUT vector<Point>& pts );
enum
{
inline Mat::Mat(const CvMat* m, bool copyData)
: flags(MAGIC_VAL + (m->type & (CV_MAT_TYPE_MASK|CV_MAT_CONT_FLAG))),
dims(2), rows(m->rows), cols(m->cols), data(m->data.ptr), refcount(0),
- datastart(0), dataend(0),
- allocator(0), size(&rows)
+ datastart(m->data.ptr), allocator(0), size(&rows)
{
if( !copyData )
{
}
template<typename _Tp> inline _Tp& Mat::at(int i0)
-{ return *(_Tp*)ptr(i0); }
+{
+ CV_DbgAssert( dims <= 2 && data && (size.p[0] == 1 || size.p[1] == 1) &&
+ (unsigned)i0 < (unsigned)(size.p[0] + size.p[1] - 1) &&
+ elemSize() == CV_ELEM_SIZE(DataType<_Tp>::type) );
+ return *(_Tp*)(data + step.p[size.p[0]==1]*i0);
+}
+
template<typename _Tp> inline const _Tp& Mat::at(int i0) const
-{ return *(const _Tp*)ptr(i0); }
+{
+ CV_DbgAssert( dims <= 2 && data && (size.p[0] == 1 || size.p[1] == 1) &&
+ (unsigned)i0 < (unsigned)(size.p[0] + size.p[1] - 1) &&
+ elemSize() == CV_ELEM_SIZE(DataType<_Tp>::type) );
+ return *(_Tp*)(data + step.p[size.p[0]==1]*i0);
+}
+
template<typename _Tp> inline _Tp& Mat::at(int i0, int i1, int i2)
-{ return *(_Tp*)ptr(i0, i1, i2); }
+{
+ CV_DbgAssert( elemSize() == CV_ELEM_SIZE(DataType<_Tp>::type) );
+ return *(_Tp*)ptr(i0, i1, i2);
+}
template<typename _Tp> inline const _Tp& Mat::at(int i0, int i1, int i2) const
-{ return *(const _Tp*)ptr(i0, i1, i2); }
+{
+ CV_DbgAssert( elemSize() == CV_ELEM_SIZE(DataType<_Tp>::type) );
+ return *(const _Tp*)ptr(i0, i1, i2);
+}
template<typename _Tp> inline _Tp& Mat::at(const int* idx)
-{ return *(_Tp*)ptr(idx); }
+{
+ CV_DbgAssert( elemSize() == CV_ELEM_SIZE(DataType<_Tp>::type) );
+ return *(_Tp*)ptr(idx);
+}
template<typename _Tp> inline const _Tp& Mat::at(const int* idx) const
-{ return *(const _Tp*)ptr(idx); }
+{
+ CV_DbgAssert( elemSize() == CV_ELEM_SIZE(DataType<_Tp>::type) );
+ return *(const _Tp*)ptr(idx);
+}
template<typename _Tp> inline MatConstIterator_<_Tp> Mat::begin() const
{
return cvarrToMat(arr, copyData, true, coiMode);
}
-
+
+///////////////////////////////////////////// SVD //////////////////////////////////////////////////////
+
inline SVD::SVD() {}
inline SVD::SVD( const Mat& m, int flags ) { operator ()(m, flags); }
inline void SVD::solveZ( const Mat& m, Mat& dst )
}
}
+//////////////////////////////////// Matrix Expressions /////////////////////////////////////////
class CV_EXPORTS MatOp
{
return Mat::eye(sz, DataType<_Tp>::type);
}
-//////////// Iterators & Comma initializers //////////////////
+//////////////////////////////// Iterators & Comma initializers //////////////////////////////////
inline MatConstIterator::MatConstIterator()
: m(0), elemSize(0), ptr(0), sliceStart(0), sliceEnd(0) {}
if( src->data.ptr )
{
cvCreateData( dst );
- cvCopy( src, dst );
+ cv::Mat _src(src), _dst(dst);
+ uchar* data0 = dst->data.ptr;
+ _src.copyTo(_dst);
+ CV_Assert(_dst.data == data0);
+ //cvCopy( src, dst );
}
return dst;
return;
int r = size.p[0];
+
+ if( (size_t)r >= nelems )
+ return;
+
size.p[0] = std::max((int)nelems, 1);
size_t newsize = total()*elemSize();
void Mat::resize(size_t nelems)
{
int saveRows = size.p[0];
+ if( saveRows == (int)nelems )
+ return;
CV_Assert( (int)nelems >= 0 );
if( isSubmatrix() || data + step.p[0]*nelems > datalimit )
hdr.cols = new_width;
hdr.flags = (hdr.flags & ~CV_MAT_CN_MASK) | ((new_cn-1) << CV_CN_SHIFT);
+ hdr.step[1] = CV_ELEM_SIZE(hdr.flags);
return hdr;
}
+
+/*************************************************************************************************\
+ Matrix Operations
+\*************************************************************************************************/
-void
-setIdentity( Mat& m, const Scalar& s )
+//////////////////////////////////////// set identity ////////////////////////////////////////////
+void setIdentity( Mat& m, const Scalar& s )
{
CV_Assert( m.dims <= 2 );
int i, j, rows = m.rows, cols = m.cols, type = m.type();
}
}
+//////////////////////////////////////////// trace ///////////////////////////////////////////
+
Scalar trace( const Mat& m )
{
CV_Assert( m.dims <= 2 );
return cv::sum(m.diag());
}
-/****************************************************************************************\
-* transpose *
-\****************************************************************************************/
-
+////////////////////////////////////// transpose /////////////////////////////////////////
+
template<typename T> static void
transposeI_( Mat& mat )
{
}
-/****************************************************************************************\
-* Reduce Mat to vector *
-\****************************************************************************************/
+////////////////////////////////////////// reduce ////////////////////////////////////////////
template<typename T, typename ST, class Op> static void
reduceR_( const Mat& srcmat, Mat& dstmat )
temp.convertTo(dst, dst.type(), 1./(dim == 0 ? src.rows : src.cols));
}
+
+//////////////////////////////////////// sort ///////////////////////////////////////////
template<typename T> static void sort_( const Mat& src, Mat& dst, int flags )
{
func( src, dst, flags );
}
+
+
+////////////////////////////////////////// kmeans ////////////////////////////////////////////
+
static void generateRandomCenter(const vector<Vec2f>& box, float* center, RNG& rng)
{
size_t j, dims = box.size();
src.convertTo( dst, -1, scale );
}
-
}
-
+
/* End of file. */