Refactored performance tests. TEST_CYCLE macro is renamed to TEST_CYCLE_N;...

Refactored performance tests. TEST_CYCLE macro is renamed to TEST_CYCLE_N; SIMPLE_TEST_CYCLE is renamed to TEST_CYCLE; from now 100 iterations are default for performance tests

modules/calib3d/perf/perf_cicrlesGrid.cpp

@@ -3,30 +3,32 @@
 using namespace std;
 using namespace cv;
 using namespace perf;
-
+using std::tr1::make_tuple;
+using std::tr1::get;
 
 typedef std::tr1::tuple<std::string, cv::Size> String_Size_t;
 typedef perf::TestBaseWithParam<String_Size_t> String_Size;
 
 PERF_TEST_P(String_Size, asymm_circles_grid, testing::Values(
-                 String_Size_t("cv/cameracalibration/asymmetric_circles/acircles1.jpg", Size(7,13)),
-                 String_Size_t("cv/cameracalibration/asymmetric_circles/acircles2.jpg", Size(7,13)),
-                 String_Size_t("cv/cameracalibration/asymmetric_circles/acircles3.jpg", Size(7,13)),
-                 String_Size_t("cv/cameracalibration/asymmetric_circles/acircles4.jpg", Size(5,5)),
-                 String_Size_t("cv/cameracalibration/asymmetric_circles/acircles5.jpg", Size(5,5)),
-                 String_Size_t("cv/cameracalibration/asymmetric_circles/acircles6.jpg", Size(5,5)),
-                 String_Size_t("cv/cameracalibration/asymmetric_circles/acircles7.jpg", Size(3,9)),
-                 String_Size_t("cv/cameracalibration/asymmetric_circles/acircles8.jpg", Size(3,9)),
-                 String_Size_t("cv/cameracalibration/asymmetric_circles/acircles9.jpg", Size(3,9))
-                 )
-             )
+                String_Size_t("cv/cameracalibration/asymmetric_circles/acircles1.jpg", Size(7,13)),
+                String_Size_t("cv/cameracalibration/asymmetric_circles/acircles2.jpg", Size(7,13)),
+                String_Size_t("cv/cameracalibration/asymmetric_circles/acircles3.jpg", Size(7,13)),
+                String_Size_t("cv/cameracalibration/asymmetric_circles/acircles4.jpg", Size(5,5)),
+                String_Size_t("cv/cameracalibration/asymmetric_circles/acircles5.jpg", Size(5,5)),
+                String_Size_t("cv/cameracalibration/asymmetric_circles/acircles6.jpg", Size(5,5)),
+                String_Size_t("cv/cameracalibration/asymmetric_circles/acircles7.jpg", Size(3,9)),
+                String_Size_t("cv/cameracalibration/asymmetric_circles/acircles8.jpg", Size(3,9)),
+                String_Size_t("cv/cameracalibration/asymmetric_circles/acircles9.jpg", Size(3,9))
+                )
+            )
 {
-    String filename = getDataPath(std::tr1::get<0>(GetParam()));
-    Size gridSize = std::tr1::get<1>(GetParam());
+    String filename = getDataPath(get<0>(GetParam()));
+    Size gridSize = get<1>(GetParam());
 
     Mat frame = imread(filename);
     if (frame.empty())
         FAIL() << "Unable to load source image " << filename;
+
     vector<Point2f> ptvec;
     ptvec.resize(gridSize.area());
 
@@ -34,8 +36,7 @@ PERF_TEST_P(String_Size, asymm_circles_grid, testing::Values(
 
     declare.in(frame).out(ptvec);
 
-    TEST_CYCLE(100)
-    {
-        ASSERT_TRUE(findCirclesGrid(frame, gridSize, ptvec, CALIB_CB_CLUSTERING | CALIB_CB_ASYMMETRIC_GRID));
-    }
+    TEST_CYCLE() ASSERT_TRUE(findCirclesGrid(frame, gridSize, ptvec, CALIB_CB_CLUSTERING | CALIB_CB_ASYMMETRIC_GRID));
+
+    SANITY_CHECK(ptvec, 2);
 }

modules/calib3d/perf/perf_pnp.cpp

@@ -3,15 +3,23 @@
 using namespace std;
 using namespace cv;
 using namespace perf;
+using std::tr1::make_tuple;
+using std::tr1::get;
 
+CV_ENUM(pnpAlgo, CV_ITERATIVE, CV_EPNP /*, CV_P3P*/)
 
-typedef std::tr1::tuple<std::string, cv::Size> String_Size_t;
-typedef perf::TestBaseWithParam<int> PointsNumber;
+typedef std::tr1::tuple<int, pnpAlgo> PointsNum_Algo_t;
+typedef perf::TestBaseWithParam<PointsNum_Algo_t> PointsNum_Algo;
 
-PERF_TEST_P(PointsNumber, solvePnP, testing::Values(4, 3*9, 7*13)
-             )
+PERF_TEST_P(PointsNum_Algo, solvePnP,
+            testing::Combine(
+                testing::Values(4, 3*9, 7*13),
+                testing::Values((int)CV_ITERATIVE, (int)CV_EPNP)
+                )
+            )
 {
-    int pointsNum = GetParam();
+    int pointsNum = get<0>(GetParam());
+    pnpAlgo algo = get<1>(GetParam());
 
     vector<Point2f> points2d(pointsNum);
     vector<Point3f> points3d(pointsNum);
@@ -38,10 +46,42 @@ PERF_TEST_P(PointsNumber, solvePnP, testing::Values(4, 3*9, 7*13)
 
     declare.in(points3d, points2d);
 
-    TEST_CYCLE(1000)
-    {
-        solvePnP(points3d, points2d, intrinsics, distortion, rvec, tvec, false);
-    }
+    TEST_CYCLE_N(1000) solvePnP(points3d, points2d, intrinsics, distortion, rvec, tvec, false, algo);
+
+    SANITY_CHECK(rvec, 1e-6);
+    SANITY_CHECK(tvec, 1e-6);
+}
+
+PERF_TEST(PointsNum_Algo, solveP3P)
+{
+    int pointsNum = 4;
+
+    vector<Point2f> points2d(pointsNum);
+    vector<Point3f> points3d(pointsNum);
+    Mat rvec = Mat::zeros(3, 1, CV_32FC1);
+    Mat tvec = Mat::zeros(3, 1, CV_32FC1);
+
+    Mat distortion = Mat::zeros(5, 1, CV_32FC1);
+    Mat intrinsics = Mat::eye(3, 3, CV_32FC1);
+    intrinsics.at<float> (0, 0) = 400.0;
+    intrinsics.at<float> (1, 1) = 400.0;
+    intrinsics.at<float> (0, 2) = 640 / 2;
+    intrinsics.at<float> (1, 2) = 480 / 2;
+
+    warmup(points3d, WARMUP_RNG);
+    warmup(rvec, WARMUP_RNG);
+    warmup(tvec, WARMUP_RNG);
+
+    projectPoints(points3d, rvec, tvec, intrinsics, distortion, points2d);
+
+    //add noise
+    Mat noise(1, points2d.size(), CV_32FC2);
+    randu(noise, 0, 0.01);
+    add(points2d, noise, points2d);
+
+    declare.in(points3d, points2d);
+
+    TEST_CYCLE_N(1000) solvePnP(points3d, points2d, intrinsics, distortion, rvec, tvec, false, CV_P3P);
 
     SANITY_CHECK(rvec, 1e-6);
     SANITY_CHECK(tvec, 1e-6);

modules/core/perf/perf_abs.cpp

@@ -3,6 +3,8 @@
 using namespace std;
 using namespace cv;
 using namespace perf;
+using std::tr1::make_tuple;
+using std::tr1::get;
 
 #define TYPICAL_MAT_SIZES_ABS  TYPICAL_MAT_SIZES 
 #define TYPICAL_MAT_TYPES_ABS  CV_8SC1, CV_8SC4, CV_32SC1, CV_32FC1
@@ -10,15 +12,15 @@ using namespace perf;
 
 PERF_TEST_P(Size_MatType, abs, TYPICAL_MATS_ABS) 
 {
-    Size sz = std::tr1::get<0>(GetParam());
-    int type = std::tr1::get<1>(GetParam());
+    Size sz = get<0>(GetParam());
+    int type = get<1>(GetParam());
 
     cv::Mat a = Mat(sz, type);
     cv::Mat c = Mat(sz, type);
 
-    declare.in(a, ::perf::TestBase::WARMUP_RNG).out(c).time(0.5);
+    declare.in(a, WARMUP_RNG).out(c);
 
-    TEST_CYCLE(100) c = cv::abs(a);
+    TEST_CYCLE() c = cv::abs(a);
 
     SANITY_CHECK(c);
 }

modules/core/perf/perf_arithm.cpp

+#include "perf_precomp.hpp"
+
+using namespace std;
+using namespace cv;
+using namespace perf;
+using std::tr1::make_tuple;
+using std::tr1::get;
+
+#define TYPICAL_MAT_SIZES_CORE_ARITHM   TYPICAL_MAT_SIZES 
+#define TYPICAL_MAT_TYPES_CORE_ARITHM   CV_8UC1, CV_8SC1, CV_8UC4, CV_32SC1, CV_32FC1
+#define TYPICAL_MATS_CORE_ARITHM        testing::Combine( testing::Values( TYPICAL_MAT_SIZES_CORE_ARITHM ), testing::Values( TYPICAL_MAT_TYPES_CORE_ARITHM ) )
+
+#ifdef ANDROID
+PERF_TEST(convert, cvRound)
+{
+    double number = theRNG().uniform(-100, 100);
+
+    int result = 0;
+
+    TEST_CYCLE_N(1000)
+    {
+        for (int i = 0; i < 500000; ++i)
+            result += cvRound(number);
+    }
+
+    SANITY_CHECK(result);
+}
+#endif
+
+PERF_TEST_P(Size_MatType, min, TYPICAL_MATS_CORE_ARITHM)
+{
+    Size sz = get<0>(GetParam());
+    int type = get<1>(GetParam());
+    cv::Mat a = Mat(sz, type);
+    cv::Mat b = Mat(sz, type);
+    cv::Mat c = Mat(sz, type);
+
+    declare.in(a, b, WARMUP_RNG).out(c);
+
+    TEST_CYCLE() min(a, b, c);
+
+    SANITY_CHECK(c);
+}
+
+PERF_TEST_P(Size_MatType, minScalar, TYPICAL_MATS_CORE_ARITHM)
+{
+    Size sz = get<0>(GetParam());
+    int type = get<1>(GetParam());
+    cv::Mat a = Mat(sz, type);
+    cv::Scalar b;
+    cv::Mat c = Mat(sz, type);
+
+    declare.in(a, b, WARMUP_RNG).out(c);
+
+    TEST_CYCLE() min(a, b, c);
+
+    SANITY_CHECK(c);
+}
+
+PERF_TEST_P(Size_MatType, max, TYPICAL_MATS_CORE_ARITHM)
+{
+    Size sz = get<0>(GetParam());
+    int type = get<1>(GetParam());
+    cv::Mat a = Mat(sz, type);
+    cv::Mat b = Mat(sz, type);
+    cv::Mat c = Mat(sz, type);
+
+    declare.in(a, b, WARMUP_RNG).out(c);
+
+    TEST_CYCLE() max(a, b, c);
+
+    SANITY_CHECK(c);
+}
+
+PERF_TEST_P(Size_MatType, maxScalar, TYPICAL_MATS_CORE_ARITHM)
+{
+    Size sz = get<0>(GetParam());
+    int type = get<1>(GetParam());
+    cv::Mat a = Mat(sz, type);
+    cv::Scalar b;
+    cv::Mat c = Mat(sz, type);
+
+    declare.in(a, b, WARMUP_RNG).out(c);
+
+    TEST_CYCLE() max(a, b, c);
+
+    SANITY_CHECK(c);
+}
+
+PERF_TEST_P(Size_MatType, absdiff, TYPICAL_MATS_CORE_ARITHM)
+{
+    Size sz = get<0>(GetParam());
+    int type = get<1>(GetParam());
+    cv::Mat a = Mat(sz, type);
+    cv::Mat b = Mat(sz, type);
+    cv::Mat c = Mat(sz, type);
+
+    declare.in(a, b, WARMUP_RNG).out(c);
+
+    TEST_CYCLE() absdiff(a, b, c);
+
+    //see ticket 1529: absdiff can be without saturation on 32S
+    if (CV_MAT_DEPTH(type) != CV_32S)
+        SANITY_CHECK(c, 1e-8);
+}
+
+PERF_TEST_P(Size_MatType, absdiffScalar, TYPICAL_MATS_CORE_ARITHM)
+{
+    Size sz = get<0>(GetParam());
+    int type = get<1>(GetParam());
+    cv::Mat a = Mat(sz, type);
+    cv::Scalar b;
+    cv::Mat c = Mat(sz, type);
+
+    declare.in(a, b, WARMUP_RNG).out(c);
+
+    TEST_CYCLE() absdiff(a, b, c);
+
+    //see ticket 1529: absdiff can be without saturation on 32S
+    if (CV_MAT_DEPTH(type) != CV_32S)
+        SANITY_CHECK(c, 1e-8);
+}
+
+PERF_TEST_P(Size_MatType, add, TYPICAL_MATS_CORE_ARITHM)
+{
+    Size sz = get<0>(GetParam());
+    int type = get<1>(GetParam());
+    cv::Mat a = Mat(sz, type);
+    cv::Mat b = Mat(sz, type);
+    cv::Mat c = Mat(sz, type);
+
+    declare.in(a, b, WARMUP_RNG).out(c);
+
+    TEST_CYCLE() add(a, b, c);
+
+    //see ticket 1529: add can be without saturation on 32S
+    if (CV_MAT_DEPTH(type) != CV_32S)
+        SANITY_CHECK(c, 1e-8);
+}
+
+PERF_TEST_P(Size_MatType, addScalar, TYPICAL_MATS_CORE_ARITHM)
+{
+    Size sz = get<0>(GetParam());
+    int type = get<1>(GetParam());
+    cv::Mat a = Mat(sz, type);
+    cv::Scalar b;
+    cv::Mat c = Mat(sz, type);
+
+    declare.in(a, b, WARMUP_RNG).out(c);
+
+    TEST_CYCLE() add(a, b, c);
+
+    //see ticket 1529: add can be without saturation on 32S
+    if (CV_MAT_DEPTH(type) != CV_32S)
+        SANITY_CHECK(c, 1e-8);
+}
+
+PERF_TEST_P(Size_MatType, subtract, TYPICAL_MATS_CORE_ARITHM)
+{
+    Size sz = get<0>(GetParam());
+    int type = get<1>(GetParam());
+    cv::Mat a = Mat(sz, type);
+    cv::Mat b = Mat(sz, type);
+    cv::Mat c = Mat(sz, type);
+
+    declare.in(a, b, WARMUP_RNG).out(c);
+
+    TEST_CYCLE() subtract(a, b, c);
+
+    //see ticket 1529: subtract can be without saturation on 32S
+    if (CV_MAT_DEPTH(type) != CV_32S)
+        SANITY_CHECK(c, 1e-8);
+}
+
+PERF_TEST_P(Size_MatType, subtractScalar, TYPICAL_MATS_CORE_ARITHM)
+{
+    Size sz = get<0>(GetParam());
+    int type = get<1>(GetParam());
+    cv::Mat a = Mat(sz, type);
+    cv::Scalar b;
+    cv::Mat c = Mat(sz, type);
+
+    declare.in(a, b, WARMUP_RNG).out(c);
+
+    TEST_CYCLE() subtract(a, b, c);
+
+    //see ticket 1529: subtract can be without saturation on 32S
+    if (CV_MAT_DEPTH(type) != CV_32S)
+        SANITY_CHECK(c, 1e-8);
+}

modules/core/perf/perf_bitwise.cpp

@@ -3,22 +3,69 @@
 using namespace std;
 using namespace cv;
 using namespace perf;
+using std::tr1::make_tuple;
+using std::tr1::get;
 
-#define TYPICAL_MAT_SIZES_BITWNOT  TYPICAL_MAT_SIZES
-#define TYPICAL_MAT_TYPES_BITWNOT  CV_8SC1, CV_8SC4, CV_32SC1, CV_32SC4
-#define TYPICAL_MATS_BITWNOT       testing::Combine( testing::Values( TYPICAL_MAT_SIZES_BITWNOT), testing::Values( TYPICAL_MAT_TYPES_BITWNOT) )
+#define TYPICAL_MAT_SIZES_BITW_ARITHM  TYPICAL_MAT_SIZES
+#define TYPICAL_MAT_TYPES_BITW_ARITHM  CV_8UC1, CV_8SC1, CV_8UC4, CV_32SC1, CV_32SC4
+#define TYPICAL_MATS_BITW_ARITHM       testing::Combine(testing::Values(TYPICAL_MAT_SIZES_BITW_ARITHM), testing::Values(TYPICAL_MAT_TYPES_BITW_ARITHM))
 
-PERF_TEST_P(Size_MatType, bitwise_not, TYPICAL_MATS_BITWNOT)
+PERF_TEST_P(Size_MatType, bitwise_not, TYPICAL_MATS_BITW_ARITHM)
 {
-    Size sz = std::tr1::get<0>(GetParam());
-    int type = std::tr1::get<1>(GetParam());
+    Size sz = get<0>(GetParam());
+    int type = get<1>(GetParam());
 
     cv::Mat a = Mat(sz, type);
     cv::Mat c = Mat(sz, type);
 
     declare.in(a, WARMUP_RNG).out(c);
 
-    TEST_CYCLE(100) cv::bitwise_not(a, c);
+    TEST_CYCLE() cv::bitwise_not(a, c);
+
+    SANITY_CHECK(c);
+}
+
+PERF_TEST_P(Size_MatType, bitwise_and, TYPICAL_MATS_BITW_ARITHM)
+{
+    Size sz = get<0>(GetParam());
+    int type = get<1>(GetParam());
+    cv::Mat a = Mat(sz, type);
+    cv::Mat b = Mat(sz, type);
+    cv::Mat c = Mat(sz, type);
+
+    declare.in(a, b, WARMUP_RNG).out(c);
+
+    TEST_CYCLE() bitwise_and(a, b, c);
+
+    SANITY_CHECK(c);
+}
+
+PERF_TEST_P(Size_MatType, bitwise_or, TYPICAL_MATS_BITW_ARITHM)
+{
+    Size sz = get<0>(GetParam());
+    int type = get<1>(GetParam());
+    cv::Mat a = Mat(sz, type);
+    cv::Mat b = Mat(sz, type);
+    cv::Mat c = Mat(sz, type);
+
+    declare.in(a, b, WARMUP_RNG).out(c);
+
+    TEST_CYCLE() bitwise_or(a, b, c);
+
+    SANITY_CHECK(c);
+}
+
+PERF_TEST_P(Size_MatType, bitwise_xor, TYPICAL_MATS_BITW_ARITHM)
+{
+    Size sz = get<0>(GetParam());
+    int type = get<1>(GetParam());
+    cv::Mat a = Mat(sz, type);
+    cv::Mat b = Mat(sz, type);
+    cv::Mat c = Mat(sz, type);
+
+    declare.in(a, b, WARMUP_RNG).out(c);
+
+    TEST_CYCLE() bitwise_xor(a, b, c);
 
     SANITY_CHECK(c);
 }

modules/core/perf/perf_compare.cpp

@@ -3,6 +3,8 @@
 using namespace std;
 using namespace cv;
 using namespace perf;
+using std::tr1::make_tuple;
+using std::tr1::get;
 
 CV_ENUM(CmpType, CMP_EQ, CMP_GT, CMP_GE, CMP_LT, CMP_LE, CMP_NE)
 
@@ -10,16 +12,16 @@ typedef std::tr1::tuple<Size, MatType, CmpType> Size_MatType_CmpType_t;
 typedef perf::TestBaseWithParam<Size_MatType_CmpType_t> Size_MatType_CmpType;
 
 PERF_TEST_P( Size_MatType_CmpType, compare,
-    testing::Combine(
-        testing::Values( TYPICAL_MAT_SIZES ),
-        testing::Values( CV_8UC1, CV_8UC4, CV_8SC1, CV_16UC1, CV_16SC1, CV_32SC1, CV_32FC1 ),
-        testing::ValuesIn( CmpType::all() )
-    )
-)
+             testing::Combine(
+                 testing::Values(TYPICAL_MAT_SIZES),
+                 testing::Values(CV_8UC1, CV_8UC4, CV_8SC1, CV_16UC1, CV_16SC1, CV_32SC1, CV_32FC1),
+                 testing::ValuesIn(CmpType::all())
+                 )
+             )
 {
-    Size sz = std::tr1::get<0>(GetParam());
-    int matType1 = std::tr1::get<1>(GetParam());
-    CmpType cmpType = std::tr1::get<2>(GetParam());
+    Size sz = get<0>(GetParam());
+    int matType1 = get<1>(GetParam());
+    CmpType cmpType = get<2>(GetParam());
 
     Mat src1(sz, matType1);
     Mat src2(sz, matType1);
@@ -27,25 +29,22 @@ PERF_TEST_P( Size_MatType_CmpType, compare,
 
     declare.in(src1, src2, WARMUP_RNG).out(dst);
 
-    TEST_CYCLE(100)
-    {
-        cv::compare(src1, src2, dst, cmpType);
-    }
+    TEST_CYCLE() cv::compare(src1, src2, dst, cmpType);
 
     SANITY_CHECK(dst);
 }
 
 PERF_TEST_P( Size_MatType_CmpType, compareScalar,
-    testing::Combine(
-        testing::Values( TYPICAL_MAT_SIZES ),
-        testing::Values( TYPICAL_MAT_TYPES ),
-        testing::ValuesIn( CmpType::all() )
-    )
-)
+             testing::Combine(
+                 testing::Values(TYPICAL_MAT_SIZES),
+                 testing::Values(TYPICAL_MAT_TYPES),
+                 testing::ValuesIn(CmpType::all())
+                 )
+             )
 {
-    Size sz = std::tr1::get<0>(GetParam());
-    int matType = std::tr1::get<1>(GetParam());
-    CmpType cmpType = std::tr1::get<2>(GetParam());
+    Size sz = get<0>(GetParam());
+    int matType = get<1>(GetParam());
+    CmpType cmpType = get<2>(GetParam());
 
     Mat src1(sz, matType);
     Scalar src2;
@@ -53,10 +52,7 @@ PERF_TEST_P( Size_MatType_CmpType, compareScalar,
 
     declare.in(src1, src2, WARMUP_RNG).out(dst);
 
-    TEST_CYCLE(100)
-    {
-        cv::compare(src1, src2, dst, cmpType);
-    }
+    TEST_CYCLE() cv::compare(src1, src2, dst, cmpType);
 
     SANITY_CHECK(dst);
 }

modules/core/perf/perf_core_arithm.cpp

-#include "perf_precomp.hpp"
-
-using namespace std;
-using namespace cv;
-using namespace perf;
-
-#define TYPICAL_MAT_SIZES_CORE_ARITHM   TYPICAL_MAT_SIZES 
-#define TYPICAL_MAT_TYPES_CORE_ARITHM   CV_8UC1, CV_8SC1, CV_8UC4, CV_32SC1, CV_32FC1
-#define TYPICAL_MATS_CORE_ARITHM        testing::Combine( testing::Values( TYPICAL_MAT_SIZES_CORE_ARITHM ), testing::Values( TYPICAL_MAT_TYPES_CORE_ARITHM ) )
-
-#define TYPICAL_MAT_TYPES_BITW_ARITHM   CV_8UC1, CV_8SC1, CV_8UC4, CV_32SC1, CV_32SC4
-#define TYPICAL_MATS_BITW_ARITHM        testing::Combine( testing::Values( TYPICAL_MAT_SIZES_CORE_ARITHM ), testing::Values( TYPICAL_MAT_TYPES_BITW_ARITHM ) )
-
-#define PERF_TEST_P__CORE_ARITHM(__f, __testset) \
-PERF_TEST_P(Size_MatType, core_arithm__ ## __f, __testset)     \
-{                                                              \
-    Size sz = std::tr1::get<0>(GetParam());                    \
-    int type = std::tr1::get<1>(GetParam());                   \
-    cv::Mat a = Mat(sz, type);                                 \
-    cv::Mat b = Mat(sz, type);                                 \
-    cv::Mat c = Mat(sz, type);                                 \
-                                                               \
-    declare.in(a, b, WARMUP_RNG)                               \
-        .out(c);                                               \
-                                                               \
-    TEST_CYCLE(100) __f(a,b, c);                               \
-                                                               \
-    SANITY_CHECK(c, 1e-8);                                     \
-}
-
-#define PERF_TEST_P__CORE_ARITHM_SCALAR(__f, __testset) \
-PERF_TEST_P(Size_MatType, core_arithm__ ## __f ##__Scalar, __testset)     \
-{                                                                         \
-    Size sz = std::tr1::get<0>(GetParam());                               \
-    int type = std::tr1::get<1>(GetParam());                              \
-    cv::Mat a = Mat(sz, type);                                            \
-    cv::Scalar b;                                                         \
-    cv::Mat c = Mat(sz, type);                                            \
-                                                                          \
-    declare.in(a, b, WARMUP_RNG)                                          \
-        .out(c);                                                          \
-                                                                          \
-    TEST_CYCLE(100) __f(a,b, c);                                          \
-                                                                          \
-    SANITY_CHECK(c, 1e-8);                                                \
-}
-
-PERF_TEST_P__CORE_ARITHM(bitwise_and, TYPICAL_MATS_BITW_ARITHM)
-PERF_TEST_P__CORE_ARITHM(bitwise_or, TYPICAL_MATS_BITW_ARITHM)
-PERF_TEST_P__CORE_ARITHM(bitwise_xor, TYPICAL_MATS_BITW_ARITHM)
-PERF_TEST_P__CORE_ARITHM(add, TYPICAL_MATS_CORE_ARITHM)
-PERF_TEST_P__CORE_ARITHM(subtract, TYPICAL_MATS_CORE_ARITHM)
-PERF_TEST_P__CORE_ARITHM(min, TYPICAL_MATS_CORE_ARITHM)
-PERF_TEST_P__CORE_ARITHM(max, TYPICAL_MATS_CORE_ARITHM)
-
-PERF_TEST_P__CORE_ARITHM_SCALAR(bitwise_and, TYPICAL_MATS_BITW_ARITHM)
-PERF_TEST_P__CORE_ARITHM_SCALAR(bitwise_or, TYPICAL_MATS_BITW_ARITHM)
-PERF_TEST_P__CORE_ARITHM_SCALAR(bitwise_xor, TYPICAL_MATS_BITW_ARITHM)
-PERF_TEST_P__CORE_ARITHM_SCALAR(add, TYPICAL_MATS_CORE_ARITHM)
-PERF_TEST_P__CORE_ARITHM_SCALAR(subtract, TYPICAL_MATS_CORE_ARITHM)
-
-#ifdef ANDROID
-PERF_TEST(convert, cvRound)
-{
-    double number = theRNG().uniform(-100, 100);
-
-    int result = 0;
-
-    TEST_CYCLE(1000)
-    {
-        for (int i = 0; i < 500000; ++i)
-            result += cvRound(number);
-    }
-}
-#endif
-
-PERF_TEST_P(Size_MatType, core_arithm__absdiff, TYPICAL_MATS_CORE_ARITHM)
-{
-    Size sz = std::tr1::get<0>(GetParam());
-    int type = std::tr1::get<1>(GetParam());
-    cv::Mat a = Mat(sz, type);
-    cv::Mat b = Mat(sz, type);
-    cv::Mat c = Mat(sz, type);
-
-    declare.in(a, b, WARMUP_RNG)
-            .out(c);
-
-    TEST_CYCLE(100) absdiff(a,b, c);
-
-#if CV_SSE2 //see ticket 1529: absdiff can be without saturation if SSE is enabled
-    if (CV_MAT_DEPTH(type) != CV_32S)
-#endif
-        SANITY_CHECK(c, 1e-8);
-}
-
-PERF_TEST_P(Size_MatType, core_arithm__absdiff__Scalar, TYPICAL_MATS_CORE_ARITHM)
-{
-    Size sz = std::tr1::get<0>(GetParam());
-    int type = std::tr1::get<1>(GetParam());
-    cv::Mat a = Mat(sz, type);
-    cv::Scalar b;
-    cv::Mat c = Mat(sz, type);
-
-    declare.in(a, b, WARMUP_RNG)
-            .out(c);
-
-    TEST_CYCLE(100) absdiff(a,b, c);
-
-#if CV_SSE2 //see ticket 1529: absdiff can be without saturation if SSE is enabled
-    if (CV_MAT_DEPTH(type) != CV_32S)
-#endif
-        SANITY_CHECK(c, 1e-8);
-}

modules/core/perf/perf_dft.cpp

@@ -3,26 +3,24 @@
 using namespace std;
 using namespace cv;
 using namespace perf;
+using std::tr1::make_tuple;
+using std::tr1::get;
 
 #define MAT_TYPES_DFT  CV_32FC1, CV_64FC1
 #define MAT_SIZES_DFT  sz1080p, sz2K
-#define TEST_MATS_DFT testing::Combine( testing::Values(MAT_SIZES_DFT), testing::Values(MAT_TYPES_DFT) )
+#define TEST_MATS_DFT  testing::Combine(testing::Values(MAT_SIZES_DFT), testing::Values(MAT_TYPES_DFT))
 
 PERF_TEST_P(Size_MatType, dft, TEST_MATS_DFT)
 {
-    Size sz = std::tr1::get<0>(GetParam());
-    int type = std::tr1::get<1>(GetParam());
+    Size sz = get<0>(GetParam());
+    int type = get<1>(GetParam());
 
     Mat src(sz, type);
     Mat dst(sz, type);
- 
-    declare.in(src, WARMUP_RNG);
-    declare.time(60);
 
-    TEST_CYCLE(100) 
-    {
-        dft(src, dst);
-    }
+    declare.in(src, WARMUP_RNG).time(60);
+
+    TEST_CYCLE() dft(src, dst);
 
     SANITY_CHECK(dst, 1e-5);
 }

modules/core/perf/perf_dot.cpp

@@ -3,30 +3,28 @@
 using namespace std;
 using namespace cv;
 using namespace perf;
+using std::tr1::make_tuple;
+using std::tr1::get;
 
 typedef tr1::tuple<int, int> MatType_Length_t;
 typedef TestBaseWithParam<MatType_Length_t> MatType_Length;
 
 PERF_TEST_P( MatType_Length, dot,
              testing::Combine(
-                testing::Values( CV_8UC1, CV_32SC1, CV_32FC1 ),
-                testing::Values( 32, 64, 128, 256, 512, 1024 )
-            ))
+                 testing::Values( CV_8UC1, CV_32SC1, CV_32FC1 ),
+                 testing::Values( 32, 64, 128, 256, 512, 1024 )
+                 ))
 {
-    unsigned int type = std::tr1::get<0>(GetParam());
-    unsigned int size = std::tr1::get<1>(GetParam());
+    int type = get<0>(GetParam());
+    int size = get<1>(GetParam());
     Mat a(size, size, type);
     Mat b(size, size, type);
 
-    declare.in(a, WARMUP_RNG);
-    declare.in(b, WARMUP_RNG);
+    declare.in(a, b, WARMUP_RNG);
 
     double product;
 
-	TEST_CYCLE(100)
-	{
-        product = a.dot(b);
-	}
+    TEST_CYCLE_N(1000) product = a.dot(b);
 
-    SANITY_CHECK(product, 1e-5);
+    SANITY_CHECK(product, 1e-6, ERROR_RELATIVE);
 }

modules/core/perf/perf_math.cpp

@@ -3,6 +3,8 @@
 using namespace std;
 using namespace cv;
 using namespace perf;
+using std::tr1::make_tuple;
+using std::tr1::get;
 
 typedef perf::TestBaseWithParam<size_t> VectorLength;
 
@@ -15,7 +17,7 @@ PERF_TEST_P(VectorLength, phase32f, testing::Values(128, 1000, 128*1024, 512*102
 
     declare.in(X, Y, WARMUP_RNG).out(angle);
 
-    TEST_CYCLE(200) cv::phase(X, Y, angle, true);
+    TEST_CYCLE_N(200) cv::phase(X, Y, angle, true);
 
     SANITY_CHECK(angle, 5e-5);
 }

modules/core/perf/perf_minmax.cpp

-#include "perf_precomp.hpp"
-
-using namespace std;
-using namespace cv;
-using namespace perf;
-
-#define TYPICAL_MAT_SIZES_MINMAX  TYPICAL_MAT_SIZES 
-#define TYPICAL_MAT_TYPES_MINMAX  CV_8SC1, CV_8SC4, CV_32SC1, CV_32FC1
-#define TYPICAL_MATS_MINMAX       testing::Combine( testing::Values( TYPICAL_MAT_SIZES_MINMAX), testing::Values( TYPICAL_MAT_TYPES_MINMAX) )
-
-PERF_TEST_P(Size_MatType, min_double, TYPICAL_MATS_MINMAX)
-{
-    Size sz = std::tr1::get<0>(GetParam());
-    int type = std::tr1::get<1>(GetParam());
-
-    cv::Mat a = Mat(sz, type);
-    cv::Mat c = Mat(sz, type);
-
-    declare.in(a, ::perf::TestBase::WARMUP_RNG).out(c);
-
-    TEST_CYCLE(100) cv::min(a, 10, c);
-
-    SANITY_CHECK(c);
-}
-
-PERF_TEST_P(Size_MatType, max_double, TYPICAL_MATS_MINMAX)
-{
-    Size sz = std::tr1::get<0>(GetParam());
-    int type = std::tr1::get<1>(GetParam());
-
-    cv::Mat a = Mat(sz, type);
-    cv::Mat c = Mat(sz, type);
-
-    declare.in(a, ::perf::TestBase::WARMUP_RNG).out(c);
-
-    TEST_CYCLE(100) cv::max(a, 10, c);
-
-    SANITY_CHECK(c);
-}

modules/core/perf/perf_minmaxloc.cpp

+#include "perf_precomp.hpp"
+
+using namespace std;
+using namespace cv;
+using namespace perf;
+using std::tr1::make_tuple;
+using std::tr1::get;
+
+PERF_TEST_P(Size_MatType, minMaxLoc, testing::Combine(
+                 testing::Values(TYPICAL_MAT_SIZES),
+                 testing::Values(CV_8UC1, CV_8SC1, CV_16UC1, CV_16SC1, CV_32SC1,  CV_32FC1, CV_64FC1)
+                 )
+             )
+{
+    Size sz = get<0>(GetParam());
+    int matType = get<1>(GetParam());
+
+    Mat src(sz, matType);
+    double minVal, maxVal;
+    Point minLoc, maxLoc;
+
+    if (matType == CV_8U)
+        randu(src, 1, 254 /*do not include 0 and 255 to avoid early exit on 1 byte data*/);
+    else if (matType == CV_8S)
+        randu(src, -127, 126);
+    else
+        warmup(src, WARMUP_RNG);
+
+    declare.in(src);
+
+    TEST_CYCLE() minMaxLoc(src, &minVal, &maxVal, &minLoc, &maxLoc);
+
+    SANITY_CHECK(minVal, 1e-12);
+    SANITY_CHECK(maxVal, 1e-12);
+}

modules/core/perf/perf_norm.cpp

+#include "perf_precomp.hpp"
+
+using namespace std;
+using namespace cv;
+using namespace perf;
+using std::tr1::make_tuple;
+using std::tr1::get;
+
+
+CV_FLAGS(NormType, NORM_INF, NORM_L1, NORM_L2, NORM_TYPE_MASK, NORM_RELATIVE, NORM_MINMAX)
+typedef std::tr1::tuple<Size, MatType, NormType> Size_MatType_NormType_t;
+typedef perf::TestBaseWithParam<Size_MatType_NormType_t> Size_MatType_NormType;
+
+PERF_TEST_P(Size_MatType_NormType, norm,
+            testing::Combine(
+                testing::Values(TYPICAL_MAT_SIZES),
+                testing::Values(TYPICAL_MAT_TYPES),
+                testing::Values((int)NORM_INF, (int)NORM_L1, (int)NORM_L2)
+                )
+            )
+{
+    Size sz = get<0>(GetParam());
+    int matType = get<1>(GetParam());
+    int normType = get<2>(GetParam());
+
+    Mat src(sz, matType);
+    double n;
+
+    declare.in(src, WARMUP_RNG);
+
+    TEST_CYCLE() n = norm(src, normType);
+
+    SANITY_CHECK(n, 1e-6, ERROR_RELATIVE);
+}
+
+PERF_TEST_P(Size_MatType_NormType, norm_mask,
+            testing::Combine(
+                testing::Values(TYPICAL_MAT_SIZES),
+                testing::Values(TYPICAL_MAT_TYPES),
+                testing::Values((int)NORM_INF, (int)NORM_L1, (int)NORM_L2)
+                )
+            )
+{
+    Size sz = get<0>(GetParam());
+    int matType = get<1>(GetParam());
+    int normType = get<2>(GetParam());
+
+    Mat src(sz, matType);
+    Mat mask = Mat::ones(sz, CV_8U);
+    double n;
+
+    declare.in(src, WARMUP_RNG).in(mask);
+
+    TEST_CYCLE() n = norm(src, normType, mask);
+
+    SANITY_CHECK(n, 1e-6, ERROR_RELATIVE);
+}
+
+PERF_TEST_P(Size_MatType_NormType, norm2,
+            testing::Combine(
+                testing::Values(TYPICAL_MAT_SIZES),
+                testing::Values(TYPICAL_MAT_TYPES),
+                testing::Values((int)NORM_INF, (int)NORM_L1, (int)NORM_L2, (int)(NORM_RELATIVE+NORM_INF), (int)(NORM_RELATIVE+NORM_L1), (int)(NORM_RELATIVE+NORM_L2))
+                )
+            )
+{
+    Size sz = get<0>(GetParam());
+    int matType = get<1>(GetParam());
+    int normType = get<2>(GetParam());
+
+    Mat src1(sz, matType);
+    Mat src2(sz, matType);
+    double n;
+
+    declare.in(src1, src2, WARMUP_RNG);
+
+    TEST_CYCLE() n = norm(src1, src2, normType);
+
+    SANITY_CHECK(n, 1e-5, ERROR_RELATIVE);
+}
+
+PERF_TEST_P(Size_MatType_NormType, norm2_mask,
+            testing::Combine(
+                testing::Values(TYPICAL_MAT_SIZES),
+                testing::Values(TYPICAL_MAT_TYPES),
+                testing::Values((int)NORM_INF, (int)NORM_L1, (int)NORM_L2, (int)(NORM_RELATIVE|NORM_INF), (int)(NORM_RELATIVE|NORM_L1), (int)(NORM_RELATIVE|NORM_L2))
+                )
+            )
+{
+    Size sz = get<0>(GetParam());
+    int matType = get<1>(GetParam());
+    int normType = get<2>(GetParam());
+
+    Mat src1(sz, matType);
+    Mat src2(sz, matType);
+    Mat mask = Mat::ones(sz, CV_8U);
+    double n;
+
+    declare.in(src1, src2, WARMUP_RNG).in(mask);
+
+    TEST_CYCLE() n = norm(src1, src2, normType, mask);
+
+    SANITY_CHECK(n, 1e-5, ERROR_RELATIVE);
+}
+
+PERF_TEST_P(Size_MatType_NormType, normalize,
+            testing::Combine(
+                testing::Values(TYPICAL_MAT_SIZES),
+                testing::Values(TYPICAL_MAT_TYPES),
+                testing::Values((int)NORM_INF, (int)NORM_L1, (int)NORM_L2)
+                )
+            )
+{
+    Size sz = get<0>(GetParam());
+    int matType = get<1>(GetParam());
+    int normType = get<2>(GetParam());
+
+    Mat src(sz, matType);
+    Mat dst(sz, matType);
+
+    double alpha = 100.;
+    if(normType==NORM_L1) alpha = (double)src.total() * src.channels();
+    if(normType==NORM_L2) alpha = (double)src.total()/10;
+
+    declare.in(src, WARMUP_RNG).out(dst);
+
+    TEST_CYCLE() normalize(src, dst, alpha, 0., normType);
+
+    SANITY_CHECK(dst, 1e-6);
+}
+
+PERF_TEST_P(Size_MatType_NormType, normalize_mask,
+            testing::Combine(
+                testing::Values(TYPICAL_MAT_SIZES),
+                testing::Values(TYPICAL_MAT_TYPES),
+                testing::Values((int)NORM_INF, (int)NORM_L1, (int)NORM_L2)
+                )
+            )
+{
+    Size sz = get<0>(GetParam());
+    int matType = get<1>(GetParam());
+    int normType = get<2>(GetParam());
+
+    Mat src(sz, matType);
+    Mat dst(sz, matType);
+    Mat mask = Mat::ones(sz, CV_8U);
+
+    double alpha = 100.;
+    if(normType==NORM_L1) alpha = (double)src.total() * src.channels();
+    if(normType==NORM_L2) alpha = (double)src.total()/10;
+
+    declare.in(src, WARMUP_RNG).in(mask).out(dst);
+
+    TEST_CYCLE() normalize(src, dst, alpha, 0., normType, -1, mask);
+
+    SANITY_CHECK(dst, 1e-6);
+}
+
+PERF_TEST_P(Size_MatType_NormType, normalize_32f,
+            testing::Combine(
+                testing::Values(TYPICAL_MAT_SIZES),
+                testing::Values(TYPICAL_MAT_TYPES),
+                testing::Values((int)NORM_INF, (int)NORM_L1, (int)NORM_L2)
+                )
+            )
+{
+    Size sz = get<0>(GetParam());
+    int matType = get<1>(GetParam());
+    int normType = get<2>(GetParam());
+
+    Mat src(sz, matType);
+    Mat dst(sz, CV_32F);
+
+    double alpha = 100.;
+    if(normType==NORM_L1) alpha = (double)src.total() * src.channels();
+    if(normType==NORM_L2) alpha = (double)src.total()/10;
+
+    declare.in(src, WARMUP_RNG).out(dst);
+
+    TEST_CYCLE() normalize(src, dst, alpha, 0., normType, CV_32F);
+
+    SANITY_CHECK(dst, 1e-6, ERROR_RELATIVE);
+}
+
+PERF_TEST_P( Size_MatType, normalize_minmax, TYPICAL_MATS )
+{
+    Size sz = get<0>(GetParam());
+    int matType = get<1>(GetParam());
+
+    Mat src(sz, matType);
+    Mat dst(sz, matType);
+
+    declare.in(src, WARMUP_RNG).out(dst);
+
+    TEST_CYCLE() normalize(src, dst, 20., 100., NORM_MINMAX);
+
+    SANITY_CHECK(dst, 1e-6, ERROR_RELATIVE);
+}

modules/core/perf/perf_reduce.cpp

+#include "perf_precomp.hpp"
+#include "opencv2/core/core_c.h"
+
+using namespace std;
+using namespace cv;
+using namespace perf;
+using std::tr1::make_tuple;
+using std::tr1::get;
+
+CV_ENUM(ROp, CV_REDUCE_SUM, CV_REDUCE_AVG, CV_REDUCE_MAX, CV_REDUCE_MIN)
+typedef std::tr1::tuple<Size, MatType, ROp> Size_MatType_ROp_t;
+typedef perf::TestBaseWithParam<Size_MatType_ROp_t> Size_MatType_ROp;
+
+
+PERF_TEST_P(Size_MatType_ROp, reduceR,
+            testing::Combine(
+                testing::Values(TYPICAL_MAT_SIZES),
+                testing::Values(TYPICAL_MAT_TYPES),
+                testing::ValuesIn(ROp::all())
+                )
+            )
+{
+    Size sz = get<0>(GetParam());
+    int matType = get<1>(GetParam());
+    int reduceOp = get<2>(GetParam());
+
+    int ddepth = -1;
+    if( CV_MAT_DEPTH(matType) < CV_32S && (reduceOp == CV_REDUCE_SUM || reduceOp == CV_REDUCE_AVG) )
+        ddepth = CV_32S;
+
+    Mat src(sz, matType);
+    Mat vec(1, sz.width, ddepth < 0 ? matType : ddepth);
+
+    declare.in(src, WARMUP_RNG).out(vec);
+
+    TEST_CYCLE() reduce(src, vec, 0, reduceOp, ddepth);
+
+    SANITY_CHECK(vec, 1);
+}
+
+PERF_TEST_P(Size_MatType_ROp, reduceC,
+            testing::Combine(
+                testing::Values(TYPICAL_MAT_SIZES),
+                testing::Values(TYPICAL_MAT_TYPES),
+                testing::ValuesIn(ROp::all())
+                )
+            )
+{
+    Size sz = get<0>(GetParam());
+    int matType = get<1>(GetParam());
+    int reduceOp = get<2>(GetParam());
+
+    int ddepth = -1;
+    if( CV_MAT_DEPTH(matType)< CV_32S && (reduceOp == CV_REDUCE_SUM || reduceOp == CV_REDUCE_AVG) )
+        ddepth = CV_32S;
+
+    Mat src(sz, matType);
+    Mat vec(sz.height, 1, ddepth < 0 ? matType : ddepth);
+
+    declare.in(src, WARMUP_RNG).out(vec);
+
+    TEST_CYCLE() reduce(src, vec, 1, reduceOp, ddepth);
+
+    SANITY_CHECK(vec, 1);
+}
+

modules/core/perf/perf_stat.cpp

 #include "perf_precomp.hpp"
-#include "opencv2/core/core_c.h"
 
 using namespace std;
 using namespace cv;
 using namespace perf;
+using std::tr1::make_tuple;
+using std::tr1::get;
 
-
-/*
-// Scalar sum(InputArray arr)
-*/
-PERF_TEST_P( Size_MatType, sum, TYPICAL_MATS )
+PERF_TEST_P(Size_MatType, sum, TYPICAL_MATS)
 {
-    Size sz = std::tr1::get<0>(GetParam());
-    int type = std::tr1::get<1>(GetParam());
+    Size sz = get<0>(GetParam());
+    int type = get<1>(GetParam());
 
     Mat arr(sz, type);
     Scalar s;
 
-    declare.in(arr, WARMUP_RNG);
+    declare.in(arr, WARMUP_RNG).out(s);
 
-    TEST_CYCLE(100) { s = sum(arr); }
+    TEST_CYCLE() s = sum(arr);
 
     SANITY_CHECK(s, 1e-6, ERROR_RELATIVE);
 }
 
-
-/*
-// Scalar mean(InputArray src)
-*/
-PERF_TEST_P( Size_MatType, mean, TYPICAL_MATS )
+PERF_TEST_P(Size_MatType, mean, TYPICAL_MATS)
 {
-    Size sz = std::tr1::get<0>(GetParam());
-    int type = std::tr1::get<1>(GetParam());
+    Size sz = get<0>(GetParam());
+    int type = get<1>(GetParam());
 
     Mat src(sz, type);
     Scalar s;
     
-    declare.in(src, WARMUP_RNG);
+    declare.in(src, WARMUP_RNG).out(s);
     
-    TEST_CYCLE(100) { s = mean(src); }
+    TEST_CYCLE() s = mean(src);
     
     SANITY_CHECK(s, 1e-6);
 }
 
-
-/*
-// Scalar mean(InputArray src, InputArray mask=noArray())
-*/
-PERF_TEST_P( Size_MatType, mean_mask, TYPICAL_MATS )
+PERF_TEST_P(Size_MatType, mean_mask, TYPICAL_MATS)
 {
-    Size sz = std::tr1::get<0>(GetParam());
-    int type = std::tr1::get<1>(GetParam());
+    Size sz = get<0>(GetParam());
+    int type = get<1>(GetParam());
 
     Mat src(sz, type);
     Mat mask = Mat::ones(src.size(), CV_8U);
     Scalar s;
     
-    declare.in(src, WARMUP_RNG).in(mask);
+    declare.in(src, WARMUP_RNG).in(mask).out(s);
     
-    TEST_CYCLE(100) { s = mean(src, mask); }
+    TEST_CYCLE() s = mean(src, mask);
     
     SANITY_CHECK(s, 1e-6);
 }
 
-CV_FLAGS(NormType, NORM_INF, NORM_L1, NORM_L2, NORM_TYPE_MASK, NORM_RELATIVE, NORM_MINMAX)
-typedef std::tr1::tuple<Size, MatType, NormType> Size_MatType_NormType_t;
-typedef perf::TestBaseWithParam<Size_MatType_NormType_t> Size_MatType_NormType;
-
-/*
-// double norm(InputArray src1, int normType=NORM_L2)
-*/
-PERF_TEST_P( Size_MatType_NormType, norm, 
-    testing::Combine(
-        testing::Values( TYPICAL_MAT_SIZES ), 
-        testing::Values( TYPICAL_MAT_TYPES ),
-        testing::Values( (int)NORM_INF, (int)NORM_L1, (int)NORM_L2 )
-    )
-)
-{
-    Size sz = std::tr1::get<0>(GetParam());
-    int matType = std::tr1::get<1>(GetParam());
-    int normType = std::tr1::get<2>(GetParam());
-
-    Mat src1(sz, matType);
-    double n;
-    
-    declare.in(src1, WARMUP_RNG);
-
-    TEST_CYCLE(100) { n = norm(src1, normType); }
-    
-    SANITY_CHECK(n, 1e-6, ERROR_RELATIVE);
-}
-
-
-/*
-// double norm(InputArray src1, int normType=NORM_L2, InputArray mask=noArray())
-*/
-PERF_TEST_P( Size_MatType_NormType, norm_mask, 
-    testing::Combine(
-        testing::Values( TYPICAL_MAT_SIZES ), 
-        testing::Values( TYPICAL_MAT_TYPES ),
-        testing::Values( (int)NORM_INF, (int)NORM_L1, (int)NORM_L2 )
-    )
-)
-{
-    Size sz = std::tr1::get<0>(GetParam());
-    int matType = std::tr1::get<1>(GetParam());
-    int normType = std::tr1::get<2>(GetParam());
-
-    Mat src1(sz, matType);
-    Mat mask = Mat::ones(sz, CV_8U);
-    double n;
-    
-    declare.in(src1, WARMUP_RNG).in(mask);
-    
-    TEST_CYCLE(100) { n = norm(src1, normType, mask); }
-    
-    SANITY_CHECK(n, 1e-6, ERROR_RELATIVE);
-}
-
-
-/*
-// double norm(InputArray src1, InputArray src2, int normType)
-*/
-PERF_TEST_P( Size_MatType_NormType, norm2, 
-    testing::Combine(
-        testing::Values( TYPICAL_MAT_SIZES ), 
-        testing::Values( TYPICAL_MAT_TYPES ),
-        testing::Values( (int)NORM_INF, (int)NORM_L1, (int)NORM_L2, (int)(NORM_RELATIVE+NORM_INF), (int)(NORM_RELATIVE+NORM_L1), (int)(NORM_RELATIVE+NORM_L2) )
-    )
-)
-{
-    Size sz = std::tr1::get<0>(GetParam());
-    int matType = std::tr1::get<1>(GetParam());
-    int normType = std::tr1::get<2>(GetParam());
-
-    Mat src1(sz, matType);
-    Mat src2(sz, matType);
-    double n;
-    
-    declare.in(src1, src2, WARMUP_RNG);
-    
-    TEST_CYCLE(100) { n = norm(src1, src2, normType); }
-    
-    SANITY_CHECK(n, 1e-5, ERROR_RELATIVE);
-}
-
-
-/*
-// double norm(InputArray src1, InputArray src2, int normType, InputArray mask=noArray())
-*/
-PERF_TEST_P( Size_MatType_NormType, norm2_mask,
-    testing::Combine(
-        testing::Values( TYPICAL_MAT_SIZES ), 
-        testing::Values( TYPICAL_MAT_TYPES ),
-        testing::Values( (int)NORM_INF, (int)NORM_L1, (int)NORM_L2, (int)(NORM_RELATIVE+NORM_INF), (int)(NORM_RELATIVE+NORM_L1), (int)(NORM_RELATIVE+NORM_L2) )
-    )
-)
-{
-    Size sz = std::tr1::get<0>(GetParam());
-    int matType = std::tr1::get<1>(GetParam());
-    int normType = std::tr1::get<2>(GetParam());
-
-    Mat src1(sz, matType);
-    Mat src2(sz, matType);
-    Mat mask = Mat::ones(sz, CV_8U);
-    double n;
-    
-    declare.in(src1, src2, WARMUP_RNG).in(mask);
-    
-    TEST_CYCLE(100) { n = norm(src1, src2, normType, mask); }
-    
-    SANITY_CHECK(n, 1e-5, ERROR_RELATIVE);
-}
-
-
-/*
-// void normalize(const InputArray src, OutputArray dst, double alpha=1, double beta=0, int normType=NORM_L2)
-*/
-PERF_TEST_P( Size_MatType_NormType, normalize, 
-    testing::Combine(
-        testing::Values( TYPICAL_MAT_SIZES ), 
-        testing::Values( TYPICAL_MAT_TYPES ),
-        testing::Values( (int)NORM_INF, (int)NORM_L1, (int)NORM_L2 )
-    )
-)
-{
-    Size sz = std::tr1::get<0>(GetParam());
-    int matType = std::tr1::get<1>(GetParam());
-    int normType = std::tr1::get<2>(GetParam());
-
-    Mat src(sz, matType);
-    Mat dst(sz, matType);
-    double alpha = 100.;
-    if(normType==NORM_L1) alpha = (double)src.total() * src.channels();
-    if(normType==NORM_L2) alpha = (double)src.total()/10;
-    
-    declare.in(src, WARMUP_RNG).out(dst);
-    
-    TEST_CYCLE(100) { normalize(src, dst, alpha, 0., normType);  }
-    
-    SANITY_CHECK(dst, 1e-6);
-}
-
-
-/*
-// void normalize(const InputArray src, OutputArray dst, double alpha=1, double beta=0, int normType=NORM_L2, int rtype=-1, InputArray mask=noArray())
-*/
-PERF_TEST_P( Size_MatType_NormType, normalize_mask, 
-    testing::Combine(
-        testing::Values( TYPICAL_MAT_SIZES ), 
-        testing::Values( TYPICAL_MAT_TYPES ),
-        testing::Values( (int)NORM_INF, (int)NORM_L1, (int)NORM_L2 )
-    )
-)
-{
-    Size sz = std::tr1::get<0>(GetParam());
-    int matType = std::tr1::get<1>(GetParam());
-    int normType = std::tr1::get<2>(GetParam());
-
-    Mat src(sz, matType);
-    Mat dst(sz, matType);
-    Mat mask = Mat::ones(sz, CV_8U);
-    double alpha = 100.;
-    if(normType==NORM_L1) alpha = (double)src.total() * src.channels();
-    if(normType==NORM_L2) alpha = (double)src.total()/10;
-    
-    declare.in(src, WARMUP_RNG).in(mask).out(dst);
-    
-    TEST_CYCLE(100) { normalize(src, dst, alpha, 0., normType, -1, mask);  }
-    
-    SANITY_CHECK(dst, 1e-6);
-}
-
-
-/*
-// void normalize(const InputArray src, OutputArray dst, double alpha=1, double beta=0, int normType=NORM_L2, int rtype=-1)
-*/
-PERF_TEST_P( Size_MatType_NormType, normalize_32f, 
-    testing::Combine(
-        testing::Values( TYPICAL_MAT_SIZES ), 
-        testing::Values( TYPICAL_MAT_TYPES ),
-        testing::Values( (int)NORM_INF, (int)NORM_L1, (int)NORM_L2 )
-    )
-)
-{
-    Size sz = std::tr1::get<0>(GetParam());
-    int matType = std::tr1::get<1>(GetParam());
-    int normType = std::tr1::get<2>(GetParam());
-
-    Mat src(sz, matType);
-    Mat dst(sz, matType);
-    double alpha = 100.;
-    if(normType==NORM_L1) alpha = (double)src.total() * src.channels();
-    if(normType==NORM_L2) alpha = (double)src.total()/10;
-    
-    declare.in(src, WARMUP_RNG).out(dst);
-    
-    TEST_CYCLE(100) { normalize(src, dst, alpha, 0., normType, CV_32F);  }
-
-    SANITY_CHECK(dst, 1e-6, ERROR_RELATIVE);
-}
-
-
-/*
-// void normalize(const InputArray src, OutputArray dst, double alpha=1, double beta=0, int normType=NORM_L2)
-*/
-PERF_TEST_P( Size_MatType, normalize_minmax, TYPICAL_MATS )
-{
-    Size sz = std::tr1::get<0>(GetParam());
-    int matType = std::tr1::get<1>(GetParam());
-
-    Mat src(sz, matType);
-    randu(src, 0, 256);
-    Mat dst(sz, matType);
-    
-    declare.in(src).out(dst);
-    
-    TEST_CYCLE(100) { normalize(src, dst, 20., 100., NORM_MINMAX);  }
-    
-    SANITY_CHECK(dst, 1e-6);
-}
-
-
-/*
-// void meanStdDev(InputArray src, OutputArray mean, OutputArray stddev)
-*/
-PERF_TEST_P( Size_MatType, meanStdDev, TYPICAL_MATS )
+PERF_TEST_P(Size_MatType, meanStdDev, TYPICAL_MATS)
 {
-    Size sz = std::tr1::get<0>(GetParam());
-    int matType = std::tr1::get<1>(GetParam());
+    Size sz = get<0>(GetParam());
+    int matType = get<1>(GetParam());
 
     Mat src(sz, matType);
-    Mat mean, dev;
+    Scalar mean;
+    Scalar dev;
 
-    declare.in(src, WARMUP_RNG);
+    declare.in(src, WARMUP_RNG).out(mean, dev);
 
-    TEST_CYCLE(100) { meanStdDev(src, mean, dev);  }
+    TEST_CYCLE() meanStdDev(src, mean, dev);
     
     SANITY_CHECK(mean, 1e-6);
     SANITY_CHECK(dev, 1e-6);
 }
 
-
-/*
-// void meanStdDev(InputArray src, OutputArray mean, OutputArray stddev, InputArray mask=noArray())
-*/
-PERF_TEST_P( Size_MatType, meanStdDev_mask, TYPICAL_MATS )
+PERF_TEST_P(Size_MatType, meanStdDev_mask, TYPICAL_MATS)
 {
-    Size sz = std::tr1::get<0>(GetParam());
-    int matType = std::tr1::get<1>(GetParam());
+    Size sz = get<0>(GetParam());
+    int matType = get<1>(GetParam());
 
     Mat src(sz, matType);
     Mat mask = Mat::ones(sz, CV_8U);
-    Mat mean, dev;
+    Scalar mean;
+    Scalar dev;
 
-    declare.in(src, WARMUP_RNG).in(mask);
+    declare.in(src, WARMUP_RNG).in(mask).out(mean, dev);
     
-    TEST_CYCLE(100) { meanStdDev(src, mean, dev, mask);  }
+    TEST_CYCLE() meanStdDev(src, mean, dev, mask);
     
     SANITY_CHECK(mean, 1e-6);
     SANITY_CHECK(dev, 1e-6);
 }
 
-
-/*
-// int countNonZero(InputArray mtx)
-*/
-PERF_TEST_P( Size_MatType, countNonZero, TYPICAL_MATS_C1 )
+PERF_TEST_P(Size_MatType, countNonZero, TYPICAL_MATS_C1)
 {
-    Size sz = std::tr1::get<0>(GetParam());
-    int matType = std::tr1::get<1>(GetParam());
+    Size sz = get<0>(GetParam());
+    int matType = get<1>(GetParam());
 
     Mat src(sz, matType);
     int cnt = 0;
 
     declare.in(src, WARMUP_RNG);
     
-    TEST_CYCLE(100) { cnt = countNonZero(src);  }
+    TEST_CYCLE() cnt = countNonZero(src);
     
     SANITY_CHECK(cnt);
 }
-
-/*
-// void minMaxLoc(InputArray src, double* minVal, double* maxVal=0, Point* minLoc=0, Point* maxLoc=0, InputArray mask=noArray())
-*/
-PERF_TEST_P( Size_MatType, minMaxLoc, testing::Combine(
-                 testing::Values( TYPICAL_MAT_SIZES ),
-                 testing::Values( CV_8UC1, CV_8SC1, CV_16UC1, CV_16SC1, CV_32SC1,  CV_32FC1, CV_64FC1 ) ) )
-{
-    Size sz = std::tr1::get<0>(GetParam());
-    int matType = std::tr1::get<1>(GetParam());
-
-    Mat src(sz, matType);
-    double minVal, maxVal;
-    Point minLoc, maxLoc;
-
-    // avoid early exit on 1 byte data
-    if (matType == CV_8U)
-        randu(src, 1, 254);
-    else if (matType == CV_8S)
-        randu(src, -127, 126);
-    else
-        warmup(src, WARMUP_RNG);
-
-    declare.in(src);
-    
-    TEST_CYCLE(100) { minMaxLoc(src, &minVal, &maxVal, &minLoc, &maxLoc);  }
-    
-    SANITY_CHECK(minVal, 1e-12);
-    SANITY_CHECK(maxVal, 1e-12);
-}
-
-
-
-CV_ENUM(ROp, CV_REDUCE_SUM, CV_REDUCE_AVG, CV_REDUCE_MAX, CV_REDUCE_MIN)
-typedef std::tr1::tuple<Size, MatType, ROp> Size_MatType_ROp_t;
-typedef perf::TestBaseWithParam<Size_MatType_ROp_t> Size_MatType_ROp;
-
-
-/*
-// void reduce(InputArray mtx, OutputArray vec, int dim, int reduceOp, int dtype=-1)
-*/
-PERF_TEST_P( Size_MatType_ROp, reduceR, 
-    testing::Combine( 
-        testing::Values( TYPICAL_MAT_SIZES ), 
-        testing::Values( TYPICAL_MAT_TYPES ),
-        testing::ValuesIn(ROp::all())
-    )
-)
-{
-    Size sz = std::tr1::get<0>(GetParam());
-    int matType = std::tr1::get<1>(GetParam());
-    int reduceOp = std::tr1::get<2>(GetParam());
-
-    int ddepth = -1;
-    if( CV_MAT_DEPTH(matType)< CV_32S && (reduceOp == CV_REDUCE_SUM || reduceOp == CV_REDUCE_AVG) )
-        ddepth = CV_32S;
-    Mat src(sz, matType);
-    Mat vec;
-
-    declare.in(src, WARMUP_RNG);
-    
-    TEST_CYCLE(100) { reduce(src, vec, 0, reduceOp, ddepth);  }
-    
-    SANITY_CHECK(vec, 1);
-}
-
-/*
-// void reduce(InputArray mtx, OutputArray vec, int dim, int reduceOp, int dtype=-1)
-*/
-PERF_TEST_P( Size_MatType_ROp, reduceC, 
-    testing::Combine( 
-        testing::Values( TYPICAL_MAT_SIZES ), 
-        testing::Values( TYPICAL_MAT_TYPES ),
-        testing::ValuesIn(ROp::all())
-    )
-)
-{
-    Size sz = std::tr1::get<0>(GetParam());
-    int matType = std::tr1::get<1>(GetParam());
-    int reduceOp = std::tr1::get<2>(GetParam());
-
-    int ddepth = -1;
-    if( CV_MAT_DEPTH(matType)< CV_32S && (reduceOp == CV_REDUCE_SUM || reduceOp == CV_REDUCE_AVG) )
-        ddepth = CV_32S;
-    Mat src(sz, matType);
-    Mat vec;
-
-    declare.in(src, WARMUP_RNG);
-    
-    TEST_CYCLE(100) { reduce(src, vec, 1, reduceOp, ddepth);  }
-
-    SANITY_CHECK(vec, 1);
-}

modules/features2d/perf/perf_fast.cpp

@@ -3,7 +3,8 @@
 using namespace std;
 using namespace cv;
 using namespace perf;
-
+using std::tr1::make_tuple;
+using std::tr1::get;
 
 typedef perf::TestBaseWithParam<std::string> fast;
 
@@ -11,7 +12,7 @@ typedef perf::TestBaseWithParam<std::string> fast;
     "cv/detectors_descriptors_evaluation/images_datasets/leuven/img1.png",\
     "stitching/a3.jpg"
 
-PERF_TEST_P( fast, detectForORB, testing::Values(FAST_IMAGES) )
+PERF_TEST_P(fast, detectForORB, testing::Values(FAST_IMAGES))
 {
     String filename = getDataPath(GetParam());
     Mat frame = imread(filename, IMREAD_GRAYSCALE);
@@ -19,15 +20,11 @@ PERF_TEST_P( fast, detectForORB, testing::Values(FAST_IMAGES) )
     if (frame.empty())
         FAIL() << "Unable to load source image " << filename;
 
-    Mat mask;
     declare.in(frame);
 
     FastFeatureDetector fd(20, true);
     vector<KeyPoint> points;
 
-    TEST_CYCLE(100)
-    {
-        fd.detect(frame, points);
-    }
+    TEST_CYCLE() fd.detect(frame, points);
 }
 

modules/features2d/perf/perf_orb.cpp

@@ -3,7 +3,8 @@
 using namespace std;
 using namespace cv;
 using namespace perf;
-
+using std::tr1::make_tuple;
+using std::tr1::get;
 
 typedef perf::TestBaseWithParam<std::string> orb;
 
@@ -11,7 +12,7 @@ typedef perf::TestBaseWithParam<std::string> orb;
     "cv/detectors_descriptors_evaluation/images_datasets/leuven/img1.png",\
     "stitching/a3.jpg"
 
-PERF_TEST_P( orb, detect, testing::Values(ORB_IMAGES) )
+PERF_TEST_P(orb, detect, testing::Values(ORB_IMAGES))
 {
     String filename = getDataPath(GetParam());
     Mat frame = imread(filename, IMREAD_GRAYSCALE);
@@ -24,13 +25,10 @@ PERF_TEST_P( orb, detect, testing::Values(ORB_IMAGES) )
     ORB detector(1500, ORB::CommonParams(1.3f, 5));
     vector<KeyPoint> points;
 
-    TEST_CYCLE(100)
-    {
-        detector(frame, mask, points);
-    }
+    TEST_CYCLE() detector(frame, mask, points);
 }
 
-PERF_TEST_P( orb, extract, testing::Values(ORB_IMAGES) )
+PERF_TEST_P(orb, extract, testing::Values(ORB_IMAGES))
 {
     String filename = getDataPath(GetParam());
     Mat frame = imread(filename, IMREAD_GRAYSCALE);
@@ -47,13 +45,10 @@ PERF_TEST_P( orb, extract, testing::Values(ORB_IMAGES) )
 
     Mat descriptors;
 
-    TEST_CYCLE(100)
-    {
-        detector(frame, mask, points, descriptors, true);
-    }
+    TEST_CYCLE() detector(frame, mask, points, descriptors, true);
 }
 
-PERF_TEST_P( orb, full, testing::Values(ORB_IMAGES) )
+PERF_TEST_P(orb, full, testing::Values(ORB_IMAGES))
 {
     String filename = getDataPath(GetParam());
     Mat frame = imread(filename, IMREAD_GRAYSCALE);
@@ -68,8 +63,5 @@ PERF_TEST_P( orb, full, testing::Values(ORB_IMAGES) )
     vector<KeyPoint> points;
     Mat descriptors;
 
-    TEST_CYCLE(100)
-    {
-        detector(frame, mask, points, descriptors, false);
-    }
+    TEST_CYCLE() detector(frame, mask, points, descriptors, false);
 }

modules/features2d/perf/perf_surf.cpp

@@ -3,7 +3,8 @@
 using namespace std;
 using namespace cv;
 using namespace perf;
-
+using std::tr1::make_tuple;
+using std::tr1::get;
 
 typedef perf::TestBaseWithParam<std::string> surf;
 
@@ -11,7 +12,7 @@ typedef perf::TestBaseWithParam<std::string> surf;
     "cv/detectors_descriptors_evaluation/images_datasets/leuven/img1.png",\
     "stitching/a3.jpg"
 
-PERF_TEST_P( surf, detect, testing::Values(SURF_IMAGES) )
+PERF_TEST_P(surf, detect, testing::Values(SURF_IMAGES))
 {
     String filename = getDataPath(GetParam());
     Mat frame = imread(filename, IMREAD_GRAYSCALE);
@@ -24,13 +25,10 @@ PERF_TEST_P( surf, detect, testing::Values(SURF_IMAGES) )
     SURF detector;
     vector<KeyPoint> points;
 
-    TEST_CYCLE(100)
-    {
-        detector(frame, mask, points);
-    }
+    TEST_CYCLE() detector(frame, mask, points);
 }
 
-PERF_TEST_P( surf, extract, testing::Values(SURF_IMAGES) )
+PERF_TEST_P(surf, extract, testing::Values(SURF_IMAGES))
 {
     String filename = getDataPath(GetParam());
     Mat frame = imread(filename, IMREAD_GRAYSCALE);
@@ -46,13 +44,10 @@ PERF_TEST_P( surf, extract, testing::Values(SURF_IMAGES) )
     vector<float> descriptors;
     detector(frame, mask, points);
 
-    TEST_CYCLE(100)
-    {
-        detector(frame, mask, points, descriptors, true);
-    }
+    TEST_CYCLE() detector(frame, mask, points, descriptors, true);
 }
 
-PERF_TEST_P( surf, full, testing::Values(SURF_IMAGES) )
+PERF_TEST_P(surf, full, testing::Values(SURF_IMAGES))
 {
     String filename = getDataPath(GetParam());
     Mat frame = imread(filename, IMREAD_GRAYSCALE);
@@ -66,8 +61,5 @@ PERF_TEST_P( surf, full, testing::Values(SURF_IMAGES) )
     vector<KeyPoint> points;
     vector<float> descriptors;
 
-    TEST_CYCLE(100)
-    {
-        detector(frame, mask, points, descriptors, false);
-    }
+    TEST_CYCLE() detector(frame, mask, points, descriptors, false);
 }

modules/gpu/perf/perf_arithm.cpp

@@ -20,7 +20,7 @@ GPU_PERF_TEST(Transpose, cv::gpu::DeviceInfo, cv::Size, perf::MatType)
     cv::gpu::GpuMat src(src_host);
     cv::gpu::GpuMat dst;
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         cv::gpu::transpose(src, dst);
     }
@@ -50,7 +50,7 @@ GPU_PERF_TEST(Flip, cv::gpu::DeviceInfo, cv::Size, perf::MatType, FlipCode)
     cv::gpu::GpuMat src(src_host);
     cv::gpu::GpuMat dst;
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         cv::gpu::flip(src, dst, flipCode);
     }
@@ -81,7 +81,7 @@ GPU_PERF_TEST(LUT, cv::gpu::DeviceInfo, cv::Size, perf::MatType)
     cv::gpu::GpuMat src(src_host);
     cv::gpu::GpuMat dst;
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         cv::gpu::LUT(src, lut, dst);
     }
@@ -113,7 +113,7 @@ GPU_PERF_TEST(CartToPolar, cv::gpu::DeviceInfo, cv::Size)
     cv::gpu::GpuMat magnitude;
     cv::gpu::GpuMat angle;
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         cv::gpu::cartToPolar(x, y, magnitude, angle);
     }
@@ -144,7 +144,7 @@ GPU_PERF_TEST(PolarToCart, cv::gpu::DeviceInfo, cv::Size)
     cv::gpu::GpuMat x;
     cv::gpu::GpuMat y;
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         cv::gpu::polarToCart(magnitude, angle, x, y, true);
     }
