OpenCV 2.4.8 components for OpenCVgrabber.
[mmanager-3rdparty.git] / OpenCV2.4.8 / build / include / opencv2 / ts / ts.hpp
1 #ifndef __OPENCV_GTESTCV_HPP__
2 #define __OPENCV_GTESTCV_HPP__
3
4 #include <stdarg.h> // for va_list
5
6 #ifdef HAVE_WINRT
7     #pragma warning(disable:4447) // Disable warning 'main' signature found without threading model
8 #endif
9
10 #ifdef _MSC_VER
11 #pragma warning( disable: 4127 )
12 #endif
13
14 #define GTEST_DONT_DEFINE_FAIL      0
15 #define GTEST_DONT_DEFINE_SUCCEED   0
16 #define GTEST_DONT_DEFINE_ASSERT_EQ 0
17 #define GTEST_DONT_DEFINE_ASSERT_NE 0
18 #define GTEST_DONT_DEFINE_ASSERT_LE 0
19 #define GTEST_DONT_DEFINE_ASSERT_LT 0
20 #define GTEST_DONT_DEFINE_ASSERT_GE 0
21 #define GTEST_DONT_DEFINE_ASSERT_GT 0
22 #define GTEST_DONT_DEFINE_TEST      0
23
24 #include "opencv2/ts/ts_gtest.h"
25
26 #ifndef GTEST_USES_SIMPLE_RE
27 #  define GTEST_USES_SIMPLE_RE 0
28 #endif
29 #ifndef GTEST_USES_POSIX_RE
30 #  define GTEST_USES_POSIX_RE 0
31 #endif
32
33 #include "opencv2/core/core.hpp"
34
35 namespace cvtest
36 {
37
38 using std::vector;
39 using std::string;
40 using cv::RNG;
41 using cv::Mat;
42 using cv::Scalar;
43 using cv::Size;
44 using cv::Point;
45 using cv::Rect;
46
47 class CV_EXPORTS TS;
48
49 CV_EXPORTS int64 readSeed(const char* str);
50
51 CV_EXPORTS void randUni( RNG& rng, Mat& a, const Scalar& param1, const Scalar& param2 );
52
53 inline unsigned randInt( RNG& rng )
54 {
55     return (unsigned)rng;
56 }
57
58 inline  double randReal( RNG& rng )
59 {
60     return (double)rng;
61 }
62
63
64 CV_EXPORTS const char* getTypeName( int type );
65 CV_EXPORTS int typeByName( const char* type_name );
66
67 CV_EXPORTS string vec2str(const string& sep, const int* v, size_t nelems);
68
69 inline int clipInt( int val, int min_val, int max_val )
70 {
71     if( val < min_val )
72         val = min_val;
73     if( val > max_val )
74         val = max_val;
75     return val;
76 }
77
78 CV_EXPORTS double getMinVal(int depth);
79 CV_EXPORTS double getMaxVal(int depth);
80
81 CV_EXPORTS Size randomSize(RNG& rng, double maxSizeLog);
82 CV_EXPORTS void randomSize(RNG& rng, int minDims, int maxDims, double maxSizeLog, vector<int>& sz);
83 CV_EXPORTS int randomType(RNG& rng, int typeMask, int minChannels, int maxChannels);
84 CV_EXPORTS Mat randomMat(RNG& rng, Size size, int type, double minVal, double maxVal, bool useRoi);
85 CV_EXPORTS Mat randomMat(RNG& rng, const vector<int>& size, int type, double minVal, double maxVal, bool useRoi);
86 CV_EXPORTS void add(const Mat& a, double alpha, const Mat& b, double beta,
87                       Scalar gamma, Mat& c, int ctype, bool calcAbs=false);
88 CV_EXPORTS void multiply(const Mat& a, const Mat& b, Mat& c, double alpha=1);
89 CV_EXPORTS void divide(const Mat& a, const Mat& b, Mat& c, double alpha=1);
90
91 CV_EXPORTS void convert(const Mat& src, Mat& dst, int dtype, double alpha=1, double beta=0);
92 CV_EXPORTS void copy(const Mat& src, Mat& dst, const Mat& mask=Mat(), bool invertMask=false);
93 CV_EXPORTS void set(Mat& dst, const Scalar& gamma, const Mat& mask=Mat());
94
95 // working with multi-channel arrays
96 CV_EXPORTS void extract( const Mat& a, Mat& plane, int coi );
97 CV_EXPORTS void insert( const Mat& plane, Mat& a, int coi );
98
99 // checks that the array does not have NaNs and/or Infs and all the elements are
100 // within [min_val,max_val). idx is the index of the first "bad" element.
101 CV_EXPORTS int check( const Mat& data, double min_val, double max_val, vector<int>* idx );
102
103 // modifies values that are close to zero
104 CV_EXPORTS void  patchZeros( Mat& mat, double level );
105
106 CV_EXPORTS void transpose(const Mat& src, Mat& dst);
107 CV_EXPORTS void erode(const Mat& src, Mat& dst, const Mat& _kernel, Point anchor=Point(-1,-1),
108                       int borderType=IPL_BORDER_CONSTANT, const Scalar& borderValue=Scalar());
109 CV_EXPORTS void dilate(const Mat& src, Mat& dst, const Mat& _kernel, Point anchor=Point(-1,-1),
110                        int borderType=IPL_BORDER_CONSTANT, const Scalar& borderValue=Scalar());
111 CV_EXPORTS void filter2D(const Mat& src, Mat& dst, int ddepth, const Mat& kernel,
112                          Point anchor, double delta, int borderType,
113                          const Scalar& borderValue=Scalar());
114 CV_EXPORTS void copyMakeBorder(const Mat& src, Mat& dst, int top, int bottom, int left, int right,
115                                int borderType, const Scalar& borderValue=Scalar());
116 CV_EXPORTS Mat calcSobelKernel2D( int dx, int dy, int apertureSize, int origin=0 );
117 CV_EXPORTS Mat calcLaplaceKernel2D( int aperture_size );
118
119 CV_EXPORTS void initUndistortMap( const Mat& a, const Mat& k, Size sz, Mat& mapx, Mat& mapy );
120
121 CV_EXPORTS void minMaxLoc(const Mat& src, double* minval, double* maxval,
122                           vector<int>* minloc, vector<int>* maxloc, const Mat& mask=Mat());
123 CV_EXPORTS double norm(const Mat& src, int normType, const Mat& mask=Mat());
124 CV_EXPORTS double norm(const Mat& src1, const Mat& src2, int normType, const Mat& mask=Mat());
125 CV_EXPORTS Scalar mean(const Mat& src, const Mat& mask=Mat());
126
127 CV_EXPORTS bool cmpUlps(const Mat& data, const Mat& refdata, int expMaxDiff, double* realMaxDiff, vector<int>* idx);
128
129 // compares two arrays. max_diff is the maximum actual difference,
130 // success_err_level is maximum allowed difference, idx is the index of the first
131 // element for which difference is >success_err_level
132 // (or index of element with the maximum difference)
133 CV_EXPORTS int cmpEps( const Mat& data, const Mat& refdata, double* max_diff,
134                        double success_err_level, vector<int>* idx,
135                        bool element_wise_relative_error );
136
137 // a wrapper for the previous function. in case of error prints the message to log file.
138 CV_EXPORTS int cmpEps2( TS* ts, const Mat& data, const Mat& refdata, double success_err_level,
139                         bool element_wise_relative_error, const char* desc );
140
141 CV_EXPORTS int cmpEps2_64f( TS* ts, const double* val, const double* refval, int len,
142                         double eps, const char* param_name );
143
144 CV_EXPORTS void logicOp(const Mat& src1, const Mat& src2, Mat& dst, char c);
145 CV_EXPORTS void logicOp(const Mat& src, const Scalar& s, Mat& dst, char c);
146 CV_EXPORTS void min(const Mat& src1, const Mat& src2, Mat& dst);
147 CV_EXPORTS void min(const Mat& src, double s, Mat& dst);
148 CV_EXPORTS void max(const Mat& src1, const Mat& src2, Mat& dst);
149 CV_EXPORTS void max(const Mat& src, double s, Mat& dst);
150
151 CV_EXPORTS void compare(const Mat& src1, const Mat& src2, Mat& dst, int cmpop);
152 CV_EXPORTS void compare(const Mat& src, double s, Mat& dst, int cmpop);
153 CV_EXPORTS void gemm(const Mat& src1, const Mat& src2, double alpha,
154                      const Mat& src3, double beta, Mat& dst, int flags);
155     CV_EXPORTS void transform( const Mat& src, Mat& dst, const Mat& transmat, const Mat& shift );
156 CV_EXPORTS double crossCorr(const Mat& src1, const Mat& src2);
157
158 struct CV_EXPORTS MatInfo
159 {
160     MatInfo(const Mat& _m) : m(&_m) {}
161     const Mat* m;
162 };
163
164 CV_EXPORTS std::ostream& operator << (std::ostream& out, const MatInfo& m);
165
166 struct CV_EXPORTS MatComparator
167 {
168 public:
169     MatComparator(double maxdiff, int context);
170
171     ::testing::AssertionResult operator()(const char* expr1, const char* expr2,
172                                           const Mat& m1, const Mat& m2);
173
174     double maxdiff;
175     double realmaxdiff;
176     vector<int> loc0;
177     int context;
178 };
179
180
181
182 class BaseTest;
183 class TS;
184
185 class CV_EXPORTS BaseTest
186 {
187 public:
188     // constructor(s) and destructor
189     BaseTest();
190     virtual ~BaseTest();
191
192     // the main procedure of the test
193     virtual void run( int start_from );
194
195     // the wrapper for run that cares of exceptions
196     virtual void safe_run( int start_from=0 );
197
198     const string& get_name() const { return name; }
199
200     // returns true if and only if the different test cases do not depend on each other
201     // (so that test system could get right to a problematic test case)
202     virtual bool can_do_fast_forward();
203
204     // deallocates all the memory.
205     // called by init() (before initialization) and by the destructor
206     virtual void clear();
207
208 protected:
209     int test_case_count; // the total number of test cases
210
211     // read test params
212     virtual int read_params( CvFileStorage* fs );
213
214     // returns the number of tests or -1 if it is unknown a-priori
215     virtual int get_test_case_count();
216
217     // prepares data for the next test case. rng seed is updated by the function
218     virtual int prepare_test_case( int test_case_idx );
219
220     // checks if the test output is valid and accurate
221     virtual int validate_test_results( int test_case_idx );
222
223     // calls the tested function. the method is called from run_test_case()
224     virtual void run_func(); // runs tested func(s)
225
226     // updates progress bar
227     virtual int update_progress( int progress, int test_case_idx, int count, double dt );
228
229     // finds test parameter
230     const CvFileNode* find_param( CvFileStorage* fs, const char* param_name );
231
232     // name of the test (it is possible to locate a test by its name)
233     string name;
234
235     // pointer to the system that includes the test
236     TS* ts;
237 };
238
239
240 /*****************************************************************************************\
241 *                               Information about a failed test                           *
242 \*****************************************************************************************/
243
244 struct TestInfo
245 {
246     TestInfo();
247
248     // pointer to the test
249     BaseTest* test;
250
251     // failure code (CV_FAIL*)
252     int code;
253
254     // seed value right before the data for the failed test case is prepared.
255     uint64 rng_seed;
256
257     // seed value right before running the test
258     uint64 rng_seed0;
259
260     // index of test case, can be then passed to BaseTest::proceed_to_test_case()
261     int test_case_idx;
262 };
263
264 /*****************************************************************************************\
265 *                                 Base Class for test system                              *
266 \*****************************************************************************************/
267
268 // common parameters:
269 struct CV_EXPORTS TSParams
270 {
271     TSParams();
272
273     // RNG seed, passed to and updated by every test executed.
274     uint64 rng_seed;
275
276     // whether to use IPP, MKL etc. or not
277     bool use_optimized;
278
279     // extensivity of the tests, scale factor for test_case_count
280     double test_case_count_scale;
281 };
282
283
284 class CV_EXPORTS TS
285 {
286 public:
287     // constructor(s) and destructor
288     TS();
289     virtual ~TS();
290
291     enum
292     {
293         NUL=0,
294         SUMMARY_IDX=0,
295         SUMMARY=1 << SUMMARY_IDX,
296         LOG_IDX=1,
297         LOG=1 << LOG_IDX,
298         CSV_IDX=2,
299         CSV=1 << CSV_IDX,
300         CONSOLE_IDX=3,
301         CONSOLE=1 << CONSOLE_IDX,
302         MAX_IDX=4
303     };
304
305     static TS* ptr();
306
307     // initialize test system before running the first test
308     virtual void init( const string& modulename );
309
310     // low-level printing functions that are used by individual tests and by the system itself
311     virtual void printf( int streams, const char* fmt, ... );
312     virtual void vprintf( int streams, const char* fmt, va_list arglist );
313
314     // updates the context: current test, test case, rng state
315     virtual void update_context( BaseTest* test, int test_case_idx, bool update_ts_context );
316
317     const TestInfo* get_current_test_info() { return &current_test_info; }
318
319     // sets information about a failed test
320     virtual void set_failed_test_info( int fail_code );
321
322     virtual void set_gtest_status();
323
324     // test error codes
325     enum
326     {
327         // everything is Ok
328         OK=0,
329
330         // generic error: stub value to be used
331         // temporarily if the error's cause is unknown
332         FAIL_GENERIC=-1,
333
334         // the test is missing some essential data to proceed further
335         FAIL_MISSING_TEST_DATA=-2,
336
337         // the tested function raised an error via cxcore error handler
338         FAIL_ERROR_IN_CALLED_FUNC=-3,
339
340         // an exception has been raised;
341         // for memory and arithmetic exception
342         // there are two specialized codes (see below...)
343         FAIL_EXCEPTION=-4,
344
345         // a memory exception
346         // (access violation, access to missed page, stack overflow etc.)
347         FAIL_MEMORY_EXCEPTION=-5,
348
349         // arithmetic exception (overflow, division by zero etc.)
350         FAIL_ARITHM_EXCEPTION=-6,
351
352         // the tested function corrupted memory (no exception have been raised)
353         FAIL_MEMORY_CORRUPTION_BEGIN=-7,
354         FAIL_MEMORY_CORRUPTION_END=-8,
355
356         // the tested function (or test ifself) do not deallocate some memory
357         FAIL_MEMORY_LEAK=-9,
358
359         // the tested function returned invalid object, e.g. matrix, containing NaNs,
360         // structure with NULL or out-of-range fields (while it should not)
361         FAIL_INVALID_OUTPUT=-10,
362
363         // the tested function returned valid object, but it does not match to
364         // the original (or produced by the test) object
365         FAIL_MISMATCH=-11,
366
367         // the tested function returned valid object (a single number or numerical array),
368         // but it differs too much from the original (or produced by the test) object
369         FAIL_BAD_ACCURACY=-12,
370
371         // the tested function hung. Sometimes, can be determined by unexpectedly long
372         // processing time (in this case there should be possibility to interrupt such a function
373         FAIL_HANG=-13,
374
375         // unexpected responce on passing bad arguments to the tested function
376         // (the function crashed, proceed succesfully (while it should not), or returned
377         // error code that is different from what is expected)
378         FAIL_BAD_ARG_CHECK=-14,
379
380         // the test data (in whole or for the particular test case) is invalid
381         FAIL_INVALID_TEST_DATA=-15,
382
383         // the test has been skipped because it is not in the selected subset of the tests to run,
384         // because it has been run already within the same run with the same parameters, or because
385         // of some other reason and this is not considered as an error.
386         // Normally TS::run() (or overrided method in the derived class) takes care of what
387         // needs to be run, so this code should not occur.
388         SKIPPED=1
389     };
390
391     // get file storage
392     CvFileStorage* get_file_storage();
393
394     // get RNG to generate random input data for a test
395     RNG& get_rng() { return rng; }
396
397     // returns the current error code
398     int get_err_code() { return current_test_info.code; }
399
400     // returns the test extensivity scale
401     double get_test_case_count_scale() { return params.test_case_count_scale; }
402
403     const string& get_data_path() const { return data_path; }
404
405     // returns textual description of failure code
406     static string str_from_code( int code );
407
408 protected:
409
410     // these are allocated within a test to try keep them valid in case of stack corruption
411     RNG rng;
412
413     // information about the current test
414     TestInfo current_test_info;
415
416     // the path to data files used by tests
417     string data_path;
418
419     TSParams params;
420     std::string output_buf[MAX_IDX];
421 };
422
423
424 /*****************************************************************************************\
425 *            Subclass of BaseTest for testing functions that process dense arrays           *
426 \*****************************************************************************************/
427
428 class CV_EXPORTS ArrayTest : public BaseTest
429 {
430 public:
431     // constructor(s) and destructor
432     ArrayTest();
433     virtual ~ArrayTest();
434
435     virtual void clear();
436
437 protected:
438
439     virtual int read_params( CvFileStorage* fs );
440     virtual int prepare_test_case( int test_case_idx );
441     virtual int validate_test_results( int test_case_idx );
442
443     virtual void prepare_to_validation( int test_case_idx );
444     virtual void get_test_array_types_and_sizes( int test_case_idx, vector<vector<Size> >& sizes, vector<vector<int> >& types );
445     virtual void fill_array( int test_case_idx, int i, int j, Mat& arr );
446     virtual void get_minmax_bounds( int i, int j, int type, Scalar& low, Scalar& high );
447     virtual double get_success_error_level( int test_case_idx, int i, int j );
448
449     bool cvmat_allowed;
450     bool iplimage_allowed;
451     bool optional_mask;
452     bool element_wise_relative_error;
453
454     int min_log_array_size;
455     int max_log_array_size;
456
457     enum { INPUT, INPUT_OUTPUT, OUTPUT, REF_INPUT_OUTPUT, REF_OUTPUT, TEMP, MASK, MAX_ARR };
458
459     vector<vector<void*> > test_array;
460     vector<vector<Mat> > test_mat;
461     float buf[4];
462 };
463
464
465 class CV_EXPORTS BadArgTest : public BaseTest
466 {
467 public:
468     // constructor(s) and destructor
469     BadArgTest();
470     virtual ~BadArgTest();
471
472 protected:
473     virtual int run_test_case( int expected_code, const string& descr );
474     virtual void run_func(void) = 0;
475     int test_case_idx;
476     int progress;
477     double t, freq;
478
479     template<class F>
480     int run_test_case( int expected_code, const string& _descr, F f)
481     {
482         double new_t = (double)cv::getTickCount(), dt;
483         if( test_case_idx < 0 )
484         {
485             test_case_idx = 0;
486             progress = 0;
487             dt = 0;
488         }
489         else
490         {
491             dt = (new_t - t)/(freq*1000);
492             t = new_t;
493         }
494         progress = update_progress(progress, test_case_idx, 0, dt);
495
496         int errcount = 0;
497         bool thrown = false;
498         const char* descr = _descr.c_str() ? _descr.c_str() : "";
499
500         try
501         {
502             f();
503         }
504         catch(const cv::Exception& e)
505         {
506             thrown = true;
507             if( e.code != expected_code )
508             {
509                 ts->printf(TS::LOG, "%s (test case #%d): the error code %d is different from the expected %d\n",
510                     descr, test_case_idx, e.code, expected_code);
511                 errcount = 1;
512             }
513         }
514         catch(...)
515         {
516             thrown = true;
517             ts->printf(TS::LOG, "%s  (test case #%d): unknown exception was thrown (the function has likely crashed)\n",
518                        descr, test_case_idx);
519             errcount = 1;
520         }
521         if(!thrown)
522         {
523             ts->printf(TS::LOG, "%s  (test case #%d): no expected exception was thrown\n",
524                        descr, test_case_idx);
525             errcount = 1;
526         }
527         test_case_idx++;
528
529         return errcount;
530     }
531 };
532
533 struct CV_EXPORTS DefaultRngAuto
534 {
535     const uint64 old_state;
536
537     DefaultRngAuto() : old_state(cv::theRNG().state) { cv::theRNG().state = (uint64)-1; }
538     ~DefaultRngAuto() { cv::theRNG().state = old_state; }
539
540     DefaultRngAuto& operator=(const DefaultRngAuto&);
541 };
542
543 }
544
545 namespace cvtest
546 {
547
548 // test images generation functions
549 CV_EXPORTS void fillGradient(Mat& img, int delta = 5);
550 CV_EXPORTS void smoothBorder(Mat& img, const Scalar& color, int delta = 3);
551
552 CV_EXPORTS void printVersionInfo(bool useStdOut = true);
553 } //namespace cvtest
554
555 // fills c with zeros
556 CV_EXPORTS void cvTsZero( CvMat* c, const CvMat* mask=0 );
557
558 // copies a to b (whole matrix or only the selected region)
559 CV_EXPORTS void cvTsCopy( const CvMat* a, CvMat* b, const CvMat* mask=0 );
560
561 // converts one array to another
562 CV_EXPORTS void  cvTsConvert( const CvMat* src, CvMat* dst );
563
564 CV_EXPORTS void cvTsGEMM( const CvMat* a, const CvMat* b, double alpha,
565                          const CvMat* c, double beta, CvMat* d, int flags );
566
567 #ifndef __CV_TEST_EXEC_ARGS
568 #if defined(_MSC_VER) && (_MSC_VER <= 1400)
569 #define __CV_TEST_EXEC_ARGS(...)    \
570     while (++argc >= (--argc,-1)) {__VA_ARGS__; break;} /*this ugly construction is needed for VS 2005*/
571 #else
572 #define __CV_TEST_EXEC_ARGS(...)    \
573     __VA_ARGS__;
574 #endif
575 #endif
576
577 #define CV_TEST_MAIN(resourcesubdir, ...) \
578 int main(int argc, char **argv) \
579 { \
580     cvtest::TS::ptr()->init(resourcesubdir); \
581     ::testing::InitGoogleTest(&argc, argv); \
582     cvtest::printVersionInfo(); \
583     __CV_TEST_EXEC_ARGS(__VA_ARGS__) \
584     return RUN_ALL_TESTS(); \
585 }
586
587 // This usually only makes sense in perf tests with several implementations,
588 // some of which are not available.
589 #define CV_TEST_FAIL_NO_IMPL() do { \
590     ::testing::Test::RecordProperty("custom_status", "noimpl"); \
591     FAIL() << "No equivalent implementation."; \
592 } while (0)
593
594 #endif
595
596 #include "ts_perf.hpp"