generic-library/opencv
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Move cv::Mat out of core.hpp

Browse Source
This commit is contained in:
Andrey Kamaev
2013-03-28 21:01:12 +04:00
parent 135c0b6cb5
commit 715fa3303e
46 changed files with 1854 additions and 1731 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1364
modules/core/include/opencv2/core.hpp
View File

File diff suppressed because it is too large Load Diff

9
modules/core/include/opencv2/core/base.hpp
View File

@@ -441,9 +441,18 @@ class CV_EXPORTS Mat;
class CV_EXPORTS SparseMat;
typedef Mat MatND;
class CV_EXPORTS MatExpr;
template<typename _Tp> class CV_EXPORTS Mat_;
template<typename _Tp> class CV_EXPORTS SparseMat_;
class CV_EXPORTS MatConstIterator;
class CV_EXPORTS SparseMatIterator;
class CV_EXPORTS SparseMatConstIterator;
template<typename _Tp> class CV_EXPORTS MatIterator_;
template<typename _Tp> class CV_EXPORTS MatConstIterator_;
template<typename _Tp> class CV_EXPORTS SparseMatIterator_;
template<typename _Tp> class CV_EXPORTS SparseMatConstIterator_;
namespace ogl
{

1428
modules/core/include/opencv2/core/mat.hpp Normal file
View File

File diff suppressed because it is too large Load Diff

29
modules/core/include/opencv2/core/mat.inl.hpp
View File

@@ -383,15 +383,6 @@ inline Mat Mat::operator()(const Range* ranges) const
return Mat(*this, ranges);
}
inline Mat::operator CvMat() const
{
CV_DbgAssert(dims <= 2);
CvMat m = cvMat(rows, dims == 1 ? 1 : cols, type(), data);
m.step = (int)step[0];
m.type = (m.type & ~CONTINUOUS_FLAG) | (flags & CONTINUOUS_FLAG);
return m;
}
inline bool Mat::isContinuous() const { return (flags & CONTINUOUS_FLAG) != 0; }
inline bool Mat::isSubmatrix() const { return (flags & SUBMATRIX_FLAG) != 0; }
inline size_t Mat::elemSize() const { return dims > 0 ? step.p[dims-1] : 0; }
@@ -2411,11 +2402,11 @@ template<typename _Tp> inline SparseMat_<_Tp>::SparseMat_(const Mat& m)
*this = sm;
}
template<typename _Tp> inline SparseMat_<_Tp>::SparseMat_(const CvSparseMat* m)
{
SparseMat sm(m);
*this = sm;
}
// template<typename _Tp> inline SparseMat_<_Tp>::SparseMat_(const CvSparseMat* m)
// {
// SparseMat sm(m);
// *this = sm;
// }
template<typename _Tp> inline SparseMat_<_Tp>&
SparseMat_<_Tp>::operator = (const SparseMat_<_Tp>& m)
@@ -2457,11 +2448,11 @@ SparseMat_<_Tp>::create(int _dims, const int* _sizes)
SparseMat::create(_dims, _sizes, DataType<_Tp>::type);
}
template<typename _Tp> inline
SparseMat_<_Tp>::operator CvSparseMat*() const
{
return SparseMat::operator CvSparseMat*();
}
// template<typename _Tp> inline
// SparseMat_<_Tp>::operator CvSparseMat*() const
// {
// return SparseMat::operator CvSparseMat*();
// }
template<typename _Tp> inline int SparseMat_<_Tp>::type() const
{ return DataType<_Tp>::type; }

37
modules/core/include/opencv2/core/types_c.h
View File