@@ -175,7 +175,7 @@ GPU_PERF_TEST(AddMat, cv::gpu::DeviceInfo, cv::Size, perf::MatType)
     cv::gpu::GpuMat src2(src2_host);
     cv::gpu::GpuMat dst;
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         cv::gpu::add(src1, src2, dst);
     }
@@ -205,7 +205,7 @@ GPU_PERF_TEST(AddScalar, cv::gpu::DeviceInfo, cv::Size, perf::MatType)
     cv::Scalar s(1,2,3,4);
     cv::gpu::GpuMat dst;
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         cv::gpu::add(src, s, dst);
     }
@@ -233,7 +233,7 @@ GPU_PERF_TEST(Exp, cv::gpu::DeviceInfo, cv::Size)
     cv::gpu::GpuMat src(src_host);
     cv::gpu::GpuMat dst;
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         cv::gpu::exp(src, dst);
     }
@@ -261,7 +261,7 @@ GPU_PERF_TEST(Pow, cv::gpu::DeviceInfo, cv::Size, perf::MatType)
     cv::gpu::GpuMat src(src_host);
     cv::gpu::GpuMat dst;
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         cv::gpu::pow(src, 0.5, dst);
     }
@@ -292,7 +292,7 @@ GPU_PERF_TEST(Compare, cv::gpu::DeviceInfo, cv::Size, perf::MatType)
     cv::gpu::GpuMat src2(src2_host);
     cv::gpu::GpuMat dst;
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         cv::gpu::compare(src1, src2, dst, cv::CMP_EQ);
     }
