CoCalc -- test_cameracalibration

GitHub Repository: Tetragramm/opencv
Path: blob/master/modules/calib3d/test/test_cameracalibration_badarg.cpp
¹⁶³³⁷ views
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
namespace opencv_test { namespace {
47

48
class CV_CameraCalibrationBadArgTest : public cvtest::BadArgTest
49
{
50
public:
51
    CV_CameraCalibrationBadArgTest() : imgSize(800, 600) {}
52
    ~CV_CameraCalibrationBadArgTest() {}
53
protected:
54
    void run(int);
55
    void run_func(void) {}
56

57
    const static int M = 2;
58

59
    Size imgSize;
60
    Size corSize;
61
    Mat chessBoard;
62
    Mat corners;
63

64
    struct C_Caller
65
    {
66
        CvMat* objPts;
67
        CvMat* imgPts;
68
        CvMat* npoints;
69
        Size imageSize;
70
        int iFixedPoint;
71
        CvMat *cameraMatrix;
72
        CvMat *distCoeffs;
73
        CvMat *rvecs;
74
        CvMat *tvecs;
75
        CvMat *newObjPts;
76
        int flags;
77

78
        void operator()() const
79
        {
80
            cvCalibrateCamera4(objPts, imgPts, npoints, cvSize(imageSize), iFixedPoint,
81
                cameraMatrix, distCoeffs, rvecs, tvecs, newObjPts, flags );
82
        }
83
    };
84
};
85

86

87
void CV_CameraCalibrationBadArgTest::run( int /* start_from */ )
88
{
89
    Mat_<float> camMat(3, 3);
90
    Mat_<float> distCoeffs0(1, 5);
91

92
    camMat << 300.f, 0.f, imgSize.width/2.f, 0, 300.f, imgSize.height/2.f, 0.f, 0.f, 1.f;
93
    distCoeffs0 << 1.2f, 0.2f, 0.f, 0.f, 0.f;
94

95
    ChessBoardGenerator cbg(Size(8,6));
96
    corSize = cbg.cornersSize();
97
    vector<Point2f> exp_corn;
98
    chessBoard = cbg(Mat(imgSize, CV_8U, Scalar(0)), camMat, distCoeffs0, exp_corn);
99
    Mat_<Point2f>(corSize.height, corSize.width, (Point2f*)&exp_corn[0]).copyTo(corners);
100

101
    CvMat objPts, imgPts, npoints, cameraMatrix, distCoeffs, rvecs, tvecs;
102
    CvMat newObjPts;
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
    caller.newObjPts = &newObjPts;
115

116
    /////////////////////////////
117
    Mat objPts_cpp;
118
    Mat imgPts_cpp;
119
    Mat npoints_cpp;
120
    Mat cameraMatrix_cpp;
121
    Mat distCoeffs_cpp;
122
    Mat rvecs_cpp;
123
    Mat tvecs_cpp;
124
    Mat newObjPts_cpp;
125

126
    objPts_cpp.create(corSize, CV_32FC3);
127
    for(int j = 0; j < corSize.height; ++j)
128
        for(int i = 0; i < corSize.width; ++i)
129
            objPts_cpp.at<Point3f>(j, i) = Point3i(i, j, 0);
130
    objPts_cpp = objPts_cpp.reshape(3, 1);
131
    Mat objPts_cpp_all(1, objPts_cpp.cols * M, CV_32FC3);
132
    for(int i = 0; i < M; i++)
133
        objPts_cpp.copyTo(objPts_cpp_all.colRange(objPts_cpp.cols * i, objPts_cpp.cols * (i + 1)));
134
    objPts_cpp = objPts_cpp_all;
135

136
    caller.iFixedPoint = -1;
137

138
    imgPts_cpp = corners.clone().reshape(2, 1);
139
    Mat imgPts_cpp_all(1, imgPts_cpp.cols * M, CV_32FC2);
140
    for(int i = 0; i < M; i++)
141
        imgPts_cpp.copyTo(imgPts_cpp_all.colRange(imgPts_cpp.cols * i, imgPts_cpp.cols * (i + 1)));
142
    imgPts_cpp = imgPts_cpp_all;
143
    npoints_cpp = Mat_<int>(M, 1, corSize.width * corSize.height);
144
    cameraMatrix_cpp.create(3, 3, CV_32F);
145
    distCoeffs_cpp.create(5, 1, CV_32F);
146
    rvecs_cpp.create(M, 1, CV_32FC3);
147
    tvecs_cpp.create(M, 1, CV_32FC3);
148
    newObjPts_cpp.create(corSize.width * corSize.height, 1, CV_32FC3);
149

150
    caller.flags = 0;
151
    //CV_CALIB_USE_INTRINSIC_GUESS;    //CV_CALIB_FIX_ASPECT_RATIO
152
    //CV_CALIB_USE_INTRINSIC_GUESS    //CV_CALIB_FIX_ASPECT_RATIO
153
    //CV_CALIB_FIX_PRINCIPAL_POINT    //CV_CALIB_ZERO_TANGENT_DIST
154
    //CV_CALIB_FIX_FOCAL_LENGTH    //CV_CALIB_FIX_K1    //CV_CALIB_FIX_K2    //CV_CALIB_FIX_K3
155

156
    objPts = cvMat(objPts_cpp);
157
    imgPts = cvMat(imgPts_cpp);
158
    npoints = cvMat(npoints_cpp);
159
    cameraMatrix = cvMat(cameraMatrix_cpp);
160
    distCoeffs = cvMat(distCoeffs_cpp);
161
    rvecs = cvMat(rvecs_cpp);
162
    tvecs = cvMat(tvecs_cpp);
163
    newObjPts = cvMat(newObjPts_cpp);
164

165
    /* /*//*/ */
166
    int errors = 0;
167

168
    bad_caller = caller;
169
    bad_caller.objPts = 0;
170
    errors += run_test_case( CV_StsBadArg, "Zero passed in objPts", bad_caller);
171

172
    bad_caller = caller;
173
    bad_caller.imgPts = 0;
174
    errors += run_test_case( CV_StsBadArg, "Zero passed in imgPts", bad_caller );
175

176
    bad_caller = caller;
177
    bad_caller.npoints = 0;
178
    errors += run_test_case( CV_StsBadArg, "Zero passed in npoints", bad_caller );
179

180
    bad_caller = caller;
181
    bad_caller.cameraMatrix = 0;
182
    errors += run_test_case( CV_StsBadArg, "Zero passed in cameraMatrix", bad_caller );
183

184
    bad_caller = caller;
185
    bad_caller.distCoeffs = 0;
186
    errors += run_test_case( CV_StsBadArg, "Zero passed in distCoeffs", bad_caller );
187

188
    bad_caller = caller;
189
    bad_caller.imageSize.width = -1;
190
    errors += run_test_case( CV_StsOutOfRange, "Bad image width", bad_caller );
191

192
    bad_caller = caller;
193
    bad_caller.imageSize.height = -1;
194
    errors += run_test_case( CV_StsOutOfRange, "Bad image height", bad_caller );
195

196
    Mat bad_nts_cpp1 = Mat_<float>(M, 1, 1.f);
197
    Mat bad_nts_cpp2 = Mat_<int>(3, 3, corSize.width * corSize.height);
198
    CvMat bad_npts_c1 = cvMat(bad_nts_cpp1);
199
    CvMat bad_npts_c2 = cvMat(bad_nts_cpp2);
200

201
    bad_caller = caller;
202
    bad_caller.npoints = &bad_npts_c1;
203
    errors += run_test_case( CV_StsUnsupportedFormat, "Bad npoints format", bad_caller );
204

205
    bad_caller = caller;
206
    bad_caller.npoints = &bad_npts_c2;
207
    errors += run_test_case( CV_StsUnsupportedFormat, "Bad npoints size", bad_caller );
208

209
    bad_caller = caller;
210
    bad_caller.rvecs = (CvMat*)zeros.ptr();
211
    errors += run_test_case( CV_StsBadArg, "Bad rvecs header", bad_caller );
212

213
    bad_caller = caller;
214
    bad_caller.tvecs = (CvMat*)zeros.ptr();
215
    errors += run_test_case( CV_StsBadArg, "Bad tvecs header", bad_caller );
216

217
    bad_caller = caller;
218
    bad_caller.newObjPts = (CvMat*)zeros.ptr();
219
    errors += run_test_case( CV_StsBadArg, "Bad newObjPts header", bad_caller );
220

221
    Mat bad_rvecs_cpp1(M+1, 1, CV_32FC3); CvMat bad_rvecs_c1 = cvMat(bad_rvecs_cpp1);
222
    Mat bad_tvecs_cpp1(M+1, 1, CV_32FC3); CvMat bad_tvecs_c1 = cvMat(bad_tvecs_cpp1);
223

224

225

226
    Mat bad_rvecs_cpp2(M, 2, CV_32FC3); CvMat bad_rvecs_c2 = cvMat(bad_rvecs_cpp2);
227
    Mat bad_tvecs_cpp2(M, 2, CV_32FC3); CvMat bad_tvecs_c2 = cvMat(bad_tvecs_cpp2);
228

229
    bad_caller = caller;
230
    bad_caller.rvecs = &bad_rvecs_c1;
231
    errors += run_test_case( CV_StsBadArg, "Bad rvecs header", bad_caller );
232

233
    bad_caller = caller;
234
    bad_caller.rvecs = &bad_rvecs_c2;
235
    errors += run_test_case( CV_StsBadArg, "Bad rvecs header", bad_caller );
236

237
    bad_caller = caller;
238
    bad_caller.tvecs = &bad_tvecs_c1;
239
    errors += run_test_case( CV_StsBadArg, "Bad tvecs header", bad_caller );
240

241
    bad_caller = caller;
242
    bad_caller.tvecs = &bad_tvecs_c2;
243
    errors += run_test_case( CV_StsBadArg, "Bad tvecs header", bad_caller );
244

245
    bad_caller = caller;
246
    bad_caller.newObjPts = &bad_tvecs_c1;
247
    errors += run_test_case( CV_StsBadArg, "Bad newObjPts header", bad_caller );
248

249
    bad_caller = caller;
250
    bad_caller.newObjPts = &bad_tvecs_c2;
251
    errors += run_test_case( CV_StsBadArg, "Bad newObjPts header", bad_caller );
252

253
    Mat bad_cameraMatrix_cpp1(3, 3, CV_32S); CvMat bad_cameraMatrix_c1 = cvMat(bad_cameraMatrix_cpp1);
254
    Mat bad_cameraMatrix_cpp2(2, 3, CV_32F); CvMat bad_cameraMatrix_c2 = cvMat(bad_cameraMatrix_cpp2);
255
    Mat bad_cameraMatrix_cpp3(3, 2, CV_64F); CvMat bad_cameraMatrix_c3 = cvMat(bad_cameraMatrix_cpp3);
256

257

258

259
    bad_caller = caller;
260
    bad_caller.cameraMatrix = &bad_cameraMatrix_c1;
261
    errors += run_test_case( CV_StsBadArg, "Bad camearaMatrix header", bad_caller );
262

263
    bad_caller = caller;
264
    bad_caller.cameraMatrix = &bad_cameraMatrix_c2;
265
    errors += run_test_case( CV_StsBadArg, "Bad camearaMatrix header", bad_caller );
266

267
    bad_caller = caller;
268
    bad_caller.cameraMatrix = &bad_cameraMatrix_c3;
269
    errors += run_test_case( CV_StsBadArg, "Bad camearaMatrix header", bad_caller );
270

271
    Mat bad_distCoeffs_cpp1(1, 5, CV_32S); CvMat bad_distCoeffs_c1 = cvMat(bad_distCoeffs_cpp1);
272
    Mat bad_distCoeffs_cpp2(2, 2, CV_64F); CvMat bad_distCoeffs_c2 = cvMat(bad_distCoeffs_cpp2);
273
    Mat bad_distCoeffs_cpp3(1, 6, CV_64F); CvMat bad_distCoeffs_c3 = cvMat(bad_distCoeffs_cpp3);
274

275

276

277
    bad_caller = caller;
278
    bad_caller.distCoeffs = &bad_distCoeffs_c1;
279
    errors += run_test_case( CV_StsBadArg, "Bad distCoeffs header", bad_caller );
280

281
    bad_caller = caller;
282
    bad_caller.distCoeffs = &bad_distCoeffs_c2;
283
    errors += run_test_case( CV_StsBadArg, "Bad distCoeffs header", bad_caller );
284

285

286
    bad_caller = caller;
287
    bad_caller.distCoeffs = &bad_distCoeffs_c3;
288
    errors += run_test_case( CV_StsBadArg, "Bad distCoeffs header", bad_caller );
289

290
    double CM[] = {0, 0, 0, /**/0, 0, 0, /**/0, 0, 0};
291
    Mat bad_cameraMatrix_cpp4(3, 3, CV_64F, CM); CvMat bad_cameraMatrix_c4 = cvMat(bad_cameraMatrix_cpp4);
292

293
    bad_caller = caller;
294
    bad_caller.flags |= CV_CALIB_USE_INTRINSIC_GUESS;
295
    bad_caller.cameraMatrix = &bad_cameraMatrix_c4;
296
    CM[0] = 0; //bad fx
297
    errors += run_test_case( CV_StsOutOfRange, "Bad camearaMatrix data", bad_caller );
298

299
    CM[0] = 500; CM[4] = 0;  //bad fy
300
    errors += run_test_case( CV_StsOutOfRange, "Bad camearaMatrix data", bad_caller );
301

302
    CM[0] = 500; CM[4] = 500; CM[2] = -1; //bad cx
303
    errors += run_test_case( CV_StsOutOfRange, "Bad camearaMatrix data", bad_caller );
304

305
    CM[0] = 500; CM[4] = 500; CM[2] = imgSize.width*2; //bad cx
306
    errors += run_test_case( CV_StsOutOfRange, "Bad camearaMatrix data", bad_caller );
307

308
    CM[0] = 500; CM[4] = 500; CM[2] = imgSize.width/2;  CM[5] = -1; //bad cy
309
    errors += run_test_case( CV_StsOutOfRange, "Bad camearaMatrix data", bad_caller );
310

311
    CM[0] = 500; CM[4] = 500; CM[2] = imgSize.width/2;  CM[5] = imgSize.height*2; //bad cy
312
    errors += run_test_case( CV_StsOutOfRange, "Bad camearaMatrix data", bad_caller );
313

314
    CM[0] = 500; CM[4] = 500; CM[2] = imgSize.width/2; CM[5] = imgSize.height/2;
315
    CM[1] = 0.1; //Non-zero skew
316
    errors += run_test_case( CV_StsOutOfRange, "Bad camearaMatrix data", bad_caller );
317

318
    CM[1] = 0;
319
    CM[3] = 0.1; /* mad matrix shape */
320
    errors += run_test_case( CV_StsOutOfRange, "Bad camearaMatrix data", bad_caller );
321

322
    CM[3] = 0; CM[6] = 0.1; /* mad matrix shape */
323
    errors += run_test_case( CV_StsOutOfRange, "Bad camearaMatrix data", bad_caller );
324

325
    CM[3] = 0; CM[6] = 0; CM[7] = 0.1; /* mad matrix shape */
326
    errors += run_test_case( CV_StsOutOfRange, "Bad camearaMatrix data", bad_caller );
327

328
    CM[3] = 0; CM[6] = 0; CM[7] = 0; CM[8] = 1.1; /* mad matrix shape */
329
    errors += run_test_case( CV_StsOutOfRange, "Bad camearaMatrix data", bad_caller );
330
    CM[8] = 1.0;
331

332
    /////////////////////////////////////////////////////////////////////////////////////
333
    bad_caller = caller;
334
    Mat bad_objPts_cpp5 = objPts_cpp.clone(); CvMat bad_objPts_c5 = cvMat(bad_objPts_cpp5);
335
    bad_caller.objPts = &bad_objPts_c5;
336

337
    cv::RNG& rng = theRNG();
338
    for(int i = 0; i < bad_objPts_cpp5.cols; ++i)
339
        bad_objPts_cpp5.at<Point3f>(0, i).z += ((float)rng - 0.5f);
340

341
    errors += run_test_case( CV_StsBadArg, "Bad objPts data", bad_caller );
342

343
    bad_objPts_cpp5 = objPts_cpp.clone(); bad_objPts_c5 = cvMat(bad_objPts_cpp5);
344
    bad_caller.objPts = &bad_objPts_c5;
345
    bad_caller.iFixedPoint = corSize.width - 1;
346
    for(int i = 0; i < bad_objPts_cpp5.cols; ++i)
347
    {
348
        bad_objPts_cpp5.at<Point3f>(0, i).x += (float)rng;
349
        bad_objPts_cpp5.at<Point3f>(0, i).y += (float)rng;
350
    }
351
    errors += run_test_case( CV_StsBadArg, "Bad objPts data", bad_caller );
352

353
    bad_caller = caller;
354
    Mat bad_npts_cpp3 = npoints_cpp.clone();
355
    CvMat bad_npts_c3 = cvMat(bad_npts_cpp3);
356
    bad_caller.npoints = &bad_npts_c3;
357
    bad_caller.iFixedPoint = corSize.width - 1;
358
    for(int i = 0; i < M; i++)
359
        bad_npts_cpp3.at<int>(i) += i;
360
    errors += run_test_case( CV_StsBadArg, "Bad npoints data", bad_caller );
361

362
    if (errors)
363
        ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH);
364
    else
365
        ts->set_failed_test_info(cvtest::TS::OK);
366

367
    //try { caller(); }
368
    //catch (...)
369
    //{
370
    //    ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH);
371
    //    printf("+!");
372
    //}
373
}
374

375

376
class CV_Rodrigues2BadArgTest : public cvtest::BadArgTest
377
{
378
public:
379
    CV_Rodrigues2BadArgTest() {}
380
    ~CV_Rodrigues2BadArgTest() {}
381
protected:
382
    void run_func(void) {}
383

384
    struct C_Caller
385
    {
386
        CvMat* src;
387
        CvMat* dst;
388
        CvMat* jacobian;
389

390
        void operator()() { cvRodrigues2(src, dst, jacobian); }
391
    };
392

393
    void run(int /* start_from */ )
394
    {
395
        Mat zeros(1, sizeof(CvMat), CV_8U, Scalar(0));
396
        CvMat src_c, dst_c, jacobian_c;
397

398
        Mat src_cpp(3, 1, CV_32F); src_c = cvMat(src_cpp);
399
        Mat dst_cpp(3, 3, CV_32F); dst_c = cvMat(dst_cpp);
400
        Mat jacobian_cpp(3, 9, CV_32F); jacobian_c = cvMat(jacobian_cpp);
401

402
        C_Caller caller, bad_caller;
403
        caller.src = &src_c;
404
        caller.dst = &dst_c;
405
        caller.jacobian = &jacobian_c;
406

407
       /* try { caller(); }
408
        catch (...)
409
        {
410
            printf("badasfas");
411
        }*/
412

413
        /*/*//*/*/
414
        int errors = 0;
415

416
        bad_caller = caller;
417
        bad_caller.src = 0;
418
        errors += run_test_case( CV_StsNullPtr, "Src is zero pointer", bad_caller );
419

420
        bad_caller = caller;
421
        bad_caller.dst = 0;
422
        errors += run_test_case( CV_StsNullPtr, "Dst is zero pointer", bad_caller );
423

424
        Mat bad_src_cpp1(3, 1, CV_8U); CvMat bad_src_c1 = cvMat(bad_src_cpp1);
425
        Mat bad_dst_cpp1(3, 1, CV_8U); CvMat bad_dst_c1 = cvMat(bad_dst_cpp1);
426
        Mat bad_jac_cpp1(3, 1, CV_8U); CvMat bad_jac_c1 = cvMat(bad_jac_cpp1);
427
        Mat bad_jac_cpp2(3, 1, CV_32FC2); CvMat bad_jac_c2 = cvMat(bad_jac_cpp2);
428
        Mat bad_jac_cpp3(3, 1, CV_32F); CvMat bad_jac_c3 = cvMat(bad_jac_cpp3);
429

430
        bad_caller = caller;
431
        bad_caller.src = &bad_src_c1;
432
        errors += run_test_case( CV_StsUnsupportedFormat, "Bad src formart", bad_caller );
433

434
        bad_caller = caller;
435
        bad_caller.dst = &bad_dst_c1;
436
        errors += run_test_case( CV_StsUnmatchedFormats, "Bad dst formart", bad_caller );
437

438
        bad_caller = caller;
439
        bad_caller.jacobian = (CvMat*)zeros.ptr();
440
        errors += run_test_case( CV_StsBadArg, "Bad jacobian ", bad_caller );
441

442
        bad_caller = caller;
443
        bad_caller.jacobian = &bad_jac_c1;
444
        errors += run_test_case( CV_StsUnmatchedFormats, "Bad jacobian format", bad_caller );
445

446
        bad_caller = caller;
447
        bad_caller.jacobian = &bad_jac_c2;
448
        errors += run_test_case( CV_StsUnmatchedFormats, "Bad jacobian format", bad_caller );
449

450
        bad_caller = caller;
451
        bad_caller.jacobian = &bad_jac_c3;
452
        errors += run_test_case( CV_StsBadSize, "Bad jacobian format", bad_caller );
453

454
        Mat bad_src_cpp2(1, 1, CV_32F); CvMat bad_src_c2 = cvMat(bad_src_cpp2);
455

456
        bad_caller = caller;
457
        bad_caller.src = &bad_src_c2;
458
        errors += run_test_case( CV_StsBadSize, "Bad src format", bad_caller );
459

460
        Mat bad_dst_cpp2(2, 1, CV_32F); CvMat bad_dst_c2 = cvMat(bad_dst_cpp2);
461
        Mat bad_dst_cpp3(3, 2, CV_32F); CvMat bad_dst_c3 = cvMat(bad_dst_cpp3);
462
        Mat bad_dst_cpp4(3, 3, CV_32FC2); CvMat bad_dst_c4 = cvMat(bad_dst_cpp4);
463

464
        bad_caller = caller;
465
        bad_caller.dst = &bad_dst_c2;
466
        errors += run_test_case( CV_StsBadSize, "Bad dst format", bad_caller );
467

468
        bad_caller = caller;
469
        bad_caller.dst = &bad_dst_c3;
470
        errors += run_test_case( CV_StsBadSize, "Bad dst format", bad_caller );
471

472
        bad_caller = caller;
473
        bad_caller.dst = &bad_dst_c4;
474
        errors += run_test_case( CV_StsBadSize, "Bad dst format", bad_caller );
475

476

477
        /********/
478
        src_cpp.create(3, 3, CV_32F); src_c = cvMat(src_cpp);
479
        dst_cpp.create(3, 1, CV_32F); dst_c = cvMat(dst_cpp);
480

481

482
        Mat bad_dst_cpp5(5, 5, CV_32F); CvMat bad_dst_c5 = cvMat(bad_dst_cpp5);
483

484
        bad_caller = caller;
485
        bad_caller.dst = &bad_dst_c5;
486
        errors += run_test_case( CV_StsBadSize, "Bad dst format", bad_caller );
487

488

489
        if (errors)
490
            ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH);
491
        else
492
            ts->set_failed_test_info(cvtest::TS::OK);
493
    }
494
};
495

