generic-library/opencv
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

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

Browse Source
This commit is contained in:
Andrey Kamaev
2011-12-29 16:46:16 +00:00
parent 80f422a531
commit 65f5343ed5
39 changed files with 1062 additions and 1039 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
modules/core/perf/perf_abs.cpp
View File

@@ -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);
}

190
modules/core/perf/perf_arithm.cpp Normal file
View File

@@ -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);
}

61
modules/core/perf/perf_bitwise.cpp
View File

@@ -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);
}

48
modules/core/perf/perf_compare.cpp
View File

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

113
modules/core/perf/perf_core_arithm.cpp
View File

@@ -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);
}

18
modules/core/perf/perf_dft.cpp
View File

@@ -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);
}

22
modules/core/perf/perf_dot.cpp
View File

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

4
modules/core/perf/perf_math.cpp
View File

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

39
modules/core/perf/perf_minmax.cpp
View File

@@ -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);
}

35
modules/core/perf/perf_minmaxloc.cpp Normal file
View File

@@ -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);
}

198
modules/core/perf/perf_norm.cpp Normal file
View File

@@ -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> 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);
}

66
modules/core/perf/perf_reduce.cpp Normal file
View File

@@ -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> 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);
}

403
modules/core/perf/perf_stat.cpp
View File

@@ -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> 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 )
)
)
PERF_TEST_P(Size_MatType, meanStdDev, TYPICAL_MATS)
{
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());
Size sz = get<0>(GetParam());
int matType = get<1>(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);
}
Scalar mean;
Scalar dev;
declare.in(src, WARMUP_RNG).out(mean, dev);
/*
// 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 )
{
Size sz = std::tr1::get<0>(GetParam());
int matType = std::tr1::get<1>(GetParam());
Mat src(sz, matType);
Mat mean, dev;
declare.in(src, WARMUP_RNG);
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);
}