@@ -321,7 +321,7 @@ GPU_PERF_TEST(BitwiseNot, cv::gpu::DeviceInfo, cv::Size, perf::MatType)
     cv::gpu::GpuMat src(src_host);
     cv::gpu::GpuMat dst;
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         cv::gpu::bitwise_not(src, dst);
     }
@@ -352,7 +352,7 @@ GPU_PERF_TEST(BitwiseAnd, cv::gpu::DeviceInfo, cv::Size, perf::MatType)
     cv::gpu::GpuMat src2(src2_host);
     cv::gpu::GpuMat dst;
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         cv::gpu::bitwise_and(src1, src2, dst);
     }
@@ -383,7 +383,7 @@ GPU_PERF_TEST(Min, cv::gpu::DeviceInfo, cv::Size, perf::MatType)
     cv::gpu::GpuMat src2(src2_host);
     cv::gpu::GpuMat dst(size, type);
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         cv::gpu::min(src1, src2, dst);
     }
@@ -412,7 +412,7 @@ GPU_PERF_TEST(MeanStdDev, cv::gpu::DeviceInfo, cv::Size)
     cv::Scalar mean;
     cv::Scalar stddev;
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         cv::gpu::meanStdDev(src, mean, stddev);
     }
@@ -442,7 +442,7 @@ GPU_PERF_TEST(Norm, cv::gpu::DeviceInfo, cv::Size, perf::MatType, NormType)
     double dst;
     cv::gpu::GpuMat buf;
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         dst = cv::gpu::norm(src, normType, buf);
     }