@@ -94,6 +94,7 @@
#ifdef __cplusplus
# include "opencv2/core/types.hpp"
# include "opencv2/core/mat.hpp"
#endif
/* CvArr* is used to pass arbitrary
@@ -307,6 +308,11 @@ typedef struct _IplImage
char *imageDataOrigin; /* Pointer to very origin of image data
(not necessarily aligned) -
needed for correct deallocation */
#ifdef __cplusplus
_IplImage() {}
_IplImage(const cv::Mat& m);
#endif
}
IplImage;
@@ -417,6 +423,12 @@ typedef struct CvMat
int cols;
#endif
#ifdef __cplusplus
CvMat() {}
CvMat(const cv::Mat& m);
#endif
}
CvMat;
@@ -478,6 +490,16 @@ CV_INLINE CvMat cvMat( int rows, int cols, int type, void* data CV_DEFAULT(NULL)
return m;
}
#ifdef __cplusplus
inline CvMat::CvMat(const cv::Mat& m)
{
CV_DbgAssert(m.dims <= 2);
*this = cvMat(m.rows, m.dims == 1 ? 1 : m.cols, m.type(), m.data);
step = (int)m.step[0];
type = (type & ~cv::Mat::CONTINUOUS_FLAG) | (m.flags & cv::Mat::CONTINUOUS_FLAG);
}
#endif
#define CV_MAT_ELEM_PTR_FAST( mat, row, col, pix_size ) \
(assert( (unsigned)(row) < (unsigned)(mat).rows && \
@@ -567,6 +589,11 @@ typedef struct CvMatND
int step;
}
dim[CV_MAX_DIM];
#ifdef __cplusplus
CvMatND() {}
CvMatND(const cv::Mat& m);
#endif
}
CvMatND;
@@ -586,7 +613,7 @@ CvMatND;
struct CvSet;
typedef struct CvSparseMat
typedef struct CV_EXPORTS CvSparseMat
{
int type;
int dims;
@@ -599,9 +626,17 @@ typedef struct CvSparseMat
int valoffset;
int idxoffset;
int size[CV_MAX_DIM];
#ifdef __cplusplus
void copyToSparseMat(cv::SparseMat& m) const;
#endif
}
CvSparseMat;
#ifdef __cplusplus
CvSparseMat* cvCreateSparseMat(const cv::SparseMat& m);
#endif
#define CV_IS_SPARSE_MAT_HDR(mat) \
((mat) != NULL && \
(((const CvSparseMat*)(mat))->type & CV_MAGIC_MASK) == CV_SPARSE_MAT_MAGIC_VAL)

3
modules/core/src/array.cpp
View File

@@ -305,7 +305,8 @@ cvCloneMatND( const CvMatND* src )
if( src->data.ptr )
{
cvCreateData( dst );
cv::Mat _src(src), _dst(dst);
cv::Mat _src = cv::cvarrToMat(src);
cv::Mat _dst = cv::cvarrToMat(dst);
uchar* data0 = dst->data.ptr;
_src.copyTo(_dst);
CV_Assert(_dst.data == data0);

6
modules/core/src/gpumat.cpp
View File

@@ -544,7 +544,7 @@ cv::gpu::GpuMat::GpuMat(const GpuMat& m)
}
cv::gpu::GpuMat::GpuMat(int rows_, int cols_, int type_, void* data_, size_t step_) :
flags(Mat::MAGIC_VAL + (type_ & TYPE_MASK)), rows(rows_), cols(cols_),
flags(Mat::MAGIC_VAL + (type_ & Mat::TYPE_MASK)), rows(rows_), cols(cols_),
step(step_), data((uchar*)data_), refcount(0),
datastart((uchar*)data_), dataend((uchar*)data_)
{
@@ -568,7 +568,7 @@ cv::gpu::GpuMat::GpuMat(int rows_, int cols_, int type_, void* data_, size_t ste
}
cv::gpu::GpuMat::GpuMat(Size size_, int type_, void* data_, size_t step_) :
flags(Mat::MAGIC_VAL + (type_ & TYPE_MASK)), rows(size_.height), cols(size_.width),
flags(Mat::MAGIC_VAL + (type_ & Mat::TYPE_MASK)), rows(size_.height), cols(size_.width),
step(step_), data((uchar*)data_), refcount(0),
datastart((uchar*)data_), dataend((uchar*)data_)
{
@@ -1495,7 +1495,7 @@ GpuMat& cv::gpu::GpuMat::setTo(Scalar s, const GpuMat& mask)
void cv::gpu::GpuMat::create(int _rows, int _cols, int _type)
{
_type &= TYPE_MASK;
_type &= Mat::TYPE_MASK;
if (rows == _rows && cols == _cols && type() == _type && data)
return;

1
modules/core/src/lapack.cpp
View File

@@ -1689,7 +1689,6 @@ cvDet( const CvArr* arr )
if( rows == 3 )
return det3(Md);
}
return cv::determinant(cv::Mat(mat));
}
return cv::determinant(cv::cvarrToMat(arr));
}

8
modules/core/src/mathfuncs.cpp
View File

