Chiebot-Mirror
/
opencv
mirror of https://github.com/opencv/opencv.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

Move cv::Mat out of core.hpp

Browse Source
pull/747/head
Andrey Kamaev 12 years ago
parent 135c0b6cb5
commit 715fa3303e
46 changed files with 1829 additions and 1706 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 8
      modules/calib3d/test/test_posit.cpp
  2. 4
      modules/calib3d/test/test_undistort.cpp
  3. 54
      modules/calib3d/test/test_undistort_badarg.cpp
  4. 13
      modules/contrib/src/ba.cpp
  5. 1364
      modules/core/include/opencv2/core.hpp
  6. 9
      modules/core/include/opencv2/core/base.hpp
  7. 1428
      modules/core/include/opencv2/core/mat.hpp
  8. 29
      modules/core/include/opencv2/core/mat.inl.hpp
  9. 37
      modules/core/include/opencv2/core/types_c.h
  10. 3
      modules/core/src/array.cpp
  11. 6
      modules/core/src/gpumat.cpp
  12. 1
      modules/core/src/lapack.cpp
  13. 8
      modules/core/src/mathfuncs.cpp
  14. 288
      modules/core/src/matrix.cpp
  15. 8
      modules/core/src/persistence.cpp
  16. 26
      modules/core/test/test_arithm.cpp
  17. 10
      modules/core/test/test_io.cpp
  18. 2
      modules/core/test/test_mat.cpp
  19. 4
      modules/core/test/test_math.cpp
  20. 4
      modules/gpu/perf/perf_video.cpp
  21. 4
      modules/highgui/src/cap.cpp
  22. 2
      modules/highgui/src/window_QT.cpp
  23. 4
      modules/highgui/test/test_video_io.cpp
  24. 13
      modules/imgproc/src/histogram.cpp
  25. 13
      modules/imgproc/test/test_histograms.cpp
  26. 2
      modules/legacy/src/calonder.cpp
  27. 8
      modules/legacy/src/em.cpp
  28. 108
      modules/legacy/src/levmarprojbandle.cpp
  29. 2
      modules/legacy/src/oneway.cpp
  30. 24
      modules/legacy/src/trifocal.cpp
  31. 4
      modules/ml/src/boost.cpp
  32. 2
      modules/ml/src/rtrees.cpp
  33. 2
      modules/ml/src/tree.cpp
  34. 2
      modules/ml/test/test_emknearestkmeans.cpp
  35. 2
      modules/objdetect/src/datamatrix.cpp
  36. 6
      modules/objdetect/src/haar.cpp
  37. 2
      modules/python/src2/cv2.cv.hpp
  38. 2
      modules/ts/src/ts_func.cpp
  39. 3
      samples/c/facedetect.cpp
  40. 3
      samples/c/smiledetect.cpp
  41. 5
      samples/c/tree_engine.cpp
  42. 4
      samples/cpp/Qt_sample/main.cpp
  43. 3
      samples/cpp/image.cpp
  44. 3
      samples/cpp/tutorial_code/core/interoperability_with_OpenCV_1/interoperability_with_OpenCV_1.cpp
  45. 3
      samples/cpp/tutorial_code/objectDetection/objectDetection.cpp
  46. 3
      samples/cpp/tutorial_code/objectDetection/objectDetection2.cpp

8
modules/calib3d/test/test_posit.cpp
Unescape View File

@ -189,13 +189,13 @@ void CV_POSITTest::run( int start_from )
rotation->data.fl, translation->data.fl );
cvReleasePOSITObject( &object );
//Mat _rotation = cvarrToMat(rotation), _true_rotation = cvarrToMat(true_rotation);
//Mat _translation = cvarrToMat(translation), _true_translation = cvarrToMat(true_translation);
code = cvtest::cmpEps2( ts, rotation, true_rotation, flEpsilon, false, "rotation matrix" );
Mat _rotation = cvarrToMat(rotation), _true_rotation = cvarrToMat(true_rotation);
Mat _translation = cvarrToMat(translation), _true_translation = cvarrToMat(true_translation);
code = cvtest::cmpEps2( ts, _rotation, _true_rotation, flEpsilon, false, "rotation matrix" );
if( code < 0 )
break;
code = cvtest::cmpEps2( ts, translation, true_translation, flEpsilon, false, "translation vector" );
code = cvtest::cmpEps2( ts, _translation, _true_translation, flEpsilon, false, "translation vector" );
if( code < 0 )
break;
}

4
modules/calib3d/test/test_undistort.cpp
Unescape View File

