mirror of
https://github.com/opencv/opencv.git
synced 2026-07-31 00:03:03 +04:00
don't use constructors for C API structures
This commit is contained in:
Alexander Alekhin
@@ -290,8 +290,8 @@ void CV_CameraCalibrationTest::run( int start_from )
|
||||
cv::String filepath;
|
||||
cv::String filename;
|
||||
|
||||
CvSize imageSize;
|
||||
CvSize etalonSize;
|
||||
Size imageSize;
|
||||
Size etalonSize;
|
||||
int numImages;
|
||||
|
||||
CvPoint2D64f* imagePoints;
|
||||
@@ -531,7 +531,7 @@ void CV_CameraCalibrationTest::run( int start_from )
|
||||
/* Now we can calibrate camera */
|
||||
calibrate( numImages,
|
||||
numbers,
|
||||
imageSize,
|
||||
cvSize(imageSize),
|
||||
imagePoints,
|
||||
objectPoints,
|
||||
distortion,
|
||||
@@ -1009,9 +1009,9 @@ void CV_CalibrationMatrixValuesTest_C::calibMatrixValues( const Mat& _cameraMatr
|
||||
double& fovx, double& fovy, double& focalLength,
|
||||
Point2d& principalPoint, double& aspectRatio )
|
||||
{
|
||||
CvMat cameraMatrix = _cameraMatrix;
|
||||
CvPoint2D64f pp;
|
||||
cvCalibrationMatrixValues( &cameraMatrix, imageSize, apertureWidth, apertureHeight,
|
||||
CvMat cameraMatrix = cvMat(_cameraMatrix);
|
||||
CvPoint2D64f pp = {0, 0};
|
||||
cvCalibrationMatrixValues( &cameraMatrix, cvSize(imageSize), apertureWidth, apertureHeight,
|
||||
&fovx, &fovy, &focalLength, &pp, &aspectRatio );
|
||||
principalPoint.x = pp.x;
|
||||
principalPoint.y = pp.y;
|
||||
@@ -1305,9 +1305,9 @@ void CV_ProjectPointsTest_C::project( const Mat& opoints, const Mat& rvec, const
|
||||
dpdc.create(npoints*2, 2, CV_64F);
|
||||
dpddist.create(npoints*2, distCoeffs.rows + distCoeffs.cols - 1, CV_64F);
|
||||
Mat imagePoints(ipoints);
|
||||
CvMat _objectPoints = opoints, _imagePoints = imagePoints;
|
||||
CvMat _rvec = rvec, _tvec = tvec, _cameraMatrix = cameraMatrix, _distCoeffs = distCoeffs;
|
||||
CvMat _dpdrot = dpdrot, _dpdt = dpdt, _dpdf = dpdf, _dpdc = dpdc, _dpddist = dpddist;
|
||||
CvMat _objectPoints = cvMat(opoints), _imagePoints = cvMat(imagePoints);
|
||||
CvMat _rvec = cvMat(rvec), _tvec = cvMat(tvec), _cameraMatrix = cvMat(cameraMatrix), _distCoeffs = cvMat(distCoeffs);
|
||||
CvMat _dpdrot = cvMat(dpdrot), _dpdt = cvMat(dpdt), _dpdf = cvMat(dpdf), _dpdc = cvMat(dpdc), _dpddist = cvMat(dpddist);
|
||||
|
||||
cvProjectPoints2( &_objectPoints, &_rvec, &_tvec, &_cameraMatrix, &_distCoeffs,
|
||||
&_imagePoints, &_dpdrot, &_dpdt, &_dpdf, &_dpdc, &_dpddist, aspectRatio );
|
||||
@@ -1925,14 +1925,14 @@ double CV_StereoCalibrationTest_C::calibrateStereoCamera( const vector<vector<Po
|
||||
std::copy(imagePoints1[i].begin(), imagePoints1[i].end(), imgPtData + j);
|
||||
std::copy(imagePoints2[i].begin(), imagePoints2[i].end(), imgPtData2 + j);
|
||||
}
|
||||
CvMat _objPt = objPt, _imgPt = imgPt, _imgPt2 = imgPt2, _npoints = npoints;
|
||||
CvMat _cameraMatrix1 = cameraMatrix1, _distCoeffs1 = distCoeffs1;
|
||||
CvMat _cameraMatrix2 = cameraMatrix2, _distCoeffs2 = distCoeffs2;
|
||||
CvMat matR = R, matT = T, matE = E, matF = F;
|
||||
CvMat _objPt = cvMat(objPt), _imgPt = cvMat(imgPt), _imgPt2 = cvMat(imgPt2), _npoints = cvMat(npoints);
|
||||
CvMat _cameraMatrix1 = cvMat(cameraMatrix1), _distCoeffs1 = cvMat(distCoeffs1);
|
||||
CvMat _cameraMatrix2 = cvMat(cameraMatrix2), _distCoeffs2 = cvMat(distCoeffs2);
|
||||
CvMat matR = cvMat(R), matT = cvMat(T), matE = cvMat(E), matF = cvMat(F);
|
||||
|
||||
return cvStereoCalibrate(&_objPt, &_imgPt, &_imgPt2, &_npoints, &_cameraMatrix1,
|
||||
&_distCoeffs1, &_cameraMatrix2, &_distCoeffs2, imageSize,
|
||||
&matR, &matT, &matE, &matF, flags, criteria );
|
||||
&_distCoeffs1, &_cameraMatrix2, &_distCoeffs2, cvSize(imageSize),
|
||||
&matR, &matT, &matE, &matF, flags, cvTermCriteria(criteria));
|
||||
}
|
||||
|
||||
void CV_StereoCalibrationTest_C::rectify( const Mat& cameraMatrix1, const Mat& distCoeffs1,
|
||||
@@ -1948,12 +1948,12 @@ void CV_StereoCalibrationTest_C::rectify( const Mat& cameraMatrix1, const Mat& d
|
||||
P1.create(3, 4, rtype);
|
||||
P2.create(3, 4, rtype);
|
||||
Q.create(4, 4, rtype);
|
||||
CvMat _cameraMatrix1 = cameraMatrix1, _distCoeffs1 = distCoeffs1;
|
||||
CvMat _cameraMatrix2 = cameraMatrix2, _distCoeffs2 = distCoeffs2;
|
||||
CvMat matR = R, matT = T, _R1 = R1, _R2 = R2, _P1 = P1, _P2 = P2, matQ = Q;
|
||||
CvMat _cameraMatrix1 = cvMat(cameraMatrix1), _distCoeffs1 = cvMat(distCoeffs1);
|
||||
CvMat _cameraMatrix2 = cvMat(cameraMatrix2), _distCoeffs2 = cvMat(distCoeffs2);
|
||||
CvMat matR = cvMat(R), matT = cvMat(T), _R1 = cvMat(R1), _R2 = cvMat(R2), _P1 = cvMat(P1), _P2 = cvMat(P2), matQ = cvMat(Q);
|
||||
cvStereoRectify( &_cameraMatrix1, &_cameraMatrix2, &_distCoeffs1, &_distCoeffs2,
|
||||
imageSize, &matR, &matT, &_R1, &_R2, &_P1, &_P2, &matQ, flags,
|
||||
alpha, newImageSize, (CvRect*)validPixROI1, (CvRect*)validPixROI2);
|
||||
cvSize(imageSize), &matR, &matT, &_R1, &_R2, &_P1, &_P2, &matQ, flags,
|
||||
alpha, cvSize(newImageSize), (CvRect*)validPixROI1, (CvRect*)validPixROI2);
|
||||
}
|
||||
|
||||
bool CV_StereoCalibrationTest_C::rectifyUncalibrated( const Mat& points1,
|
||||
@@ -1961,19 +1961,19 @@ bool CV_StereoCalibrationTest_C::rectifyUncalibrated( const Mat& points1,
|
||||
{
|
||||
H1.create(3, 3, CV_64F);
|
||||
H2.create(3, 3, CV_64F);
|
||||
CvMat _pt1 = points1, _pt2 = points2, matF, *pF=0, _H1 = H1, _H2 = H2;
|
||||
CvMat _pt1 = cvMat(points1), _pt2 = cvMat(points2), matF, *pF=0, _H1 = cvMat(H1), _H2 = cvMat(H2);
|
||||
if( F.size() == Size(3, 3) )
|
||||
pF = &(matF = F);
|
||||
return cvStereoRectifyUncalibrated(&_pt1, &_pt2, pF, imgSize, &_H1, &_H2, threshold) > 0;
|
||||
pF = &(matF = cvMat(F));
|
||||
return cvStereoRectifyUncalibrated(&_pt1, &_pt2, pF, cvSize(imgSize), &_H1, &_H2, threshold) > 0;
|
||||
}
|
||||
|
||||
void CV_StereoCalibrationTest_C::triangulate( const Mat& P1, const Mat& P2,
|
||||
const Mat &points1, const Mat &points2,
|
||||
Mat &points4D )
|
||||
{
|
||||
CvMat _P1 = P1, _P2 = P2, _points1 = points1, _points2 = points2;
|
||||
CvMat _P1 = cvMat(P1), _P2 = cvMat(P2), _points1 = cvMat(points1), _points2 = cvMat(points2);
|
||||
points4D.create(4, points1.cols, points1.type());
|
||||
CvMat _points4D = points4D;
|
||||
CvMat _points4D = cvMat(points4D);
|
||||
cvTriangulatePoints(&_P1, &_P2, &_points1, &_points2, &_points4D);
|
||||
}
|
||||
|
||||
@@ -1981,10 +1981,10 @@ void CV_StereoCalibrationTest_C::correct( const Mat& F,
|
||||
const Mat &points1, const Mat &points2,
|
||||
Mat &newPoints1, Mat &newPoints2 )
|
||||
{
|
||||
CvMat _F = F, _points1 = points1, _points2 = points2;
|
||||
CvMat _F = cvMat(F), _points1 = cvMat(points1), _points2 = cvMat(points2);
|
||||
newPoints1.create(1, points1.cols, points1.type());
|
||||
newPoints2.create(1, points2.cols, points2.type());
|
||||
CvMat _newPoints1 = newPoints1, _newPoints2 = newPoints2;
|
||||
CvMat _newPoints1 = cvMat(newPoints1), _newPoints2 = cvMat(newPoints2);
|
||||
cvCorrectMatches(&_F, &_points1, &_points2, &_newPoints1, &_newPoints2);
|
||||
}
|
||||
|
||||
|
||||
@@ -75,7 +75,7 @@ protected:
|
||||
|
||||
void operator()() const
|
||||
{
|
||||
cvCalibrateCamera2(objPts, imgPts, npoints, imageSize,
|
||||
cvCalibrateCamera2(objPts, imgPts, npoints, cvSize(imageSize),
|
||||
cameraMatrix, distCoeffs, rvecs, tvecs, flags );
|
||||
}
|
||||
};
|
||||
@@ -137,13 +137,13 @@ void CV_CameraCalibrationBadArgTest::run( int /* start_from */ )
|
||||
//CV_CALIB_FIX_PRINCIPAL_POINT //CV_CALIB_ZERO_TANGENT_DIST
|
||||
//CV_CALIB_FIX_FOCAL_LENGTH //CV_CALIB_FIX_K1 //CV_CALIB_FIX_K2 //CV_CALIB_FIX_K3
|
||||
|
||||
objPts = objPts_cpp;
|
||||
imgPts = imgPts_cpp;
|
||||
npoints = npoints_cpp;
|
||||
cameraMatrix = cameraMatrix_cpp;
|
||||
distCoeffs = distCoeffs_cpp;
|
||||
rvecs = rvecs_cpp;
|
||||
tvecs = tvecs_cpp;
|
||||
objPts = cvMat(objPts_cpp);
|
||||
imgPts = cvMat(imgPts_cpp);
|
||||
npoints = cvMat(npoints_cpp);
|
||||
cameraMatrix = cvMat(cameraMatrix_cpp);
|
||||
distCoeffs = cvMat(distCoeffs_cpp);
|
||||
rvecs = cvMat(rvecs_cpp);
|
||||
tvecs = cvMat(tvecs_cpp);
|
||||
|
||||
/* /*//*/ */
|
||||
int errors = 0;
|
||||
@@ -178,8 +178,8 @@ void CV_CameraCalibrationBadArgTest::run( int /* start_from */ )
|
||||
|
||||
Mat bad_nts_cpp1 = Mat_<float>(M, 1, 1.f);
|
||||
Mat bad_nts_cpp2 = Mat_<int>(3, 3, corSize.width * corSize.height);
|
||||
CvMat bad_npts_c1 = bad_nts_cpp1;
|
||||
CvMat bad_npts_c2 = bad_nts_cpp2;
|
||||
CvMat bad_npts_c1 = cvMat(bad_nts_cpp1);
|
||||
CvMat bad_npts_c2 = cvMat(bad_nts_cpp2);
|
||||
|
||||
bad_caller = caller;
|
||||
bad_caller.npoints = &bad_npts_c1;
|
||||
@@ -197,13 +197,13 @@ void CV_CameraCalibrationBadArgTest::run( int /* start_from */ )
|
||||
bad_caller.tvecs = (CvMat*)zeros.ptr();
|
||||
errors += run_test_case( CV_StsBadArg, "Bad tvecs header", bad_caller );
|
||||
|
||||
Mat bad_rvecs_cpp1(M+1, 1, CV_32FC3); CvMat bad_rvecs_c1 = bad_rvecs_cpp1;
|
||||
Mat bad_tvecs_cpp1(M+1, 1, CV_32FC3); CvMat bad_tvecs_c1 = bad_tvecs_cpp1;
|
||||
Mat bad_rvecs_cpp1(M+1, 1, CV_32FC3); CvMat bad_rvecs_c1 = cvMat(bad_rvecs_cpp1);
|
||||
Mat bad_tvecs_cpp1(M+1, 1, CV_32FC3); CvMat bad_tvecs_c1 = cvMat(bad_tvecs_cpp1);
|
||||
|
||||
|
||||
|
||||
Mat bad_rvecs_cpp2(M, 2, CV_32FC3); CvMat bad_rvecs_c2 = bad_rvecs_cpp2;
|
||||
Mat bad_tvecs_cpp2(M, 2, CV_32FC3); CvMat bad_tvecs_c2 = bad_tvecs_cpp2;
|
||||
Mat bad_rvecs_cpp2(M, 2, CV_32FC3); CvMat bad_rvecs_c2 = cvMat(bad_rvecs_cpp2);
|
||||
Mat bad_tvecs_cpp2(M, 2, CV_32FC3); CvMat bad_tvecs_c2 = cvMat(bad_tvecs_cpp2);
|
||||
|
||||
bad_caller = caller;
|
||||
bad_caller.rvecs = &bad_rvecs_c1;
|
||||
@@ -221,9 +221,9 @@ void CV_CameraCalibrationBadArgTest::run( int /* start_from */ )
|
||||
bad_caller.tvecs = &bad_tvecs_c2;
|
||||
errors += run_test_case( CV_StsBadArg, "Bad tvecs header", bad_caller );
|
||||
|
||||
Mat bad_cameraMatrix_cpp1(3, 3, CV_32S); CvMat bad_cameraMatrix_c1 = bad_cameraMatrix_cpp1;
|
||||
Mat bad_cameraMatrix_cpp2(2, 3, CV_32F); CvMat bad_cameraMatrix_c2 = bad_cameraMatrix_cpp2;
|
||||
Mat bad_cameraMatrix_cpp3(3, 2, CV_64F); CvMat bad_cameraMatrix_c3 = bad_cameraMatrix_cpp3;
|
||||
Mat bad_cameraMatrix_cpp1(3, 3, CV_32S); CvMat bad_cameraMatrix_c1 = cvMat(bad_cameraMatrix_cpp1);
|
||||
Mat bad_cameraMatrix_cpp2(2, 3, CV_32F); CvMat bad_cameraMatrix_c2 = cvMat(bad_cameraMatrix_cpp2);
|
||||
Mat bad_cameraMatrix_cpp3(3, 2, CV_64F); CvMat bad_cameraMatrix_c3 = cvMat(bad_cameraMatrix_cpp3);
|
||||
|
||||
|
||||
|
||||
@@ -239,9 +239,9 @@ void CV_CameraCalibrationBadArgTest::run( int /* start_from */ )
|
||||
bad_caller.cameraMatrix = &bad_cameraMatrix_c3;
|
||||
errors += run_test_case( CV_StsBadArg, "Bad camearaMatrix header", bad_caller );
|
||||
|
||||
Mat bad_distCoeffs_cpp1(1, 5, CV_32S); CvMat bad_distCoeffs_c1 = bad_distCoeffs_cpp1;
|
||||
Mat bad_distCoeffs_cpp2(2, 2, CV_64F); CvMat bad_distCoeffs_c2 = bad_distCoeffs_cpp2;
|
||||
Mat bad_distCoeffs_cpp3(1, 6, CV_64F); CvMat bad_distCoeffs_c3 = bad_distCoeffs_cpp3;
|
||||
Mat bad_distCoeffs_cpp1(1, 5, CV_32S); CvMat bad_distCoeffs_c1 = cvMat(bad_distCoeffs_cpp1);
|
||||
Mat bad_distCoeffs_cpp2(2, 2, CV_64F); CvMat bad_distCoeffs_c2 = cvMat(bad_distCoeffs_cpp2);
|
||||
Mat bad_distCoeffs_cpp3(1, 6, CV_64F); CvMat bad_distCoeffs_c3 = cvMat(bad_distCoeffs_cpp3);
|
||||
|
||||
|
||||
|
||||
@@ -259,7 +259,7 @@ void CV_CameraCalibrationBadArgTest::run( int /* start_from */ )
|
||||
errors += run_test_case( CV_StsBadArg, "Bad distCoeffs header", bad_caller );
|
||||
|
||||
double CM[] = {0, 0, 0, /**/0, 0, 0, /**/0, 0, 0};
|
||||
Mat bad_cameraMatrix_cpp4(3, 3, CV_64F, CM); CvMat bad_cameraMatrix_c4 = bad_cameraMatrix_cpp4;
|
||||
Mat bad_cameraMatrix_cpp4(3, 3, CV_64F, CM); CvMat bad_cameraMatrix_c4 = cvMat(bad_cameraMatrix_cpp4);
|
||||
|
||||
bad_caller = caller;
|
||||
bad_caller.flags |= CV_CALIB_USE_INTRINSIC_GUESS;
|
||||
@@ -302,7 +302,7 @@ void CV_CameraCalibrationBadArgTest::run( int /* start_from */ )
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////////////
|
||||
bad_caller = caller;
|
||||
Mat bad_objPts_cpp5 = objPts_cpp.clone(); CvMat bad_objPts_c5 = bad_objPts_cpp5;
|
||||
Mat bad_objPts_cpp5 = objPts_cpp.clone(); CvMat bad_objPts_c5 = cvMat(bad_objPts_cpp5);
|
||||
bad_caller.objPts = &bad_objPts_c5;
|
||||
|
||||
cv::RNG& rng = theRNG();
|
||||
@@ -347,9 +347,9 @@ protected:
|
||||
Mat zeros(1, sizeof(CvMat), CV_8U, Scalar(0));
|
||||
CvMat src_c, dst_c, jacobian_c;
|
||||
|
||||
Mat src_cpp(3, 1, CV_32F); src_c = src_cpp;
|
||||
Mat dst_cpp(3, 3, CV_32F); dst_c = dst_cpp;
|
||||
Mat jacobian_cpp(3, 9, CV_32F); jacobian_c = jacobian_cpp;
|
||||
Mat src_cpp(3, 1, CV_32F); src_c = cvMat(src_cpp);
|
||||
Mat dst_cpp(3, 3, CV_32F); dst_c = cvMat(dst_cpp);
|
||||
Mat jacobian_cpp(3, 9, CV_32F); jacobian_c = cvMat(jacobian_cpp);
|
||||
|
||||
C_Caller caller, bad_caller;
|
||||
caller.src = &src_c;
|
||||
@@ -373,11 +373,11 @@ protected:
|
||||
bad_caller.dst = 0;
|
||||
errors += run_test_case( CV_StsNullPtr, "Dst is zero pointer", bad_caller );
|
||||
|
||||
Mat bad_src_cpp1(3, 1, CV_8U); CvMat bad_src_c1 = bad_src_cpp1;
|
||||
Mat bad_dst_cpp1(3, 1, CV_8U); CvMat bad_dst_c1 = bad_dst_cpp1;
|
||||
Mat bad_jac_cpp1(3, 1, CV_8U); CvMat bad_jac_c1 = bad_jac_cpp1;
|
||||
Mat bad_jac_cpp2(3, 1, CV_32FC2); CvMat bad_jac_c2 = bad_jac_cpp2;
|
||||
Mat bad_jac_cpp3(3, 1, CV_32F); CvMat bad_jac_c3 = bad_jac_cpp3;
|
||||
Mat bad_src_cpp1(3, 1, CV_8U); CvMat bad_src_c1 = cvMat(bad_src_cpp1);
|
||||
Mat bad_dst_cpp1(3, 1, CV_8U); CvMat bad_dst_c1 = cvMat(bad_dst_cpp1);
|
||||
Mat bad_jac_cpp1(3, 1, CV_8U); CvMat bad_jac_c1 = cvMat(bad_jac_cpp1);
|
||||
Mat bad_jac_cpp2(3, 1, CV_32FC2); CvMat bad_jac_c2 = cvMat(bad_jac_cpp2);
|
||||
Mat bad_jac_cpp3(3, 1, CV_32F); CvMat bad_jac_c3 = cvMat(bad_jac_cpp3);
|
||||
|
||||
bad_caller = caller;
|
||||
bad_caller.src = &bad_src_c1;
|
||||
@@ -403,15 +403,15 @@ protected:
|
||||
bad_caller.jacobian = &bad_jac_c3;
|
||||
errors += run_test_case( CV_StsBadSize, "Bad jacobian format", bad_caller );
|
||||
|
||||
Mat bad_src_cpp2(1, 1, CV_32F); CvMat bad_src_c2 = bad_src_cpp2;
|
||||
Mat bad_src_cpp2(1, 1, CV_32F); CvMat bad_src_c2 = cvMat(bad_src_cpp2);
|
||||
|
||||
bad_caller = caller;
|
||||
bad_caller.src = &bad_src_c2;
|
||||
errors += run_test_case( CV_StsBadSize, "Bad src format", bad_caller );
|
||||
|
||||
Mat bad_dst_cpp2(2, 1, CV_32F); CvMat bad_dst_c2 = bad_dst_cpp2;
|
||||
Mat bad_dst_cpp3(3, 2, CV_32F); CvMat bad_dst_c3 = bad_dst_cpp3;
|
||||
Mat bad_dst_cpp4(3, 3, CV_32FC2); CvMat bad_dst_c4 = bad_dst_cpp4;
|
||||
Mat bad_dst_cpp2(2, 1, CV_32F); CvMat bad_dst_c2 = cvMat(bad_dst_cpp2);
|
||||
Mat bad_dst_cpp3(3, 2, CV_32F); CvMat bad_dst_c3 = cvMat(bad_dst_cpp3);
|
||||
Mat bad_dst_cpp4(3, 3, CV_32FC2); CvMat bad_dst_c4 = cvMat(bad_dst_cpp4);
|
||||
|
||||
bad_caller = caller;
|
||||
bad_caller.dst = &bad_dst_c2;
|
||||
@@ -427,11 +427,11 @@ protected:
|
||||
|
||||
|
||||
/********/
|
||||
src_cpp.create(3, 3, CV_32F); src_c = src_cpp;
|
||||
dst_cpp.create(3, 1, CV_32F); dst_c = dst_cpp;
|
||||
src_cpp.create(3, 3, CV_32F); src_c = cvMat(src_cpp);
|
||||
dst_cpp.create(3, 1, CV_32F); dst_c = cvMat(dst_cpp);
|
||||
|
||||
|
||||
Mat bad_dst_cpp5(5, 5, CV_32F); CvMat bad_dst_c5 = bad_dst_cpp5;
|
||||
Mat bad_dst_cpp5(5, 5, CV_32F); CvMat bad_dst_c5 = cvMat(bad_dst_cpp5);
|
||||
|
||||
bad_caller = caller;
|
||||
bad_caller.dst = &bad_dst_c5;
|
||||
@@ -488,15 +488,7 @@ protected:
|
||||
|
||||
void run(int /* start_from */ )
|
||||
{
|
||||
CvMat zeros;
|
||||
#if defined __GNUC__ && __GNUC__ >= 8
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wclass-memaccess"
|
||||
#endif
|
||||
memset(&zeros, 0, sizeof(zeros));
|
||||
#if defined __GNUC__ && __GNUC__ >= 8
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
CvMat zeros = CvMat();
|
||||
|
||||
C_Caller caller, bad_caller;
|
||||
CvMat objectPoints_c, r_vec_c, t_vec_c, A_c, distCoeffs_c, imagePoints_c,
|
||||
@@ -504,24 +496,24 @@ protected:
|
||||
|
||||
const int n = 10;
|
||||
|
||||
Mat imagePoints_cpp(1, n, CV_32FC2); imagePoints_c = imagePoints_cpp;
|
||||
Mat imagePoints_cpp(1, n, CV_32FC2); imagePoints_c = cvMat(imagePoints_cpp);
|
||||
|
||||
Mat objectPoints_cpp(1, n, CV_32FC3);
|
||||
randu(objectPoints_cpp, Scalar::all(1), Scalar::all(10));
|
||||
objectPoints_c = objectPoints_cpp;
|
||||
objectPoints_c = cvMat(objectPoints_cpp);
|
||||
|
||||
Mat t_vec_cpp(Mat::zeros(1, 3, CV_32F)); t_vec_c = t_vec_cpp;
|
||||
Mat t_vec_cpp(Mat::zeros(1, 3, CV_32F)); t_vec_c = cvMat(t_vec_cpp);
|
||||
Mat r_vec_cpp(3, 1, CV_32F);
|
||||
cvtest::Rodrigues(Mat::eye(3, 3, CV_32F), r_vec_cpp); r_vec_c = r_vec_cpp;
|
||||
cvtest::Rodrigues(Mat::eye(3, 3, CV_32F), r_vec_cpp); r_vec_c = cvMat(r_vec_cpp);
|
||||
|
||||
Mat A_cpp = camMat.clone(); A_c = A_cpp;
|
||||
Mat distCoeffs_cpp = distCoeffs.clone(); distCoeffs_c = distCoeffs_cpp;
|
||||
Mat A_cpp = camMat.clone(); A_c = cvMat(A_cpp);
|
||||
Mat distCoeffs_cpp = distCoeffs.clone(); distCoeffs_c = cvMat(distCoeffs_cpp);
|
||||
|
||||
Mat dpdr_cpp(2*n, 3, CV_32F); dpdr_c = dpdr_cpp;
|
||||
Mat dpdt_cpp(2*n, 3, CV_32F); dpdt_c = dpdt_cpp;
|
||||
Mat dpdf_cpp(2*n, 2, CV_32F); dpdf_c = dpdf_cpp;
|
||||
Mat dpdc_cpp(2*n, 2, CV_32F); dpdc_c = dpdc_cpp;
|
||||
Mat dpdk_cpp(2*n, 4, CV_32F); dpdk_c = dpdk_cpp;
|
||||
Mat dpdr_cpp(2*n, 3, CV_32F); dpdr_c = cvMat(dpdr_cpp);
|
||||
Mat dpdt_cpp(2*n, 3, CV_32F); dpdt_c = cvMat(dpdt_cpp);
|
||||
Mat dpdf_cpp(2*n, 2, CV_32F); dpdf_c = cvMat(dpdf_cpp);
|
||||
Mat dpdc_cpp(2*n, 2, CV_32F); dpdc_c = cvMat(dpdc_cpp);
|
||||
Mat dpdk_cpp(2*n, 4, CV_32F); dpdk_c = cvMat(dpdk_cpp);
|
||||
|
||||
caller.aspectRatio = 1.0;
|
||||
caller.objectPoints = &objectPoints_c;
|
||||
@@ -561,9 +553,9 @@ protected:
|
||||
errors += run_test_case( CV_StsBadArg, "Zero imagePoints", bad_caller );
|
||||
|
||||
/****************************/
|
||||
Mat bad_r_vec_cpp1(r_vec_cpp.size(), CV_32S); CvMat bad_r_vec_c1 = bad_r_vec_cpp1;
|
||||
Mat bad_r_vec_cpp2(2, 2, CV_32F); CvMat bad_r_vec_c2 = bad_r_vec_cpp2;
|
||||
Mat bad_r_vec_cpp3(r_vec_cpp.size(), CV_32FC2); CvMat bad_r_vec_c3 = bad_r_vec_cpp3;
|
||||
Mat bad_r_vec_cpp1(r_vec_cpp.size(), CV_32S); CvMat bad_r_vec_c1 = cvMat(bad_r_vec_cpp1);
|
||||
Mat bad_r_vec_cpp2(2, 2, CV_32F); CvMat bad_r_vec_c2 = cvMat(bad_r_vec_cpp2);
|
||||
Mat bad_r_vec_cpp3(r_vec_cpp.size(), CV_32FC2); CvMat bad_r_vec_c3 = cvMat(bad_r_vec_cpp3);
|
||||
|
||||
bad_caller = caller;
|
||||
bad_caller.r_vec = &bad_r_vec_c1;
|
||||
@@ -578,9 +570,9 @@ protected:
|
||||
errors += run_test_case( CV_StsBadArg, "Bad rvec format", bad_caller );
|
||||
|
||||
/****************************/
|
||||
Mat bad_t_vec_cpp1(t_vec_cpp.size(), CV_32S); CvMat bad_t_vec_c1 = bad_t_vec_cpp1;
|
||||
Mat bad_t_vec_cpp2(2, 2, CV_32F); CvMat bad_t_vec_c2 = bad_t_vec_cpp2;
|
||||
Mat bad_t_vec_cpp3(1, 1, CV_32FC2); CvMat bad_t_vec_c3 = bad_t_vec_cpp3;
|
||||
Mat bad_t_vec_cpp1(t_vec_cpp.size(), CV_32S); CvMat bad_t_vec_c1 = cvMat(bad_t_vec_cpp1);
|
||||
Mat bad_t_vec_cpp2(2, 2, CV_32F); CvMat bad_t_vec_c2 = cvMat(bad_t_vec_cpp2);
|
||||
Mat bad_t_vec_cpp3(1, 1, CV_32FC2); CvMat bad_t_vec_c3 = cvMat(bad_t_vec_cpp3);
|
||||
|
||||
bad_caller = caller;
|
||||
bad_caller.t_vec = &bad_t_vec_c1;
|
||||
@@ -595,8 +587,8 @@ protected:
|
||||
errors += run_test_case( CV_StsBadArg, "Bad tvec format", bad_caller );
|
||||
|
||||
/****************************/
|
||||
Mat bad_A_cpp1(A_cpp.size(), CV_32S); CvMat bad_A_c1 = bad_A_cpp1;
|
||||
Mat bad_A_cpp2(2, 2, CV_32F); CvMat bad_A_c2 = bad_A_cpp2;
|
||||
Mat bad_A_cpp1(A_cpp.size(), CV_32S); CvMat bad_A_c1 = cvMat(bad_A_cpp1);
|
||||
Mat bad_A_cpp2(2, 2, CV_32F); CvMat bad_A_c2 = cvMat(bad_A_cpp2);
|
||||
|
||||
bad_caller = caller;
|
||||
bad_caller.A = &bad_A_c1;
|
||||
@@ -607,9 +599,9 @@ protected:
|
||||
errors += run_test_case( CV_StsBadArg, "Bad A format", bad_caller );
|
||||
|
||||
/****************************/
|
||||
Mat bad_distCoeffs_cpp1(distCoeffs_cpp.size(), CV_32S); CvMat bad_distCoeffs_c1 = bad_distCoeffs_cpp1;
|
||||
Mat bad_distCoeffs_cpp2(2, 2, CV_32F); CvMat bad_distCoeffs_c2 = bad_distCoeffs_cpp2;
|
||||
Mat bad_distCoeffs_cpp3(1, 7, CV_32F); CvMat bad_distCoeffs_c3 = bad_distCoeffs_cpp3;
|
||||
Mat bad_distCoeffs_cpp1(distCoeffs_cpp.size(), CV_32S); CvMat bad_distCoeffs_c1 = cvMat(bad_distCoeffs_cpp1);
|
||||
Mat bad_distCoeffs_cpp2(2, 2, CV_32F); CvMat bad_distCoeffs_c2 = cvMat(bad_distCoeffs_cpp2);
|
||||
Mat bad_distCoeffs_cpp3(1, 7, CV_32F); CvMat bad_distCoeffs_c3 = cvMat(bad_distCoeffs_cpp3);
|
||||
|
||||
bad_caller = caller;
|
||||
bad_caller.distCoeffs = &zeros;
|
||||
@@ -629,9 +621,9 @@ protected:
|
||||
|
||||
|
||||
/****************************/
|
||||
Mat bad_dpdr_cpp1(dpdr_cpp.size(), CV_32S); CvMat bad_dpdr_c1 = bad_dpdr_cpp1;
|
||||
Mat bad_dpdr_cpp2(dpdr_cpp.cols+1, 3, CV_32F); CvMat bad_dpdr_c2 = bad_dpdr_cpp2;
|
||||
Mat bad_dpdr_cpp3(dpdr_cpp.cols, 7, CV_32F); CvMat bad_dpdr_c3 = bad_dpdr_cpp3;
|
||||
Mat bad_dpdr_cpp1(dpdr_cpp.size(), CV_32S); CvMat bad_dpdr_c1 = cvMat(bad_dpdr_cpp1);
|
||||
Mat bad_dpdr_cpp2(dpdr_cpp.cols+1, 3, CV_32F); CvMat bad_dpdr_c2 = cvMat(bad_dpdr_cpp2);
|
||||
Mat bad_dpdr_cpp3(dpdr_cpp.cols, 7, CV_32F); CvMat bad_dpdr_c3 = cvMat(bad_dpdr_cpp3);
|
||||
|
||||
bad_caller = caller;
|
||||
bad_caller.dpdr = &zeros;
|
||||
@@ -669,7 +661,7 @@ protected:
|
||||
|
||||
/****************************/
|
||||
|
||||
Mat bad_dpdf_cpp2(dpdr_cpp.cols+1, 2, CV_32F); CvMat bad_dpdf_c2 = bad_dpdf_cpp2;
|
||||
Mat bad_dpdf_cpp2(dpdr_cpp.cols+1, 2, CV_32F); CvMat bad_dpdf_c2 = cvMat(bad_dpdf_cpp2);
|
||||
|
||||
bad_caller = caller;
|
||||
bad_caller.dpdf = &zeros;
|
||||
|
||||
@@ -78,9 +78,9 @@ protected:
|
||||
findChessboardCorners(img, pattern_size, corners, flags);
|
||||
else
|
||||
if (!drawCorners)
|
||||
cvFindChessboardCorners( &arr, pattern_size, out_corners, out_corner_count, flags );
|
||||
cvFindChessboardCorners( &arr, cvSize(pattern_size), out_corners, out_corner_count, flags );
|
||||
else
|
||||
cvDrawChessboardCorners( &drawCorImg, pattern_size,
|
||||
cvDrawChessboardCorners( &drawCorImg, cvSize(pattern_size),
|
||||
(CvPoint2D32f*)(corners.empty() ? 0 : &corners[0]),
|
||||
(int)corners.size(), was_found);
|
||||
}
|
||||
@@ -128,14 +128,14 @@ void CV_ChessboardDetectorBadArgTest::run( int /*start_from */)
|
||||
drawCorners = false;
|
||||
|
||||
img = cb.clone();
|
||||
arr = img;
|
||||
arr = cvMat(img);
|
||||
out_corner_count = 0;
|
||||
out_corners = 0;
|
||||
errors += run_test_case( CV_StsNullPtr, "Null pointer to corners" );
|
||||
|
||||
drawCorners = true;
|
||||
Mat cvdrawCornImg(img.size(), CV_8UC2);
|
||||
drawCorImg = cvdrawCornImg;
|
||||
drawCorImg = cvMat(cvdrawCornImg);
|
||||
was_found = true;
|
||||
errors += run_test_case( CV_StsUnsupportedFormat, "2 channel image" );
|
||||
|
||||
|
||||
@@ -96,7 +96,7 @@ void CV_ChessboardDetectorTimingTest::run( int start_from )
|
||||
{
|
||||
int count0 = -1;
|
||||
int count = 0;
|
||||
CvSize pattern_size;
|
||||
Size pattern_size;
|
||||
int result, result1 = 0;
|
||||
|
||||
const char* imgname = cvReadString((CvFileNode*)cvGetSeqElem(board_list->data.seq,idx*4), "dummy.txt");
|
||||
@@ -110,7 +110,7 @@ void CV_ChessboardDetectorTimingTest::run( int start_from )
|
||||
filename = cv::format("%s%s", filepath.c_str(), imgname );
|
||||
|
||||
cv::Mat img2 = cv::imread( filename );
|
||||
img = img2;
|
||||
img = cvIplImage(img2);
|
||||
|
||||
if( img2.empty() )
|
||||
{
|
||||
@@ -135,11 +135,11 @@ void CV_ChessboardDetectorTimingTest::run( int start_from )
|
||||
v = (CvPoint2D32f*)_v->data.fl;
|
||||
|
||||
int64 _time0 = cvGetTickCount();
|
||||
result = cvCheckChessboard(gray, pattern_size);
|
||||
result = cvCheckChessboard(gray, cvSize(pattern_size));
|
||||
int64 _time01 = cvGetTickCount();
|
||||
|
||||
OPENCV_CALL( result1 = cvFindChessboardCorners(
|
||||
gray, pattern_size, v, &count, 15 ));
|
||||
gray, cvSize(pattern_size), v, &count, 15 ));
|
||||
int64 _time1 = cvGetTickCount();
|
||||
|
||||
if( result != is_chessboard )
|
||||
|
||||
@@ -180,7 +180,7 @@ void CV_ChessboardSubpixelTest::run( int )
|
||||
break;
|
||||
}
|
||||
|
||||
IplImage chessboard_image_header = chessboard_image;
|
||||
IplImage chessboard_image_header = cvIplImage(chessboard_image);
|
||||
cvFindCornerSubPix(&chessboard_image_header, (CvPoint2D32f*)&test_corners[0],
|
||||
(int)test_corners.size(), cvSize(3, 3), cvSize(1, 1), cvTermCriteria(CV_TERMCRIT_EPS|CV_TERMCRIT_ITER,300,0.1));
|
||||
find4QuadCornerSubpix(chessboard_image, test_corners, Size(5, 5));
|
||||
|
||||
@@ -351,9 +351,9 @@ static int cvTsRodrigues( const CvMat* src, CvMat* dst, CvMat* jacobian )
|
||||
{
|
||||
CV_Assert(src.data != dst.data && "Inplace is not supported");
|
||||
CV_Assert(!dst.empty() && "'dst' must be allocated");
|
||||
CvMat _src = src, _dst = dst, _jac;
|
||||
CvMat _src = cvMat(src), _dst = cvMat(dst), _jac;
|
||||
if( jac )
|
||||
_jac = *jac;
|
||||
_jac = cvMat(*jac);
|
||||
cvTsRodrigues(&_src, &_dst, jac ? &_jac : 0);
|
||||
}
|
||||
|
||||
@@ -667,13 +667,13 @@ void CV_RodriguesTest::run_func()
|
||||
|
||||
if( calc_jacobians )
|
||||
{
|
||||
v2m_jac = test_mat[OUTPUT][1];
|
||||
m2v_jac = test_mat[OUTPUT][3];
|
||||
v2m_jac = cvMat(test_mat[OUTPUT][1]);
|
||||
m2v_jac = cvMat(test_mat[OUTPUT][3]);
|
||||
}
|
||||
|
||||
if( !test_cpp )
|
||||
{
|
||||
CvMat _input = test_mat[INPUT][0], _output = test_mat[OUTPUT][0], _output2 = test_mat[OUTPUT][2];
|
||||
CvMat _input = cvMat(test_mat[INPUT][0]), _output = cvMat(test_mat[OUTPUT][0]), _output2 = cvMat(test_mat[OUTPUT][2]);
|
||||
cvRodrigues2( &_input, &_output, calc_jacobians ? &v2m_jac : 0 );
|
||||
cvRodrigues2( &_output, &_output2, calc_jacobians ? &m2v_jac : 0 );
|
||||
}
|
||||
@@ -980,8 +980,8 @@ int CV_FundamentalMatTest::prepare_test_case( int test_case_idx )
|
||||
void CV_FundamentalMatTest::run_func()
|
||||
{
|
||||
// cvFindFundamentalMat calls cv::findFundamentalMat
|
||||
CvMat _input0 = test_mat[INPUT][0], _input1 = test_mat[INPUT][1];
|
||||
CvMat F = test_mat[TEMP][0], mask = test_mat[TEMP][1];
|
||||
CvMat _input0 = cvMat(test_mat[INPUT][0]), _input1 = cvMat(test_mat[INPUT][1]);
|
||||
CvMat F = cvMat(test_mat[TEMP][0]), mask = cvMat(test_mat[TEMP][1]);
|
||||
f_result = cvFindFundamentalMat( &_input0, &_input1, &F, method, MAX(sigma*3, 0.01), 0, &mask );
|
||||
}
|
||||
|
||||
@@ -1543,7 +1543,7 @@ void CV_ConvertHomogeneousTest::fill_array( int /*test_case_idx*/, int /*i*/, in
|
||||
|
||||
void CV_ConvertHomogeneousTest::run_func()
|
||||
{
|
||||
CvMat _input = test_mat[INPUT][0], _output = test_mat[OUTPUT][0];
|
||||
CvMat _input = cvMat(test_mat[INPUT][0]), _output = cvMat(test_mat[OUTPUT][0]);
|
||||
cvConvertPointsHomogeneous( &_input, &_output );
|
||||
}
|
||||
|
||||
@@ -1678,7 +1678,7 @@ void CV_ComputeEpilinesTest::fill_array( int test_case_idx, int i, int j, Mat& a
|
||||
|
||||
void CV_ComputeEpilinesTest::run_func()
|
||||
{
|
||||
CvMat _points = test_mat[INPUT][0], _F = test_mat[INPUT][1], _lines = test_mat[OUTPUT][0];
|
||||
CvMat _points = cvMat(test_mat[INPUT][0]), _F = cvMat(test_mat[INPUT][1]), _lines = cvMat(test_mat[OUTPUT][0]);
|
||||
cvComputeCorrespondEpilines( &_points, which_image, &_F, &_lines );
|
||||
}
|
||||
|
||||
|
||||
@@ -124,7 +124,7 @@ protected:
|
||||
|
||||
Mat_<out3d_t> _3dImg(disp.size());
|
||||
|
||||
CvMat cvdisp = disp; CvMat cv_3dImg = _3dImg; CvMat cvQ = Q;
|
||||
CvMat cvdisp = cvMat(disp); CvMat cv_3dImg = cvMat(_3dImg); CvMat cvQ = cvMat(Q);
|
||||
cvReprojectImageTo3D( &cvdisp, &cv_3dImg, &cvQ, handleMissingValues );
|
||||
|
||||
if (std::numeric_limits<OutT>::max() == std::numeric_limits<float>::max())
|
||||
|
||||
@@ -410,7 +410,7 @@ void CV_UndistortPointsTest::prepare_to_validation(int /*test_case_idx*/)
|
||||
{
|
||||
if (useDstMat)
|
||||
{
|
||||
CvMat temp = dst_points_mat;
|
||||
CvMat temp = cvMat(dst_points_mat);
|
||||
for (int i=0;i<N_POINTS*2;i++)
|
||||
{
|
||||
points[i] = temp.data.fl[i];
|
||||
@@ -469,14 +469,14 @@ void CV_UndistortPointsTest::run_func()
|
||||
}
|
||||
else
|
||||
{
|
||||
CvMat _input0 = test_mat[INPUT][0], _input1 = test_mat[INPUT][1], _input2, _input3, _input4;
|
||||
CvMat _output = test_mat[TEMP][0];
|
||||
CvMat _input0 = cvMat(test_mat[INPUT][0]), _input1 = cvMat(test_mat[INPUT][1]), _input2, _input3, _input4;
|
||||
CvMat _output = cvMat(test_mat[TEMP][0]);
|
||||
if(!zero_distortion)
|
||||
_input2 = test_mat[INPUT][2];
|
||||
_input2 = cvMat(test_mat[INPUT][2]);
|
||||
if(!zero_R)
|
||||
_input3 = test_mat[INPUT][3];
|
||||
_input3 = cvMat(test_mat[INPUT][3]);
|
||||
if(!zero_new_cam)
|
||||
_input4 = test_mat[INPUT][4];
|
||||
_input4 = cvMat(test_mat[INPUT][4]);
|
||||
cvUndistortPoints(&_input0, &_output, &_input1,
|
||||
zero_distortion ? 0 : &_input2,
|
||||
zero_R ? 0 : &_input3,
|
||||
@@ -853,10 +853,10 @@ void CV_InitUndistortRectifyMapTest::prepare_to_validation(int/* test_case_idx*/
|
||||
CvMat _new_cam = cvMat(test_mat[INPUT][4].rows,test_mat[INPUT][4].cols,CV_64F,new_cam);
|
||||
CvMat _points= cvMat(test_mat[INPUT][0].rows,test_mat[INPUT][0].cols,CV_64FC2,points);
|
||||
|
||||
CvMat _input1 = test_mat[INPUT][1];
|
||||
CvMat _input2 = test_mat[INPUT][2];
|
||||
CvMat _input3 = test_mat[INPUT][3];
|
||||
CvMat _input4 = test_mat[INPUT][4];
|
||||
CvMat _input1 = cvMat(test_mat[INPUT][1]);
|
||||
CvMat _input2 = cvMat(test_mat[INPUT][2]);
|
||||
CvMat _input3 = cvMat(test_mat[INPUT][3]);
|
||||
CvMat _input4 = cvMat(test_mat[INPUT][4]);
|
||||
|
||||
cvtest::convert(cvarrToMat(&_input1), cvarrToMat(&_camera), -1);
|
||||
cvtest::convert(cvarrToMat(&_input2), cvarrToMat(&_distort), -1);
|
||||
@@ -871,8 +871,8 @@ void CV_InitUndistortRectifyMapTest::prepare_to_validation(int/* test_case_idx*/
|
||||
}
|
||||
cv::Mat map1,map2;
|
||||
cv::convertMaps(mapx,mapy,map1,map2,CV_32FC1);
|
||||
CvMat _map1 = map1;
|
||||
CvMat _map2 = map2;
|
||||
CvMat _map1 = cvMat(map1);
|
||||
CvMat _map2 = cvMat(map2);
|
||||
for (int i=0;i<N_POINTS;i++)
|
||||
{
|
||||
double u = test_mat[INPUT][0].ptr<double>()[2*i];
|
||||
@@ -886,7 +886,7 @@ void CV_InitUndistortRectifyMapTest::prepare_to_validation(int/* test_case_idx*/
|
||||
cvUndistortPoints(&_points,&ref_points,&_camera,
|
||||
zero_distortion ? 0 : &_distort, zero_R ? 0 : &_rot, zero_new_cam ? &_camera : &_new_cam);
|
||||
//cvTsDistortPoints(&_points,&ref_points,&_camera,&_distort,&_rot,&_new_cam);
|
||||
CvMat dst = test_mat[REF_OUTPUT][0];
|
||||
CvMat dst = cvMat(test_mat[REF_OUTPUT][0]);
|
||||
cvtest::convert(cvarrToMat(&ref_points), cvarrToMat(&dst), -1);
|
||||
|
||||
cvtest::copy(test_mat[INPUT][0],test_mat[OUTPUT][0]);
|
||||
@@ -912,13 +912,13 @@ void CV_InitUndistortRectifyMapTest::run_func()
|
||||
}
|
||||
else
|
||||
{
|
||||
CvMat input1 = test_mat[INPUT][1], input2, input3, input4;
|
||||
CvMat input1 = cvMat(test_mat[INPUT][1]), input2, input3, input4;
|
||||
if( !zero_distortion )
|
||||
input2 = test_mat[INPUT][2];
|
||||
input2 = cvMat(test_mat[INPUT][2]);
|
||||
if( !zero_R )
|
||||
input3 = test_mat[INPUT][3];
|
||||
input3 = cvMat(test_mat[INPUT][3]);
|
||||
if( !zero_new_cam )
|
||||
input4 = test_mat[INPUT][4];
|
||||
input4 = cvMat(test_mat[INPUT][4]);
|
||||
cvInitUndistortRectifyMap(&input1,
|
||||
zero_distortion ? 0 : &input2,
|
||||
zero_R ? 0 : &input3,
|
||||
|
||||
Reference in New Issue
Block a user