@@ -474,7 +474,7 @@ GPU_PERF_TEST(NormDiff, cv::gpu::DeviceInfo, cv::Size, NormType)
     cv::gpu::GpuMat src2(src2_host);
     double dst;
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         dst = cv::gpu::norm(src1, src2, normType);
     }
@@ -504,7 +504,7 @@ GPU_PERF_TEST(Sum, cv::gpu::DeviceInfo, cv::Size, perf::MatType)
     cv::Scalar dst;
     cv::gpu::GpuMat buf;
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         dst = cv::gpu::sum(src, buf);
     }
@@ -534,7 +534,7 @@ GPU_PERF_TEST(MinMax, cv::gpu::DeviceInfo, cv::Size, perf::MatType)
     double minVal, maxVal;
     cv::gpu::GpuMat buf;
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         cv::gpu::minMax(src, &minVal, &maxVal, cv::gpu::GpuMat(), buf);
     }
@@ -565,7 +565,7 @@ GPU_PERF_TEST(MinMaxLoc, cv::gpu::DeviceInfo, cv::Size, perf::MatType)
     cv::Point minLoc, maxLoc;
     cv::gpu::GpuMat valbuf, locbuf;
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         cv::gpu::minMaxLoc(src, &minVal, &maxVal, &minLoc, &maxLoc, cv::gpu::GpuMat(), valbuf, locbuf);
     }