@ -855,8 +855,8 @@ void CV_InitUndistortRectifyMapTest::prepare_to_validation(int/* test_case_idx*/
//Applying precalculated undistort rectify map
if (!useCPlus)
{
mapx = cv::Mat(_mapx);
mapy = cv::Mat(_mapy);
mapx = cv::cvarrToMat(_mapx);
mapy = cv::cvarrToMat(_mapy);
}
cv::Mat map1,map2;
cv::convertMaps(mapx,mapy,map1,map2,CV_32FC1);

54
modules/calib3d/test/test_undistort_badarg.cpp
Unescape View File

@ -243,27 +243,27 @@ void CV_UndistortPointsBadArgTest::run(int)
//C++ tests
useCPlus = true;
camera_mat = cv::Mat(&_camera_mat_orig);
distortion_coeffs = cv::Mat(&_distortion_coeffs_orig);
P = cv::Mat(&_P_orig);
R = cv::Mat(&_R_orig);
src_points = cv::Mat(&_src_points_orig);
camera_mat = cv::cvarrToMat(&_camera_mat_orig);
distortion_coeffs = cv::cvarrToMat(&_distortion_coeffs_orig);
P = cv::cvarrToMat(&_P_orig);
R = cv::cvarrToMat(&_R_orig);
src_points = cv::cvarrToMat(&_src_points_orig);
temp = cvCreateMat(2,2,CV_32FC2);
src_points = cv::Mat(temp);
src_points = cv::cvarrToMat(temp);
errcount += run_test_case( CV_StsAssert, "Invalid input data matrix size" );
src_points = cv::Mat(&_src_points_orig);
src_points = cv::cvarrToMat(&_src_points_orig);
cvReleaseMat(&temp);
temp = cvCreateMat(1,4,CV_64FC2);
src_points = cv::Mat(temp);
src_points = cv::cvarrToMat(temp);
errcount += run_test_case( CV_StsAssert, "Invalid input data matrix type" );
src_points = cv::Mat(&_src_points_orig);
src_points = cv::cvarrToMat(&_src_points_orig);
cvReleaseMat(&temp);
src_points = cv::Mat();
errcount += run_test_case( CV_StsAssert, "Input data matrix is not continuous" );
src_points = cv::Mat(&_src_points_orig);
src_points = cv::cvarrToMat(&_src_points_orig);
cvReleaseMat(&temp);
@ -360,12 +360,12 @@ void CV_InitUndistortRectifyMapBadArgTest::run(int)
//C++ tests
useCPlus = true;
camera_mat = cv::Mat(&_camera_mat_orig);
distortion_coeffs = cv::Mat(&_distortion_coeffs_orig);
new_camera_mat = cv::Mat(&_new_camera_mat_orig);
R = cv::Mat(&_R_orig);
mapx = cv::Mat(&_mapx_orig);
mapy = cv::Mat(&_mapy_orig);
camera_mat = cv::cvarrToMat(&_camera_mat_orig);
distortion_coeffs = cv::cvarrToMat(&_distortion_coeffs_orig);
new_camera_mat = cv::cvarrToMat(&_new_camera_mat_orig);
R = cv::cvarrToMat(&_R_orig);
mapx = cv::cvarrToMat(&_mapx_orig);
mapy = cv::cvarrToMat(&_mapy_orig);
mat_type = CV_64F;
@ -373,21 +373,21 @@ void CV_InitUndistortRectifyMapBadArgTest::run(int)
mat_type = mat_type_orig;
temp = cvCreateMat(3,2,CV_32FC1);
camera_mat = cv::Mat(temp);
camera_mat = cv::cvarrToMat(temp);
errcount += run_test_case( CV_StsAssert, "Invalid camera data matrix size" );
camera_mat = cv::Mat(&_camera_mat_orig);
camera_mat = cv::cvarrToMat(&_camera_mat_orig);
cvReleaseMat(&temp);
temp = cvCreateMat(4,3,CV_32FC1);
R = cv::Mat(temp);
R = cv::cvarrToMat(temp);
errcount += run_test_case( CV_StsAssert, "Invalid R data matrix size" );
R = cv::Mat(&_R_orig);
R = cv::cvarrToMat(&_R_orig);
cvReleaseMat(&temp);
temp = cvCreateMat(6,1,CV_32FC1);
distortion_coeffs = cv::Mat(temp);
distortion_coeffs = cv::cvarrToMat(temp);
errcount += run_test_case( CV_StsAssert, "Invalid distortion coefficients data matrix size" );
distortion_coeffs = cv::Mat(&_distortion_coeffs_orig);
distortion_coeffs = cv::cvarrToMat(&_distortion_coeffs_orig);
cvReleaseMat(&temp);
//------------
@ -499,11 +499,11 @@ void CV_UndistortBadArgTest::run(int)
//C++ tests
useCPlus = true;
camera_mat = cv::Mat(&_camera_mat_orig);
distortion_coeffs = cv::Mat(&_distortion_coeffs_orig);
new_camera_mat = cv::Mat(&_new_camera_mat_orig);
src = cv::Mat(&_src_orig);
dst = cv::Mat(&_dst_orig);
camera_mat = cv::cvarrToMat(&_camera_mat_orig);
distortion_coeffs = cv::cvarrToMat(&_distortion_coeffs_orig);
new_camera_mat = cv::cvarrToMat(&_new_camera_mat_orig);
src = cv::cvarrToMat(&_src_orig);
dst = cv::cvarrToMat(&_dst_orig);
//------------
delete[] arr_src;

13
modules/contrib/src/ba.cpp
Unescape View File

@ -359,7 +359,7 @@ void LevMarqSparse::ask_for_proj(CvMat &/*_vis*/,bool once) {
cvGetSubRect( P, &cam_mat, cvRect( 0, j * num_cam_param, 1, num_cam_param ));
CvMat measur_mat;
cvGetSubRect( hX, &measur_mat, cvRect( 0, ind * num_err_param, 1, num_err_param ));
Mat _point_mat(&point_mat), _cam_mat(&cam_mat), _measur_mat(&measur_mat);
Mat _point_mat = cv::cvarrToMat(&point_mat), _cam_mat = cv::cvarrToMat(&cam_mat), _measur_mat = cv::cvarrToMat(&measur_mat);
func( i, j, _point_mat, _cam_mat, _measur_mat, data);
assert( ind*num_err_param == ((int*)(Vis_index->data.ptr + i * Vis_index->step))[j]);
ind+=1;
@ -398,7 +398,7 @@ void LevMarqSparse::ask_for_projac(CvMat &/*_vis*/) //should be evaluated at p
//CvMat* Bij = B_line[j];
//CvMat* Bij = ((CvMat**)(B->data.ptr + B->step * i))[j];
Mat _point_mat(&point_mat), _cam_mat(&cam_mat), _Aij(Aij), _Bij(Bij);
Mat _point_mat = cv::cvarrToMat(&point_mat), _cam_mat = cv::cvarrToMat(&cam_mat), _Aij = cv::cvarrToMat(Aij), _Bij = cv::cvarrToMat(Bij);
(*fjac)(i, j, _point_mat, _cam_mat, _Aij, _Bij, data);
}
}
@ -1100,16 +1100,17 @@ void LevMarqSparse::bundleAdjust( std::vector<Point3d>& points, //positions of p
}
//fill camera params
//R.clear();T.clear();cameraMatrix.clear();
Mat levmarP = cv::cvarrToMat(levmar.P);
for( int i = 0; i < num_cameras; i++ ) {
//rotation
Mat rot_vec = Mat(levmar.P).rowRange(i*num_cam_param, i*num_cam_param+3);
Mat rot_vec = levmarP.rowRange(i*num_cam_param, i*num_cam_param+3);
Rodrigues( rot_vec, R[i] );
//translation
T[i] = Mat(levmar.P).rowRange(i*num_cam_param + 3, i*num_cam_param+6);
T[i] = levmarP.rowRange(i*num_cam_param + 3, i*num_cam_param+6);
//intrinsic camera matrix
double* intr_data = (double*)cameraMatrix[i].data;
double* intr = (double*)(Mat(levmar.P).data + Mat(levmar.P).step * (i*num_cam_param+6));
double* intr = (double*)(levmarP.data +levmarP.step * (i*num_cam_param+6));
//focals
intr_data[0] = intr[0]; //fx
intr_data[4] = intr[1]; //fy
@ -1119,7 +1120,7 @@ void LevMarqSparse::bundleAdjust( std::vector<Point3d>& points, //positions of p
//add distortion if exists
if( distCoeffs.size() ) {
Mat(levmar.P).rowRange(i*num_cam_param + 10, i*num_cam_param+10+numdist).copyTo(distCoeffs[i]);
levmarP.rowRange(i*num_cam_param + 10, i*num_cam_param+10+numdist).copyTo(distCoeffs[i]);
}
}
}

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
Unescape 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
View File

