using namespace std;
using namespace cv;
using namespace perf;
-
+using std::tr1::make_tuple;
+using std::tr1::get;
typedef std::tr1::tuple<std::string, cv::Size> String_Size_t;
typedef perf::TestBaseWithParam<String_Size_t> String_Size;
PERF_TEST_P(String_Size, asymm_circles_grid, testing::Values(
- String_Size_t("cv/cameracalibration/asymmetric_circles/acircles1.jpg", Size(7,13)),
- String_Size_t("cv/cameracalibration/asymmetric_circles/acircles2.jpg", Size(7,13)),
- String_Size_t("cv/cameracalibration/asymmetric_circles/acircles3.jpg", Size(7,13)),
- String_Size_t("cv/cameracalibration/asymmetric_circles/acircles4.jpg", Size(5,5)),
- String_Size_t("cv/cameracalibration/asymmetric_circles/acircles5.jpg", Size(5,5)),
- String_Size_t("cv/cameracalibration/asymmetric_circles/acircles6.jpg", Size(5,5)),
- String_Size_t("cv/cameracalibration/asymmetric_circles/acircles7.jpg", Size(3,9)),
- String_Size_t("cv/cameracalibration/asymmetric_circles/acircles8.jpg", Size(3,9)),
- String_Size_t("cv/cameracalibration/asymmetric_circles/acircles9.jpg", Size(3,9))
- )
- )
+ String_Size_t("cv/cameracalibration/asymmetric_circles/acircles1.jpg", Size(7,13)),
+ String_Size_t("cv/cameracalibration/asymmetric_circles/acircles2.jpg", Size(7,13)),
+ String_Size_t("cv/cameracalibration/asymmetric_circles/acircles3.jpg", Size(7,13)),
+ String_Size_t("cv/cameracalibration/asymmetric_circles/acircles4.jpg", Size(5,5)),
+ String_Size_t("cv/cameracalibration/asymmetric_circles/acircles5.jpg", Size(5,5)),
+ String_Size_t("cv/cameracalibration/asymmetric_circles/acircles6.jpg", Size(5,5)),
+ String_Size_t("cv/cameracalibration/asymmetric_circles/acircles7.jpg", Size(3,9)),
+ String_Size_t("cv/cameracalibration/asymmetric_circles/acircles8.jpg", Size(3,9)),
+ String_Size_t("cv/cameracalibration/asymmetric_circles/acircles9.jpg", Size(3,9))
+ )
+ )
{
- String filename = getDataPath(std::tr1::get<0>(GetParam()));
- Size gridSize = std::tr1::get<1>(GetParam());
+ String filename = getDataPath(get<0>(GetParam()));
+ Size gridSize = get<1>(GetParam());
Mat frame = imread(filename);
if (frame.empty())
FAIL() << "Unable to load source image " << filename;
+
vector<Point2f> ptvec;
ptvec.resize(gridSize.area());
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);
}
using namespace std;
using namespace cv;
using namespace perf;
+using std::tr1::make_tuple;
+using std::tr1::get;
+CV_ENUM(pnpAlgo, CV_ITERATIVE, CV_EPNP /*, CV_P3P*/)
-typedef std::tr1::tuple<std::string, cv::Size> String_Size_t;
-typedef perf::TestBaseWithParam<int> PointsNumber;
+typedef std::tr1::tuple<int, pnpAlgo> PointsNum_Algo_t;
+typedef perf::TestBaseWithParam<PointsNum_Algo_t> PointsNum_Algo;
-PERF_TEST_P(PointsNumber, solvePnP, testing::Values(4, 3*9, 7*13)
- )
+PERF_TEST_P(PointsNum_Algo, solvePnP,
+ testing::Combine(
+ testing::Values(4, 3*9, 7*13),
+ testing::Values((int)CV_ITERATIVE, (int)CV_EPNP)
+ )
+ )
{
- int pointsNum = GetParam();
+ int pointsNum = get<0>(GetParam());
+ pnpAlgo algo = get<1>(GetParam());
vector<Point2f> points2d(pointsNum);
vector<Point3f> points3d(pointsNum);
declare.in(points3d, points2d);
- TEST_CYCLE(1000)
- {
- solvePnP(points3d, points2d, intrinsics, distortion, rvec, tvec, false);
- }
+ TEST_CYCLE_N(1000) solvePnP(points3d, points2d, intrinsics, distortion, rvec, tvec, false, algo);
+
+ SANITY_CHECK(rvec, 1e-6);
+ SANITY_CHECK(tvec, 1e-6);
+}
+
+PERF_TEST(PointsNum_Algo, solveP3P)
+{
+ int pointsNum = 4;
+
+ vector<Point2f> points2d(pointsNum);
+ vector<Point3f> points3d(pointsNum);
+ Mat rvec = Mat::zeros(3, 1, CV_32FC1);
+ Mat tvec = Mat::zeros(3, 1, CV_32FC1);
+
+ Mat distortion = Mat::zeros(5, 1, CV_32FC1);
+ Mat intrinsics = Mat::eye(3, 3, CV_32FC1);
+ intrinsics.at<float> (0, 0) = 400.0;
+ intrinsics.at<float> (1, 1) = 400.0;
+ intrinsics.at<float> (0, 2) = 640 / 2;
+ intrinsics.at<float> (1, 2) = 480 / 2;
+
+ warmup(points3d, WARMUP_RNG);
+ warmup(rvec, WARMUP_RNG);
+ warmup(tvec, WARMUP_RNG);
+
+ projectPoints(points3d, rvec, tvec, intrinsics, distortion, points2d);
+
+ //add noise
+ Mat noise(1, points2d.size(), CV_32FC2);
+ randu(noise, 0, 0.01);
+ add(points2d, noise, points2d);
+
+ declare.in(points3d, points2d);
+
+ TEST_CYCLE_N(1000) solvePnP(points3d, points2d, intrinsics, distortion, rvec, tvec, false, CV_P3P);
SANITY_CHECK(rvec, 1e-6);
SANITY_CHECK(tvec, 1e-6);
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
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);
}
--- /dev/null
+#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);
+}
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);
}
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)
typedef perf::TestBaseWithParam<Size_MatType_CmpType_t> Size_MatType_CmpType;
PERF_TEST_P( Size_MatType_CmpType, compare,
- testing::Combine(
- testing::Values( TYPICAL_MAT_SIZES ),
- testing::Values( CV_8UC1, CV_8UC4, CV_8SC1, CV_16UC1, CV_16SC1, CV_32SC1, CV_32FC1 ),
- testing::ValuesIn( CmpType::all() )
- )
-)
+ testing::Combine(
+ testing::Values(TYPICAL_MAT_SIZES),
+ testing::Values(CV_8UC1, CV_8UC4, CV_8SC1, CV_16UC1, CV_16SC1, CV_32SC1, CV_32FC1),
+ testing::ValuesIn(CmpType::all())
+ )
+ )
{
- Size sz = std::tr1::get<0>(GetParam());
- int matType1 = std::tr1::get<1>(GetParam());
- CmpType cmpType = std::tr1::get<2>(GetParam());
+ Size sz = get<0>(GetParam());
+ int matType1 = get<1>(GetParam());
+ CmpType cmpType = get<2>(GetParam());
Mat src1(sz, matType1);
Mat src2(sz, matType1);
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;
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);
}
+++ /dev/null
-#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);
-}
using namespace std;\r
using namespace cv;\r
using namespace perf;\r
+using std::tr1::make_tuple;\r
+using std::tr1::get;\r
\r
#define MAT_TYPES_DFT CV_32FC1, CV_64FC1\r
#define MAT_SIZES_DFT sz1080p, sz2K\r
-#define TEST_MATS_DFT testing::Combine( testing::Values(MAT_SIZES_DFT), testing::Values(MAT_TYPES_DFT) )\r
+#define TEST_MATS_DFT testing::Combine(testing::Values(MAT_SIZES_DFT), testing::Values(MAT_TYPES_DFT))\r
\r
PERF_TEST_P(Size_MatType, dft, TEST_MATS_DFT)\r
{\r
- Size sz = std::tr1::get<0>(GetParam());\r
- int type = std::tr1::get<1>(GetParam());\r
+ Size sz = get<0>(GetParam());\r
+ int type = get<1>(GetParam());\r
\r
Mat src(sz, type);\r
Mat dst(sz, type);\r
- \r
- declare.in(src, WARMUP_RNG);\r
- declare.time(60);\r
\r
- TEST_CYCLE(100) \r
- {\r
- dft(src, dst);\r
- }\r
+ declare.in(src, WARMUP_RNG).time(60);\r
+\r
+ TEST_CYCLE() dft(src, dst);\r
\r
SANITY_CHECK(dst, 1e-5);\r
}\r
using namespace std;\r
using namespace cv;\r
using namespace perf;\r
+using std::tr1::make_tuple;\r
+using std::tr1::get;\r
\r
typedef tr1::tuple<int, int> MatType_Length_t;\r
typedef TestBaseWithParam<MatType_Length_t> MatType_Length;\r
\r
PERF_TEST_P( MatType_Length, dot,\r
testing::Combine(\r
- testing::Values( CV_8UC1, CV_32SC1, CV_32FC1 ),\r
- testing::Values( 32, 64, 128, 256, 512, 1024 )\r
- ))\r
+ testing::Values( CV_8UC1, CV_32SC1, CV_32FC1 ),\r
+ testing::Values( 32, 64, 128, 256, 512, 1024 )\r
+ ))\r
{\r
- unsigned int type = std::tr1::get<0>(GetParam());\r
- unsigned int size = std::tr1::get<1>(GetParam());\r
+ int type = get<0>(GetParam());\r
+ int size = get<1>(GetParam());\r
Mat a(size, size, type);\r
Mat b(size, size, type);\r
\r
- declare.in(a, WARMUP_RNG);\r
- declare.in(b, WARMUP_RNG);\r
+ declare.in(a, b, WARMUP_RNG);\r
\r
double product;\r
\r
- TEST_CYCLE(100)\r
- {\r
- product = a.dot(b);\r
- }\r
+ TEST_CYCLE_N(1000) product = a.dot(b);\r
\r
- SANITY_CHECK(product, 1e-5);\r
+ SANITY_CHECK(product, 1e-6, ERROR_RELATIVE);\r
}\r
using namespace std;
using namespace cv;
using namespace perf;
+using std::tr1::make_tuple;
+using std::tr1::get;
typedef perf::TestBaseWithParam<size_t> VectorLength;
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);
}
+++ /dev/null
-#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);
-}
--- /dev/null
+#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);
+}
--- /dev/null
+#include "perf_precomp.hpp"
+
+using namespace std;
+using namespace cv;
+using namespace perf;
+using std::tr1::make_tuple;
+using std::tr1::get;
+
+
+CV_FLAGS(NormType, NORM_INF, NORM_L1, NORM_L2, NORM_TYPE_MASK, NORM_RELATIVE, NORM_MINMAX)
+typedef std::tr1::tuple<Size, MatType, NormType> Size_MatType_NormType_t;
+typedef perf::TestBaseWithParam<Size_MatType_NormType_t> Size_MatType_NormType;
+
+PERF_TEST_P(Size_MatType_NormType, norm,
+ testing::Combine(
+ testing::Values(TYPICAL_MAT_SIZES),
+ testing::Values(TYPICAL_MAT_TYPES),
+ testing::Values((int)NORM_INF, (int)NORM_L1, (int)NORM_L2)
+ )
+ )
+{
+ Size sz = get<0>(GetParam());
+ int matType = get<1>(GetParam());
+ int normType = get<2>(GetParam());
+
+ Mat src(sz, matType);
+ double n;
+
+ declare.in(src, WARMUP_RNG);
+
+ TEST_CYCLE() n = norm(src, normType);
+
+ SANITY_CHECK(n, 1e-6, ERROR_RELATIVE);
+}
+
+PERF_TEST_P(Size_MatType_NormType, norm_mask,
+ testing::Combine(
+ testing::Values(TYPICAL_MAT_SIZES),
+ testing::Values(TYPICAL_MAT_TYPES),
+ testing::Values((int)NORM_INF, (int)NORM_L1, (int)NORM_L2)
+ )
+ )
+{
+ Size sz = get<0>(GetParam());
+ int matType = get<1>(GetParam());
+ int normType = get<2>(GetParam());
+
+ Mat src(sz, matType);
+ Mat mask = Mat::ones(sz, CV_8U);
+ double n;
+
+ declare.in(src, WARMUP_RNG).in(mask);
+
+ TEST_CYCLE() n = norm(src, normType, mask);
+
+ SANITY_CHECK(n, 1e-6, ERROR_RELATIVE);
+}
+
+PERF_TEST_P(Size_MatType_NormType, norm2,
+ testing::Combine(
+ testing::Values(TYPICAL_MAT_SIZES),
+ testing::Values(TYPICAL_MAT_TYPES),
+ testing::Values((int)NORM_INF, (int)NORM_L1, (int)NORM_L2, (int)(NORM_RELATIVE+NORM_INF), (int)(NORM_RELATIVE+NORM_L1), (int)(NORM_RELATIVE+NORM_L2))
+ )
+ )
+{
+ Size sz = get<0>(GetParam());
+ int matType = get<1>(GetParam());
+ int normType = get<2>(GetParam());
+
+ Mat src1(sz, matType);
+ Mat src2(sz, matType);
+ double n;
+
+ declare.in(src1, src2, WARMUP_RNG);
+
+ TEST_CYCLE() n = norm(src1, src2, normType);
+
+ SANITY_CHECK(n, 1e-5, ERROR_RELATIVE);
+}
+
+PERF_TEST_P(Size_MatType_NormType, norm2_mask,
+ testing::Combine(
+ testing::Values(TYPICAL_MAT_SIZES),
+ testing::Values(TYPICAL_MAT_TYPES),
+ testing::Values((int)NORM_INF, (int)NORM_L1, (int)NORM_L2, (int)(NORM_RELATIVE|NORM_INF), (int)(NORM_RELATIVE|NORM_L1), (int)(NORM_RELATIVE|NORM_L2))
+ )
+ )
+{
+ Size sz = get<0>(GetParam());
+ int matType = get<1>(GetParam());
+ int normType = get<2>(GetParam());
+
+ Mat src1(sz, matType);
+ Mat src2(sz, matType);
+ Mat mask = Mat::ones(sz, CV_8U);
+ double n;
+
+ declare.in(src1, src2, WARMUP_RNG).in(mask);
+
+ TEST_CYCLE() n = norm(src1, src2, normType, mask);
+
+ SANITY_CHECK(n, 1e-5, ERROR_RELATIVE);
+}
+
+PERF_TEST_P(Size_MatType_NormType, normalize,
+ testing::Combine(
+ testing::Values(TYPICAL_MAT_SIZES),
+ testing::Values(TYPICAL_MAT_TYPES),
+ testing::Values((int)NORM_INF, (int)NORM_L1, (int)NORM_L2)
+ )
+ )
+{
+ Size sz = get<0>(GetParam());
+ int matType = get<1>(GetParam());
+ int normType = get<2>(GetParam());
+
+ Mat src(sz, matType);
+ Mat dst(sz, matType);
+
+ double alpha = 100.;
+ if(normType==NORM_L1) alpha = (double)src.total() * src.channels();
+ if(normType==NORM_L2) alpha = (double)src.total()/10;
+
+ declare.in(src, WARMUP_RNG).out(dst);
+
+ TEST_CYCLE() normalize(src, dst, alpha, 0., normType);
+
+ SANITY_CHECK(dst, 1e-6);
+}
+
+PERF_TEST_P(Size_MatType_NormType, normalize_mask,
+ testing::Combine(
+ testing::Values(TYPICAL_MAT_SIZES),
+ testing::Values(TYPICAL_MAT_TYPES),
+ testing::Values((int)NORM_INF, (int)NORM_L1, (int)NORM_L2)
+ )
+ )
+{
+ Size sz = get<0>(GetParam());
+ int matType = get<1>(GetParam());
+ int normType = get<2>(GetParam());
+
+ Mat src(sz, matType);
+ Mat dst(sz, matType);
+ Mat mask = Mat::ones(sz, CV_8U);
+
+ double alpha = 100.;
+ if(normType==NORM_L1) alpha = (double)src.total() * src.channels();
+ if(normType==NORM_L2) alpha = (double)src.total()/10;
+
+ declare.in(src, WARMUP_RNG).in(mask).out(dst);
+
+ TEST_CYCLE() normalize(src, dst, alpha, 0., normType, -1, mask);
+
+ SANITY_CHECK(dst, 1e-6);
+}
+
+PERF_TEST_P(Size_MatType_NormType, normalize_32f,
+ testing::Combine(
+ testing::Values(TYPICAL_MAT_SIZES),
+ testing::Values(TYPICAL_MAT_TYPES),
+ testing::Values((int)NORM_INF, (int)NORM_L1, (int)NORM_L2)
+ )
+ )
+{
+ Size sz = get<0>(GetParam());
+ int matType = get<1>(GetParam());
+ int normType = get<2>(GetParam());
+
+ Mat src(sz, matType);
+ Mat dst(sz, CV_32F);
+
+ double alpha = 100.;
+ if(normType==NORM_L1) alpha = (double)src.total() * src.channels();
+ if(normType==NORM_L2) alpha = (double)src.total()/10;
+
+ declare.in(src, WARMUP_RNG).out(dst);
+
+ TEST_CYCLE() normalize(src, dst, alpha, 0., normType, CV_32F);
+
+ SANITY_CHECK(dst, 1e-6, ERROR_RELATIVE);
+}
+
+PERF_TEST_P( Size_MatType, normalize_minmax, TYPICAL_MATS )
+{
+ Size sz = get<0>(GetParam());
+ int matType = get<1>(GetParam());
+
+ Mat src(sz, matType);
+ Mat dst(sz, matType);
+
+ declare.in(src, WARMUP_RNG).out(dst);
+
+ TEST_CYCLE() normalize(src, dst, 20., 100., NORM_MINMAX);
+
+ SANITY_CHECK(dst, 1e-6, ERROR_RELATIVE);
+}
--- /dev/null
+#include "perf_precomp.hpp"
+#include "opencv2/core/core_c.h"
+
+using namespace std;
+using namespace cv;
+using namespace perf;
+using std::tr1::make_tuple;
+using std::tr1::get;
+
+CV_ENUM(ROp, CV_REDUCE_SUM, CV_REDUCE_AVG, CV_REDUCE_MAX, CV_REDUCE_MIN)
+typedef std::tr1::tuple<Size, MatType, ROp> Size_MatType_ROp_t;
+typedef perf::TestBaseWithParam<Size_MatType_ROp_t> Size_MatType_ROp;
+
+
+PERF_TEST_P(Size_MatType_ROp, reduceR,
+ testing::Combine(
+ testing::Values(TYPICAL_MAT_SIZES),
+ testing::Values(TYPICAL_MAT_TYPES),
+ testing::ValuesIn(ROp::all())
+ )
+ )
+{
+ Size sz = get<0>(GetParam());
+ int matType = get<1>(GetParam());
+ int reduceOp = get<2>(GetParam());
+
+ int ddepth = -1;
+ if( CV_MAT_DEPTH(matType) < CV_32S && (reduceOp == CV_REDUCE_SUM || reduceOp == CV_REDUCE_AVG) )
+ ddepth = CV_32S;
+
+ Mat src(sz, matType);
+ Mat vec(1, sz.width, ddepth < 0 ? matType : ddepth);
+
+ declare.in(src, WARMUP_RNG).out(vec);
+
+ TEST_CYCLE() reduce(src, vec, 0, reduceOp, ddepth);
+
+ SANITY_CHECK(vec, 1);
+}
+
+PERF_TEST_P(Size_MatType_ROp, reduceC,
+ testing::Combine(
+ testing::Values(TYPICAL_MAT_SIZES),
+ testing::Values(TYPICAL_MAT_TYPES),
+ testing::ValuesIn(ROp::all())
+ )
+ )
+{
+ Size sz = get<0>(GetParam());
+ int matType = get<1>(GetParam());
+ int reduceOp = get<2>(GetParam());
+
+ int ddepth = -1;
+ if( CV_MAT_DEPTH(matType)< CV_32S && (reduceOp == CV_REDUCE_SUM || reduceOp == CV_REDUCE_AVG) )
+ ddepth = CV_32S;
+
+ Mat src(sz, matType);
+ Mat vec(sz.height, 1, ddepth < 0 ? matType : ddepth);
+
+ declare.in(src, WARMUP_RNG).out(vec);
+
+ TEST_CYCLE() reduce(src, vec, 1, reduceOp, ddepth);
+
+ SANITY_CHECK(vec, 1);
+}
+
#include "perf_precomp.hpp"
-#include "opencv2/core/core_c.h"
using namespace std;
using namespace cv;
using namespace perf;
+using std::tr1::make_tuple;
+using std::tr1::get;
-
-/*
-// Scalar sum(InputArray arr)
-*/
-PERF_TEST_P( Size_MatType, sum, TYPICAL_MATS )
+PERF_TEST_P(Size_MatType, sum, TYPICAL_MATS)
{
- Size sz = std::tr1::get<0>(GetParam());
- int type = std::tr1::get<1>(GetParam());
+ Size sz = get<0>(GetParam());
+ int type = get<1>(GetParam());
Mat arr(sz, type);
Scalar s;
- declare.in(arr, WARMUP_RNG);
+ declare.in(arr, WARMUP_RNG).out(s);
- TEST_CYCLE(100) { s = sum(arr); }
+ TEST_CYCLE() s = sum(arr);
SANITY_CHECK(s, 1e-6, ERROR_RELATIVE);
}
-
-/*
-// Scalar mean(InputArray src)
-*/
-PERF_TEST_P( Size_MatType, mean, TYPICAL_MATS )
+PERF_TEST_P(Size_MatType, mean, TYPICAL_MATS)
{
- Size sz = std::tr1::get<0>(GetParam());
- int type = std::tr1::get<1>(GetParam());
+ Size sz = get<0>(GetParam());
+ int type = get<1>(GetParam());
Mat src(sz, type);
Scalar s;
- declare.in(src, WARMUP_RNG);
+ declare.in(src, WARMUP_RNG).out(s);
- TEST_CYCLE(100) { s = mean(src); }
+ TEST_CYCLE() s = mean(src);
SANITY_CHECK(s, 1e-6);
}
-
-/*
-// Scalar mean(InputArray src, InputArray mask=noArray())
-*/
-PERF_TEST_P( Size_MatType, mean_mask, TYPICAL_MATS )
+PERF_TEST_P(Size_MatType, mean_mask, TYPICAL_MATS)
{
- Size sz = std::tr1::get<0>(GetParam());
- int type = std::tr1::get<1>(GetParam());
+ Size sz = get<0>(GetParam());
+ int type = get<1>(GetParam());
Mat src(sz, type);
Mat mask = Mat::ones(src.size(), CV_8U);
Scalar s;
- declare.in(src, WARMUP_RNG).in(mask);
+ declare.in(src, WARMUP_RNG).in(mask).out(s);
- TEST_CYCLE(100) { s = mean(src, mask); }
+ TEST_CYCLE() s = mean(src, mask);
SANITY_CHECK(s, 1e-6);
}
-CV_FLAGS(NormType, NORM_INF, NORM_L1, NORM_L2, NORM_TYPE_MASK, NORM_RELATIVE, NORM_MINMAX)
-typedef std::tr1::tuple<Size, MatType, NormType> Size_MatType_NormType_t;
-typedef perf::TestBaseWithParam<Size_MatType_NormType_t> Size_MatType_NormType;
-
-/*
-// double norm(InputArray src1, int normType=NORM_L2)
-*/
-PERF_TEST_P( Size_MatType_NormType, norm,
- testing::Combine(
- testing::Values( TYPICAL_MAT_SIZES ),
- testing::Values( TYPICAL_MAT_TYPES ),
- testing::Values( (int)NORM_INF, (int)NORM_L1, (int)NORM_L2 )
- )
-)
-{
- Size sz = std::tr1::get<0>(GetParam());
- int matType = std::tr1::get<1>(GetParam());
- int normType = std::tr1::get<2>(GetParam());
-
- Mat src1(sz, matType);
- double n;
-
- declare.in(src1, WARMUP_RNG);
-
- TEST_CYCLE(100) { n = norm(src1, normType); }
-
- SANITY_CHECK(n, 1e-6, ERROR_RELATIVE);
-}
-
-
-/*
-// double norm(InputArray src1, int normType=NORM_L2, InputArray mask=noArray())
-*/
-PERF_TEST_P( Size_MatType_NormType, norm_mask,
- testing::Combine(
- testing::Values( TYPICAL_MAT_SIZES ),
- testing::Values( TYPICAL_MAT_TYPES ),
- testing::Values( (int)NORM_INF, (int)NORM_L1, (int)NORM_L2 )
- )
-)
-{
- Size sz = std::tr1::get<0>(GetParam());
- int matType = std::tr1::get<1>(GetParam());
- int normType = std::tr1::get<2>(GetParam());
-
- Mat src1(sz, matType);
- Mat mask = Mat::ones(sz, CV_8U);
- double n;
-
- declare.in(src1, WARMUP_RNG).in(mask);
-
- TEST_CYCLE(100) { n = norm(src1, normType, mask); }
-
- SANITY_CHECK(n, 1e-6, ERROR_RELATIVE);
-}
-
-
-/*
-// double norm(InputArray src1, InputArray src2, int normType)
-*/
-PERF_TEST_P( Size_MatType_NormType, norm2,
- testing::Combine(
- testing::Values( TYPICAL_MAT_SIZES ),
- testing::Values( TYPICAL_MAT_TYPES ),
- testing::Values( (int)NORM_INF, (int)NORM_L1, (int)NORM_L2, (int)(NORM_RELATIVE+NORM_INF), (int)(NORM_RELATIVE+NORM_L1), (int)(NORM_RELATIVE+NORM_L2) )
- )
-)
-{
- Size sz = std::tr1::get<0>(GetParam());
- int matType = std::tr1::get<1>(GetParam());
- int normType = std::tr1::get<2>(GetParam());
-
- Mat src1(sz, matType);
- Mat src2(sz, matType);
- double n;
-
- declare.in(src1, src2, WARMUP_RNG);
-
- TEST_CYCLE(100) { n = norm(src1, src2, normType); }
-
- SANITY_CHECK(n, 1e-5, ERROR_RELATIVE);
-}
-
-
-/*
-// double norm(InputArray src1, InputArray src2, int normType, InputArray mask=noArray())
-*/
-PERF_TEST_P( Size_MatType_NormType, norm2_mask,
- testing::Combine(
- testing::Values( TYPICAL_MAT_SIZES ),
- testing::Values( TYPICAL_MAT_TYPES ),
- testing::Values( (int)NORM_INF, (int)NORM_L1, (int)NORM_L2, (int)(NORM_RELATIVE+NORM_INF), (int)(NORM_RELATIVE+NORM_L1), (int)(NORM_RELATIVE+NORM_L2) )
- )
-)
-{
- Size sz = std::tr1::get<0>(GetParam());
- int matType = std::tr1::get<1>(GetParam());
- int normType = std::tr1::get<2>(GetParam());
-
- Mat src1(sz, matType);
- Mat src2(sz, matType);
- Mat mask = Mat::ones(sz, CV_8U);
- double n;
-
- declare.in(src1, src2, WARMUP_RNG).in(mask);
-
- TEST_CYCLE(100) { n = norm(src1, src2, normType, mask); }
-
- SANITY_CHECK(n, 1e-5, ERROR_RELATIVE);
-}
-
-
-/*
-// void normalize(const InputArray src, OutputArray dst, double alpha=1, double beta=0, int normType=NORM_L2)
-*/
-PERF_TEST_P( Size_MatType_NormType, normalize,
- testing::Combine(
- testing::Values( TYPICAL_MAT_SIZES ),
- testing::Values( TYPICAL_MAT_TYPES ),
- testing::Values( (int)NORM_INF, (int)NORM_L1, (int)NORM_L2 )
- )
-)
-{
- Size sz = std::tr1::get<0>(GetParam());
- int matType = std::tr1::get<1>(GetParam());
- int normType = std::tr1::get<2>(GetParam());
-
- Mat src(sz, matType);
- Mat dst(sz, matType);
- double alpha = 100.;
- if(normType==NORM_L1) alpha = (double)src.total() * src.channels();
- if(normType==NORM_L2) alpha = (double)src.total()/10;
-
- declare.in(src, WARMUP_RNG).out(dst);
-
- TEST_CYCLE(100) { normalize(src, dst, alpha, 0., normType); }
-
- SANITY_CHECK(dst, 1e-6);
-}
-
-
-/*
-// void normalize(const InputArray src, OutputArray dst, double alpha=1, double beta=0, int normType=NORM_L2, int rtype=-1, InputArray mask=noArray())
-*/
-PERF_TEST_P( Size_MatType_NormType, normalize_mask,
- testing::Combine(
- testing::Values( TYPICAL_MAT_SIZES ),
- testing::Values( TYPICAL_MAT_TYPES ),
- testing::Values( (int)NORM_INF, (int)NORM_L1, (int)NORM_L2 )
- )
-)
-{
- Size sz = std::tr1::get<0>(GetParam());
- int matType = std::tr1::get<1>(GetParam());
- int normType = std::tr1::get<2>(GetParam());
-
- Mat src(sz, matType);
- Mat dst(sz, matType);
- Mat mask = Mat::ones(sz, CV_8U);
- double alpha = 100.;
- if(normType==NORM_L1) alpha = (double)src.total() * src.channels();
- if(normType==NORM_L2) alpha = (double)src.total()/10;
-
- declare.in(src, WARMUP_RNG).in(mask).out(dst);
-
- TEST_CYCLE(100) { normalize(src, dst, alpha, 0., normType, -1, mask); }
-
- SANITY_CHECK(dst, 1e-6);
-}
-
-
-/*
-// void normalize(const InputArray src, OutputArray dst, double alpha=1, double beta=0, int normType=NORM_L2, int rtype=-1)
-*/
-PERF_TEST_P( Size_MatType_NormType, normalize_32f,
- testing::Combine(
- testing::Values( TYPICAL_MAT_SIZES ),
- testing::Values( TYPICAL_MAT_TYPES ),
- testing::Values( (int)NORM_INF, (int)NORM_L1, (int)NORM_L2 )
- )
-)
-{
- Size sz = std::tr1::get<0>(GetParam());
- int matType = std::tr1::get<1>(GetParam());
- int normType = std::tr1::get<2>(GetParam());
-
- Mat src(sz, matType);
- Mat dst(sz, matType);
- double alpha = 100.;
- if(normType==NORM_L1) alpha = (double)src.total() * src.channels();
- if(normType==NORM_L2) alpha = (double)src.total()/10;
-
- declare.in(src, WARMUP_RNG).out(dst);
-
- TEST_CYCLE(100) { normalize(src, dst, alpha, 0., normType, CV_32F); }
-
- SANITY_CHECK(dst, 1e-6, ERROR_RELATIVE);
-}
-
-
-/*
-// void normalize(const InputArray src, OutputArray dst, double alpha=1, double beta=0, int normType=NORM_L2)
-*/
-PERF_TEST_P( Size_MatType, normalize_minmax, TYPICAL_MATS )
-{
- Size sz = std::tr1::get<0>(GetParam());
- int matType = std::tr1::get<1>(GetParam());
-
- Mat src(sz, matType);
- randu(src, 0, 256);
- Mat dst(sz, matType);
-
- declare.in(src).out(dst);
-
- TEST_CYCLE(100) { normalize(src, dst, 20., 100., NORM_MINMAX); }
-
- SANITY_CHECK(dst, 1e-6);
-}
-
-
-/*
-// void meanStdDev(InputArray src, OutputArray mean, OutputArray stddev)
-*/
-PERF_TEST_P( Size_MatType, meanStdDev, TYPICAL_MATS )
+PERF_TEST_P(Size_MatType, meanStdDev, TYPICAL_MATS)
{
- Size sz = std::tr1::get<0>(GetParam());
- int matType = std::tr1::get<1>(GetParam());
+ Size sz = get<0>(GetParam());
+ int matType = get<1>(GetParam());
Mat src(sz, matType);
- Mat mean, dev;
+ Scalar mean;
+ Scalar dev;
- declare.in(src, WARMUP_RNG);
+ declare.in(src, WARMUP_RNG).out(mean, dev);
- TEST_CYCLE(100) { meanStdDev(src, mean, dev); }
+ TEST_CYCLE() meanStdDev(src, mean, dev);
SANITY_CHECK(mean, 1e-6);
SANITY_CHECK(dev, 1e-6);
}
-
-/*
-// void meanStdDev(InputArray src, OutputArray mean, OutputArray stddev, InputArray mask=noArray())
-*/
-PERF_TEST_P( Size_MatType, meanStdDev_mask, TYPICAL_MATS )
+PERF_TEST_P(Size_MatType, meanStdDev_mask, TYPICAL_MATS)
{
- Size sz = std::tr1::get<0>(GetParam());
- int matType = std::tr1::get<1>(GetParam());
+ Size sz = get<0>(GetParam());
+ int matType = get<1>(GetParam());
Mat src(sz, matType);
Mat mask = Mat::ones(sz, CV_8U);
- Mat mean, dev;
+ Scalar mean;
+ Scalar dev;
- declare.in(src, WARMUP_RNG).in(mask);
+ declare.in(src, WARMUP_RNG).in(mask).out(mean, dev);
- TEST_CYCLE(100) { meanStdDev(src, mean, dev, mask); }
+ TEST_CYCLE() meanStdDev(src, mean, dev, mask);
SANITY_CHECK(mean, 1e-6);
SANITY_CHECK(dev, 1e-6);
}
-
-/*
-// int countNonZero(InputArray mtx)
-*/
-PERF_TEST_P( Size_MatType, countNonZero, TYPICAL_MATS_C1 )
+PERF_TEST_P(Size_MatType, countNonZero, TYPICAL_MATS_C1)
{
- Size sz = std::tr1::get<0>(GetParam());
- int matType = std::tr1::get<1>(GetParam());
+ Size sz = get<0>(GetParam());
+ int matType = get<1>(GetParam());
Mat src(sz, matType);
int cnt = 0;
declare.in(src, WARMUP_RNG);
- TEST_CYCLE(100) { cnt = countNonZero(src); }
+ TEST_CYCLE() cnt = countNonZero(src);
SANITY_CHECK(cnt);
}
-
-/*
-// void minMaxLoc(InputArray src, double* minVal, double* maxVal=0, Point* minLoc=0, Point* maxLoc=0, InputArray mask=noArray())
-*/
-PERF_TEST_P( Size_MatType, minMaxLoc, testing::Combine(
- testing::Values( TYPICAL_MAT_SIZES ),
- testing::Values( CV_8UC1, CV_8SC1, CV_16UC1, CV_16SC1, CV_32SC1, CV_32FC1, CV_64FC1 ) ) )
-{
- Size sz = std::tr1::get<0>(GetParam());
- int matType = std::tr1::get<1>(GetParam());
-
- Mat src(sz, matType);
- double minVal, maxVal;
- Point minLoc, maxLoc;
-
- // avoid early exit on 1 byte data
- if (matType == CV_8U)
- randu(src, 1, 254);
- else if (matType == CV_8S)
- randu(src, -127, 126);
- else
- warmup(src, WARMUP_RNG);
-
- declare.in(src);
-
- TEST_CYCLE(100) { minMaxLoc(src, &minVal, &maxVal, &minLoc, &maxLoc); }
-
- SANITY_CHECK(minVal, 1e-12);
- SANITY_CHECK(maxVal, 1e-12);
-}
-
-
-
-CV_ENUM(ROp, CV_REDUCE_SUM, CV_REDUCE_AVG, CV_REDUCE_MAX, CV_REDUCE_MIN)
-typedef std::tr1::tuple<Size, MatType, ROp> Size_MatType_ROp_t;
-typedef perf::TestBaseWithParam<Size_MatType_ROp_t> Size_MatType_ROp;
-
-
-/*
-// void reduce(InputArray mtx, OutputArray vec, int dim, int reduceOp, int dtype=-1)
-*/
-PERF_TEST_P( Size_MatType_ROp, reduceR,
- testing::Combine(
- testing::Values( TYPICAL_MAT_SIZES ),
- testing::Values( TYPICAL_MAT_TYPES ),
- testing::ValuesIn(ROp::all())
- )
-)
-{
- Size sz = std::tr1::get<0>(GetParam());
- int matType = std::tr1::get<1>(GetParam());
- int reduceOp = std::tr1::get<2>(GetParam());
-
- int ddepth = -1;
- if( CV_MAT_DEPTH(matType)< CV_32S && (reduceOp == CV_REDUCE_SUM || reduceOp == CV_REDUCE_AVG) )
- ddepth = CV_32S;
- Mat src(sz, matType);
- Mat vec;
-
- declare.in(src, WARMUP_RNG);
-
- TEST_CYCLE(100) { reduce(src, vec, 0, reduceOp, ddepth); }
-
- SANITY_CHECK(vec, 1);
-}
-
-/*
-// void reduce(InputArray mtx, OutputArray vec, int dim, int reduceOp, int dtype=-1)
-*/
-PERF_TEST_P( Size_MatType_ROp, reduceC,
- testing::Combine(
- testing::Values( TYPICAL_MAT_SIZES ),
- testing::Values( TYPICAL_MAT_TYPES ),
- testing::ValuesIn(ROp::all())
- )
-)
-{
- Size sz = std::tr1::get<0>(GetParam());
- int matType = std::tr1::get<1>(GetParam());
- int reduceOp = std::tr1::get<2>(GetParam());
-
- int ddepth = -1;
- if( CV_MAT_DEPTH(matType)< CV_32S && (reduceOp == CV_REDUCE_SUM || reduceOp == CV_REDUCE_AVG) )
- ddepth = CV_32S;
- Mat src(sz, matType);
- Mat vec;
-
- declare.in(src, WARMUP_RNG);
-
- TEST_CYCLE(100) { reduce(src, vec, 1, reduceOp, ddepth); }
-
- SANITY_CHECK(vec, 1);
-}
using namespace std;
using namespace cv;
using namespace perf;
-
+using std::tr1::make_tuple;
+using std::tr1::get;
typedef perf::TestBaseWithParam<std::string> fast;
"cv/detectors_descriptors_evaluation/images_datasets/leuven/img1.png",\
"stitching/a3.jpg"
-PERF_TEST_P( fast, detectForORB, testing::Values(FAST_IMAGES) )
+PERF_TEST_P(fast, detectForORB, testing::Values(FAST_IMAGES))
{
String filename = getDataPath(GetParam());
Mat frame = imread(filename, IMREAD_GRAYSCALE);
if (frame.empty())
FAIL() << "Unable to load source image " << filename;
- Mat mask;
declare.in(frame);
FastFeatureDetector fd(20, true);
vector<KeyPoint> points;
- TEST_CYCLE(100)
- {
- fd.detect(frame, points);
- }
+ TEST_CYCLE() fd.detect(frame, points);
}
using namespace std;
using namespace cv;
using namespace perf;
-
+using std::tr1::make_tuple;
+using std::tr1::get;
typedef perf::TestBaseWithParam<std::string> orb;
"cv/detectors_descriptors_evaluation/images_datasets/leuven/img1.png",\
"stitching/a3.jpg"
-PERF_TEST_P( orb, detect, testing::Values(ORB_IMAGES) )
+PERF_TEST_P(orb, detect, testing::Values(ORB_IMAGES))
{
String filename = getDataPath(GetParam());
Mat frame = imread(filename, IMREAD_GRAYSCALE);
ORB detector(1500, ORB::CommonParams(1.3f, 5));
vector<KeyPoint> points;
- TEST_CYCLE(100)
- {
- detector(frame, mask, points);
- }
+ TEST_CYCLE() detector(frame, mask, points);
}
-PERF_TEST_P( orb, extract, testing::Values(ORB_IMAGES) )
+PERF_TEST_P(orb, extract, testing::Values(ORB_IMAGES))
{
String filename = getDataPath(GetParam());
Mat frame = imread(filename, IMREAD_GRAYSCALE);
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);
vector<KeyPoint> points;
Mat descriptors;
- TEST_CYCLE(100)
- {
- detector(frame, mask, points, descriptors, false);
- }
+ TEST_CYCLE() detector(frame, mask, points, descriptors, false);
}
using namespace std;
using namespace cv;
using namespace perf;
-
+using std::tr1::make_tuple;
+using std::tr1::get;
typedef perf::TestBaseWithParam<std::string> surf;
"cv/detectors_descriptors_evaluation/images_datasets/leuven/img1.png",\
"stitching/a3.jpg"
-PERF_TEST_P( surf, detect, testing::Values(SURF_IMAGES) )
+PERF_TEST_P(surf, detect, testing::Values(SURF_IMAGES))
{
String filename = getDataPath(GetParam());
Mat frame = imread(filename, IMREAD_GRAYSCALE);
SURF detector;
vector<KeyPoint> points;
- TEST_CYCLE(100)
- {
- detector(frame, mask, points);
- }
+ TEST_CYCLE() detector(frame, mask, points);
}
-PERF_TEST_P( surf, extract, testing::Values(SURF_IMAGES) )
+PERF_TEST_P(surf, extract, testing::Values(SURF_IMAGES))
{
String filename = getDataPath(GetParam());
Mat frame = imread(filename, IMREAD_GRAYSCALE);
vector<float> descriptors;
detector(frame, mask, points);
- TEST_CYCLE(100)
- {
- detector(frame, mask, points, descriptors, true);
- }
+ TEST_CYCLE() detector(frame, mask, points, descriptors, true);
}
-PERF_TEST_P( surf, full, testing::Values(SURF_IMAGES) )
+PERF_TEST_P(surf, full, testing::Values(SURF_IMAGES))
{
String filename = getDataPath(GetParam());
Mat frame = imread(filename, IMREAD_GRAYSCALE);
vector<KeyPoint> points;
vector<float> descriptors;
- TEST_CYCLE(100)
- {
- detector(frame, mask, points, descriptors, false);
- }
+ TEST_CYCLE() detector(frame, mask, points, descriptors, false);
}
cv::gpu::GpuMat src(src_host);\r
cv::gpu::GpuMat dst;\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
cv::gpu::transpose(src, dst);\r
}\r
cv::gpu::GpuMat src(src_host);\r
cv::gpu::GpuMat dst;\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
cv::gpu::flip(src, dst, flipCode);\r
}\r
cv::gpu::GpuMat src(src_host);\r
cv::gpu::GpuMat dst;\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
cv::gpu::LUT(src, lut, dst);\r
}\r
cv::gpu::GpuMat magnitude;\r
cv::gpu::GpuMat angle;\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
cv::gpu::cartToPolar(x, y, magnitude, angle);\r
}\r
cv::gpu::GpuMat x;\r
cv::gpu::GpuMat y;\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
cv::gpu::polarToCart(magnitude, angle, x, y, true);\r
}\r
cv::gpu::GpuMat src2(src2_host);\r
cv::gpu::GpuMat dst;\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
cv::gpu::add(src1, src2, dst);\r
}\r
cv::Scalar s(1,2,3,4);\r
cv::gpu::GpuMat dst;\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
cv::gpu::add(src, s, dst);\r
}\r
cv::gpu::GpuMat src(src_host);\r
cv::gpu::GpuMat dst;\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
cv::gpu::exp(src, dst);\r
}\r
cv::gpu::GpuMat src(src_host);\r
cv::gpu::GpuMat dst;\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
cv::gpu::pow(src, 0.5, dst);\r
}\r
cv::gpu::GpuMat src2(src2_host);\r
cv::gpu::GpuMat dst;\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
cv::gpu::compare(src1, src2, dst, cv::CMP_EQ);\r
}\r
cv::gpu::GpuMat src(src_host);\r
cv::gpu::GpuMat dst;\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
cv::gpu::bitwise_not(src, dst);\r
}\r
cv::gpu::GpuMat src2(src2_host);\r
cv::gpu::GpuMat dst;\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
cv::gpu::bitwise_and(src1, src2, dst);\r
}\r
cv::gpu::GpuMat src2(src2_host);\r
cv::gpu::GpuMat dst(size, type);\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
cv::gpu::min(src1, src2, dst);\r
}\r
cv::Scalar mean;\r
cv::Scalar stddev;\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
cv::gpu::meanStdDev(src, mean, stddev);\r
}\r
double dst;\r
cv::gpu::GpuMat buf;\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
dst = cv::gpu::norm(src, normType, buf);\r
}\r
cv::gpu::GpuMat src2(src2_host);\r
double dst;\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
dst = cv::gpu::norm(src1, src2, normType);\r
}\r
cv::Scalar dst;\r
cv::gpu::GpuMat buf;\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
dst = cv::gpu::sum(src, buf);\r
}\r
double minVal, maxVal;\r
cv::gpu::GpuMat buf;\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
cv::gpu::minMax(src, &minVal, &maxVal, cv::gpu::GpuMat(), buf);\r
}\r
cv::Point minLoc, maxLoc;\r
cv::gpu::GpuMat valbuf, locbuf;\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
cv::gpu::minMaxLoc(src, &minVal, &maxVal, &minLoc, &maxLoc, cv::gpu::GpuMat(), valbuf, locbuf);\r
}\r
int dst;\r
cv::gpu::GpuMat buf;\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
dst = cv::gpu::countNonZero(src, buf);\r
}\r
cv::gpu::GpuMat src2(src2_host);\r
cv::gpu::GpuMat dst;\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
cv::gpu::addWeighted(src1, 0.5, src2, 0.5, 0.0, dst);\r
}\r
cv::gpu::GpuMat src(src_host);\r
cv::gpu::GpuMat dst;\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
cv::gpu::reduce(src, dst, dim, CV_REDUCE_MIN);\r
}\r
\r
declare.time(5.0);\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
cv::gpu::gemm(src1, src2, 1.0, src3, 1.0, dst);\r
}\r
cv::gpu::GpuMat src(src_host);\r
cv::gpu::GpuMat dst;\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
cv::gpu::transformPoints(src, cv::Mat::ones(1, 3, CV_32FC1), cv::Mat::ones(1, 3, CV_32FC1), dst);\r
}\r
cv::gpu::GpuMat src(src_host);\r
cv::gpu::GpuMat dst;\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
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);\r
}\r
\r
declare.time(3.0);\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
cv::gpu::solvePnPRansac(object, image, cv::Mat::ones(3, 3, CV_32FC1), cv::Mat(1, 8, CV_32F, cv::Scalar::all(0)), rvec, tvec);\r
}\r
\r
declare.time(5.0);\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
bm(img_l, img_r, dst);\r
}\r
\r
declare.time(10.0);\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
bp(img_l, img_r, dst);\r
}\r
\r
declare.time(10.0);\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
bp(img_l, img_r, dst);\r
}\r
\r
cv::gpu::DisparityBilateralFilter f(128);\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
f(disp, img, dst);\r
}\r
\r
declare.time(3.0);\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
matcher.matchSingle(query, train, trainIdx, distance);\r
}\r
\r
declare.time(3.0);\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
matcher.knnMatchSingle(query, train, trainIdx, distance, allDist, k);\r
}\r
\r
declare.time(3.0);\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
matcher.radiusMatchSingle(query, train, trainIdx, distance, nMatches, 2.0);\r
}\r
\r
declare.time(2.0);\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
surf(img, cv::gpu::GpuMat(), keypoints, descriptors);\r
}\r
\r
cv::gpu::FAST_GPU fastGPU(20);\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
fastGPU(img, cv::gpu::GpuMat(), keypoints);\r
}\r
\r
cv::gpu::ORB_GPU orbGPU(4000);\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
orbGPU(img, cv::gpu::GpuMat(), keypoints, descriptors);\r
}\r
\r
cv::Ptr<cv::gpu::FilterEngine_GPU> filter = cv::gpu::createBoxFilter_GPU(type, type, cv::Size(ksize, ksize));\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
filter->apply(src, dst);\r
}\r
\r
cv::Ptr<cv::gpu::FilterEngine_GPU> filter = cv::gpu::createMorphologyFilter_GPU(op, type, cv::Mat::ones(ksize, ksize, CV_8U));\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
filter->apply(src, dst);\r
}\r
\r
declare.time(1.0);\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
filter->apply(src, dst);\r
}\r
\r
declare.time(1.0);\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
filter->apply(src, dst, cv::Rect(0, 0, src.cols, src.rows));\r
}\r
\r
declare.time(3.0);\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
cv::gpu::remap(src, dst, xmap, ymap, interpolation, borderMode);\r
}\r
\r
declare.time(5.0);\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
cv::gpu::meanShiftFiltering(src, dst, 50, 50);\r
}\r
\r
declare.time(5.0);\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
cv::gpu::meanShiftProc(src, dstr, dstsp, 50, 50);\r
}\r
\r
declare.time(5.0);\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
meanShiftSegmentation(src, dst, 10, 10, 20);\r
}\r
cv::gpu::GpuMat src(src_host);\r
cv::gpu::GpuMat dst;\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
cv::gpu::drawColorDisp(src, dst, 255);\r
}\r
cv::gpu::GpuMat src(src_host);\r
cv::gpu::GpuMat dst;\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
cv::gpu::reprojectImageTo3D(src, dst, cv::Mat::ones(4, 4, CV_32FC1));\r
}\r
cv::gpu::GpuMat src(src_host);\r
cv::gpu::GpuMat dst(size, CV_MAKETYPE(type, info.dcn));\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
cv::gpu::cvtColor(src, dst, info.code, info.dcn);\r
}\r
cv::gpu::GpuMat src(src_host);\r
cv::gpu::GpuMat dst(size, type);\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
cv::gpu::threshold(src, dst, 100.0, 255.0, cv::THRESH_BINARY);\r
}\r
\r
declare.time(1.0);\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
cv::gpu::resize(src, dst, cv::Size(), f, f, interpolation);\r
}\r
reflect[1][2] = size.height;\r
cv::Mat M(2, 3, CV_64F, (void*) reflect); \r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
cv::gpu::warpAffine(src, dst, M, size, interpolation);\r
}\r
reflect[1][2] = size.height;\r
cv::Mat M(3, 3, CV_64F, (void*)reflect); \r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
cv::gpu::warpPerspective(src, dst, M, size, interpolation);\r
}\r
cv::gpu::GpuMat map_x;\r
cv::gpu::GpuMat map_y;\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
cv::gpu::buildWarpPlaneMaps(size, cv::Rect(0, 0, size.width, size.height), cv::Mat::eye(3, 3, CV_32FC1), \r
cv::Mat::ones(3, 3, CV_32FC1), cv::Mat::zeros(1, 3, CV_32F), 1.0, map_x, map_y);\r
cv::gpu::GpuMat map_x;\r
cv::gpu::GpuMat map_y;\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
cv::gpu::buildWarpCylindricalMaps(size, cv::Rect(0, 0, size.width, size.height), cv::Mat::eye(3, 3, CV_32FC1),\r
cv::Mat::ones(3, 3, CV_32FC1), 1.0, map_x, map_y);\r
cv::gpu::GpuMat map_x;\r
cv::gpu::GpuMat map_y;\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
cv::gpu::buildWarpSphericalMaps(size, cv::Rect(0, 0, size.width, size.height), cv::Mat::eye(3, 3, CV_32FC1),\r
cv::Mat::ones(3, 3, CV_32FC1), 1.0, map_x, map_y);\r
cv::gpu::GpuMat src(src_host);\r
cv::gpu::GpuMat dst;\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
cv::gpu::rotate(src, dst, size, 30.0, 0, 0, interpolation);\r
}\r
cv::gpu::GpuMat src(src_host);\r
cv::gpu::GpuMat dst;\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
cv::gpu::copyMakeBorder(src, dst, 5, 5, 5, 5, borderType);\r
}\r
cv::gpu::GpuMat dst;\r
cv::gpu::GpuMat buf;\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
cv::gpu::integralBuffered(src, dst, buf);\r
}\r
cv::gpu::GpuMat src(src_host);\r
cv::gpu::GpuMat sum, sqsum;\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
cv::gpu::integral(src, sum, sqsum);\r
}\r
cv::gpu::GpuMat src(src_host);\r
cv::gpu::GpuMat dst;\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
cv::gpu::sqrIntegral(src, dst);\r
}\r
cv::gpu::GpuMat src(src_host);\r
cv::gpu::GpuMat dst;\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
cv::gpu::columnSum(src, dst);\r
}\r
int ksize = 7; \r
double k = 0.5;\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
cv::gpu::cornerHarris(src, dst, Dx, Dy, blockSize, ksize, k);\r
}\r
int blockSize = 3;\r
int ksize = 7; \r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
cv::gpu::cornerMinEigenVal(src, dst, Dx, Dy, blockSize, ksize);\r
}\r
cv::gpu::GpuMat b(b_host);\r
cv::gpu::GpuMat dst;\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
cv::gpu::mulSpectrums(a, b, dst, 0);\r
}\r
\r
declare.time(2.0);\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
cv::gpu::dft(src, dst, size);\r
}\r
\r
declare.time(2.0);\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
cv::gpu::convolve(image, templ, dst, false, buf);\r
}\r
cv::gpu::GpuMat src(src_host);\r
cv::gpu::GpuMat dst;\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
cv::gpu::pyrDown(src, dst);\r
}\r
cv::gpu::GpuMat src(src_host);\r
cv::gpu::GpuMat dst;\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
cv::gpu::pyrUp(src, dst);\r
}\r
cv::gpu::GpuMat weights2(size, CV_32FC1, cv::Scalar::all(0.5));\r
cv::gpu::GpuMat dst;\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
cv::gpu::blendLinear(img1, img2, weights1, weights2, dst);\r
}\r
cv::gpu::GpuMat dst;\r
cv::gpu::CannyBuf buf;\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
cv::gpu::Canny(image, buf, dst, 50.0, 100.0);\r
}\r
cv::gpu::GpuMat hist;\r
cv::gpu::GpuMat buf;\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
cv::gpu::calcHist(src, hist, buf);\r
}\r
cv::gpu::GpuMat hist;\r
cv::gpu::GpuMat buf;\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
cv::gpu::equalizeHist(src, dst, hist, buf);\r
}\r
\r
cv::gpu::ImagePyramid pyr;\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
pyr.build(src, 5);\r
}\r
\r
cv::gpu::ImagePyramid pyr(src, 3);\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
pyr.getLayer(dst, cv::Size(size.width / 2 + 10, size.height / 2 + 10));\r
}\r
\r
cv::gpu::GpuMat dst;\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
cv::gpu::merge(src, dst);\r
}\r
for (int i = 0; i < num_channels; ++i)\r
dst[i] = cv::gpu::GpuMat(size, type); \r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
cv::gpu::split(src, dst);\r
}\r
cv::gpu::GpuMat src(size, type);\r
cv::Scalar val(1, 2, 3, 4);\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
src.setTo(val);\r
}\r
cv::Scalar val(1, 2, 3, 4);\r
cv::gpu::GpuMat mask(mask_host);\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
src.setTo(val, mask);\r
}\r
cv::gpu::GpuMat mask(mask_host);\r
cv::gpu::GpuMat dst;\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
src.copyTo(dst, mask);\r
}\r
cv::gpu::GpuMat src(src_host);\r
cv::gpu::GpuMat dst;\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
src.convertTo(dst, type2, 0.5, 1.0);\r
}\r
cv::gpu::HOGDescriptor hog;\r
hog.setSVMDetector(cv::gpu::HOGDescriptor::getDefaultPeopleDetector());\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
hog.detectMultiScale(img, found_locations);\r
}\r
\r
declare.time(10);\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
d_flow(frame0, frame1, u, v);\r
}\r
cv::gpu::GpuMat newFrame;\r
cv::gpu::GpuMat buf;\r
\r
- TEST_CYCLE(100)\r
+ TEST_CYCLE()\r
{\r
cv::gpu::interpolateFrames(frame0, frame1, fu, fv, bu, bv, 0.5f, newFrame, buf);\r
}\r
typedef std::tr1::tuple<Size, MatType, int> Size_MatType_kSize_t;
typedef perf::TestBaseWithParam<Size_MatType_kSize_t> Size_MatType_kSize;
-PERF_TEST_P( Size_MatType_kSize, medianBlur,
- testing::Combine(
- testing::Values(szODD, szQVGA, szVGA, sz720p),
- testing::Values(CV_8UC1, CV_8UC4, CV_16UC1, CV_16SC1, CV_32FC1),
- testing::Values(3, 5)
- )
- )
+PERF_TEST_P(Size_MatType_kSize, medianBlur,
+ testing::Combine(
+ testing::Values(szODD, szQVGA, szVGA, sz720p),
+ testing::Values(CV_8UC1, CV_8UC4, CV_16UC1, CV_16SC1, CV_32FC1),
+ testing::Values(3, 5)
+ )
+ )
{
Size size = get<0>(GetParam());
int type = get<1>(GetParam());
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);
}
typedef std::tr1::tuple<Size, MatType, BorderType> Size_MatType_BorderType_t;
typedef perf::TestBaseWithParam<Size_MatType_BorderType_t> Size_MatType_BorderType;
-PERF_TEST_P( Size_MatType_BorderType3x3, gaussianBlur3x3,
- testing::Combine(
- testing::Values(szODD, szQVGA, szVGA, sz720p),
- testing::Values(CV_8UC1, CV_8UC4, CV_16UC1, CV_16SC1, CV_32FC1),
- testing::ValuesIn(BorderType3x3::all())
- )
- )
+PERF_TEST_P(Size_MatType_BorderType3x3, gaussianBlur3x3,
+ testing::Combine(
+ testing::Values(szODD, szQVGA, szVGA, sz720p),
+ testing::Values(CV_8UC1, CV_8UC4, CV_16UC1, CV_16SC1, CV_32FC1),
+ testing::ValuesIn(BorderType3x3::all())
+ )
+ )
{
Size size = get<0>(GetParam());
int type = get<1>(GetParam());
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());
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());
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());
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);
}
typedef std::tr1::tuple<String, int, bool, std::tr1::tuple<double, double> > Img_Aperture_L2_thresholds_t;
typedef perf::TestBaseWithParam<Img_Aperture_L2_thresholds_t> Img_Aperture_L2_thresholds;
-PERF_TEST_P( Img_Aperture_L2_thresholds, canny,
- testing::Combine(
- testing::Values( "cv/shared/lena.jpg", "stitching/b1.jpg", "cv/detectors_descriptors_evaluation/images_datasets/leuven/img1.png" ),
- testing::Values( 3, 5 ),
- testing::Bool(),
- testing::Values( make_tuple(50.0, 100.0), make_tuple(0.0, 50.0), make_tuple(100.0, 120.0) )
- )
- )
+PERF_TEST_P(Img_Aperture_L2_thresholds, canny,
+ testing::Combine(
+ testing::Values( "cv/shared/lena.jpg", "stitching/b1.jpg", "cv/detectors_descriptors_evaluation/images_datasets/leuven/img1.png" ),
+ testing::Values( 3, 5 ),
+ testing::Bool(),
+ testing::Values( make_tuple(50.0, 100.0), make_tuple(0.0, 50.0), make_tuple(100.0, 120.0) )
+ )
+ )
{
String filename = getDataPath(get<0>(GetParam()));
int aperture = get<1>(GetParam());
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);
}
using namespace std;
using namespace cv;
using namespace perf;
+using std::tr1::make_tuple;
+using std::tr1::get;
CV_ENUM(CvtMode, CV_YUV2BGR, CV_YUV2RGB, //YUV
- CV_YUV420i2BGR, CV_YUV420i2RGB, CV_YUV420sp2BGR, CV_YUV420sp2RGB, //YUV420
- CV_RGB2GRAY, CV_RGBA2GRAY, CV_BGR2GRAY, CV_BGRA2GRAY, //Gray
- CV_GRAY2RGB, CV_GRAY2RGBA, /*CV_GRAY2BGR, CV_GRAY2BGRA*/ //Gray2
- CV_BGR2HSV, CV_RGB2HSV, CV_BGR2HLS, CV_RGB2HLS //H
-)
+ CV_YUV420i2BGR, CV_YUV420i2RGB, CV_YUV420sp2BGR, CV_YUV420sp2RGB, //YUV420
+ CV_RGB2GRAY, CV_RGBA2GRAY, CV_BGR2GRAY, CV_BGRA2GRAY, //Gray
+ CV_GRAY2RGB, CV_GRAY2RGBA, /*CV_GRAY2BGR, CV_GRAY2BGRA*/ //Gray2
+ CV_BGR2HSV, CV_RGB2HSV, CV_BGR2HLS, CV_RGB2HLS //H
+ )
typedef std::tr1::tuple<Size, CvtMode> Size_CvtMode_t;
typedef perf::TestBaseWithParam<Size_CvtMode_t> Size_CvtMode;
typedef std::tr1::tuple<Size, CvtMode, int> Size_CvtMode_OutChNum_t;
typedef perf::TestBaseWithParam<Size_CvtMode_OutChNum_t> Size_CvtMode_OutChNum;
-
-/*
-// void cvtColor(InputArray src, OutputArray dst, int code, int dstCn=0 )
-*/
-
-
-PERF_TEST_P( Size_CvtMode_OutChNum, cvtColorYUV,
- testing::Combine(
- testing::Values( TYPICAL_MAT_SIZES ),
- testing::Values( (int)CV_YUV2BGR, (int)CV_YUV2RGB ),
- testing::Values( 3, 4 )
- )
-)
+PERF_TEST_P(Size_CvtMode_OutChNum, cvtColorYUV,
+ testing::Combine(
+ testing::Values(TYPICAL_MAT_SIZES),
+ testing::Values((int)CV_YUV2BGR, (int)CV_YUV2RGB),
+ testing::Values(3, 4)
+ )
+ )
{
- Size sz = std::tr1::get<0>(GetParam());
- int mode = std::tr1::get<1>(GetParam());
- int ch = std::tr1::get<2>(GetParam());
+ Size sz = get<0>(GetParam());
+ int mode = get<1>(GetParam());
+ int ch = get<2>(GetParam());
Mat src(sz, CV_8UC3);
Mat dst(sz, CV_8UC(ch));
declare.in(src, WARMUP_RNG).out(dst);
- TEST_CYCLE(100) { cvtColor(src, dst, mode, ch); }
+ TEST_CYCLE() cvtColor(src, dst, mode, ch);
- SANITY_CHECK(dst);
+ SANITY_CHECK(dst, 1);
}
-PERF_TEST_P( Size_CvtMode_OutChNum, cvtColorYUV420,
- testing::Combine(
- testing::Values( szVGA, sz720p, sz1080p, Size(130, 60) ),
- testing::Values( (int)CV_YUV420i2BGR, (int)CV_YUV420i2RGB, (int)CV_YUV420sp2BGR, (int)CV_YUV420sp2RGB ),
- testing::Values( 3, 4 )
- )
-)
+PERF_TEST_P(Size_CvtMode_OutChNum, cvtColorYUV420,
+ testing::Combine(
+ testing::Values(szVGA, sz720p, sz1080p, Size(130, 60)),
+ testing::Values((int)CV_YUV420i2BGR, (int)CV_YUV420i2RGB, (int)CV_YUV420sp2BGR, (int)CV_YUV420sp2RGB),
+ testing::Values(3, 4)
+ )
+ )
{
- Size sz = std::tr1::get<0>(GetParam());
- int mode = std::tr1::get<1>(GetParam());
- int ch = std::tr1::get<2>(GetParam());
+ Size sz = get<0>(GetParam());
+ int mode = get<1>(GetParam());
+ int ch = get<2>(GetParam());
- Mat src(sz.height+sz.height/2, sz.width, CV_8UC1);
+ Mat src(sz.height + sz.height / 2, sz.width, CV_8UC1);
Mat dst(sz, CV_8UC(ch));
declare.in(src, WARMUP_RNG).out(dst);
- TEST_CYCLE(100) { cvtColor(src, dst, mode, ch); }
+ TEST_CYCLE() cvtColor(src, dst, mode, ch);
- SANITY_CHECK(dst);
+ SANITY_CHECK(dst, 1);
}
-PERF_TEST_P( Size_CvtMode, cvtColorGray,
- testing::Combine(
- testing::Values( TYPICAL_MAT_SIZES ),
- testing::Values( (int)CV_RGB2GRAY, (int)CV_RGBA2GRAY, (int)CV_BGR2GRAY, (int)CV_BGRA2GRAY )
- )
-)
+PERF_TEST_P(Size_CvtMode, cvtColorGray,
+ testing::Combine(
+ testing::Values(TYPICAL_MAT_SIZES),
+ testing::Values((int)CV_RGB2GRAY, (int)CV_RGBA2GRAY, (int)CV_BGR2GRAY, (int)CV_BGRA2GRAY)
+ )
+ )
{
- Size sz = std::tr1::get<0>(GetParam());
- int mode = std::tr1::get<1>(GetParam());
+ Size sz = get<0>(GetParam());
+ int mode = get<1>(GetParam());
- Mat src(sz, CV_8UC((mode==CV_RGBA2GRAY || mode==CV_BGRA2GRAY)?4:3));
+ Mat src(sz, CV_8UC((mode==CV_RGBA2GRAY || mode==CV_BGRA2GRAY) ? 4 : 3));
Mat dst(sz, CV_8UC1);
declare.in(src, WARMUP_RNG).out(dst);
- TEST_CYCLE(100) { cvtColor(src, dst, mode); }
+ TEST_CYCLE() cvtColor(src, dst, mode);
SANITY_CHECK(dst);
}
-PERF_TEST_P( Size_CvtMode, cvtColorGray2,
- testing::Combine(
- testing::Values( TYPICAL_MAT_SIZES ),
- testing::Values( (int)CV_GRAY2RGB, (int)CV_GRAY2RGBA/*, CV_GRAY2BGR, CV_GRAY2BGRA*/ )
- )
-)
+PERF_TEST_P(Size_CvtMode, cvtColorGray2,
+ testing::Combine(
+ testing::Values(TYPICAL_MAT_SIZES),
+ testing::Values((int)CV_GRAY2RGB, (int)CV_GRAY2RGBA)
+ )
+ )
{
- Size sz = std::tr1::get<0>(GetParam());
- int mode = std::tr1::get<1>(GetParam());
+ Size sz = get<0>(GetParam());
+ int mode = get<1>(GetParam());
Mat src(sz, CV_8UC1);
- Mat dst(sz, CV_8UC((mode==CV_GRAY2RGBA || mode==CV_GRAY2BGRA)?4:3));
+ Mat dst(sz, CV_8UC((mode==CV_GRAY2RGBA || mode==CV_GRAY2BGRA) ? 4 : 3));
declare.in(src, WARMUP_RNG).out(dst);
- TEST_CYCLE(100) { cvtColor(src, dst, mode); }
+ TEST_CYCLE() cvtColor(src, dst, mode);
SANITY_CHECK(dst);
}
-PERF_TEST_P( Size_CvtMode, cvtColorH,
- testing::Combine(
- testing::Values( TYPICAL_MAT_SIZES ),
- testing::Values( (int)CV_BGR2HSV, (int)CV_RGB2HSV, (int)CV_BGR2HLS, (int)CV_RGB2HLS )
- )
-)
+PERF_TEST_P(Size_CvtMode, cvtColorH,
+ testing::Combine(
+ testing::Values(TYPICAL_MAT_SIZES),
+ testing::Values((int)CV_BGR2HSV, (int)CV_RGB2HSV, (int)CV_BGR2HLS, (int)CV_RGB2HLS)
+ )
+ )
{
- Size sz = std::tr1::get<0>(GetParam());
- int mode = std::tr1::get<1>(GetParam());
+ Size sz = get<0>(GetParam());
+ int mode = get<1>(GetParam());
Mat src(sz, CV_8UC3);
Mat dst(sz, CV_8UC3);
declare.in(src, WARMUP_RNG).out(dst);
- TEST_CYCLE(100) { cvtColor(src, dst, mode); }
+ TEST_CYCLE() cvtColor(src, dst, mode);
- SANITY_CHECK(dst);
+ SANITY_CHECK(dst, 1);
}
#include "perf_precomp.hpp"\r
\r
-#include <opencv2/highgui/highgui.hpp>\r
-\r
using namespace std;\r
using namespace cv;\r
using namespace perf;\r
+using std::tr1::make_tuple;\r
+using std::tr1::get;\r
\r
CV_ENUM(InpaintingMethod, INPAINT_NS, INPAINT_TELEA)\r
typedef std::tr1::tuple<Size, InpaintingMethod> InpaintArea_InpaintingMethod_t;\r
typedef perf::TestBaseWithParam<InpaintArea_InpaintingMethod_t> InpaintArea_InpaintingMethod;\r
\r
\r
-/*\r
-//! restores the damaged image areas using one of the available intpainting algorithms\r
-CV_EXPORTS_W void inpaint( InputArray src, InputArray inpaintMask,\r
- OutputArray dst, double inpaintRange, int flags );\r
-*/\r
-PERF_TEST_P( InpaintArea_InpaintingMethod, inpaint,\r
- testing::Combine(\r
- SZ_ALL_SMALL,\r
- testing::ValuesIn(InpaintingMethod::all())\r
- )\r
- )\r
+PERF_TEST_P(InpaintArea_InpaintingMethod, inpaint,\r
+ testing::Combine(\r
+ SZ_ALL_SMALL,\r
+ testing::ValuesIn(InpaintingMethod::all())\r
+ )\r
+ )\r
{\r
- Mat src = imread( getDataPath("gpu/hog/road.png") );\r
+ Mat src = imread(getDataPath("gpu/hog/road.png"));\r
\r
- Size sz = std::tr1::get<0>(GetParam());\r
- int inpaintingMethod = std::tr1::get<1>(GetParam());\r
+ Size sz = get<0>(GetParam());\r
+ int inpaintingMethod = get<1>(GetParam());\r
\r
Mat mask(src.size(), CV_8UC1, Scalar(0));\r
+ Mat result(src.size(), src.type());\r
\r
Rect inpaintArea(src.cols/3, src.rows/3, sz.width, sz.height);\r
mask(inpaintArea).setTo(255);\r
\r
- declare.time(30);\r
+ declare.in(src, mask).out(result).time(30);\r
\r
- Mat result;\r
- TEST_CYCLE(100)\r
- {\r
- inpaint(src, mask, result, 10.0, inpaintingMethod);\r
+ TEST_CYCLE() inpaint(src, mask, result, 10.0, inpaintingMethod);\r
\r
- //rectangle(result, inpaintArea, Scalar(255));\r
- //char buf[256];\r
- //sprintf(buf, "frame_%d_%d.jpg", sz.width, inpaintingMethod);\r
- //imwrite(buf, result);\r
- }\r
+ Mat inpaintedArea = result(inpaintArea);\r
+ SANITY_CHECK(inpaintedArea);\r
}\r
using namespace std;\r
using namespace cv;\r
using namespace perf;\r
+using std::tr1::make_tuple;\r
+using std::tr1::get;\r
\r
typedef std::tr1::tuple<Size, MatType, MatDepth> Size_MatType_OutMatDepth_t;\r
typedef perf::TestBaseWithParam<Size_MatType_OutMatDepth_t> Size_MatType_OutMatDepth;\r
\r
-/*\r
-// void integral(InputArray image, OutputArray sum, int sdepth=-1 )\r
-*/\r
-PERF_TEST_P( Size_MatType_OutMatDepth, integral,\r
- testing::Combine(\r
- testing::Values( TYPICAL_MAT_SIZES ), \r
- testing::Values( CV_8UC1, CV_8UC4 ),\r
- testing::Values( CV_32S, CV_32F, CV_64F )\r
- )\r
- )\r
+PERF_TEST_P(Size_MatType_OutMatDepth, integral,\r
+ testing::Combine(\r
+ testing::Values(TYPICAL_MAT_SIZES),\r
+ testing::Values(CV_8UC1, CV_8UC4),\r
+ testing::Values(CV_32S, CV_32F, CV_64F)\r
+ )\r
+ )\r
{\r
- Size sz = std::tr1::get<0>(GetParam());\r
- int matType = std::tr1::get<1>(GetParam());\r
- int sdepth = std::tr1::get<2>(GetParam());\r
+ Size sz = get<0>(GetParam());\r
+ int matType = get<1>(GetParam());\r
+ int sdepth = get<2>(GetParam());\r
\r
Mat src(sz, matType);\r
Mat sum(sz, sdepth);\r
\r
declare.in(src, WARMUP_RNG).out(sum);\r
\r
- TEST_CYCLE(100) { integral(src, sum, sdepth); }\r
+ TEST_CYCLE() integral(src, sum, sdepth);\r
\r
- SANITY_CHECK(sum);\r
+ SANITY_CHECK(sum, 1e-6);\r
}\r
\r
-\r
-\r
-/*\r
-// void integral(InputArray image, OutputArray sum, OutputArray sqsum, int sdepth=-1 )\r
-*/\r
-PERF_TEST_P( Size_MatType_OutMatDepth, integral_sqsum,\r
- testing::Combine(\r
- testing::Values( TYPICAL_MAT_SIZES ), \r
- testing::Values( CV_8UC1, CV_8UC4 ),\r
- testing::Values( CV_32S, CV_32F, CV_64F )\r
- )\r
- )\r
+PERF_TEST_P(Size_MatType_OutMatDepth, integral_sqsum,\r
+ testing::Combine(\r
+ testing::Values(TYPICAL_MAT_SIZES),\r
+ testing::Values(CV_8UC1, CV_8UC4),\r
+ testing::Values(CV_32S, CV_32F, CV_64F)\r
+ )\r
+ )\r
{\r
- Size sz = std::tr1::get<0>(GetParam());\r
- int matType = std::tr1::get<1>(GetParam());\r
- int sdepth = std::tr1::get<2>(GetParam());\r
+ Size sz = get<0>(GetParam());\r
+ int matType = get<1>(GetParam());\r
+ int sdepth = get<2>(GetParam());\r
\r
Mat src(sz, matType);\r
Mat sum(sz, sdepth);\r
\r
declare.in(src, WARMUP_RNG).out(sum, sqsum);\r
\r
- TEST_CYCLE(100) { integral(src, sum, sqsum, sdepth); }\r
+ TEST_CYCLE() integral(src, sum, sqsum, sdepth);\r
\r
- SANITY_CHECK(sum);\r
- SANITY_CHECK(sqsum);\r
+ SANITY_CHECK(sum, 1e-6);\r
+ SANITY_CHECK(sqsum, 1e-6);\r
}\r
\r
-\r
-\r
-/*\r
-// void integral(InputArray image, OutputArray sum, OutputArray sqsum, OutputArray tilted, int sdepth=-1 )\r
-*/\r
PERF_TEST_P( Size_MatType_OutMatDepth, integral_sqsum_tilted,\r
- testing::Combine(\r
- testing::Values( TYPICAL_MAT_SIZES ), \r
- testing::Values( CV_8UC1, CV_8UC4 ),\r
- testing::Values( CV_32S, CV_32F, CV_64F )\r
- )\r
- )\r
+ testing::Combine(\r
+ testing::Values( TYPICAL_MAT_SIZES ),\r
+ testing::Values( CV_8UC1, CV_8UC4 ),\r
+ testing::Values( CV_32S, CV_32F, CV_64F )\r
+ )\r
+ )\r
{\r
- Size sz = std::tr1::get<0>(GetParam());\r
- int matType = std::tr1::get<1>(GetParam());\r
- int sdepth = std::tr1::get<2>(GetParam());\r
+ Size sz = get<0>(GetParam());\r
+ int matType = get<1>(GetParam());\r
+ int sdepth = get<2>(GetParam());\r
\r
Mat src(sz, matType);\r
Mat sum(sz, sdepth);\r
\r
declare.in(src, WARMUP_RNG).out(sum, sqsum, tilted);\r
\r
- TEST_CYCLE(100) { integral(src, sum, sqsum, tilted, sdepth); }\r
+ TEST_CYCLE() integral(src, sum, sqsum, tilted, sdepth);\r
\r
- SANITY_CHECK(sum);\r
- SANITY_CHECK(sqsum);\r
- SANITY_CHECK(tilted);\r
+ SANITY_CHECK(sum, 1e-6);\r
+ SANITY_CHECK(sqsum, 1e-6);\r
+ SANITY_CHECK(tilted, 1e-6);\r
}\r
using namespace std;\r
using namespace cv;\r
using namespace perf;\r
+using std::tr1::make_tuple;\r
+using std::tr1::get;\r
\r
#define TYPICAL_MAT_TYPES_MORPH CV_8UC1, CV_8UC4\r
-#define TYPICAL_MATS_MORPH testing::Combine( SZ_ALL_GA, testing::Values( TYPICAL_MAT_TYPES_MORPH) )\r
+#define TYPICAL_MATS_MORPH testing::Combine(SZ_ALL_GA, testing::Values(TYPICAL_MAT_TYPES_MORPH))\r
\r
PERF_TEST_P(Size_MatType, erode, TYPICAL_MATS_MORPH)\r
{\r
- Size sz = std::tr1::get<0>(GetParam());\r
- int type = std::tr1::get<1>(GetParam());\r
+ Size sz = get<0>(GetParam());\r
+ int type = get<1>(GetParam());\r
\r
Mat src(sz, type);\r
Mat dst(sz, type);\r
\r
declare.in(src, WARMUP_RNG).out(dst);\r
\r
- TEST_CYCLE(100) \r
- {\r
- erode(src, dst, noArray());\r
- }\r
+ TEST_CYCLE() erode(src, dst, noArray());\r
\r
SANITY_CHECK(dst);\r
}\r
\r
PERF_TEST_P(Size_MatType, dilate, TYPICAL_MATS_MORPH)\r
{\r
- Size sz = std::tr1::get<0>(GetParam());\r
- int type = std::tr1::get<1>(GetParam());\r
+ Size sz = get<0>(GetParam());\r
+ int type = get<1>(GetParam());\r
\r
Mat src(sz, type);\r
Mat dst(sz, type);\r
\r
declare.in(src, WARMUP_RNG).out(dst);\r
\r
- TEST_CYCLE(100)\r
- {\r
- dilate(src, dst, noArray());\r
- }\r
+ TEST_CYCLE() dilate(src, dst, noArray());\r
\r
SANITY_CHECK(dst);\r
}\r
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());
declare.in(src, WARMUP_RNG).out(dst);
- TEST_CYCLE(100) { cv::pyrUp(src, dst); }
+ TEST_CYCLE() pyrUp(src, dst);
SANITY_CHECK(dst);
}
using namespace std;
using namespace cv;
using namespace perf;
+using std::tr1::make_tuple;
+using std::tr1::get;
typedef tr1::tuple<MatType, Size, Size> MatInfo_Size_Size_t;
typedef TestBaseWithParam<MatInfo_Size_Size_t> MatInfo_Size_Size;
PERF_TEST_P(MatInfo_Size_Size, resizeUpLinear,
- testing::Values(
+ testing::Values(
MatInfo_Size_Size_t(CV_8UC1, szVGA, szqHD),
MatInfo_Size_Size_t(CV_8UC1, szVGA, sz720p),
MatInfo_Size_Size_t(CV_8UC4, szVGA, sz720p)
)
-)
+ )
{
- int matType = tr1::get<0>(GetParam());
- Size from = tr1::get<1>(GetParam());
- Size to = tr1::get<2>(GetParam());
+ int matType = get<0>(GetParam());
+ Size from = get<1>(GetParam());
+ Size to = get<2>(GetParam());
cv::Mat src(from, matType);
cv::Mat dst(to, matType);
declare.in(src, WARMUP_RNG).out(dst);
- SIMPLE_TEST_CYCLE() cv::resize(src, dst, to);
+ TEST_CYCLE() resize(src, dst, to);
SANITY_CHECK(dst, 1 + 1e-6);
}
PERF_TEST_P(MatInfo_Size_Size, resizeDownLinear,
- testing::Values(
+ testing::Values(
MatInfo_Size_Size_t(CV_8UC1, szVGA, szQVGA),
MatInfo_Size_Size_t(CV_8UC4, szqHD, szVGA),
MatInfo_Size_Size_t(CV_8UC1, sz720p, Size(120 * sz720p.width / sz720p.height, 120)),//face detection min_face_size = 20%
MatInfo_Size_Size_t(CV_8UC4, sz720p, szVGA),
MatInfo_Size_Size_t(CV_8UC4, sz720p, szQVGA)
)
-)
+ )
{
- int matType = tr1::get<0>(GetParam());
- Size from = tr1::get<1>(GetParam());
- Size to = tr1::get<2>(GetParam());
+ int matType = get<0>(GetParam());
+ Size from = get<1>(GetParam());
+ Size to = get<2>(GetParam());
cv::Mat src(from, matType);
cv::Mat dst(to, matType);
declare.in(src, WARMUP_RNG).out(dst);
- SIMPLE_TEST_CYCLE() cv::resize(src, dst, to);
+ TEST_CYCLE() resize(src, dst, to);
SANITY_CHECK(dst, 1 + 1e-6);
}
typedef tr1::tuple<MatType, Size, int> MatInfo_Size_Scale_t;
typedef TestBaseWithParam<MatInfo_Size_Scale_t> MatInfo_Size_Scale;
-PERF_TEST_P( MatInfo_Size_Scale, resizeAreaFast,
- testing::Combine(
- testing::Values( CV_8UC1, CV_8UC4 ),
- testing::Values( szVGA, szqHD, sz720p, sz1080p ),
- testing::Values( 2, 4 )
- )
- )
+PERF_TEST_P(MatInfo_Size_Scale, resizeAreaFast,
+ testing::Combine(
+ testing::Values(CV_8UC1, CV_8UC4),
+ testing::Values(szVGA, szqHD, sz720p, sz1080p),
+ testing::Values(2, 4)
+ )
+ )
{
- int matType = tr1::get<0>(GetParam());
- Size from = tr1::get<1>(GetParam());
- int scale = tr1::get<2>(GetParam());
+ int matType = get<0>(GetParam());
+ Size from = get<1>(GetParam());
+ int scale = get<2>(GetParam());
from.width = (from.width/scale)*scale;
from.height = (from.height/scale)*scale;
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);
using namespace std;
using namespace cv;
using namespace perf;
-
using std::tr1::make_tuple;
using std::tr1::get;
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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)
testing::Values(TYPICAL_MAT_SIZES),
testing::Values(CV_8UC1, CV_16SC1),
testing::ValuesIn(ThreshType::all())
+ )
)
- )
{
- Size sz = std::tr1::get<0>(GetParam());
- int type = std::tr1::get<1>(GetParam());
- ThreshType threshType = std::tr1::get<2>(GetParam());
+ Size sz = get<0>(GetParam());
+ int type = get<1>(GetParam());
+ ThreshType threshType = get<2>(GetParam());
Mat src(sz, type);
Mat dst(sz, type);
- double thresh = cv::theRNG().uniform(1, 254);
- double maxval = cv::theRNG().uniform(1, 254);
+ double thresh = theRNG().uniform(1, 254);
+ double maxval = theRNG().uniform(1, 254);
declare.in(src, WARMUP_RNG).out(dst);
- TEST_CYCLE(100)
- {
- cv::threshold(src, dst, thresh, maxval, threshType);
- }
+ TEST_CYCLE() threshold(src, dst, thresh, maxval, threshType);
SANITY_CHECK(dst);
}
-
typedef perf::TestBaseWithParam<Size> Size_Only;
-PERF_TEST_P(Size_Only, threshold_otsu, testing::Values(TYPICAL_MAT_SIZES) )
+PERF_TEST_P(Size_Only, threshold_otsu, testing::Values(TYPICAL_MAT_SIZES))
{
Size sz = GetParam();
Mat src(sz, CV_8UC1);
Mat dst(sz, CV_8UC1);
- double maxval = cv::theRNG().uniform(1, 254);
+ double maxval = theRNG().uniform(1, 254);
declare.in(src, WARMUP_RNG).out(dst);
- TEST_CYCLE(100)
- {
- cv::threshold(src, dst, 0, maxval, THRESH_BINARY|THRESH_OTSU);
- }
+ TEST_CYCLE() threshold(src, dst, 0, maxval, THRESH_BINARY|THRESH_OTSU);
SANITY_CHECK(dst);
}
using namespace std;
using namespace cv;
using namespace perf;
+using std::tr1::make_tuple;
+using std::tr1::get;
typedef std::tr1::tuple<std::string, int> ImageName_MinSize_t;
typedef perf::TestBaseWithParam<ImageName_MinSize_t> ImageName_MinSize;
-PERF_TEST_P( ImageName_MinSize, CascadeClassifierLBPFrontalFace,
- testing::Combine(testing::Values( std::string("cv/shared/lena.jpg"),
- std::string("cv/shared/1_itseez-0000247.jpg"),
- std::string("cv/shared/1_itseez-0000289.jpg"),
- std::string("cv/shared/1_itseez-0000492.jpg"),
- std::string("cv/shared/1_itseez-0000573.jpg"),
- std::string("cv/shared/1_itseez-0000803.jpg"),
- std::string("cv/shared/1_itseez-0000892.jpg"),
- std::string("cv/shared/1_itseez-0000984.jpg"),
- std::string("cv/shared/1_itseez-0001238.jpg"),
- std::string("cv/shared/1_itseez-0001438.jpg"),
- std::string("cv/shared/1_itseez-0002524.jpg")),
- testing::Values(24, 30, 40, 50, 60, 70, 80, 90) ) )
+PERF_TEST_P(ImageName_MinSize, CascadeClassifierLBPFrontalFace,
+ testing::Combine(testing::Values( std::string("cv/shared/lena.jpg"),
+ std::string("cv/shared/1_itseez-0000247.jpg"),
+ std::string("cv/shared/1_itseez-0000289.jpg"),
+ std::string("cv/shared/1_itseez-0000492.jpg"),
+ std::string("cv/shared/1_itseez-0000573.jpg"),
+ std::string("cv/shared/1_itseez-0000803.jpg"),
+ std::string("cv/shared/1_itseez-0000892.jpg"),
+ std::string("cv/shared/1_itseez-0000984.jpg"),
+ std::string("cv/shared/1_itseez-0001238.jpg"),
+ std::string("cv/shared/1_itseez-0001438.jpg"),
+ std::string("cv/shared/1_itseez-0002524.jpg")),
+ testing::Values(24, 30, 40, 50, 60, 70, 80, 90)
+ )
+ )
{
- const string filename = std::tr1::get<0>(GetParam());
- int min_size = std::tr1::get<1>(GetParam());
+ const string filename = get<0>(GetParam());
+ int min_size = get<1>(GetParam());
Size minSize(min_size, min_size);
CascadeClassifier cc(getDataPath("cv/cascadeandhog/cascades/lbpcascade_frontalface.xml"));
vector<Rect> res;
-
- declare.in(img);//.out(res)
+ equalizeHist(img, img);
+ declare.in(img);
while(next())
{
res.clear();
startTimer();
- equalizeHist(img, img);
cc.detectMultiScale(img, res, 1.1, 3, 0, minSize);
stopTimer();
}
using namespace std;\r
using namespace cv;\r
using namespace perf;\r
+using std::tr1::make_tuple;\r
+using std::tr1::get;\r
\r
#define SURF_MATCH_CONFIDENCE 0.65f\r
#define ORB_MATCH_CONFIDENCE 0.3f\r
typedef TestBaseWithParam<String> stitch;\r
typedef TestBaseWithParam<String> match;\r
\r
-PERF_TEST_P( stitch, a123, testing::Values("surf", "orb"))\r
+PERF_TEST_P(stitch, a123, testing::Values("surf", "orb"))\r
{\r
Mat pano;\r
\r
Stitcher stitcher = Stitcher::createDefault();\r
stitcher.setFeaturesFinder(featuresFinder);\r
stitcher.setFeaturesMatcher(featuresMatcher);\r
- stitcher.setWarper(new CylindricalWarper());\r
+ stitcher.setWarper(new SphericalWarper());\r
stitcher.setRegistrationResol(WORK_MEGAPIX);\r
\r
startTimer();\r
}\r
}\r
\r
-PERF_TEST_P( stitch, b12, testing::Values("surf", "orb"))\r
+PERF_TEST_P(stitch, b12, testing::Values("surf", "orb"))\r
{\r
Mat pano;\r
\r
Stitcher stitcher = Stitcher::createDefault();\r
stitcher.setFeaturesFinder(featuresFinder);\r
stitcher.setFeaturesMatcher(featuresMatcher);\r
- stitcher.setWarper(new CylindricalWarper());\r
+ stitcher.setWarper(new SphericalWarper());\r
stitcher.setRegistrationResol(WORK_MEGAPIX);\r
\r
startTimer();\r
detail::MatchesInfo pairwise_matches;\r
\r
declare.in(features1.descriptors, features2.descriptors)\r
- .iterations(100);\r
+ .iterations(100);\r
\r
while(next())\r
{\r
//\r
// declare.in(a, b).out(c).time(0.5);\r
//\r
-// SIMPLE_TEST_CYCLE() cv::add(a, b, c);\r
+// TEST_CYCLE() cv::add(a, b, c);\r
//\r
// SANITY_CHECK(c);\r
// }\r
return RUN_ALL_TESTS();\\r
}\r
\r
-#define TEST_CYCLE(n) for(declare.iterations(n); startTimer(), next(); stopTimer())\r
-#define SIMPLE_TEST_CYCLE() for(; startTimer(), next(); stopTimer())\r
+#define TEST_CYCLE_N(n) for(declare.iterations(n); startTimer(), next(); stopTimer())\r
+#define TEST_CYCLE() for(; startTimer(), next(); stopTimer())\r
\r
//flags\r
namespace perf\r
projects / profile / ivi / opencv.git / commitdiff