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