File diff suppressed because it is too large Load Diff

29
modules/core/include/opencv2/core/mat.inl.hpp
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
}

288
modules/core/src/matrix.cpp
Unescape 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,145 +389,141 @@ 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 Mat::diag(int d) const
{
CV_Assert( dims <= 2 );
Mat m = *this;
size_t esz = elemSize();
int len;
if( d >= 0 )
{
len = std::min(cols - d, rows);
m.data += esz*d;
}
else
{
len = std::min(rows + d, cols);
m.data -= step[0]*d;
Mat temp(thiz);
thiz.release();
temp.copyTo(thiz);
}
CV_DbgAssert( len > 0 );
m.size[0] = m.rows = len;
m.size[1] = m.cols = 1;
m.step[0] += (len > 1 ? esz : 0);
if( m.rows > 1 )
m.flags &= ~CONTINUOUS_FLAG;
else
m.flags |= CONTINUOUS_FLAG;
if( size() != Size(1,1) )
m.flags |= SUBMATRIX_FLAG;
return m;
return thiz;
}
Mat::Mat(const CvMat* m, bool copyData) : size(&rows)
static Mat cvMatToMat(const CvMat* m, bool copyData)
{
initEmpty();
Mat thiz;
if( !m )
return;
return thiz;
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;
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;
datalimit = datastart + _step*rows;
dataend = datalimit - _step + minstep;
step[0] = _step; step[1] = esz;
thiz.datalimit = thiz.datastart + _step*thiz.rows;
thiz.dataend = thiz.datalimit - _step + minstep;
thiz.step[0] = _step; thiz.step[1] = esz;
}
else
{
data = datastart = dataend = 0;
Mat(m->rows, m->cols, m->type, m->data.ptr, m->step).copyTo(*this);
thiz.data = thiz.datastart = thiz.dataend = 0;
Mat(m->rows, m->cols, m->type, m->data.ptr, m->step).copyTo(thiz);
}
return thiz;
}
Mat::Mat(const IplImage* img, bool copyData) : size(&rows)
static Mat iplImageToMat(const IplImage* img, bool copyData)
{
initEmpty();
Mat m;
if( !img )
return;
return m;
dims = 2;
m.dims = 2;
CV_DbgAssert(CV_IS_IMAGE(img) && img->imageData != 0);
int imgdepth = IPL2CV_DEPTH(img->depth);
size_t esz;
step[0] = img->widthStep;
m.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);
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;
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;
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 m = *this;
release();
Mat m2 = m;
m.release();
if( !img->roi || !img->roi->coi ||
img->dataOrder == IPL_DATA_ORDER_PLANE)
m.copyTo(*this);
m2.copyTo(m);
else
{
int ch[] = {img->roi->coi - 1, 0};
create(m.rows, m.cols, m.type());
mixChannels(&m, 1, this, 1, ch, 1);
m.create(m2.rows, m2.cols, m2.type());
mixChannels(&m2, 1, &m, 1, ch, 1);
}
}
}
return m;
}
Mat::operator IplImage() const
Mat Mat::diag(int d) const
{
CV_Assert( dims <= 2 );
IplImage img;
cvInitImageHeader(&img, size(), cvIplDepth(flags), channels());
cvSetData(&img, data, (int)step[0]);
return img;
}
Mat m = *this;
size_t esz = elemSize();
int len;
if( d >= 0 )
{
len = std::min(cols - d, rows);
m.data += esz*d;
}
else
{
len = std::min(rows + d, cols);
m.data -= step[0]*d;
}
CV_DbgAssert( len > 0 );
m.size[0] = m.rows = len;
m.size[1] = m.cols = 1;
m.step[0] += (len > 1 ? esz : 0);
if( m.rows > 1 )
m.flags &= ~CONTINUOUS_FLAG;
else
m.flags |= CONTINUOUS_FLAG;
if( size() != Size(1,1) )
m.flags |= SUBMATRIX_FLAG;
return m;
}
void Mat::pop_back(size_t nelems)
{
@ -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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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());

