From: ilya-lavrenov Date: Thu, 22 Aug 2013 14:03:05 +0000 (+0400) Subject: most of the performance tests was rewritten in google-test manner X-Git-Tag: accepted/tizen/ivi/20140515.103456~1^2~543^2~1 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=4c28a6f0f651f3def96d6c10da2ebf9cd28a5068;p=profile%2Fivi%2Fopencv.git most of the performance tests was rewritten in google-test manner --- diff --git a/modules/ocl/perf/main.cpp b/modules/ocl/perf/main.cpp index 428ab97..f67961f 100644 --- a/modules/ocl/perf/main.cpp +++ b/modules/ocl/perf/main.cpp @@ -42,7 +42,7 @@ #include "perf_precomp.hpp" -int main(int argc, const char *argv[]) +static int old_main(int argc, const char *argv[]) { const char *keys = "{ h | help | false | print help message }" @@ -99,7 +99,7 @@ int main(int argc, const char *argv[]) // set this to overwrite binary cache every time the test starts ocl::setBinaryDiskCache(ocl::CACHE_UPDATE); - + if (cmd.get("verify")) { TestSystem::instance().setNumIters(1); @@ -162,3 +162,33 @@ END_DEV: return 0; } + +const char * impls[] = +{ + "ocl", + "plain", +#ifdef HAVE_OPENCV_GPU + "gpu" +#endif +}; + +int main(int argc, char **argv) +{ + // temp solution: if no '--gtest_' and '--perf_' args switch to old behavior + bool useGTest = false; + + for(int i=1; i LUTParams; +typedef TestBaseWithParam LUTFixture; - gen(src, size, size, all_type[j], 0, 256); - gen(lut, 1, 256, CV_8UC1, 0, 1); +PERF_TEST_P(LUTFixture, LUT, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + LUTMatTypes::all())) +{ + // getting params + LUTParams params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params); - LUT(src, lut, dst); + const std::string impl = getSelectedImpl(); - CPU_ON; - LUT(src, lut, dst); - CPU_OFF; + // creating src data + Mat src(srcSize, type), lut(1, 256, CV_8UC1); + int dstType = CV_MAKETYPE(lut.depth(), src.channels()); + Mat dst(srcSize, dstType); - d_src.upload(src); - d_lut.upload(lut); + randu(lut, 0, 2); + declare.in(src, WARMUP_RNG).in(lut).out(dst); - WARMUP_ON; - ocl::LUT(d_src, d_lut, d_dst); - WARMUP_OFF; + // select implementation + if (impl == "ocl") + { + ocl::oclMat oclSrc(src), oclLut(lut), oclDst(srcSize, dstType); - GPU_ON; - ocl::LUT(d_src, d_lut, d_dst); - GPU_OFF; + TEST_CYCLE() cv::ocl::LUT(oclSrc, oclLut, oclDst); - GPU_FULL_ON; - d_src.upload(src); - d_lut.upload(lut); - ocl::LUT(d_src, d_lut, d_dst); - d_dst.download(ocl_dst); - GPU_FULL_OFF; + oclDst.download(dst); - TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 0); - } + SANITY_CHECK(dst); + } + else if (impl == "plain") + { + TEST_CYCLE() cv::LUT(src, lut, dst); + SANITY_CHECK(dst); } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); } ///////////// Exp //////////////////////// -PERFTEST(Exp) -{ - Mat src, dst, ocl_dst; - ocl::oclMat d_src, d_dst; - for (int size = Min_Size; size <= Max_Size; size *= Multiple) - { - SUBTEST << size << 'x' << size << "; CV_32FC1"; +typedef TestBaseWithParam ExpFixture; + +PERF_TEST_P(ExpFixture, Exp, OCL_TYPICAL_MAT_SIZES) +{ + // getting params + const Size srcSize = GetParam(); - gen(src, size, size, CV_32FC1, 5, 16); + const std::string impl = getSelectedImpl(); - exp(src, dst); + // creating src data + Mat src(srcSize, CV_32FC1), dst(srcSize, CV_32FC1); + declare.in(src).out(dst); + randu(src, 5, 16); - CPU_ON; - exp(src, dst); - CPU_OFF; - d_src.upload(src); + // select implementation + if (impl == "ocl") + { + ocl::oclMat oclSrc(src), oclDst(srcSize, src.type()); - WARMUP_ON; - ocl::exp(d_src, d_dst); - WARMUP_OFF; + TEST_CYCLE() cv::ocl::exp(oclSrc, oclDst); - GPU_ON; - ocl::exp(d_src, d_dst); - GPU_OFF; + oclDst.download(dst); - GPU_FULL_ON; - d_src.upload(src); - ocl::exp(d_src, d_dst); - d_dst.download(ocl_dst); - GPU_FULL_OFF; + SANITY_CHECK(dst, 0.3); + } + else if (impl == "plain") + { + TEST_CYCLE() cv::exp(src, dst); - TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 2); + SANITY_CHECK(dst, 0.3); } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); } ///////////// LOG //////////////////////// -PERFTEST(Log) -{ - Mat src, dst, ocl_dst; - ocl::oclMat d_src, d_dst; - for (int size = Min_Size; size <= Max_Size; size *= Multiple) - { - SUBTEST << size << 'x' << size << "; 32F"; +typedef TestBaseWithParam LogFixture; - gen(src, size, size, CV_32F, 1, 10); +PERF_TEST_P(LogFixture, Log, OCL_TYPICAL_MAT_SIZES) +{ + // getting params + const Size srcSize = GetParam(); + const std::string impl = getSelectedImpl(); - log(src, dst); + // creating src data + Mat src(srcSize, CV_32F), dst(srcSize, src.type()); + randu(src, 1, 10); + declare.in(src).out(dst); - CPU_ON; - log(src, dst); - CPU_OFF; - d_src.upload(src); + if (srcSize == OCL_SIZE_4000) + declare.time(3.6); - WARMUP_ON; - ocl::log(d_src, d_dst); - WARMUP_OFF; + // select implementation + if (impl == "ocl") + { + ocl::oclMat oclSrc(src), oclDst(srcSize, src.type()); - GPU_ON; - ocl::log(d_src, d_dst); - GPU_OFF; + TEST_CYCLE() cv::ocl::log(oclSrc, oclDst); - GPU_FULL_ON; - d_src.upload(src); - ocl::log(d_src, d_dst); - d_dst.download(ocl_dst); - GPU_FULL_OFF; + oclDst.download(dst); - TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1); + SANITY_CHECK(dst); } -} - -///////////// Add //////////////////////// -PERFTEST(Add) -{ - Mat src1, src2, dst, ocl_dst; - ocl::oclMat d_src1, d_src2, d_dst; - - int all_type[] = {CV_8UC1, CV_32FC1}; - std::string type_name[] = {"CV_8UC1", "CV_32FC1"}; - - for (int size = Min_Size; size <= Max_Size; size *= Multiple) + else if (impl == "plain") { - for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++) - { - SUBTEST << size << 'x' << size << "; " << type_name[j]; + TEST_CYCLE() cv::log(src, dst); - gen(src1, size, size, all_type[j], 0, 1); - gen(src2, size, size, all_type[j], 0, 1); + SANITY_CHECK(dst); + } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); +} - add(src1, src2, dst); +///////////// Add //////////////////////// - CPU_ON; - add(src1, src2, dst); - CPU_OFF; +CV_ENUM(AddMatTypes, CV_8UC1, CV_32FC1) - d_src1.upload(src1); - d_src2.upload(src2); +typedef tuple AddParams; +typedef TestBaseWithParam AddFixture; - WARMUP_ON; - ocl::add(d_src1, d_src2, d_dst); - WARMUP_OFF; +PERF_TEST_P(AddFixture, Add, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + AddMatTypes::all())) +{ + // getting params + AddParams params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params); + const string impl = getSelectedImpl(); + + // creating src data + Mat src1(srcSize, type), src2(srcSize, type), dst(srcSize, type); + randu(src1, 0, 1); + randu(src2, 0, 1); + declare.in(src1, src2).out(dst); + + // select implementation + if (impl == "ocl") + { + ocl::oclMat oclSrc1(src1), oclSrc2(src2), oclDst(srcSize, type); - GPU_ON; - ocl::add(d_src1, d_src2, d_dst); - GPU_OFF; + TEST_CYCLE() cv::ocl::add(oclSrc1, oclSrc2, oclDst); - GPU_FULL_ON; - d_src1.upload(src1); - d_src2.upload(src2); - ocl::add(d_src1, d_src2, d_dst); - d_dst.download(ocl_dst); - GPU_FULL_OFF; + oclDst.download(dst); - TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 0.0); - } + SANITY_CHECK(dst); + } + else if (impl == "plain") + { + TEST_CYCLE() cv::add(src1, src2, dst); + SANITY_CHECK(dst); } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); } ///////////// Mul //////////////////////// -PERFTEST(Mul) -{ - Mat src1, src2, dst, ocl_dst; - ocl::oclMat d_src1, d_src2, d_dst; - - int all_type[] = {CV_8UC1, CV_8UC4}; - std::string type_name[] = {"CV_8UC1", "CV_8UC4"}; - - for (int size = Min_Size; size <= Max_Size; size *= Multiple) - { - for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++) - { - SUBTEST << size << 'x' << size << "; " << type_name[j] ; - - gen(src1, size, size, all_type[j], 0, 256); - gen(src2, size, size, all_type[j], 0, 256); - multiply(src1, src2, dst); +CV_ENUM(MulMatTypes, CV_8UC1, CV_8UC4) - CPU_ON; - multiply(src1, src2, dst); - CPU_OFF; - d_src1.upload(src1); - d_src2.upload(src2); +typedef tuple MulParams; +typedef TestBaseWithParam MulFixture; - WARMUP_ON; - ocl::multiply(d_src1, d_src2, d_dst); - WARMUP_OFF; +PERF_TEST_P(MulFixture, Mul, ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + MulMatTypes::all())) +{ + // getting params + MulParams params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params); + const string impl = getSelectedImpl(); + + // creating src data + Mat src1(srcSize, type), src2(srcSize, type), dst(srcSize, type); + randu(src1, 0, 256); + randu(src2, 0, 256); + declare.in(src1, src2).out(dst); + + // select implementation + if (impl == "ocl") + { + ocl::oclMat oclSrc1(src1), oclSrc2(src2), oclDst(srcSize, type); - GPU_ON; - ocl::multiply(d_src1, d_src2, d_dst); - GPU_OFF; + TEST_CYCLE() cv::ocl::multiply(oclSrc1, oclSrc2, oclDst); - GPU_FULL_ON; - d_src1.upload(src1); - d_src2.upload(src2); - ocl::multiply(d_src1, d_src2, d_dst); - d_dst.download(ocl_dst); - GPU_FULL_OFF; + oclDst.download(dst); - TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 0.0); - } + SANITY_CHECK(dst); + } + else if (impl == "plain") + { + TEST_CYCLE() cv::multiply(src1, src2, dst); + SANITY_CHECK(dst); } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); } ///////////// Div //////////////////////// -PERFTEST(Div) -{ - Mat src1, src2, dst, ocl_dst; - ocl::oclMat d_src1, d_src2, d_dst; - int all_type[] = {CV_8UC1, CV_8UC4}; - std::string type_name[] = {"CV_8UC1", "CV_8UC4"}; - for (int size = Min_Size; size <= Max_Size; size *= Multiple) - { - for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++) - { - SUBTEST << size << 'x' << size << "; " << type_name[j]; +typedef MulMatTypes DivMatTypes; +typedef tuple DivParams; +typedef TestBaseWithParam DivFixture; - gen(src1, size, size, all_type[j], 0, 256); - gen(src2, size, size, all_type[j], 0, 256); - - divide(src1, src2, dst); - - CPU_ON; - divide(src1, src2, dst); - CPU_OFF; - - d_src1.upload(src1); - d_src2.upload(src2); - - WARMUP_ON; - ocl::divide(d_src1, d_src2, d_dst); - WARMUP_OFF; +PERF_TEST_P(DivFixture, Div, ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + DivMatTypes::all())) +{ + // getting params + DivParams params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params); + const string impl = getSelectedImpl(); + + // creating src data + Mat src1(srcSize, type), src2(srcSize, type), dst(srcSize, type); + declare.in(src1, src2).out(dst); + randu(src1, 0, 256); + randu(src2, 0, 256); + + if ((srcSize == OCL_SIZE_4000 && type == CV_8UC1) || + (srcSize == OCL_SIZE_2000 && type == CV_8UC4)) + declare.time(4.2); + else if (srcSize == OCL_SIZE_4000 && type == CV_8UC4) + declare.time(16.6); + + // select implementation + if (impl == "ocl") + { + ocl::oclMat oclSrc1(src1), oclSrc2(src2), oclDst(srcSize, type); - GPU_ON; - ocl::divide(d_src1, d_src2, d_dst); - GPU_OFF; + TEST_CYCLE() cv::ocl::divide(oclSrc1, oclSrc2, oclDst); - GPU_FULL_ON; - d_src1.upload(src1); - d_src2.upload(src2); - ocl::divide(d_src1, d_src2, d_dst); - d_dst.download(ocl_dst); - GPU_FULL_OFF; + oclDst.download(dst); - TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1); - } + SANITY_CHECK(dst); + } + else if (impl == "plain") + { + TEST_CYCLE() cv::divide(src1, src2, dst); + SANITY_CHECK(dst); } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); } ///////////// Absdiff //////////////////////// -PERFTEST(Absdiff) -{ - Mat src1, src2, dst, ocl_dst; - ocl::oclMat d_src1, d_src2, d_dst; - int all_type[] = {CV_8UC1, CV_8UC4}; - std::string type_name[] = {"CV_8UC1", "CV_8UC4"}; +typedef MulMatTypes AbsDiffMatTypes; +typedef tuple AbsDiffParams; +typedef TestBaseWithParam AbsDiffFixture; - for (int size = Min_Size; size <= Max_Size; size *= Multiple) +PERF_TEST_P(AbsDiffFixture, Absdiff, ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + AbsDiffMatTypes::all())) +{ + // getting params + AbsDiffParams params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params); + const string impl = getSelectedImpl(); + + // creating src data + Mat src1(srcSize, type), src2(srcSize, type), dst(srcSize, type); + declare.in(src1, src2).in(dst); + randu(src1, 0, 256); + randu(src2, 0, 256); + + // select implementation + if (impl == "ocl") { - for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++) - { - SUBTEST << size << 'x' << size << "; " << type_name[j] ; - - gen(src1, size, size, all_type[j], 0, 256); - gen(src2, size, size, all_type[j], 0, 256); - gen(dst, size, size, all_type[j], 0, 256); - - absdiff(src1, src2, dst); - - CPU_ON; - absdiff(src1, src2, dst); - CPU_OFF; - - d_src1.upload(src1); - d_src2.upload(src2); + ocl::oclMat oclSrc1(src1), oclSrc2(src2), oclDst(srcSize, type); - WARMUP_ON; - ocl::absdiff(d_src1, d_src2, d_dst); - WARMUP_OFF; + TEST_CYCLE() cv::ocl::absdiff(oclSrc1, oclSrc2, oclDst); - GPU_ON; - ocl::absdiff(d_src1, d_src2, d_dst); - GPU_OFF; + oclDst.download(dst); - GPU_FULL_ON; - d_src1.upload(src1); - d_src2.upload(src2); - ocl::absdiff(d_src1, d_src2, d_dst); - d_dst.download(ocl_dst); - GPU_FULL_OFF; - - TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 0.0); - } + SANITY_CHECK(dst); + } + else if (impl == "plain") + { + TEST_CYCLE() cv::absdiff(src1, src2, dst); + SANITY_CHECK(dst); } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); } ///////////// CartToPolar //////////////////////// -PERFTEST(CartToPolar) -{ - Mat src1, src2, dst, dst1, ocl_dst, ocl_dst1; - ocl::oclMat d_src1, d_src2, d_dst, d_dst1; - int all_type[] = {CV_32FC1}; - std::string type_name[] = {"CV_32FC1"}; +typedef TestBaseWithParam CartToPolarFixture; - for (int size = Min_Size; size <= Max_Size; size *= Multiple) +PERF_TEST_P(CartToPolarFixture, CartToPolar, OCL_TYPICAL_MAT_SIZES) +{ + // getting params + const Size srcSize = GetParam(); + const string impl = getSelectedImpl(); + + // creating src data + Mat src1(srcSize, CV_32FC1), src2(srcSize, CV_32FC1), + dst1(srcSize, CV_32FC1), dst2(srcSize, CV_32FC1); + declare.in(src1, src2).out(dst1, dst2); + randu(src1, 0, 256); + randu(src2, 0, 256); + + if (srcSize == OCL_SIZE_4000) + declare.time(3.6); + + // select implementation + if (impl == "ocl") { - for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++) - { - SUBTEST << size << 'x' << size << "; " << type_name[j]; - - gen(src1, size, size, all_type[j], 0, 256); - gen(src2, size, size, all_type[j], 0, 256); - gen(dst, size, size, all_type[j], 0, 256); - gen(dst1, size, size, all_type[j], 0, 256); - + ocl::oclMat oclSrc1(src1), oclSrc2(src2), + oclDst1(srcSize, src1.type()), oclDst2(srcSize, src1.type()); - cartToPolar(src1, src2, dst, dst1, 1); + TEST_CYCLE() cv::ocl::cartToPolar(oclSrc1, oclSrc2, oclDst1, oclDst2); - CPU_ON; - cartToPolar(src1, src2, dst, dst1, 1); - CPU_OFF; + oclDst1.download(dst1); + oclDst2.download(dst2); - d_src1.upload(src1); - d_src2.upload(src2); - - WARMUP_ON; - ocl::cartToPolar(d_src1, d_src2, d_dst, d_dst1, 1); - WARMUP_OFF; - - GPU_ON; - ocl::cartToPolar(d_src1, d_src2, d_dst, d_dst1, 1); - GPU_OFF; - - GPU_FULL_ON; - d_src1.upload(src1); - d_src2.upload(src2); - ocl::cartToPolar(d_src1, d_src2, d_dst, d_dst1, 1); - d_dst.download(ocl_dst); - d_dst1.download(ocl_dst1); - GPU_FULL_OFF; - - double diff1 = checkNorm(ocl_dst1, dst1); - double diff2 = checkNorm(ocl_dst, dst); - double max_diff = max(diff1, diff2); - TestSystem::instance().setAccurate(max_diff<=.5?1:0, max_diff); - - } + SANITY_CHECK(dst1, 5e-3); + SANITY_CHECK(dst2, 5e-3); + } + else if (impl == "plain") + { + TEST_CYCLE() cv::cartToPolar(src1, src2, dst1, dst2); + SANITY_CHECK(dst1, 5e-3); + SANITY_CHECK(dst2, 5e-3); } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); } ///////////// PolarToCart //////////////////////// -PERFTEST(PolarToCart) -{ - Mat src1, src2, dst, dst1, ocl_dst, ocl_dst1; - ocl::oclMat d_src1, d_src2, d_dst, d_dst1; - int all_type[] = {CV_32FC1}; - std::string type_name[] = {"CV_32FC1"}; +typedef TestBaseWithParam PolarToCartFixture; - for (int size = Min_Size; size <= Max_Size; size *= Multiple) +PERF_TEST_P(PolarToCartFixture, PolarToCart, OCL_TYPICAL_MAT_SIZES) +{ + // getting params + const Size srcSize = GetParam(); + const string impl = getSelectedImpl(); + + // creating src data + Mat src1(srcSize, CV_32FC1), src2(srcSize, CV_32FC1), + dst1(srcSize, CV_32FC1), dst2(srcSize, CV_32FC1); + declare.in(src1, src2).out(dst1, dst2); + randu(src1, 0, 256); + randu(src2, 0, 256); + + if (srcSize == OCL_SIZE_4000) + declare.time(5.4); + + // select implementation + if (impl == "ocl") { - for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++) - { - SUBTEST << size << 'x' << size << "; " << type_name[j] ; - - gen(src1, size, size, all_type[j], 0, 256); - gen(src2, size, size, all_type[j], 0, 256); - gen(dst, size, size, all_type[j], 0, 256); - gen(dst1, size, size, all_type[j], 0, 256); - - - polarToCart(src1, src2, dst, dst1, 1); - - CPU_ON; - polarToCart(src1, src2, dst, dst1, 1); - CPU_OFF; - d_src1.upload(src1); - d_src2.upload(src2); - - WARMUP_ON; - ocl::polarToCart(d_src1, d_src2, d_dst, d_dst1, 1); - WARMUP_OFF; + ocl::oclMat oclSrc1(src1), oclSrc2(src2), + oclDst1(srcSize, src1.type()), oclDst2(srcSize, src1.type()); - GPU_ON; - ocl::polarToCart(d_src1, d_src2, d_dst, d_dst1, 1); - GPU_OFF; + TEST_CYCLE() cv::ocl::polarToCart(oclSrc1, oclSrc2, oclDst1, oclDst2); - GPU_FULL_ON; - d_src1.upload(src1); - d_src2.upload(src2); - ocl::polarToCart(d_src1, d_src2, d_dst, d_dst1, 1); - d_dst.download(ocl_dst); - d_dst1.download(ocl_dst1); - GPU_FULL_OFF; + oclDst1.download(dst1); + oclDst2.download(dst2); - double diff1 = checkNorm(ocl_dst1, dst1); - double diff2 = checkNorm(ocl_dst, dst); - double max_diff = max(diff1, diff2); - TestSystem::instance().setAccurate(max_diff<=.5?1:0, max_diff); - - } + SANITY_CHECK(dst1, 5e-5); + SANITY_CHECK(dst2, 5e-5); + } + else if (impl == "plain") + { + TEST_CYCLE() cv::polarToCart(src1, src2, dst1, dst2); + SANITY_CHECK(dst1, 5e-5); + SANITY_CHECK(dst2, 5e-5); } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); } ///////////// Magnitude //////////////////////// -PERFTEST(magnitude) -{ - Mat x, y, mag, ocl_mag; - ocl::oclMat d_x, d_y, d_mag; - int all_type[] = {CV_32FC1}; - std::string type_name[] = {"CV_32FC1"}; +typedef TestBaseWithParam MagnitudeFixture; - for (int size = Min_Size; size <= Max_Size; size *= Multiple) +PERF_TEST_P(MagnitudeFixture, Magnitude, OCL_TYPICAL_MAT_SIZES) +{ + // getting params + const Size srcSize = GetParam(); + const string impl = getSelectedImpl(); + + // creating src data + Mat src1(srcSize, CV_32FC1), src2(srcSize, CV_32FC1), + dst(srcSize, CV_32FC1); + randu(src1, 0, 1); + randu(src2, 0, 1); + declare.in(src1, src2).out(dst); + + // select implementation + if (impl == "ocl") { - for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++) - { - SUBTEST << size << 'x' << size << "; " << type_name[j]; - - gen(x, size, size, all_type[j], 0, 1); - gen(y, size, size, all_type[j], 0, 1); + ocl::oclMat oclSrc1(src1), oclSrc2(src2), + oclDst(srcSize, src1.type()); - magnitude(x, y, mag); + TEST_CYCLE() cv::ocl::magnitude(oclSrc1, oclSrc2, oclDst); - CPU_ON; - magnitude(x, y, mag); - CPU_OFF; - d_x.upload(x); - d_y.upload(y); + oclDst.download(dst); - WARMUP_ON; - ocl::magnitude(d_x, d_y, d_mag); - WARMUP_OFF; - - GPU_ON; - ocl::magnitude(d_x, d_y, d_mag); - GPU_OFF; - - GPU_FULL_ON; - d_x.upload(x); - d_y.upload(y); - ocl::magnitude(d_x, d_y, d_mag); - d_mag.download(ocl_mag); - GPU_FULL_OFF; - - TestSystem::instance().ExpectedMatNear(ocl_mag, mag, 1e-5); - } + SANITY_CHECK(dst, 1e-6); + } + else if (impl == "plain") + { + TEST_CYCLE() cv::magnitude(src1, src2, dst); + SANITY_CHECK(dst, 1e-6); } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); } ///////////// Transpose //////////////////////// -PERFTEST(Transpose) -{ - Mat src, dst, ocl_dst; - ocl::oclMat d_src, d_dst; - int all_type[] = {CV_8UC1, CV_8UC4}; - std::string type_name[] = {"CV_8UC1", "CV_8UC4"}; +typedef MulMatTypes TransposeMatTypes; +typedef tuple TransposeParams; +typedef TestBaseWithParam TransposeFixture; - for (int size = Min_Size; size <= Max_Size; size *= Multiple) +PERF_TEST_P(TransposeFixture, Transpose, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + TransposeMatTypes::all())) +{ + // getting params + TransposeParams params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params); + const string impl = getSelectedImpl(); + + // creating src data + Mat src(srcSize, type), dst(srcSize, type); + declare.in(src, WARMUP_RNG).out(dst); + + // select implementation + if (impl == "ocl") { - for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++) - { - SUBTEST << size << 'x' << size << "; " << type_name[j]; + ocl::oclMat oclSrc(src), oclDst(srcSize, type); - gen(src, size, size, all_type[j], 0, 256); - gen(dst, size, size, all_type[j], 0, 256); + TEST_CYCLE() cv::ocl::transpose(oclSrc, oclDst); - transpose(src, dst); + oclDst.download(dst); - CPU_ON; - transpose(src, dst); - CPU_OFF; - d_src.upload(src); - - WARMUP_ON; - ocl::transpose(d_src, d_dst); - WARMUP_OFF; - - GPU_ON; - ocl::transpose(d_src, d_dst); - GPU_OFF; - - GPU_FULL_ON; - d_src.upload(src); - ocl::transpose(d_src, d_dst); - d_dst.download(ocl_dst); - GPU_FULL_OFF; - - TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1e-5); - } + SANITY_CHECK(dst); + } + else if (impl == "plain") + { + TEST_CYCLE() cv::transpose(src, dst); + SANITY_CHECK(dst); } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); } ///////////// Flip //////////////////////// -PERFTEST(Flip) -{ - Mat src, dst, ocl_dst; - ocl::oclMat d_src, d_dst; - int all_type[] = {CV_8UC1, CV_8UC4}; - std::string type_name[] = {"CV_8UC1", "CV_8UC4"}; +typedef MulMatTypes FlipMatTypes; +typedef tuple FlipParams; +typedef TestBaseWithParam FlipFixture; - for (int size = Min_Size; size <= Max_Size; size *= Multiple) +PERF_TEST_P(FlipFixture, Flip, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + FlipMatTypes::all())) +{ + // getting params + TransposeParams params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params); + const string impl = getSelectedImpl(); + + // creating src data + Mat src(srcSize, type), dst(srcSize, type); + declare.in(src, WARMUP_RNG).out(dst); + + // select implementation + if (impl == "ocl") { - for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++) - { - SUBTEST << size << 'x' << size << "; " << type_name[j] << " ; FLIP_BOTH"; - - gen(src, size, size, all_type[j], 0, 256); - gen(dst, size, size, all_type[j], 0, 256); - - flip(src, dst, 0); + ocl::oclMat oclSrc(src), oclDst(srcSize, type); - CPU_ON; - flip(src, dst, 0); - CPU_OFF; - d_src.upload(src); + TEST_CYCLE() cv::ocl::flip(oclSrc, oclDst, 0); - WARMUP_ON; - ocl::flip(d_src, d_dst, 0); - WARMUP_OFF; + oclDst.download(dst); - GPU_ON; - ocl::flip(d_src, d_dst, 0); - GPU_OFF; - - GPU_FULL_ON; - d_src.upload(src); - ocl::flip(d_src, d_dst, 0); - d_dst.download(ocl_dst); - GPU_FULL_OFF; - - TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1e-5); - } + SANITY_CHECK(dst); + } + else if (impl == "plain") + { + TEST_CYCLE() cv::flip(src, dst, 0); + SANITY_CHECK(dst); } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); } ///////////// minMax //////////////////////// -PERFTEST(minMax) -{ - Mat src; - ocl::oclMat d_src; - - double min_val = 0.0, max_val = 0.0; - double min_val_ = 0.0, max_val_ = 0.0; - Point min_loc, max_loc; - int all_type[] = {CV_8UC1, CV_32FC1}; - std::string type_name[] = {"CV_8UC1", "CV_32FC1"}; - for (int size = Min_Size; size <= Max_Size; size *= Multiple) - { - for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++) - { - SUBTEST << size << 'x' << size << "; " << type_name[j]; +typedef AddMatTypes minMaxMatTypes; +typedef tuple minMaxParams; +typedef TestBaseWithParam minMaxFixture; - gen(src, size, size, all_type[j], 0, 256); +PERF_TEST_P(minMaxFixture, minMax, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + minMaxMatTypes::all())) +{ + // getting params + minMaxParams params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params); + const string impl = getSelectedImpl(); - CPU_ON; - minMaxLoc(src, &min_val, &max_val, &min_loc, &max_loc); - CPU_OFF; - d_src.upload(src); + // creating src data + Mat src(srcSize, type); + declare.in(src, WARMUP_RNG); - WARMUP_ON; - ocl::minMax(d_src, &min_val_, &max_val_); - WARMUP_OFF; + double min_val = 0.0, max_val = 0.0; - if(EeceptDoubleEQ(max_val_, max_val) && EeceptDoubleEQ(min_val_, min_val)) - TestSystem::instance().setAccurate(1, max(fabs(max_val_-max_val), fabs(min_val_-min_val))); - else - TestSystem::instance().setAccurate(0, max(fabs(max_val_-max_val), fabs(min_val_-min_val))); + // select implementation + if (impl == "ocl") + { + ocl::oclMat oclSrc(src); - GPU_ON; - ocl::minMax(d_src, &min_val, &max_val); - GPU_OFF; + TEST_CYCLE() cv::ocl::minMax(oclSrc, &min_val, &max_val); - GPU_FULL_ON; - d_src.upload(src); - ocl::minMax(d_src, &min_val, &max_val); - GPU_FULL_OFF; + ASSERT_GE(max_val, min_val); + SANITY_CHECK(min_val); + SANITY_CHECK(max_val); + } + else if (impl == "plain") + { + Point min_loc, max_loc; - } + TEST_CYCLE() cv::minMaxLoc(src, &min_val, &max_val, &min_loc, &max_loc); + ASSERT_GE(max_val, min_val); + SANITY_CHECK(min_val); + SANITY_CHECK(max_val); } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); } ///////////// minMaxLoc //////////////////////// -PERFTEST(minMaxLoc) + +typedef AddMatTypes minMaxLocMatTypes; +typedef tuple minMaxLocParams; +typedef TestBaseWithParam minMaxLocFixture; + +PERF_TEST_P(minMaxLocFixture, minMaxLoc, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + minMaxLocMatTypes::all())) { - Mat src; - ocl::oclMat d_src; + // getting params + minMaxLocParams params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params); + const string impl = getSelectedImpl(); + + // creating src data + Mat src(srcSize, type); + randu(src, 0, 1); + declare.in(src); double min_val = 0.0, max_val = 0.0; - double min_val_ = 0.0, max_val_ = 0.0; Point min_loc, max_loc; - Point min_loc_, max_loc_; - int all_type[] = {CV_8UC1, CV_32FC1}; - std::string type_name[] = {"CV_8UC1", "CV_32FC1"}; - for (int size = Min_Size; size <= Max_Size; size *= Multiple) + // select implementation + if (impl == "ocl") { - for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++) - { - SUBTEST << size << 'x' << size << "; " << type_name[j] ; + ocl::oclMat oclSrc(src); - gen(src, size, size, all_type[j], 0, 1); + TEST_CYCLE() cv::ocl::minMaxLoc(oclSrc, &min_val, &max_val, &min_loc, &max_loc); - CPU_ON; - minMaxLoc(src, &min_val, &max_val, &min_loc, &max_loc); - CPU_OFF; - d_src.upload(src); - - WARMUP_ON; - ocl::minMaxLoc(d_src, &min_val_, &max_val_, &min_loc_, &max_loc_); - WARMUP_OFF; - - double error0 = 0., error1 = 0., minlocVal = 0., minlocVal_ = 0., maxlocVal = 0., maxlocVal_ = 0.; - if(src.depth() == 0) - { - minlocVal = src.at(min_loc); - minlocVal_ = src.at(min_loc_); - maxlocVal = src.at(max_loc); - maxlocVal_ = src.at(max_loc_); - } - if(src.depth() == 1) - { - minlocVal = src.at(min_loc); - minlocVal_ = src.at(min_loc_); - maxlocVal = src.at(max_loc); - maxlocVal_ = src.at(max_loc_); - } - if(src.depth() == 2) - { - minlocVal = src.at(min_loc); - minlocVal_ = src.at(min_loc_); - maxlocVal = src.at(max_loc); - maxlocVal_ = src.at(max_loc_); - } - if(src.depth() == 3) - { - minlocVal = src.at(min_loc); - minlocVal_ = src.at(min_loc_); - maxlocVal = src.at(max_loc); - maxlocVal_ = src.at(max_loc_); - } - if(src.depth() == 4) - { - minlocVal = src.at(min_loc); - minlocVal_ = src.at(min_loc_); - maxlocVal = src.at(max_loc); - maxlocVal_ = src.at(max_loc_); - } - if(src.depth() == 5) - { - minlocVal = src.at(min_loc); - minlocVal_ = src.at(min_loc_); - maxlocVal = src.at(max_loc); - maxlocVal_ = src.at(max_loc_); - } - if(src.depth() == 6) - { - minlocVal = src.at(min_loc); - minlocVal_ = src.at(min_loc_); - maxlocVal = src.at(max_loc); - maxlocVal_ = src.at(max_loc_); - } - error0 = ::abs(minlocVal_ - minlocVal); - error1 = ::abs(maxlocVal_ - maxlocVal); - if( EeceptDoubleEQ(maxlocVal_, maxlocVal) - &&EeceptDoubleEQ(minlocVal_, minlocVal) - &&EeceptDoubleEQ(max_val_, max_val) - &&EeceptDoubleEQ(min_val_, min_val)) - TestSystem::instance().setAccurate(1, 0.); - else - TestSystem::instance().setAccurate(0, max(error0, error1)); - - GPU_ON; - ocl::minMaxLoc(d_src, &min_val, &max_val, &min_loc, &max_loc); - GPU_OFF; - - GPU_FULL_ON; - d_src.upload(src); - ocl::minMaxLoc(d_src, &min_val, &max_val, &min_loc, &max_loc); - GPU_FULL_OFF; - } + ASSERT_GE(max_val, min_val); + SANITY_CHECK(min_val); + SANITY_CHECK(max_val); + } + else if (impl == "plain") + { + TEST_CYCLE() cv::minMaxLoc(src, &min_val, &max_val, &min_loc, &max_loc); + ASSERT_GE(max_val, min_val); + SANITY_CHECK(min_val); + SANITY_CHECK(max_val); } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); } ///////////// Sum //////////////////////// -PERFTEST(Sum) -{ - Mat src; - Scalar cpures, gpures; - ocl::oclMat d_src; - - int all_type[] = {CV_8UC1, CV_32SC1}; - std::string type_name[] = {"CV_8UC1", "CV_32SC1"}; - - for (int size = Min_Size; size <= Max_Size; size *= Multiple) - { - for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++) - { - SUBTEST << size << 'x' << size << "; " << type_name[j] ; - gen(src, size, size, all_type[j], 0, 60); +CV_ENUM(SumMatTypes, CV_8UC1, CV_32SC1) - cpures = sum(src); +typedef tuple SumParams; +typedef TestBaseWithParam SumFixture; - CPU_ON; - cpures = sum(src); - CPU_OFF; - d_src.upload(src); - - WARMUP_ON; - gpures = ocl::sum(d_src); - WARMUP_OFF; - - vector diffs(4); - diffs[3] = fabs(cpures[3] - gpures[3]); - diffs[2] = fabs(cpures[2] - gpures[2]); - diffs[1] = fabs(cpures[1] - gpures[1]); - diffs[0] = fabs(cpures[0] - gpures[0]); - double max_diff = *max_element(diffs.begin(), diffs.end()); - TestSystem::instance().setAccurate(max_diff<0.1?1:0, max_diff); +PERF_TEST_P(SumFixture, Sum, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + SumMatTypes::all())) +{ + // getting params + SumParams params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params); + const string impl = getSelectedImpl(); + + // creating src data + Mat src(srcSize, type); + Scalar result; + randu(src, 0, 60); + declare.in(src); + + // select implementation + if (impl == "ocl") + { + ocl::oclMat oclSrc(src); - GPU_ON; - gpures = ocl::sum(d_src); - GPU_OFF; + TEST_CYCLE() result = cv::ocl::sum(oclSrc); - GPU_FULL_ON; - d_src.upload(src); - gpures = ocl::sum(d_src); - GPU_FULL_OFF; - } + SANITY_CHECK(result); + } + else if (impl == "plain") + { + TEST_CYCLE() result = cv::sum(src); + SANITY_CHECK(result); } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); } ///////////// countNonZero //////////////////////// -PERFTEST(countNonZero) -{ - Mat src; - ocl::oclMat d_src; - int all_type[] = {CV_8UC1, CV_32FC1}; - std::string type_name[] = {"CV_8UC1", "CV_32FC1"}; +CV_ENUM(countNonZeroMatTypes, CV_8UC1, CV_32FC1) - for (int size = Min_Size; size <= Max_Size; size *= Multiple) - { - for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++) - { - SUBTEST << size << 'x' << size << "; " << type_name[j] ; - - gen(src, size, size, all_type[j], 0, 256); - - countNonZero(src); - - int cpures = 0, gpures = 0; - CPU_ON; - cpures = countNonZero(src); - CPU_OFF; - d_src.upload(src); +typedef tuple countNonZeroParams; +typedef TestBaseWithParam countNonZeroFixture; - WARMUP_ON; - gpures = ocl::countNonZero(d_src); - WARMUP_OFF; - - int diff = abs(cpures - gpures); - if(diff == 0) - TestSystem::instance().setAccurate(1, 0); - else - TestSystem::instance().setAccurate(0, diff); +PERF_TEST_P(countNonZeroFixture, countNonZero, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + countNonZeroMatTypes::all())) +{ + // getting params + countNonZeroParams params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params); + const string impl = getSelectedImpl(); + + // creating src data + Mat src(srcSize, type); + int result = 0; + randu(src, 0, 256); + declare.in(src); + + // select implementation + if (impl == "ocl") + { + ocl::oclMat oclSrc(src); - GPU_ON; - ocl::countNonZero(d_src); - GPU_OFF; + TEST_CYCLE() result = cv::ocl::countNonZero(oclSrc); - GPU_FULL_ON; - d_src.upload(src); - ocl::countNonZero(d_src); - GPU_FULL_OFF; - } + SANITY_CHECK(result); + } + else if (impl == "plain") + { + TEST_CYCLE() result = cv::countNonZero(src); + SANITY_CHECK(result); } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); } ///////////// Phase //////////////////////// -PERFTEST(Phase) -{ - Mat src1, src2, dst, ocl_dst; - ocl::oclMat d_src1, d_src2, d_dst; - int all_type[] = {CV_32FC1}; - std::string type_name[] = {"CV_32FC1"}; +typedef TestBaseWithParam PhaseFixture; - for (int size = Min_Size; size <= Max_Size; size *= Multiple) +PERF_TEST_P(PhaseFixture, Phase, OCL_TYPICAL_MAT_SIZES) +{ + // getting params + const Size srcSize = GetParam(); + const string impl = getSelectedImpl(); + + // creating src data + Mat src1(srcSize, CV_32FC1), src2(srcSize, CV_32FC1), + dst(srcSize, CV_32FC1); + declare.in(src1, src2).out(dst); + randu(src1, 0, 256); + randu(src2, 0, 256); + + // select implementation + if (impl == "ocl") { - for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++) - { - SUBTEST << size << 'x' << size << "; " << type_name[j] ; - - gen(src1, size, size, all_type[j], 0, 256); - gen(src2, size, size, all_type[j], 0, 256); - gen(dst, size, size, all_type[j], 0, 256); - - phase(src1, src2, dst, 1); - - CPU_ON; - phase(src1, src2, dst, 1); - CPU_OFF; + ocl::oclMat oclSrc1(src1), oclSrc2(src2), + oclDst(srcSize, src1.type()); - d_src1.upload(src1); - d_src2.upload(src2); + TEST_CYCLE() cv::ocl::phase(oclSrc1, oclSrc2, oclDst, 1); - WARMUP_ON; - ocl::phase(d_src1, d_src2, d_dst, 1); - WARMUP_OFF; + oclDst.download(dst); - GPU_ON; - ocl::phase(d_src1, d_src2, d_dst, 1); - GPU_OFF; - - GPU_FULL_ON; - d_src1.upload(src1); - d_src2.upload(src2); - ocl::phase(d_src1, d_src2, d_dst, 1); - d_dst.download(ocl_dst); - GPU_FULL_OFF; - - TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1e-2); - } + SANITY_CHECK(dst, 1e-2); + } + else if (impl == "plain") + { + TEST_CYCLE() cv::phase(src1, src2, dst, 1); + SANITY_CHECK(dst, 1e-2); } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); } ///////////// bitwise_and//////////////////////// -PERFTEST(bitwise_and) -{ - Mat src1, src2, dst, ocl_dst; - ocl::oclMat d_src1, d_src2, d_dst; - int all_type[] = {CV_8UC1, CV_32SC1}; - std::string type_name[] = {"CV_8UC1", "CV_32SC1"}; +typedef SumMatTypes BitwiseAndMatTypes; +typedef tuple BitwiseAndParams; +typedef TestBaseWithParam BitwiseAndFixture; - for (int size = Min_Size; size <= Max_Size; size *= Multiple) +PERF_TEST_P(BitwiseAndFixture, bitwise_and, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + BitwiseAndMatTypes::all())) +{ + // getting params + BitwiseAndParams params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params); + const string impl = getSelectedImpl(); + + // creating src data + Mat src1(srcSize, type), src2(srcSize, type), dst(srcSize, type); + declare.in(src1, src2).out(dst); + randu(src1, 0, 256); + randu(src2, 0, 256); + + // select implementation + if (impl == "ocl") { - for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++) - { - SUBTEST << size << 'x' << size << "; " << type_name[j] ; + ocl::oclMat oclSrc1(src1), oclSrc2(src2), oclDst(srcSize, src1.type()); - gen(src1, size, size, all_type[j], 0, 256); - gen(src2, size, size, all_type[j], 0, 256); - gen(dst, size, size, all_type[j], 0, 256); + TEST_CYCLE() cv::ocl::bitwise_and(oclSrc1, oclSrc2, oclDst); - bitwise_and(src1, src2, dst); + oclDst.download(dst); - CPU_ON; - bitwise_and(src1, src2, dst); - CPU_OFF; - d_src1.upload(src1); - d_src2.upload(src2); - - WARMUP_ON; - ocl::bitwise_and(d_src1, d_src2, d_dst); - WARMUP_OFF; - - GPU_ON; - ocl::bitwise_and(d_src1, d_src2, d_dst); - GPU_OFF; - - GPU_FULL_ON; - d_src1.upload(src1); - d_src2.upload(src2); - ocl::bitwise_and(d_src1, d_src2, d_dst); - d_dst.download(ocl_dst); - GPU_FULL_OFF; - - TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 0.0); - } + SANITY_CHECK(dst); + } + else if (impl == "plain") + { + TEST_CYCLE() cv::bitwise_and(src1, src2, dst); + SANITY_CHECK(dst); } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); } ///////////// bitwise_not//////////////////////// -PERFTEST(bitwise_not) -{ - Mat src1, dst, ocl_dst; - ocl::oclMat d_src1, d_dst; - int all_type[] = {CV_8UC1, CV_32SC1}; - std::string type_name[] = {"CV_8UC1", "CV_32SC1"}; +typedef SumMatTypes BitwiseNotMatTypes; +typedef tuple BitwiseNotParams; +typedef TestBaseWithParam BitwiseNotFixture; - for (int size = Min_Size; size <= Max_Size; size *= Multiple) +PERF_TEST_P(BitwiseAndFixture, bitwise_not, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + BitwiseAndMatTypes::all())) +{ + // getting params + BitwiseNotParams params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params); + const string impl = getSelectedImpl(); + + // creating src data + Mat src(srcSize, type), dst(srcSize, type); + declare.in(src, WARMUP_RNG).out(dst); + + // select implementation + if (impl == "ocl") { - for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++) - { - SUBTEST << size << 'x' << size << "; " << type_name[j] ; - - gen(src1, size, size, all_type[j], 0, 256); - gen(dst, size, size, all_type[j], 0, 256); - - bitwise_not(src1, dst); - - CPU_ON; - bitwise_not(src1, dst); - CPU_OFF; - d_src1.upload(src1); + ocl::oclMat oclSrc(src), oclDst(srcSize, type); - WARMUP_ON; - ocl::bitwise_not(d_src1, d_dst); - WARMUP_OFF; + TEST_CYCLE() cv::ocl::bitwise_not(oclSrc, oclDst); - GPU_ON; - ocl::bitwise_not(d_src1, d_dst); - GPU_OFF; + oclDst.download(dst); - GPU_FULL_ON; - d_src1.upload(src1); - ocl::bitwise_not(d_src1, d_dst); - d_dst.download(ocl_dst); - GPU_FULL_OFF; - - TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 0.0); - } + SANITY_CHECK(dst); + } + else if (impl == "plain") + { + TEST_CYCLE() cv::bitwise_not(src, dst); + SANITY_CHECK(dst); } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); } ///////////// compare//////////////////////// -PERFTEST(compare) -{ - Mat src1, src2, dst, ocl_dst; - ocl::oclMat d_src1, d_src2, d_dst; - int CMP_EQ = 0; - int all_type[] = {CV_8UC1, CV_32FC1}; - std::string type_name[] = {"CV_8UC1", "CV_32FC1"}; +typedef countNonZeroMatTypes CompareMatTypes; +typedef tuple CompareParams; +typedef TestBaseWithParam CompareFixture; - for (int size = Min_Size; size <= Max_Size; size *= Multiple) +PERF_TEST_P(CompareFixture, compare, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + CompareMatTypes::all())) +{ + // getting params + CompareParams params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params); + const string impl = getSelectedImpl(); + + // creating src data + Mat src1(srcSize, type), src2(srcSize, type), dst(srcSize, CV_8UC1); + declare.in(src1, src2, WARMUP_RNG).out(dst); + + // select implementation + if (impl == "ocl") { - for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++) - { - SUBTEST << size << 'x' << size << "; " << type_name[j] ; - - gen(src1, size, size, all_type[j], 0, 256); - gen(src2, size, size, all_type[j], 0, 256); - gen(dst, size, size, all_type[j], 0, 256); - - compare(src1, src2, dst, CMP_EQ); - - CPU_ON; - compare(src1, src2, dst, CMP_EQ); - CPU_OFF; - - d_src1.upload(src1); - d_src2.upload(src2); - - WARMUP_ON; - ocl::compare(d_src1, d_src2, d_dst, CMP_EQ); - WARMUP_OFF; + ocl::oclMat oclSrc1(src1), oclSrc2(src2), oclDst(srcSize, CV_8UC1); - GPU_ON; - ocl::compare(d_src1, d_src2, d_dst, CMP_EQ); - GPU_OFF; + TEST_CYCLE() cv::ocl::compare(oclSrc1, oclSrc2, oclDst, CMP_EQ); - GPU_FULL_ON; - d_src1.upload(src1); - d_src2.upload(src2); - ocl::compare(d_src1, d_src2, d_dst, CMP_EQ); - d_dst.download(ocl_dst); - GPU_FULL_OFF; + oclDst.download(dst); - TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 0.0); - } + SANITY_CHECK(dst); + } + else if (impl == "plain") + { + TEST_CYCLE() cv::compare(src1, src2, dst, CMP_EQ); + SANITY_CHECK(dst); } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); } ///////////// pow //////////////////////// -PERFTEST(pow) -{ - Mat src, dst, ocl_dst; - ocl::oclMat d_src, d_dst; - - int all_type[] = {CV_32FC1}; - std::string type_name[] = {"CV_32FC1"}; - - for (int size = Min_Size; size <= Max_Size; size *= Multiple) - { - for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++) - { - SUBTEST << size << 'x' << size << "; " << type_name[j] ; - gen(src, size, size, all_type[j], 5, 16); +typedef TestBaseWithParam PowFixture; - pow(src, -2.0, dst); +PERF_TEST_P(PowFixture, pow, OCL_TYPICAL_MAT_SIZES) +{ + // getting params + const Size srcSize = GetParam(); + const string impl = getSelectedImpl(); - CPU_ON; - pow(src, -2.0, dst); - CPU_OFF; - d_src.upload(src); - d_dst.upload(dst); + // creating src data + Mat src(srcSize, CV_32F), dst(srcSize, CV_32F); + declare.in(src, WARMUP_RNG).out(dst); - WARMUP_ON; - ocl::pow(d_src, -2.0, d_dst); - WARMUP_OFF; + // select implementation + if (impl == "ocl") + { + ocl::oclMat oclSrc(src), oclDst(srcSize, src.type()); - GPU_ON; - ocl::pow(d_src, -2.0, d_dst); - GPU_OFF; + TEST_CYCLE() cv::ocl::pow(oclSrc, -2.0, oclDst); - GPU_FULL_ON; - d_src.upload(src); - ocl::pow(d_src, -2.0, d_dst); - d_dst.download(ocl_dst); - GPU_FULL_OFF; + oclDst.download(dst); - TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1.0); - } + SANITY_CHECK(dst, 5e-2); + } + else if (impl == "plain") + { + TEST_CYCLE() cv::pow(src, -2.0, dst); + SANITY_CHECK(dst, 5e-2); } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); } ///////////// MagnitudeSqr//////////////////////// -PERFTEST(MagnitudeSqr) -{ - Mat src1, src2, dst, ocl_dst; - ocl::oclMat d_src1, d_src2, d_dst; - - int all_type[] = {CV_32FC1}; - std::string type_name[] = {"CV_32FC1"}; - for (int size = Min_Size; size <= Max_Size; size *= Multiple) - { - for (size_t t = 0; t < sizeof(all_type) / sizeof(int); t++) - { - SUBTEST << size << 'x' << size << "; " << type_name[t]; +typedef TestBaseWithParam MagnitudeSqrFixture; - gen(src1, size, size, all_type[t], 0, 256); - gen(src2, size, size, all_type[t], 0, 256); - gen(dst, size, size, all_type[t], 0, 256); - - CPU_ON; - for (int i = 0; i < src1.rows; ++i) - for (int j = 0; j < src1.cols; ++j) - { - float val1 = src1.at(i, j); - float val2 = src2.at(i, j); - ((float *)(dst.data))[i * dst.step / 4 + j] = val1 * val1 + val2 * val2; +PERF_TEST_P(MagnitudeSqrFixture, MagnitudeSqr, OCL_TYPICAL_MAT_SIZES) +{ + // getting params + const Size srcSize = GetParam(); + const string impl = getSelectedImpl(); - } - CPU_OFF; + // creating src data + Mat src1(srcSize, CV_32FC1), src2(srcSize, CV_32FC1), + dst(srcSize, CV_32FC1); + declare.in(src1, src2, WARMUP_RNG).out(dst); - d_src1.upload(src1); - d_src2.upload(src2); + // select implementation + if (impl == "ocl") + { + ocl::oclMat oclSrc1(src1), oclSrc2(src2), oclDst(srcSize, src1.type()); - WARMUP_ON; - ocl::magnitudeSqr(d_src1, d_src2, d_dst); - WARMUP_OFF; + TEST_CYCLE() cv::ocl::magnitudeSqr(oclSrc1, oclSrc2, oclDst); - GPU_ON; - ocl::magnitudeSqr(d_src1, d_src2, d_dst); - GPU_OFF; + oclDst.download(dst); - GPU_FULL_ON; - d_src1.upload(src1); - d_src2.upload(src2); - ocl::magnitudeSqr(d_src1, d_src2, d_dst); - d_dst.download(ocl_dst); - GPU_FULL_OFF; + SANITY_CHECK(dst, 1e-6, ERROR_RELATIVE); + } + else if (impl == "plain") + { + ASSERT_EQ(1, src1.channels()); - TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1.0); + TEST_CYCLE() + { + for (int y = 0; y < srcSize.height; ++y) + { + const float * const src1Data = reinterpret_cast(src1.data + src1.step * y); + const float * const src2Data = reinterpret_cast(src2.data + src2.step * y); + float * const dstData = reinterpret_cast(dst.data + dst.step * y); + for (int x = 0; x < srcSize.width; ++x) + { + float t0 = src1Data[x] * src1Data[x]; + float t1 = src2Data[x] * src2Data[x]; + dstData[x] = t0 + t1; + } + } } + SANITY_CHECK(dst, 1e-6, ERROR_RELATIVE); } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); } ///////////// AddWeighted//////////////////////// -PERFTEST(AddWeighted) -{ - Mat src1, src2, dst, ocl_dst; - ocl::oclMat d_src1, d_src2, d_dst; +typedef countNonZeroMatTypes AddWeightedMatTypes; +typedef tuple AddWeightedParams; +typedef TestBaseWithParam AddWeightedFixture; + +PERF_TEST_P(AddWeightedFixture, AddWeighted, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + AddWeightedMatTypes::all())) +{ + // getting params + AddWeightedParams params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params); + const string impl = getSelectedImpl(); + + // creating src data + Mat src1(srcSize, type), src2(srcSize, type), dst(srcSize, type); + declare.in(src1, src2, WARMUP_RNG).out(dst); double alpha = 2.0, beta = 1.0, gama = 3.0; - int all_type[] = {CV_8UC1, CV_32FC1}; - std::string type_name[] = {"CV_8UC1", "CV_32FC1"}; - for (int size = Min_Size; size <= Max_Size; size *= Multiple) + // select implementation + if (impl == "ocl") { - for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++) - { - SUBTEST << size << 'x' << size << "; " << type_name[j] ; + ocl::oclMat oclSrc1(src1), oclSrc2(src2), oclDst(srcSize, type); - gen(src1, size, size, all_type[j], 0, 256); - gen(src2, size, size, all_type[j], 0, 256); - gen(dst, size, size, all_type[j], 0, 256); + TEST_CYCLE() cv::ocl::addWeighted(oclSrc1, alpha, oclSrc2, beta, gama, oclDst); + oclDst.download(dst); - addWeighted(src1, alpha, src2, beta, gama, dst); - - CPU_ON; - addWeighted(src1, alpha, src2, beta, gama, dst); - CPU_OFF; - d_src1.upload(src1); - d_src2.upload(src2); - - WARMUP_ON; - ocl::addWeighted(d_src1, alpha, d_src2, beta, gama, d_dst); - WARMUP_OFF; - - GPU_ON; - ocl::addWeighted(d_src1, alpha, d_src2, beta, gama, d_dst); - GPU_OFF; - - GPU_FULL_ON; - d_src1.upload(src1); - d_src2.upload(src2); - ocl::addWeighted(d_src1, alpha, d_src2, beta, gama, d_dst); - d_dst.download(ocl_dst); - GPU_FULL_OFF; - - TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1e-5); - } + SANITY_CHECK(dst); + } + else if (impl == "plain") + { + TEST_CYCLE() cv::addWeighted(src1, alpha, src2, beta, gama, dst); + SANITY_CHECK(dst); } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); } diff --git a/modules/ocl/perf/perf_blend.cpp b/modules/ocl/perf/perf_blend.cpp index 11eea64..c8a7608 100644 --- a/modules/ocl/perf/perf_blend.cpp +++ b/modules/ocl/perf/perf_blend.cpp @@ -45,9 +45,15 @@ //M*/ #include "perf_precomp.hpp" + +using namespace perf; + ///////////// blend //////////////////////// + template -void blendLinearGold(const cv::Mat &img1, const cv::Mat &img2, const cv::Mat &weights1, const cv::Mat &weights2, cv::Mat &result_gold) +static void blendLinearGold(const cv::Mat &img1, const cv::Mat &img2, + const cv::Mat &weights1, const cv::Mat &weights2, + cv::Mat &result_gold) { result_gold.create(img1.size(), img1.type()); @@ -63,60 +69,54 @@ void blendLinearGold(const cv::Mat &img1, const cv::Mat &img2, const cv::Mat &we for (int x = 0; x < img1.cols * cn; ++x) { - float w1 = weights1_row[x / cn]; - float w2 = weights2_row[x / cn]; - result_gold_row[x] = static_cast((img1_row[x] * w1 + img2_row[x] * w2) / (w1 + w2 + 1e-5f)); + int x1 = x * cn; + float w1 = weights1_row[x]; + float w2 = weights2_row[x]; + result_gold_row[x] = static_cast((img1_row[x1] * w1 + + img2_row[x1] * w2) / (w1 + w2 + 1e-5f)); } } } -PERFTEST(blend) + +typedef TestBaseWithParam blendLinearFixture; + +PERF_TEST_P(blendLinearFixture, blendLinear, OCL_TYPICAL_MAT_SIZES) { - Mat src1, src2, weights1, weights2, dst, ocl_dst; - ocl::oclMat d_src1, d_src2, d_weights1, d_weights2, d_dst; + // getting params + const Size srcSize = GetParam(); + const int type = CV_8UC1; + const std::string impl = getSelectedImpl(); + + // creating src data + Mat src1(srcSize, type), src2(srcSize, CV_8UC1), dst; + Mat weights1(srcSize, CV_32FC1), weights2(srcSize, CV_32FC1); - int all_type[] = {CV_8UC1, CV_8UC4}; - std::string type_name[] = {"CV_8UC1", "CV_8UC4"}; + declare.in(src1, src2, WARMUP_RNG); + randu(weights1, 0.0f, 1.0f); + randu(weights2, 0.0f, 1.0f); - for (int size = Min_Size; size <= Max_Size; size *= Multiple) + // select implementation + if (impl == "ocl") { - for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++) - { - SUBTEST << size << 'x' << size << "; " << type_name[j] << " and CV_32FC1"; - - gen(src1, size, size, all_type[j], 0, 256); - gen(src2, size, size, all_type[j], 0, 256); - gen(weights1, size, size, CV_32FC1, 0, 1); - gen(weights2, size, size, CV_32FC1, 0, 1); - - blendLinearGold(src1, src2, weights1, weights2, dst); - - CPU_ON; - blendLinearGold(src1, src2, weights1, weights2, dst); - CPU_OFF; - - d_src1.upload(src1); - d_src2.upload(src2); - d_weights1.upload(weights1); - d_weights2.upload(weights2); - - WARMUP_ON; - ocl::blendLinear(d_src1, d_src2, d_weights1, d_weights2, d_dst); - WARMUP_OFF; - - GPU_ON; - ocl::blendLinear(d_src1, d_src2, d_weights1, d_weights2, d_dst); - GPU_OFF; - - GPU_FULL_ON; - d_src1.upload(src1); - d_src2.upload(src2); - d_weights1.upload(weights1); - d_weights2.upload(weights2); - ocl::blendLinear(d_src1, d_src2, d_weights1, d_weights2, d_dst); - d_dst.download(ocl_dst); - GPU_FULL_OFF; - - TestSystem::instance().ExpectedMatNear(dst, ocl_dst, 1.f); - } + ocl::oclMat oclSrc1(src1), oclSrc2(src2), oclDst; + ocl::oclMat oclWeights1(weights1), oclWeights2(weights2); + + TEST_CYCLE() cv::ocl::blendLinear(oclSrc1, oclSrc2, oclWeights1, oclWeights2, oclDst); + + oclDst.download(dst); + + SANITY_CHECK(dst); + } + else if (impl == "plain") + { + TEST_CYCLE() blendLinearGold(src1, src2, weights1, weights2, dst); + + SANITY_CHECK(dst); } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); } diff --git a/modules/ocl/perf/perf_brute_force_matcher.cpp b/modules/ocl/perf/perf_brute_force_matcher.cpp index 14df629..841fa64 100644 --- a/modules/ocl/perf/perf_brute_force_matcher.cpp +++ b/modules/ocl/perf/perf_brute_force_matcher.cpp @@ -45,123 +45,242 @@ //M*/ #include "perf_precomp.hpp" +using namespace perf; + +#define OCL_BFMATCHER_TYPICAL_MAT_SIZES ::testing::Values(cv::Size(128, 500), cv::Size(128, 1000), cv::Size(128, 2000)) + //////////////////// BruteForceMatch ///////////////// -PERFTEST(BruteForceMatcher) + +typedef TestBaseWithParam BruteForceMatcherFixture; + +PERF_TEST_P(BruteForceMatcherFixture, match, + OCL_BFMATCHER_TYPICAL_MAT_SIZES) { - Mat trainIdx_cpu; - Mat distance_cpu; - Mat allDist_cpu; - Mat nMatches_cpu; + const Size srcSize = GetParam(); + const string impl = getSelectedImpl(); - for (int size = Min_Size; size <= Max_Size; size *= Multiple) - { - // Init CPU matcher - int desc_len = 64; + vector matches; + Mat query(srcSize, CV_32F), train(srcSize, CV_32F); + declare.in(query, train).time(srcSize.height == 2000 ? 8 : 4 ); + randu(query, 0.0f, 1.0f); + randu(train, 0.0f, 1.0f); + if (impl == "plain") + { BFMatcher matcher(NORM_L2); + TEST_CYCLE() matcher.match(query, train, matches); - Mat query; - gen(query, size, desc_len, CV_32F, 0, 1); - - Mat train; - gen(train, size, desc_len, CV_32F, 0, 1); - // Output - vector< vector > matches(2); - vector< vector > d_matches(2); + SANITY_CHECK_MATCHES(matches); + } + else if (impl == "ocl") + { // Init GPU matcher - ocl::BruteForceMatcher_OCL_base d_matcher(ocl::BruteForceMatcher_OCL_base::L2Dist); + ocl::BruteForceMatcher_OCL_base oclMatcher(ocl::BruteForceMatcher_OCL_base::L2Dist); + ocl::oclMat oclQuery(query), oclTrain(train); - ocl::oclMat d_query(query); - ocl::oclMat d_train(train); + TEST_CYCLE() oclMatcher.match(oclQuery, oclTrain, matches); - ocl::oclMat d_trainIdx, d_distance, d_allDist, d_nMatches; + SANITY_CHECK_MATCHES(matches); + } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); +} + +//PERF_TEST_P(BruteForceMatcherFixture, matchSingle, +// OCL_BFMATCHER_TYPICAL_MAT_SIZES) +//{ +// const Size srcSize = GetParam(); +// const string impl = getSelectedImpl(); + +// Mat query(srcSize, CV_32F), train(srcSize, CV_32F); +// Mat trainIdx, distance; - SUBTEST << size << "; match"; +// randu(query, 0.0f, 1.0f); +// randu(train, 0.0f, 1.0f); - matcher.match(query, train, matches[0]); +// if (impl == "plain") +// CV_TEST_FAIL_NO_IMPL(); +// else if (impl == "ocl") +// { +// ocl::oclMat oclQuery(query), oclTrain(train), oclTrainIdx, oclDistance; - CPU_ON; - matcher.match(query, train, matches[0]); - CPU_OFF; +// TEST_CYCLE() oclMatcher->matchSingle(oclQuery, oclTrain, oclTrainIdx, oclDistance); + +// oclTrainIdx.download(trainIdx); +// oclDistance.download(distance); + +// SANITY_CHECK(trainIdx); +// SANITY_CHECK(distance); +// } +//#ifdef HAVE_OPENCV_GPU +// else if (impl == "gpu") +// CV_TEST_FAIL_NO_IMPL(); +//#endif +// else +// CV_TEST_FAIL_NO_IMPL(); +//} + +PERF_TEST_P(BruteForceMatcherFixture, knnMatch, + OCL_BFMATCHER_TYPICAL_MAT_SIZES) +{ + const Size srcSize = GetParam(); + const string impl = getSelectedImpl(); - WARMUP_ON; - d_matcher.matchSingle(d_query, d_train, d_trainIdx, d_distance); - WARMUP_OFF; + vector > matches(2); + Mat query(srcSize, CV_32F), train(srcSize, CV_32F); + randu(query, 0.0f, 1.0f); + randu(train, 0.0f, 1.0f); - GPU_ON; - d_matcher.matchSingle(d_query, d_train, d_trainIdx, d_distance); - GPU_OFF; + declare.in(query, train); + if (srcSize.height == 2000) + declare.time(8); - GPU_FULL_ON; - d_query.upload(query); - d_train.upload(train); - d_matcher.match(d_query, d_train, d_matches[0]); - GPU_FULL_OFF; + if (impl == "plain") + { + BFMatcher matcher (NORM_L2); + TEST_CYCLE() matcher.knnMatch(query, train, matches, 2); - int diff = abs((int)d_matches[0].size() - (int)matches[0].size()); - if(diff == 0) - TestSystem::instance().setAccurate(1, 0); - else - TestSystem::instance().setAccurate(0, diff); + std::vector & matches0 = matches[0], & matches1 = matches[1]; + SANITY_CHECK_MATCHES(matches0); + SANITY_CHECK_MATCHES(matches1); + } + else if (impl == "ocl") + { + ocl::BruteForceMatcher_OCL_base oclMatcher(ocl::BruteForceMatcher_OCL_base::L2Dist); + ocl::oclMat oclQuery(query), oclTrain(train); - SUBTEST << size << "; knnMatch"; + TEST_CYCLE() oclMatcher.knnMatch(oclQuery, oclTrain, matches, 2); - matcher.knnMatch(query, train, matches, 2); + std::vector & matches0 = matches[0], & matches1 = matches[1]; + SANITY_CHECK_MATCHES(matches0); + SANITY_CHECK_MATCHES(matches1); + } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); +} - CPU_ON; - matcher.knnMatch(query, train, matches, 2); - CPU_OFF; +//PERF_TEST_P(BruteForceMatcherFixture, knnMatchSingle, +// OCL_BFMATCHER_TYPICAL_MAT_SIZES) +//{ +// const Size srcSize = GetParam(); +// const string impl = getSelectedImpl(); - WARMUP_ON; - d_matcher.knnMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_allDist, 2); - WARMUP_OFF; +// Mat query(srcSize, CV_32F), train(srcSize, CV_32F); +// Mat trainIdx, distance, allDist; - GPU_ON; - d_matcher.knnMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_allDist, 2); - GPU_OFF; +// randu(query, 0.0f, 1.0f); +// randu(train, 0.0f, 1.0f); - GPU_FULL_ON; - d_query.upload(query); - d_train.upload(train); - d_matcher.knnMatch(d_query, d_train, d_matches, 2); - GPU_FULL_OFF; +// if (impl == "plain") +// CV_TEST_FAIL_NO_IMPL(); +// else if (impl == "ocl") +// { +// ocl::oclMat oclQuery(query), oclTrain(train), oclTrainIdx, oclDistance, oclAllDist; - diff = abs((int)d_matches[0].size() - (int)matches[0].size()); - if(diff == 0) - TestSystem::instance().setAccurate(1, 0); - else - TestSystem::instance().setAccurate(0, diff); +// TEST_CYCLE() oclMatcher->knnMatchSingle(oclQuery, oclTrain, oclTrainIdx, oclDistance, oclAllDist, 2); - SUBTEST << size << "; radiusMatch"; +// oclTrainIdx.download(trainIdx); +// oclDistance.download(distance); +// oclAllDist.download(allDist); - float max_distance = 2.0f; +// SANITY_CHECK(trainIdx); +// SANITY_CHECK(distance); +// SANITY_CHECK(allDist); +// } +//#ifdef HAVE_OPENCV_GPU +// else if (impl == "gpu") +// CV_TEST_FAIL_NO_IMPL(); +//#endif +// else +// CV_TEST_FAIL_NO_IMPL(); +//} - matcher.radiusMatch(query, train, matches, max_distance); +PERF_TEST_P(BruteForceMatcherFixture, DISABLED_radiusMatch, + OCL_BFMATCHER_TYPICAL_MAT_SIZES) +{ + const Size srcSize = GetParam(); + const string impl = getSelectedImpl(); - CPU_ON; - matcher.radiusMatch(query, train, matches, max_distance); - CPU_OFF; + const float max_distance = 2.0f; + vector > matches(2); + Mat query(srcSize, CV_32F), train(srcSize, CV_32F); + declare.in(query, train); + Mat trainIdx, distance, allDist; - d_trainIdx.release(); + randu(query, 0.0f, 1.0f); + randu(train, 0.0f, 1.0f); - WARMUP_ON; - d_matcher.radiusMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_nMatches, max_distance); - WARMUP_OFF; + if (impl == "plain") + { + BFMatcher matcher (NORM_L2); + TEST_CYCLE() matcher.radiusMatch(query, matches, max_distance); - GPU_ON; - d_matcher.radiusMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_nMatches, max_distance); - GPU_OFF; + std::vector & matches0 = matches[0], & matches1 = matches[1]; + SANITY_CHECK_MATCHES(matches0); + SANITY_CHECK_MATCHES(matches1); + } + else if (impl == "ocl") + { + ocl::oclMat oclQuery(query), oclTrain(train); + ocl::BruteForceMatcher_OCL_base oclMatcher(ocl::BruteForceMatcher_OCL_base::L2Dist); - GPU_FULL_ON; - d_query.upload(query); - d_train.upload(train); - d_matcher.radiusMatch(d_query, d_train, d_matches, max_distance); - GPU_FULL_OFF; + TEST_CYCLE() oclMatcher.radiusMatch(oclQuery, oclTrain, matches, max_distance); - diff = abs((int)d_matches[0].size() - (int)matches[0].size()); - if(diff == 0) - TestSystem::instance().setAccurate(1, 0); - else - TestSystem::instance().setAccurate(0, diff); + std::vector & matches0 = matches[0], & matches1 = matches[1]; + SANITY_CHECK_MATCHES(matches0); + SANITY_CHECK_MATCHES(matches1); } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); } + +//PERF_TEST_P(BruteForceMatcherFixture, radiusMatchSingle, +// OCL_BFMATCHER_TYPICAL_MAT_SIZES) +//{ +// const Size srcSize = GetParam(); +// const string impl = getSelectedImpl(); + +// const float max_distance = 2.0f; +// Mat query(srcSize, CV_32F), train(srcSize, CV_32F); +// Mat trainIdx, distance, nMatches; + +// randu(query, 0.0f, 1.0f); +// randu(train, 0.0f, 1.0f); + +// if (impl == "plain") +// CV_TEST_FAIL_NO_IMPL(); +// else if (impl == "ocl") +// { +// ocl::oclMat oclQuery(query), oclTrain(train), oclTrainIdx, oclDistance, oclNMatches; + +// TEST_CYCLE() oclMatcher->radiusMatchSingle(oclQuery, oclTrain, oclTrainIdx, oclDistance, oclNMatches, max_distance); + +// oclTrainIdx.download(trainIdx); +// oclDistance.download(distance); +// oclNMatches.download(nMatches); + +// SANITY_CHECK(trainIdx); +// SANITY_CHECK(distance); +// SANITY_CHECK(nMatches); +// } +//#ifdef HAVE_OPENCV_GPU +// else if (impl == "gpu") +// CV_TEST_FAIL_NO_IMPL(); +//#endif +// else +// CV_TEST_FAIL_NO_IMPL(); +//} + +#undef OCL_BFMATCHER_TYPICAL_MAT_SIZES diff --git a/modules/ocl/perf/perf_calib3d.cpp b/modules/ocl/perf/perf_calib3d.cpp index ff6c6f2..7288677 100644 --- a/modules/ocl/perf/perf_calib3d.cpp +++ b/modules/ocl/perf/perf_calib3d.cpp @@ -45,48 +45,49 @@ //M*/ #include "perf_precomp.hpp" + ///////////// StereoMatchBM //////////////////////// -PERFTEST(StereoMatchBM) -{ - Mat left_image = imread(abspath("aloeL.jpg"), cv::IMREAD_GRAYSCALE); - Mat right_image = imread(abspath("aloeR.jpg"), cv::IMREAD_GRAYSCALE); - Mat disp,dst; - ocl::oclMat d_left, d_right,d_disp; - int n_disp= 128; - int winSize =19; - SUBTEST << left_image.cols << 'x' << left_image.rows << "; aloeL.jpg ;"<< right_image.cols << 'x' << right_image.rows << "; aloeR.jpg "; +PERF_TEST(StereoMatchBMFixture, DISABLED_StereoMatchBM) +{ + Mat left_image = imread(getDataPath("gpu/stereobm/aloe-L.png"), cv::IMREAD_GRAYSCALE); + Mat right_image = imread(getDataPath("gpu/stereobm/aloe-R.png"), cv::IMREAD_GRAYSCALE); - StereoBM bm(0, n_disp, winSize); - bm(left_image, right_image, dst); + ASSERT_TRUE(!left_image.empty()) << "no input image"; + ASSERT_TRUE(!right_image.empty()) << "no input image"; + ASSERT_TRUE(right_image.size() == left_image.size()); + ASSERT_TRUE(right_image.size() == left_image.size()); - CPU_ON; - bm(left_image, right_image, dst); - CPU_OFF; + const std::string impl = getSelectedImpl(); + const int n_disp = 128, winSize = 19; + Mat disp(left_image.size(), CV_16SC1); - d_left.upload(left_image); - d_right.upload(right_image); + declare.in(left_image, right_image).out(disp); - ocl::StereoBM_OCL d_bm(0, n_disp, winSize); + if (impl == "ocl") + { + ocl::oclMat oclLeft(left_image), oclRight(right_image), + oclDisp(left_image.size(), CV_16SC1); + ocl::StereoBM_OCL oclBM(0, n_disp, winSize); - WARMUP_ON; - d_bm(d_left, d_right, d_disp); - WARMUP_OFF; + TEST_CYCLE() oclBM(oclLeft, oclRight, oclDisp); - cv::Mat ocl_mat; - d_disp.download(ocl_mat); - ocl_mat.convertTo(ocl_mat, dst.type()); + oclDisp.download(disp); - GPU_ON; - d_bm(d_left, d_right, d_disp); - GPU_OFF; + SANITY_CHECK(disp); + } + else if (impl == "plain") + { + StereoBM bm(0, n_disp, winSize); - GPU_FULL_ON; - d_left.upload(left_image); - d_right.upload(right_image); - d_bm(d_left, d_right, d_disp); - d_disp.download(disp); - GPU_FULL_OFF; + TEST_CYCLE() bm(left_image, right_image, disp); - TestSystem::instance().setAccurate(-1, 0.); + SANITY_CHECK(disp); + } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); + #endif + else + CV_TEST_FAIL_NO_IMPL(); } diff --git a/modules/ocl/perf/perf_canny.cpp b/modules/ocl/perf/perf_canny.cpp index 6f85ee8..34a38ef 100644 --- a/modules/ocl/perf/perf_canny.cpp +++ b/modules/ocl/perf/perf_canny.cpp @@ -45,41 +45,38 @@ //M*/ #include "perf_precomp.hpp" -///////////// Canny //////////////////////// -PERFTEST(Canny) -{ - Mat img = imread(abspath("aloeL.jpg"), CV_LOAD_IMAGE_GRAYSCALE); - - if (img.empty()) - { - throw runtime_error("can't open aloeL.jpg"); - } - - SUBTEST << img.cols << 'x' << img.rows << "; aloeL.jpg" << "; edges" << "; CV_8UC1"; +using namespace perf; - Mat edges(img.size(), CV_8UC1), ocl_edges; +///////////// Canny //////////////////////// - CPU_ON; - Canny(img, edges, 50.0, 100.0); - CPU_OFF; +PERF_TEST(CannyFixture, Canny) +{ + Mat img = imread(getDataPath("gpu/stereobm/aloe-L.png"), cv::IMREAD_GRAYSCALE), + edges(img.size(), CV_8UC1); + ASSERT_TRUE(!img.empty()) << "can't open aloeL.jpg"; - ocl::oclMat d_img(img); - ocl::oclMat d_edges; - ocl::CannyBuf d_buf; + const std::string impl = getSelectedImpl(); + declare.in(img).out(edges); - WARMUP_ON; - ocl::Canny(d_img, d_buf, d_edges, 50.0, 100.0); - WARMUP_OFF; + if (impl == "ocl") + { + ocl::oclMat oclImg(img), oclEdges(img.size(), CV_8UC1); - GPU_ON; - ocl::Canny(d_img, d_buf, d_edges, 50.0, 100.0); - GPU_OFF; + TEST_CYCLE() Canny(oclImg, oclEdges, 50.0, 100.0); + oclEdges.download(edges); - GPU_FULL_ON; - d_img.upload(img); - ocl::Canny(d_img, d_buf, d_edges, 50.0, 100.0); - d_edges.download(ocl_edges); - GPU_FULL_OFF; + SANITY_CHECK(edges); + } + else if (impl == "plain") + { + TEST_CYCLE() Canny(img, edges, 50.0, 100.0); - TestSystem::instance().ExceptedMatSimilar(edges, ocl_edges, 2e-2); + SANITY_CHECK(edges); + } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); } diff --git a/modules/ocl/perf/perf_color.cpp b/modules/ocl/perf/perf_color.cpp index 1934417..645b835 100644 --- a/modules/ocl/perf/perf_color.cpp +++ b/modules/ocl/perf/perf_color.cpp @@ -45,49 +45,39 @@ //M*/ #include "perf_precomp.hpp" -///////////// cvtColor//////////////////////// -PERFTEST(cvtColor) -{ - Mat src, dst, ocl_dst; - ocl::oclMat d_src, d_dst; - - int all_type[] = {CV_8UC4}; - std::string type_name[] = {"CV_8UC4"}; - - for (int size = Min_Size; size <= Max_Size; size *= Multiple) - { - for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++) - { - gen(src, size, size, all_type[j], 0, 256); - SUBTEST << size << "x" << size << "; " << type_name[j] << " ; CV_RGBA2GRAY"; - - cvtColor(src, dst, CV_RGBA2GRAY, 4); - - CPU_ON; - cvtColor(src, dst, CV_RGBA2GRAY, 4); - CPU_OFF; +using namespace perf; - d_src.upload(src); +///////////// cvtColor//////////////////////// - WARMUP_ON; - ocl::cvtColor(d_src, d_dst, CV_RGBA2GRAY, 4); - WARMUP_OFF; +typedef TestBaseWithParam cvtColorFixture; - GPU_ON; - ocl::cvtColor(d_src, d_dst, CV_RGBA2GRAY, 4); - GPU_OFF; +PERF_TEST_P(cvtColorFixture, cvtColor, OCL_TYPICAL_MAT_SIZES) +{ + const Size srcSize = GetParam(); + const std::string impl = getSelectedImpl(); - GPU_FULL_ON; - d_src.upload(src); - ocl::cvtColor(d_src, d_dst, CV_RGBA2GRAY, 4); - d_dst.download(ocl_dst); - GPU_FULL_OFF; + Mat src(srcSize, CV_8UC4), dst(srcSize, CV_8UC4); + declare.in(src).out(dst); - TestSystem::instance().ExceptedMatSimilar(dst, ocl_dst, 1e-5); - } + if (impl == "ocl") + { + ocl::oclMat oclSrc(src), oclDst(src.size(), CV_8UC4); + TEST_CYCLE() ocl::cvtColor(oclSrc, oclDst, CV_RGBA2GRAY, 4); + oclDst.download(dst); + SANITY_CHECK(dst); } + else if (impl == "plain") + { + TEST_CYCLE() cv::cvtColor(src, dst, CV_RGBA2GRAY, 4); - + SANITY_CHECK(dst); + } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); } diff --git a/modules/ocl/perf/perf_fft.cpp b/modules/ocl/perf/perf_fft.cpp index ce9949b..e234509 100644 --- a/modules/ocl/perf/perf_fft.cpp +++ b/modules/ocl/perf/perf_fft.cpp @@ -45,47 +45,43 @@ //M*/ #include "perf_precomp.hpp" -///////////// dft //////////////////////// -PERFTEST(dft) -{ - Mat src, dst, ocl_dst; - ocl::oclMat d_src, d_dst; - - int all_type[] = {CV_32FC2}; - std::string type_name[] = {"CV_32FC2"}; - - for (int size = Min_Size; size <= Max_Size; size *= Multiple) - { - for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++) - { - SUBTEST << size << 'x' << size << "; " << type_name[j] << " ; complex-to-complex"; +using namespace perf; - gen(src, size, size, all_type[j], Scalar::all(0), Scalar::all(1)); +///////////// dft //////////////////////// - dft(src, dst); +typedef TestBaseWithParam dftFixture; - CPU_ON; - dft(src, dst); - CPU_OFF; +PERF_TEST_P(dftFixture, DISABLED_dft, OCL_TYPICAL_MAT_SIZES) +{ + const std::string impl = getSelectedImpl(); + Size srcSize = GetParam(); - d_src.upload(src); + Mat src(srcSize, CV_32FC2), dst; + randu(src, 0.0f, 1.0f); + declare.in(src); - WARMUP_ON; - ocl::dft(d_src, d_dst, Size(size, size)); - WARMUP_OFF; + if (impl == "ocl") + { + ocl::oclMat oclSrc(src), oclDst; - GPU_ON; - ocl::dft(d_src, d_dst, Size(size, size)); - GPU_OFF; + EXPECT_NO_THROW({ + TEST_CYCLE() cv::ocl::dft(oclSrc, oclDst); + }); - GPU_FULL_ON; - d_src.upload(src); - ocl::dft(d_src, d_dst, Size(size, size)); - d_dst.download(ocl_dst); - GPU_FULL_OFF; + oclDst.download(dst); - TestSystem::instance().ExpectedMatNear(dst, ocl_dst, src.size().area() * 1e-4); - } + SANITY_CHECK(dst); + } + else if (impl == "plain") + { + TEST_CYCLE() cv::dft(src, dst); + SANITY_CHECK(dst); } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); } diff --git a/modules/ocl/perf/perf_filters.cpp b/modules/ocl/perf/perf_filters.cpp index e4204cb..3d9be40 100644 --- a/modules/ocl/perf/perf_filters.cpp +++ b/modules/ocl/perf/perf_filters.cpp @@ -45,333 +45,344 @@ //M*/ #include "perf_precomp.hpp" +using namespace perf; +using std::tr1::get; +using std::tr1::tuple; + ///////////// Blur//////////////////////// -PERFTEST(Blur) -{ - Mat src1, dst, ocl_dst; - ocl::oclMat d_src1, d_dst; - Size ksize = Size(3, 3); - int bordertype = BORDER_CONSTANT; - int all_type[] = {CV_8UC1, CV_8UC4}; - std::string type_name[] = {"CV_8UC1", "CV_8UC4"}; +CV_ENUM(BlurMatType, CV_8UC1, CV_8UC4) - for (int size = Min_Size; size <= Max_Size; size *= Multiple) - { - for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++) - { - SUBTEST << size << 'x' << size << "; " << type_name[j] ; +typedef tuple BlurParams; +typedef TestBaseWithParam BlurFixture; - gen(src1, size, size, all_type[j], 0, 256); - gen(dst, size, size, all_type[j], 0, 256); +PERF_TEST_P(BlurFixture, Blur, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + BlurMatType::all())) +{ + // getting params + BlurParams params = GetParam(); + const Size srcSize = get<0>(params), ksize(3, 3); + const int type = get<1>(params), bordertype = BORDER_CONSTANT; - blur(src1, dst, ksize, Point(-1, -1), bordertype); + const std::string impl = getSelectedImpl(); - CPU_ON; - blur(src1, dst, ksize, Point(-1, -1), bordertype); - CPU_OFF; + Mat src(srcSize, type), dst(srcSize, type); + declare.in(src, WARMUP_RNG).out(dst); - d_src1.upload(src1); + if (srcSize == OCL_SIZE_4000 && type == CV_8UC4) + declare.time(5); - WARMUP_ON; - ocl::blur(d_src1, d_dst, ksize, Point(-1, -1), bordertype); - WARMUP_OFF; + if (impl == "ocl") + { + ocl::oclMat oclSrc(src), oclDst(srcSize, type); - GPU_ON; - ocl::blur(d_src1, d_dst, ksize, Point(-1, -1), bordertype); - GPU_OFF; + TEST_CYCLE() cv::ocl::blur(oclSrc, oclDst, ksize, Point(-1, -1), bordertype); - GPU_FULL_ON; - d_src1.upload(src1); - ocl::blur(d_src1, d_dst, ksize, Point(-1, -1), bordertype); - d_dst.download(ocl_dst); - GPU_FULL_OFF; + oclDst.download(dst); - TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1.0); - } + SANITY_CHECK(dst, 1 + DBL_EPSILON); + } + else if (impl == "plain") + { + TEST_CYCLE() cv::blur(src, dst, ksize, Point(-1, -1), bordertype); + SANITY_CHECK(dst, 1 + DBL_EPSILON); } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); } -///////////// Laplacian//////////////////////// -PERFTEST(Laplacian) -{ - Mat src1, dst, ocl_dst; - ocl::oclMat d_src1, d_dst; - int ksize = 3; - int all_type[] = {CV_8UC1, CV_8UC4}; - std::string type_name[] = {"CV_8UC1", "CV_8UC4"}; +///////////// Laplacian//////////////////////// - for (int size = Min_Size; size <= Max_Size; size *= Multiple) - { - for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++) - { - SUBTEST << size << 'x' << size << "; " << type_name[j] ; +typedef BlurMatType LaplacianMatType; +typedef tuple LaplacianParams; +typedef TestBaseWithParam LaplacianFixture; - gen(src1, size, size, all_type[j], 0, 256); - gen(dst, size, size, all_type[j], 0, 256); +PERF_TEST_P(LaplacianFixture, Laplacian, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + LaplacianMatType::all())) +{ + // getting params + LaplacianParams params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params), ksize = 3; - Laplacian(src1, dst, -1, ksize, 1); + const std::string impl = getSelectedImpl(); - CPU_ON; - Laplacian(src1, dst, -1, ksize, 1); - CPU_OFF; + Mat src(srcSize, type), dst(srcSize, type); + declare.in(src, WARMUP_RNG).out(dst); - d_src1.upload(src1); + if (srcSize == OCL_SIZE_4000 && type == CV_8UC4) + declare.time(6); - WARMUP_ON; - ocl::Laplacian(d_src1, d_dst, -1, ksize, 1); - WARMUP_OFF; + if (impl == "ocl") + { + ocl::oclMat oclSrc(src), oclDst(srcSize, type); - GPU_ON; - ocl::Laplacian(d_src1, d_dst, -1, ksize, 1); - GPU_OFF; + TEST_CYCLE() cv::ocl::Laplacian(oclSrc, oclDst, -1, ksize, 1); - GPU_FULL_ON; - d_src1.upload(src1); - ocl::Laplacian(d_src1, d_dst, -1, ksize, 1); - d_dst.download(ocl_dst); - GPU_FULL_OFF; + oclDst.download(dst); - TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1e-5); - } + SANITY_CHECK(dst); + } + else if (impl == "plain") + { + TEST_CYCLE() cv::Laplacian(src, dst, -1, ksize, 1); + SANITY_CHECK(dst); } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); } ///////////// Erode //////////////////// -PERFTEST(Erode) -{ - Mat src, dst, ker, ocl_dst; - ocl::oclMat d_src, d_dst; - int all_type[] = {CV_8UC1, CV_8UC4, CV_32FC1, CV_32FC4}; - std::string type_name[] = {"CV_8UC1", "CV_8UC4", "CV_32FC1", "CV_32FC4"}; +CV_ENUM(ErodeMatType, CV_8UC1, CV_8UC4, CV_32FC1, CV_32FC4) - for (int size = Min_Size; size <= Max_Size; size *= Multiple) - { - for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++) - { - SUBTEST << size << 'x' << size << "; " << type_name[j] ; +typedef tuple ErodeParams; +typedef TestBaseWithParam ErodeFixture; - gen(src, size, size, all_type[j], Scalar::all(0), Scalar::all(256)); - ker = getStructuringElement(MORPH_RECT, Size(3, 3)); +PERF_TEST_P(ErodeFixture, Erode, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + ErodeMatType::all())) +{ + // getting params + ErodeParams params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params), ksize = 3; + const Mat ker = getStructuringElement(MORPH_RECT, Size(ksize, ksize)); - erode(src, dst, ker); + const std::string impl = getSelectedImpl(); - CPU_ON; - erode(src, dst, ker); - CPU_OFF; + Mat src(srcSize, type), dst(srcSize, type); + declare.in(src, WARMUP_RNG).out(dst).in(ker); - d_src.upload(src); + if (srcSize == OCL_SIZE_4000 && type == CV_8UC4) + declare.time(5); - WARMUP_ON; - ocl::erode(d_src, d_dst, ker); - WARMUP_OFF; + if (impl == "ocl") + { + ocl::oclMat oclSrc(src), oclDst(srcSize, type), oclKer(ker); - GPU_ON; - ocl::erode(d_src, d_dst, ker); - GPU_OFF; + TEST_CYCLE() cv::ocl::erode(oclSrc, oclDst, oclKer); - GPU_FULL_ON; - d_src.upload(src); - ocl::erode(d_src, d_dst, ker); - d_dst.download(ocl_dst); - GPU_FULL_OFF; + oclDst.download(dst); - TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1e-5); - } + SANITY_CHECK(dst); + } + else if (impl == "plain") + { + TEST_CYCLE() cv::erode(src, dst, ker); + SANITY_CHECK(dst); } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); } ///////////// Sobel //////////////////////// -PERFTEST(Sobel) -{ - Mat src, dst, ocl_dst; - ocl::oclMat d_src, d_dst; - - int dx = 1; - int dy = 1; - int all_type[] = {CV_8UC1, CV_8UC4}; - std::string type_name[] = {"CV_8UC1", "CV_8UC4"}; - for (int size = Min_Size; size <= Max_Size; size *= Multiple) - { - for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++) - { - SUBTEST << size << 'x' << size << "; " << type_name[j] ; +typedef BlurMatType SobelMatType; +typedef tuple SobelMatParams; +typedef TestBaseWithParam SobelFixture; - gen(src, size, size, all_type[j], 0, 256); +PERF_TEST_P(SobelFixture, Sobel, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + SobelMatType::all())) +{ + // getting params + SobelMatParams params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params), dx = 1, dy = 1; - Sobel(src, dst, -1, dx, dy); + const std::string impl = getSelectedImpl(); - CPU_ON; - Sobel(src, dst, -1, dx, dy); - CPU_OFF; + Mat src(srcSize, type), dst(srcSize, type); + declare.in(src, WARMUP_RNG).out(dst); - d_src.upload(src); + if ((srcSize == OCL_SIZE_2000 && type == CV_8UC4) || + (srcSize == OCL_SIZE_4000 && type == CV_8UC1)) + declare.time(5.5); + else if (srcSize == OCL_SIZE_4000 && type == CV_8UC4) + declare.time(20); - WARMUP_ON; - ocl::Sobel(d_src, d_dst, -1, dx, dy); - WARMUP_OFF; + if (impl == "ocl") + { + ocl::oclMat oclSrc(src), oclDst(srcSize, type); - GPU_ON; - ocl::Sobel(d_src, d_dst, -1, dx, dy); - GPU_OFF; + TEST_CYCLE() cv::ocl::Sobel(oclSrc, oclDst, -1, dx, dy); - GPU_FULL_ON; - d_src.upload(src); - ocl::Sobel(d_src, d_dst, -1, dx, dy); - d_dst.download(ocl_dst); - GPU_FULL_OFF; + oclDst.download(dst); - TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1); - } + SANITY_CHECK(dst); + } + else if (impl == "plain") + { + TEST_CYCLE() cv::Sobel(src, dst, -1, dx, dy); + SANITY_CHECK(dst); } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); } + ///////////// Scharr //////////////////////// -PERFTEST(Scharr) -{ - Mat src, dst, ocl_dst; - ocl::oclMat d_src, d_dst; - int dx = 1; - int dy = 0; - int all_type[] = {CV_8UC1, CV_8UC4}; - std::string type_name[] = {"CV_8UC1", "CV_8UC4"}; +typedef BlurMatType ScharrMatType; +typedef tuple ScharrParams; +typedef TestBaseWithParam ScharrFixture; - for (int size = Min_Size; size <= Max_Size; size *= Multiple) - { - for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++) - { - SUBTEST << size << 'x' << size << "; " << type_name[j] ; - - gen(src, size, size, all_type[j], 0, 256); +PERF_TEST_P(ScharrFixture, Scharr, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + ScharrMatType::all())) +{ + // getting params + ScharrParams params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params), dx = 1, dy = 0; - Scharr(src, dst, -1, dx, dy); + const std::string impl = getSelectedImpl(); - CPU_ON; - Scharr(src, dst, -1, dx, dy); - CPU_OFF; + Mat src(srcSize, type), dst(srcSize, type); + declare.in(src, WARMUP_RNG).out(dst); - d_src.upload(src); + if ((srcSize == OCL_SIZE_2000 && type == CV_8UC4) || + (srcSize == OCL_SIZE_4000 && type == CV_8UC1)) + declare.time(5.5); + else if (srcSize == OCL_SIZE_4000 && type == CV_8UC4) + declare.time(21); - WARMUP_ON; - ocl::Scharr(d_src, d_dst, -1, dx, dy); - WARMUP_OFF; + if (impl == "ocl") + { + ocl::oclMat oclSrc(src), oclDst(srcSize, type); - GPU_ON; - ocl::Scharr(d_src, d_dst, -1, dx, dy); - GPU_OFF; + TEST_CYCLE() cv::ocl::Scharr(oclSrc, oclDst, -1, dx, dy); - GPU_FULL_ON; - d_src.upload(src); - ocl::Scharr(d_src, d_dst, -1, dx, dy); - d_dst.download(ocl_dst); - GPU_FULL_OFF; + oclDst.download(dst); - TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1); - } + SANITY_CHECK(dst); + } + else if (impl == "plain") + { + TEST_CYCLE() cv::Scharr(src, dst, -1, dx, dy); + SANITY_CHECK(dst); } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); } ///////////// GaussianBlur //////////////////////// -PERFTEST(GaussianBlur) -{ - Mat src, dst, ocl_dst; - int all_type[] = {CV_8UC1, CV_8UC4, CV_32FC1, CV_32FC4}; - std::string type_name[] = {"CV_8UC1", "CV_8UC4", "CV_32FC1", "CV_32FC4"}; - const int ksize = 7; - for (int size = Min_Size; size <= Max_Size; size *= Multiple) - { - for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++) - { - SUBTEST << size << 'x' << size << "; " << type_name[j] ; +typedef ErodeMatType GaussianBlurMatType; +typedef tuple GaussianBlurParams; +typedef TestBaseWithParam GaussianBlurFixture; - gen(src, size, size, all_type[j], 0, 256); +PERF_TEST_P(GaussianBlurFixture, GaussianBlur, + ::testing::Combine(::testing::Values(OCL_SIZE_1000, OCL_SIZE_2000), + GaussianBlurMatType::all())) +{ + // getting params + GaussianBlurParams params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params), ksize = 7; - GaussianBlur(src, dst, Size(ksize, ksize), 0); + const std::string impl = getSelectedImpl(); - CPU_ON; - GaussianBlur(src, dst, Size(ksize, ksize), 0); - CPU_OFF; + Mat src(srcSize, type), dst(srcSize, type); + declare.in(src, WARMUP_RNG).out(dst); - ocl::oclMat d_src(src); - ocl::oclMat d_dst; + const double eps = src.depth() == CV_8U ? 1 + DBL_EPSILON : 3e-4; - WARMUP_ON; - ocl::GaussianBlur(d_src, d_dst, Size(ksize, ksize), 0); - WARMUP_OFF; + if (impl == "ocl") + { + ocl::oclMat oclSrc(src), oclDst(srcSize, type); - GPU_ON; - ocl::GaussianBlur(d_src, d_dst, Size(ksize, ksize), 0); - GPU_OFF; + TEST_CYCLE() cv::ocl::GaussianBlur(oclSrc, oclDst, Size(ksize, ksize), 0); - GPU_FULL_ON; - d_src.upload(src); - ocl::GaussianBlur(d_src, d_dst, Size(ksize, ksize), 0); - d_dst.download(ocl_dst); - GPU_FULL_OFF; + oclDst.download(dst); - TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1.0); - } + SANITY_CHECK(dst, eps); + } + else if (impl == "plain") + { + TEST_CYCLE() cv::GaussianBlur(src, dst, Size(ksize, ksize), 0); + SANITY_CHECK(dst, eps); } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); } ///////////// filter2D//////////////////////// -PERFTEST(filter2D) -{ - Mat src; - - for (int size = Min_Size; size <= Max_Size; size *= Multiple) - { - int all_type[] = {CV_8UC1, CV_8UC4}; - std::string type_name[] = {"CV_8UC1", "CV_8UC4"}; - - for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++) - { - gen(src, size, size, all_type[j], 0, 256); - - const int ksize = 3; - - SUBTEST << "ksize = " << ksize << "; " << size << 'x' << size << "; " << type_name[j] ; - Mat kernel; - gen(kernel, ksize, ksize, CV_32SC1, -3.0, 3.0); +typedef BlurMatType filter2DMatType; +typedef tuple filter2DParams; +typedef TestBaseWithParam filter2DFixture; - Mat dst, ocl_dst; - - cv::filter2D(src, dst, -1, kernel); - - CPU_ON; - cv::filter2D(src, dst, -1, kernel); - CPU_OFF; +PERF_TEST_P(filter2DFixture, filter2D, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + filter2DMatType::all())) +{ + // getting params + filter2DParams params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params), ksize = 3; - ocl::oclMat d_src(src), d_dst; + const std::string impl = getSelectedImpl(); - WARMUP_ON; - ocl::filter2D(d_src, d_dst, -1, kernel); - WARMUP_OFF; + Mat src(srcSize, type), dst(srcSize, type), kernel(ksize, ksize, CV_32SC1); + declare.in(src, WARMUP_RNG).in(kernel).out(dst); + randu(kernel, -3.0, 3.0); - GPU_ON; - ocl::filter2D(d_src, d_dst, -1, kernel); - GPU_OFF; + if (srcSize == OCL_SIZE_4000 && type == CV_8UC4) + declare.time(8); - GPU_FULL_ON; - d_src.upload(src); - ocl::filter2D(d_src, d_dst, -1, kernel); - d_dst.download(ocl_dst); - GPU_FULL_OFF; + if (impl == "ocl") + { + ocl::oclMat oclSrc(src), oclDst(srcSize, type), oclKernel(kernel); - TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1e-5); + TEST_CYCLE() cv::ocl::filter2D(oclSrc, oclDst, -1, oclKernel); - } + oclDst.download(dst); + SANITY_CHECK(dst); + } + else if (impl == "plain") + { + TEST_CYCLE() cv::filter2D(src, dst, -1, kernel); + SANITY_CHECK(dst); } + #ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); } diff --git a/modules/ocl/perf/perf_gemm.cpp b/modules/ocl/perf/perf_gemm.cpp index aa04b9c..1e765e8 100644 --- a/modules/ocl/perf/perf_gemm.cpp +++ b/modules/ocl/perf/perf_gemm.cpp @@ -45,46 +45,46 @@ //M*/ #include "perf_precomp.hpp" -///////////// gemm //////////////////////// -PERFTEST(gemm) -{ - Mat src1, src2, src3, dst, ocl_dst; - ocl::oclMat d_src1, d_src2, d_src3, d_dst; +using namespace perf; - for (int size = Min_Size; size <= Max_Size; size *= Multiple) - { - SUBTEST << size << 'x' << size; +///////////// gemm //////////////////////// - gen(src1, size, size, CV_32FC1, Scalar::all(-10), Scalar::all(10)); - gen(src2, size, size, CV_32FC1, Scalar::all(-10), Scalar::all(10)); - gen(src3, size, size, CV_32FC1, Scalar::all(-10), Scalar::all(10)); +typedef TestBaseWithParam gemmFixture; - gemm(src1, src2, 1.0, src3, 1.0, dst); +PERF_TEST_P(gemmFixture, DISABLED_gemm, OCL_TYPICAL_MAT_SIZES) +{ + // getting params + const Size srcSize = GetParam(); + const std::string impl = getSelectedImpl(); - CPU_ON; - gemm(src1, src2, 1.0, src3, 1.0, dst); - CPU_OFF; + Mat src1(srcSize, CV_32FC1), src2(srcSize, CV_32FC1), + src3(srcSize, CV_32FC1), dst(srcSize, CV_32FC1); + declare.in(src1, src2, src3).out(dst); + randu(src1, -10.0f, 10.0f); + randu(src2, -10.0f, 10.0f); + randu(src3, -10.0f, 10.0f); - d_src1.upload(src1); - d_src2.upload(src2); - d_src3.upload(src3); + if (impl == "ocl") + { + ocl::oclMat oclSrc1(src1), oclSrc2(src2), + oclSrc3(src3), oclDst(srcSize, CV_32FC1); - WARMUP_ON; - ocl::gemm(d_src1, d_src2, 1.0, d_src3, 1.0, d_dst); - WARMUP_OFF; + TEST_CYCLE() cv::ocl::gemm(oclSrc1, oclSrc2, 1.0, oclSrc3, 1.0, oclDst); - GPU_ON; - ocl::gemm(d_src1, d_src2, 1.0, d_src3, 1.0, d_dst); - GPU_OFF; + oclDst.download(dst); - GPU_FULL_ON; - d_src1.upload(src1); - d_src2.upload(src2); - d_src3.upload(src3); - ocl::gemm(d_src1, d_src2, 1.0, d_src3, 1.0, d_dst); - d_dst.download(ocl_dst); - GPU_FULL_OFF; + SANITY_CHECK(dst); + } + else if (impl == "plain") + { + TEST_CYCLE() cv::gemm(src1, src2, 1.0, src3, 1.0, dst); - TestSystem::instance().ExpectedMatNear(ocl_dst, dst, src1.cols * src1.rows * 1e-4); + SANITY_CHECK(dst); } + #ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); } diff --git a/modules/ocl/perf/perf_gftt.cpp b/modules/ocl/perf/perf_gftt.cpp index 430d441..a314fc0 100644 --- a/modules/ocl/perf/perf_gftt.cpp +++ b/modules/ocl/perf/perf_gftt.cpp @@ -46,56 +46,54 @@ #include "perf_precomp.hpp" -///////////// GoodFeaturesToTrack //////////////////////// -PERFTEST(GoodFeaturesToTrack) -{ - using namespace cv; - - int maxCorners = 2000; - double qualityLevel = 0.01; - - std::string images[] = { "rubberwhale1.png", "aloeL.jpg" }; - - std::vector pts_gold, pts_ocl; - - for(size_t imgIdx = 0; imgIdx < (sizeof(images)/sizeof(std::string)); ++imgIdx) - { - Mat frame = imread(abspath(images[imgIdx]), IMREAD_GRAYSCALE); - CV_Assert(!frame.empty()); +using namespace perf; +using std::tr1::tuple; +using std::tr1::get; - for(float minDistance = 0; minDistance < 4; minDistance += 3.0) - { - SUBTEST << "image = " << images[imgIdx] << "; "; - SUBTEST << "minDistance = " << minDistance << "; "; +///////////// GoodFeaturesToTrack //////////////////////// - cv::goodFeaturesToTrack(frame, pts_gold, maxCorners, qualityLevel, minDistance); +typedef tuple GoodFeaturesToTrackParams; +typedef TestBaseWithParam GoodFeaturesToTrackFixture; - CPU_ON; - cv::goodFeaturesToTrack(frame, pts_gold, maxCorners, qualityLevel, minDistance); - CPU_OFF; +PERF_TEST_P(GoodFeaturesToTrackFixture, GoodFeaturesToTrack, + ::testing::Combine(::testing::Values(string("gpu/opticalflow/rubberwhale1.png"), + string("gpu/stereobm/aloe-L.png")), + ::testing::Range(0.0, 4.0, 3.0))) +{ + std::vector pts_gold; - cv::ocl::GoodFeaturesToTrackDetector_OCL detector(maxCorners, qualityLevel, minDistance); + // getting params + GoodFeaturesToTrackParams param = GetParam(); + const string fileName = getDataPath(get<0>(param)), impl = getSelectedImpl(); + const int maxCorners = 2000; + const double qualityLevel = 0.01, minDistance = get<1>(param); - ocl::oclMat frame_ocl(frame), pts_oclmat; + Mat frame = imread(fileName, IMREAD_GRAYSCALE); + declare.in(frame); + ASSERT_TRUE(!frame.empty()) << "no input image"; - WARMUP_ON; - detector(frame_ocl, pts_oclmat); - WARMUP_OFF; + if (impl == "ocl") + { + ocl::oclMat oclFrame(frame), pts_oclmat; + cv::ocl::GoodFeaturesToTrackDetector_OCL detector(maxCorners, qualityLevel, minDistance); - detector.downloadPoints(pts_oclmat, pts_ocl); + TEST_CYCLE() detector(oclFrame, pts_oclmat); - double diff = abs(static_cast(pts_gold.size() - pts_ocl.size())); - TestSystem::instance().setAccurate(diff == 0.0, diff); + detector.downloadPoints(pts_oclmat, pts_gold); - GPU_ON; - detector(frame_ocl, pts_oclmat); - GPU_OFF; + SANITY_CHECK(pts_gold); + } + else if (impl == "plain") + { + TEST_CYCLE() cv::goodFeaturesToTrack(frame, pts_gold, + maxCorners, qualityLevel, minDistance); - GPU_FULL_ON; - frame_ocl.upload(frame); - detector(frame_ocl, pts_oclmat); - detector.downloadPoints(pts_oclmat, pts_ocl); - GPU_FULL_OFF; - } + SANITY_CHECK(pts_gold); } + #ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); } diff --git a/modules/ocl/perf/perf_haar.cpp b/modules/ocl/perf/perf_haar.cpp index ea1a474..38917a0 100644 --- a/modules/ocl/perf/perf_haar.cpp +++ b/modules/ocl/perf/perf_haar.cpp @@ -45,6 +45,8 @@ //M*/ #include "perf_precomp.hpp" +using namespace perf; + ///////////// Haar //////////////////////// namespace cv { @@ -83,61 +85,45 @@ public: } } -PERFTEST(Haar) -{ - Mat img = imread(abspath("basketball1.png"), CV_LOAD_IMAGE_GRAYSCALE); - if (img.empty()) - { - throw runtime_error("can't open basketball1.png"); - } +PERF_TEST(HaarFixture, Haar) +{ + const std::string impl = getSelectedImpl(); + vector faces; - CascadeClassifier faceCascadeCPU; + Mat img = imread(getDataPath("gpu/haarcascade/basketball1.png"), CV_LOAD_IMAGE_GRAYSCALE); + ASSERT_TRUE(!img.empty()) << "can't open basketball1.png"; + declare.in(img); - if (!faceCascadeCPU.load(abspath("haarcascade_frontalface_alt.xml"))) + if (impl == "plain") { - throw runtime_error("can't load haarcascade_frontalface_alt.xml"); - } + CascadeClassifier faceCascade; + ASSERT_TRUE(faceCascade.load(getDataPath("gpu/haarcascade/haarcascade_frontalface_alt.xml"))) + << "can't load haarcascade_frontalface_alt.xml"; - vector faces; + TEST_CYCLE() faceCascade.detectMultiScale(img, faces, + 1.1, 2, 0 | CV_HAAR_SCALE_IMAGE, Size(30, 30)); - SUBTEST << img.cols << "x" << img.rows << "; scale image"; - CPU_ON; - faceCascadeCPU.detectMultiScale(img, faces, - 1.1, 2, 0 | CV_HAAR_SCALE_IMAGE, Size(30, 30)); - CPU_OFF; + SANITY_CHECK(faces, 4 + 1e-4); + } + else if (impl == "ocl") + { + ocl::CascadeClassifier_GPU faceCascade; + ocl::oclMat oclImg(img); + ASSERT_TRUE(faceCascade.load(getDataPath("gpu/haarcascade/haarcascade_frontalface_alt.xml"))) + << "can't load haarcascade_frontalface_alt.xml"; - vector oclfaces; - ocl::CascadeClassifier_GPU faceCascade; + TEST_CYCLE() faceCascade.detectMultiScale(oclImg, faces, + 1.1, 2, 0 | CV_HAAR_SCALE_IMAGE, Size(30, 30)); - if (!faceCascade.load(abspath("haarcascade_frontalface_alt.xml"))) - { - throw runtime_error("can't load haarcascade_frontalface_alt.xml"); + SANITY_CHECK(faces, 4 + 1e-4); } - ocl::oclMat d_img(img); - - WARMUP_ON; - faceCascade.detectMultiScale(d_img, oclfaces, - 1.1, 2, 0 | CV_HAAR_SCALE_IMAGE, Size(30, 30)); - WARMUP_OFF; - - if(faces.size() == oclfaces.size()) - TestSystem::instance().setAccurate(1, 0); +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif else - TestSystem::instance().setAccurate(0, abs((int)faces.size() - (int)oclfaces.size())); - - faces.clear(); - - GPU_ON; - faceCascade.detectMultiScale(d_img, oclfaces, - 1.1, 2, 0 | CV_HAAR_SCALE_IMAGE, Size(30, 30)); - GPU_OFF; - - GPU_FULL_ON; - d_img.upload(img); - faceCascade.detectMultiScale(d_img, oclfaces, - 1.1, 2, 0 | CV_HAAR_SCALE_IMAGE, Size(30, 30)); - GPU_FULL_OFF; + CV_TEST_FAIL_NO_IMPL(); } diff --git a/modules/ocl/perf/perf_hog.cpp b/modules/ocl/perf/perf_hog.cpp index e6d85b5..9f0dab9 100644 --- a/modules/ocl/perf/perf_hog.cpp +++ b/modules/ocl/perf/perf_hog.cpp @@ -45,50 +45,42 @@ //M*/ #include "perf_precomp.hpp" +using namespace perf; + ///////////// HOG//////////////////////// -PERFTEST(HOG) +PERF_TEST(HOGFixture, HOG) { - Mat src = imread(abspath("road.png"), cv::IMREAD_GRAYSCALE); - - if (src.empty()) - { - throw runtime_error("can't open road.png"); - } + Mat src = imread(getDataPath("gpu/hog/road.png"), cv::IMREAD_GRAYSCALE); + ASSERT_TRUE(!src.empty()) << "can't open input image road.png"; - cv::HOGDescriptor hog; - hog.setSVMDetector(hog.getDefaultPeopleDetector()); + const std::string impl = getSelectedImpl(); std::vector found_locations; - std::vector d_found_locations; - - SUBTEST << src.cols << 'x' << src.rows << "; road.png"; + declare.in(src).time(5); - hog.detectMultiScale(src, found_locations); + if (impl == "plain") + { + cv::HOGDescriptor hog; + hog.setSVMDetector(hog.getDefaultPeopleDetector()); - CPU_ON; - hog.detectMultiScale(src, found_locations); - CPU_OFF; + TEST_CYCLE() hog.detectMultiScale(src, found_locations); - cv::ocl::HOGDescriptor ocl_hog; - ocl_hog.setSVMDetector(ocl_hog.getDefaultPeopleDetector()); - ocl::oclMat d_src; - d_src.upload(src); + SANITY_CHECK(found_locations, 1 + DBL_EPSILON); + } + else if (impl == "ocl") + { + cv::ocl::HOGDescriptor ocl_hog; + ocl_hog.setSVMDetector(ocl_hog.getDefaultPeopleDetector()); + ocl::oclMat oclSrc(src); - WARMUP_ON; - ocl_hog.detectMultiScale(d_src, d_found_locations); - WARMUP_OFF; + TEST_CYCLE() ocl_hog.detectMultiScale(oclSrc, found_locations); - if(d_found_locations.size() == found_locations.size()) - TestSystem::instance().setAccurate(1, 0); + SANITY_CHECK(found_locations, 1 + DBL_EPSILON); + } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif else - TestSystem::instance().setAccurate(0, abs((int)found_locations.size() - (int)d_found_locations.size())); - - GPU_ON; - ocl_hog.detectMultiScale(d_src, found_locations); - GPU_OFF; - - GPU_FULL_ON; - d_src.upload(src); - ocl_hog.detectMultiScale(d_src, found_locations); - GPU_FULL_OFF; + CV_TEST_FAIL_NO_IMPL(); } diff --git a/modules/ocl/perf/perf_imgproc.cpp b/modules/ocl/perf/perf_imgproc.cpp index 2ed64ce..b333078 100644 --- a/modules/ocl/perf/perf_imgproc.cpp +++ b/modules/ocl/perf/perf_imgproc.cpp @@ -45,295 +45,299 @@ //M*/ #include "perf_precomp.hpp" -///////////// equalizeHist //////////////////////// -PERFTEST(equalizeHist) -{ - Mat src, dst, ocl_dst; - int all_type[] = {CV_8UC1}; - std::string type_name[] = {"CV_8UC1"}; +using namespace perf; +using std::tr1::tuple; +using std::tr1::get; - for (int size = Min_Size; size <= Max_Size; size *= Multiple) - { - for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++) - { - SUBTEST << size << 'x' << size << "; " << type_name[j] ; - - gen(src, size, size, all_type[j], 0, 256); - - equalizeHist(src, dst); +///////////// equalizeHist //////////////////////// - CPU_ON; - equalizeHist(src, dst); - CPU_OFF; +typedef TestBaseWithParam equalizeHistFixture; - ocl::oclMat d_src(src); - ocl::oclMat d_dst; - ocl::oclMat d_hist; - ocl::oclMat d_buf; +PERF_TEST_P(equalizeHistFixture, equalizeHist, OCL_TYPICAL_MAT_SIZES) +{ + // getting params + const Size srcSize = GetParam(); + const string impl = getSelectedImpl(); - WARMUP_ON; - ocl::equalizeHist(d_src, d_dst); - WARMUP_OFF; + // creating src data + Mat src(srcSize, CV_8UC1), dst(srcSize, CV_8UC1); + declare.in(src, WARMUP_RNG).out(dst); - GPU_ON; - ocl::equalizeHist(d_src, d_dst); - GPU_OFF; + // select implementation + if (impl == "ocl") + { + ocl::oclMat oclSrc(src), oclDst(srcSize, src.type()); - GPU_FULL_ON; - d_src.upload(src); - ocl::equalizeHist(d_src, d_dst); - d_dst.download(ocl_dst); - GPU_FULL_OFF; + TEST_CYCLE() cv::ocl::equalizeHist(oclSrc, oclDst); - TestSystem::instance().ExpectedMatNear(dst, ocl_dst, 1.1); - } + oclDst.download(dst); + SANITY_CHECK(dst, 1 + DBL_EPSILON); } -} -/////////// CopyMakeBorder ////////////////////// -PERFTEST(CopyMakeBorder) -{ - Mat src, dst, ocl_dst; - ocl::oclMat d_dst; - - int bordertype = BORDER_CONSTANT; - int all_type[] = {CV_8UC1, CV_8UC4}; - std::string type_name[] = {"CV_8UC1", "CV_8UC4"}; - - for (int size = Min_Size; size <= Max_Size; size *= Multiple) + else if (impl == "plain") { - for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++) - { - SUBTEST << size << 'x' << size << "; " << type_name[j] ; + TEST_CYCLE() cv::equalizeHist(src, dst); + SANITY_CHECK(dst, 1 + DBL_EPSILON); + } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); +} - gen(src, size, size, all_type[j], 0, 256); - - copyMakeBorder(src, dst, 7, 5, 5, 7, bordertype, cv::Scalar(1.0)); +/////////// CopyMakeBorder ////////////////////// - CPU_ON; - copyMakeBorder(src, dst, 7, 5, 5, 7, bordertype, cv::Scalar(1.0)); - CPU_OFF; +CV_ENUM(CopyMakeBorderMatType, CV_8UC1, CV_8UC4) - ocl::oclMat d_src(src); +typedef tuple CopyMakeBorderParams; +typedef TestBaseWithParam CopyMakeBorderFixture; - WARMUP_ON; - ocl::copyMakeBorder(d_src, d_dst, 7, 5, 5, 7, bordertype, cv::Scalar(1.0)); - WARMUP_OFF; +PERF_TEST_P(CopyMakeBorderFixture, CopyMakeBorder, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + CopyMakeBorderMatType::all())) +{ + // getting params + CopyMakeBorderParams params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params), borderType = BORDER_CONSTANT; + const string impl = getSelectedImpl(); + + // creating src data + Mat src(srcSize, type), dst; + const Size dstSize = srcSize + Size(12, 12); + dst.create(dstSize, type); + declare.in(src, WARMUP_RNG).out(dst); + + // select implementation + if (impl == "ocl") + { + ocl::oclMat oclSrc(src), oclDst(dstSize, type); - GPU_ON; - ocl::copyMakeBorder(d_src, d_dst, 7, 5, 5, 7, bordertype, cv::Scalar(1.0)); - GPU_OFF; + TEST_CYCLE() cv::ocl::copyMakeBorder(oclSrc, oclDst, 7, 5, 5, 7, borderType, cv::Scalar(1.0)); - GPU_FULL_ON; - d_src.upload(src); - ocl::copyMakeBorder(d_src, d_dst, 7, 5, 5, 7, bordertype, cv::Scalar(1.0)); - d_dst.download(ocl_dst); - GPU_FULL_OFF; + oclDst.download(dst); - TestSystem::instance().ExpectedMatNear(dst, ocl_dst, 0.0); - } + SANITY_CHECK(dst); + } + else if (impl == "plain") + { + TEST_CYCLE() cv::copyMakeBorder(src, dst, 7, 5, 5, 7, borderType, cv::Scalar(1.0)); + SANITY_CHECK(dst); } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); } -///////////// cornerMinEigenVal //////////////////////// -PERFTEST(cornerMinEigenVal) -{ - Mat src, dst, ocl_dst; - ocl::oclMat d_dst; - int blockSize = 7, apertureSize = 1 + 2 * (rand() % 4); - int borderType = BORDER_REFLECT; - int all_type[] = {CV_8UC1, CV_32FC1}; - std::string type_name[] = {"CV_8UC1", "CV_32FC1"}; +///////////// cornerMinEigenVal //////////////////////// - for (int size = Min_Size; size <= Max_Size; size *= Multiple) - { - for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++) - { - SUBTEST << size << 'x' << size << "; " << type_name[j] ; +CV_ENUM(cornerMinEigenValMatType, CV_8UC1, CV_32FC1) - gen(src, size, size, all_type[j], 0, 256); +typedef tuple cornerMinEigenValParams; +typedef TestBaseWithParam cornerMinEigenValFixture; - cornerMinEigenVal(src, dst, blockSize, apertureSize, borderType); +PERF_TEST_P(cornerMinEigenValFixture, cornerMinEigenVal, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + cornerMinEigenValMatType::all())) +{ + // getting params + cornerMinEigenValParams params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params), borderType = BORDER_REFLECT; + const int blockSize = 7, apertureSize = 1 + 2 * 3; - CPU_ON; - cornerMinEigenVal(src, dst, blockSize, apertureSize, borderType); - CPU_OFF; + const string impl = getSelectedImpl(); - ocl::oclMat d_src(src); + // creating src data + Mat src(srcSize, type), dst(srcSize, CV_32FC1); + declare.in(src, WARMUP_RNG).out(dst) + .time(srcSize == OCL_SIZE_4000 ? 20 : srcSize == OCL_SIZE_2000 ? 5 : 3); - WARMUP_ON; - ocl::cornerMinEigenVal(d_src, d_dst, blockSize, apertureSize, borderType); - WARMUP_OFF; + const int depth = CV_MAT_DEPTH(type); + const ERROR_TYPE errorType = depth == CV_8U ? ERROR_ABSOLUTE : ERROR_RELATIVE; - GPU_ON; - ocl::cornerMinEigenVal(d_src, d_dst, blockSize, apertureSize, borderType); - GPU_OFF; + // select implementation + if (impl == "ocl") + { + ocl::oclMat oclSrc(src), oclDst(srcSize, CV_32FC1); - GPU_FULL_ON; - d_src.upload(src); - ocl::cornerMinEigenVal(d_src, d_dst, blockSize, apertureSize, borderType); - d_dst.download(ocl_dst); - GPU_FULL_OFF; + TEST_CYCLE() cv::ocl::cornerMinEigenVal(oclSrc, oclDst, blockSize, apertureSize, borderType); - TestSystem::instance().ExpectedMatNear(dst, ocl_dst, 1.0); - } + oclDst.download(dst); + SANITY_CHECK(dst, 1e-6, errorType); } -} -///////////// cornerHarris //////////////////////// -PERFTEST(cornerHarris) -{ - Mat src, dst, ocl_dst; - ocl::oclMat d_src, d_dst; - - int all_type[] = {CV_8UC1, CV_32FC1}; - std::string type_name[] = {"CV_8UC1", "CV_32FC1"}; - - for (int size = Min_Size; size <= Max_Size; size *= Multiple) + else if (impl == "plain") { - for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++) - { - SUBTEST << size << 'x' << size << "; " << type_name[j] << " ; BORDER_REFLECT"; + TEST_CYCLE() cv::cornerMinEigenVal(src, dst, blockSize, apertureSize, borderType); - gen(src, size, size, all_type[j], 0, 1); + SANITY_CHECK(dst, 1e-6, errorType); + } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); +} - cornerHarris(src, dst, 5, 7, 0.1, BORDER_REFLECT); +///////////// cornerHarris //////////////////////// - CPU_ON; - cornerHarris(src, dst, 5, 7, 0.1, BORDER_REFLECT); - CPU_OFF; +typedef cornerMinEigenValMatType cornerHarrisMatType; +typedef tuple cornerHarrisParams; +typedef TestBaseWithParam cornerHarrisFixture; - d_src.upload(src); +PERF_TEST_P(cornerHarrisFixture, cornerHarris, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + cornerHarrisMatType::all())) +{ + // getting params + cornerHarrisParams params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params), borderType = BORDER_REFLECT; - WARMUP_ON; - ocl::cornerHarris(d_src, d_dst, 5, 7, 0.1, BORDER_REFLECT); - WARMUP_OFF; + const string impl = getSelectedImpl(); - GPU_ON; - ocl::cornerHarris(d_src, d_dst, 5, 7, 0.1, BORDER_REFLECT); - GPU_OFF; + // creating src data + Mat src(srcSize, type), dst(srcSize, CV_32FC1); + randu(src, 0, 1); + declare.in(src).out(dst) + .time(srcSize == OCL_SIZE_4000 ? 20 : srcSize == OCL_SIZE_2000 ? 5 : 3); - GPU_FULL_ON; - d_src.upload(src); - ocl::cornerHarris(d_src, d_dst, 5, 7, 0.1, BORDER_REFLECT); - d_dst.download(ocl_dst); - GPU_FULL_OFF; + // select implementation + if (impl == "ocl") + { + ocl::oclMat oclSrc(src), oclDst(srcSize, CV_32FC1); - TestSystem::instance().ExpectedMatNear(dst, ocl_dst, 1.0); - } + TEST_CYCLE() cv::ocl::cornerHarris(oclSrc, oclDst, 5, 7, 0.1, borderType); + oclDst.download(dst); + SANITY_CHECK(dst, 3e-5); } -} -///////////// integral //////////////////////// -PERFTEST(integral) -{ - Mat src, sum, ocl_sum; - ocl::oclMat d_src, d_sum, d_buf; - - int all_type[] = {CV_8UC1}; - std::string type_name[] = {"CV_8UC1"}; - - for (int size = Min_Size; size <= Max_Size; size *= Multiple) + else if (impl == "plain") { - for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++) - { - SUBTEST << size << 'x' << size << "; " << type_name[j] ; + TEST_CYCLE() cv::cornerHarris(src, dst, 5, 7, 0.1, borderType); - gen(src, size, size, all_type[j], 0, 256); + SANITY_CHECK(dst, 3e-5); + } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); +} - integral(src, sum); +///////////// integral //////////////////////// - CPU_ON; - integral(src, sum); - CPU_OFF; +typedef TestBaseWithParam integralFixture; - d_src.upload(src); +PERF_TEST_P(integralFixture, DISABLED_integral, OCL_TYPICAL_MAT_SIZES) +{ + // getting params + const Size srcSize = GetParam(); + const string impl = getSelectedImpl(); - WARMUP_ON; - ocl::integral(d_src, d_sum); - WARMUP_OFF; + // creating src data + Mat src(srcSize, CV_8UC1), dst; + declare.in(src, WARMUP_RNG); - GPU_ON; - ocl::integral(d_src, d_sum); - GPU_OFF; + // select implementation + if (impl == "ocl") + { + ocl::oclMat oclSrc(src), oclDst; - GPU_FULL_ON; - d_src.upload(src); - ocl::integral(d_src, d_sum); - d_sum.download(ocl_sum); - GPU_FULL_OFF; + TEST_CYCLE() cv::ocl::integral(oclSrc, oclDst); - if(sum.type() == ocl_sum.type()) //we won't test accuracy when cpu function overlow - TestSystem::instance().ExpectedMatNear(sum, ocl_sum, 0.0); + oclDst.download(dst); - } + SANITY_CHECK(dst); + } + else if (impl == "plain") + { + TEST_CYCLE() cv::integral(src, dst); + SANITY_CHECK(dst); } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); } + ///////////// WarpAffine //////////////////////// -PERFTEST(WarpAffine) -{ - Mat src, dst, ocl_dst; - ocl::oclMat d_src, d_dst; +typedef CopyMakeBorderMatType WarpAffineMatType; +typedef tuple WarpAffineParams; +typedef TestBaseWithParam WarpAffineFixture; + +PERF_TEST_P(WarpAffineFixture, WarpAffine, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + WarpAffineMatType::all())) +{ static const double coeffs[2][3] = { - {cos(CV_PI / 6), -sin(CV_PI / 6), 100.0}, - {sin(CV_PI / 6), cos(CV_PI / 6), -100.0} + { cos(CV_PI / 6), -sin(CV_PI / 6), 100.0 }, + { sin(CV_PI / 6), cos(CV_PI / 6), -100.0 } }; Mat M(2, 3, CV_64F, (void *)coeffs); - int interpolation = INTER_NEAREST; + const int interpolation = INTER_NEAREST; - int all_type[] = {CV_8UC1, CV_8UC4}; - std::string type_name[] = {"CV_8UC1", "CV_8UC4"}; + // getting params + WarpAffineParams params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params); + const string impl = getSelectedImpl(); + // creating src data + Mat src(srcSize, type), dst(srcSize, type); + declare.in(src, WARMUP_RNG).out(dst); - for (int size = Min_Size; size <= Max_Size; size *= Multiple) + // select implementation + if (impl == "ocl") { - for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++) - { - SUBTEST << size << 'x' << size << "; " << type_name[j] ; - - gen(src, size, size, all_type[j], 0, 256); - gen(dst, size, size, all_type[j], 0, 256); - Size size1 = Size(size, size); - - warpAffine(src, dst, M, size1, interpolation); - - CPU_ON; - warpAffine(src, dst, M, size1, interpolation); - CPU_OFF; - - d_src.upload(src); + ocl::oclMat oclSrc(src), oclDst(srcSize, type); - WARMUP_ON; - ocl::warpAffine(d_src, d_dst, M, size1, interpolation); - WARMUP_OFF; + TEST_CYCLE() cv::ocl::warpAffine(oclSrc, oclDst, M, srcSize, interpolation); - GPU_ON; - ocl::warpAffine(d_src, d_dst, M, size1, interpolation); - GPU_OFF; + oclDst.download(dst); - GPU_FULL_ON; - d_src.upload(src); - ocl::warpAffine(d_src, d_dst, M, size1, interpolation); - d_dst.download(ocl_dst); - GPU_FULL_OFF; - - TestSystem::instance().ExpectedMatNear(dst, ocl_dst, 1.0); - } + SANITY_CHECK(dst); + } + else if (impl == "plain") + { + TEST_CYCLE() cv::warpAffine(src, dst, M, srcSize, interpolation); + SANITY_CHECK(dst); } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); } + ///////////// WarpPerspective //////////////////////// -PERFTEST(WarpPerspective) -{ - Mat src, dst, ocl_dst; - ocl::oclMat d_src, d_dst; +typedef CopyMakeBorderMatType WarpPerspectiveMatType; +typedef tuple WarpPerspectiveParams; +typedef TestBaseWithParam WarpPerspectiveFixture; + +PERF_TEST_P(WarpPerspectiveFixture, WarpPerspective, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + WarpPerspectiveMatType::all())) +{ static const double coeffs[3][3] = { {cos(CV_PI / 6), -sin(CV_PI / 6), 100.0}, @@ -341,199 +345,154 @@ PERFTEST(WarpPerspective) {0.0, 0.0, 1.0} }; Mat M(3, 3, CV_64F, (void *)coeffs); - int interpolation = INTER_LINEAR; - - int all_type[] = {CV_8UC1, CV_8UC4}; - std::string type_name[] = {"CV_8UC1", "CV_8UC4"}; - - for (int size = Min_Size; size <= Max_Size; size *= Multiple) - { - for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++) - { - SUBTEST << size << 'x' << size << "; " << type_name[j] ; - - gen(src, size, size, all_type[j], 0, 256); - gen(dst, size, size, all_type[j], 0, 256); - Size size1 = Size(size, size); - - warpPerspective(src, dst, M, size1, interpolation); + const int interpolation = INTER_LINEAR; - CPU_ON; - warpPerspective(src, dst, M, size1, interpolation); - CPU_OFF; + // getting params + WarpPerspectiveParams params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params); + const string impl = getSelectedImpl(); - d_src.upload(src); + // creating src data + Mat src(srcSize, type), dst(srcSize, type); + declare.in(src, WARMUP_RNG).out(dst) + .time(srcSize == OCL_SIZE_4000 ? 18 : srcSize == OCL_SIZE_2000 ? 5 : 2); - WARMUP_ON; - ocl::warpPerspective(d_src, d_dst, M, size1, interpolation); - WARMUP_OFF; + // select implementation + if (impl == "ocl") + { + ocl::oclMat oclSrc(src), oclDst(srcSize, type); - GPU_ON; - ocl::warpPerspective(d_src, d_dst, M, size1, interpolation); - GPU_OFF; + TEST_CYCLE() cv::ocl::warpPerspective(oclSrc, oclDst, M, srcSize, interpolation); - GPU_FULL_ON; - d_src.upload(src); - ocl::warpPerspective(d_src, d_dst, M, size1, interpolation); - d_dst.download(ocl_dst); - GPU_FULL_OFF; + oclDst.download(dst); - TestSystem::instance().ExpectedMatNear(dst, ocl_dst, 1.0); - } + SANITY_CHECK(dst); + } + else if (impl == "plain") + { + TEST_CYCLE() cv::warpPerspective(src, dst, M, srcSize, interpolation); + SANITY_CHECK(dst); } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); } ///////////// resize //////////////////////// -PERFTEST(resize) -{ - Mat src, dst, ocl_dst; - ocl::oclMat d_src, d_dst; +CV_ENUM(resizeInterType, INTER_NEAREST, INTER_LINEAR) - int all_type[] = {CV_8UC1, CV_8UC4}; - std::string type_name[] = {"CV_8UC1", "CV_8UC4"}; +typedef CopyMakeBorderMatType resizeMatType; +typedef tuple resizeParams; +typedef TestBaseWithParam resizeFixture; - for (int size = Min_Size; size <= Max_Size; size *= Multiple) +PERF_TEST_P(resizeFixture, resize, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + resizeMatType::all(), + resizeInterType::all(), + ::testing::Values(0.5, 2.0))) +{ + // getting params + resizeParams params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params), interType = get<2>(params); + double scale = get<3>(params); + const string impl = getSelectedImpl(); + + // creating src data + Mat src(srcSize, type), dst; + const Size dstSize(cvRound(srcSize.width * scale), cvRound(srcSize.height * scale)); + dst.create(dstSize, type); + declare.in(src, WARMUP_RNG).out(dst); + if (interType == INTER_LINEAR && type == CV_8UC4 && OCL_SIZE_4000 == srcSize) + declare.time(11); + + // select implementation + if (impl == "ocl") { - for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++) - { - SUBTEST << size << 'x' << size << "; " << type_name[j] << " ; up"; - - gen(src, size, size, all_type[j], 0, 256); + ocl::oclMat oclSrc(src), oclDst(dstSize, type); - resize(src, dst, Size(), 2.0, 2.0); + TEST_CYCLE() cv::ocl::resize(oclSrc, oclDst, Size(), scale, scale, interType); - CPU_ON; - resize(src, dst, Size(), 2.0, 2.0); - CPU_OFF; - - d_src.upload(src); - - WARMUP_ON; - ocl::resize(d_src, d_dst, Size(), 2.0, 2.0); - WARMUP_OFF; - - GPU_ON; - ocl::resize(d_src, d_dst, Size(), 2.0, 2.0); - GPU_OFF; - - GPU_FULL_ON; - d_src.upload(src); - ocl::resize(d_src, d_dst, Size(), 2.0, 2.0); - d_dst.download(ocl_dst); - GPU_FULL_OFF; - - TestSystem::instance().ExpectedMatNear(dst, ocl_dst, 1.0); - } + oclDst.download(dst); + SANITY_CHECK(dst, 1 + DBL_EPSILON); } - - for (int size = Min_Size; size <= Max_Size; size *= Multiple) + else if (impl == "plain") { - for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++) - { - SUBTEST << size << 'x' << size << "; " << type_name[j] << " ; down"; - - gen(src, size, size, all_type[j], 0, 256); - - resize(src, dst, Size(), 0.5, 0.5); - - CPU_ON; - resize(src, dst, Size(), 0.5, 0.5); - CPU_OFF; - - d_src.upload(src); - - WARMUP_ON; - ocl::resize(d_src, d_dst, Size(), 0.5, 0.5); - WARMUP_OFF; - - GPU_ON; - ocl::resize(d_src, d_dst, Size(), 0.5, 0.5); - GPU_OFF; - - GPU_FULL_ON; - d_src.upload(src); - ocl::resize(d_src, d_dst, Size(), 0.5, 0.5); - d_dst.download(ocl_dst); - GPU_FULL_OFF; - - TestSystem::instance().ExpectedMatNear(dst, ocl_dst, 1.0); - } + TEST_CYCLE() cv::resize(src, dst, Size(), scale, scale, interType); + SANITY_CHECK(dst, 1 + DBL_EPSILON); } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); } -///////////// threshold//////////////////////// -PERFTEST(threshold) -{ - Mat src, dst, ocl_dst; - ocl::oclMat d_src, d_dst; - - for (int size = Min_Size; size <= Max_Size; size *= Multiple) - { - SUBTEST << size << 'x' << size << "; 8UC1; THRESH_BINARY"; - gen(src, size, size, CV_8U, 0, 100); - - threshold(src, dst, 50.0, 0.0, THRESH_BINARY); +///////////// threshold//////////////////////// - CPU_ON; - threshold(src, dst, 50.0, 0.0, THRESH_BINARY); - CPU_OFF; +CV_ENUM(ThreshType, THRESH_BINARY, THRESH_TRUNC) - d_src.upload(src); +typedef tuple ThreshParams; +typedef TestBaseWithParam ThreshFixture; - WARMUP_ON; - ocl::threshold(d_src, d_dst, 50.0, 0.0, THRESH_BINARY); - WARMUP_OFF; +PERF_TEST_P(ThreshFixture, threshold, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + ThreshType::all())) +{ + // getting params + ThreshParams params = GetParam(); + const Size srcSize = get<0>(params); + const int threshType = get<1>(params); + const string impl = getSelectedImpl(); + + // creating src data + Mat src(srcSize, CV_8U), dst(srcSize, CV_8U); + randu(src, 0, 100); + declare.in(src).out(dst); + + // select implementation + if (impl == "ocl") + { + ocl::oclMat oclSrc(src), oclDst(srcSize, CV_8U); - GPU_ON; - ocl::threshold(d_src, d_dst, 50.0, 0.0, THRESH_BINARY); - GPU_OFF; + TEST_CYCLE() cv::ocl::threshold(oclSrc, oclDst, 50.0, 0.0, threshType); - GPU_FULL_ON; - d_src.upload(src); - ocl::threshold(d_src, d_dst, 50.0, 0.0, THRESH_BINARY); - d_dst.download(ocl_dst); - GPU_FULL_OFF; + oclDst.download(dst); - TestSystem::instance().ExpectedMatNear(dst, ocl_dst, 1.0); + SANITY_CHECK(dst); } - - for (int size = Min_Size; size <= Max_Size; size *= Multiple) + else if (impl == "plain") { - SUBTEST << size << 'x' << size << "; 32FC1; THRESH_TRUNC [NPP]"; - - gen(src, size, size, CV_32FC1, 0, 100); - - threshold(src, dst, 50.0, 0.0, THRESH_TRUNC); - - CPU_ON; - threshold(src, dst, 50.0, 0.0, THRESH_TRUNC); - CPU_OFF; - - d_src.upload(src); + TEST_CYCLE() cv::threshold(src, dst, 50.0, 0.0, threshType); - WARMUP_ON; - ocl::threshold(d_src, d_dst, 50.0, 0.0, THRESH_TRUNC); - WARMUP_OFF; - - GPU_ON; - ocl::threshold(d_src, d_dst, 50.0, 0.0, THRESH_TRUNC); - GPU_OFF; - - GPU_FULL_ON; - d_src.upload(src); - ocl::threshold(d_src, d_dst, 50.0, 0.0, THRESH_TRUNC); - d_dst.download(ocl_dst); - GPU_FULL_OFF; - - TestSystem::instance().ExpectedMatNear(dst, ocl_dst, 1.0); + SANITY_CHECK(dst); } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); } + ///////////// meanShiftFiltering//////////////////////// -COOR do_meanShift(int x0, int y0, uchar *sptr, uchar *dptr, int sstep, cv::Size size, int sp, int sr, int maxIter, float eps, int *tab) + +typedef struct +{ + short x; + short y; +} COOR; + +static COOR do_meanShift(int x0, int y0, uchar *sptr, uchar *dptr, int sstep, cv::Size size, int sp, int sr, int maxIter, float eps, int *tab) { int isr2 = sr * sr; @@ -715,48 +674,46 @@ static void meanShiftFiltering_(const Mat &src_roi, Mat &dst_roi, int sp, int sr } } -PERFTEST(meanShiftFiltering) +typedef TestBaseWithParam meanShiftFilteringFixture; + +PERF_TEST_P(meanShiftFilteringFixture, meanShiftFiltering, + OCL_TYPICAL_MAT_SIZES) { - int sp = 5, sr = 6; - Mat src, dst, ocl_dst; + const Size srcSize = GetParam(); + const int sp = 5, sr = 6; + const string impl = getSelectedImpl(); + cv::TermCriteria crit(cv::TermCriteria::COUNT + cv::TermCriteria::EPS, 5, 1); - ocl::oclMat d_src, d_dst; + Mat src(srcSize, CV_8UC4), dst(srcSize, CV_8UC4); + declare.in(src, WARMUP_RNG).out(dst) + .time(srcSize == OCL_SIZE_4000 ? + 56 : srcSize == OCL_SIZE_2000 ? 15 : 3.8); - for (int size = Min_Size; size <= Max_Size; size *= Multiple) + if (impl == "plain") { - SUBTEST << size << 'x' << size << "; 8UC3 vs 8UC4"; - - gen(src, size, size, CV_8UC4, Scalar::all(0), Scalar::all(256)); - - cv::TermCriteria crit(cv::TermCriteria::COUNT + cv::TermCriteria::EPS, 5, 1); - - meanShiftFiltering_(src, dst, sp, sr, crit); + TEST_CYCLE() meanShiftFiltering_(src, dst, sp, sr, crit); - CPU_ON; - meanShiftFiltering_(src, dst, sp, sr, crit); - CPU_OFF; - - d_src.upload(src); - - WARMUP_ON; - ocl::meanShiftFiltering(d_src, d_dst, sp, sr, crit); - WARMUP_OFF; + SANITY_CHECK(dst); + } + else if (impl == "ocl") + { + ocl::oclMat oclSrc(src), oclDst(srcSize, CV_8UC4); - GPU_ON; - ocl::meanShiftFiltering(d_src, d_dst, sp, sr, crit); - GPU_OFF; + TEST_CYCLE() ocl::meanShiftFiltering(oclSrc, oclDst, sp, sr, crit); - GPU_FULL_ON; - d_src.upload(src); - ocl::meanShiftFiltering(d_src, d_dst, sp, sr, crit); - d_dst.download(ocl_dst); - GPU_FULL_OFF; + oclDst.download(dst); - TestSystem::instance().ExpectedMatNear(dst, ocl_dst, 0.0); + SANITY_CHECK(dst); } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); } -void meanShiftProc_(const Mat &src_roi, Mat &dst_roi, Mat &dstCoor_roi, int sp, int sr, cv::TermCriteria crit) +static void meanShiftProc_(const Mat &src_roi, Mat &dst_roi, Mat &dstCoor_roi, int sp, int sr, cv::TermCriteria crit) { if (src_roi.empty()) { @@ -814,200 +771,213 @@ void meanShiftProc_(const Mat &src_roi, Mat &dst_roi, Mat &dstCoor_roi, int sp, } } -PERFTEST(meanShiftProc) -{ - Mat src; - vector dst(2), ocl_dst(2); - ocl::oclMat d_src, d_dst, d_dstCoor; - TermCriteria crit(TermCriteria::COUNT + TermCriteria::EPS, 5, 1); - - for (int size = Min_Size; size <= Max_Size; size *= Multiple) - { - SUBTEST << size << 'x' << size << "; 8UC4 and CV_16SC2 "; - - gen(src, size, size, CV_8UC4, Scalar::all(0), Scalar::all(256)); +typedef TestBaseWithParam meanShiftProcFixture; - meanShiftProc_(src, dst[0], dst[1], 5, 6, crit); +PERF_TEST_P(meanShiftProcFixture, meanShiftProc, + OCL_TYPICAL_MAT_SIZES) +{ + const Size srcSize = GetParam(); + const string impl = getSelectedImpl(); + TermCriteria crit(TermCriteria::COUNT + TermCriteria::EPS, 5, 1); - CPU_ON; - meanShiftProc_(src, dst[0], dst[1], 5, 6, crit); - CPU_OFF; + Mat src(srcSize, CV_8UC4), dst1(srcSize, CV_8UC4), + dst2(srcSize, CV_16SC2); + declare.in(src, WARMUP_RNG).out(dst1, dst2) + .time(srcSize == OCL_SIZE_4000 ? + 56 : srcSize == OCL_SIZE_2000 ? 15 : 3.8);; - d_src.upload(src); + if (impl == "plain") + { + TEST_CYCLE() meanShiftProc_(src, dst1, dst2, 5, 6, crit); - WARMUP_ON; - ocl::meanShiftProc(d_src, d_dst, d_dstCoor, 5, 6, crit); - WARMUP_OFF; + SANITY_CHECK(dst1); + SANITY_CHECK(dst2); + } + else if (impl == "ocl") + { + ocl::oclMat oclSrc(src), oclDst1(srcSize, CV_8UC4), + oclDst2(srcSize, CV_16SC2); - GPU_ON; - ocl::meanShiftProc(d_src, d_dst, d_dstCoor, 5, 6, crit); - GPU_OFF; + TEST_CYCLE() ocl::meanShiftProc(oclSrc, oclDst1, oclDst2, 5, 6, crit); - GPU_FULL_ON; - d_src.upload(src); - ocl::meanShiftProc(d_src, d_dst, d_dstCoor, 5, 6, crit); - d_dst.download(ocl_dst[0]); - d_dstCoor.download(ocl_dst[1]); - GPU_FULL_OFF; + oclDst1.download(dst1); + oclDst2.download(dst2); - vector eps(2, 0.); - TestSystem::instance().ExpectMatsNear(dst, ocl_dst, eps); + SANITY_CHECK(dst1); + SANITY_CHECK(dst2); } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); } ///////////// remap//////////////////////// -PERFTEST(remap) -{ - Mat src, dst, xmap, ymap, ocl_dst; - ocl::oclMat d_src, d_dst, d_xmap, d_ymap; - int all_type[] = {CV_8UC1, CV_8UC4}; - std::string type_name[] = {"CV_8UC1", "CV_8UC4"}; +CV_ENUM(RemapInterType, INTER_NEAREST, INTER_LINEAR) - int interpolation = INTER_LINEAR; - int borderMode = BORDER_CONSTANT; +typedef CopyMakeBorderMatType remapMatType; +typedef tuple remapParams; +typedef TestBaseWithParam remapFixture; - for (int size = Min_Size; size <= Max_Size; size *= Multiple) - { - for (size_t t = 0; t < sizeof(all_type) / sizeof(int); t++) - { - SUBTEST << size << 'x' << size << "; src " << type_name[t] << "; map CV_32FC1"; - - gen(src, size, size, all_type[t], 0, 256); +PERF_TEST_P(remapFixture, remap, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + remapMatType::all(), + RemapInterType::all())) +{ + // getting params + remapParams params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params), interpolation = get<2>(params); + const string impl = getSelectedImpl(); - xmap.create(size, size, CV_32FC1); - dst.create(size, size, CV_32FC1); - ymap.create(size, size, CV_32FC1); + // creating src data + Mat src(srcSize, type), dst(srcSize, type); + declare.in(src, WARMUP_RNG).out(dst); - for (int i = 0; i < size; ++i) - { - float *xmap_row = xmap.ptr(i); - float *ymap_row = ymap.ptr(i); + if (srcSize == OCL_SIZE_4000 && interpolation == INTER_LINEAR) + declare.time(9); - for (int j = 0; j < size; ++j) - { - xmap_row[j] = (j - size * 0.5f) * 0.75f + size * 0.5f; - ymap_row[j] = (i - size * 0.5f) * 0.75f + size * 0.5f; - } - } + Mat xmap, ymap; + xmap.create(srcSize, CV_32FC1); + ymap.create(srcSize, CV_32FC1); - remap(src, dst, xmap, ymap, interpolation, borderMode); + for (int i = 0; i < srcSize.height; ++i) + { + float * const xmap_row = xmap.ptr(i); + float * const ymap_row = ymap.ptr(i); - CPU_ON; - remap(src, dst, xmap, ymap, interpolation, borderMode); - CPU_OFF; + for (int j = 0; j < srcSize.width; ++j) + { + xmap_row[j] = (j - srcSize.width * 0.5f) * 0.75f + srcSize.width * 0.5f; + ymap_row[j] = (i - srcSize.height * 0.5f) * 0.75f + srcSize.height * 0.5f; + } + } - d_src.upload(src); - d_dst.upload(dst); - d_xmap.upload(xmap); - d_ymap.upload(ymap); + const int borderMode = BORDER_CONSTANT; - WARMUP_ON; - ocl::remap(d_src, d_dst, d_xmap, d_ymap, interpolation, borderMode); - WARMUP_OFF; + // select implementation + if (impl == "ocl") + { + ocl::oclMat oclSrc(src), oclDst(srcSize, type); + ocl::oclMat oclXMap(xmap), oclYMap(ymap); - GPU_ON; - ocl::remap(d_src, d_dst, d_xmap, d_ymap, interpolation, borderMode); - GPU_OFF; + TEST_CYCLE() cv::ocl::remap(oclSrc, oclDst, oclXMap, oclYMap, interpolation, borderMode); - GPU_FULL_ON; - d_src.upload(src); - ocl::remap(d_src, d_dst, d_xmap, d_ymap, interpolation, borderMode); - d_dst.download(ocl_dst); - GPU_FULL_OFF; + oclDst.download(dst); - TestSystem::instance().ExpectedMatNear(dst, ocl_dst, 2.0); - } + SANITY_CHECK(dst, 1 + DBL_EPSILON); + } + else if (impl == "plain") + { + TEST_CYCLE() cv::remap(src, dst, xmap, ymap, interpolation, borderMode); + SANITY_CHECK(dst, 1 + DBL_EPSILON); } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); } -///////////// CLAHE //////////////////////// -PERFTEST(CLAHE) -{ - Mat src, dst, ocl_dst; - cv::ocl::oclMat d_src, d_dst; - int all_type[] = {CV_8UC1}; - std::string type_name[] = {"CV_8UC1"}; - - double clipLimit = 40.0; - cv::Ptr clahe = cv::createCLAHE(clipLimit); - cv::Ptr d_clahe = cv::ocl::createCLAHE(clipLimit); +///////////// CLAHE //////////////////////// - for (int size = Min_Size; size <= Max_Size; size *= Multiple) - { - for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++) - { - SUBTEST << size << 'x' << size << "; " << type_name[j] ; +typedef TestBaseWithParam CLAHEFixture; - gen(src, size, size, all_type[j], 0, 256); +PERF_TEST_P(CLAHEFixture, CLAHE, OCL_TYPICAL_MAT_SIZES) +{ + // getting params + const Size srcSize = GetParam(); + const string impl = getSelectedImpl(); - CPU_ON; - clahe->apply(src, dst); - CPU_OFF; + // creating src data + Mat src(srcSize, CV_8UC1), dst; + const double clipLimit = 40.0; + declare.in(src, WARMUP_RNG); - d_src.upload(src); + if (srcSize == OCL_SIZE_4000) + declare.time(11); - WARMUP_ON; - d_clahe->apply(d_src, d_dst); - WARMUP_OFF; + // select implementation + if (impl == "ocl") + { + ocl::oclMat oclSrc(src), oclDst; + cv::Ptr oclClahe = cv::ocl::createCLAHE(clipLimit); - ocl_dst = d_dst; + TEST_CYCLE() oclClahe->apply(oclSrc, oclDst); - TestSystem::instance().ExpectedMatNear(dst, ocl_dst, 1.0); + oclDst.download(dst); - GPU_ON; - d_clahe->apply(d_src, d_dst); - GPU_OFF; + SANITY_CHECK(dst); + } + else if (impl == "plain") + { + cv::Ptr clahe = cv::createCLAHE(clipLimit); + TEST_CYCLE() clahe->apply(src, dst); - GPU_FULL_ON; - d_src.upload(src); - d_clahe->apply(d_src, d_dst); - d_dst.download(dst); - GPU_FULL_OFF; - } + SANITY_CHECK(dst); } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); } ///////////// columnSum//////////////////////// -PERFTEST(columnSum) + +typedef TestBaseWithParam columnSumFixture; + +static void columnSumPerfTest(const Mat & src, Mat & dst) { - Mat src, dst, ocl_dst; - ocl::oclMat d_src, d_dst; + for (int j = 0; j < src.cols; j++) + dst.at(0, j) = src.at(0, j); - for (int size = Min_Size; size <= Max_Size; size *= Multiple) - { - SUBTEST << size << 'x' << size << "; CV_32FC1"; + for (int i = 1; i < src.rows; ++i) + for (int j = 0; j < src.cols; ++j) + dst.at(i, j) = dst.at(i - 1 , j) + src.at(i , j); +} - gen(src, size, size, CV_32FC1, 0, 256); +PERF_TEST_P(columnSumFixture, columnSum, OCL_TYPICAL_MAT_SIZES) +{ + // getting params + const Size srcSize = GetParam(); + const string impl = getSelectedImpl(); - CPU_ON; - dst.create(src.size(), src.type()); - for (int j = 0; j < src.cols; j++) - dst.at(0, j) = src.at(0, j); + // creating src data + Mat src(srcSize, CV_32FC1), dst(srcSize, CV_32FC1); + declare.in(src, WARMUP_RNG).out(dst); - for (int i = 1; i < src.rows; ++i) - for (int j = 0; j < src.cols; ++j) - dst.at(i, j) = dst.at(i - 1 , j) + src.at(i , j); - CPU_OFF; + if (srcSize == OCL_SIZE_4000) + declare.time(5); - d_src.upload(src); + // select implementation + if (impl == "ocl") + { + ocl::oclMat oclSrc(src), oclDst(srcSize, CV_32FC1); - WARMUP_ON; - ocl::columnSum(d_src, d_dst); - WARMUP_OFF; + TEST_CYCLE() cv::ocl::columnSum(oclSrc, oclDst); - GPU_ON; - ocl::columnSum(d_src, d_dst); - GPU_OFF; + oclDst.download(dst); - GPU_FULL_ON; - d_src.upload(src); - ocl::columnSum(d_src, d_dst); - d_dst.download(ocl_dst); - GPU_FULL_OFF; + SANITY_CHECK(dst); + } + else if (impl == "plain") + { + TEST_CYCLE() columnSumPerfTest(src, dst); - TestSystem::instance().ExpectedMatNear(dst, ocl_dst, 5e-1); + SANITY_CHECK(dst); } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); } diff --git a/modules/ocl/perf/perf_match_template.cpp b/modules/ocl/perf/perf_match_template.cpp index 8caf4b4..a1c7caf 100644 --- a/modules/ocl/perf/perf_match_template.cpp +++ b/modules/ocl/perf/perf_match_template.cpp @@ -45,101 +45,97 @@ //M*/ #include "perf_precomp.hpp" -/////////// matchTemplate //////////////////////// -//void InitMatchTemplate() -//{ -// Mat src; gen(src, 500, 500, CV_32F, 0, 1); -// Mat templ; gen(templ, 500, 500, CV_32F, 0, 1); -// ocl::oclMat d_src(src), d_templ(templ), d_dst; -// ocl::matchTemplate(d_src, d_templ, d_dst, CV_TM_CCORR); -//} -PERFTEST(matchTemplate) -{ - //InitMatchTemplate(); - Mat src, templ, dst, ocl_dst; - int templ_size = 5; - - for (int size = Min_Size; size <= Max_Size; size *= Multiple) - { - int all_type[] = {CV_32FC1, CV_32FC4}; - std::string type_name[] = {"CV_32FC1", "CV_32FC4"}; - - for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++) - { - for(templ_size = 5; templ_size <= 5; templ_size *= 5) - { - gen(src, size, size, all_type[j], 0, 1); - - SUBTEST << src.cols << 'x' << src.rows << "; " << type_name[j] << "; templ " << templ_size << 'x' << templ_size << "; CCORR"; - - gen(templ, templ_size, templ_size, all_type[j], 0, 1); - - matchTemplate(src, templ, dst, CV_TM_CCORR); - - CPU_ON; - matchTemplate(src, templ, dst, CV_TM_CCORR); - CPU_OFF; - - ocl::oclMat d_src(src), d_templ(templ), d_dst; - - WARMUP_ON; - ocl::matchTemplate(d_src, d_templ, d_dst, CV_TM_CCORR); - WARMUP_OFF; +using namespace perf; +using std::tr1::tuple; +using std::tr1::get; - GPU_ON; - ocl::matchTemplate(d_src, d_templ, d_dst, CV_TM_CCORR); - GPU_OFF; +/////////// matchTemplate //////////////////////// - GPU_FULL_ON; - d_src.upload(src); - d_templ.upload(templ); - ocl::matchTemplate(d_src, d_templ, d_dst, CV_TM_CCORR); - d_dst.download(ocl_dst); - GPU_FULL_OFF; +CV_ENUM(CV_TM_CCORRMatType, CV_32FC1, CV_32FC4) - TestSystem::instance().ExpectedMatNear(dst, ocl_dst, templ.rows * templ.cols * 1e-1); - } - } +typedef tuple CV_TM_CCORRParams; +typedef TestBaseWithParam CV_TM_CCORRFixture; - int all_type_8U[] = {CV_8UC1}; - std::string type_name_8U[] = {"CV_8UC1"}; +PERF_TEST_P(CV_TM_CCORRFixture, matchTemplate, + ::testing::Combine(::testing::Values(OCL_SIZE_1000, OCL_SIZE_2000), + CV_TM_CCORRMatType::all())) +{ + // getting params + CV_TM_CCORRParams params = GetParam(); + const Size srcSize = get<0>(params), templSize(5, 5); + const int type = get<1>(params); + + std::string impl = getSelectedImpl(); + + // creating src data + Mat src(srcSize, type), templ(templSize, type); + const Size dstSize(src.cols - templ.cols + 1, src.rows - templ.rows + 1); + Mat dst(dstSize, CV_32F); + randu(src, 0.0f, 1.0f); + randu(templ, 0.0f, 1.0f); + declare.time(srcSize == OCL_SIZE_2000 ? 20 : 6).in(src, templ).out(dst); + + // select implementation + if (impl == "ocl") + { + ocl::oclMat oclSrc(src), oclTempl(templ), oclDst(dstSize, CV_32F); - for (size_t j = 0; j < sizeof(all_type_8U) / sizeof(int); j++) - { - for(templ_size = 5; templ_size <= 5; templ_size *= 5) - { - SUBTEST << src.cols << 'x' << src.rows << "; " << type_name_8U[j] << "; templ " << templ_size << 'x' << templ_size << "; CCORR_NORMED"; + TEST_CYCLE() cv::ocl::matchTemplate(oclSrc, oclTempl, oclDst, CV_TM_CCORR); - gen(src, size, size, all_type_8U[j], 0, 255); + oclDst.download(dst); - gen(templ, templ_size, templ_size, all_type_8U[j], 0, 255); + SANITY_CHECK(dst, 1e-4); + } + else if (impl == "plain") + { + TEST_CYCLE() cv::matchTemplate(src, templ, dst, CV_TM_CCORR); - matchTemplate(src, templ, dst, CV_TM_CCORR_NORMED); + SANITY_CHECK(dst, 1e-4); + } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); +} - CPU_ON; - matchTemplate(src, templ, dst, CV_TM_CCORR_NORMED); - CPU_OFF; +typedef TestBaseWithParam CV_TM_CCORR_NORMEDFixture; - ocl::oclMat d_src(src); - ocl::oclMat d_templ(templ), d_dst; +PERF_TEST_P(CV_TM_CCORR_NORMEDFixture, matchTemplate, OCL_TYPICAL_MAT_SIZES) +{ + // getting params + const Size srcSize = GetParam(), templSize(5, 5); + const std::string impl = getSelectedImpl(); + + // creating src data + Mat src(srcSize, CV_8UC1), templ(templSize, CV_8UC1), dst; + const Size dstSize(src.cols - templ.cols + 1, src.rows - templ.rows + 1); + dst.create(dstSize, CV_8UC1); + declare.in(src, templ, WARMUP_RNG).out(dst) + .time(srcSize == OCL_SIZE_2000 ? 10 : srcSize == OCL_SIZE_4000 ? 23 : 2); + + // select implementation + if (impl == "ocl") + { + ocl::oclMat oclSrc(src), oclTempl(templ), oclDst(dstSize, CV_8UC1); - WARMUP_ON; - ocl::matchTemplate(d_src, d_templ, d_dst, CV_TM_CCORR_NORMED); - WARMUP_OFF; + TEST_CYCLE() cv::ocl::matchTemplate(oclSrc, oclTempl, oclDst, CV_TM_CCORR_NORMED); - GPU_ON; - ocl::matchTemplate(d_src, d_templ, d_dst, CV_TM_CCORR_NORMED); - GPU_OFF; + oclDst.download(dst); - GPU_FULL_ON; - d_src.upload(src); - d_templ.upload(templ); - ocl::matchTemplate(d_src, d_templ, d_dst, CV_TM_CCORR_NORMED); - d_dst.download(ocl_dst); - GPU_FULL_OFF; + SANITY_CHECK(dst, 2e-2); + } + else if (impl == "plain") + { + TEST_CYCLE() cv::matchTemplate(src, templ, dst, CV_TM_CCORR_NORMED); - TestSystem::instance().ExpectedMatNear(dst, ocl_dst, templ.rows * templ.cols * 1e-1); - } - } + SANITY_CHECK(dst, 2e-2); } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); } diff --git a/modules/ocl/perf/perf_matrix_operation.cpp b/modules/ocl/perf/perf_matrix_operation.cpp index 092e548..dc3e154 100644 --- a/modules/ocl/perf/perf_matrix_operation.cpp +++ b/modules/ocl/perf/perf_matrix_operation.cpp @@ -45,142 +45,147 @@ //M*/ #include "perf_precomp.hpp" -///////////// ConvertTo//////////////////////// -PERFTEST(ConvertTo) -{ - Mat src, dst, ocl_dst; - ocl::oclMat d_src, d_dst; +using namespace perf; +using std::tr1::tuple; +using std::tr1::get; - int all_type[] = {CV_8UC1, CV_8UC4}; - std::string type_name[] = {"CV_8UC1", "CV_8UC4"}; - - for (int size = Min_Size; size <= Max_Size; size *= Multiple) - { - for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++) - { - SUBTEST << size << 'x' << size << "; " << type_name[j] << " to 32FC1"; +///////////// ConvertTo//////////////////////// - gen(src, size, size, all_type[j], 0, 256); - //gen(dst, size, size, all_type[j], 0, 256); +CV_ENUM(ConvertToMatType, CV_8UC1, CV_8UC4) - //d_dst.upload(dst); +typedef tuple ConvertToParams; +typedef TestBaseWithParam ConvertToFixture; - src.convertTo(dst, CV_32FC1); +PERF_TEST_P(ConvertToFixture, ConvertTo, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + ConvertToMatType::all())) +{ + // getting params + ConvertToParams params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params); - CPU_ON; - src.convertTo(dst, CV_32FC1); - CPU_OFF; + std::string impl = getSelectedImpl(); - d_src.upload(src); + // creating src data + Mat src(srcSize, type), dst; + const int dstType = CV_MAKE_TYPE(CV_32F, src.channels()); + dst.create(srcSize, dstType); + declare.in(src, WARMUP_RNG).out(dst); - WARMUP_ON; - d_src.convertTo(d_dst, CV_32FC1); - WARMUP_OFF; + // select implementation + if (impl == "ocl") + { + ocl::oclMat oclSrc(src), oclDst(srcSize, dstType); - GPU_ON; - d_src.convertTo(d_dst, CV_32FC1); - GPU_OFF; + TEST_CYCLE() oclSrc.convertTo(oclDst, dstType); - GPU_FULL_ON; - d_src.upload(src); - d_src.convertTo(d_dst, CV_32FC1); - d_dst.download(ocl_dst); - GPU_FULL_OFF; + oclDst.download(dst); - TestSystem::instance().ExpectedMatNear(dst, ocl_dst, 0.0); - } + SANITY_CHECK(dst); + } + else if (impl == "plain") + { + TEST_CYCLE() src.convertTo(dst, dstType); + SANITY_CHECK(dst); } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); } -///////////// copyTo//////////////////////// -PERFTEST(copyTo) -{ - Mat src, dst, ocl_dst; - ocl::oclMat d_src, d_dst; - - int all_type[] = {CV_8UC1, CV_8UC4}; - std::string type_name[] = {"CV_8UC1", "CV_8UC4"}; - for (int size = Min_Size; size <= Max_Size; size *= Multiple) - { - for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++) - { - SUBTEST << size << 'x' << size << "; " << type_name[j] ; - - gen(src, size, size, all_type[j], 0, 256); - //gen(dst, size, size, all_type[j], 0, 256); +///////////// copyTo//////////////////////// - //d_dst.upload(dst); +typedef ConvertToMatType copyToMatType; +typedef tuple copyToParams; +typedef TestBaseWithParam copyToFixture; - src.copyTo(dst); +PERF_TEST_P(copyToFixture, copyTo, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + copyToMatType::all())) +{ + // getting params + copyToParams params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params); - CPU_ON; - src.copyTo(dst); - CPU_OFF; + std::string impl = getSelectedImpl(); - d_src.upload(src); + // creating src data + Mat src(srcSize, type), dst(srcSize, type); + declare.in(src, WARMUP_RNG).out(dst); - WARMUP_ON; - d_src.copyTo(d_dst); - WARMUP_OFF; + // select implementation + if (impl == "ocl") + { + ocl::oclMat oclSrc(src), oclDst(srcSize, type); - GPU_ON; - d_src.copyTo(d_dst); - GPU_OFF; + TEST_CYCLE() oclSrc.copyTo(oclDst); - GPU_FULL_ON; - d_src.upload(src); - d_src.copyTo(d_dst); - d_dst.download(ocl_dst); - GPU_FULL_OFF; + oclDst.download(dst); - TestSystem::instance().ExpectedMatNear(dst, ocl_dst, 0.0); - } + SANITY_CHECK(dst); + } + else if (impl == "plain") + { + TEST_CYCLE() src.copyTo(dst); + SANITY_CHECK(dst); } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); } -///////////// setTo//////////////////////// -PERFTEST(setTo) -{ - Mat src, ocl_src; - Scalar val(1, 2, 3, 4); - ocl::oclMat d_src; - - int all_type[] = {CV_8UC1, CV_8UC4}; - std::string type_name[] = {"CV_8UC1", "CV_8UC4"}; - for (int size = Min_Size; size <= Max_Size; size *= Multiple) - { - for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++) - { - SUBTEST << size << 'x' << size << "; " << type_name[j] ; - - gen(src, size, size, all_type[j], 0, 256); +///////////// setTo//////////////////////// - src.setTo(val); +typedef ConvertToMatType setToMatType; +typedef tuple setToParams; +typedef TestBaseWithParam setToFixture; - CPU_ON; - src.setTo(val); - CPU_OFF; +PERF_TEST_P(setToFixture, setTo, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + setToMatType::all())) +{ + // getting params + setToParams params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params); + const Scalar val(1, 2, 3, 4); - d_src.upload(src); + std::string impl = getSelectedImpl(); - WARMUP_ON; - d_src.setTo(val); - WARMUP_OFF; + // creating src data + Mat src(srcSize, type); + declare.in(src); - d_src.download(ocl_src); - TestSystem::instance().ExpectedMatNear(src, ocl_src, 1.0); + // select implementation + if (impl == "ocl") + { + ocl::oclMat oclSrc(srcSize, type); - GPU_ON;; - d_src.setTo(val); - GPU_OFF; + TEST_CYCLE() oclSrc.setTo(val); + oclSrc.download(src); - GPU_FULL_ON; - d_src.upload(src); - d_src.setTo(val); - GPU_FULL_OFF; - } + SANITY_CHECK(src); + } + else if (impl == "plain") + { + TEST_CYCLE() src.setTo(val); + SANITY_CHECK(src); } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); } diff --git a/modules/ocl/perf/perf_moments.cpp b/modules/ocl/perf/perf_moments.cpp index a1515b8..59452d4 100644 --- a/modules/ocl/perf/perf_moments.cpp +++ b/modules/ocl/perf/perf_moments.cpp @@ -43,50 +43,59 @@ // the use of this software, even if advised of the possibility of such damage. // //M*/ + #include "perf_precomp.hpp" -///////////// Moments //////////////////////// -PERFTEST(Moments) -{ - Mat src; - bool binaryImage = 0; - int all_type[] = {CV_8UC1, CV_16SC1, CV_32FC1, CV_64FC1}; - std::string type_name[] = {"CV_8UC1", "CV_16SC1", "CV_32FC1", "CV_64FC1"}; +using namespace perf; +using std::tr1::tuple; +using std::tr1::get; - for (int size = Min_Size; size <= Max_Size; size *= Multiple) - { - for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++) - { - SUBTEST << size << 'x' << size << "; " << type_name[j]; +///////////// Moments //////////////////////// - gen(src, size, size, all_type[j], 0, 256); +CV_ENUM(MomentsMatType, CV_8UC1, CV_16SC1, CV_32FC1, CV_64FC1) - cv::Moments CvMom = moments(src, binaryImage); +typedef tuple MomentsParams; +typedef TestBaseWithParam MomentsFixture; - CPU_ON; - moments(src, binaryImage); - CPU_OFF; +PERF_TEST_P(MomentsFixture, DISABLED_Moments, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + MomentsMatType::all())) +{ + // getting params + MomentsParams params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params); - cv::Moments oclMom; - WARMUP_ON; - oclMom = ocl::ocl_moments(src, binaryImage); - WARMUP_OFF; + std::string impl = getSelectedImpl(); - Mat gpu_dst, cpu_dst; - HuMoments(CvMom, cpu_dst); - HuMoments(oclMom, gpu_dst); + // creating src data + Mat src(srcSize, type), dst(7, 1, CV_64F); + const bool binaryImage = false; + cv::Moments mom; - GPU_ON; - ocl::ocl_moments(src, binaryImage); - GPU_OFF; + declare.in(src, WARMUP_RNG).out(dst); - GPU_FULL_ON; - ocl::ocl_moments(src, binaryImage); - GPU_FULL_OFF; + // select implementation + if (impl == "ocl") + { + ocl::oclMat oclSrc(src); - TestSystem::instance().ExpectedMatNear(gpu_dst, cpu_dst, .5); + TEST_CYCLE() mom = cv::ocl::ocl_moments(oclSrc, binaryImage); + cv::HuMoments(mom, dst); - } + SANITY_CHECK(dst); + } + else if (impl == "plain") + { + TEST_CYCLE() mom = cv::moments(src, binaryImage); + cv::HuMoments(mom, dst); + SANITY_CHECK(dst); } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); } diff --git a/modules/ocl/perf/perf_norm.cpp b/modules/ocl/perf/perf_norm.cpp index a80ab13..b0e18fa 100644 --- a/modules/ocl/perf/perf_norm.cpp +++ b/modules/ocl/perf/perf_norm.cpp @@ -45,43 +45,46 @@ //M*/ #include "perf_precomp.hpp" -///////////// norm//////////////////////// -PERFTEST(norm) -{ - Mat src1, src2, ocl_src1; - ocl::oclMat d_src1, d_src2; +using namespace perf; +using std::tr1::tuple; +using std::tr1::get; - for (int size = Min_Size; size <= Max_Size; size *= Multiple) - { - SUBTEST << size << 'x' << size << "; CV_8UC1; NORM_INF"; - - gen(src1, size, size, CV_8UC1, Scalar::all(0), Scalar::all(1)); - gen(src2, size, size, CV_8UC1, Scalar::all(0), Scalar::all(1)); +///////////// norm//////////////////////// - norm(src1, src2, NORM_INF); +typedef TestBaseWithParam normFixture; - CPU_ON; - norm(src1, src2, NORM_INF); - CPU_OFF; +PERF_TEST_P(normFixture, DISABLED_norm, OCL_TYPICAL_MAT_SIZES) +{ + // getting params + const Size srcSize = GetParam(); + const std::string impl = getSelectedImpl(); + double value = 0.0; - d_src1.upload(src1); - d_src2.upload(src2); + // creating src data + Mat src1(srcSize, CV_8UC1), src2(srcSize, CV_8UC1); + declare.in(src1, src2); + randu(src1, 0, 1); + randu(src2, 0, 1); - WARMUP_ON; - ocl::norm(d_src1, d_src2, NORM_INF); - WARMUP_OFF; + // select implementation + if (impl == "ocl") + { + ocl::oclMat oclSrc1(src1), oclSrc2(src2); - d_src1.download(ocl_src1); - TestSystem::instance().ExpectedMatNear(src1, ocl_src1, .5); + TEST_CYCLE() value = cv::ocl::norm(oclSrc1, oclSrc2, NORM_INF); - GPU_ON; - ocl::norm(d_src1, d_src2, NORM_INF); - GPU_OFF; + SANITY_CHECK(value); + } + else if (impl == "plain") + { + TEST_CYCLE() value = cv::norm(src1, src2, NORM_INF); - GPU_FULL_ON; - d_src1.upload(src1); - d_src2.upload(src2); - ocl::norm(d_src1, d_src2, NORM_INF); - GPU_FULL_OFF; + SANITY_CHECK(value); } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); } diff --git a/modules/ocl/perf/perf_opticalflow.cpp b/modules/ocl/perf/perf_opticalflow.cpp index a6724c8..2f06267 100644 --- a/modules/ocl/perf/perf_opticalflow.cpp +++ b/modules/ocl/perf/perf_opticalflow.cpp @@ -46,117 +46,130 @@ #include "perf_precomp.hpp" ///////////// PyrLKOpticalFlow //////////////////////// -PERFTEST(PyrLKOpticalFlow) -{ - std::string images1[] = {"rubberwhale1.png", "aloeL.jpg"}; - std::string images2[] = {"rubberwhale2.png", "aloeR.jpg"}; - - for (size_t i = 0; i < sizeof(images1) / sizeof(std::string); i++) - { - Mat frame0 = imread(abspath(images1[i]), i == 0 ? IMREAD_COLOR : IMREAD_GRAYSCALE); - - if (frame0.empty()) - { - std::string errstr = "can't open " + images1[i]; - throw runtime_error(errstr); - } - - Mat frame1 = imread(abspath(images2[i]), i == 0 ? IMREAD_COLOR : IMREAD_GRAYSCALE); - - if (frame1.empty()) - { - std::string errstr = "can't open " + images2[i]; - throw runtime_error(errstr); - } - - Mat gray_frame; - - if (i == 0) - { - cvtColor(frame0, gray_frame, COLOR_BGR2GRAY); - } - - for (int points = Min_Size; points <= Max_Size; points *= Multiple) - { - if (i == 0) - SUBTEST << frame0.cols << "x" << frame0.rows << "; color; " << points << " points"; - else - SUBTEST << frame0.cols << "x" << frame0.rows << "; gray; " << points << " points"; - Mat ocl_nextPts; - Mat ocl_status; - - vector pts; - goodFeaturesToTrack(i == 0 ? gray_frame : frame0, pts, points, 0.01, 0.0); - - vector nextPts; - vector status; - vector err; +using namespace perf; +using std::tr1::get; +using std::tr1::tuple; +using std::tr1::make_tuple; - calcOpticalFlowPyrLK(frame0, frame1, pts, nextPts, status, err); - - CPU_ON; - calcOpticalFlowPyrLK(frame0, frame1, pts, nextPts, status, err); - CPU_OFF; - - ocl::PyrLKOpticalFlow d_pyrLK; - - ocl::oclMat d_frame0(frame0); - ocl::oclMat d_frame1(frame1); - - ocl::oclMat d_pts; - Mat pts_mat(1, (int)pts.size(), CV_32FC2, (void *)&pts[0]); - d_pts.upload(pts_mat); - - ocl::oclMat d_nextPts; - ocl::oclMat d_status; - ocl::oclMat d_err; +template +static vector & MatToVector(const ocl::oclMat & oclSrc, vector & instance) +{ + Mat src; + oclSrc.download(src); - WARMUP_ON; - d_pyrLK.sparse(d_frame0, d_frame1, d_pts, d_nextPts, d_status, &d_err); - WARMUP_OFF; + for (int i = 0; i < src.cols; ++i) + instance.push_back(src.at(0, i)); - GPU_ON; - d_pyrLK.sparse(d_frame0, d_frame1, d_pts, d_nextPts, d_status, &d_err); - GPU_OFF; + return instance; +} - GPU_FULL_ON; - d_frame0.upload(frame0); - d_frame1.upload(frame1); - d_pts.upload(pts_mat); - d_pyrLK.sparse(d_frame0, d_frame1, d_pts, d_nextPts, d_status, &d_err); +CV_ENUM(LoadMode, IMREAD_GRAYSCALE, IMREAD_COLOR) + +typedef tuple > PyrLKOpticalFlowParamType; +typedef TestBaseWithParam PyrLKOpticalFlowFixture; + +PERF_TEST_P(PyrLKOpticalFlowFixture, + PyrLKOpticalFlow, + ::testing::Combine( + ::testing::Values(1000, 2000, 4000), + ::testing::Values( + make_tuple + ( + string("gpu/opticalflow/rubberwhale1.png"), + string("gpu/opticalflow/rubberwhale1.png"), + LoadMode(IMREAD_COLOR) + ) +// , make_tuple +// ( +// string("gpu/stereobm/aloe-L.png"), +// string("gpu/stereobm/aloe-R.png"), +// LoadMode(IMREAD_GRAYSCALE) +// ) + ) + ) + ) +{ + PyrLKOpticalFlowParamType params = GetParam(); + tuple fileParam = get<1>(params); + const int pointsCount = get<0>(params); + const int openMode = static_cast(get<2>(fileParam)); + const string fileName0 = get<0>(fileParam), fileName1 = get<1>(fileParam); + Mat frame0 = imread(getDataPath(fileName0), openMode); + Mat frame1 = imread(getDataPath(fileName1), openMode); + const string impl = getSelectedImpl(); + + ASSERT_FALSE(frame0.empty()) << "can't load " << fileName0; + ASSERT_FALSE(frame1.empty()) << "can't load " << fileName1; + + Mat grayFrame; + if (openMode == IMREAD_COLOR) + cvtColor(frame0, grayFrame, COLOR_BGR2GRAY); + else + grayFrame = frame0; + + // initialization + vector pts, nextPts; + vector status; + vector err; + goodFeaturesToTrack(grayFrame, pts, pointsCount, 0.01, 0.0); + + // selecting implementation + if (impl == "plain") + { + TEST_CYCLE() + cv::calcOpticalFlowPyrLK(frame0, frame1, pts, nextPts, status, err); - if (!d_nextPts.empty()) - d_nextPts.download(ocl_nextPts); + SANITY_CHECK(nextPts); + SANITY_CHECK(status); + SANITY_CHECK(err); + } + else if (impl == "ocl") + { + ocl::PyrLKOpticalFlow oclPyrLK; + ocl::oclMat oclFrame0(frame0), oclFrame1(frame1); + ocl::oclMat oclPts(1, static_cast(pts.size()), CV_32FC2, (void *)&pts[0]); + ocl::oclMat oclNextPts, oclStatus, oclErr; - if (!d_status.empty()) - d_status.download(ocl_status); - GPU_FULL_OFF; + TEST_CYCLE() + oclPyrLK.sparse(oclFrame0, oclFrame1, oclPts, oclNextPts, oclStatus, &oclErr); - size_t mismatch = 0; - for (int i = 0; i < (int)nextPts.size(); ++i) - { - if(status[i] != ocl_status.at(0, i)) - { - mismatch++; - continue; - } - if(status[i]) - { - Point2f gpu_rst = ocl_nextPts.at(0, i); - Point2f cpu_rst = nextPts[i]; - if(fabs(gpu_rst.x - cpu_rst.x) >= 1. || fabs(gpu_rst.y - cpu_rst.y) >= 1.) - mismatch++; - } - } - double ratio = (double)mismatch / (double)nextPts.size(); - if(ratio < .02) - TestSystem::instance().setAccurate(1, ratio); - else - TestSystem::instance().setAccurate(0, ratio); - } + MatToVector(oclNextPts, nextPts); + MatToVector(oclStatus, status); + MatToVector(oclErr, err); + SANITY_CHECK(nextPts); + SANITY_CHECK(status); + SANITY_CHECK(err); } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); + +// size_t mismatch = 0; +// for (int i = 0; i < (int)nextPts.size(); ++i) +// { +// if(status[i] != ocl_status.at(0, i)) +// { +// mismatch++; +// continue; +// } +// if(status[i]) +// { +// Point2f gpu_rst = ocl_nextPts.at(0, i); +// Point2f cpu_rst = nextPts[i]; +// if(fabs(gpu_rst.x - cpu_rst.x) >= 1. || fabs(gpu_rst.y - cpu_rst.y) >= 1.) +// mismatch++; +// } +// } +// double ratio = (double)mismatch / (double)nextPts.size(); +// if(ratio < .02) +// TestSystem::instance().setAccurate(1, ratio); +// else +// TestSystem::instance().setAccurate(0, ratio); } diff --git a/modules/ocl/perf/perf_precomp.hpp b/modules/ocl/perf/perf_precomp.hpp index 216ebe5..8c13b9e 100644 --- a/modules/ocl/perf/perf_precomp.hpp +++ b/modules/ocl/perf/perf_precomp.hpp @@ -40,6 +40,15 @@ // //M*/ +#ifdef __GNUC__ +# pragma GCC diagnostic ignored "-Wmissing-declarations" +# pragma GCC diagnostic ignored "-Wunused-function" +# if defined __clang__ || defined __APPLE__ +# pragma GCC diagnostic ignored "-Wmissing-prototypes" +# pragma GCC diagnostic ignored "-Wextra" +# endif +#endif + #ifndef __OPENCV_PERF_PRECOMP_HPP__ #define __OPENCV_PERF_PRECOMP_HPP__ @@ -50,6 +59,7 @@ #include #include #include + #include "opencv2/core/core.hpp" #include "opencv2/imgproc/imgproc.hpp" #include "opencv2/highgui/highgui.hpp" @@ -59,9 +69,12 @@ #include "opencv2/features2d/features2d.hpp" #include "opencv2/ocl/ocl.hpp" #include "opencv2/ts/ts.hpp" -#include "opencv2/ts/ts_perf.hpp" -#include "opencv2/ts/ts_gtest.h" +#define OCL_SIZE_1000 cv::Size(1000, 1000) +#define OCL_SIZE_2000 cv::Size(2000, 2000) +#define OCL_SIZE_4000 cv::Size(4000, 4000) + +#define OCL_TYPICAL_MAT_SIZES ::testing::Values(OCL_SIZE_1000, OCL_SIZE_2000, OCL_SIZE_4000) #define Min_Size 1000 #define Max_Size 4000 @@ -76,15 +89,15 @@ void gen(Mat &mat, int rows, int cols, int type, int low, int high, int n); string abspath(const string &relpath); int CV_CDECL cvErrorCallback(int, const char *, const char *, const char *, int, void *); -typedef struct -{ - short x; - short y; -} COOR; -COOR do_meanShift(int x0, int y0, uchar *sptr, uchar *dptr, int sstep, - cv::Size size, int sp, int sr, int maxIter, float eps, int *tab); -void meanShiftProc_(const Mat &src_roi, Mat &dst_roi, Mat &dstCoor_roi, - int sp, int sr, cv::TermCriteria crit); +//typedef struct +//{ +// short x; +// short y; +//} COOR; +//COOR do_meanShift(int x0, int y0, uchar *sptr, uchar *dptr, int sstep, +// cv::Size size, int sp, int sr, int maxIter, float eps, int *tab); +//void meanShiftProc_(const Mat &src_roi, Mat &dst_roi, Mat &dstCoor_roi, +// int sp, int sr, cv::TermCriteria crit); template diff --git a/modules/ocl/perf/perf_pyramid.cpp b/modules/ocl/perf/perf_pyramid.cpp index 1026279..6b24811 100644 --- a/modules/ocl/perf/perf_pyramid.cpp +++ b/modules/ocl/perf/perf_pyramid.cpp @@ -45,88 +45,103 @@ //M*/ #include "perf_precomp.hpp" +using namespace perf; +using std::tr1::tuple; +using std::tr1::get; + ///////////// pyrDown ////////////////////// -PERFTEST(pyrDown) -{ - Mat src, dst, ocl_dst; - int all_type[] = {CV_8UC1, CV_8UC4}; - std::string type_name[] = {"CV_8UC1", "CV_8UC4"}; - for (int size = Min_Size; size <= Max_Size; size *= Multiple) - { - for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++) - { - SUBTEST << size << 'x' << size << "; " << type_name[j] ; +CV_ENUM(pyrDownMatType, CV_8UC1, CV_8UC4) - gen(src, size, size, all_type[j], 0, 256); +typedef tuple pyrDownParams; +typedef TestBaseWithParam pyrDownFixture; - pyrDown(src, dst); +PERF_TEST_P(pyrDownFixture, pyrDown, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + pyrDownMatType::all())) +{ + // getting params + pyrDownParams params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params); - CPU_ON; - pyrDown(src, dst); - CPU_OFF; + std::string impl = getSelectedImpl(); - ocl::oclMat d_src(src); - ocl::oclMat d_dst; + // creating src data + Mat src(srcSize, type), dst; + Size dstSize((srcSize.height + 1) >> 1, (srcSize.width + 1) >> 1); + dst.create(dstSize, type); + declare.in(src).out(dst); - WARMUP_ON; - ocl::pyrDown(d_src, d_dst); - WARMUP_OFF; + // select implementation + if (impl == "ocl") + { + ocl::oclMat oclSrc(src), oclDst(dstSize, type); + + TEST_CYCLE() cv::ocl::pyrDown(oclSrc, oclDst); - GPU_ON; - ocl::pyrDown(d_src, d_dst); - GPU_OFF; + oclDst.download(dst); - GPU_FULL_ON; - d_src.upload(src); - ocl::pyrDown(d_src, d_dst); - d_dst.download(ocl_dst); - GPU_FULL_OFF; + SANITY_CHECK(dst); + } + else if (impl == "plain") + { + TEST_CYCLE() cv::pyrDown(src, dst); - TestSystem::instance().ExpectedMatNear(dst, ocl_dst, dst.depth() == CV_32F ? 1e-4f : 1.0f); - } + SANITY_CHECK(dst); } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); } ///////////// pyrUp //////////////////////// -PERFTEST(pyrUp) -{ - Mat src, dst, ocl_dst; - int all_type[] = {CV_8UC1, CV_8UC4}; - std::string type_name[] = {"CV_8UC1", "CV_8UC4"}; - for (int size = 500; size <= 2000; size *= 2) - { - for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++) - { - SUBTEST << size << 'x' << size << "; " << type_name[j] ; +typedef pyrDownMatType pyrUpMatType; +typedef tuple pyrUpParams; +typedef TestBaseWithParam pyrUpFixture; - gen(src, size, size, all_type[j], 0, 256); +PERF_TEST_P(pyrUpFixture, pyrUp, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + pyrUpMatType::all())) +{ + // getting params + pyrUpParams params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params); - pyrUp(src, dst); + std::string impl = getSelectedImpl(); - CPU_ON; - pyrUp(src, dst); - CPU_OFF; + // creating src data + Mat src(srcSize, type), dst; + Size dstSize(srcSize.height << 1, srcSize.width << 1); + dst.create(dstSize, type); + declare.in(src).out(dst); - ocl::oclMat d_src(src); - ocl::oclMat d_dst; + // select implementation + if (impl == "ocl") + { + ocl::oclMat oclSrc(src), oclDst(dstSize, type); - WARMUP_ON; - ocl::pyrUp(d_src, d_dst); - WARMUP_OFF; + TEST_CYCLE() cv::ocl::pyrDown(oclSrc, oclDst); - GPU_ON; - ocl::pyrUp(d_src, d_dst); - GPU_OFF; + oclDst.download(dst); - GPU_FULL_ON; - d_src.upload(src); - ocl::pyrUp(d_src, d_dst); - d_dst.download(ocl_dst); - GPU_FULL_OFF; + SANITY_CHECK(dst); + } + else if (impl == "plain") + { + TEST_CYCLE() cv::pyrDown(src, dst); - TestSystem::instance().ExpectedMatNear(dst, ocl_dst, (src.depth() == CV_32F ? 1e-4f : 1.0)); - } + SANITY_CHECK(dst); } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); } diff --git a/modules/ocl/perf/perf_split_merge.cpp b/modules/ocl/perf/perf_split_merge.cpp index 736125e..304d3dd 100644 --- a/modules/ocl/perf/perf_split_merge.cpp +++ b/modules/ocl/perf/perf_split_merge.cpp @@ -45,110 +45,120 @@ //M*/ #include "perf_precomp.hpp" +using namespace perf; +using std::tr1::tuple; +using std::tr1::get; + ///////////// Merge//////////////////////// -PERFTEST(Merge) -{ - Mat dst, ocl_dst; - ocl::oclMat d_dst; - int channels = 4; - int all_type[] = {CV_8UC1, CV_32FC1}; - std::string type_name[] = {"CV_8UC1", "CV_32FC1"}; +CV_ENUM(MergeMatType, CV_8U, CV_32F) - for (int size = Min_Size; size <= Max_Size; size *= Multiple) - { - for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++) - { - SUBTEST << size << 'x' << size << "; " << type_name[j] ; - Size size1 = Size(size, size); - std::vector src(channels); - - for (int i = 0; i < channels; ++i) - { - src[i] = Mat(size1, all_type[j], cv::Scalar::all(i)); - } - - merge(src, dst); - - CPU_ON; - merge(src, dst); - CPU_OFF; - - std::vector d_src(channels); - - for (int i = 0; i < channels; ++i) - { - d_src[i] = ocl::oclMat(size1, all_type[j], cv::Scalar::all(i)); - } - - WARMUP_ON; - ocl::merge(d_src, d_dst); - WARMUP_OFF; - - GPU_ON; - ocl::merge(d_src, d_dst); - GPU_OFF; - - GPU_FULL_ON; - for (int i = 0; i < channels; ++i) - { - d_src[i] = ocl::oclMat(size1, all_type[j], cv::Scalar::all(i)); - } - ocl::merge(d_src, d_dst); - d_dst.download(ocl_dst); - GPU_FULL_OFF; - - TestSystem::instance().ExpectedMatNear(dst, ocl_dst, 0.0); - } +typedef tuple MergeParams; +typedef TestBaseWithParam MergeFixture; - } -} - -///////////// Split//////////////////////// -PERFTEST(Split) +PERF_TEST_P(MergeFixture, Merge, + ::testing::Combine(::testing::Values(OCL_SIZE_1000, OCL_SIZE_2000), + MergeMatType::all())) { - //int channels = 4; - int all_type[] = {CV_8UC1, CV_32FC1}; - std::string type_name[] = {"CV_8UC1", "CV_32FC1"}; + // getting params + MergeParams params = GetParam(); + const Size srcSize = get<0>(params); + const int depth = get<1>(params), channels = 3; + + std::string impl = getSelectedImpl(); + + // creating src data + const int dstType = CV_MAKE_TYPE(depth, channels); + Mat dst(srcSize, dstType); + vector src(channels); + for (vector::iterator i = src.begin(), end = src.end(); i != end; ++i) + { + i->create(srcSize, CV_MAKE_TYPE(depth, 1)); + declare.in(*i, WARMUP_RNG); + } + declare.out(dst); - for (int size = Min_Size; size <= Max_Size; size *= Multiple) + // select implementation + if (impl == "ocl") { - for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++) - { - SUBTEST << size << 'x' << size << "; " << type_name[j]; - Size size1 = Size(size, size); + ocl::oclMat oclDst(srcSize, dstType); + vector oclSrc(src.size()); + for (vector::size_type i = 0, end = src.size(); i < end; ++i) + oclSrc[i] = src[i]; - Mat src(size1, CV_MAKE_TYPE(all_type[j], 4), cv::Scalar(1, 2, 3, 4)); + TEST_CYCLE() cv::ocl::merge(oclSrc, oclDst); - std::vector dst, ocl_dst(4); + oclDst.download(dst); - split(src, dst); + SANITY_CHECK(dst); + } + else if (impl == "plain") + { + TEST_CYCLE() cv::merge(src, dst); - CPU_ON; - split(src, dst); - CPU_OFF; + SANITY_CHECK(dst); + } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); +} - ocl::oclMat d_src(size1, CV_MAKE_TYPE(all_type[j], 4), cv::Scalar(1, 2, 3, 4)); - std::vector d_dst; +///////////// Split//////////////////////// - WARMUP_ON; - ocl::split(d_src, d_dst); - WARMUP_OFF; +typedef MergeMatType SplitMatType; +typedef tuple SplitParams; +typedef TestBaseWithParam SplitFixture; - GPU_ON; - ocl::split(d_src, d_dst); - GPU_OFF; +PERF_TEST_P(SplitFixture, Split, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + SplitMatType::all())) +{ + // getting params + MergeParams params = GetParam(); + const Size srcSize = get<0>(params); + const int depth = get<1>(params), channels = 3; - GPU_FULL_ON; - d_src.upload(src); - ocl::split(d_src, d_dst); - for(size_t i = 0; i < dst.size(); i++) - d_dst[i].download(ocl_dst[i]); - GPU_FULL_OFF; + std::string impl = getSelectedImpl(); - vector eps(4, 0.); - TestSystem::instance().ExpectMatsNear(dst, ocl_dst, eps); - } + // creating src data + Mat src(srcSize, CV_MAKE_TYPE(depth, channels)); + declare.in(src, WARMUP_RNG); + // select implementation + if (impl == "ocl") + { + ocl::oclMat oclSrc(src); + vector oclDst(channels, ocl::oclMat(srcSize, CV_MAKE_TYPE(depth, 1))); + + TEST_CYCLE() cv::ocl::split(oclSrc, oclDst); + + AssertEQ(channels, 3); + Mat dst0, dst1, dst2; + oclDst[0].download(dst0); + oclDst[1].download(dst1); + oclDst[2].download(dst2); + SANITY_CHECK(dst0); + SANITY_CHECK(dst1); + SANITY_CHECK(dst2); + } + else if (impl == "plain") + { + vector dst(channels, Mat(srcSize, CV_MAKE_TYPE(depth, 1))); + TEST_CYCLE() cv::split(src, dst); + + AssertEQ(channels, 3); + Mat & dst0 = dst[0], & dst1 = dst[1], & dst2 = dst[2]; + SANITY_CHECK(dst0); + SANITY_CHECK(dst1); + SANITY_CHECK(dst2); } +#ifdef HAVE_OPENCV_GPU + else if (impl == "gpu") + CV_TEST_FAIL_NO_IMPL(); +#endif + else + CV_TEST_FAIL_NO_IMPL(); }