From: Andrey Kamaev Date: Thu, 29 Dec 2011 16:46:16 +0000 (+0000) Subject: Refactored performance tests. TEST_CYCLE macro is renamed to TEST_CYCLE_N; SIMPLE_TES... X-Git-Tag: accepted/2.0/20130307.220821~1493 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=65f5343ed56c29abc3c5cf710b03e0b9b9da14fc;p=profile%2Fivi%2Fopencv.git 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 --- diff --git a/modules/calib3d/perf/perf_cicrlesGrid.cpp b/modules/calib3d/perf/perf_cicrlesGrid.cpp index 5e3dd31..fb65cac 100644 --- a/modules/calib3d/perf/perf_cicrlesGrid.cpp +++ b/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 String_Size_t; typedef perf::TestBaseWithParam 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 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); } diff --git a/modules/calib3d/perf/perf_pnp.cpp b/modules/calib3d/perf/perf_pnp.cpp index 78d22a4..24bfe73 100644 --- a/modules/calib3d/perf/perf_pnp.cpp +++ b/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 String_Size_t; -typedef perf::TestBaseWithParam PointsNumber; +typedef std::tr1::tuple PointsNum_Algo_t; +typedef perf::TestBaseWithParam 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 points2d(pointsNum); vector 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 points2d(pointsNum); + vector 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 (0, 0) = 400.0; + intrinsics.at (1, 1) = 400.0; + intrinsics.at (0, 2) = 640 / 2; + intrinsics.at (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); diff --git a/modules/core/perf/perf_abs.cpp b/modules/core/perf/perf_abs.cpp index 8898a45..c84608b 100644 --- a/modules/core/perf/perf_abs.cpp +++ b/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); } diff --git a/modules/core/perf/perf_arithm.cpp b/modules/core/perf/perf_arithm.cpp new file mode 100644 index 0000000..e49a927 --- /dev/null +++ b/modules/core/perf/perf_arithm.cpp @@ -0,0 +1,190 @@ +#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); +} diff --git a/modules/core/perf/perf_bitwise.cpp b/modules/core/perf/perf_bitwise.cpp index 1ebf11e..76354f4 100644 --- a/modules/core/perf/perf_bitwise.cpp +++ b/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); } diff --git a/modules/core/perf/perf_compare.cpp b/modules/core/perf/perf_compare.cpp index 32f8886..abbd0d0 100644 --- a/modules/core/perf/perf_compare.cpp +++ b/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_t; typedef perf::TestBaseWithParam 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); } diff --git a/modules/core/perf/perf_core_arithm.cpp b/modules/core/perf/perf_core_arithm.cpp deleted file mode 100644 index 0927134..0000000 --- a/modules/core/perf/perf_core_arithm.cpp +++ /dev/null @@ -1,113 +0,0 @@ -#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); -} diff --git a/modules/core/perf/perf_dft.cpp b/modules/core/perf/perf_dft.cpp index 81c0d48..43200d2 100644 --- a/modules/core/perf/perf_dft.cpp +++ b/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); } diff --git a/modules/core/perf/perf_dot.cpp b/modules/core/perf/perf_dot.cpp index 1a4b898..c6d73ca 100644 --- a/modules/core/perf/perf_dot.cpp +++ b/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 MatType_Length_t; typedef TestBaseWithParam 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); } diff --git a/modules/core/perf/perf_math.cpp b/modules/core/perf/perf_math.cpp index 696be76..b7dab14 100644 --- a/modules/core/perf/perf_math.cpp +++ b/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 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); } diff --git a/modules/core/perf/perf_minmax.cpp b/modules/core/perf/perf_minmax.cpp deleted file mode 100644 index d50bfc6..0000000 --- a/modules/core/perf/perf_minmax.cpp +++ /dev/null @@ -1,39 +0,0 @@ -#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); -} diff --git a/modules/core/perf/perf_minmaxloc.cpp b/modules/core/perf/perf_minmaxloc.cpp new file mode 100644 index 0000000..21fb354 --- /dev/null +++ b/modules/core/perf/perf_minmaxloc.cpp @@ -0,0 +1,35 @@ +#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); +} diff --git a/modules/core/perf/perf_norm.cpp b/modules/core/perf/perf_norm.cpp new file mode 100644 index 0000000..a9428ee --- /dev/null +++ b/modules/core/perf/perf_norm.cpp @@ -0,0 +1,198 @@ +#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_t; +typedef perf::TestBaseWithParam 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); +} diff --git a/modules/core/perf/perf_reduce.cpp b/modules/core/perf/perf_reduce.cpp new file mode 100644 index 0000000..7717277 --- /dev/null +++ b/modules/core/perf/perf_reduce.cpp @@ -0,0 +1,66 @@ +#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_t; +typedef perf::TestBaseWithParam 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); +} + diff --git a/modules/core/perf/perf_stat.cpp b/modules/core/perf/perf_stat.cpp index 7a688eb..5a693f9 100644 --- a/modules/core/perf/perf_stat.cpp +++ b/modules/core/perf/perf_stat.cpp @@ -1,436 +1,103 @@ #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_t; -typedef perf::TestBaseWithParam 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_t; -typedef perf::TestBaseWithParam 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); -} diff --git a/modules/features2d/perf/perf_fast.cpp b/modules/features2d/perf/perf_fast.cpp index 6d295ca..da75f9d 100644 --- a/modules/features2d/perf/perf_fast.cpp +++ b/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 fast; @@ -11,7 +12,7 @@ typedef perf::TestBaseWithParam 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 points; - TEST_CYCLE(100) - { - fd.detect(frame, points); - } + TEST_CYCLE() fd.detect(frame, points); } diff --git a/modules/features2d/perf/perf_orb.cpp b/modules/features2d/perf/perf_orb.cpp index 78f2f92..cb8b6c0 100644 --- a/modules/features2d/perf/perf_orb.cpp +++ b/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 orb; @@ -11,7 +12,7 @@ typedef perf::TestBaseWithParam 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 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 points; Mat descriptors; - TEST_CYCLE(100) - { - detector(frame, mask, points, descriptors, false); - } + TEST_CYCLE() detector(frame, mask, points, descriptors, false); } diff --git a/modules/features2d/perf/perf_surf.cpp b/modules/features2d/perf/perf_surf.cpp index 4d63b8f..937cf6f 100644 --- a/modules/features2d/perf/perf_surf.cpp +++ b/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 surf; @@ -11,7 +12,7 @@ typedef perf::TestBaseWithParam 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 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 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 points; vector descriptors; - TEST_CYCLE(100) - { - detector(frame, mask, points, descriptors, false); - } + TEST_CYCLE() detector(frame, mask, points, descriptors, false); } diff --git a/modules/gpu/perf/perf_arithm.cpp b/modules/gpu/perf/perf_arithm.cpp index 394bdc5..d9a2d02 100644 --- a/modules/gpu/perf/perf_arithm.cpp +++ b/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); } diff --git a/modules/gpu/perf/perf_calib3d.cpp b/modules/gpu/perf/perf_calib3d.cpp index a3fe08e..0175527 100644 --- a/modules/gpu/perf/perf_calib3d.cpp +++ b/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); } diff --git a/modules/gpu/perf/perf_features2d.cpp b/modules/gpu/perf/perf_features2d.cpp index 08ffc5d..62b5819 100644 --- a/modules/gpu/perf/perf_features2d.cpp +++ b/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); } diff --git a/modules/gpu/perf/perf_filters.cpp b/modules/gpu/perf/perf_filters.cpp index f4c9fd6..79c60f5 100644 --- a/modules/gpu/perf/perf_filters.cpp +++ b/modules/gpu/perf/perf_filters.cpp @@ -23,7 +23,7 @@ GPU_PERF_TEST(BoxFilter, cv::gpu::DeviceInfo, cv::Size, perf::MatType, int) cv::Ptr 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 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)); } diff --git a/modules/gpu/perf/perf_imgproc.cpp b/modules/gpu/perf/perf_imgproc.cpp index 7d617c8..e2138a9 100644 --- a/modules/gpu/perf/perf_imgproc.cpp +++ b/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)); } diff --git a/modules/gpu/perf/perf_matop.cpp b/modules/gpu/perf/perf_matop.cpp index 6950fbb..f56dbf3 100644 --- a/modules/gpu/perf/perf_matop.cpp +++ b/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); } diff --git a/modules/gpu/perf/perf_objdetect.cpp b/modules/gpu/perf/perf_objdetect.cpp index 338a663..b6c02aa 100644 --- a/modules/gpu/perf/perf_objdetect.cpp +++ b/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); } diff --git a/modules/gpu/perf/perf_video.cpp b/modules/gpu/perf/perf_video.cpp index 66d8ce5..34934d4 100644 --- a/modules/gpu/perf/perf_video.cpp +++ b/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); } diff --git a/modules/imgproc/perf/perf_blur.cpp b/modules/imgproc/perf/perf_blur.cpp index 3408f66..58992fe 100644 --- a/modules/imgproc/perf/perf_blur.cpp +++ b/modules/imgproc/perf/perf_blur.cpp @@ -9,13 +9,13 @@ using std::tr1::get; typedef std::tr1::tuple Size_MatType_kSize_t; typedef perf::TestBaseWithParam 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_Borde typedef std::tr1::tuple Size_MatType_BorderType_t; typedef perf::TestBaseWithParam 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); } diff --git a/modules/imgproc/perf/perf_canny.cpp b/modules/imgproc/perf/perf_canny.cpp index 31939b2..b59cfe9 100644 --- a/modules/imgproc/perf/perf_canny.cpp +++ b/modules/imgproc/perf/perf_canny.cpp @@ -9,14 +9,14 @@ using std::tr1::get; typedef std::tr1::tuple > Img_Aperture_L2_thresholds_t; typedef perf::TestBaseWithParam 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); } diff --git a/modules/imgproc/perf/perf_cvt_color.cpp b/modules/imgproc/perf/perf_cvt_color.cpp index 0e7ae27..aacdf97 100644 --- a/modules/imgproc/perf/perf_cvt_color.cpp +++ b/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_t; typedef perf::TestBaseWithParam Size_CvtMode; @@ -17,116 +19,110 @@ typedef perf::TestBaseWithParam Size_CvtMode; typedef std::tr1::tuple Size_CvtMode_OutChNum_t; typedef perf::TestBaseWithParam 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); } diff --git a/modules/imgproc/perf/perf_inpaint.cpp b/modules/imgproc/perf/perf_inpaint.cpp index bbd8e68..ca07c7d 100644 --- a/modules/imgproc/perf/perf_inpaint.cpp +++ b/modules/imgproc/perf/perf_inpaint.cpp @@ -1,48 +1,38 @@ #include "perf_precomp.hpp" -#include - 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 InpaintArea_InpaintingMethod_t; typedef perf::TestBaseWithParam 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); } diff --git a/modules/imgproc/perf/perf_integral.cpp b/modules/imgproc/perf/perf_integral.cpp index 480ad17..1ae7108 100644 --- a/modules/imgproc/perf/perf_integral.cpp +++ b/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_OutMatDepth_t; typedef perf::TestBaseWithParam 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); } diff --git a/modules/imgproc/perf/perf_morph.cpp b/modules/imgproc/perf/perf_morph.cpp index 286df2b..20d0893 100644 --- a/modules/imgproc/perf/perf_morph.cpp +++ b/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); } diff --git a/modules/imgproc/perf/perf_pyramids.cpp b/modules/imgproc/perf/perf_pyramids.cpp index 4481900..66ea6d8 100644 --- a/modules/imgproc/perf/perf_pyramids.cpp +++ b/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); } diff --git a/modules/imgproc/perf/perf_geometric_transformations.cpp b/modules/imgproc/perf/perf_resize.cpp similarity index 66% rename from modules/imgproc/perf/perf_geometric_transformations.cpp rename to modules/imgproc/perf/perf_resize.cpp index 8f1ff20..fba1294 100644 --- a/modules/imgproc/perf/perf_geometric_transformations.cpp +++ b/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 MatInfo_Size_Size_t; typedef TestBaseWithParam 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 MatInfo_Size_Scale_t; typedef TestBaseWithParam 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); diff --git a/modules/imgproc/perf/perf_filters.cpp b/modules/imgproc/perf/perf_sepfilters.cpp similarity index 92% rename from modules/imgproc/perf/perf_filters.cpp rename to modules/imgproc/perf/perf_sepfilters.cpp index 78217ad..9a5bd4e 100644 --- a/modules/imgproc/perf/perf_filters.cpp +++ b/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); } diff --git a/modules/imgproc/perf/perf_threshold.cpp b/modules/imgproc/perf/perf_threshold.cpp index 31d1663..b95b36f 100644 --- a/modules/imgproc/perf/perf_threshold.cpp +++ b/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_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); } diff --git a/modules/objdetect/perf/perf_cascadeclassifier.cpp b/modules/objdetect/perf/perf_cascadeclassifier.cpp index af01dd5..2d3ca63 100644 --- a/modules/objdetect/perf/perf_cascadeclassifier.cpp +++ b/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 ImageName_MinSize_t; typedef perf::TestBaseWithParam 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 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(); } diff --git a/modules/stitching/perf/perf_stich.cpp b/modules/stitching/perf/perf_stich.cpp index ed60a36..0898aa5 100644 --- a/modules/stitching/perf/perf_stich.cpp +++ b/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 stitch; typedef TestBaseWithParam 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()) { diff --git a/modules/ts/include/opencv2/ts/ts_perf.hpp b/modules/ts/include/opencv2/ts/ts_perf.hpp index 106c9d1..2df5cc9 100644 --- a/modules/ts/include/opencv2/ts/ts_perf.hpp +++ b/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