← 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/ts/include/opencv2/ts/ts_perf.hpp

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