@@ -2350,7 +2350,7 @@ int cv::solveCubic( InputArray _coeffs, OutputArray _roots )
coeffs.size() == Size(1, n0) ||
coeffs.size() == Size(1, n0+1)) );
_roots.create(n0, 1, ctype, -1, true, DEPTH_MASK_FLT);
_roots.create(n0, 1, ctype, -1, true, _OutputArray::DEPTH_MASK_FLT);
Mat roots = _roots.getMat();
int i = -1, n = 0;
@@ -2482,7 +2482,7 @@ double cv::solvePoly( InputArray _coeffs0, OutputArray _roots0, int maxIters )
int n = coeffs0.cols + coeffs0.rows - 2;
_roots0.create(n, 1, CV_MAKETYPE(cdepth, 2), -1, true, DEPTH_MASK_FLT);
_roots0.create(n, 1, CV_MAKETYPE(cdepth, 2), -1, true, _OutputArray::DEPTH_MASK_FLT);
Mat roots0 = _roots0.getMat();
AutoBuffer<C> buf(n*2+2);
@@ -2550,7 +2550,9 @@ cvSolveCubic( const CvMat* coeffs, CvMat* roots )
void cvSolvePoly(const CvMat* a, CvMat *r, int maxiter, int)
{
cv::Mat _a = cv::cvarrToMat(a), _r = cv::cvarrToMat(r), _r0 = r;
cv::Mat _a = cv::cvarrToMat(a);
cv::Mat _r = cv::cvarrToMat(r);
cv::Mat _r0 = _r;
cv::solvePoly(_a, _r, maxiter);
CV_Assert( _r.data == _r0.data ); // check that the array of roots was not reallocated
}

316
modules/core/src/matrix.cpp
View File