@@ -595,7 +595,7 @@ GPU_PERF_TEST(CountNonZero, cv::gpu::DeviceInfo, cv::Size, perf::MatType)
     int dst;
     cv::gpu::GpuMat buf;
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         dst = cv::gpu::countNonZero(src, buf);
     }
@@ -627,7 +627,7 @@ GPU_PERF_TEST(AddWeighted, cv::gpu::DeviceInfo, cv::Size, perf::MatType)
     cv::gpu::GpuMat src2(src2_host);
     cv::gpu::GpuMat dst;
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         cv::gpu::addWeighted(src1, 0.5, src2, 0.5, 0.0, dst);
     }
@@ -659,7 +659,7 @@ GPU_PERF_TEST(Reduce, cv::gpu::DeviceInfo, cv::Size, perf::MatType, FlipCode)
     cv::gpu::GpuMat src(src_host);
     cv::gpu::GpuMat dst;
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         cv::gpu::reduce(src, dst, dim, CV_REDUCE_MIN);
     }
@@ -698,7 +698,7 @@ GPU_PERF_TEST(GEMM, cv::gpu::DeviceInfo, cv::Size)
 
     declare.time(5.0);
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         cv::gpu::gemm(src1, src2, 1.0, src3, 1.0, dst);
     }

modules/gpu/perf/perf_calib3d.cpp

@@ -18,7 +18,7 @@ GPU_PERF_TEST_1(TransformPoints, cv::gpu::DeviceInfo)
     cv::gpu::GpuMat src(src_host);
     cv::gpu::GpuMat dst;
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         cv::gpu::transformPoints(src, cv::Mat::ones(1, 3, CV_32FC1), cv::Mat::ones(1, 3, CV_32FC1), dst);
     }
@@ -42,7 +42,7 @@ GPU_PERF_TEST_1(ProjectPoints, cv::gpu::DeviceInfo)
     cv::gpu::GpuMat src(src_host);
     cv::gpu::GpuMat dst;
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         cv::gpu::projectPoints(src, cv::Mat::ones(1, 3, CV_32FC1), cv::Mat::ones(1, 3, CV_32FC1), cv::Mat::ones(3, 3, CV_32FC1), cv::Mat(), dst);
     }
@@ -68,7 +68,7 @@ GPU_PERF_TEST_1(SolvePnPRansac, cv::gpu::DeviceInfo)
 
     declare.time(3.0);
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         cv::gpu::solvePnPRansac(object, image, cv::Mat::ones(3, 3, CV_32FC1), cv::Mat(1, 8, CV_32F, cv::Scalar::all(0)), rvec, tvec);
     }
@@ -99,7 +99,7 @@ GPU_PERF_TEST_1(StereoBM, cv::gpu::DeviceInfo)
 
     declare.time(5.0);
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         bm(img_l, img_r, dst);
     }
@@ -130,7 +130,7 @@ GPU_PERF_TEST_1(StereoBeliefPropagation, cv::gpu::DeviceInfo)
 
     declare.time(10.0);
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         bp(img_l, img_r, dst);
     }
@@ -161,7 +161,7 @@ GPU_PERF_TEST_1(StereoConstantSpaceBP, cv::gpu::DeviceInfo)
 
     declare.time(10.0);
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         bp(img_l, img_r, dst);
     }
@@ -190,7 +190,7 @@ GPU_PERF_TEST_1(DisparityBilateralFilter, cv::gpu::DeviceInfo)
 
     cv::gpu::DisparityBilateralFilter f(128);
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         f(disp, img, dst);
     }

modules/gpu/perf/perf_features2d.cpp

@@ -25,7 +25,7 @@ GPU_PERF_TEST(BruteForceMatcher_match, cv::gpu::DeviceInfo, int)
 
     declare.time(3.0);
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         matcher.matchSingle(query, train, trainIdx, distance);
     }
@@ -59,7 +59,7 @@ GPU_PERF_TEST(BruteForceMatcher_knnMatch, cv::gpu::DeviceInfo, int, int)
 
     declare.time(3.0);
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         matcher.knnMatchSingle(query, train, trainIdx, distance, allDist, k);
     }
@@ -94,7 +94,7 @@ GPU_PERF_TEST(BruteForceMatcher_radiusMatch, cv::gpu::DeviceInfo, int)
 
     declare.time(3.0);
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         matcher.radiusMatchSingle(query, train, trainIdx, distance, nMatches, 2.0);
     }
@@ -124,7 +124,7 @@ GPU_PERF_TEST_1(SURF, cv::gpu::DeviceInfo)
 
     declare.time(2.0);
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         surf(img, cv::gpu::GpuMat(), keypoints, descriptors);
     }
@@ -150,7 +150,7 @@ GPU_PERF_TEST_1(FAST, cv::gpu::DeviceInfo)
 
     cv::gpu::FAST_GPU fastGPU(20);
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         fastGPU(img, cv::gpu::GpuMat(), keypoints);
     }
@@ -176,7 +176,7 @@ GPU_PERF_TEST_1(ORB, cv::gpu::DeviceInfo)
 
     cv::gpu::ORB_GPU orbGPU(4000);
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         orbGPU(img, cv::gpu::GpuMat(), keypoints, descriptors);
     }

modules/gpu/perf/perf_filters.cpp

@@ -23,7 +23,7 @@ GPU_PERF_TEST(BoxFilter, cv::gpu::DeviceInfo, cv::Size, perf::MatType, int)
 
     cv::Ptr<cv::gpu::FilterEngine_GPU> filter = cv::gpu::createBoxFilter_GPU(type, type, cv::Size(ksize, ksize));
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         filter->apply(src, dst);
     }
@@ -57,7 +57,7 @@ GPU_PERF_TEST(MorphologyFilter, cv::gpu::DeviceInfo, cv::Size, perf::MatType, Mo
 
     cv::Ptr<cv::gpu::FilterEngine_GPU> filter = cv::gpu::createMorphologyFilter_GPU(op, type, cv::Mat::ones(ksize, ksize, CV_8U));
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         filter->apply(src, dst);
     }
@@ -93,7 +93,7 @@ GPU_PERF_TEST(LinearFilter, cv::gpu::DeviceInfo, cv::Size, perf::MatType, int)
 
     declare.time(1.0);
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         filter->apply(src, dst);
     }
@@ -129,7 +129,7 @@ GPU_PERF_TEST(SeparableLinearFilter, cv::gpu::DeviceInfo, cv::Size, perf::MatTyp
 
     declare.time(1.0);
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         filter->apply(src, dst, cv::Rect(0, 0, src.cols, src.rows));
     }

modules/gpu/perf/perf_imgproc.cpp

@@ -28,7 +28,7 @@ GPU_PERF_TEST(Remap, cv::gpu::DeviceInfo, cv::Size, perf::MatType, Interpolation
 
     declare.time(3.0);
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         cv::gpu::remap(src, dst, xmap, ymap, interpolation, borderMode);
     }
@@ -61,7 +61,7 @@ GPU_PERF_TEST_1(MeanShiftFiltering, cv::gpu::DeviceInfo)
 
     declare.time(5.0);
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         cv::gpu::meanShiftFiltering(src, dst, 50, 50);
     }
@@ -90,7 +90,7 @@ GPU_PERF_TEST_1(MeanShiftProc, cv::gpu::DeviceInfo)
 
     declare.time(5.0);
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         cv::gpu::meanShiftProc(src, dstr, dstsp, 50, 50);
     }
@@ -118,7 +118,7 @@ GPU_PERF_TEST_1(MeanShiftSegmentation, cv::gpu::DeviceInfo)
 
     declare.time(5.0);
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         meanShiftSegmentation(src, dst, 10, 10, 20);
     }
@@ -144,7 +144,7 @@ GPU_PERF_TEST(DrawColorDisp, cv::gpu::DeviceInfo, cv::Size, perf::MatType)
     cv::gpu::GpuMat src(src_host);
     cv::gpu::GpuMat dst;
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         cv::gpu::drawColorDisp(src, dst, 255);
     }
@@ -173,7 +173,7 @@ GPU_PERF_TEST(ReprojectImageTo3D, cv::gpu::DeviceInfo, cv::Size, perf::MatType)
     cv::gpu::GpuMat src(src_host);
     cv::gpu::GpuMat dst;
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         cv::gpu::reprojectImageTo3D(src, dst, cv::Mat::ones(4, 4, CV_32FC1));
     }
@@ -203,7 +203,7 @@ GPU_PERF_TEST(CvtColor, cv::gpu::DeviceInfo, cv::Size, perf::MatType, CvtColorIn
     cv::gpu::GpuMat src(src_host);
     cv::gpu::GpuMat dst(size, CV_MAKETYPE(type, info.dcn));
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         cv::gpu::cvtColor(src, dst, info.code, info.dcn);
     }
@@ -236,7 +236,7 @@ GPU_PERF_TEST(Threshold, cv::gpu::DeviceInfo, cv::Size, perf::MatType)
     cv::gpu::GpuMat src(src_host);
     cv::gpu::GpuMat dst(size, type);
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         cv::gpu::threshold(src, dst, 100.0, 255.0, cv::THRESH_BINARY);
     }
@@ -269,7 +269,7 @@ GPU_PERF_TEST(Resize, cv::gpu::DeviceInfo, cv::Size, perf::MatType, Interpolatio
 
     declare.time(1.0);
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         cv::gpu::resize(src, dst, cv::Size(), f, f, interpolation);
     }
@@ -307,7 +307,7 @@ GPU_PERF_TEST(WarpAffine, cv::gpu::DeviceInfo, cv::Size, perf::MatType, Interpol
     reflect[1][2] = size.height;
     cv::Mat M(2, 3, CV_64F, (void*) reflect); 
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         cv::gpu::warpAffine(src, dst, M, size, interpolation);
     }
@@ -345,7 +345,7 @@ GPU_PERF_TEST(WarpPerspective, cv::gpu::DeviceInfo, cv::Size, perf::MatType, Int
     reflect[1][2] = size.height;
     cv::Mat M(3, 3, CV_64F, (void*)reflect); 
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         cv::gpu::warpPerspective(src, dst, M, size, interpolation);
     }
@@ -370,7 +370,7 @@ GPU_PERF_TEST(BuildWarpPlaneMaps, cv::gpu::DeviceInfo, cv::Size)
     cv::gpu::GpuMat map_x;
     cv::gpu::GpuMat map_y;
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         cv::gpu::buildWarpPlaneMaps(size, cv::Rect(0, 0, size.width, size.height), cv::Mat::eye(3, 3, CV_32FC1), 
                                     cv::Mat::ones(3, 3, CV_32FC1), cv::Mat::zeros(1, 3, CV_32F), 1.0, map_x, map_y);
@@ -394,7 +394,7 @@ GPU_PERF_TEST(BuildWarpCylindricalMaps, cv::gpu::DeviceInfo, cv::Size)
     cv::gpu::GpuMat map_x;
     cv::gpu::GpuMat map_y;
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         cv::gpu::buildWarpCylindricalMaps(size, cv::Rect(0, 0, size.width, size.height), cv::Mat::eye(3, 3, CV_32FC1),
                                           cv::Mat::ones(3, 3, CV_32FC1), 1.0, map_x, map_y);
@@ -418,7 +418,7 @@ GPU_PERF_TEST(BuildWarpSphericalMaps, cv::gpu::DeviceInfo, cv::Size)
     cv::gpu::GpuMat map_x;
     cv::gpu::GpuMat map_y;
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         cv::gpu::buildWarpSphericalMaps(size, cv::Rect(0, 0, size.width, size.height), cv::Mat::eye(3, 3, CV_32FC1),
                                         cv::Mat::ones(3, 3, CV_32FC1), 1.0, map_x, map_y);
@@ -448,7 +448,7 @@ GPU_PERF_TEST(Rotate, cv::gpu::DeviceInfo, cv::Size, perf::MatType, Interpolatio
     cv::gpu::GpuMat src(src_host);
     cv::gpu::GpuMat dst;
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         cv::gpu::rotate(src, dst, size, 30.0, 0, 0, interpolation);
     }
@@ -479,7 +479,7 @@ GPU_PERF_TEST(CopyMakeBorder, cv::gpu::DeviceInfo, cv::Size, perf::MatType, Bord
     cv::gpu::GpuMat src(src_host);
     cv::gpu::GpuMat dst;
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         cv::gpu::copyMakeBorder(src, dst, 5, 5, 5, 5, borderType);
     }
@@ -509,7 +509,7 @@ GPU_PERF_TEST(Integral, cv::gpu::DeviceInfo, cv::Size)
     cv::gpu::GpuMat dst;
     cv::gpu::GpuMat buf;
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         cv::gpu::integralBuffered(src, dst, buf);
     }
@@ -536,7 +536,7 @@ GPU_PERF_TEST(IntegralBoth, cv::gpu::DeviceInfo, cv::Size)
     cv::gpu::GpuMat src(src_host);
     cv::gpu::GpuMat sum, sqsum;
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         cv::gpu::integral(src, sum, sqsum);
     }
@@ -563,7 +563,7 @@ GPU_PERF_TEST(IntegralSqr, cv::gpu::DeviceInfo, cv::Size)
     cv::gpu::GpuMat src(src_host);
     cv::gpu::GpuMat dst;
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         cv::gpu::sqrIntegral(src, dst);
     }
@@ -590,7 +590,7 @@ GPU_PERF_TEST(ColumnSum, cv::gpu::DeviceInfo, cv::Size)
     cv::gpu::GpuMat src(src_host);
     cv::gpu::GpuMat dst;
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         cv::gpu::columnSum(src, dst);
     }
@@ -624,7 +624,7 @@ GPU_PERF_TEST(CornerHarris, cv::gpu::DeviceInfo, perf::MatType)
     int ksize = 7;        
     double k = 0.5;
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         cv::gpu::cornerHarris(src, dst, Dx, Dy, blockSize, ksize, k);
     }
@@ -657,7 +657,7 @@ GPU_PERF_TEST(CornerMinEigenVal, cv::gpu::DeviceInfo, perf::MatType)
     int blockSize = 3;
     int ksize = 7; 
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         cv::gpu::cornerMinEigenVal(src, dst, Dx, Dy, blockSize, ksize);
     }
@@ -686,7 +686,7 @@ GPU_PERF_TEST(MulSpectrums, cv::gpu::DeviceInfo, cv::Size)
     cv::gpu::GpuMat b(b_host);
     cv::gpu::GpuMat dst;
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         cv::gpu::mulSpectrums(a, b, dst, 0);
     }
@@ -715,7 +715,7 @@ GPU_PERF_TEST(Dft, cv::gpu::DeviceInfo, cv::Size)
 
     declare.time(2.0);
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         cv::gpu::dft(src, dst, size);
     }
