ts.hpp
Go to the documentation of this file.
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
250 
251  // failure code (CV_FAIL*)
252  int code;
253 
254  // seed value right before the data for the failed test case is prepared.
256 
257  // seed value right before running the test
259 
260  // index of test case, can be then passed to BaseTest::proceed_to_test_case()
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.
275 
276  // whether to use IPP, MKL etc. or not
278 
279  // extensivity of the tests, scale factor for test_case_count
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 response 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
412 
413  // information about the current test
415 
416  // the path to data files used by tests
417  string data_path;
418 
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 
453 
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;
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 {
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"
const Mat * m
Definition: ts.hpp:161
Definition: ts.hpp:158
double * min_val
Definition: core_c.h:833
Point2i Point
Definition: core.hpp:893
CV_EXPORTS const char * getTypeName(int type)
CV_EXPORTS void gemm(const Mat &src1, const Mat &src2, double alpha, const Mat &src3, double beta, Mat &dst, int flags)
Definition: ts.hpp:297
CV_EXPORTS void divide(const Mat &a, const Mat &b, Mat &c, double alpha=1)
Random Number Generator.
Definition: core.hpp:2019
int int int int * dy
const int * sizes
Definition: core_c.h:212
bool use_optimized
Definition: ts.hpp:277
GLdouble GLdouble GLdouble GLdouble top
GLint level
Definition: tracking.hpp:88
const string & get_data_path() const
Definition: ts.hpp:403
bool optional_mask
Definition: ts.hpp:451
Definition: ts.hpp:244
bool element_wise_relative_error
Definition: ts.hpp:452
CV_EXPORTS void copy(const Mat &src, Mat &dst, const Mat &mask=Mat(), bool invertMask=false)
CV_EXPORTS void dilate(const Mat &src, Mat &dst, const Mat &_kernel, Point anchor=Point(-1,-1), int borderType=IPL_BORDER_CONSTANT, const Scalar &borderValue=Scalar())
CV_EXPORTS Mat calcLaplaceKernel2D(int aperture_size)
CV_EXPORTS void cvTsConvert(const CvMat *src, CvMat *dst)
Definition: ts.hpp:457
Definition: ts.hpp:533
Size2i Size
Definition: core.hpp:896
int clipInt(int val, int min_val, int max_val)
Definition: ts.hpp:69
class CV_EXPORTS TS
Definition: ts.hpp:47
CV_EXPORTS void patchZeros(Mat &mat, double level)
const int * idx
Definition: core_c.h:323
int max_log_array_size
Definition: ts.hpp:455
const CvArr * src1
Definition: core_c.h:436
GLuint src
Definition: core_c.h:1650
CV_EXPORTS Mat calcSobelKernel2D(int dx, int dy, int apertureSize, int origin=0)
int int int flags
Definition: highgui_c.h:186
CV_EXPORTS double getMinVal(int depth)
TSParams params
Definition: ts.hpp:419
CV_EXPORTS void min(const Mat &src1, const Mat &src2, Mat &dst)
uint64 rng_seed0
Definition: ts.hpp:258
GLsizei GLsizei GLenum GLenum const GLvoid * data
Definition: core_c.h:403
int d
Definition: legacy.hpp:3064
CV_EXPORTS bool cmpUlps(const Mat &data, const Mat &refdata, int expMaxDiff, double *realMaxDiff, vector< int > *idx)
const string & get_name() const
Definition: ts.hpp:198
double realmaxdiff
Definition: ts.hpp:175
uint64 rng_seed
Definition: ts.hpp:274
CV_EXPORTS double norm(const Mat &src, int normType, const Mat &mask=Mat())
CvArr const CvMat * kernel
Definition: imgproc_c.h:89
CvRNG * rng
Definition: core_c.h:652
CV_EXPORTS RNG & theRNG()
returns the thread-local Random number generator
int CvMemStorage int double eps
Definition: imgproc_c.h:353
uint64 state
Definition: core.hpp:2050
CV_EXPORTS int cmpEps(const Mat &data, const Mat &refdata, double *max_diff, double success_err_level, vector< int > *idx, bool element_wise_relative_error)
CV_EXPORTS string vec2str(const string &sep, const int *v, size_t nelems)
BaseTest * test
Definition: ts.hpp:249
void clear(const ColorA &color=ColorA::black(), bool clearDepthBuffer=true)
int test_case_idx
Definition: ts.hpp:475
CV_EXPORTS void transform(const Mat &src, Mat &dst, const Mat &transmat, const Mat &shift)
const char const char * str
Definition: core_c.h:1552
CV_EXPORTS cv::Mat randomMat(cv::Size size, int type, double minVal=0.0, double maxVal=255.0)
CV_EXPORTS void set(Mat &dst, const Scalar &gamma, const Mat &mask=Mat())
string name
Definition: ts.hpp:233
CV_EXPORTS void cvTsZero(CvMat *c, const CvMat *mask=0)
CvArr const CvArr const CvArr * mapy
Definition: imgproc_c.h:176
~DefaultRngAuto()
Definition: ts.hpp:538
uint64 rng_seed
Definition: ts.hpp:255
const char * name
Definition: core_c.h:1538
GLint GLvoid * img
Definition: legacy.hpp:1150
Definition: ts.hpp:185
CvArr const CvMat * transmat
Definition: core_c.h:694
CvArr const CvArr * mapx
Definition: imgproc_c.h:176
CV_EXPORTS int randomType(RNG &rng, int typeMask, int minChannels, int maxChannels)
GLuint GLfloat * val
const CvArr const CvArr const CvArr * src3
Definition: core_c.h:436
Definition: ts.hpp:166
CV_EXPORTS int typeByName(const char *type_name)
Definition: ts.hpp:465
CvArr const CvMat * mat
Definition: core_c.h:700
int test_case_count
Definition: ts.hpp:209
CV_EXPORTS int cmpEps2(TS *ts, const Mat &data, const Mat &refdata, double success_err_level, bool element_wise_relative_error, const char *desc)
GLclampf GLclampf GLclampf alpha
Definition: core_c.h:687
double get_test_case_count_scale()
Definition: ts.hpp:401
CV_EXPORTS void fillGradient(Mat &img, int delta=5)
int min_log_array_size
Definition: ts.hpp:454
int coi
Definition: core_c.h:94
CV_EXPORTS void add(const Mat &a, double alpha, const Mat &b, double beta, Scalar gamma, Mat &c, int ctype, bool calcAbs=false)
CvSize int int int CvPoint int delta
Definition: core_c.h:1427
RNG rng
Definition: ts.hpp:411
Definition: ts.hpp:284
CV_EXPORTS void convert(const Mat &src, Mat &dst, int dtype, double alpha=1, double beta=0)
CvArr int CvScalar param1
Definition: core_c.h:649
const CvMat CvMat CvMat int k
Definition: legacy.hpp:3052
CV_EXPORTS_W int64 getTickCount()
Returns the number of ticks.
GLuint GLuint GLsizei count
Definition: core_c.h:973
struct CvFileStorage CvFileStorage
Definition: types_c.h:1740
GLdouble left
Definition: types_c.h:1828
double randReal(RNG &rng)
Definition: ts.hpp:58
int test_case_idx
Definition: ts.hpp:261
double maxdiff
Definition: ts.hpp:174
Definition: ts.hpp:269
Definition: types_c.h:645
const GLdouble * v
double const CvArr double beta
Definition: core_c.h:523
GLdouble GLdouble right
unsigned randInt(RNG &rng)
Definition: ts.hpp:53
The Core Functionality.
double t
Definition: ts.hpp:477
GLboolean GLboolean GLboolean b
Definition: legacy.hpp:633
Definition: ts.hpp:428
The n-dimensional matrix class.
Definition: core.hpp:1688
CV_EXPORTS void copyMakeBorder(const Mat &src, Mat &dst, int top, int bottom, int left, int right, int borderType, const Scalar &borderValue=Scalar())
TestInfo current_test_info
Definition: ts.hpp:414
CV_EXPORTS cv::Size randomSize(int minVal, int maxVal)
CV_EXPORTS void minMaxLoc(const Mat &src, double *minval, double *maxval, vector< int > *minloc, vector< int > *maxloc, const Mat &mask=Mat())
CV_EXPORTS void erode(const Mat &src, Mat &dst, const Mat &_kernel, Point anchor=Point(-1,-1), int borderType=IPL_BORDER_CONSTANT, const Scalar &borderValue=Scalar())
vector< vector< void * > > test_array
Definition: ts.hpp:459
CV_EXPORTS void smoothBorder(Mat &img, const Scalar &color, int delta=3)
CV_EXPORTS std::vector< MatType > types(int depth_start, int depth_end, int cn_start, int cn_end)
return vector with types from specified range.
Definition: ts_gtest.h:17733
int context
Definition: ts.hpp:177
GLuint GLuint GLsizei GLenum type
Definition: core_c.h:114
CV_EXPORTS void extract(const Mat &a, Mat &plane, int coi)
GLenum const GLfloat * params
Definition: compat.hpp:688
CV_EXPORTS void randUni(RNG &rng, Mat &a, const Scalar &param1, const Scalar &param2)
__int64 int64
Definition: types_c.h:158
CV_EXPORTS void multiply(const Mat &a, const Mat &b, Mat &c, double alpha=1)
const GLubyte * c
Definition: legacy.hpp:633
vector< int > loc0
Definition: ts.hpp:176
bool cvmat_allowed
Definition: ts.hpp:449
CV_EXPORTS void logicOp(const Mat &src1, const Mat &src2, Mat &dst, char c)
CV_EXPORTS void max(const Mat &src1, const Mat &src2, Mat &dst)
CvArr int code
Definition: imgproc_c.h:144
const char * ptr
Definition: core_c.h:942
RNG & get_rng()
Definition: ts.hpp:395
GLboolean GLboolean GLboolean GLboolean a
Definition: legacy.hpp:633
const uint64 old_state
Definition: ts.hpp:535
const TestInfo * get_current_test_info()
Definition: ts.hpp:317
CV_EXPORTS std::ostream & operator<<(std::ostream &out, const MatInfo &m)
int int int * dx
const CvMat const CvMat * F
Definition: calib3d.hpp:297
CV_EXPORTS int check(const Mat &data, double min_val, double max_val, vector< int > *idx)
CV_EXPORTS void filter2D(const Mat &src, Mat &dst, int ddepth, const Mat &kernel, Point anchor, double delta, int borderType, const Scalar &borderValue=Scalar())
CV_EXPORTS Scalar mean(const Mat &src, const Mat &mask=Mat())
GLXContext context
CvArr int CvScalar CvScalar param2
Definition: core_c.h:649
CV_EXPORTS int64 readSeed(const char *str)
CvArr * arr
Definition: core_c.h:649
int get_err_code()
Definition: ts.hpp:398
double const CvArr double double gamma
Definition: core_c.h:523
GLuint dst
Definition: calib3d.hpp:134
The standard OpenCV exception class.
Definition: core.hpp:143
GLenum GLsizei len
double test_case_count_scale
Definition: ts.hpp:280
CV_EXPORTS void printVersionInfo(bool useStdOut=true)
vector< vector< Mat > > test_mat
Definition: ts.hpp:460
int progress
Definition: ts.hpp:476
CV_EXPORTS void transpose(const Mat &src, Mat &dst)
bool iplimage_allowed
Definition: ts.hpp:450
GLdouble GLdouble GLdouble bottom
const CvArr CvArr CvStereoBMState * state
Definition: calib3d.hpp:353
CV_EXPORTS void initUndistortMap(const Mat &a, const Mat &k, Size sz, Mat &mapx, Mat &mapy)
const void int const char * dt
Definition: core_c.h:1568
int code
error code
Definition: core.hpp:165
const GLfloat * m
CV_EXPORTS void cvTsCopy(const CvMat *a, CvMat *b, const CvMat *mask=0)
GLint GLint GLsizei GLsizei GLsizei depth
Definition: core_c.h:76
unsigned __int64 uint64
Definition: types_c.h:159
GLdouble GLdouble t
GLdouble s
const CvArr const CvArr * src2
Definition: core_c.h:436
CV_EXPORTS void cvTsGEMM(const CvMat *a, const CvMat *b, double alpha, const CvMat *c, double beta, CvMat *d, int flags)
CV_EXPORTS double crossCorr(const Mat &src1, const Mat &src2)
TS * ts
Definition: ts.hpp:236
int run_test_case(int expected_code, const string &_descr, F f)
Definition: ts.hpp:480
GLenum GLint GLuint mask
Definition: tracking.hpp:132
GLclampf f
MatInfo(const Mat &_m)
Definition: ts.hpp:160
CV_EXPORTS int cmpEps2_64f(TS *ts, const double *val, const double *refval, int len, double eps, const char *param_name)
GLsizeiptr size
Definition: core_c.h:939
int code
Definition: ts.hpp:252
Scalar_< double > Scalar
Definition: core.hpp:968
CV_EXPORTS void compare(const Mat &src1, const Mat &src2, Mat &dst, int cmpop)
string data_path
Definition: ts.hpp:417
Rect_< int > Rect
Definition: core.hpp:897
double double * max_val
Definition: core_c.h:833
short float uchar uchar uchar uchar uchar ushort int uchar ushort int float float float float float float float float float float float float float float float float float float float float float float float float float float float float float float float float float float float float float float float float float float float float float float float float float float float float float float float float float float float float float float float float float float float float float float float float float float float float float int int int float int int int float int CV_CUDEV_IMPLEMENT_VEC_BINARY_OP char CV_CUDEV_IMPLEMENT_VEC_BINARY_OP ushort CV_CUDEV_IMPLEMENT_VEC_BINARY_OP short CV_CUDEV_IMPLEMENT_VEC_BINARY_OP int CV_CUDEV_IMPLEMENT_VEC_BINARY_OP uint CV_CUDEV_IMPLEMENT_VEC_BINARY_OP float CV_CUDEV_IMPLEMENT_VEC_BINARY_OP double int int uint double
Definition: vec_math.hpp:432
CV_EXPORTS double getMaxVal(int depth)
CV_EXPORTS void insert(const Mat &plane, Mat &a, int coi)
DefaultRngAuto()
Definition: ts.hpp:537
GLuint color
Definition: core_c.h:1276