496

497
//////////////////////////////////////////////////////////////////////////////////
498
//////////////////////////////////////////////////////////////////////////////////
499
class CV_ProjectPoints2BadArgTest : public cvtest::BadArgTest
500
{
501
public:
502
    CV_ProjectPoints2BadArgTest() : camMat(3, 3), distCoeffs(1, 5)
503
    {
504
        Size imsSize(800, 600);
505
        camMat << 300.f, 0.f, imsSize.width/2.f, 0, 300.f, imsSize.height/2.f, 0.f, 0.f, 1.f;
506
        distCoeffs << 1.2f, 0.2f, 0.f, 0.f, 0.f;
507
    }
508
    ~CV_ProjectPoints2BadArgTest() {}
509
protected:
510
    void run_func(void) {}
511

512
    Mat_<float> camMat;
513
    Mat_<float> distCoeffs;
514

515
    struct C_Caller
516
    {
517
        CvMat* objectPoints;
518
        CvMat* r_vec;
519
        CvMat* t_vec;
520
        CvMat* A;
521
        CvMat* distCoeffs;
522
        CvMat* imagePoints;
523
        CvMat* dpdr;
524
        CvMat* dpdt;
525
        CvMat* dpdf;
526
        CvMat* dpdc;
527
        CvMat* dpdk;
528
        double aspectRatio;
529

530
        void operator()()
531
        {
532
            cvProjectPoints2( objectPoints, r_vec, t_vec, A, distCoeffs, imagePoints,
533
                dpdr, dpdt, dpdf, dpdc, dpdk, aspectRatio );
534
        }
535
    };
536

537
    void run(int /* start_from */ )
538
    {
539
        CvMat zeros = CvMat();
540

541
        C_Caller caller, bad_caller;
542
        CvMat objectPoints_c, r_vec_c, t_vec_c, A_c, distCoeffs_c, imagePoints_c,
543
            dpdr_c, dpdt_c, dpdf_c, dpdc_c, dpdk_c;
544

545
        const int n = 10;
546

547
        Mat imagePoints_cpp(1, n, CV_32FC2); imagePoints_c = cvMat(imagePoints_cpp);
548

549
        Mat objectPoints_cpp(1, n, CV_32FC3);
550
        randu(objectPoints_cpp, Scalar::all(1), Scalar::all(10));
551
        objectPoints_c = cvMat(objectPoints_cpp);
552

553
        Mat t_vec_cpp(Mat::zeros(1, 3, CV_32F)); t_vec_c = cvMat(t_vec_cpp);
554
        Mat r_vec_cpp(3, 1, CV_32F);
555
        cvtest::Rodrigues(Mat::eye(3, 3, CV_32F), r_vec_cpp); r_vec_c = cvMat(r_vec_cpp);
556

557
        Mat A_cpp = camMat.clone(); A_c = cvMat(A_cpp);
558
        Mat distCoeffs_cpp = distCoeffs.clone(); distCoeffs_c = cvMat(distCoeffs_cpp);
559

560
        Mat dpdr_cpp(2*n, 3, CV_32F); dpdr_c = cvMat(dpdr_cpp);
561
        Mat dpdt_cpp(2*n, 3, CV_32F); dpdt_c = cvMat(dpdt_cpp);
562
        Mat dpdf_cpp(2*n, 2, CV_32F); dpdf_c = cvMat(dpdf_cpp);
563
        Mat dpdc_cpp(2*n, 2, CV_32F); dpdc_c = cvMat(dpdc_cpp);
564
        Mat dpdk_cpp(2*n, 4, CV_32F); dpdk_c = cvMat(dpdk_cpp);
565

566
        caller.aspectRatio = 1.0;
567
        caller.objectPoints = &objectPoints_c;
568
        caller.r_vec = &r_vec_c;
569
        caller.t_vec = &t_vec_c;
570
        caller.A = &A_c;
571
        caller.distCoeffs = &distCoeffs_c;
572
        caller.imagePoints = &imagePoints_c;
573
        caller.dpdr = &dpdr_c;
574
        caller.dpdt = &dpdt_c;
575
        caller.dpdf = &dpdf_c;
576
        caller.dpdc = &dpdc_c;
577
        caller.dpdk = &dpdk_c;
578

579
        /********************/
580
        int errors = 0;
581

582

583
        bad_caller = caller;
584
        bad_caller.objectPoints = 0;
585
        errors += run_test_case( CV_StsBadArg, "Zero objectPoints", bad_caller );
586

587
        bad_caller = caller;
588
        bad_caller.r_vec = 0;
589
        errors += run_test_case( CV_StsBadArg, "Zero r_vec", bad_caller );
590

591
        bad_caller = caller;
592
        bad_caller.t_vec = 0;
593
        errors += run_test_case( CV_StsBadArg, "Zero t_vec", bad_caller );
594

595
        bad_caller = caller;
596
        bad_caller.A = 0;
597
        errors += run_test_case( CV_StsBadArg, "Zero camMat", bad_caller );
598

599
        bad_caller = caller;
600
        bad_caller.imagePoints = 0;
601
        errors += run_test_case( CV_StsBadArg, "Zero imagePoints", bad_caller );
602

603
        /****************************/
604
        Mat bad_r_vec_cpp1(r_vec_cpp.size(), CV_32S); CvMat bad_r_vec_c1 = cvMat(bad_r_vec_cpp1);
605
        Mat bad_r_vec_cpp2(2, 2, CV_32F); CvMat bad_r_vec_c2 = cvMat(bad_r_vec_cpp2);
606
        Mat bad_r_vec_cpp3(r_vec_cpp.size(), CV_32FC2); CvMat bad_r_vec_c3 = cvMat(bad_r_vec_cpp3);
607

608
        bad_caller = caller;
609
        bad_caller.r_vec = &bad_r_vec_c1;
610
        errors += run_test_case( CV_StsBadArg, "Bad rvec format", bad_caller );
611

612
        bad_caller = caller;
613
        bad_caller.r_vec = &bad_r_vec_c2;
614
        errors += run_test_case( CV_StsBadArg, "Bad rvec format", bad_caller );
615

616
        bad_caller = caller;
617
        bad_caller.r_vec = &bad_r_vec_c3;
618
        errors += run_test_case( CV_StsBadArg, "Bad rvec format", bad_caller );
619

620
        /****************************/
621
        Mat bad_t_vec_cpp1(t_vec_cpp.size(), CV_32S); CvMat bad_t_vec_c1 = cvMat(bad_t_vec_cpp1);
622
        Mat bad_t_vec_cpp2(2, 2, CV_32F); CvMat bad_t_vec_c2 = cvMat(bad_t_vec_cpp2);
623
        Mat bad_t_vec_cpp3(1, 1, CV_32FC2); CvMat bad_t_vec_c3 = cvMat(bad_t_vec_cpp3);
624

625
        bad_caller = caller;
626
        bad_caller.t_vec = &bad_t_vec_c1;
627
        errors += run_test_case( CV_StsBadArg, "Bad tvec format", bad_caller );
628

629
        bad_caller = caller;
630
        bad_caller.t_vec = &bad_t_vec_c2;
631
        errors += run_test_case( CV_StsBadArg, "Bad tvec format", bad_caller );
632

633
        bad_caller = caller;
634
        bad_caller.t_vec = &bad_t_vec_c3;
635
        errors += run_test_case( CV_StsBadArg, "Bad tvec format", bad_caller );
636

637
        /****************************/
638
        Mat bad_A_cpp1(A_cpp.size(), CV_32S); CvMat bad_A_c1 = cvMat(bad_A_cpp1);
639
        Mat bad_A_cpp2(2, 2, CV_32F); CvMat bad_A_c2 = cvMat(bad_A_cpp2);
640

641
        bad_caller = caller;
642
        bad_caller.A = &bad_A_c1;
643
        errors += run_test_case( CV_StsBadArg, "Bad A format", bad_caller );
644

645
        bad_caller = caller;
646
        bad_caller.A = &bad_A_c2;
647
        errors += run_test_case( CV_StsBadArg, "Bad A format", bad_caller );
648

649
        /****************************/
650
        Mat bad_distCoeffs_cpp1(distCoeffs_cpp.size(), CV_32S); CvMat bad_distCoeffs_c1 = cvMat(bad_distCoeffs_cpp1);
651
        Mat bad_distCoeffs_cpp2(2, 2, CV_32F); CvMat bad_distCoeffs_c2 = cvMat(bad_distCoeffs_cpp2);
652
        Mat bad_distCoeffs_cpp3(1, 7, CV_32F); CvMat bad_distCoeffs_c3 = cvMat(bad_distCoeffs_cpp3);
653

654
        bad_caller = caller;
655
        bad_caller.distCoeffs = &zeros;
656
        errors += run_test_case( CV_StsBadArg, "Bad distCoeffs format", bad_caller );
657

658
        bad_caller = caller;
659
        bad_caller.distCoeffs = &bad_distCoeffs_c1;
660
        errors += run_test_case( CV_StsBadArg, "Bad distCoeffs format", bad_caller );
661

662
        bad_caller = caller;
663
        bad_caller.distCoeffs = &bad_distCoeffs_c2;
664
        errors += run_test_case( CV_StsBadArg, "Bad distCoeffs format", bad_caller );
665

666
        bad_caller = caller;
667
        bad_caller.distCoeffs = &bad_distCoeffs_c3;
668
        errors += run_test_case( CV_StsBadArg, "Bad distCoeffs format", bad_caller );
669

670

671
        /****************************/
672
        Mat bad_dpdr_cpp1(dpdr_cpp.size(), CV_32S); CvMat bad_dpdr_c1 = cvMat(bad_dpdr_cpp1);
673
        Mat bad_dpdr_cpp2(dpdr_cpp.cols+1, 3, CV_32F); CvMat bad_dpdr_c2 = cvMat(bad_dpdr_cpp2);
674
        Mat bad_dpdr_cpp3(dpdr_cpp.cols, 7, CV_32F); CvMat bad_dpdr_c3 = cvMat(bad_dpdr_cpp3);
675

676
        bad_caller = caller;
677
        bad_caller.dpdr = &zeros;
678
        errors += run_test_case( CV_StsBadArg, "Bad dpdr format", bad_caller );
679

680
        bad_caller = caller;
681
        bad_caller.dpdr = &bad_dpdr_c1;
682
        errors += run_test_case( CV_StsBadArg, "Bad dpdr format", bad_caller );
683

684
        bad_caller = caller;
685
        bad_caller.dpdr = &bad_dpdr_c2;
686
        errors += run_test_case( CV_StsBadArg, "Bad dpdr format", bad_caller );
687

688
        bad_caller = caller;
689
        bad_caller.dpdr = &bad_dpdr_c3;
690
        errors += run_test_case( CV_StsBadArg, "Bad dpdr format", bad_caller );
691

692
        /****************************/
693

694
        bad_caller = caller;
695
        bad_caller.dpdt = &zeros;
696
        errors += run_test_case( CV_StsBadArg, "Bad dpdt format", bad_caller );
697

698
        bad_caller = caller;
699
        bad_caller.dpdt = &bad_dpdr_c1;
700
        errors += run_test_case( CV_StsBadArg, "Bad dpdt format", bad_caller );
701

702
        bad_caller = caller;
703
        bad_caller.dpdt = &bad_dpdr_c2;
704
        errors += run_test_case( CV_StsBadArg, "Bad dpdt format", bad_caller );
705

706
        bad_caller = caller;
707
        bad_caller.dpdt = &bad_dpdr_c3;
708
        errors += run_test_case( CV_StsBadArg, "Bad dpdt format", bad_caller );
709

710
        /****************************/
711

712
        Mat bad_dpdf_cpp2(dpdr_cpp.cols+1, 2, CV_32F); CvMat bad_dpdf_c2 = cvMat(bad_dpdf_cpp2);
713

714
        bad_caller = caller;
715
        bad_caller.dpdf = &zeros;
716
        errors += run_test_case( CV_StsBadArg, "Bad dpdf format", bad_caller );
717

718
        bad_caller = caller;
719
        bad_caller.dpdf = &bad_dpdr_c1;
720
        errors += run_test_case( CV_StsBadArg, "Bad dpdf format", bad_caller );
721

722
        bad_caller = caller;
723
        bad_caller.dpdf = &bad_dpdf_c2;
724
        errors += run_test_case( CV_StsBadArg, "Bad dpdf format", bad_caller );
725

726
        bad_caller = caller;
727
        bad_caller.dpdf = &bad_dpdr_c3;
728
        errors += run_test_case( CV_StsBadArg, "Bad dpdf format", bad_caller );
729

730
        /****************************/
731

732
        bad_caller = caller;
733
        bad_caller.dpdc = &zeros;
734
        errors += run_test_case( CV_StsBadArg, "Bad dpdc format", bad_caller );
735

736
        bad_caller = caller;
737
        bad_caller.dpdc = &bad_dpdr_c1;
738
        errors += run_test_case( CV_StsBadArg, "Bad dpdc format", bad_caller );
739

740
        bad_caller = caller;
741
        bad_caller.dpdc = &bad_dpdf_c2;
742
        errors += run_test_case( CV_StsBadArg, "Bad dpdc format", bad_caller );
743

744
        bad_caller = caller;
745
        bad_caller.dpdc = &bad_dpdr_c3;
746
        errors += run_test_case( CV_StsBadArg, "Bad dpdc format", bad_caller );
747

748
        /****************************/
749

750
        bad_caller = caller;
751
        bad_caller.dpdk = &zeros;
752
        errors += run_test_case( CV_StsBadArg, "Bad dpdk format", bad_caller );
753

754
        bad_caller = caller;
755
        bad_caller.dpdk = &bad_dpdr_c1;
756
        errors += run_test_case( CV_StsBadArg, "Bad dpdk format", bad_caller );
757

758
        bad_caller = caller;
759
        bad_caller.dpdk = &bad_dpdf_c2;
760
        errors += run_test_case( CV_StsBadArg, "Bad dpdk format", bad_caller );
761

762
        bad_caller = caller;
763
        bad_caller.dpdk = &bad_dpdr_c3;
764
        errors += run_test_case( CV_StsBadArg, "Bad dpdk format", bad_caller );
765

766
        bad_caller = caller;
767
        bad_caller.distCoeffs = 0;
768
        errors += run_test_case( CV_StsNullPtr, "distCoeffs is NULL while dpdk is not", bad_caller );
769

770

771
        if (errors)
772
            ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH);
773
        else
774
            ts->set_failed_test_info(cvtest::TS::OK);
775
    }
776
};
777

778

779
TEST(Calib3d_CalibrateCamera_C, badarg) { CV_CameraCalibrationBadArgTest test; test.safe_run(); }
780
TEST(Calib3d_Rodrigues_C, badarg) { CV_Rodrigues2BadArgTest test; test.safe_run(); }
781
TEST(Calib3d_ProjectPoints_C, badarg) { CV_ProjectPoints2BadArgTest test; test.safe_run(); }
782

783
}} // namespace
784

785
Product

Resources

Company