@@ -747,7 +747,7 @@ GPU_PERF_TEST(Convolve, cv::gpu::DeviceInfo, cv::Size, int)
 
     declare.time(2.0);
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         cv::gpu::convolve(image, templ, dst, false, buf);
     }
@@ -776,7 +776,7 @@ GPU_PERF_TEST(PyrDown, cv::gpu::DeviceInfo, cv::Size, perf::MatType)
     cv::gpu::GpuMat src(src_host);
     cv::gpu::GpuMat dst;
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         cv::gpu::pyrDown(src, dst);
     }
@@ -805,7 +805,7 @@ GPU_PERF_TEST(PyrUp, cv::gpu::DeviceInfo, cv::Size, perf::MatType)
     cv::gpu::GpuMat src(src_host);
     cv::gpu::GpuMat dst;
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         cv::gpu::pyrUp(src, dst);
     }
@@ -838,7 +838,7 @@ GPU_PERF_TEST(BlendLinear, cv::gpu::DeviceInfo, cv::Size, perf::MatType)
     cv::gpu::GpuMat weights2(size, CV_32FC1, cv::Scalar::all(0.5));
     cv::gpu::GpuMat dst;
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         cv::gpu::blendLinear(img1, img2, weights1, weights2, dst);
     }
@@ -865,7 +865,7 @@ GPU_PERF_TEST_1(Canny, cv::gpu::DeviceInfo)
     cv::gpu::GpuMat dst;
     cv::gpu::CannyBuf buf;
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         cv::gpu::Canny(image, buf, dst, 50.0, 100.0);
     }
@@ -891,7 +891,7 @@ GPU_PERF_TEST(CalcHist, cv::gpu::DeviceInfo, cv::Size)
     cv::gpu::GpuMat hist;
     cv::gpu::GpuMat buf;
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         cv::gpu::calcHist(src, hist, buf);
     }
@@ -920,7 +920,7 @@ GPU_PERF_TEST(EqualizeHist, cv::gpu::DeviceInfo, cv::Size)
     cv::gpu::GpuMat hist;
     cv::gpu::GpuMat buf;
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         cv::gpu::equalizeHist(src, dst, hist, buf);
     }
@@ -949,7 +949,7 @@ GPU_PERF_TEST(ImagePyramid_build, cv::gpu::DeviceInfo, cv::Size, perf::MatType)
 
     cv::gpu::ImagePyramid pyr;
     
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         pyr.build(src, 5);
     }
@@ -977,7 +977,7 @@ GPU_PERF_TEST(ImagePyramid_getLayer, cv::gpu::DeviceInfo, cv::Size, perf::MatTyp
 
     cv::gpu::ImagePyramid pyr(src, 3);
     
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         pyr.getLayer(dst, cv::Size(size.width / 2 + 10, size.height / 2 + 10));
     }

modules/gpu/perf/perf_matop.cpp

@@ -21,7 +21,7 @@ GPU_PERF_TEST(Merge, cv::gpu::DeviceInfo, cv::Size, perf::MatType)
 
     cv::gpu::GpuMat dst;
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         cv::gpu::merge(src, dst);
     }
@@ -51,7 +51,7 @@ GPU_PERF_TEST(Split, cv::gpu::DeviceInfo, cv::Size, perf::MatType)
     for (int i = 0; i < num_channels; ++i)
         dst[i] = cv::gpu::GpuMat(size, type); 
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         cv::gpu::split(src, dst);
     }
@@ -76,7 +76,7 @@ GPU_PERF_TEST(SetTo, cv::gpu::DeviceInfo, cv::Size, perf::MatType)
     cv::gpu::GpuMat src(size, type);
     cv::Scalar val(1, 2, 3, 4);
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         src.setTo(val);
     }
@@ -108,7 +108,7 @@ GPU_PERF_TEST(SetToMasked, cv::gpu::DeviceInfo, cv::Size, perf::MatType)
     cv::Scalar val(1, 2, 3, 4);
     cv::gpu::GpuMat mask(mask_host);
     
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         src.setTo(val, mask);
     }
@@ -140,7 +140,7 @@ GPU_PERF_TEST(CopyToMasked, cv::gpu::DeviceInfo, cv::Size, perf::MatType)
     cv::gpu::GpuMat mask(mask_host);
     cv::gpu::GpuMat dst;
     
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         src.copyTo(dst, mask);
     }
@@ -170,7 +170,7 @@ GPU_PERF_TEST(ConvertTo, cv::gpu::DeviceInfo, cv::Size, perf::MatType, perf::Mat
     cv::gpu::GpuMat src(src_host);
     cv::gpu::GpuMat dst;
     
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         src.convertTo(dst, type2, 0.5, 1.0);
     }

modules/gpu/perf/perf_objdetect.cpp

@@ -16,7 +16,7 @@ GPU_PERF_TEST_1(HOG, cv::gpu::DeviceInfo)
     cv::gpu::HOGDescriptor hog;
     hog.setSVMDetector(cv::gpu::HOGDescriptor::getDefaultPeopleDetector());
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         hog.detectMultiScale(img, found_locations);
     }

modules/gpu/perf/perf_video.cpp

@@ -30,7 +30,7 @@ GPU_PERF_TEST_1(BroxOpticalFlow, cv::gpu::DeviceInfo)
 
     declare.time(10);
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         d_flow(frame0, frame1, u, v);
     }
@@ -70,7 +70,7 @@ GPU_PERF_TEST_1(InterpolateFrames, cv::gpu::DeviceInfo)
     cv::gpu::GpuMat newFrame;
     cv::gpu::GpuMat buf;
 
-    TEST_CYCLE(100)
+    TEST_CYCLE()
     {
         cv::gpu::interpolateFrames(frame0, frame1, fu, fv, bu, bv, 0.5f, newFrame, buf);
     }

modules/imgproc/perf/perf_blur.cpp

@@ -9,13 +9,13 @@ using std::tr1::get;
 typedef std::tr1::tuple<Size, MatType, int> Size_MatType_kSize_t;
 typedef perf::TestBaseWithParam<Size_MatType_kSize_t> Size_MatType_kSize;
 
