← Back to branch summary

~paparazzi-uav/paparazzi/v5.0-manual

« back to all changes in this revision

Viewing changes to sw/ext/opencv_bebop/opencv/modules/calib3d/test/test_cameracalibration_badarg.cpp

  • Committer: Paparazzi buildbot
  • Date: 2016-05-18 15:00:29 UTC
  • Revision ID: felix.ruess+docbot@gmail.com-20160518150029-e8lgzi5kvb4p7un9
Manual import commit 4b8bbb730080dac23cf816b98908dacfabe2a8ec from v5.0 branch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
sw/ext/opencv_bebop/opencv/modules/calib3d/test/test_cameracalibration_badarg.cpp
 
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:
 
54
    CV_CameraCalibrationBadArgTest() : imgSize(800, 600) {}
 
55
    ~CV_CameraCalibrationBadArgTest() {}
 
56
protected:
 
57
    void run(int);
 
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
 
 
79
        void operator()() const
 
80
        {
 
81
            cvCalibrateCamera2(objPts, imgPts, npoints, imageSize,
 
82
                cameraMatrix, distCoeffs, rvecs, tvecs, flags );
 
83
        }
 
84
    };
 
85
};
 
86
 
 
87
 
 
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:
 
334
    CV_Rodrigues2BadArgTest() {}
 
335
    ~CV_Rodrigues2BadArgTest() {}
 
336
protected:
 
337
    void run_func(void) {}
 
338
 
 
339
    struct C_Caller
 
340
    {
 
341
        CvMat* src;
 
342
        CvMat* dst;
 
343
        CvMat* jacobian;
 
344
 
 
345
        void operator()() { cvRodrigues2(src, dst, jacobian); }
 
346
    };
 
347
 
 
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:
 
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
    }
 
463
    ~CV_ProjectPoints2BadArgTest() {}
 
464
protected:
 
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
 
 
485
        void operator()()
 
486
        {
 
487
            cvProjectPoints2( objectPoints, r_vec, t_vec, A, distCoeffs, imagePoints,
 
488
                dpdr, dpdt, dpdf, dpdc, dpdk, aspectRatio );
 
489
        }
 
490
    };
 
491
 
 
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
 
 
735
TEST(Calib3d_CalibrateCamera_C, badarg) { CV_CameraCalibrationBadArgTest test; test.safe_run(); }
 
736
TEST(Calib3d_Rodrigues_C, badarg) { CV_Rodrigues2BadArgTest test; test.safe_run(); }
 
737
TEST(Calib3d_ProjectPoints_C, badarg) { CV_ProjectPoints2BadArgTest test; test.safe_run(); }