1 /*M///////////////////////////////////////////////////////////////////////////////////////
2 //
3 // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
4 //
5 // By downloading, copying, installing or using the software you agree to this license.
6 // If you do not agree to this license, do not download, install,
7 // copy or use the software.
8 //
9 //
10 // Intel License Agreement
11 // For Open Source Computer Vision Library
12 //
13 // Copyright (C) 2000, Intel Corporation, all rights reserved.
14 // Third party copyrights are property of their respective owners.
15 //
16 // Redistribution and use in source and binary forms, with or without modification,
17 // are permitted provided that the following conditions are met:
18 //
19 // * Redistribution's of source code must retain the above copyright notice,
20 // this list of conditions and the following disclaimer.
21 //
22 // * Redistribution's in binary form must reproduce the above copyright notice,
23 // this list of conditions and the following disclaimer in the documentation
24 // and/or other materials provided with the distribution.
25 //
26 // * The name of Intel Corporation may not be used to endorse or promote products
27 // derived from this software without specific prior written permission.
28 //
29 // This software is provided by the copyright holders and contributors "as is" and
30 // any express or implied warranties, including, but not limited to, the implied
31 // warranties of merchantability and fitness for a particular purpose are disclaimed.
32 // In no event shall the Intel Corporation or contributors be liable for any direct,
33 // indirect, incidental, special, exemplary, or consequential damages
34 // (including, but not limited to, procurement of substitute goods or services;
35 // loss of use, data, or profits; or business interruption) however caused
36 // and on any theory of liability, whether in contract, strict liability,
37 // or tort (including negligence or otherwise) arising in any way out of
38 // the use of this software, even if advised of the possibility of such damage.
39 //
40 //M*/
41
42 #include "test_precomp.hpp"
43 #include "test_chessboardgenerator.hpp"
44 #include "opencv2/calib3d/calib3d_c.h"
45
46 #include <iostream>
47
48 using namespace cv;
49 using namespace std;
50
51 class CV_CameraCalibrationBadArgTest : public cvtest::BadArgTest
52 {
53 public:
CV_CameraCalibrationBadArgTest()54 CV_CameraCalibrationBadArgTest() : imgSize(800, 600) {}
~CV_CameraCalibrationBadArgTest()55 ~CV_CameraCalibrationBadArgTest() {}
56 protected:
57 void run(int);
run_func(void)58 void run_func(void) {}
59
60 const static int M = 1;
61
62 Size imgSize;
63 Size corSize;
64 Mat chessBoard;
65 Mat corners;
66
67 struct C_Caller
68 {
69 CvMat* objPts;
70 CvMat* imgPts;
71 CvMat* npoints;
72 Size imageSize;
73 CvMat *cameraMatrix;
74 CvMat *distCoeffs;
75 CvMat *rvecs;
76 CvMat *tvecs;
77 int flags;
78
operator ()CV_CameraCalibrationBadArgTest::C_Caller79 void operator()() const
80 {
81 cvCalibrateCamera2(objPts, imgPts, npoints, imageSize,
82 cameraMatrix, distCoeffs, rvecs, tvecs, flags );
83 }
84 };
85 };
86
87
run(int)88 void CV_CameraCalibrationBadArgTest::run( int /* start_from */ )
89 {
90 Mat_<float> camMat(3, 3);
91 Mat_<float> distCoeffs0(1, 5);
92
93 camMat << 300.f, 0.f, imgSize.width/2.f, 0, 300.f, imgSize.height/2.f, 0.f, 0.f, 1.f;
94 distCoeffs0 << 1.2f, 0.2f, 0.f, 0.f, 0.f;
95
96 ChessBoardGenerator cbg(Size(8,6));
97 corSize = cbg.cornersSize();
98 vector<Point2f> exp_corn;
99 chessBoard = cbg(Mat(imgSize, CV_8U, Scalar(0)), camMat, distCoeffs0, exp_corn);
100 Mat_<Point2f>(corSize.height, corSize.width, (Point2f*)&exp_corn[0]).copyTo(corners);
101
102 CvMat objPts, imgPts, npoints, cameraMatrix, distCoeffs, rvecs, tvecs;
103 Mat zeros(1, sizeof(CvMat), CV_8U, Scalar(0));
104
105 C_Caller caller, bad_caller;
106 caller.imageSize = imgSize;
107 caller.objPts = &objPts;
108 caller.imgPts = &imgPts;
109 caller.npoints = &npoints;
110 caller.cameraMatrix = &cameraMatrix;
111 caller.distCoeffs = &distCoeffs;
112 caller.rvecs = &rvecs;
113 caller.tvecs = &tvecs;
114
115 /////////////////////////////
116 Mat objPts_cpp;
117 Mat imgPts_cpp;
118 Mat npoints_cpp;
119 Mat cameraMatrix_cpp;
120 Mat distCoeffs_cpp;
121 Mat rvecs_cpp;
122 Mat tvecs_cpp;
123
124 objPts_cpp.create(corSize, CV_32FC3);
125 for(int j = 0; j < corSize.height; ++j)
126 for(int i = 0; i < corSize.width; ++i)
127 objPts_cpp.at<Point3f>(j, i) = Point3i(i, j, 0);
128 objPts_cpp = objPts_cpp.reshape(3, 1);
129
130 imgPts_cpp = corners.clone().reshape(2, 1);
131 npoints_cpp = Mat_<int>(M, 1, corSize.width * corSize.height);
132 cameraMatrix_cpp.create(3, 3, CV_32F);
133 distCoeffs_cpp.create(5, 1, CV_32F);
134 rvecs_cpp.create(M, 1, CV_32FC3);
135 tvecs_cpp.create(M, 1, CV_32FC3);
136
137 caller.flags = 0;
138 //CV_CALIB_USE_INTRINSIC_GUESS; //CV_CALIB_FIX_ASPECT_RATIO
139 //CV_CALIB_USE_INTRINSIC_GUESS //CV_CALIB_FIX_ASPECT_RATIO
140 //CV_CALIB_FIX_PRINCIPAL_POINT //CV_CALIB_ZERO_TANGENT_DIST
141 //CV_CALIB_FIX_FOCAL_LENGTH //CV_CALIB_FIX_K1 //CV_CALIB_FIX_K2 //CV_CALIB_FIX_K3
142
143 objPts = objPts_cpp;
144 imgPts = imgPts_cpp;
145 npoints = npoints_cpp;
146 cameraMatrix = cameraMatrix_cpp;
147 distCoeffs = distCoeffs_cpp;
148 rvecs = rvecs_cpp;
149 tvecs = tvecs_cpp;
150
151 /* /*//*/ */
152 int errors = 0;
153
154 bad_caller = caller;
155 bad_caller.objPts = 0;
156 errors += run_test_case( CV_StsBadArg, "Zero passed in objPts", bad_caller);
157
158 bad_caller = caller;
159 bad_caller.imgPts = 0;
160 errors += run_test_case( CV_StsBadArg, "Zero passed in imgPts", bad_caller );
161
162 bad_caller = caller;
163 bad_caller.npoints = 0;
164 errors += run_test_case( CV_StsBadArg, "Zero passed in npoints", bad_caller );
165
166 bad_caller = caller;
167 bad_caller.cameraMatrix = 0;
168 errors += run_test_case( CV_StsBadArg, "Zero passed in cameraMatrix", bad_caller );
169
170 bad_caller = caller;
171 bad_caller.distCoeffs = 0;
172 errors += run_test_case( CV_StsBadArg, "Zero passed in distCoeffs", bad_caller );
173
174 bad_caller = caller;
175 bad_caller.imageSize.width = -1;
176 errors += run_test_case( CV_StsOutOfRange, "Bad image width", bad_caller );
177
178 bad_caller = caller;
179 bad_caller.imageSize.height = -1;
180 errors += run_test_case( CV_StsOutOfRange, "Bad image height", bad_caller );
181
182 Mat bad_nts_cpp1 = Mat_<float>(M, 1, 1.f);
183 Mat bad_nts_cpp2 = Mat_<int>(3, 3, corSize.width * corSize.height);
184 CvMat bad_npts_c1 = bad_nts_cpp1;
185 CvMat bad_npts_c2 = bad_nts_cpp2;
186
187 bad_caller = caller;
188 bad_caller.npoints = &bad_npts_c1;
189 errors += run_test_case( CV_StsUnsupportedFormat, "Bad npoints format", bad_caller );
190
191 bad_caller = caller;
192 bad_caller.npoints = &bad_npts_c2;
193 errors += run_test_case( CV_StsUnsupportedFormat, "Bad npoints size", bad_caller );
194
195 bad_caller = caller;
196 bad_caller.rvecs = (CvMat*)zeros.ptr();
197 errors += run_test_case( CV_StsBadArg, "Bad rvecs header", bad_caller );
198
199 bad_caller = caller;
200 bad_caller.tvecs = (CvMat*)zeros.ptr();
201 errors += run_test_case( CV_StsBadArg, "Bad tvecs header", bad_caller );
202
203 Mat bad_rvecs_cpp1(M+1, 1, CV_32FC3); CvMat bad_rvecs_c1 = bad_rvecs_cpp1;
204 Mat bad_tvecs_cpp1(M+1, 1, CV_32FC3); CvMat bad_tvecs_c1 = bad_tvecs_cpp1;
205
206
207
208 Mat bad_rvecs_cpp2(M, 2, CV_32FC3); CvMat bad_rvecs_c2 = bad_rvecs_cpp2;
209 Mat bad_tvecs_cpp2(M, 2, CV_32FC3); CvMat bad_tvecs_c2 = bad_tvecs_cpp2;
210
211 bad_caller = caller;
212 bad_caller.rvecs = &bad_rvecs_c1;
213 errors += run_test_case( CV_StsBadArg, "Bad tvecs header", bad_caller );
214
215 bad_caller = caller;
216 bad_caller.rvecs = &bad_rvecs_c2;
217 errors += run_test_case( CV_StsBadArg, "Bad tvecs header", bad_caller );
218
219 bad_caller = caller;
220 bad_caller.tvecs = &bad_tvecs_c1;
221 errors += run_test_case( CV_StsBadArg, "Bad tvecs header", bad_caller );
222
223 bad_caller = caller;
224 bad_caller.tvecs = &bad_tvecs_c2;
225 errors += run_test_case( CV_StsBadArg, "Bad tvecs header", bad_caller );
226
227 Mat bad_cameraMatrix_cpp1(3, 3, CV_32S); CvMat bad_cameraMatrix_c1 = bad_cameraMatrix_cpp1;
228 Mat bad_cameraMatrix_cpp2(2, 3, CV_32F); CvMat bad_cameraMatrix_c2 = bad_cameraMatrix_cpp2;
229 Mat bad_cameraMatrix_cpp3(3, 2, CV_64F); CvMat bad_cameraMatrix_c3 = bad_cameraMatrix_cpp3;
230
231
232
233 bad_caller = caller;
234 bad_caller.cameraMatrix = &bad_cameraMatrix_c1;
235 errors += run_test_case( CV_StsBadArg, "Bad camearaMatrix header", bad_caller );
236
237 bad_caller = caller;
238 bad_caller.cameraMatrix = &bad_cameraMatrix_c2;
239 errors += run_test_case( CV_StsBadArg, "Bad camearaMatrix header", bad_caller );
240
241 bad_caller = caller;
242 bad_caller.cameraMatrix = &bad_cameraMatrix_c3;
243 errors += run_test_case( CV_StsBadArg, "Bad camearaMatrix header", bad_caller );
244
245 Mat bad_distCoeffs_cpp1(1, 5, CV_32S); CvMat bad_distCoeffs_c1 = bad_distCoeffs_cpp1;
246 Mat bad_distCoeffs_cpp2(2, 2, CV_64F); CvMat bad_distCoeffs_c2 = bad_distCoeffs_cpp2;
247 Mat bad_distCoeffs_cpp3(1, 6, CV_64F); CvMat bad_distCoeffs_c3 = bad_distCoeffs_cpp3;
248
249
250
251 bad_caller = caller;
252 bad_caller.distCoeffs = &bad_distCoeffs_c1;
253 errors += run_test_case( CV_StsBadArg, "Bad distCoeffs header", bad_caller );
254
255 bad_caller = caller;
256 bad_caller.distCoeffs = &bad_distCoeffs_c2;
257 errors += run_test_case( CV_StsBadArg, "Bad distCoeffs header", bad_caller );
258
259
260 bad_caller = caller;
261 bad_caller.distCoeffs = &bad_distCoeffs_c3;
262 errors += run_test_case( CV_StsBadArg, "Bad distCoeffs header", bad_caller );
263
264 double CM[] = {0, 0, 0, /**/0, 0, 0, /**/0, 0, 0};
265 Mat bad_cameraMatrix_cpp4(3, 3, CV_64F, CM); CvMat bad_cameraMatrix_c4 = bad_cameraMatrix_cpp4;
266
267 bad_caller = caller;
268 bad_caller.flags |= CV_CALIB_USE_INTRINSIC_GUESS;
269 bad_caller.cameraMatrix = &bad_cameraMatrix_c4;
270 CM[0] = 0; //bad fx
271 errors += run_test_case( CV_StsOutOfRange, "Bad camearaMatrix data", bad_caller );
272
273 CM[0] = 500; CM[4] = 0; //bad fy
274 errors += run_test_case( CV_StsOutOfRange, "Bad camearaMatrix data", bad_caller );
275
276 CM[0] = 500; CM[4] = 500; CM[2] = -1; //bad cx
277 errors += run_test_case( CV_StsOutOfRange, "Bad camearaMatrix data", bad_caller );
278
279 CM[0] = 500; CM[4] = 500; CM[2] = imgSize.width*2; //bad cx
280 errors += run_test_case( CV_StsOutOfRange, "Bad camearaMatrix data", bad_caller );
281
282 CM[0] = 500; CM[4] = 500; CM[2] = imgSize.width/2; CM[5] = -1; //bad cy
283 errors += run_test_case( CV_StsOutOfRange, "Bad camearaMatrix data", bad_caller );
284
285 CM[0] = 500; CM[4] = 500; CM[2] = imgSize.width/2; CM[5] = imgSize.height*2; //bad cy
286 errors += run_test_case( CV_StsOutOfRange, "Bad camearaMatrix data", bad_caller );
287
288 CM[0] = 500; CM[4] = 500; CM[2] = imgSize.width/2; CM[5] = imgSize.height/2;
289 CM[1] = 0.1; //Non-zero skew
290 errors += run_test_case( CV_StsOutOfRange, "Bad camearaMatrix data", bad_caller );
291
292 CM[1] = 0;
293 CM[3] = 0.1; /* mad matrix shape */
294 errors += run_test_case( CV_StsOutOfRange, "Bad camearaMatrix data", bad_caller );
295
296 CM[3] = 0; CM[6] = 0.1; /* mad matrix shape */
297 errors += run_test_case( CV_StsOutOfRange, "Bad camearaMatrix data", bad_caller );
298
299 CM[3] = 0; CM[6] = 0; CM[7] = 0.1; /* mad matrix shape */
300 errors += run_test_case( CV_StsOutOfRange, "Bad camearaMatrix data", bad_caller );
301
302 CM[3] = 0; CM[6] = 0; CM[7] = 0; CM[8] = 1.1; /* mad matrix shape */
303 errors += run_test_case( CV_StsOutOfRange, "Bad camearaMatrix data", bad_caller );
304 CM[8] = 1.0;
305
306 /////////////////////////////////////////////////////////////////////////////////////
307 bad_caller = caller;
308 Mat bad_objPts_cpp5 = objPts_cpp.clone(); CvMat bad_objPts_c5 = bad_objPts_cpp5;
309 bad_caller.objPts = &bad_objPts_c5;
310
311 cv::RNG& rng = theRNG();
312 for(int i = 0; i < bad_objPts_cpp5.rows; ++i)
313 bad_objPts_cpp5.at<Point3f>(0, i).z += ((float)rng - 0.5f);
314
315 errors += run_test_case( CV_StsBadArg, "Bad objPts data", bad_caller );
316
317 if (errors)
318 ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH);
319 else
320 ts->set_failed_test_info(cvtest::TS::OK);
321
322 //try { caller(); }
323 //catch (...)
324 //{
325 // ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH);
326 // printf("+!");
327 //}
328 }
329
330
331 class CV_Rodrigues2BadArgTest : public cvtest::BadArgTest
332 {
333 public:
CV_Rodrigues2BadArgTest()334 CV_Rodrigues2BadArgTest() {}
~CV_Rodrigues2BadArgTest()335 ~CV_Rodrigues2BadArgTest() {}
336 protected:
run_func(void)337 void run_func(void) {}
338
339 struct C_Caller
340 {
341 CvMat* src;
342 CvMat* dst;
343 CvMat* jacobian;
344
operator ()CV_Rodrigues2BadArgTest::C_Caller345 void operator()() { cvRodrigues2(src, dst, jacobian); }
346 };
347
run(int)348 void run(int /* start_from */ )
349 {
350 Mat zeros(1, sizeof(CvMat), CV_8U, Scalar(0));
351 CvMat src_c, dst_c, jacobian_c;
352
353 Mat src_cpp(3, 1, CV_32F); src_c = src_cpp;
354 Mat dst_cpp(3, 3, CV_32F); dst_c = dst_cpp;
355 Mat jacobian_cpp(3, 9, CV_32F); jacobian_c = jacobian_cpp;
356
357 C_Caller caller, bad_caller;
358 caller.src = &src_c;
359 caller.dst = &dst_c;
360 caller.jacobian = &jacobian_c;
361
362 /* try { caller(); }
363 catch (...)
364 {
365 printf("badasfas");
366 }*/
367
368 /*/*//*/*/
369 int errors = 0;
370
371 bad_caller = caller;
372 bad_caller.src = 0;
373 errors += run_test_case( CV_StsNullPtr, "Src is zero pointer", bad_caller );
374
375 bad_caller = caller;
376 bad_caller.dst = 0;
377 errors += run_test_case( CV_StsNullPtr, "Dst is zero pointer", bad_caller );
378
379 Mat bad_src_cpp1(3, 1, CV_8U); CvMat bad_src_c1 = bad_src_cpp1;
380 Mat bad_dst_cpp1(3, 1, CV_8U); CvMat bad_dst_c1 = bad_dst_cpp1;
381 Mat bad_jac_cpp1(3, 1, CV_8U); CvMat bad_jac_c1 = bad_jac_cpp1;
382 Mat bad_jac_cpp2(3, 1, CV_32FC2); CvMat bad_jac_c2 = bad_jac_cpp2;
383 Mat bad_jac_cpp3(3, 1, CV_32F); CvMat bad_jac_c3 = bad_jac_cpp3;
384
385 bad_caller = caller;
386 bad_caller.src = &bad_src_c1;
387 errors += run_test_case( CV_StsUnsupportedFormat, "Bad src formart", bad_caller );
388
389 bad_caller = caller;
390 bad_caller.dst = &bad_dst_c1;
391 errors += run_test_case( CV_StsUnmatchedFormats, "Bad dst formart", bad_caller );
392
393 bad_caller = caller;
394 bad_caller.jacobian = (CvMat*)zeros.ptr();
395 errors += run_test_case( CV_StsBadArg, "Bad jacobian ", bad_caller );
396
397 bad_caller = caller;
398 bad_caller.jacobian = &bad_jac_c1;
399 errors += run_test_case( CV_StsUnmatchedFormats, "Bad jacobian format", bad_caller );
400
401 bad_caller = caller;
402 bad_caller.jacobian = &bad_jac_c2;
403 errors += run_test_case( CV_StsUnmatchedFormats, "Bad jacobian format", bad_caller );
404
405 bad_caller = caller;
406 bad_caller.jacobian = &bad_jac_c3;
407 errors += run_test_case( CV_StsBadSize, "Bad jacobian format", bad_caller );
408
409 Mat bad_src_cpp2(1, 1, CV_32F); CvMat bad_src_c2 = bad_src_cpp2;
410
411 bad_caller = caller;
412 bad_caller.src = &bad_src_c2;
413 errors += run_test_case( CV_StsBadSize, "Bad src format", bad_caller );
414
415 Mat bad_dst_cpp2(2, 1, CV_32F); CvMat bad_dst_c2 = bad_dst_cpp2;
416 Mat bad_dst_cpp3(3, 2, CV_32F); CvMat bad_dst_c3 = bad_dst_cpp3;
417 Mat bad_dst_cpp4(3, 3, CV_32FC2); CvMat bad_dst_c4 = bad_dst_cpp4;
418
419 bad_caller = caller;
420 bad_caller.dst = &bad_dst_c2;
421 errors += run_test_case( CV_StsBadSize, "Bad dst format", bad_caller );
422
423 bad_caller = caller;
424 bad_caller.dst = &bad_dst_c3;
425 errors += run_test_case( CV_StsBadSize, "Bad dst format", bad_caller );
426
427 bad_caller = caller;
428 bad_caller.dst = &bad_dst_c4;
429 errors += run_test_case( CV_StsBadSize, "Bad dst format", bad_caller );
430
431
432 /********/
433 src_cpp.create(3, 3, CV_32F); src_c = src_cpp;
434 dst_cpp.create(3, 1, CV_32F); dst_c = dst_cpp;
435
436
437 Mat bad_dst_cpp5(5, 5, CV_32F); CvMat bad_dst_c5 = bad_dst_cpp5;
438
439 bad_caller = caller;
440 bad_caller.dst = &bad_dst_c5;
441 errors += run_test_case( CV_StsBadSize, "Bad dst format", bad_caller );
442
443
444 if (errors)
445 ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH);
446 else
447 ts->set_failed_test_info(cvtest::TS::OK);
448 }
449 };
450
451
452 //////////////////////////////////////////////////////////////////////////////////
453 //////////////////////////////////////////////////////////////////////////////////
454 class CV_ProjectPoints2BadArgTest : public cvtest::BadArgTest
455 {
456 public:
CV_ProjectPoints2BadArgTest()457 CV_ProjectPoints2BadArgTest() : camMat(3, 3), distCoeffs(1, 5)
458 {
459 Size imsSize(800, 600);
460 camMat << 300.f, 0.f, imsSize.width/2.f, 0, 300.f, imsSize.height/2.f, 0.f, 0.f, 1.f;
461 distCoeffs << 1.2f, 0.2f, 0.f, 0.f, 0.f;
462 }
~CV_ProjectPoints2BadArgTest()463 ~CV_ProjectPoints2BadArgTest() {}
464 protected:
run_func(void)465 void run_func(void) {}
466
467 Mat_<float> camMat;
468 Mat_<float> distCoeffs;
469
470 struct C_Caller
471 {
472 CvMat* objectPoints;
473 CvMat* r_vec;
474 CvMat* t_vec;
475 CvMat* A;
476 CvMat* distCoeffs;
477 CvMat* imagePoints;
478 CvMat* dpdr;
479 CvMat* dpdt;
480 CvMat* dpdf;
481 CvMat* dpdc;
482 CvMat* dpdk;
483 double aspectRatio;
484
operator ()CV_ProjectPoints2BadArgTest::C_Caller485 void operator()()
486 {
487 cvProjectPoints2( objectPoints, r_vec, t_vec, A, distCoeffs, imagePoints,
488 dpdr, dpdt, dpdf, dpdc, dpdk, aspectRatio );
489 }
490 };
491
run(int)492 void run(int /* start_from */ )
493 {
494 CvMat zeros;
495 memset(&zeros, 0, sizeof(zeros));
496
497 C_Caller caller, bad_caller;
498 CvMat objectPoints_c, r_vec_c, t_vec_c, A_c, distCoeffs_c, imagePoints_c,
499 dpdr_c, dpdt_c, dpdf_c, dpdc_c, dpdk_c;
500
501 const int n = 10;
502
503 Mat imagePoints_cpp(1, n, CV_32FC2); imagePoints_c = imagePoints_cpp;
504
505 Mat objectPoints_cpp(1, n, CV_32FC3);
506 randu(objectPoints_cpp, Scalar::all(1), Scalar::all(10));
507 objectPoints_c = objectPoints_cpp;
508
509 Mat t_vec_cpp(Mat::zeros(1, 3, CV_32F)); t_vec_c = t_vec_cpp;
510 Mat r_vec_cpp;
511 Rodrigues(Mat::eye(3, 3, CV_32F), r_vec_cpp); r_vec_c = r_vec_cpp;
512
513 Mat A_cpp = camMat.clone(); A_c = A_cpp;
514 Mat distCoeffs_cpp = distCoeffs.clone(); distCoeffs_c = distCoeffs_cpp;
515
516 Mat dpdr_cpp(2*n, 3, CV_32F); dpdr_c = dpdr_cpp;
517 Mat dpdt_cpp(2*n, 3, CV_32F); dpdt_c = dpdt_cpp;
518 Mat dpdf_cpp(2*n, 2, CV_32F); dpdf_c = dpdf_cpp;
519 Mat dpdc_cpp(2*n, 2, CV_32F); dpdc_c = dpdc_cpp;
520 Mat dpdk_cpp(2*n, 4, CV_32F); dpdk_c = dpdk_cpp;
521
522 caller.aspectRatio = 1.0;
523 caller.objectPoints = &objectPoints_c;
524 caller.r_vec = &r_vec_c;
525 caller.t_vec = &t_vec_c;
526 caller.A = &A_c;
527 caller.distCoeffs = &distCoeffs_c;
528 caller.imagePoints = &imagePoints_c;
529 caller.dpdr = &dpdr_c;
530 caller.dpdt = &dpdt_c;
531 caller.dpdf = &dpdf_c;
532 caller.dpdc = &dpdc_c;
533 caller.dpdk = &dpdk_c;
534
535 /********************/
536 int errors = 0;
537
538
539 bad_caller = caller;
540 bad_caller.objectPoints = 0;
541 errors += run_test_case( CV_StsBadArg, "Zero objectPoints", bad_caller );
542
543 bad_caller = caller;
544 bad_caller.r_vec = 0;
545 errors += run_test_case( CV_StsBadArg, "Zero r_vec", bad_caller );
546
547 bad_caller = caller;
548 bad_caller.t_vec = 0;
549 errors += run_test_case( CV_StsBadArg, "Zero t_vec", bad_caller );
550
551 bad_caller = caller;
552 bad_caller.A = 0;
553 errors += run_test_case( CV_StsBadArg, "Zero camMat", bad_caller );
554
555 bad_caller = caller;
556 bad_caller.imagePoints = 0;
557 errors += run_test_case( CV_StsBadArg, "Zero imagePoints", bad_caller );
558
559 /****************************/
560 Mat bad_r_vec_cpp1(r_vec_cpp.size(), CV_32S); CvMat bad_r_vec_c1 = bad_r_vec_cpp1;
561 Mat bad_r_vec_cpp2(2, 2, CV_32F); CvMat bad_r_vec_c2 = bad_r_vec_cpp2;
562 Mat bad_r_vec_cpp3(r_vec_cpp.size(), CV_32FC2); CvMat bad_r_vec_c3 = bad_r_vec_cpp3;
563
564 bad_caller = caller;
565 bad_caller.r_vec = &bad_r_vec_c1;
566 errors += run_test_case( CV_StsBadArg, "Bad rvec format", bad_caller );
567
568 bad_caller = caller;
569 bad_caller.r_vec = &bad_r_vec_c2;
570 errors += run_test_case( CV_StsBadArg, "Bad rvec format", bad_caller );
571
572 bad_caller = caller;
573 bad_caller.r_vec = &bad_r_vec_c3;
574 errors += run_test_case( CV_StsBadArg, "Bad rvec format", bad_caller );
575
576 /****************************/
577 Mat bad_t_vec_cpp1(t_vec_cpp.size(), CV_32S); CvMat bad_t_vec_c1 = bad_t_vec_cpp1;
578 Mat bad_t_vec_cpp2(2, 2, CV_32F); CvMat bad_t_vec_c2 = bad_t_vec_cpp2;
579 Mat bad_t_vec_cpp3(1, 1, CV_32FC2); CvMat bad_t_vec_c3 = bad_t_vec_cpp3;
580
581 bad_caller = caller;
582 bad_caller.t_vec = &bad_t_vec_c1;
583 errors += run_test_case( CV_StsBadArg, "Bad tvec format", bad_caller );
584
585 bad_caller = caller;
586 bad_caller.t_vec = &bad_t_vec_c2;
587 errors += run_test_case( CV_StsBadArg, "Bad tvec format", bad_caller );
588
589 bad_caller = caller;
590 bad_caller.t_vec = &bad_t_vec_c3;
591 errors += run_test_case( CV_StsBadArg, "Bad tvec format", bad_caller );
592
593 /****************************/
594 Mat bad_A_cpp1(A_cpp.size(), CV_32S); CvMat bad_A_c1 = bad_A_cpp1;
595 Mat bad_A_cpp2(2, 2, CV_32F); CvMat bad_A_c2 = bad_A_cpp2;
596
597 bad_caller = caller;
598 bad_caller.A = &bad_A_c1;
599 errors += run_test_case( CV_StsBadArg, "Bad A format", bad_caller );
600
601 bad_caller = caller;
602 bad_caller.A = &bad_A_c2;
603 errors += run_test_case( CV_StsBadArg, "Bad A format", bad_caller );
604
605 /****************************/
606 Mat bad_distCoeffs_cpp1(distCoeffs_cpp.size(), CV_32S); CvMat bad_distCoeffs_c1 = bad_distCoeffs_cpp1;
607 Mat bad_distCoeffs_cpp2(2, 2, CV_32F); CvMat bad_distCoeffs_c2 = bad_distCoeffs_cpp2;
608 Mat bad_distCoeffs_cpp3(1, 7, CV_32F); CvMat bad_distCoeffs_c3 = bad_distCoeffs_cpp3;
609
610 bad_caller = caller;
611 bad_caller.distCoeffs = &zeros;
612 errors += run_test_case( CV_StsBadArg, "Bad distCoeffs format", bad_caller );
613
614 bad_caller = caller;
615 bad_caller.distCoeffs = &bad_distCoeffs_c1;
616 errors += run_test_case( CV_StsBadArg, "Bad distCoeffs format", bad_caller );
617
618 bad_caller = caller;
619 bad_caller.distCoeffs = &bad_distCoeffs_c2;
620 errors += run_test_case( CV_StsBadArg, "Bad distCoeffs format", bad_caller );
621
622 bad_caller = caller;
623 bad_caller.distCoeffs = &bad_distCoeffs_c3;
624 errors += run_test_case( CV_StsBadArg, "Bad distCoeffs format", bad_caller );
625
626
627 /****************************/
628 Mat bad_dpdr_cpp1(dpdr_cpp.size(), CV_32S); CvMat bad_dpdr_c1 = bad_dpdr_cpp1;
629 Mat bad_dpdr_cpp2(dpdr_cpp.cols+1, 3, CV_32F); CvMat bad_dpdr_c2 = bad_dpdr_cpp2;
630 Mat bad_dpdr_cpp3(dpdr_cpp.cols, 7, CV_32F); CvMat bad_dpdr_c3 = bad_dpdr_cpp3;
631
632 bad_caller = caller;
633 bad_caller.dpdr = &zeros;
634 errors += run_test_case( CV_StsBadArg, "Bad dpdr format", bad_caller );
635
636 bad_caller = caller;
637 bad_caller.dpdr = &bad_dpdr_c1;
638 errors += run_test_case( CV_StsBadArg, "Bad dpdr format", bad_caller );
639
640 bad_caller = caller;
641 bad_caller.dpdr = &bad_dpdr_c2;
642 errors += run_test_case( CV_StsBadArg, "Bad dpdr format", bad_caller );
643
644 bad_caller = caller;
645 bad_caller.dpdr = &bad_dpdr_c3;
646 errors += run_test_case( CV_StsBadArg, "Bad dpdr format", bad_caller );
647
648 /****************************/
649
650 bad_caller = caller;
651 bad_caller.dpdt = &zeros;
652 errors += run_test_case( CV_StsBadArg, "Bad dpdt format", bad_caller );
653
654 bad_caller = caller;
655 bad_caller.dpdt = &bad_dpdr_c1;
656 errors += run_test_case( CV_StsBadArg, "Bad dpdt format", bad_caller );
657
658 bad_caller = caller;
659 bad_caller.dpdt = &bad_dpdr_c2;
660 errors += run_test_case( CV_StsBadArg, "Bad dpdt format", bad_caller );
661
662 bad_caller = caller;
663 bad_caller.dpdt = &bad_dpdr_c3;
664 errors += run_test_case( CV_StsBadArg, "Bad dpdt format", bad_caller );
665
666 /****************************/
667
668 Mat bad_dpdf_cpp2(dpdr_cpp.cols+1, 2, CV_32F); CvMat bad_dpdf_c2 = bad_dpdf_cpp2;
669
670 bad_caller = caller;
671 bad_caller.dpdf = &zeros;
672 errors += run_test_case( CV_StsBadArg, "Bad dpdf format", bad_caller );
673
674 bad_caller = caller;
675 bad_caller.dpdf = &bad_dpdr_c1;
676 errors += run_test_case( CV_StsBadArg, "Bad dpdf format", bad_caller );
677
678 bad_caller = caller;
679 bad_caller.dpdf = &bad_dpdf_c2;
680 errors += run_test_case( CV_StsBadArg, "Bad dpdf format", bad_caller );
681
682 bad_caller = caller;
683 bad_caller.dpdf = &bad_dpdr_c3;
684 errors += run_test_case( CV_StsBadArg, "Bad dpdf format", bad_caller );
685
686 /****************************/
687
688 bad_caller = caller;
689 bad_caller.dpdc = &zeros;
690 errors += run_test_case( CV_StsBadArg, "Bad dpdc format", bad_caller );
691
692 bad_caller = caller;
693 bad_caller.dpdc = &bad_dpdr_c1;
694 errors += run_test_case( CV_StsBadArg, "Bad dpdc format", bad_caller );
695
696 bad_caller = caller;
697 bad_caller.dpdc = &bad_dpdf_c2;
698 errors += run_test_case( CV_StsBadArg, "Bad dpdc format", bad_caller );
699
700 bad_caller = caller;
701 bad_caller.dpdc = &bad_dpdr_c3;
702 errors += run_test_case( CV_StsBadArg, "Bad dpdc format", bad_caller );
703
704 /****************************/
705
706 bad_caller = caller;
707 bad_caller.dpdk = &zeros;
708 errors += run_test_case( CV_StsBadArg, "Bad dpdk format", bad_caller );
709
710 bad_caller = caller;
711 bad_caller.dpdk = &bad_dpdr_c1;
712 errors += run_test_case( CV_StsBadArg, "Bad dpdk format", bad_caller );
713
714 bad_caller = caller;
715 bad_caller.dpdk = &bad_dpdf_c2;
716 errors += run_test_case( CV_StsBadArg, "Bad dpdk format", bad_caller );
717
718 bad_caller = caller;
719 bad_caller.dpdk = &bad_dpdr_c3;
720 errors += run_test_case( CV_StsBadArg, "Bad dpdk format", bad_caller );
721
722 bad_caller = caller;
723 bad_caller.distCoeffs = 0;
724 errors += run_test_case( CV_StsNullPtr, "distCoeffs is NULL while dpdk is not", bad_caller );
725
726
727 if (errors)
728 ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH);
729 else
730 ts->set_failed_test_info(cvtest::TS::OK);
731 }
732 };
733
734
TEST(Calib3d_CalibrateCamera_C,badarg)735 TEST(Calib3d_CalibrateCamera_C, badarg) { CV_CameraCalibrationBadArgTest test; test.safe_run(); }
TEST(Calib3d_Rodrigues_C,badarg)736 TEST(Calib3d_Rodrigues_C, badarg) { CV_Rodrigues2BadArgTest test; test.safe_run(); }
TEST(Calib3d_ProjectPoints_C,badarg)737 TEST(Calib3d_ProjectPoints_C, badarg) { CV_ProjectPoints2BadArgTest test; test.safe_run(); }
738