-PERF_TEST_P( Size_MatType_kSize, medianBlur,
-             testing::Combine(
-                 testing::Values(szODD, szQVGA, szVGA, sz720p),
-                 testing::Values(CV_8UC1, CV_8UC4, CV_16UC1, CV_16SC1, CV_32FC1),
-                 testing::Values(3, 5)
-                 )
-             )
+PERF_TEST_P(Size_MatType_kSize, medianBlur,
+            testing::Combine(
+                testing::Values(szODD, szQVGA, szVGA, sz720p),
+                testing::Values(CV_8UC1, CV_8UC4, CV_16UC1, CV_16SC1, CV_32FC1),
+                testing::Values(3, 5)
+                )
+            )
 {
     Size size = get<0>(GetParam());
     int type = get<1>(GetParam());
@@ -29,10 +29,7 @@ PERF_TEST_P( Size_MatType_kSize, medianBlur,
     if (CV_MAT_DEPTH(type) > CV_16S || CV_MAT_CN(type) > 1)
         declare.time(15);
 
-    TEST_CYCLE(100)
-    {
-        medianBlur(src, dst, ksize);
-    }
+    TEST_CYCLE() medianBlur(src, dst, ksize);
 
     SANITY_CHECK(dst);
 }
@@ -46,13 +43,13 @@ typedef perf::TestBaseWithParam<Size_MatType_BorderType3x3_t> Size_MatType_Borde
 typedef std::tr1::tuple<Size, MatType, BorderType> Size_MatType_BorderType_t;
 typedef perf::TestBaseWithParam<Size_MatType_BorderType_t> Size_MatType_BorderType;
 
-PERF_TEST_P( Size_MatType_BorderType3x3, gaussianBlur3x3,
-             testing::Combine(
-                 testing::Values(szODD, szQVGA, szVGA, sz720p),
-                 testing::Values(CV_8UC1, CV_8UC4, CV_16UC1, CV_16SC1, CV_32FC1),
-                 testing::ValuesIn(BorderType3x3::all())
-                 )
-             )
+PERF_TEST_P(Size_MatType_BorderType3x3, gaussianBlur3x3,
+            testing::Combine(
+                testing::Values(szODD, szQVGA, szVGA, sz720p),
+                testing::Values(CV_8UC1, CV_8UC4, CV_16UC1, CV_16SC1, CV_32FC1),
+                testing::ValuesIn(BorderType3x3::all())
+                )
+            )
 {
     Size size = get<0>(GetParam());
     int type = get<1>(GetParam());
@@ -63,21 +60,18 @@ PERF_TEST_P( Size_MatType_BorderType3x3, gaussianBlur3x3,
 
     declare.in(src, WARMUP_RNG).out(dst);
 
-    TEST_CYCLE(100)
-    {
-        GaussianBlur(src, dst, Size(3,3), 0, 0, btype);
-    }
+    TEST_CYCLE() GaussianBlur(src, dst, Size(3,3), 0, 0, btype);
 
     SANITY_CHECK(dst);
 }
 
-PERF_TEST_P( Size_MatType_BorderType3x3, blur3x3,
-             testing::Combine(
-                 testing::Values(szODD, szQVGA, szVGA, sz720p),
-                 testing::Values(CV_8UC1, CV_8UC4, CV_16UC1, CV_16SC1, CV_32FC1),
-                 testing::ValuesIn(BorderType3x3::all())
-                 )
-             )
+PERF_TEST_P(Size_MatType_BorderType3x3, blur3x3,
+            testing::Combine(
+                testing::Values(szODD, szQVGA, szVGA, sz720p),
+                testing::Values(CV_8UC1, CV_8UC4, CV_16UC1, CV_16SC1, CV_32FC1),
+                testing::ValuesIn(BorderType3x3::all())
+                )
+            )
 {
     Size size = get<0>(GetParam());
     int type = get<1>(GetParam());
@@ -88,21 +82,18 @@ PERF_TEST_P( Size_MatType_BorderType3x3, blur3x3,
 
     declare.in(src, WARMUP_RNG).out(dst);
 
-    TEST_CYCLE(100)
-    {
-        blur(src, dst, Size(3,3), Point(-1,-1), btype);
-    }
+    TEST_CYCLE() blur(src, dst, Size(3,3), Point(-1,-1), btype);
 
     SANITY_CHECK(dst);
 }
 
-PERF_TEST_P( Size_MatType_BorderType, gaussianBlur5x5,
-             testing::Combine(
-                 testing::Values(szODD, szQVGA, szVGA, sz720p),
-                 testing::Values(CV_8UC1, CV_8UC4, CV_16UC1, CV_16SC1, CV_32FC1),
-                 testing::ValuesIn(BorderType::all())
-                 )
-             )
+PERF_TEST_P(Size_MatType_BorderType, gaussianBlur5x5,
+            testing::Combine(
+                testing::Values(szODD, szQVGA, szVGA, sz720p),
+                testing::Values(CV_8UC1, CV_8UC4, CV_16UC1, CV_16SC1, CV_32FC1),
+                testing::ValuesIn(BorderType::all())
+                )
+            )
 {
     Size size = get<0>(GetParam());
     int type = get<1>(GetParam());
@@ -113,21 +104,18 @@ PERF_TEST_P( Size_MatType_BorderType, gaussianBlur5x5,
 
     declare.in(src, WARMUP_RNG).out(dst);
 
-    TEST_CYCLE(100)
-    {
-        GaussianBlur(src, dst, Size(5,5), 0, 0, btype);
-    }
+    TEST_CYCLE() GaussianBlur(src, dst, Size(5,5), 0, 0, btype);
 
     SANITY_CHECK(dst);
 }
 
-PERF_TEST_P( Size_MatType_BorderType, blur5x5,
-             testing::Combine(
-                 testing::Values(szODD, szQVGA, szVGA, sz720p),
-                 testing::Values(CV_8UC1, CV_8UC4, CV_16UC1, CV_16SC1, CV_32FC1),
-                 testing::ValuesIn(BorderType::all())
-                 )
-             )
+PERF_TEST_P(Size_MatType_BorderType, blur5x5,
+            testing::Combine(
+                testing::Values(szODD, szQVGA, szVGA, sz720p),
+                testing::Values(CV_8UC1, CV_8UC4, CV_16UC1, CV_16SC1, CV_32FC1),
+                testing::ValuesIn(BorderType::all())
+                )
+            )
 {
     Size size = get<0>(GetParam());
     int type = get<1>(GetParam());
@@ -138,10 +126,7 @@ PERF_TEST_P( Size_MatType_BorderType, blur5x5,
 
     declare.in(src, WARMUP_RNG).out(dst);
 
-    TEST_CYCLE(100)
-    {
-        blur(src, dst, Size(5,5), Point(-1,-1), btype);
-    }
+    TEST_CYCLE() blur(src, dst, Size(5,5), Point(-1,-1), btype);
 
     SANITY_CHECK(dst);
 }

modules/imgproc/perf/perf_canny.cpp

@@ -9,14 +9,14 @@ using std::tr1::get;
 typedef std::tr1::tuple<String, int, bool, std::tr1::tuple<double, double> > Img_Aperture_L2_thresholds_t;
 typedef perf::TestBaseWithParam<Img_Aperture_L2_thresholds_t> Img_Aperture_L2_thresholds;
 
-PERF_TEST_P( Img_Aperture_L2_thresholds, canny,
-             testing::Combine(
-                 testing::Values( "cv/shared/lena.jpg", "stitching/b1.jpg", "cv/detectors_descriptors_evaluation/images_datasets/leuven/img1.png" ),
-                 testing::Values( 3, 5 ),
-                 testing::Bool(),
-                 testing::Values( make_tuple(50.0, 100.0), make_tuple(0.0, 50.0), make_tuple(100.0, 120.0) )
-             )
-           )
+PERF_TEST_P(Img_Aperture_L2_thresholds, canny,
+            testing::Combine(
+                testing::Values( "cv/shared/lena.jpg", "stitching/b1.jpg", "cv/detectors_descriptors_evaluation/images_datasets/leuven/img1.png" ),
+                testing::Values( 3, 5 ),
+                testing::Bool(),
+                testing::Values( make_tuple(50.0, 100.0), make_tuple(0.0, 50.0), make_tuple(100.0, 120.0) )
+                )
+            )
 {
     String filename = getDataPath(get<0>(GetParam()));
     int aperture = get<1>(GetParam());
@@ -31,9 +31,7 @@ PERF_TEST_P( Img_Aperture_L2_thresholds, canny,
 
     declare.in(img).out(edges);
 
-
-    TEST_CYCLE(100) { Canny(img, edges, thresh_low, thresh_high, aperture, useL2); }
-
+    TEST_CYCLE() Canny(img, edges, thresh_low, thresh_high, aperture, useL2);
 
     SANITY_CHECK(edges);
 }

modules/imgproc/perf/perf_cvt_color.cpp

@@ -3,13 +3,15 @@
 using namespace std;
 using namespace cv;
 using namespace perf;
+using std::tr1::make_tuple;
+using std::tr1::get;
 
 CV_ENUM(CvtMode, CV_YUV2BGR, CV_YUV2RGB, //YUV
-                 CV_YUV420i2BGR, CV_YUV420i2RGB, CV_YUV420sp2BGR, CV_YUV420sp2RGB, //YUV420
-                 CV_RGB2GRAY, CV_RGBA2GRAY, CV_BGR2GRAY, CV_BGRA2GRAY, //Gray
-                 CV_GRAY2RGB, CV_GRAY2RGBA, /*CV_GRAY2BGR, CV_GRAY2BGRA*/ //Gray2
-                 CV_BGR2HSV, CV_RGB2HSV, CV_BGR2HLS, CV_RGB2HLS //H
-)
+        CV_YUV420i2BGR, CV_YUV420i2RGB, CV_YUV420sp2BGR, CV_YUV420sp2RGB, //YUV420
+        CV_RGB2GRAY, CV_RGBA2GRAY, CV_BGR2GRAY, CV_BGRA2GRAY, //Gray
+        CV_GRAY2RGB, CV_GRAY2RGBA, /*CV_GRAY2BGR, CV_GRAY2BGRA*/ //Gray2
+        CV_BGR2HSV, CV_RGB2HSV, CV_BGR2HLS, CV_RGB2HLS //H
+        )
 
 typedef std::tr1::tuple<Size, CvtMode> Size_CvtMode_t;
 typedef perf::TestBaseWithParam<Size_CvtMode_t> Size_CvtMode;
@@ -17,116 +19,110 @@ typedef perf::TestBaseWithParam<Size_CvtMode_t> Size_CvtMode;
 typedef std::tr1::tuple<Size, CvtMode, int> Size_CvtMode_OutChNum_t;
 typedef perf::TestBaseWithParam<Size_CvtMode_OutChNum_t> Size_CvtMode_OutChNum;
 
-
-/*
-// void cvtColor(InputArray src, OutputArray dst, int code, int dstCn=0 )
-*/
-
-
-PERF_TEST_P( Size_CvtMode_OutChNum, cvtColorYUV,
-    testing::Combine( 
-    testing::Values( TYPICAL_MAT_SIZES ), 
-        testing::Values( (int)CV_YUV2BGR, (int)CV_YUV2RGB ),
-        testing::Values( 3, 4 )
-    )
-)
+PERF_TEST_P(Size_CvtMode_OutChNum, cvtColorYUV,
+            testing::Combine(
+                testing::Values(TYPICAL_MAT_SIZES),
+                testing::Values((int)CV_YUV2BGR, (int)CV_YUV2RGB),
+                testing::Values(3, 4)
+                )
+            )
 {
-    Size sz = std::tr1::get<0>(GetParam());
-    int mode = std::tr1::get<1>(GetParam());
-    int ch = std::tr1::get<2>(GetParam());
+    Size sz = get<0>(GetParam());
+    int mode = get<1>(GetParam());
+    int ch = get<2>(GetParam());
 
     Mat src(sz, CV_8UC3);
     Mat dst(sz, CV_8UC(ch));
 
     declare.in(src, WARMUP_RNG).out(dst);
     
-    TEST_CYCLE(100) { cvtColor(src, dst, mode, ch);  }
+    TEST_CYCLE() cvtColor(src, dst, mode, ch);
     
-    SANITY_CHECK(dst);
+    SANITY_CHECK(dst, 1);
 }
 
 
-PERF_TEST_P( Size_CvtMode_OutChNum, cvtColorYUV420,
-    testing::Combine( 
-        testing::Values( szVGA, sz720p, sz1080p, Size(130, 60) ), 
-        testing::Values( (int)CV_YUV420i2BGR, (int)CV_YUV420i2RGB, (int)CV_YUV420sp2BGR, (int)CV_YUV420sp2RGB ),
-        testing::Values( 3, 4 )
-    )
-)
+PERF_TEST_P(Size_CvtMode_OutChNum, cvtColorYUV420,
+            testing::Combine(
+                testing::Values(szVGA, sz720p, sz1080p, Size(130, 60)),
+                testing::Values((int)CV_YUV420i2BGR, (int)CV_YUV420i2RGB, (int)CV_YUV420sp2BGR, (int)CV_YUV420sp2RGB),
+                testing::Values(3, 4)
+                )
+            )
 {
-    Size sz = std::tr1::get<0>(GetParam());
-    int mode = std::tr1::get<1>(GetParam());
-    int ch = std::tr1::get<2>(GetParam());
+    Size sz = get<0>(GetParam());
+    int mode = get<1>(GetParam());
+    int ch = get<2>(GetParam());
 
-    Mat src(sz.height+sz.height/2, sz.width, CV_8UC1);
+    Mat src(sz.height + sz.height / 2, sz.width, CV_8UC1);
     Mat dst(sz, CV_8UC(ch));
 
     declare.in(src, WARMUP_RNG).out(dst);
     
-    TEST_CYCLE(100) { cvtColor(src, dst, mode, ch);  }
+    TEST_CYCLE() cvtColor(src, dst, mode, ch);
     
-    SANITY_CHECK(dst);
+    SANITY_CHECK(dst, 1);
 }
 
 
-PERF_TEST_P( Size_CvtMode, cvtColorGray,
-    testing::Combine( 
-        testing::Values( TYPICAL_MAT_SIZES ), 
-        testing::Values( (int)CV_RGB2GRAY, (int)CV_RGBA2GRAY, (int)CV_BGR2GRAY, (int)CV_BGRA2GRAY )
-    )
-)
+PERF_TEST_P(Size_CvtMode, cvtColorGray,
+            testing::Combine(
+                testing::Values(TYPICAL_MAT_SIZES),
+                testing::Values((int)CV_RGB2GRAY, (int)CV_RGBA2GRAY, (int)CV_BGR2GRAY, (int)CV_BGRA2GRAY)
+                )
+            )
 {
-    Size sz = std::tr1::get<0>(GetParam());
-    int mode = std::tr1::get<1>(GetParam());
+    Size sz = get<0>(GetParam());
+    int mode = get<1>(GetParam());
 
-    Mat src(sz, CV_8UC((mode==CV_RGBA2GRAY || mode==CV_BGRA2GRAY)?4:3));
+    Mat src(sz, CV_8UC((mode==CV_RGBA2GRAY || mode==CV_BGRA2GRAY) ? 4 : 3));
     Mat dst(sz, CV_8UC1);
 
     declare.in(src, WARMUP_RNG).out(dst);
     
-    TEST_CYCLE(100) { cvtColor(src, dst, mode);  }
+    TEST_CYCLE() cvtColor(src, dst, mode);
     
     SANITY_CHECK(dst);
 }
 
 
-PERF_TEST_P( Size_CvtMode, cvtColorGray2,
-    testing::Combine( 
-        testing::Values( TYPICAL_MAT_SIZES ), 
-        testing::Values( (int)CV_GRAY2RGB, (int)CV_GRAY2RGBA/*, CV_GRAY2BGR, CV_GRAY2BGRA*/ )
-    )
-)
+PERF_TEST_P(Size_CvtMode, cvtColorGray2,
+            testing::Combine(
+                testing::Values(TYPICAL_MAT_SIZES),
+                testing::Values((int)CV_GRAY2RGB, (int)CV_GRAY2RGBA)
+                )
+            )
 {
-    Size sz = std::tr1::get<0>(GetParam());
-    int mode = std::tr1::get<1>(GetParam());
+    Size sz = get<0>(GetParam());
+    int mode = get<1>(GetParam());
 
     Mat src(sz, CV_8UC1);
-    Mat dst(sz, CV_8UC((mode==CV_GRAY2RGBA || mode==CV_GRAY2BGRA)?4:3));
+    Mat dst(sz, CV_8UC((mode==CV_GRAY2RGBA || mode==CV_GRAY2BGRA) ? 4 : 3));
 
     declare.in(src, WARMUP_RNG).out(dst);
     
-    TEST_CYCLE(100) { cvtColor(src, dst, mode);  }
+    TEST_CYCLE() cvtColor(src, dst, mode);
     
     SANITY_CHECK(dst);
 }
 
-PERF_TEST_P( Size_CvtMode, cvtColorH,
-    testing::Combine( 
-        testing::Values( TYPICAL_MAT_SIZES ), 
-        testing::Values( (int)CV_BGR2HSV, (int)CV_RGB2HSV, (int)CV_BGR2HLS, (int)CV_RGB2HLS )
-    )
-)
+PERF_TEST_P(Size_CvtMode, cvtColorH,
+            testing::Combine(
+                testing::Values(TYPICAL_MAT_SIZES),
+                testing::Values((int)CV_BGR2HSV, (int)CV_RGB2HSV, (int)CV_BGR2HLS, (int)CV_RGB2HLS)
+                )
+            )
 {
-    Size sz = std::tr1::get<0>(GetParam());
-    int mode = std::tr1::get<1>(GetParam());
+    Size sz = get<0>(GetParam());
+    int mode = get<1>(GetParam());
 
     Mat src(sz, CV_8UC3);
     Mat dst(sz, CV_8UC3);
 
     declare.in(src, WARMUP_RNG).out(dst);
     
-    TEST_CYCLE(100) { cvtColor(src, dst, mode);  }
+    TEST_CYCLE() cvtColor(src, dst, mode);
     
-    SANITY_CHECK(dst);
+    SANITY_CHECK(dst, 1);
 }
 

modules/imgproc/perf/perf_inpaint.cpp

 #include "perf_precomp.hpp"
 
-#include <opencv2/highgui/highgui.hpp>
-
 using namespace std;
 using namespace cv;
 using namespace perf;
+using std::tr1::make_tuple;
+using std::tr1::get;
 
 CV_ENUM(InpaintingMethod, INPAINT_NS, INPAINT_TELEA)
 typedef std::tr1::tuple<Size, InpaintingMethod> InpaintArea_InpaintingMethod_t;
 typedef perf::TestBaseWithParam<InpaintArea_InpaintingMethod_t> InpaintArea_InpaintingMethod;
 
 
-/*
-//! restores the damaged image areas using one of the available intpainting algorithms
-CV_EXPORTS_W void inpaint( InputArray src, InputArray inpaintMask,
-                           OutputArray dst, double inpaintRange, int flags );
-*/
-PERF_TEST_P( InpaintArea_InpaintingMethod, inpaint,
-             testing::Combine(
-                 SZ_ALL_SMALL,
-                 testing::ValuesIn(InpaintingMethod::all())
-             )
-           )
+PERF_TEST_P(InpaintArea_InpaintingMethod, inpaint,
+            testing::Combine(
+                SZ_ALL_SMALL,
+                testing::ValuesIn(InpaintingMethod::all())
+                )
+            )
 {
-    Mat src = imread( getDataPath("gpu/hog/road.png") );
+    Mat src = imread(getDataPath("gpu/hog/road.png"));
 
-    Size sz = std::tr1::get<0>(GetParam());
-    int inpaintingMethod = std::tr1::get<1>(GetParam());
+    Size sz = get<0>(GetParam());
+    int inpaintingMethod = get<1>(GetParam());
 
     Mat mask(src.size(), CV_8UC1, Scalar(0));
+    Mat result(src.size(), src.type());
 
     Rect inpaintArea(src.cols/3, src.rows/3, sz.width, sz.height);
     mask(inpaintArea).setTo(255);
 
-    declare.time(30);
+    declare.in(src, mask).out(result).time(30);
 
-    Mat result;
-    TEST_CYCLE(100)
-    {
-        inpaint(src, mask, result, 10.0, inpaintingMethod);
+    TEST_CYCLE() inpaint(src, mask, result, 10.0, inpaintingMethod);
 
-        //rectangle(result, inpaintArea, Scalar(255));
-        //char buf[256];
-        //sprintf(buf, "frame_%d_%d.jpg", sz.width, inpaintingMethod);
-        //imwrite(buf, result);
-    }
+    Mat inpaintedArea = result(inpaintArea);
+    SANITY_CHECK(inpaintedArea);
 }

modules/imgproc/perf/perf_integral.cpp

@@ -3,51 +3,45 @@
 using namespace std;
 using namespace cv;
 using namespace perf;
+using std::tr1::make_tuple;
+using std::tr1::get;
 
 typedef std::tr1::tuple<Size, MatType, MatDepth> Size_MatType_OutMatDepth_t;
 typedef perf::TestBaseWithParam<Size_MatType_OutMatDepth_t> Size_MatType_OutMatDepth;
 
-/*
-// void integral(InputArray image, OutputArray sum, int sdepth=-1 )
-*/
-PERF_TEST_P( Size_MatType_OutMatDepth, integral,
-    testing::Combine(
-        testing::Values( TYPICAL_MAT_SIZES ), 
-        testing::Values( CV_8UC1, CV_8UC4 ),
-        testing::Values( CV_32S, CV_32F, CV_64F )
-    )
-    )
+PERF_TEST_P(Size_MatType_OutMatDepth, integral,
+            testing::Combine(
+                testing::Values(TYPICAL_MAT_SIZES),
+                testing::Values(CV_8UC1, CV_8UC4),
+                testing::Values(CV_32S, CV_32F, CV_64F)
+                )
+            )
 {
-    Size sz = std::tr1::get<0>(GetParam());
-    int matType = std::tr1::get<1>(GetParam());
-    int sdepth = std::tr1::get<2>(GetParam());
+    Size sz = get<0>(GetParam());
+    int matType = get<1>(GetParam());
+    int sdepth = get<2>(GetParam());
 
     Mat src(sz, matType);
     Mat sum(sz, sdepth);
 
     declare.in(src, WARMUP_RNG).out(sum);
     
-    TEST_CYCLE(100) { integral(src, sum, sdepth);  }
+    TEST_CYCLE() integral(src, sum, sdepth);
     
-    SANITY_CHECK(sum);
+    SANITY_CHECK(sum, 1e-6);
 }
 
-
-
-/*
-// void integral(InputArray image, OutputArray sum, OutputArray sqsum, int sdepth=-1 )
-*/
-PERF_TEST_P( Size_MatType_OutMatDepth, integral_sqsum,
-    testing::Combine(
-        testing::Values( TYPICAL_MAT_SIZES ), 
-        testing::Values( CV_8UC1, CV_8UC4 ),
-        testing::Values( CV_32S, CV_32F, CV_64F )
-    )
-    )
+PERF_TEST_P(Size_MatType_OutMatDepth, integral_sqsum,
+            testing::Combine(
+                testing::Values(TYPICAL_MAT_SIZES),
+                testing::Values(CV_8UC1, CV_8UC4),
+                testing::Values(CV_32S, CV_32F, CV_64F)
+                )
+            )
 {
-    Size sz = std::tr1::get<0>(GetParam());
-    int matType = std::tr1::get<1>(GetParam());
-    int sdepth = std::tr1::get<2>(GetParam());
+    Size sz = get<0>(GetParam());
+    int matType = get<1>(GetParam());
+    int sdepth = get<2>(GetParam());
 
     Mat src(sz, matType);
     Mat sum(sz, sdepth);
@@ -55,28 +49,23 @@ PERF_TEST_P( Size_MatType_OutMatDepth, integral_sqsum,
 
     declare.in(src, WARMUP_RNG).out(sum, sqsum);
     
-    TEST_CYCLE(100) { integral(src, sum, sqsum, sdepth);  }
+    TEST_CYCLE() integral(src, sum, sqsum, sdepth);
     
-    SANITY_CHECK(sum);
-    SANITY_CHECK(sqsum);
+    SANITY_CHECK(sum, 1e-6);
+    SANITY_CHECK(sqsum, 1e-6);
 }
 
-
-
-/*
-// void integral(InputArray image, OutputArray sum, OutputArray sqsum, OutputArray tilted, int sdepth=-1 )
-*/
 PERF_TEST_P( Size_MatType_OutMatDepth, integral_sqsum_tilted,
-    testing::Combine(
-        testing::Values( TYPICAL_MAT_SIZES ), 
-        testing::Values( CV_8UC1, CV_8UC4 ),
-        testing::Values( CV_32S, CV_32F, CV_64F )
-    )
-    )
+             testing::Combine(
+                 testing::Values( TYPICAL_MAT_SIZES ),
+                 testing::Values( CV_8UC1, CV_8UC4 ),
+                 testing::Values( CV_32S, CV_32F, CV_64F )
+                 )
+             )
 {
-    Size sz = std::tr1::get<0>(GetParam());
-    int matType = std::tr1::get<1>(GetParam());
-    int sdepth = std::tr1::get<2>(GetParam());
+    Size sz = get<0>(GetParam());
+    int matType = get<1>(GetParam());
+    int sdepth = get<2>(GetParam());
 
     Mat src(sz, matType);
     Mat sum(sz, sdepth);
@@ -85,9 +74,9 @@ PERF_TEST_P( Size_MatType_OutMatDepth, integral_sqsum_tilted,
 
     declare.in(src, WARMUP_RNG).out(sum, sqsum, tilted);
     
-    TEST_CYCLE(100) { integral(src, sum, sqsum, tilted, sdepth);  }
+    TEST_CYCLE() integral(src, sum, sqsum, tilted, sdepth);
     
-    SANITY_CHECK(sum);
-    SANITY_CHECK(sqsum);
-    SANITY_CHECK(tilted);
+    SANITY_CHECK(sum, 1e-6);
+    SANITY_CHECK(sqsum, 1e-6);
+    SANITY_CHECK(tilted, 1e-6);
 }

modules/imgproc/perf/perf_morph.cpp

@@ -3,42 +3,38 @@
 using namespace std;
 using namespace cv;
 using namespace perf;
+using std::tr1::make_tuple;
+using std::tr1::get;
 
 #define TYPICAL_MAT_TYPES_MORPH  CV_8UC1, CV_8UC4
-#define TYPICAL_MATS_MORPH       testing::Combine( SZ_ALL_GA, testing::Values( TYPICAL_MAT_TYPES_MORPH) )
+#define TYPICAL_MATS_MORPH       testing::Combine(SZ_ALL_GA, testing::Values(TYPICAL_MAT_TYPES_MORPH))
 
 PERF_TEST_P(Size_MatType, erode, TYPICAL_MATS_MORPH)
 {
-    Size sz = std::tr1::get<0>(GetParam());
-    int type = std::tr1::get<1>(GetParam());
+    Size sz = get<0>(GetParam());
+    int type = get<1>(GetParam());
 
     Mat src(sz, type);
     Mat dst(sz, type);
 
     declare.in(src, WARMUP_RNG).out(dst);
 
-    TEST_CYCLE(100) 
-    {
-        erode(src, dst, noArray());
-    }
+    TEST_CYCLE() erode(src, dst, noArray());
 
     SANITY_CHECK(dst);
 }
 
 PERF_TEST_P(Size_MatType, dilate, TYPICAL_MATS_MORPH)
 {
-    Size sz = std::tr1::get<0>(GetParam());
-    int type = std::tr1::get<1>(GetParam());
+    Size sz = get<0>(GetParam());
+    int type = get<1>(GetParam());
 
     Mat src(sz, type);
     Mat dst(sz, type);
 
     declare.in(src, WARMUP_RNG).out(dst);
 
-    TEST_CYCLE(100)
-    {
-        dilate(src, dst, noArray());
-    }
+    TEST_CYCLE() dilate(src, dst, noArray());
 
     SANITY_CHECK(dst);
 }

modules/imgproc/perf/perf_pyramids.cpp

@@ -3,34 +3,33 @@
 using namespace std;
 using namespace cv;
 using namespace perf;
-
 using std::tr1::make_tuple;
 using std::tr1::get;
 
-PERF_TEST_P( Size_MatType, pyrDown, testing::Combine(
-                 testing::Values( sz1080p, sz720p, szVGA, szQVGA, szODD ),
-                 testing::Values( CV_8UC1, CV_8UC3, CV_8UC4, CV_16SC1, CV_16SC3, CV_16SC4 )
-                 )
-             )
+PERF_TEST_P(Size_MatType, pyrDown, testing::Combine(
+                testing::Values(sz1080p, sz720p, szVGA, szQVGA, szODD),
+                testing::Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_16SC1, CV_16SC3, CV_16SC4)
+                )
+            )
 {
     Size sz = get<0>(GetParam());
     int matType = get<1>(GetParam());
 
     Mat src(sz, matType);
-    Mat dst((sz.height+1)/2, (sz.width+1)/2, matType);
+    Mat dst((sz.height + 1)/2, (sz.width + 1)/2, matType);
 
     declare.in(src, WARMUP_RNG).out(dst);
 
-    TEST_CYCLE(100) { cv::pyrDown(src, dst);  }
+    TEST_CYCLE() pyrDown(src, dst);
 
     SANITY_CHECK(dst);
 }
 
-PERF_TEST_P( Size_MatType, pyrUp, testing::Combine(
-                 testing::Values( sz720p, szVGA, szQVGA, szODD ),
-                 testing::Values( CV_8UC1, CV_8UC3, CV_8UC4, CV_16SC1, CV_16SC3, CV_16SC4 )
-                 )
-             )
+PERF_TEST_P(Size_MatType, pyrUp, testing::Combine(
+                testing::Values(sz720p, szVGA, szQVGA, szODD),
+                testing::Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_16SC1, CV_16SC3, CV_16SC4)
+                )
+            )
 {
     Size sz = get<0>(GetParam());
     int matType = get<1>(GetParam());
@@ -40,7 +39,7 @@ PERF_TEST_P( Size_MatType, pyrUp, testing::Combine(
 
     declare.in(src, WARMUP_RNG).out(dst);
 
-    TEST_CYCLE(100) { cv::pyrUp(src, dst);  }
+    TEST_CYCLE() pyrUp(src, dst);
 
     SANITY_CHECK(dst);
 }

modules/imgproc/perf/perf_geometric_transformations.cpp → modules/imgproc/perf/perf_resize.cpp

@@ -3,52 +3,54 @@
 using namespace std;
 using namespace cv;
 using namespace perf;
+using std::tr1::make_tuple;
+using std::tr1::get;
 
 typedef tr1::tuple<MatType, Size, Size> MatInfo_Size_Size_t;
 typedef TestBaseWithParam<MatInfo_Size_Size_t> MatInfo_Size_Size;
 
 PERF_TEST_P(MatInfo_Size_Size, resizeUpLinear,
-    testing::Values(
+            testing::Values(
                 MatInfo_Size_Size_t(CV_8UC1, szVGA, szqHD),
                 MatInfo_Size_Size_t(CV_8UC1, szVGA, sz720p),
                 MatInfo_Size_Size_t(CV_8UC4, szVGA, sz720p)
                 )
-)
+            )
 {
-    int matType = tr1::get<0>(GetParam());
-    Size from = tr1::get<1>(GetParam());
-    Size to = tr1::get<2>(GetParam());
+    int matType = get<0>(GetParam());
+    Size from = get<1>(GetParam());
+    Size to = get<2>(GetParam());
 
     cv::Mat src(from, matType);
     cv::Mat dst(to, matType);
 
     declare.in(src, WARMUP_RNG).out(dst);
 
-    SIMPLE_TEST_CYCLE() cv::resize(src, dst, to);
+    TEST_CYCLE() resize(src, dst, to);
 
     SANITY_CHECK(dst, 1 + 1e-6);
 }
 
 PERF_TEST_P(MatInfo_Size_Size, resizeDownLinear,
-    testing::Values(
+            testing::Values(
                 MatInfo_Size_Size_t(CV_8UC1, szVGA, szQVGA),
                 MatInfo_Size_Size_t(CV_8UC4, szqHD, szVGA),
                 MatInfo_Size_Size_t(CV_8UC1, sz720p, Size(120 * sz720p.width / sz720p.height, 120)),//face detection min_face_size = 20%
                 MatInfo_Size_Size_t(CV_8UC4, sz720p, szVGA),
                 MatInfo_Size_Size_t(CV_8UC4, sz720p, szQVGA)
                 )
-)
+            )
 {
-    int matType = tr1::get<0>(GetParam());
-    Size from = tr1::get<1>(GetParam());
-    Size to = tr1::get<2>(GetParam());
+    int matType = get<0>(GetParam());
+    Size from = get<1>(GetParam());
+    Size to = get<2>(GetParam());
 
     cv::Mat src(from, matType);
     cv::Mat dst(to, matType);
 
     declare.in(src, WARMUP_RNG).out(dst);
 
-    SIMPLE_TEST_CYCLE() cv::resize(src, dst, to);
+    TEST_CYCLE() resize(src, dst, to);
 
     SANITY_CHECK(dst, 1 + 1e-6);
 }
@@ -57,17 +59,17 @@ PERF_TEST_P(MatInfo_Size_Size, resizeDownLinear,
 typedef tr1::tuple<MatType, Size, int> MatInfo_Size_Scale_t;
 typedef TestBaseWithParam<MatInfo_Size_Scale_t> MatInfo_Size_Scale;
 
-PERF_TEST_P( MatInfo_Size_Scale, resizeAreaFast,
-             testing::Combine(
-                 testing::Values( CV_8UC1, CV_8UC4 ),
-                 testing::Values( szVGA, szqHD, sz720p, sz1080p ),
-                 testing::Values( 2, 4 )
-                 )
-             )
+PERF_TEST_P(MatInfo_Size_Scale, resizeAreaFast,
+            testing::Combine(
+                testing::Values(CV_8UC1, CV_8UC4),
+                testing::Values(szVGA, szqHD, sz720p, sz1080p),
+                testing::Values(2, 4)
+                )
+            )
 {
-    int matType = tr1::get<0>(GetParam());
-    Size from = tr1::get<1>(GetParam());
-    int scale = tr1::get<2>(GetParam());
+    int matType = get<0>(GetParam());
+    Size from = get<1>(GetParam());
+    int scale = get<2>(GetParam());
 
     from.width = (from.width/scale)*scale;
     from.height = (from.height/scale)*scale;
@@ -77,7 +79,7 @@ PERF_TEST_P( MatInfo_Size_Scale, resizeAreaFast,
 
     declare.in(src, WARMUP_RNG).out(dst);
 
-    SIMPLE_TEST_CYCLE() cv::resize(src, dst, dst.size(), 0, 0, INTER_AREA);
+    TEST_CYCLE() resize(src, dst, dst.size(), 0, 0, INTER_AREA);
 
     //difference equal to 1 is allowed because of different possible rounding modes: round-to-nearest vs bankers' rounding
     SANITY_CHECK(dst, 1);

modules/imgproc/perf/perf_filters.cpp → modules/imgproc/perf/perf_sepfilters.cpp

@@ -3,7 +3,6 @@
 using namespace std;
 using namespace cv;
 using namespace perf;
-
 using std::tr1::make_tuple;
 using std::tr1::get;
 
@@ -50,7 +49,7 @@ PERF_TEST_P(Size_MatType_dx_dy_Border3x3, sobelFilter,
 
     declare.in(src, WARMUP_RNG).out(dst);
 
-    TEST_CYCLE(100) { Sobel(src, dst, ddepth, dx, dy, 3, 1, 0, border); }
+    TEST_CYCLE() Sobel(src, dst, ddepth, dx, dy, 3, 1, 0, border);
 
     SANITY_CHECK(dst);
 }
@@ -78,7 +77,7 @@ PERF_TEST_P(Size_MatType_dx_dy_Border3x3ROI, sobelFilter,
 
     declare.in(src).out(dst);
 
-    TEST_CYCLE(100) { Sobel(src, dst, ddepth, dx, dy, 3, 1, 0, border); }
+    TEST_CYCLE() Sobel(src, dst, ddepth, dx, dy, 3, 1, 0, border);
 
     SANITY_CHECK(dst);
 }
@@ -103,7 +102,7 @@ PERF_TEST_P(Size_MatType_dx_dy_Border5x5, sobelFilter,
 
     declare.in(src, WARMUP_RNG).out(dst);
 
-    TEST_CYCLE(100) { Sobel(src, dst, ddepth, dx, dy, 5, 1, 0, border); }
+    TEST_CYCLE() Sobel(src, dst, ddepth, dx, dy, 5, 1, 0, border);
 
     SANITY_CHECK(dst);
 }
@@ -131,7 +130,7 @@ PERF_TEST_P(Size_MatType_dx_dy_Border5x5ROI, sobelFilter,
 
     declare.in(src).out(dst);
 
-    TEST_CYCLE(100) { Sobel(src, dst, ddepth, dx, dy, 5, 1, 0, border); }
+    TEST_CYCLE() Sobel(src, dst, ddepth, dx, dy, 5, 1, 0, border);
 
     SANITY_CHECK(dst);
 }
@@ -158,7 +157,7 @@ PERF_TEST_P(Size_MatType_dx_dy_Border3x3, scharrFilter,
 
     declare.in(src, WARMUP_RNG).out(dst);
 
-    TEST_CYCLE(100) { Scharr(src, dst, ddepth, dx, dy, 1, 0, border); }
+    TEST_CYCLE() Scharr(src, dst, ddepth, dx, dy, 1, 0, border);
 
     SANITY_CHECK(dst);
 }
@@ -186,7 +185,7 @@ PERF_TEST_P(Size_MatType_dx_dy_Border3x3ROI, scharrFilter,
 
     declare.in(src).out(dst);
 
-    TEST_CYCLE(100) { Scharr(src, dst, ddepth, dx, dy, 1, 0, border); }
+    TEST_CYCLE() Scharr(src, dst, ddepth, dx, dy, 1, 0, border);
 
     SANITY_CHECK(dst);
 }
@@ -211,7 +210,7 @@ PERF_TEST_P(Size_MatType_dx_dy_Border3x3, scharrViaSobelFilter,
 
     declare.in(src, WARMUP_RNG).out(dst);
 
-    TEST_CYCLE(100) { Sobel(src, dst, ddepth, dx, dy, -1, 1, 0, border); }
+    TEST_CYCLE() Sobel(src, dst, ddepth, dx, dy, -1, 1, 0, border);
 
     SANITY_CHECK(dst);
 }
@@ -239,7 +238,7 @@ PERF_TEST_P(Size_MatType_dx_dy_Border3x3ROI, scharrViaSobelFilter,
 
     declare.in(src).out(dst);
 
-    TEST_CYCLE(100) { Sobel(src, dst, ddepth, dx, dy, -1, 1, 0, border); }
+    TEST_CYCLE() Sobel(src, dst, ddepth, dx, dy, -1, 1, 0, border);
 
     SANITY_CHECK(dst);
 }

modules/imgproc/perf/perf_threshold.cpp

@@ -3,6 +3,8 @@
 using namespace std;
 using namespace cv;
 using namespace perf;
+using std::tr1::make_tuple;
+using std::tr1::get;
 
 CV_ENUM(ThreshType, THRESH_BINARY, THRESH_BINARY_INV, THRESH_TRUNC, THRESH_TOZERO, THRESH_TOZERO_INV)
 
@@ -14,48 +16,41 @@ PERF_TEST_P(Size_MatType_ThreshType, threshold,
                 testing::Values(TYPICAL_MAT_SIZES),
                 testing::Values(CV_8UC1, CV_16SC1),
                 testing::ValuesIn(ThreshType::all())
+                )
             )
-          )
 {
 
-    Size sz = std::tr1::get<0>(GetParam());
-    int type = std::tr1::get<1>(GetParam());
-    ThreshType threshType = std::tr1::get<2>(GetParam());
+    Size sz = get<0>(GetParam());
+    int type = get<1>(GetParam());
+    ThreshType threshType = get<2>(GetParam());
 
     Mat src(sz, type);
     Mat dst(sz, type);
 
-    double thresh = cv::theRNG().uniform(1, 254);
-    double maxval = cv::theRNG().uniform(1, 254);
+    double thresh = theRNG().uniform(1, 254);
+    double maxval = theRNG().uniform(1, 254);
 
     declare.in(src, WARMUP_RNG).out(dst);
 
-    TEST_CYCLE(100)
-    {
-        cv::threshold(src, dst, thresh, maxval, threshType);
-    }
+    TEST_CYCLE() threshold(src, dst, thresh, maxval, threshType);
 
     SANITY_CHECK(dst);
 }
 
-
 typedef perf::TestBaseWithParam<Size> Size_Only;
 
-PERF_TEST_P(Size_Only, threshold_otsu, testing::Values(TYPICAL_MAT_SIZES) )
+PERF_TEST_P(Size_Only, threshold_otsu, testing::Values(TYPICAL_MAT_SIZES))
 {
     Size sz = GetParam();
 
     Mat src(sz, CV_8UC1);
     Mat dst(sz, CV_8UC1);
 
-    double maxval = cv::theRNG().uniform(1, 254);
+    double maxval = theRNG().uniform(1, 254);
 
     declare.in(src, WARMUP_RNG).out(dst);
 
-    TEST_CYCLE(100)
-    {
-        cv::threshold(src, dst, 0, maxval, THRESH_BINARY|THRESH_OTSU);
-    }
+    TEST_CYCLE() threshold(src, dst, 0, maxval, THRESH_BINARY|THRESH_OTSU);
 
     SANITY_CHECK(dst);
 }

modules/objdetect/perf/perf_cascadeclassifier.cpp

@@ -4,26 +4,30 @@
 using namespace std;
 using namespace cv;
 using namespace perf;
+using std::tr1::make_tuple;
+using std::tr1::get;
 
 typedef std::tr1::tuple<std::string, int> ImageName_MinSize_t;
 typedef perf::TestBaseWithParam<ImageName_MinSize_t> ImageName_MinSize;
 
-PERF_TEST_P( ImageName_MinSize, CascadeClassifierLBPFrontalFace, 
-        testing::Combine(testing::Values( std::string("cv/shared/lena.jpg"), 
-                                          std::string("cv/shared/1_itseez-0000247.jpg"), 
-                                          std::string("cv/shared/1_itseez-0000289.jpg"), 
-                                          std::string("cv/shared/1_itseez-0000492.jpg"), 
-                                          std::string("cv/shared/1_itseez-0000573.jpg"), 
-                                          std::string("cv/shared/1_itseez-0000803.jpg"), 
-                                          std::string("cv/shared/1_itseez-0000892.jpg"), 
-                                          std::string("cv/shared/1_itseez-0000984.jpg"), 
-                                          std::string("cv/shared/1_itseez-0001238.jpg"), 
-                                          std::string("cv/shared/1_itseez-0001438.jpg"), 
-                                          std::string("cv/shared/1_itseez-0002524.jpg")), 
-            testing::Values(24, 30, 40, 50, 60, 70, 80, 90) ) )
+PERF_TEST_P(ImageName_MinSize, CascadeClassifierLBPFrontalFace,
+            testing::Combine(testing::Values( std::string("cv/shared/lena.jpg"),
+                                              std::string("cv/shared/1_itseez-0000247.jpg"),
+                                              std::string("cv/shared/1_itseez-0000289.jpg"),
+                                              std::string("cv/shared/1_itseez-0000492.jpg"),
+                                              std::string("cv/shared/1_itseez-0000573.jpg"),
+                                              std::string("cv/shared/1_itseez-0000803.jpg"),
+                                              std::string("cv/shared/1_itseez-0000892.jpg"),
+                                              std::string("cv/shared/1_itseez-0000984.jpg"),
+                                              std::string("cv/shared/1_itseez-0001238.jpg"),
+                                              std::string("cv/shared/1_itseez-0001438.jpg"),
+                                              std::string("cv/shared/1_itseez-0002524.jpg")),
+                             testing::Values(24, 30, 40, 50, 60, 70, 80, 90)
+                             )
+            )
 {
-    const string filename = std::tr1::get<0>(GetParam());
-    int min_size = std::tr1::get<1>(GetParam());
+    const string filename = get<0>(GetParam());
+    int min_size = get<1>(GetParam());
     Size minSize(min_size, min_size);
 
     CascadeClassifier cc(getDataPath("cv/cascadeandhog/cascades/lbpcascade_frontalface.xml"));
@@ -36,15 +40,14 @@ PERF_TEST_P( ImageName_MinSize, CascadeClassifierLBPFrontalFace,
 
     vector<Rect> res;
 
-
-    declare.in(img);//.out(res)
+    equalizeHist(img, img);
+    declare.in(img);
 
     while(next())
     {
         res.clear();
 
         startTimer();
-        equalizeHist(img, img);
         cc.detectMultiScale(img, res, 1.1, 3, 0, minSize);
         stopTimer();
     }

modules/stitching/perf/perf_stich.cpp

@@ -6,6 +6,8 @@
 using namespace std;
 using namespace cv;
 using namespace perf;
+using std::tr1::make_tuple;
+using std::tr1::get;
 
 #define SURF_MATCH_CONFIDENCE 0.65f
 #define ORB_MATCH_CONFIDENCE  0.3f
@@ -14,7 +16,7 @@ using namespace perf;
 typedef TestBaseWithParam<String> stitch;
 typedef TestBaseWithParam<String> match;
 
-PERF_TEST_P( stitch, a123, testing::Values("surf", "orb"))
+PERF_TEST_P(stitch, a123, testing::Values("surf", "orb"))
 {
     Mat pano;
     
@@ -39,7 +41,7 @@ PERF_TEST_P( stitch, a123, testing::Values("surf", "orb"))
         Stitcher stitcher = Stitcher::createDefault();
         stitcher.setFeaturesFinder(featuresFinder);
         stitcher.setFeaturesMatcher(featuresMatcher);
-        stitcher.setWarper(new CylindricalWarper());
+        stitcher.setWarper(new SphericalWarper());
         stitcher.setRegistrationResol(WORK_MEGAPIX);
 
         startTimer();
@@ -48,7 +50,7 @@ PERF_TEST_P( stitch, a123, testing::Values("surf", "orb"))
     }
 }
 
-PERF_TEST_P( stitch, b12, testing::Values("surf", "orb"))
+PERF_TEST_P(stitch, b12, testing::Values("surf", "orb"))
 {
     Mat pano;
     
@@ -72,7 +74,7 @@ PERF_TEST_P( stitch, b12, testing::Values("surf", "orb"))
         Stitcher stitcher = Stitcher::createDefault();
         stitcher.setFeaturesFinder(featuresFinder);
         stitcher.setFeaturesMatcher(featuresMatcher);
-        stitcher.setWarper(new CylindricalWarper());
+        stitcher.setWarper(new SphericalWarper());
         stitcher.setRegistrationResol(WORK_MEGAPIX);
 
         startTimer();
@@ -114,7 +116,7 @@ PERF_TEST_P( match, bestOf2Nearest, testing::Values("surf", "orb"))
     detail::MatchesInfo pairwise_matches;
 
     declare.in(features1.descriptors, features2.descriptors)
-           .iterations(100);
+            .iterations(100);
 
     while(next())
     {

modules/ts/include/opencv2/ts/ts_perf.hpp

@@ -433,7 +433,7 @@ CV_EXPORTS void PrintTo(const Size& sz, ::std::ostream* os);
 //
 //     declare.in(a, b).out(c).time(0.5);
 //
-//     SIMPLE_TEST_CYCLE() cv::add(a, b, c);
+//     TEST_CYCLE() cv::add(a, b, c);
 //
 //     SANITY_CHECK(c);
 //   }
@@ -458,8 +458,8 @@ int main(int argc, char **argv)\
     return RUN_ALL_TESTS();\
 }
 
-#define TEST_CYCLE(n) for(declare.iterations(n); startTimer(), next(); stopTimer())
-#define SIMPLE_TEST_CYCLE() for(; startTimer(), next(); stopTimer())
+#define TEST_CYCLE_N(n) for(declare.iterations(n); startTimer(), next(); stopTimer())
+#define TEST_CYCLE() for(; startTimer(), next(); stopTimer())
 
 //flags
 namespace perf