@@ -371,13 +371,14 @@ Mat::Mat(const Mat& m, const Range* ranges) : size(&rows)
}
Mat::Mat(const CvMatND* m, bool copyData) : size(&rows)
static Mat cvMatNDToMat(const CvMatND* m, bool copyData)
{
initEmpty();
Mat thiz;
if( !m )
return;
data = datastart = m->data.ptr;
flags |= CV_MAT_TYPE(m->type);
return thiz;
thiz.data = thiz.datastart = m->data.ptr;
thiz.flags |= CV_MAT_TYPE(m->type);
int _sizes[CV_MAX_DIM];
size_t _steps[CV_MAX_DIM];
@@ -388,16 +389,107 @@ Mat::Mat(const CvMatND* m, bool copyData) : size(&rows)
_steps[i] = m->dim[i].step;
}
setSize(*this, d, _sizes, _steps);
finalizeHdr(*this);
setSize(thiz, d, _sizes, _steps);
finalizeHdr(thiz);
if( copyData )
{
Mat temp(*this);
temp.copyTo(*this);
Mat temp(thiz);
thiz.release();
temp.copyTo(thiz);
}
return thiz;
}
static Mat cvMatToMat(const CvMat* m, bool copyData)
{
Mat thiz;
if( !m )
return thiz;
if( !copyData )
{
thiz.flags = Mat::MAGIC_VAL + (m->type & (CV_MAT_TYPE_MASK|CV_MAT_CONT_FLAG));
thiz.dims = 2;
thiz.rows = m->rows;
thiz.cols = m->cols;
thiz.data = thiz.datastart = m->data.ptr;
size_t esz = CV_ELEM_SIZE(m->type), minstep = thiz.cols*esz, _step = m->step;
if( _step == 0 )
_step = minstep;
thiz.datalimit = thiz.datastart + _step*thiz.rows;
thiz.dataend = thiz.datalimit - _step + minstep;
thiz.step[0] = _step; thiz.step[1] = esz;
}
else
{
thiz.data = thiz.datastart = thiz.dataend = 0;
Mat(m->rows, m->cols, m->type, m->data.ptr, m->step).copyTo(thiz);
}
return thiz;
}
static Mat iplImageToMat(const IplImage* img, bool copyData)
{
Mat m;
if( !img )
return m;
m.dims = 2;
CV_DbgAssert(CV_IS_IMAGE(img) && img->imageData != 0);
int imgdepth = IPL2CV_DEPTH(img->depth);
size_t esz;
m.step[0] = img->widthStep;
if(!img->roi)
{
CV_Assert(img->dataOrder == IPL_DATA_ORDER_PIXEL);
m.flags = Mat::MAGIC_VAL + CV_MAKETYPE(imgdepth, img->nChannels);
m.rows = img->height;
m.cols = img->width;
m.datastart = m.data = (uchar*)img->imageData;
esz = CV_ELEM_SIZE(m.flags);
}
else
{
CV_Assert(img->dataOrder == IPL_DATA_ORDER_PIXEL || img->roi->coi != 0);
bool selectedPlane = img->roi->coi && img->dataOrder == IPL_DATA_ORDER_PLANE;
m.flags = Mat::MAGIC_VAL + CV_MAKETYPE(imgdepth, selectedPlane ? 1 : img->nChannels);
m.rows = img->roi->height;
m.cols = img->roi->width;
esz = CV_ELEM_SIZE(m.flags);
m.data = m.datastart = (uchar*)img->imageData +
(selectedPlane ? (img->roi->coi - 1)*m.step*img->height : 0) +
img->roi->yOffset*m.step[0] + img->roi->xOffset*esz;
}
m.datalimit = m.datastart + m.step.p[0]*m.rows;
m.dataend = m.datastart + m.step.p[0]*(m.rows-1) + esz*m.cols;
m.flags |= (m.cols*esz == m.step.p[0] || m.rows == 1 ? Mat::CONTINUOUS_FLAG : 0);
m.step[1] = esz;
if( copyData )
{
Mat m2 = m;
m.release();
if( !img->roi || !img->roi->coi ||
img->dataOrder == IPL_DATA_ORDER_PLANE)
m2.copyTo(m);
else
{
int ch[] = {img->roi->coi - 1, 0};
m.create(m2.rows, m2.cols, m2.type());
mixChannels(&m2, 1, &m, 1, ch, 1);
}
}
return m;
}
Mat Mat::diag(int d) const
{
@@ -433,101 +525,6 @@ Mat Mat::diag(int d) const
return m;
}
Mat::Mat(const CvMat* m, bool copyData) : size(&rows)
{
initEmpty();
if( !m )
return;
if( !copyData )
{
flags = MAGIC_VAL + (m->type & (CV_MAT_TYPE_MASK|CV_MAT_CONT_FLAG));
dims = 2;
rows = m->rows;
cols = m->cols;
data = datastart = m->data.ptr;
size_t esz = CV_ELEM_SIZE(m->type), minstep = cols*esz, _step = m->step;
if( _step == 0 )
_step = minstep;
datalimit = datastart + _step*rows;
dataend = datalimit - _step + minstep;
step[0] = _step; step[1] = esz;
}
else
{
data = datastart = dataend = 0;
Mat(m->rows, m->cols, m->type, m->data.ptr, m->step).copyTo(*this);
}
}
Mat::Mat(const IplImage* img, bool copyData) : size(&rows)
{
initEmpty();
if( !img )
return;
dims = 2;
CV_DbgAssert(CV_IS_IMAGE(img) && img->imageData != 0);
int imgdepth = IPL2CV_DEPTH(img->depth);
size_t esz;
step[0] = img->widthStep;
if(!img->roi)
{
CV_Assert(img->dataOrder == IPL_DATA_ORDER_PIXEL);
flags = MAGIC_VAL + CV_MAKETYPE(imgdepth, img->nChannels);
rows = img->height; cols = img->width;
datastart = data = (uchar*)img->imageData;
esz = CV_ELEM_SIZE(flags);
}
else
{
CV_Assert(img->dataOrder == IPL_DATA_ORDER_PIXEL || img->roi->coi != 0);
bool selectedPlane = img->roi->coi && img->dataOrder == IPL_DATA_ORDER_PLANE;
flags = MAGIC_VAL + CV_MAKETYPE(imgdepth, selectedPlane ? 1 : img->nChannels);
rows = img->roi->height; cols = img->roi->width;
esz = CV_ELEM_SIZE(flags);
data = datastart = (uchar*)img->imageData +
(selectedPlane ? (img->roi->coi - 1)*step*img->height : 0) +
img->roi->yOffset*step[0] + img->roi->xOffset*esz;
}
datalimit = datastart + step.p[0]*rows;
dataend = datastart + step.p[0]*(rows-1) + esz*cols;
flags |= (cols*esz == step.p[0] || rows == 1 ? CONTINUOUS_FLAG : 0);
step[1] = esz;
if( copyData )
{
Mat m = *this;
release();
if( !img->roi || !img->roi->coi ||
img->dataOrder == IPL_DATA_ORDER_PLANE)
m.copyTo(*this);
else
{
int ch[] = {img->roi->coi - 1, 0};
create(m.rows, m.cols, m.type());
mixChannels(&m, 1, this, 1, ch, 1);
}
}
}
Mat::operator IplImage() const
{
CV_Assert( dims <= 2 );
IplImage img;
cvInitImageHeader(&img, size(), cvIplDepth(flags), channels());
cvSetData(&img, data, (int)step[0]);
return img;
}
void Mat::pop_back(size_t nelems)
{
CV_Assert( nelems <= (size_t)size.p[0] );
@@ -673,16 +670,16 @@ Mat cvarrToMat(const CvArr* arr, bool copyData,
{
if( !arr )
return Mat();
if( CV_IS_MAT(arr) )
return Mat((const CvMat*)arr, copyData );
if( CV_IS_MAT_HDR_Z(arr) )
return cvMatToMat((const CvMat*)arr, copyData);
if( CV_IS_MATND(arr) )
return Mat((const CvMatND*)arr, copyData );
return cvMatNDToMat((const CvMatND*)arr, copyData );
if( CV_IS_IMAGE(arr) )
{
const IplImage* iplimg = (const IplImage*)arr;
if( coiMode == 0 && iplimg->roi && iplimg->roi->coi > 0 )
CV_Error(CV_BadCOI, "COI is not supported by the function");
return Mat(iplimg, copyData);
return iplImageToMat(iplimg, copyData);
}
if( CV_IS_SEQ(arr) )
{
@@ -2938,7 +2935,7 @@ CV_IMPL void cvTranspose( const CvArr* srcarr, CvArr* dstarr )
CV_IMPL void cvCompleteSymm( CvMat* matrix, int LtoR )
{
cv::Mat m(matrix);
cv::Mat m = cv::cvarrToMat(matrix);
cv::completeSymm( m, LtoR != 0 );
}
@@ -3109,17 +3106,6 @@ Mat Mat::reshape(int _cn, int _newndims, const int* _newsz) const
return Mat();
}
Mat::operator CvMatND() const
{
CvMatND mat;
cvInitMatNDHeader( &mat, dims, size, type(), data );
int i, d = dims;
for( i = 0; i < d; i++ )
mat.dim[i].step = (int)step[i];
mat.type |= flags & CONTINUOUS_FLAG;
return mat;
}
NAryMatIterator::NAryMatIterator()
: arrays(0), planes(0), ptrs(0), narrays(0), nplanes(0), size(0), iterdepth(0), idx(0)
{
@@ -3630,24 +3616,6 @@ SparseMat::SparseMat(const Mat& m)
}
}
SparseMat::SparseMat(const CvSparseMat* m)
: flags(MAGIC_VAL), hdr(0)
{
CV_Assert(m);
create( m->dims, &m->size[0], m->type );
CvSparseMatIterator it;
CvSparseNode* n = cvInitSparseMatIterator(m, &it);
size_t esz = elemSize();
for( ; n != 0; n = cvGetNextSparseNode(&it) )
{
const int* idx = CV_NODE_IDX(m, n);
uchar* to = newNode(idx, hash(idx));
copyElem((const uchar*)CV_NODE_VAL(m, n), to, esz);
}
}
void SparseMat::create(int d, const int* _sizes, int _type)
{
int i;
@@ -3795,24 +3763,6 @@ void SparseMat::clear()
hdr->clear();
}
SparseMat::operator CvSparseMat*() const
{
if( !hdr )
return 0;
CvSparseMat* m = cvCreateSparseMat(hdr->dims, hdr->size, type());
SparseMatConstIterator from = begin();
size_t i, N = nzcount(), esz = elemSize();
for( i = 0; i < N; i++, ++from )
{
const Node* n = from.node();
uchar* to = cvPtrND(m, n->idx, 0, -2, 0);
copyElem(from.ptr, to, esz);
}
return m;
}
uchar* SparseMat::ptr(int i0, bool createMissing, size_t* hashval)
{
CV_Assert( hdr && hdr->dims == 1 );
@@ -4266,4 +4216,58 @@ Rect RotatedRect::boundingRect() const
}
// glue
CvMatND::CvMatND(const cv::Mat& m)
{
cvInitMatNDHeader(this, m.dims, m.size, m.type(), m.data );
int i, d = m.dims;
for( i = 0; i < d; i++ )
dim[i].step = (int)m.step[i];
type |= m.flags & cv::Mat::CONTINUOUS_FLAG;
}
_IplImage::_IplImage(const cv::Mat& m)
{
CV_Assert( m.dims <= 2 );
cvInitImageHeader(this, m.size(), cvIplDepth(m.flags), m.channels());
cvSetData(this, m.data, (int)m.step[0]);
}
CvSparseMat* cvCreateSparseMat(const cv::SparseMat& sm)
{
if( !sm.hdr )
return 0;
CvSparseMat* m = cvCreateSparseMat(sm.hdr->dims, sm.hdr->size, sm.type());
cv::SparseMatConstIterator from = sm.begin();
size_t i, N = sm.nzcount(), esz = sm.elemSize();
for( i = 0; i < N; i++, ++from )
{
const cv::SparseMat::Node* n = from.node();
uchar* to = cvPtrND(m, n->idx, 0, -2, 0);
cv::copyElem(from.ptr, to, esz);
}
return m;
}
void CvSparseMat::copyToSparseMat(cv::SparseMat& m) const
{
m.create( dims, &size[0], type );
CvSparseMatIterator it;
CvSparseNode* n = cvInitSparseMatIterator(this, &it);
size_t esz = m.elemSize();
for( ; n != 0; n = cvGetNextSparseNode(&it) )
{
const int* idx = CV_NODE_IDX(this, n);
uchar* to = m.newNode(idx, m.hash(idx));
cv::copyElem((const uchar*)CV_NODE_VAL(this, n), to, esz);
}
}
/* End of file. */

8
modules/core/src/persistence.cpp
View File

@@ -5470,7 +5470,7 @@ void write( FileStorage& fs, const String& name, const Mat& value )
// TODO: the 4 functions below need to be implemented more efficiently
void write( FileStorage& fs, const String& name, const SparseMat& value )
{
Ptr<CvSparseMat> mat = (CvSparseMat*)value;
Ptr<CvSparseMat> mat = cvCreateSparseMat(value);
cvWrite( *fs, name.size() ? name.c_str() : 0, mat );
}
@@ -5495,12 +5495,12 @@ void read( const FileNode& node, Mat& mat, const Mat& default_mat )
void* obj = cvRead((CvFileStorage*)node.fs, (CvFileNode*)*node);
if(CV_IS_MAT_HDR_Z(obj))
{
Mat((const CvMat*)obj).copyTo(mat);
cvarrToMat(obj).copyTo(mat);
cvReleaseMat((CvMat**)&obj);
}
else if(CV_IS_MATND_HDR(obj))
{
Mat((const CvMatND*)obj).copyTo(mat);
cvarrToMat(obj).copyTo(mat);
cvReleaseMatND((CvMatND**)&obj);
}
else
@@ -5519,7 +5519,7 @@ void read( const FileNode& node, SparseMat& mat, const SparseMat& default_mat )
}
Ptr<CvSparseMat> m = (CvSparseMat*)cvRead((CvFileStorage*)node.fs, (CvFileNode*)*node);
CV_Assert(CV_IS_SPARSE_MAT(m.obj));
SparseMat(m).copyTo(mat);
m->copyToSparseMat(mat);
}
void write(FileStorage& fs, const String& objname, const std::vector<KeyPoint>& keypoints)