4
modules/gpu/perf/perf_video.cpp
Unescape View File

@ -596,8 +596,8 @@ PERF_TEST_P(Video, Video_FGDStatModel,
stopTimer();
}
const cv::Mat background = model->background;
const cv::Mat foreground = model->foreground;
const cv::Mat background = cv::cvarrToMat(model->background);
const cv::Mat foreground = cv::cvarrToMat(model->foreground);
CPU_SANITY_CHECK(background);
CPU_SANITY_CHECK(foreground);

4
modules/highgui/src/cap.cpp
Unescape View File

@ -495,10 +495,10 @@ bool VideoCapture::retrieve(Mat& image, int channel)
return false;
}
if(_img->origin == IPL_ORIGIN_TL)
image = Mat(_img);
image = cv::cvarrToMat(_img);
else
{
Mat temp(_img);
Mat temp = cv::cvarrToMat(_img);
flip(temp, image, 0);
}
return true;

2
modules/highgui/src/window_QT.cpp
Unescape View File

@ -948,7 +948,7 @@ void GuiReceiver::showImage(QString name, void* arr)
mat = cvGetMat(arr, &stub);
cv::Mat im(mat);
cv::Mat im = cv::cvarrToMat(mat);
cv::imshow(name.toUtf8().data(), im);
}
else

4
modules/highgui/test/test_video_io.cpp
Unescape View File

