Merge pull request #8940 from 678098:nonblocking_haar_detector_parallel_for
[platform/upstream/opencv.git] / modules / ts / include / opencv2 / ts / ts_perf.hpp
1 #ifndef OPENCV_TS_PERF_HPP
2 #define OPENCV_TS_PERF_HPP
3
4 #include "opencv2/ts.hpp"
5
6 #include "ts_gtest.h"
7 #include "ts_ext.hpp"
8
9 #include <functional>
10
11 #if !(defined(LOGD) || defined(LOGI) || defined(LOGW) || defined(LOGE))
12 # if defined(__ANDROID__) && defined(USE_ANDROID_LOGGING)
13 #  include <android/log.h>
14
15 #  define PERF_TESTS_LOG_TAG "OpenCV_perf"
16 #  define LOGD(...) ((void)__android_log_print(ANDROID_LOG_DEBUG, PERF_TESTS_LOG_TAG, __VA_ARGS__))
17 #  define LOGI(...) ((void)__android_log_print(ANDROID_LOG_INFO, PERF_TESTS_LOG_TAG, __VA_ARGS__))
18 #  define LOGW(...) ((void)__android_log_print(ANDROID_LOG_WARN, PERF_TESTS_LOG_TAG, __VA_ARGS__))
19 #  define LOGE(...) ((void)__android_log_print(ANDROID_LOG_ERROR, PERF_TESTS_LOG_TAG, __VA_ARGS__))
20 # else
21 #  define LOGD(_str, ...) do{printf(_str , ## __VA_ARGS__); printf("\n");fflush(stdout);} while(0)
22 #  define LOGI(_str, ...) do{printf(_str , ## __VA_ARGS__); printf("\n");fflush(stdout);} while(0)
23 #  define LOGW(_str, ...) do{printf(_str , ## __VA_ARGS__); printf("\n");fflush(stdout);} while(0)
24 #  define LOGE(_str, ...) do{printf(_str , ## __VA_ARGS__); printf("\n");fflush(stdout);} while(0)
25 # endif
26 #endif
27
28 // declare major namespaces to avoid errors on unknown namespace
29 namespace cv { namespace cuda {} namespace ocl {} }
30 namespace cvtest { }
31
32 namespace perf
33 {
34
35 // Tuple stuff from Google Tests
36 using testing::get;
37 using testing::make_tuple;
38 using testing::tuple;
39 using testing::tuple_size;
40 using testing::tuple_element;
41
42 class TestBase;
43
44 /*****************************************************************************************\
45 *                Predefined typical frame sizes and typical test parameters               *
46 \*****************************************************************************************/
47 const static cv::Size szQVGA = cv::Size(320, 240);
48 const static cv::Size szVGA = cv::Size(640, 480);
49 const static cv::Size szSVGA = cv::Size(800, 600);
50 const static cv::Size szXGA = cv::Size(1024, 768);
51 const static cv::Size szSXGA = cv::Size(1280, 1024);
52 const static cv::Size szWQHD = cv::Size(2560, 1440);
53
54 const static cv::Size sznHD = cv::Size(640, 360);
55 const static cv::Size szqHD = cv::Size(960, 540);
56 const static cv::Size sz240p = szQVGA;
57 const static cv::Size sz720p = cv::Size(1280, 720);
58 const static cv::Size sz1080p = cv::Size(1920, 1080);
59 const static cv::Size sz1440p = szWQHD;
60 const static cv::Size sz2160p = cv::Size(3840, 2160);//UHDTV1 4K
61 const static cv::Size sz4320p = cv::Size(7680, 4320);//UHDTV2 8K
62
63 const static cv::Size sz3MP = cv::Size(2048, 1536);
64 const static cv::Size sz5MP = cv::Size(2592, 1944);
65 const static cv::Size sz2K = cv::Size(2048, 2048);
66
67 const static cv::Size szODD = cv::Size(127, 61);
68
69 const static cv::Size szSmall24 = cv::Size(24, 24);
70 const static cv::Size szSmall32 = cv::Size(32, 32);
71 const static cv::Size szSmall64 = cv::Size(64, 64);
72 const static cv::Size szSmall128 = cv::Size(128, 128);
73
74 #define SZ_ALL_VGA ::testing::Values(::perf::szQVGA, ::perf::szVGA, ::perf::szSVGA)
75 #define SZ_ALL_GA  ::testing::Values(::perf::szQVGA, ::perf::szVGA, ::perf::szSVGA, ::perf::szXGA, ::perf::szSXGA)
76 #define SZ_ALL_HD  ::testing::Values(::perf::sznHD, ::perf::szqHD, ::perf::sz720p, ::perf::sz1080p)
77 #define SZ_ALL_SMALL ::testing::Values(::perf::szSmall24, ::perf::szSmall32, ::perf::szSmall64, ::perf::szSmall128)
78 #define SZ_ALL  ::testing::Values(::perf::szQVGA, ::perf::szVGA, ::perf::szSVGA, ::perf::szXGA, ::perf::szSXGA, ::perf::sznHD, ::perf::szqHD, ::perf::sz720p, ::perf::sz1080p)
79 #define SZ_TYPICAL  ::testing::Values(::perf::szVGA, ::perf::szqHD, ::perf::sz720p, ::perf::szODD)
80
81
82 #define TYPICAL_MAT_SIZES ::perf::szVGA, ::perf::sz720p, ::perf::sz1080p, ::perf::szODD
83 #define TYPICAL_MAT_TYPES CV_8UC1, CV_8UC4, CV_32FC1
84 #define TYPICAL_MATS testing::Combine( testing::Values( TYPICAL_MAT_SIZES ), testing::Values( TYPICAL_MAT_TYPES ) )
85 #define TYPICAL_MATS_C1 testing::Combine( testing::Values( TYPICAL_MAT_SIZES ), testing::Values( CV_8UC1, CV_32FC1 ) )
86 #define TYPICAL_MATS_C4 testing::Combine( testing::Values( TYPICAL_MAT_SIZES ), testing::Values( CV_8UC4 ) )
87
88
89 /*****************************************************************************************\
90 *                MatType - printable wrapper over integer 'type' of Mat                   *
91 \*****************************************************************************************/
92 class MatType
93 {
94 public:
95     MatType(int val=0) : _type(val) {}
96     operator int() const {return _type;}
97
98 private:
99     int _type;
100 };
101
102 /*****************************************************************************************\
103 *     CV_ENUM and CV_FLAGS - macro to create printable wrappers for defines and enums     *
104 \*****************************************************************************************/
105
106 #define CV_ENUM(class_name, ...)                                                        \
107     namespace {                                                                         \
108     using namespace cv;using namespace cv::cuda; using namespace cv::ocl;               \
109     struct class_name {                                                                 \
110         class_name(int val = 0) : val_(val) {}                                          \
111         operator int() const { return val_; }                                           \
112         void PrintTo(std::ostream* os) const {                                          \
113             const int vals[] = { __VA_ARGS__ };                                         \
114             const char* svals = #__VA_ARGS__;                                           \
115             for(int i = 0, pos = 0; i < (int)(sizeof(vals)/sizeof(int)); ++i) {         \
116                 while(isspace(svals[pos]) || svals[pos] == ',') ++pos;                  \
117                 int start = pos;                                                        \
118                 while(!(isspace(svals[pos]) || svals[pos] == ',' || svals[pos] == 0))   \
119                     ++pos;                                                              \
120                 if (val_ == vals[i]) {                                                  \
121                     *os << std::string(svals + start, svals + pos);                     \
122                     return;                                                             \
123                 }                                                                       \
124             }                                                                           \
125             *os << "UNKNOWN";                                                           \
126         }                                                                               \
127         static ::testing::internal::ParamGenerator<class_name> all() {                  \
128             const class_name vals[] = { __VA_ARGS__ };                                  \
129             return ::testing::ValuesIn(vals);                                           \
130         }                                                                               \
131     private: int val_;                                                                  \
132     };                                                                                  \
133     static inline void PrintTo(const class_name& t, std::ostream* os) { t.PrintTo(os); } }
134
135 #define CV_FLAGS(class_name, ...)                                                       \
136     namespace {                                                                         \
137     struct class_name {                                                                 \
138         class_name(int val = 0) : val_(val) {}                                          \
139         operator int() const { return val_; }                                           \
140         void PrintTo(std::ostream* os) const {                                          \
141             using namespace cv;using namespace cv::cuda; using namespace cv::ocl;        \
142             const int vals[] = { __VA_ARGS__ };                                         \
143             const char* svals = #__VA_ARGS__;                                           \
144             int value = val_;                                                           \
145             bool first = true;                                                          \
146             for(int i = 0, pos = 0; i < (int)(sizeof(vals)/sizeof(int)); ++i) {         \
147                 while(isspace(svals[pos]) || svals[pos] == ',') ++pos;                  \
148                 int start = pos;                                                        \
149                 while(!(isspace(svals[pos]) || svals[pos] == ',' || svals[pos] == 0))   \
150                     ++pos;                                                              \
151                 if ((value & vals[i]) == vals[i]) {                                     \
152                     value &= ~vals[i];                                                  \
153                     if (first) first = false; else *os << "|";                          \
154                     *os << std::string(svals + start, svals + pos);                     \
155                     if (!value) return;                                                 \
156                 }                                                                       \
157             }                                                                           \
158             if (first) *os << "UNKNOWN";                                                \
159         }                                                                               \
160     private: int val_;                                                                  \
161     };                                                                                  \
162     static inline void PrintTo(const class_name& t, std::ostream* os) { t.PrintTo(os); } }
163
164 CV_ENUM(MatDepth, CV_8U, CV_8S, CV_16U, CV_16S, CV_32S, CV_32F, CV_64F, CV_USRTYPE1)
165
166 /*****************************************************************************************\
167 *                 Regression control utility for performance testing                      *
168 \*****************************************************************************************/
169 enum ERROR_TYPE
170 {
171     ERROR_ABSOLUTE = 0,
172     ERROR_RELATIVE = 1
173 };
174
175 class CV_EXPORTS Regression
176 {
177 public:
178     static Regression& add(TestBase* test, const std::string& name, cv::InputArray array, double eps = DBL_EPSILON, ERROR_TYPE err = ERROR_ABSOLUTE);
179     static Regression& addMoments(TestBase* test, const std::string& name, const cv::Moments & array, double eps = DBL_EPSILON, ERROR_TYPE err = ERROR_ABSOLUTE);
180     static Regression& addKeypoints(TestBase* test, const std::string& name, const std::vector<cv::KeyPoint>& array, double eps = DBL_EPSILON, ERROR_TYPE err = ERROR_ABSOLUTE);
181     static Regression& addMatches(TestBase* test, const std::string& name, const std::vector<cv::DMatch>& array, double eps = DBL_EPSILON, ERROR_TYPE err = ERROR_ABSOLUTE);
182     static void Init(const std::string& testSuitName, const std::string& ext = ".xml");
183
184     Regression& operator() (const std::string& name, cv::InputArray array, double eps = DBL_EPSILON, ERROR_TYPE err = ERROR_ABSOLUTE);
185
186 private:
187     static Regression& instance();
188     Regression();
189     ~Regression();
190
191     Regression(const Regression&);
192     Regression& operator=(const Regression&);
193
194     cv::RNG regRNG;//own random numbers generator to make collection and verification work identical
195     std::string storageInPath;
196     std::string storageOutPath;
197     cv::FileStorage storageIn;
198     cv::FileStorage storageOut;
199     cv::FileNode rootIn;
200     std::string currentTestNodeName;
201     std::string suiteName;
202
203     cv::FileStorage& write();
204
205     static std::string getCurrentTestNodeName();
206     static bool isVector(cv::InputArray a);
207     static double getElem(cv::Mat& m, int x, int y, int cn = 0);
208
209     void init(const std::string& testSuitName, const std::string& ext);
210     void write(cv::InputArray array);
211     void write(cv::Mat m);
212     void verify(cv::FileNode node, cv::InputArray array, double eps, ERROR_TYPE err);
213     void verify(cv::FileNode node, cv::Mat actual, double eps, std::string argname, ERROR_TYPE err);
214 };
215
216 #define SANITY_CHECK(array, ...) ::perf::Regression::add(this, #array, array , ## __VA_ARGS__)
217 #define SANITY_CHECK_MOMENTS(array, ...) ::perf::Regression::addMoments(this, #array, array , ## __VA_ARGS__)
218 #define SANITY_CHECK_KEYPOINTS(array, ...) ::perf::Regression::addKeypoints(this, #array, array , ## __VA_ARGS__)
219 #define SANITY_CHECK_MATCHES(array, ...) ::perf::Regression::addMatches(this, #array, array , ## __VA_ARGS__)
220 #define SANITY_CHECK_NOTHING() this->setVerified()
221
222 class CV_EXPORTS GpuPerf
223 {
224 public:
225   static bool targetDevice();
226 };
227
228 #define PERF_RUN_CUDA()  ::perf::GpuPerf::targetDevice()
229
230 /*****************************************************************************************\
231 *                            Container for performance metrics                            *
232 \*****************************************************************************************/
233 typedef struct CV_EXPORTS performance_metrics
234 {
235     size_t bytesIn;
236     size_t bytesOut;
237     unsigned int samples;
238     unsigned int outliers;
239     double gmean;
240     double gstddev;//stddev for log(time)
241     double mean;
242     double stddev;
243     double median;
244     double min;
245     double frequency;
246     int terminationReason;
247
248     enum
249     {
250         TERM_ITERATIONS = 0,
251         TERM_TIME = 1,
252         TERM_INTERRUPT = 2,
253         TERM_EXCEPTION = 3,
254         TERM_SKIP_TEST = 4, // there are some limitations and test should be skipped
255         TERM_UNKNOWN = -1
256     };
257
258     performance_metrics();
259     void clear();
260 } performance_metrics;
261
262
263 /*****************************************************************************************\
264 *                           Strategy for performance measuring                            *
265 \*****************************************************************************************/
266 enum PERF_STRATEGY
267 {
268     PERF_STRATEGY_DEFAULT = -1,
269     PERF_STRATEGY_BASE = 0,
270     PERF_STRATEGY_SIMPLE = 1
271 };
272
273
274 /*****************************************************************************************\
275 *                           Base fixture for performance tests                            *
276 \*****************************************************************************************/
277 #ifdef CV_COLLECT_IMPL_DATA
278 // Implementation collection processing class.
279 // Accumulates and shapes implementation data.
280 typedef struct ImplData
281 {
282     bool ipp;
283     bool icv;
284     bool ipp_mt;
285     bool ocl;
286     bool plain;
287     std::vector<int> implCode;
288     std::vector<cv::String> funName;
289
290     ImplData()
291     {
292         Reset();
293     }
294
295     void Reset()
296     {
297         cv::setImpl(0);
298         ipp = icv = ocl = ipp_mt = false;
299         implCode.clear();
300         funName.clear();
301     }
302
303     void GetImpl()
304     {
305         flagsToVars(cv::getImpl(implCode, funName));
306     }
307
308     std::vector<cv::String> GetCallsForImpl(int impl)
309     {
310         std::vector<cv::String> out;
311
312         for(int i = 0; i < (int)implCode.size(); i++)
313         {
314             if(impl == implCode[i])
315                 out.push_back(funName[i]);
316         }
317         return out;
318     }
319
320     // Remove duplicate entries
321     void ShapeUp()
322     {
323         std::vector<int> savedCode;
324         std::vector<cv::String> savedName;
325
326         for(int i = 0; i < (int)implCode.size(); i++)
327         {
328             bool match = false;
329             for(int j = 0; j < (int)savedCode.size(); j++)
330             {
331                 if(implCode[i] == savedCode[j] && !funName[i].compare(savedName[j]))
332                 {
333                     match = true;
334                     break;
335                 }
336             }
337             if(!match)
338             {
339                 savedCode.push_back(implCode[i]);
340                 savedName.push_back(funName[i]);
341             }
342         }
343
344         implCode = savedCode;
345         funName = savedName;
346     }
347
348     // convert flags register to more handy variables
349     void flagsToVars(int flags)
350     {
351 #if defined(HAVE_IPP_ICV)
352         ipp    = 0;
353         icv    = ((flags&CV_IMPL_IPP) > 0);
354 #else
355         ipp    = ((flags&CV_IMPL_IPP) > 0);
356         icv    = 0;
357 #endif
358         ipp_mt = ((flags&CV_IMPL_MT) > 0);
359         ocl    = ((flags&CV_IMPL_OCL) > 0);
360         plain  = (flags == 0);
361     }
362
363 } ImplData;
364 #endif
365
366 #ifdef ENABLE_INSTRUMENTATION
367 class InstumentData
368 {
369 public:
370     static ::cv::String treeToString();
371     static void         printTree();
372 };
373 #endif
374
375 class CV_EXPORTS TestBase: public ::testing::Test
376 {
377 public:
378     TestBase();
379
380     static void Init(int argc, const char* const argv[]);
381     static void Init(const std::vector<std::string> & availableImpls,
382                      int argc, const char* const argv[]);
383     static void RecordRunParameters();
384     static std::string getDataPath(const std::string& relativePath);
385     static std::string getSelectedImpl();
386
387     static enum PERF_STRATEGY getCurrentModulePerformanceStrategy();
388     static enum PERF_STRATEGY setModulePerformanceStrategy(enum PERF_STRATEGY strategy);
389
390     class PerfSkipTestException: public cv::Exception
391     {
392     public:
393         int dummy; // workaround for MacOSX Xcode 7.3 bug (don't make class "empty")
394         PerfSkipTestException() : dummy(0) {}
395     };
396
397 protected:
398     virtual void PerfTestBody() = 0;
399
400     virtual void SetUp();
401     virtual void TearDown();
402
403     bool startTimer(); // bool is dummy for conditional loop
404     void stopTimer();
405     bool next();
406
407     PERF_STRATEGY getCurrentPerformanceStrategy() const;
408
409     enum WarmUpType
410     {
411         WARMUP_READ,
412         WARMUP_WRITE,
413         WARMUP_RNG,
414         WARMUP_NONE
415     };
416
417     void reportMetrics(bool toJUnitXML = false);
418     static void warmup(cv::InputOutputArray a, WarmUpType wtype = WARMUP_READ);
419
420     performance_metrics& calcMetrics();
421
422     void RunPerfTestBody();
423
424 #ifdef CV_COLLECT_IMPL_DATA
425     ImplData implConf;
426 #endif
427 #ifdef ENABLE_INSTRUMENTATION
428     InstumentData instrConf;
429 #endif
430
431 private:
432     typedef std::vector<std::pair<int, cv::Size> > SizeVector;
433     typedef std::vector<int64> TimeVector;
434
435     SizeVector inputData;
436     SizeVector outputData;
437     unsigned int getTotalInputSize() const;
438     unsigned int getTotalOutputSize() const;
439
440     enum PERF_STRATEGY testStrategy;
441
442     TimeVector times;
443     int64 lastTime;
444     int64 totalTime;
445     int64 timeLimit;
446     static int64 timeLimitDefault;
447     static unsigned int iterationsLimitDefault;
448
449     unsigned int minIters;
450     unsigned int nIters;
451     unsigned int currentIter;
452     unsigned int runsPerIteration;
453     unsigned int perfValidationStage;
454
455     performance_metrics metrics;
456     void validateMetrics();
457
458     static int64 _timeadjustment;
459     static int64 _calibrate();
460
461     static void warmup_impl(cv::Mat m, WarmUpType wtype);
462     static int getSizeInBytes(cv::InputArray a);
463     static cv::Size getSize(cv::InputArray a);
464     static void declareArray(SizeVector& sizes, cv::InputOutputArray a, WarmUpType wtype);
465
466     class CV_EXPORTS _declareHelper
467     {
468     public:
469         _declareHelper& in(cv::InputOutputArray a1, WarmUpType wtype = WARMUP_READ);
470         _declareHelper& in(cv::InputOutputArray a1, cv::InputOutputArray a2, WarmUpType wtype = WARMUP_READ);
471         _declareHelper& in(cv::InputOutputArray a1, cv::InputOutputArray a2, cv::InputOutputArray a3, WarmUpType wtype = WARMUP_READ);
472         _declareHelper& in(cv::InputOutputArray a1, cv::InputOutputArray a2, cv::InputOutputArray a3, cv::InputOutputArray a4, WarmUpType wtype = WARMUP_READ);
473
474         _declareHelper& out(cv::InputOutputArray a1, WarmUpType wtype = WARMUP_WRITE);
475         _declareHelper& out(cv::InputOutputArray a1, cv::InputOutputArray a2, WarmUpType wtype = WARMUP_WRITE);
476         _declareHelper& out(cv::InputOutputArray a1, cv::InputOutputArray a2, cv::InputOutputArray a3, WarmUpType wtype = WARMUP_WRITE);
477         _declareHelper& out(cv::InputOutputArray a1, cv::InputOutputArray a2, cv::InputOutputArray a3, cv::InputOutputArray a4, WarmUpType wtype = WARMUP_WRITE);
478
479         _declareHelper& iterations(unsigned int n);
480         _declareHelper& time(double timeLimitSecs);
481         _declareHelper& tbb_threads(int n = -1);
482         _declareHelper& runs(unsigned int runsNumber);
483
484         _declareHelper& strategy(enum PERF_STRATEGY s);
485     private:
486         TestBase* test;
487         _declareHelper(TestBase* t);
488         _declareHelper(const _declareHelper&);
489         _declareHelper& operator=(const _declareHelper&);
490         friend class TestBase;
491     };
492     friend class _declareHelper;
493
494     bool verified;
495
496 public:
497     _declareHelper declare;
498
499     void setVerified() { this->verified = true; }
500 };
501
502 template<typename T> class TestBaseWithParam: public TestBase, public ::testing::WithParamInterface<T> {};
503
504 typedef tuple<cv::Size, MatType> Size_MatType_t;
505 typedef TestBaseWithParam<Size_MatType_t> Size_MatType;
506
507 /*****************************************************************************************\
508 *                              Print functions for googletest                             *
509 \*****************************************************************************************/
510 CV_EXPORTS void PrintTo(const MatType& t, std::ostream* os);
511
512 } //namespace perf
513
514 namespace cv
515 {
516
517 CV_EXPORTS void PrintTo(const String& str, ::std::ostream* os);
518 CV_EXPORTS void PrintTo(const Size& sz, ::std::ostream* os);
519
520 } //namespace cv
521
522
523 /*****************************************************************************************\
524 *                        Macro definitions for performance tests                          *
525 \*****************************************************************************************/
526
527 #define CV__PERF_TEST_BODY_IMPL(name) \
528     { \
529        CV__TRACE_APP_FUNCTION_NAME("PERF_TEST: " name); \
530        RunPerfTestBody(); \
531     }
532
533 #define PERF_PROXY_NAMESPACE_NAME_(test_case_name, test_name) \
534   test_case_name##_##test_name##_perf_namespace_proxy
535
536 // Defines a performance test.
537 //
538 // The first parameter is the name of the test case, and the second
539 // parameter is the name of the test within the test case.
540 //
541 // The user should put his test code between braces after using this
542 // macro.  Example:
543 //
544 //   PERF_TEST(FooTest, InitializesCorrectly) {
545 //     Foo foo;
546 //     EXPECT_TRUE(foo.StatusIsOK());
547 //   }
548 #define PERF_TEST(test_case_name, test_name)\
549     namespace PERF_PROXY_NAMESPACE_NAME_(test_case_name, test_name) {\
550      class TestBase {/*compile error for this class means that you are trying to use perf::TestBase as a fixture*/};\
551      class test_case_name : public ::perf::TestBase {\
552       public:\
553        test_case_name() {}\
554       protected:\
555        virtual void PerfTestBody();\
556      };\
557      TEST_F(test_case_name, test_name){ CV__PERF_TEST_BODY_IMPL(#test_case_name "_" #test_name); }\
558     }\
559     void PERF_PROXY_NAMESPACE_NAME_(test_case_name, test_name)::test_case_name::PerfTestBody()
560
561 // Defines a performance test that uses a test fixture.
562 //
563 // The first parameter is the name of the test fixture class, which
564 // also doubles as the test case name.  The second parameter is the
565 // name of the test within the test case.
566 //
567 // A test fixture class must be declared earlier.  The user should put
568 // his test code between braces after using this macro.  Example:
569 //
570 //   class FooTest : public ::perf::TestBase {
571 //    protected:
572 //     virtual void SetUp() { TestBase::SetUp(); b_.AddElement(3); }
573 //
574 //     Foo a_;
575 //     Foo b_;
576 //   };
577 //
578 //   PERF_TEST_F(FooTest, InitializesCorrectly) {
579 //     EXPECT_TRUE(a_.StatusIsOK());
580 //   }
581 //
582 //   PERF_TEST_F(FooTest, ReturnsElementCountCorrectly) {
583 //     EXPECT_EQ(0, a_.size());
584 //     EXPECT_EQ(1, b_.size());
585 //   }
586 #define PERF_TEST_F(fixture, testname) \
587     namespace PERF_PROXY_NAMESPACE_NAME_(fixture, testname) {\
588      class TestBase {/*compile error for this class means that you are trying to use perf::TestBase as a fixture*/};\
589      class fixture : public ::fixture {\
590       public:\
591        fixture() {}\
592       protected:\
593        virtual void PerfTestBody();\
594      };\
595      TEST_F(fixture, testname){ CV__PERF_TEST_BODY_IMPL(#fixture "_" #testname); }\
596     }\
597     void PERF_PROXY_NAMESPACE_NAME_(fixture, testname)::fixture::PerfTestBody()
598
599 // Defines a parametrized performance test.
600 //
601 // @Note PERF_TEST_P() below violates behavior of original Google Tests - there is no tests instantiation in original TEST_P()
602 // This macro is intended for usage with separate INSTANTIATE_TEST_CASE_P macro
603 #define PERF_TEST_P_(test_case_name, test_name) CV__TEST_P(test_case_name, test_name, PerfTestBody, CV__PERF_TEST_BODY_IMPL)
604
605 // Defines a parametrized performance test.
606 //
607 // @Note Original TEST_P() macro doesn't instantiate tests with parameters. To keep original usage use PERF_TEST_P_() macro
608 //
609 // The first parameter is the name of the test fixture class, which
610 // also doubles as the test case name.  The second parameter is the
611 // name of the test within the test case.
612 //
613 // The user should put his test code between braces after using this
614 // macro.  Example:
615 //
616 //   typedef ::perf::TestBaseWithParam<cv::Size> FooTest;
617 //
618 //   PERF_TEST_P(FooTest, DoTestingRight, ::testing::Values(::perf::szVGA, ::perf::sz720p) {
619 //     cv::Mat b(GetParam(), CV_8U, cv::Scalar(10));
620 //     cv::Mat a(GetParam(), CV_8U, cv::Scalar(20));
621 //     cv::Mat c(GetParam(), CV_8U, cv::Scalar(0));
622 //
623 //     declare.in(a, b).out(c).time(0.5);
624 //
625 //     TEST_CYCLE() cv::add(a, b, c);
626 //
627 //     SANITY_CHECK(c);
628 //   }
629 #define PERF_TEST_P(fixture, name, params)  \
630     class fixture##_##name : public fixture {\
631      public:\
632       fixture##_##name() {}\
633      protected:\
634       virtual void PerfTestBody();\
635     };\
636     CV__TEST_P(fixture##_##name, name, PerfTestBodyDummy, CV__PERF_TEST_BODY_IMPL){} \
637     INSTANTIATE_TEST_CASE_P(/*none*/, fixture##_##name, params);\
638     void fixture##_##name::PerfTestBody()
639
640 #ifndef __CV_TEST_EXEC_ARGS
641 #if defined(_MSC_VER) && (_MSC_VER <= 1400)
642 #define __CV_TEST_EXEC_ARGS(...)    \
643     while (++argc >= (--argc,-1)) {__VA_ARGS__; break;} /*this ugly construction is needed for VS 2005*/
644 #else
645 #define __CV_TEST_EXEC_ARGS(...)    \
646     __VA_ARGS__;
647 #endif
648 #endif
649
650 #ifdef HAVE_OPENCL
651 namespace cvtest { namespace ocl {
652 void dumpOpenCLDevice();
653 }}
654 #define TEST_DUMP_OCL_INFO cvtest::ocl::dumpOpenCLDevice();
655 #else
656 #define TEST_DUMP_OCL_INFO
657 #endif
658
659
660 #define CV_PERF_TEST_MAIN_INTERNALS(modulename, impls, ...)     \
661     CV_TRACE_FUNCTION(); \
662     { CV_TRACE_REGION("INIT"); \
663     ::perf::Regression::Init(#modulename); \
664     ::perf::TestBase::Init(std::vector<std::string>(impls, impls + sizeof impls / sizeof *impls), \
665                            argc, argv); \
666     ::testing::InitGoogleTest(&argc, argv); \
667     cvtest::printVersionInfo(); \
668     ::testing::Test::RecordProperty("cv_module_name", #modulename); \
669     ::perf::TestBase::RecordRunParameters(); \
670     __CV_TEST_EXEC_ARGS(__VA_ARGS__) \
671     TEST_DUMP_OCL_INFO \
672     } \
673     return RUN_ALL_TESTS();
674
675 // impls must be an array, not a pointer; "plain" should always be one of the implementations
676 #define CV_PERF_TEST_MAIN_WITH_IMPLS(modulename, impls, ...) \
677 int main(int argc, char **argv)\
678 {\
679     CV_PERF_TEST_MAIN_INTERNALS(modulename, impls, __VA_ARGS__)\
680 }
681
682 #define CV_PERF_TEST_MAIN(modulename, ...) \
683 int main(int argc, char **argv)\
684 {\
685     const char * plain_only[] = { "plain" };\
686     CV_PERF_TEST_MAIN_INTERNALS(modulename, plain_only, __VA_ARGS__)\
687 }
688
689 //! deprecated
690 #define TEST_CYCLE_N(n) for(declare.iterations(n); next() && startTimer(); stopTimer())
691 //! deprecated
692 #define TEST_CYCLE() for(; next() && startTimer(); stopTimer())
693 //! deprecated
694 #define TEST_CYCLE_MULTIRUN(runsNum) for(declare.runs(runsNum); next() && startTimer(); stopTimer()) for(int r = 0; r < runsNum; ++r)
695
696 #define PERF_SAMPLE_BEGIN() \
697     for(; next() && startTimer(); stopTimer()) \
698     { \
699         CV_TRACE_REGION("iteration");
700 #define PERF_SAMPLE_END() \
701     }
702
703 namespace perf
704 {
705 namespace comparators
706 {
707
708 template<typename T>
709 struct CV_EXPORTS RectLess_ :
710         public std::binary_function<cv::Rect_<T>, cv::Rect_<T>, bool>
711 {
712   bool operator()(const cv::Rect_<T>& r1, const cv::Rect_<T>& r2) const
713   {
714     return r1.x < r2.x ||
715             (r1.x == r2.x && r1.y < r2.y) ||
716             (r1.x == r2.x && r1.y == r2.y && r1.width < r2.width) ||
717             (r1.x == r2.x && r1.y == r2.y && r1.width == r2.width && r1.height < r2.height);
718   }
719 };
720
721 typedef RectLess_<int> RectLess;
722
723 struct CV_EXPORTS KeypointGreater :
724         public std::binary_function<cv::KeyPoint, cv::KeyPoint, bool>
725 {
726     bool operator()(const cv::KeyPoint& kp1, const cv::KeyPoint& kp2) const
727     {
728         if (kp1.response > kp2.response) return true;
729         if (kp1.response < kp2.response) return false;
730         if (kp1.size > kp2.size) return true;
731         if (kp1.size < kp2.size) return false;
732         if (kp1.octave > kp2.octave) return true;
733         if (kp1.octave < kp2.octave) return false;
734         if (kp1.pt.y < kp2.pt.y) return false;
735         if (kp1.pt.y > kp2.pt.y) return true;
736         return kp1.pt.x < kp2.pt.x;
737     }
738 };
739
740 } //namespace comparators
741
742 void CV_EXPORTS sort(std::vector<cv::KeyPoint>& pts, cv::InputOutputArray descriptors);
743 } //namespace perf
744
745 #endif //OPENCV_TS_PERF_HPP