26
modules/core/test/test_arithm.cpp
View File

@@ -35,7 +35,7 @@ struct BaseElemWiseOp
virtual int getRandomType(RNG& rng)
{
return cvtest::randomType(rng, DEPTH_MASK_ALL_BUT_8S, 1,
return cvtest::randomType(rng, _OutputArray::DEPTH_MASK_ALL_BUT_8S, 1,
ninputs > 1 ? ARITHM_MAX_CHANNELS : 4);
}
@@ -425,7 +425,7 @@ struct CmpOp : public BaseElemWiseOp
}
int getRandomType(RNG& rng)
{
return cvtest::randomType(rng, DEPTH_MASK_ALL_BUT_8S, 1, 1);
return cvtest::randomType(rng, _OutputArray::DEPTH_MASK_ALL_BUT_8S, 1, 1);
}
double getMaxErr(int)
@@ -455,7 +455,7 @@ struct CmpSOp : public BaseElemWiseOp
}
int getRandomType(RNG& rng)
{
return cvtest::randomType(rng, DEPTH_MASK_ALL_BUT_8S, 1, 1);
return cvtest::randomType(rng, _OutputArray::DEPTH_MASK_ALL_BUT_8S, 1, 1);
}
double getMaxErr(int)
{
@@ -478,7 +478,7 @@ struct CopyOp : public BaseElemWiseOp
}
int getRandomType(RNG& rng)
{
return cvtest::randomType(rng, DEPTH_MASK_ALL, 1, ARITHM_MAX_CHANNELS);
return cvtest::randomType(rng, _OutputArray::DEPTH_MASK_ALL, 1, ARITHM_MAX_CHANNELS);
}
double getMaxErr(int)
{
@@ -501,7 +501,7 @@ struct SetOp : public BaseElemWiseOp
}
int getRandomType(RNG& rng)
{
return cvtest::randomType(rng, DEPTH_MASK_ALL, 1, ARITHM_MAX_CHANNELS);
return cvtest::randomType(rng, _OutputArray::DEPTH_MASK_ALL, 1, ARITHM_MAX_CHANNELS);
}
double getMaxErr(int)
{
@@ -718,8 +718,8 @@ struct ConvertScaleOp : public BaseElemWiseOp
}
int getRandomType(RNG& rng)
{
int srctype = cvtest::randomType(rng, DEPTH_MASK_ALL, 1, ARITHM_MAX_CHANNELS);
ddepth = cvtest::randomType(rng, DEPTH_MASK_ALL, 1, 1);
int srctype = cvtest::randomType(rng, _OutputArray::DEPTH_MASK_ALL, 1, ARITHM_MAX_CHANNELS);
ddepth = cvtest::randomType(rng, _OutputArray::DEPTH_MASK_ALL, 1, 1);
return srctype;
}
double getMaxErr(int)
@@ -957,7 +957,7 @@ struct ExpOp : public BaseElemWiseOp
ExpOp() : BaseElemWiseOp(1, FIX_ALPHA+FIX_BETA+FIX_GAMMA, 1, 1, Scalar::all(0)) {};
int getRandomType(RNG& rng)
{
return cvtest::randomType(rng, DEPTH_MASK_FLT, 1, ARITHM_MAX_CHANNELS);
return cvtest::randomType(rng, _OutputArray::DEPTH_MASK_FLT, 1, ARITHM_MAX_CHANNELS);
}
void getValueRange(int depth, double& minval, double& maxval)
{
@@ -984,7 +984,7 @@ struct LogOp : public BaseElemWiseOp
LogOp() : BaseElemWiseOp(1, FIX_ALPHA+FIX_BETA+FIX_GAMMA, 1, 1, Scalar::all(0)) {};
int getRandomType(RNG& rng)
{
return cvtest::randomType(rng, DEPTH_MASK_FLT, 1, ARITHM_MAX_CHANNELS);
return cvtest::randomType(rng, _OutputArray::DEPTH_MASK_FLT, 1, ARITHM_MAX_CHANNELS);
}
void getValueRange(int depth, double& minval, double& maxval)
{
@@ -1070,7 +1070,7 @@ struct CartToPolarToCartOp : public BaseElemWiseOp
}
int getRandomType(RNG& rng)
{
return cvtest::randomType(rng, DEPTH_MASK_FLT, 1, 1);
return cvtest::randomType(rng, _OutputArray::DEPTH_MASK_FLT, 1, 1);
}
void op(const vector<Mat>& src, Mat& dst, const Mat&)
{
@@ -1157,7 +1157,7 @@ struct CountNonZeroOp : public BaseElemWiseOp
{}
int getRandomType(RNG& rng)
{
return cvtest::randomType(rng, DEPTH_MASK_ALL, 1, 1);
return cvtest::randomType(rng, _OutputArray::DEPTH_MASK_ALL, 1, 1);
}
void op(const vector<Mat>& src, Mat& dst, const Mat& mask)
{
@@ -1237,7 +1237,7 @@ struct NormOp : public BaseElemWiseOp
};
int getRandomType(RNG& rng)
{
int type = cvtest::randomType(rng, DEPTH_MASK_ALL_BUT_8S, 1, 4);
int type = cvtest::randomType(rng, _OutputArray::DEPTH_MASK_ALL_BUT_8S, 1, 4);
for(;;)
{
normType = rng.uniform(1, 8);
@@ -1283,7 +1283,7 @@ struct MinMaxLocOp : public BaseElemWiseOp
};
int getRandomType(RNG& rng)
{
return cvtest::randomType(rng, DEPTH_MASK_ALL_BUT_8S, 1, 1);
return cvtest::randomType(rng, _OutputArray::DEPTH_MASK_ALL_BUT_8S, 1, 1);
}
void saveOutput(const vector<int>& minidx, const vector<int>& maxidx,
double minval, double maxval, Mat& dst)

10
modules/core/test/test_io.cpp
View File

@@ -211,7 +211,7 @@ protected:
vector<int> pt;
if( !m || !CV_IS_MAT(m) || m->rows != test_mat.rows || m->cols != test_mat.cols ||
cvtest::cmpEps( Mat(&stub1), Mat(&_test_stub1), &max_diff, 0, &pt, true) < 0 )
cvtest::cmpEps( cv::cvarrToMat(&stub1), cv::cvarrToMat(&_test_stub1), &max_diff, 0, &pt, true) < 0 )
{
ts->printf( cvtest::TS::LOG, "the read matrix is not correct: (%.20g vs %.20g) at (%d,%d)\n",
cvGetReal2D(&stub1, pt[0], pt[1]), cvGetReal2D(&_test_stub1, pt[0], pt[1]),
@@ -241,7 +241,7 @@ protected:
if( !CV_ARE_TYPES_EQ(&stub, &_test_stub) ||
!CV_ARE_SIZES_EQ(&stub, &_test_stub) ||
//cvNorm(&stub, &_test_stub, CV_L2) != 0 )
cvtest::cmpEps( Mat(&stub1), Mat(&_test_stub1), &max_diff, 0, &pt, true) < 0 )
cvtest::cmpEps( cv::cvarrToMat(&stub1), cv::cvarrToMat(&_test_stub1), &max_diff, 0, &pt, true) < 0 )
{
ts->printf( cvtest::TS::LOG, "readObj method: the read nd matrix is not correct: (%.20g vs %.20g) vs at (%d,%d)\n",
cvGetReal2D(&stub1, pt[0], pt[1]), cvGetReal2D(&_test_stub1, pt[0], pt[1]),
@@ -259,7 +259,7 @@ protected:
if( !CV_ARE_TYPES_EQ(&stub, &_test_stub) ||
!CV_ARE_SIZES_EQ(&stub, &_test_stub) ||
//cvNorm(&stub, &_test_stub, CV_L2) != 0 )
cvtest::cmpEps( Mat(&stub1), Mat(&_test_stub1), &max_diff, 0, &pt, true) < 0 )
cvtest::cmpEps( cv::cvarrToMat(&stub1), cv::cvarrToMat(&_test_stub1), &max_diff, 0, &pt, true) < 0 )
{
ts->printf( cvtest::TS::LOG, "C++ method: the read nd matrix is not correct: (%.20g vs %.20g) vs at (%d,%d)\n",
cvGetReal2D(&stub1, pt[0], pt[1]), cvGetReal2D(&_test_stub1, pt[1], pt[0]),
@@ -271,11 +271,11 @@ protected:
cvRelease((void**)&m_nd);
Ptr<CvSparseMat> m_s = (CvSparseMat*)fs["test_sparse_mat"].readObj();
Ptr<CvSparseMat> _test_sparse_ = (CvSparseMat*)test_sparse_mat;
Ptr<CvSparseMat> _test_sparse_ = cvCreateSparseMat(test_sparse_mat);
Ptr<CvSparseMat> _test_sparse = (CvSparseMat*)cvClone(_test_sparse_);
SparseMat m_s2;
fs["test_sparse_mat"] >> m_s2;
Ptr<CvSparseMat> _m_s2 = (CvSparseMat*)m_s2;
Ptr<CvSparseMat> _m_s2 = cvCreateSparseMat(m_s2);
if( !m_s || !CV_IS_SPARSE_MAT(m_s) ||
!cvTsCheckSparse(m_s, _test_sparse,0) ||

2
modules/core/test/test_mat.cpp
View File

@@ -734,7 +734,7 @@ void Core_ArrayOpTest::run( int /* start_from */)
}
}
Ptr<CvSparseMat> M2 = (CvSparseMat*)M;
Ptr<CvSparseMat> M2 = cvCreateSparseMat(M);
MatND Md;
M.copyTo(Md);
SparseMat M3; SparseMat(Md).convertTo(M3, Md.type(), 2);

4
modules/core/test/test_math.cpp
View File

@@ -2292,9 +2292,9 @@ void Core_SolvePolyTest::run( int )
cvFlip(&amat, &amat, 0);
int nr2;
if( cubic_case == 0 )
nr2 = cv::solveCubic(cv::Mat(&amat),umat2);
nr2 = cv::solveCubic(cv::cvarrToMat(&amat),umat2);
else
nr2 = cv::solveCubic(cv::Mat_<float>(cv::Mat(&amat)), umat2);
nr2 = cv::solveCubic(cv::Mat_<float>(cv::cvarrToMat(&amat)), umat2);
cvFlip(&amat, &amat, 0);
if(nr2 > 0)
std::sort(ar2.begin(), ar2.begin()+nr2, pred_double());