@ -247,7 +247,7 @@ void CV_HighGuiTest::VideoTest(const string& dir, const cvtest::VideoFormat& fmt
if (!img)
break;
frames.push_back(Mat(img).clone());
frames.push_back(cv::cvarrToMat(img, true));
if (writer == 0)
{
@ -285,7 +285,7 @@ void CV_HighGuiTest::VideoTest(const string& dir, const cvtest::VideoFormat& fmt
break;
Mat img = frames[i];
Mat img1(ipl1);
Mat img1 = cv::cvarrToMat(ipl1);
double psnr = PSNR(img1, img);
if (psnr < thresDbell)

13
modules/imgproc/src/histogram.cpp
Unescape View File

@ -2456,7 +2456,8 @@ cvCompareHist( const CvHistogram* hist1,
if( !CV_IS_SPARSE_MAT(hist1->bins) )
{
cv::Mat H1((const CvMatND*)hist1->bins), H2((const CvMatND*)hist2->bins);
cv::Mat H1 = cv::cvarrToMat(hist1->bins);
cv::Mat H2 = cv::cvarrToMat(hist2->bins);
return cv::compareHist(H1, H2, method);
}
@ -2758,7 +2759,7 @@ cvCalcArrHist( CvArr** img, CvHistogram* hist, int accumulate, const CvArr* mask
if( !CV_IS_SPARSE_HIST(hist) )
{
cv::Mat H((const CvMatND*)hist->bins);
cv::Mat H = cv::cvarrToMat(hist->bins);
cv::calcHist( &images[0], (int)images.size(), 0, _mask,
H, cvGetDims(hist->bins), H.size, ranges, uniform, accumulate != 0 );
}
@ -2768,7 +2769,8 @@ cvCalcArrHist( CvArr** img, CvHistogram* hist, int accumulate, const CvArr* mask
if( !accumulate )
cvZero( hist->bins );
cv::SparseMat sH(sparsemat);
cv::SparseMat sH;
sparsemat->copyToSparseMat(sH);
cv::calcHist( &images[0], (int)images.size(), 0, _mask, sH, sH.dims(),
sH.dims() > 0 ? sH.hdr->size : 0, ranges, uniform, accumulate != 0, true );
@ -2820,13 +2822,14 @@ cvCalcArrBackProject( CvArr** img, CvArr* dst, const CvHistogram* hist )
if( !CV_IS_SPARSE_HIST(hist) )
{
cv::Mat H((const CvMatND*)hist->bins);
cv::Mat H = cv::cvarrToMat(hist->bins);
cv::calcBackProject( &images[0], (int)images.size(),
0, H, _dst, ranges, 1, uniform );
}
else
{
cv::SparseMat sH((const CvSparseMat*)hist->bins);
cv::SparseMat sH;
((const CvSparseMat*)hist->bins)->copyToSparseMat(sH);
cv::calcBackProject( &images[0], (int)images.size(),
0, sH, _dst, ranges, 1, uniform );
}

13
modules/imgproc/test/test_histograms.cpp
Unescape View File

@ -630,7 +630,8 @@ void CV_MinMaxHistTest::run_func(void)
{
if( hist_type != CV_HIST_ARRAY && test_cpp )
{
cv::SparseMat h((CvSparseMat*)hist[0]->bins);
cv::SparseMat h;
((CvSparseMat*)hist[0]->bins)->copyToSparseMat(h);
double _min_val = 0, _max_val = 0;
cv::minMaxLoc(h, &_min_val, &_max_val, min_idx, max_idx );
min_val = (float)_min_val;
@ -727,10 +728,11 @@ void CV_NormHistTest::run_func(void)
{
if( hist_type != CV_HIST_ARRAY && test_cpp )
{
cv::SparseMat h((CvSparseMat*)hist[0]->bins);
cv::SparseMat h;
((CvSparseMat*)hist[0]->bins)->copyToSparseMat(h);
cv::normalize(h, h, factor, CV_L1);
cvReleaseSparseMat((CvSparseMat**)&hist[0]->bins);
hist[0]->bins = (CvSparseMat*)h;
hist[0]->bins = cvCreateSparseMat(h);
}
else
cvNormalizeHist( hist[0], factor );
@ -978,8 +980,9 @@ void CV_CompareHistTest::run_func(void)
int k;
if( hist_type != CV_HIST_ARRAY && test_cpp )
{
cv::SparseMat h0((CvSparseMat*)hist[0]->bins);
cv::SparseMat h1((CvSparseMat*)hist[1]->bins);
cv::SparseMat h0, h1;
((CvSparseMat*)hist[0]->bins)->copyToSparseMat(h0);
((CvSparseMat*)hist[1]->bins)->copyToSparseMat(h1);
for( k = 0; k < MAX_METHOD; k++ )
result[k] = cv::compareHist(h0, h1, k);
}

2
modules/legacy/src/calonder.cpp
Unescape View File

@ -334,7 +334,7 @@ void RandomizedTree::train(std::vector<BaseKeypoint> const& base_set,
Size patchSize(PATCH_SIZE, PATCH_SIZE);
for (keypt_it = base_set.begin(); keypt_it != base_set.end(); ++keypt_it, ++class_id) {
for (int i = 0; i < views; ++i) {
make_patch( Mat(keypt_it->image), Point(keypt_it->x, keypt_it->y ), patch, patchSize, rng );
make_patch( cv::cvarrToMat(keypt_it->image), Point(keypt_it->x, keypt_it->y ), patch, patchSize, rng );
IplImage iplPatch = patch;
addExample(class_id, getData(&iplPatch));
}

8
modules/legacy/src/em.cpp
Unescape View File

@ -139,15 +139,15 @@ void init_params(const CvEMParams& src,
Mat& prbs, Mat& weights,
Mat& means, std::vector<Mat>& covsHdrs)
{
prbs = src.probs;
weights = src.weights;
means = src.means;
prbs = cv::cvarrToMat(src.probs);
weights = cv::cvarrToMat(src.weights);
means = cv::cvarrToMat(src.means);
if(src.covs)
{
covsHdrs.resize(src.nclusters);
for(size_t i = 0; i < covsHdrs.size(); i++)
covsHdrs[i] = src.covs[i];
covsHdrs[i] = cv::cvarrToMat(src.covs[i]);
}
}

108
modules/legacy/src/levmarprojbandle.cpp
Unescape View File

@ -745,6 +745,7 @@ void icvReconstructPoints4DStatus(CvMat** projPoints, CvMat **projMatrs, CvMat**
double* matrW_dat = 0;
CV_FUNCNAME( "icvReconstructPoints4DStatus" );
__BEGIN__;
/* ----- Test input params for errors ----- */
@ -770,6 +771,7 @@ void icvReconstructPoints4DStatus(CvMat** projPoints, CvMat **projMatrs, CvMat**
CV_ERROR( CV_StsOutOfRange, "Points must have 4 cordinates" );
}
/* !!! Not tested all input parameters */
/* ----- End test ----- */
@ -778,75 +780,75 @@ void icvReconstructPoints4DStatus(CvMat** projPoints, CvMat **projMatrs, CvMat**
/* Allocate maximum data */
{
double matrV_dat[4*4];
CvMat matrV = cvMat(4,4,CV_64F,matrV_dat);
CvMat matrV;
double matrV_dat[4*4];
matrV = cvMat(4,4,CV_64F,matrV_dat);
CV_CALL(matrA_dat = (double*)cvAlloc(3*numImages * 4 * sizeof(double)));
CV_CALL(matrW_dat = (double*)cvAlloc(3*numImages * 4 * sizeof(double)));
CV_CALL(matrA_dat = (double*)cvAlloc(3*numImages * 4 * sizeof(double)));
CV_CALL(matrW_dat = (double*)cvAlloc(3*numImages * 4 * sizeof(double)));
/* reconstruct each point */
for( currPoint = 0; currPoint < numPoints; currPoint++ )
{
/* Reconstruct current point */
/* Define number of visible projections */
int numVisProj = 0;
for( currImage = 0; currImage < numImages; currImage++ )
/* reconstruct each point */
for( currPoint = 0; currPoint < numPoints; currPoint++ )
{
if( cvmGet(presPoints[currImage],0,currPoint) > 0 )
/* Reconstruct current point */
/* Define number of visible projections */
int numVisProj = 0;
for( currImage = 0; currImage < numImages; currImage++ )
{
numVisProj++;
if( cvmGet(presPoints[currImage],0,currPoint) > 0 )
{
numVisProj++;
}
}
}
if( numVisProj < 2 )
{
/* This point can't be reconstructed */
continue;
}
if( numVisProj < 2 )
{
/* This point can't be reconstructed */
continue;
}
/* Allocate memory and create matrices */
CvMat matrA;
matrA = cvMat(3*numVisProj,4,CV_64F,matrA_dat);
/* Allocate memory and create matrices */
CvMat matrA;
matrA = cvMat(3*numVisProj,4,CV_64F,matrA_dat);
CvMat matrW;
matrW = cvMat(3*numVisProj,4,CV_64F,matrW_dat);
CvMat matrW;
matrW = cvMat(3*numVisProj,4,CV_64F,matrW_dat);
int currVisProj = 0;
for( currImage = 0; currImage < numImages; currImage++ )/* For each view */
{
if( cvmGet(presPoints[currImage],0,currPoint) > 0 )
int currVisProj = 0;
for( currImage = 0; currImage < numImages; currImage++ )/* For each view */
{
double x,y;
x = cvmGet(projPoints[currImage],0,currPoint);
y = cvmGet(projPoints[currImage],1,currPoint);
for( int k = 0; k < 4; k++ )
if( cvmGet(presPoints[currImage],0,currPoint) > 0 )
{
matrA_dat[currVisProj*12 + k] =
x * cvmGet(projMatrs[currImage],2,k) - cvmGet(projMatrs[currImage],0,k);
double x,y;
x = cvmGet(projPoints[currImage],0,currPoint);
y = cvmGet(projPoints[currImage],1,currPoint);
for( int k = 0; k < 4; k++ )
{
matrA_dat[currVisProj*12 + k] =
x * cvmGet(projMatrs[currImage],2,k) - cvmGet(projMatrs[currImage],0,k);
matrA_dat[currVisProj*12+4 + k] =
y * cvmGet(projMatrs[currImage],2,k) - cvmGet(projMatrs[currImage],1,k);
matrA_dat[currVisProj*12+4 + k] =
y * cvmGet(projMatrs[currImage],2,k) - cvmGet(projMatrs[currImage],1,k);
matrA_dat[currVisProj*12+8 + k] =
x * cvmGet(projMatrs[currImage],1,k) - y * cvmGet(projMatrs[currImage],0,k);
matrA_dat[currVisProj*12+8 + k] =
x * cvmGet(projMatrs[currImage],1,k) - y * cvmGet(projMatrs[currImage],0,k);
}
currVisProj++;
}
currVisProj++;
}
}
/* Solve system for current point */
{
cvSVD(&matrA,&matrW,0,&matrV,CV_SVD_V_T);
/* Solve system for current point */
{
cvSVD(&matrA,&matrW,0,&matrV,CV_SVD_V_T);
/* Copy computed point */
cvmSet(points4D,0,currPoint,cvmGet(&matrV,3,0));//X
cvmSet(points4D,1,currPoint,cvmGet(&matrV,3,1));//Y
cvmSet(points4D,2,currPoint,cvmGet(&matrV,3,2));//Z
cvmSet(points4D,3,currPoint,cvmGet(&matrV,3,3));//W
}
/* Copy computed point */
cvmSet(points4D,0,currPoint,cvmGet(&matrV,3,0));//X
cvmSet(points4D,1,currPoint,cvmGet(&matrV,3,1));//Y
cvmSet(points4D,2,currPoint,cvmGet(&matrV,3,2));//Z
cvmSet(points4D,3,currPoint,cvmGet(&matrV,3,3));//W
}
}
}
{/* Compute projection error */
@ -913,7 +915,7 @@ static void icvProjPointsStatusFunc( int numImages, CvMat *points4D, CvMat **pro
{
CV_ERROR( CV_StsNullPtr, "Some of parameters is a NULL pointer" );
}
{
int numPoints;
numPoints = points4D->cols;
if( numPoints < 1 )
@ -994,7 +996,7 @@ static void icvProjPointsStatusFunc( int numImages, CvMat *points4D, CvMat **pro
}
}
}
}
__END__;
}

2
modules/legacy/src/oneway.cpp
Unescape View File

@ -1740,7 +1740,7 @@ namespace cv{
CV_Error(CV_StsNotImplemented, "OpenCV was built without SURF support");
surf_extractor->set("hessianThreshold", 1.0);
//printf("Extracting SURF features...");
surf_extractor->detect(Mat(img), features);
surf_extractor->detect(cv::cvarrToMat(img), features);
//printf("done\n");
for (int j = 0; j < (int)features.size(); j++)

24
modules/legacy/src/trifocal.cpp
Unescape View File

@ -223,7 +223,7 @@ int icvComputeProjectMatrices6Points( CvMat* points1,CvMat* points2,CvMat* point
CV_ERROR( CV_StsUnmatchedSizes, "Number of coordinates of points4D must be 4" );
}
#endif
{
/* Find transform matrix for each camera */
int i;
CvMat* points[3];
@ -400,7 +400,7 @@ int icvComputeProjectMatrices6Points( CvMat* points1,CvMat* points2,CvMat* point
#endif
}/* for all sollutions */
}
__END__;
return numSol;
}
@ -1362,7 +1362,7 @@ void icvFindBaseTransform(CvMat* points,CvMat* resultT)
/* Function gets four points and compute transformation to e1=(100) e2=(010) e3=(001) e4=(111) */
/* !!! test each three points not collinear. Need to test */
{
/* Create matrices */
CvMat matrA;
CvMat vectB;
@ -1410,7 +1410,7 @@ void icvFindBaseTransform(CvMat* points,CvMat* resultT)
cvInvert(&matrA,&tmpRes);
cvConvert(&tmpRes,resultT);
}
__END__;
return;
@ -1459,7 +1459,7 @@ void GetGeneratorReduceFundSolution(CvMat* points1,CvMat* points2,CvMat* fundRed
}
/* Using 3 corr. points compute reduce */
{
/* Create matrix */
CvMat matrA;
double matrA_dat[3*5];
@ -1507,7 +1507,7 @@ void GetGeneratorReduceFundSolution(CvMat* points1,CvMat* points2,CvMat* fundRed
cvmSet(fundReduceCoef1,0,i,cvmGet(&matrV,3,i));
cvmSet(fundReduceCoef2,0,i,cvmGet(&matrV,4,i));
}
}
__END__;
return;
@ -1551,7 +1551,7 @@ int GetGoodReduceFundamMatrFromTwo(CvMat* fundReduceCoef1,CvMat* fundReduceCoef2
{
CV_ERROR( CV_StsUnmatchedSizes, "Size of resFundReduceCoef must be 1x5" );
}
{
double p1,q1,r1,s1,t1;
double p2,q2,r2,s2,t2;
p1 = cvmGet(fundReduceCoef1,0,0);
@ -1599,7 +1599,7 @@ int GetGoodReduceFundamMatrFromTwo(CvMat* fundReduceCoef1,CvMat* fundReduceCoef2
numRoots++;
}
}
}
__END__;
return numRoots;
}
@ -1636,7 +1636,7 @@ void GetProjMatrFromReducedFundamental(CvMat* fundReduceCoefs,CvMat* projMatrCoe
/* Computes project matrix from given reduced matrix */
/* we have p,q,r,s,t and need get a,b,c,d */
/* Fill matrix to compute ratio a:b:c as A:B:C */
{
CvMat matrA;
double matrA_dat[3*3];
matrA = cvMat(3,3,CV_64F,matrA_dat);
@ -1752,7 +1752,7 @@ void GetProjMatrFromReducedFundamental(CvMat* fundReduceCoefs,CvMat* projMatrCoe
cvmSet(projMatrCoefs,0,3,d);
}
}
__END__;
return;
}
@ -2106,7 +2106,7 @@ void icvReconstructPointsFor3View( CvMat* projMatr1,CvMat* projMatr2,CvMat* proj
{
CV_ERROR( CV_StsUnmatchedSizes, "Size of projection matrices must be 3x4" );
}
{
CvMat matrA;
double matrA_dat[36];
matrA = cvMat(9,4,CV_64F,matrA_dat);
@ -2203,7 +2203,7 @@ void icvReconstructPointsFor3View( CvMat* projMatr1,CvMat* projMatr2,CvMat* proj
}
}
}*/
}
__END__;
return;
}

4
modules/ml/src/boost.cpp
Unescape View File

@ -1655,10 +1655,10 @@ CvBoost::predict( const CvMat* _sample, const CvMat* _missing,
const int* cmap = data->cat_map->data.i;
const int* cofs = data->cat_ofs->data.i;
cv::Mat sample = _sample;
cv::Mat sample = cv::cvarrToMat(_sample);
cv::Mat missing;
if(!_missing)
missing = _missing;
missing = cv::cvarrToMat(_missing);
// if need, preprocess the input vector
if( !raw_mode )

2
modules/ml/src/rtrees.cpp
Unescape View File

@ -861,7 +861,7 @@ float CvRTrees::predict_prob( const Mat& _sample, const Mat& _missing) const
Mat CvRTrees::getVarImportance()
{
return Mat(get_var_importance());
return cvarrToMat(get_var_importance());
}
// End of file.

2
modules/ml/src/tree.cpp
Unescape View File

@ -4142,7 +4142,7 @@ void CvDTree::read( CvFileStorage* fs, CvFileNode* node, CvDTreeTrainData* _data
Mat CvDTree::getVarImportance()
{
return Mat(get_var_importance());
return cvarrToMat(get_var_importance());
}
/* End of file. */

2
modules/ml/test/test_emknearestkmeans.cpp
Unescape View File

@ -597,7 +597,7 @@ protected:
ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_TEST_DATA);
}
Mat values = data.get_values();
Mat values = cv::cvarrToMat(data.get_values());
CV_Assert(values.cols == 58);
int responseIndex = 57;

2
modules/objdetect/src/datamatrix.cpp
Unescape View File

@ -528,7 +528,7 @@ void findDataMatrix(InputArray _image,
{
_dmtx.create(rc_i.original->rows, rc_i.original->cols, rc_i.original->type, i);
Mat dst = _dmtx.getMat(i);
Mat(rc_i.original).copyTo(dst);
cv::cvarrToMat(rc_i.original).copyTo(dst);
}
cvReleaseMat(&rc_i.original);
}

6
modules/objdetect/src/haar.cpp
Unescape View File

@ -1611,17 +1611,17 @@ cvHaarDetectObjectsForROC( const CvArr* _img,
if( use_ipp )
{
cv::Mat fsum(sum1.rows, sum1.cols, CV_32F, sum1.data.ptr, sum1.step);
cv::Mat(&sum1).convertTo(fsum, CV_32F, 1, -(1<<24));
cv::cvarrToMat(&sum1).convertTo(fsum, CV_32F, 1, -(1<<24));
}
else
#endif
cvSetImagesForHaarClassifierCascade( cascade, &sum1, &sqsum1, _tilted, 1. );
cv::Mat _norm1(&norm1), _mask1(&mask1);
cv::Mat _norm1 = cv::cvarrToMat(&norm1), _mask1 = cv::cvarrToMat(&mask1);
cv::parallel_for_(cv::Range(0, stripCount),
cv::HaarDetectObjects_ScaleImage_Invoker(cascade,
(((sz1.height + stripCount - 1)/stripCount + ystep-1)/ystep)*ystep,
factor, cv::Mat(&sum1), cv::Mat(&sqsum1), &_norm1, &_mask1,
factor, cv::cvarrToMat(&sum1), cv::cvarrToMat(&sqsum1), &_norm1, &_mask1,
cv::Rect(equRect), allCandidates, rejectLevels, levelWeights, outputRejectLevels, &mtx));
}
}

2
modules/python/src2/cv2.cv.hpp
Unescape View File

@ -253,7 +253,7 @@ static PyObject *iplimage_tostring(PyObject *self, PyObject *args)
return NULL;
if (i == NULL)
return NULL;
cv::Mat img(i);
cv::Mat img = cvarrToMat(i);
size_t esz = img.elemSize();
int nrows = img.rows, ncols = img.cols;

2
modules/ts/src/ts_func.cpp
Unescape View File

@ -71,7 +71,7 @@ int randomType(RNG& rng, int typeMask, int minChannels, int maxChannels)
{
int channels = rng.uniform(minChannels, maxChannels+1);
int depth = 0;
CV_Assert((typeMask & DEPTH_MASK_ALL) != 0);
CV_Assert((typeMask & _OutputArray::DEPTH_MASK_ALL) != 0);
for(;;)
{
depth = rng.uniform(CV_8U, CV_64F+1);

3
samples/c/facedetect.cpp
Unescape View File

@ -1,6 +1,7 @@
#include "opencv2/objdetect/objdetect.hpp"
#include "opencv2/highgui/highgui.hpp"
#include "opencv2/imgproc/imgproc.hpp"
#include "opencv2/core/utility.hpp"
#include <cctype>
#include <iostream>
@ -124,7 +125,7 @@ int main( int argc, const char** argv )
for(;;)
{
IplImage* iplImg = cvQueryFrame( capture );
frame = iplImg;
frame = cv::cvarrToMat(iplImg);
if( frame.empty() )
break;
if( iplImg->origin == IPL_ORIGIN_TL )

3
samples/c/smiledetect.cpp
Unescape View File

@ -1,6 +1,7 @@
#include "opencv2/objdetect/objdetect.hpp"
#include "opencv2/highgui/highgui.hpp"
#include "opencv2/imgproc/imgproc.hpp"
#include "opencv2/core/utility.hpp"
#include <cctype>
#include <iostream>
@ -120,7 +121,7 @@ int main( int argc, const char** argv )
for(;;)
{
IplImage* iplImg = cvQueryFrame( capture );
frame = iplImg;
frame = cv::cvarrToMat(iplImg);
if( frame.empty() )
break;
if( iplImg->origin == IPL_ORIGIN_TL )

5
samples/c/tree_engine.cpp
Unescape View File

@ -1,5 +1,6 @@
#include "opencv2/ml/ml.hpp"
#include "opencv2/core/core_c.h"
#include "opencv2/core/utility.hpp"
#include <stdio.h>
#include <map>
@ -21,7 +22,7 @@ static void help()
static int count_classes(CvMLData& data)
{
cv::Mat r(data.get_responses());
cv::Mat r = cv::cvarrToMat(data.get_responses());
std::map<int, int> rmap;
int i, n = (int)r.total();
for( i = 0; i < n; i++ )
@ -42,7 +43,7 @@ static void print_result(float train_err, float test_err, const CvMat* _var_imp)
if (_var_imp)
{
cv::Mat var_imp(_var_imp), sorted_idx;
cv::Mat var_imp = cv::cvarrToMat(_var_imp), sorted_idx;
cv::sortIdx(var_imp, sorted_idx, CV_SORT_EVERY_ROW + CV_SORT_DESCENDING);
printf( "variable importance:\n" );

4
samples/cpp/Qt_sample/main.cpp
Unescape View File

@ -118,7 +118,7 @@ static void foundCorners(vector<CvPoint2D32f> *srcImagePoints,IplImage* source,
cvNormalize(grayImage, grayImage, 0, 255, CV_MINMAX);
cvThreshold( grayImage, grayImage, 26, 255, CV_THRESH_BINARY_INV);//25
Mat MgrayImage = grayImage;
Mat MgrayImage = cv::cvarrToMat(grayImage);
//For debug
//MgrayImage = MgrayImage.clone();//deep copy
vector<vector<Point> > contours;
@ -184,7 +184,7 @@ static void foundCorners(vector<CvPoint2D32f> *srcImagePoints,IplImage* source,
}
srcImagePoints->at(3) = srcImagePoints_temp.at(index);
Mat Msource = source;
Mat Msource = cv::cvarrToMat(source);
stringstream ss;
for(size_t i = 0 ; i<srcImagePoints_temp.size(); i++ )
{

3
samples/cpp/image.cpp
Unescape View File

@ -3,6 +3,7 @@
#include "opencv2/imgproc/imgproc.hpp"
#include "opencv2/highgui/highgui.hpp"
#include "opencv2/flann/miniflann.hpp"
#include "opencv2/core/utility.hpp"
using namespace cv; // all the new API is put into "cv" namespace. Export its content
using namespace std;
@ -32,7 +33,7 @@ int main( int argc, char** argv )
fprintf(stderr, "Can not load image %s\n", imagename);
return -1;
}
Mat img(iplimg); // cv::Mat replaces the CvMat and IplImage, but it's easy to convert
Mat img = cv::cvarrToMat(iplimg); // cv::Mat replaces the CvMat and IplImage, but it's easy to convert
// between the old and the new data structures (by default, only the header
// is converted, while the data is shared)
#else

3
samples/cpp/tutorial_code/core/interoperability_with_OpenCV_1/interoperability_with_OpenCV_1.cpp
Unescape View File

@ -4,6 +4,7 @@
#include <opencv2/core/core.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/core/utility.hpp>"
using namespace cv; // The new C++ interface API is inside this namespace. Import it.
using namespace std;
@ -33,7 +34,7 @@ int main( int argc, char** argv )
cerr << "Can not load image " << imagename << endl;
return -1;
}
Mat I(IplI); // Convert to the new style container. Only header created. Image not copied.
Mat I = cv::cvarrToMat(IplI); // Convert to the new style container. Only header created. Image not copied.
#else
Mat I = imread(imagename); // the newer cvLoadImage alternative, MATLAB-style function
if( I.empty() ) // same as if( !I.data )

3
samples/cpp/tutorial_code/objectDetection/objectDetection.cpp
Unescape View File

@ -6,6 +6,7 @@
#include "opencv2/objdetect/objdetect.hpp"
#include "opencv2/highgui/highgui.hpp"
#include "opencv2/imgproc/imgproc.hpp"
#include "opencv2/core/utility.hpp"
#include <iostream>
#include <stdio.h>
@ -43,7 +44,7 @@ int main( void )
{
for(;;)
{
frame = cvQueryFrame( capture );
frame = cv::cvarrToMat(cvQueryFrame( capture ));
//-- 3. Apply the classifier to the frame
if( !frame.empty() )

3
samples/cpp/tutorial_code/objectDetection/objectDetection2.cpp
Unescape View File

@ -6,6 +6,7 @@
#include "opencv2/objdetect/objdetect.hpp"
#include "opencv2/highgui/highgui.hpp"
#include "opencv2/imgproc/imgproc.hpp"
#include "opencv2/core/utility.hpp"
#include <iostream>
#include <stdio.h>
@ -43,7 +44,7 @@ int main( void )
{
for(;;)
{
frame = cvQueryFrame( capture );
frame = cv::cvarrToMat(cvQueryFrame( capture ));
//-- 3. Apply the classifier to the frame
if( !frame.empty() )

Write Preview
Loading…
Cancel
Save