diff --git a/modules/ocl/perf/main.cpp b/modules/ocl/perf/main.cpp index 428ab97e43..e24c2c14e5 100644 --- a/modules/ocl/perf/main.cpp +++ b/modules/ocl/perf/main.cpp @@ -42,123 +42,54 @@ #include "perf_precomp.hpp" -int main(int argc, const char *argv[]) +const char * impls[] = { - const char *keys = - "{ h | help | false | print help message }" - "{ f | filter | | filter for test }" - "{ w | workdir | | set working directory }" - "{ l | list | false | show all tests }" - "{ d | device | 0 | device id }" - "{ c | cpu_ocl | false | use cpu as ocl device}" - "{ i | iters | 10 | iteration count }" - "{ m | warmup | 1 | gpu warm up iteration count}" - "{ t | xtop | 1.1 | xfactor top boundary}" - "{ b | xbottom | 0.9 | xfactor bottom boundary}" - "{ v | verify | false | only run gpu once to verify if problems occur}"; + IMPL_OCL, + IMPL_PLAIN, +#ifdef HAVE_OPENCV_GPU + IMPL_GPU +#endif +}; + +int main(int argc, char ** argv) +{ + const char * keys = + "{ h | help | false | print help message }" + "{ t | type | gpu | set device type:cpu or gpu}" + "{ p | platform | 0 | set platform id }" + "{ d | device | 0 | set device id }"; - redirectError(cvErrorCallback); CommandLineParser cmd(argc, argv, keys); if (cmd.get("help")) { - cout << "Avaible options:" << endl; + cout << "Available options besides google test option:" << endl; cmd.printParams(); return 0; } - // get ocl devices - bool use_cpu = cmd.get("c"); - vector oclinfo; - int num_devices = 0; - if(use_cpu) - num_devices = getDevice(oclinfo, ocl::CVCL_DEVICE_TYPE_CPU); - else - num_devices = getDevice(oclinfo); - if (num_devices < 1) - { - cerr << "no device found\n"; - return -1; - } - - // show device info - int devidx = 0; - for (size_t i = 0; i < oclinfo.size(); i++) - { - for (size_t j = 0; j < oclinfo[i].DeviceName.size(); j++) - { - cout << "device " << devidx++ << ": " << oclinfo[i].DeviceName[j] << endl; - } - } - + string type = cmd.get("type"); + unsigned int pid = cmd.get("platform"); int device = cmd.get("device"); - if (device < 0 || device >= num_devices) - { - cerr << "Invalid device ID" << endl; - return -1; - } - // set this to overwrite binary cache every time the test starts - ocl::setBinaryDiskCache(ocl::CACHE_UPDATE); - - if (cmd.get("verify")) - { - TestSystem::instance().setNumIters(1); - TestSystem::instance().setGPUWarmupIters(0); - TestSystem::instance().setCPUIters(0); - } + int flag = type == "cpu" ? cv::ocl::CVCL_DEVICE_TYPE_CPU : + cv::ocl::CVCL_DEVICE_TYPE_GPU; - devidx = 0; - for (size_t i = 0; i < oclinfo.size(); i++) + std::vector oclinfo; + int devnums = cv::ocl::getDevice(oclinfo, flag); + if (devnums <= device || device < 0) { - for (size_t j = 0; j < oclinfo[i].DeviceName.size(); j++, devidx++) - { - if (device == devidx) - { - ocl::setDevice(oclinfo[i], (int)j); - TestSystem::instance().setRecordName(oclinfo[i].DeviceName[j]); - cout << "use " << devidx << ": " <("filter"); - string workdir = cmd.get("workdir"); - bool list = cmd.get("list"); - int iters = cmd.get("iters"); - int wu_iters = cmd.get("warmup"); - double x_top = cmd.get("xtop"); - double x_bottom = cmd.get("xbottom"); - - TestSystem::instance().setTopThreshold(x_top); - TestSystem::instance().setBottomThreshold(x_bottom); - - if (!filter.empty()) - { - TestSystem::instance().setTestFilter(filter); - } - - if (!workdir.empty()) - { - if (workdir[workdir.size() - 1] != '/' && workdir[workdir.size() - 1] != '\\') - { - workdir += '/'; - } - - TestSystem::instance().setWorkingDir(workdir); + std::cout << "device invalid\n"; + return -1; } - if (list) + if (pid >= oclinfo.size()) { - TestSystem::instance().setListMode(true); + std::cout << "platform invalid\n"; + return -1; } - TestSystem::instance().setNumIters(iters); - TestSystem::instance().setGPUWarmupIters(wu_iters); - - TestSystem::instance().run(); + cv::ocl::setDevice(oclinfo[pid], device); + cv::ocl::setBinaryDiskCache(cv::ocl::CACHE_UPDATE); - return 0; + CV_PERF_TEST_MAIN_INTERNALS(ocl, impls) } diff --git a/modules/ocl/perf/perf_arithm.cpp b/modules/ocl/perf/perf_arithm.cpp index 7cefd78f7f..1fb82f1221 100644 --- a/modules/ocl/perf/perf_arithm.cpp +++ b/modules/ocl/perf/perf_arithm.cpp @@ -45,1153 +45,883 @@ //M*/ #include "perf_precomp.hpp" -///////////// Lut //////////////////////// -PERFTEST(lut) -{ - Mat src, lut, dst, ocl_dst; - ocl::oclMat d_src, d_lut, d_dst; - int all_type[] = {CV_8UC1, CV_8UC3}; - std::string type_name[] = {"CV_8UC1", "CV_8UC3"}; - - 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]; +using namespace perf; +using std::tr1::get; +using std::tr1::tuple; - gen(src, size, size, all_type[j], 0, 256); - gen(lut, 1, 256, CV_8UC1, 0, 1); +///////////// Lut //////////////////////// - LUT(src, lut, dst); +typedef Size_MatType LUTFixture; - CPU_ON; - LUT(src, lut, dst); - CPU_OFF; +PERF_TEST_P(LUTFixture, LUT, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + OCL_PERF_ENUM(CV_8UC1, CV_8UC3))) +{ + // getting params + const Size_MatType_t params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params); - d_src.upload(src); - d_lut.upload(lut); + // creating src data + Mat src(srcSize, type), lut(1, 256, CV_8UC1); + int dstType = CV_MAKETYPE(lut.depth(), src.channels()); + Mat dst(srcSize, dstType); - WARMUP_ON; - ocl::LUT(d_src, d_lut, d_dst); - WARMUP_OFF; + randu(lut, 0, 2); + declare.in(src, WARMUP_RNG).in(lut).out(dst); - GPU_ON; - ocl::LUT(d_src, d_lut, d_dst); - GPU_OFF; + // select implementation + if (RUN_OCL_IMPL) + { + ocl::oclMat oclSrc(src), oclLut(lut), oclDst(srcSize, dstType); - 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; + TEST_CYCLE() cv::ocl::LUT(oclSrc, oclLut, oclDst); + oclDst.download(dst); - TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 0); - } + SANITY_CHECK(dst); + } + else if (RUN_PLAIN_IMPL) + { + TEST_CYCLE() cv::LUT(src, lut, dst); + SANITY_CHECK(dst); } + else + OCL_PERF_ELSE } ///////////// 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; - gen(src, size, size, CV_32FC1, 5, 16); +PERF_TEST_P(ExpFixture, Exp, OCL_TYPICAL_MAT_SIZES) +{ + // getting params + const Size srcSize = GetParam(); + const double eps = 3e-1; - 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 (RUN_OCL_IMPL) + { + 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, eps); + } + else if (RUN_PLAIN_IMPL) + { + TEST_CYCLE() cv::exp(src, dst); - TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 2); + SANITY_CHECK(dst, eps); } + else + OCL_PERF_ELSE } ///////////// 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; + +PERF_TEST_P(LogFixture, Log, OCL_TYPICAL_MAT_SIZES) +{ + // getting params + const Size srcSize = GetParam(); + const double eps = 1e-5; - gen(src, size, size, CV_32F, 1, 10); + // creating src data + Mat src(srcSize, CV_32F), dst(srcSize, src.type()); + randu(src, 1, 10); + declare.in(src).out(dst); - log(src, dst); + if (srcSize == OCL_SIZE_4000) + declare.time(3.6); - CPU_ON; - log(src, dst); - CPU_OFF; - d_src.upload(src); + // select implementation + if (RUN_OCL_IMPL) + { + ocl::oclMat oclSrc(src), oclDst(srcSize, src.type()); - WARMUP_ON; - ocl::log(d_src, d_dst); - WARMUP_OFF; + TEST_CYCLE() cv::ocl::log(oclSrc, oclDst); - GPU_ON; - ocl::log(d_src, d_dst); - GPU_OFF; + oclDst.download(dst); - GPU_FULL_ON; - d_src.upload(src); - ocl::log(d_src, d_dst); - d_dst.download(ocl_dst); - GPU_FULL_OFF; + SANITY_CHECK(dst, eps); + } + else if (RUN_PLAIN_IMPL) + { + TEST_CYCLE() cv::log(src, dst); - TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1); + SANITY_CHECK(dst, eps); } + else + OCL_PERF_ELSE } ///////////// 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"}; +typedef Size_MatType AddFixture; - for (int size = Min_Size; size <= Max_Size; size *= Multiple) +PERF_TEST_P(AddFixture, Add, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + OCL_PERF_ENUM(CV_8UC1, CV_32FC1))) +{ + // getting params + const Size_MatType_t params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params); + + // 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 (RUN_OCL_IMPL) { - 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, 1); - gen(src2, size, size, all_type[j], 0, 1); - - add(src1, src2, dst); - - CPU_ON; - add(src1, src2, dst); - CPU_OFF; - - d_src1.upload(src1); - d_src2.upload(src2); - - WARMUP_ON; - ocl::add(d_src1, d_src2, d_dst); - WARMUP_OFF; + 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 (RUN_PLAIN_IMPL) + { + TEST_CYCLE() cv::add(src1, src2, dst); + SANITY_CHECK(dst); } + else + OCL_PERF_ELSE } ///////////// 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"}; +typedef Size_MatType MulFixture; - for (int size = Min_Size; size <= Max_Size; size *= Multiple) +PERF_TEST_P(MulFixture, Mul, ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + OCL_PERF_ENUM(CV_8UC1, CV_8UC4))) +{ + // getting params + const Size_MatType_t params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params); + + // 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 (RUN_OCL_IMPL) { - 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); + ocl::oclMat oclSrc1(src1), oclSrc2(src2), oclDst(srcSize, type); - CPU_ON; - multiply(src1, src2, dst); - CPU_OFF; - d_src1.upload(src1); - d_src2.upload(src2); + TEST_CYCLE() cv::ocl::multiply(oclSrc1, oclSrc2, oclDst); - WARMUP_ON; - ocl::multiply(d_src1, d_src2, d_dst); - WARMUP_OFF; + oclDst.download(dst); - GPU_ON; - ocl::multiply(d_src1, d_src2, d_dst); - GPU_OFF; - - 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; - - TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 0.0); - } + SANITY_CHECK(dst); + } + else if (RUN_PLAIN_IMPL) + { + TEST_CYCLE() cv::multiply(src1, src2, dst); + SANITY_CHECK(dst); } + else + OCL_PERF_ELSE } ///////////// 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]; - - 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); +typedef Size_MatType DivFixture; - WARMUP_ON; - ocl::divide(d_src1, d_src2, d_dst); - WARMUP_OFF; +PERF_TEST_P(DivFixture, Div, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + OCL_PERF_ENUM(CV_8UC1, CV_8UC4))) +{ + // getting params + const Size_MatType_t params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params); + + // 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 (RUN_OCL_IMPL) + { + 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 (RUN_PLAIN_IMPL) + { + TEST_CYCLE() cv::divide(src1, src2, dst); + SANITY_CHECK(dst); } + else + OCL_PERF_ELSE } ///////////// 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"}; - - 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); - gen(dst, size, size, all_type[j], 0, 256); +typedef Size_MatType AbsDiffFixture; - absdiff(src1, src2, dst); - - CPU_ON; - absdiff(src1, src2, dst); - CPU_OFF; +PERF_TEST_P(AbsDiffFixture, Absdiff, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + OCL_PERF_ENUM(CV_8UC1, CV_8UC4))) +{ + const Size_MatType_t params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params); - d_src1.upload(src1); - d_src2.upload(src2); + Mat src1(srcSize, type), src2(srcSize, type), dst(srcSize, type); + declare.in(src1, src2).in(dst); + randu(src1, 0, 256); + randu(src2, 0, 256); - WARMUP_ON; - ocl::absdiff(d_src1, d_src2, d_dst); - WARMUP_OFF; + if (RUN_OCL_IMPL) + { + ocl::oclMat oclSrc1(src1), oclSrc2(src2), oclDst(srcSize, type); - GPU_ON; - ocl::absdiff(d_src1, d_src2, d_dst); - GPU_OFF; + TEST_CYCLE() cv::ocl::absdiff(oclSrc1, oclSrc2, oclDst); - 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; + oclDst.download(dst); - TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 0.0); - } + SANITY_CHECK(dst); + } + else if (RUN_PLAIN_IMPL) + { + TEST_CYCLE() cv::absdiff(src1, src2, dst); + SANITY_CHECK(dst); } + else + OCL_PERF_ELSE } ///////////// 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"}; - - 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); - gen(dst, size, size, all_type[j], 0, 256); - gen(dst1, size, size, all_type[j], 0, 256); +typedef TestBaseWithParam CartToPolarFixture; - cartToPolar(src1, src2, dst, dst1, 1); - - CPU_ON; - cartToPolar(src1, src2, dst, dst1, 1); - CPU_OFF; +PERF_TEST_P(CartToPolarFixture, CartToPolar, OCL_TYPICAL_MAT_SIZES) +{ + const Size srcSize = GetParam(); + const double eps = 8e-3; - d_src1.upload(src1); - d_src2.upload(src2); + 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); - WARMUP_ON; - ocl::cartToPolar(d_src1, d_src2, d_dst, d_dst1, 1); - WARMUP_OFF; + if (srcSize == OCL_SIZE_4000) + declare.time(3.6); - GPU_ON; - ocl::cartToPolar(d_src1, d_src2, d_dst, d_dst1, 1); - GPU_OFF; + if (RUN_OCL_IMPL) + { + ocl::oclMat oclSrc1(src1), oclSrc2(src2), + oclDst1(srcSize, src1.type()), oclDst2(srcSize, src1.type()); - 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; + TEST_CYCLE() cv::ocl::cartToPolar(oclSrc1, oclSrc2, oclDst1, oclDst2); - 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); + oclDst1.download(dst1); + oclDst2.download(dst2); - } + SANITY_CHECK(dst1, eps); + SANITY_CHECK(dst2, eps); + } + else if (RUN_PLAIN_IMPL) + { + TEST_CYCLE() cv::cartToPolar(src1, src2, dst1, dst2); + SANITY_CHECK(dst1, eps); + SANITY_CHECK(dst2, eps); } + else + OCL_PERF_ELSE } ///////////// 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"}; - - 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); - gen(dst, size, size, all_type[j], 0, 256); - gen(dst1, size, size, all_type[j], 0, 256); +typedef TestBaseWithParam PolarToCartFixture; - polarToCart(src1, src2, dst, dst1, 1); +PERF_TEST_P(PolarToCartFixture, PolarToCart, OCL_TYPICAL_MAT_SIZES) +{ + const Size srcSize = GetParam(); - CPU_ON; - polarToCart(src1, src2, dst, dst1, 1); - CPU_OFF; - d_src1.upload(src1); - d_src2.upload(src2); + 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); - WARMUP_ON; - ocl::polarToCart(d_src1, d_src2, d_dst, d_dst1, 1); - WARMUP_OFF; + if (srcSize == OCL_SIZE_4000) + declare.time(5.4); - GPU_ON; - ocl::polarToCart(d_src1, d_src2, d_dst, d_dst1, 1); - GPU_OFF; + if (RUN_OCL_IMPL) + { + ocl::oclMat oclSrc1(src1), oclSrc2(src2), + oclDst1(srcSize, src1.type()), oclDst2(srcSize, src1.type()); - 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; + TEST_CYCLE() cv::ocl::polarToCart(oclSrc1, oclSrc2, oclDst1, oclDst2); - 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); + oclDst1.download(dst1); + oclDst2.download(dst2); - } + SANITY_CHECK(dst1, 5e-5); + SANITY_CHECK(dst2, 5e-5); + } + else if (RUN_PLAIN_IMPL) + { + TEST_CYCLE() cv::polarToCart(src1, src2, dst1, dst2); + SANITY_CHECK(dst1, 5e-5); + SANITY_CHECK(dst2, 5e-5); } + else + OCL_PERF_ELSE } ///////////// 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"}; - - 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(x, size, size, all_type[j], 0, 1); - gen(y, size, size, all_type[j], 0, 1); +typedef TestBaseWithParam MagnitudeFixture; - magnitude(x, y, mag); +PERF_TEST_P(MagnitudeFixture, Magnitude, OCL_TYPICAL_MAT_SIZES) +{ + const Size srcSize = GetParam(); - CPU_ON; - magnitude(x, y, mag); - CPU_OFF; - d_x.upload(x); - d_y.upload(y); + 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); - WARMUP_ON; - ocl::magnitude(d_x, d_y, d_mag); - WARMUP_OFF; + if (RUN_OCL_IMPL) + { + ocl::oclMat oclSrc1(src1), oclSrc2(src2), + oclDst(srcSize, src1.type()); - GPU_ON; - ocl::magnitude(d_x, d_y, d_mag); - GPU_OFF; + TEST_CYCLE() cv::ocl::magnitude(oclSrc1, oclSrc2, oclDst); - 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; + oclDst.download(dst); - TestSystem::instance().ExpectedMatNear(ocl_mag, mag, 1e-5); - } + SANITY_CHECK(dst, 1e-6); + } + else if (RUN_PLAIN_IMPL) + { + TEST_CYCLE() cv::magnitude(src1, src2, dst); + SANITY_CHECK(dst, 1e-6); } + else + OCL_PERF_ELSE } ///////////// 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"}; - - 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); +typedef Size_MatType TransposeFixture; - transpose(src, dst); +PERF_TEST_P(TransposeFixture, Transpose, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + OCL_PERF_ENUM(CV_8UC1, CV_8UC4))) +{ + const Size_MatType_t params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params); - CPU_ON; - transpose(src, dst); - CPU_OFF; - d_src.upload(src); + Mat src(srcSize, type), dst(srcSize, type); + declare.in(src, WARMUP_RNG).out(dst); - WARMUP_ON; - ocl::transpose(d_src, d_dst); - WARMUP_OFF; + if (RUN_OCL_IMPL) + { + ocl::oclMat oclSrc(src), oclDst(srcSize, type); - GPU_ON; - ocl::transpose(d_src, d_dst); - GPU_OFF; + TEST_CYCLE() cv::ocl::transpose(oclSrc, oclDst); - GPU_FULL_ON; - d_src.upload(src); - ocl::transpose(d_src, d_dst); - d_dst.download(ocl_dst); - GPU_FULL_OFF; + oclDst.download(dst); - TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1e-5); - } + SANITY_CHECK(dst); + } + else if (RUN_PLAIN_IMPL) + { + TEST_CYCLE() cv::transpose(src, dst); + SANITY_CHECK(dst); } + else + OCL_PERF_ELSE } ///////////// 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 Size_MatType FlipFixture; - 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] << " ; FLIP_BOTH"; - - gen(src, size, size, all_type[j], 0, 256); - gen(dst, size, size, all_type[j], 0, 256); - - flip(src, dst, 0); +PERF_TEST_P(FlipFixture, Flip, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + OCL_PERF_ENUM(CV_8UC1, CV_8UC4))) +{ + const Size_MatType_t params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params); - CPU_ON; - flip(src, dst, 0); - CPU_OFF; - d_src.upload(src); + Mat src(srcSize, type), dst(srcSize, type); + declare.in(src, WARMUP_RNG).out(dst); - WARMUP_ON; - ocl::flip(d_src, d_dst, 0); - WARMUP_OFF; + if (RUN_OCL_IMPL) + { + ocl::oclMat oclSrc(src), oclDst(srcSize, type); - GPU_ON; - ocl::flip(d_src, d_dst, 0); - GPU_OFF; + TEST_CYCLE() cv::ocl::flip(oclSrc, oclDst, 0); - GPU_FULL_ON; - d_src.upload(src); - ocl::flip(d_src, d_dst, 0); - d_dst.download(ocl_dst); - GPU_FULL_OFF; + oclDst.download(dst); - TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1e-5); - } + SANITY_CHECK(dst); + } + else if (RUN_PLAIN_IMPL) + { + TEST_CYCLE() cv::flip(src, dst, 0); + SANITY_CHECK(dst); } + else + OCL_PERF_ELSE } ///////////// 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 Size_MatType minMaxFixture; - gen(src, size, size, all_type[j], 0, 256); +PERF_TEST_P(minMaxFixture, minMax, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + OCL_PERF_ENUM(CV_8UC1, CV_32FC1))) +{ + const Size_MatType_t params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params); - CPU_ON; - minMaxLoc(src, &min_val, &max_val, &min_loc, &max_loc); - CPU_OFF; - d_src.upload(src); + Mat src(srcSize, type); + declare.in(src, WARMUP_RNG); - WARMUP_ON; - ocl::minMax(d_src, &min_val_, &max_val_); - WARMUP_OFF; + double min_val = std::numeric_limits::max(), + max_val = std::numeric_limits::min(); - 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))); + if (RUN_OCL_IMPL) + { + 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 (RUN_PLAIN_IMPL) + { + 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); } + else + OCL_PERF_ELSE } ///////////// minMaxLoc //////////////////////// -PERFTEST(minMaxLoc) + +typedef Size_MatType minMaxLocFixture; + +PERF_TEST_P(minMaxLocFixture, minMaxLoc, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + OCL_PERF_ENUM(CV_8UC1, CV_32FC1))) { - Mat src; - ocl::oclMat d_src; + const Size_MatType_t params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params); + + 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) + if (RUN_OCL_IMPL) { - 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 (RUN_PLAIN_IMPL) + { + 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); } + else + OCL_PERF_ELSE } ///////////// 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); +typedef Size_MatType SumFixture; - cpures = sum(src); - - CPU_ON; - cpures = sum(src); - CPU_OFF; - d_src.upload(src); +PERF_TEST_P(SumFixture, Sum, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + OCL_PERF_ENUM(CV_8UC1, CV_32SC1))) +{ + const Size_MatType_t params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params); - WARMUP_ON; - gpures = ocl::sum(d_src); - WARMUP_OFF; + Mat src(srcSize, type); + Scalar result; + randu(src, 0, 60); + declare.in(src); - 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); + if (RUN_OCL_IMPL) + { + 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 (RUN_PLAIN_IMPL) + { + TEST_CYCLE() result = cv::sum(src); + SANITY_CHECK(result); } + else + OCL_PERF_ELSE } ///////////// countNonZero //////////////////////// -PERFTEST(countNonZero) -{ - Mat src; - ocl::oclMat d_src; - - 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] ; - - gen(src, size, size, all_type[j], 0, 256); - - countNonZero(src); +typedef Size_MatType countNonZeroFixture; - int cpures = 0, gpures = 0; - CPU_ON; - cpures = countNonZero(src); - CPU_OFF; - d_src.upload(src); +PERF_TEST_P(countNonZeroFixture, countNonZero, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + OCL_PERF_ENUM(CV_8UC1, CV_32FC1))) +{ + const Size_MatType_t params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params); - WARMUP_ON; - gpures = ocl::countNonZero(d_src); - WARMUP_OFF; + Mat src(srcSize, type); + int result = 0; + randu(src, 0, 256); + declare.in(src); - int diff = abs(cpures - gpures); - if(diff == 0) - TestSystem::instance().setAccurate(1, 0); - else - TestSystem::instance().setAccurate(0, diff); + if (RUN_OCL_IMPL) + { + 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 (RUN_PLAIN_IMPL) + { + TEST_CYCLE() result = cv::countNonZero(src); + SANITY_CHECK(result); } + else + OCL_PERF_ELSE } ///////////// 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"}; - - 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); - gen(dst, size, size, all_type[j], 0, 256); +typedef TestBaseWithParam PhaseFixture; - phase(src1, src2, dst, 1); - - CPU_ON; - phase(src1, src2, dst, 1); - CPU_OFF; +PERF_TEST_P(PhaseFixture, Phase, OCL_TYPICAL_MAT_SIZES) +{ + const Size srcSize = GetParam(); - d_src1.upload(src1); - d_src2.upload(src2); + 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); - WARMUP_ON; - ocl::phase(d_src1, d_src2, d_dst, 1); - WARMUP_OFF; + if (RUN_OCL_IMPL) + { + ocl::oclMat oclSrc1(src1), oclSrc2(src2), + oclDst(srcSize, src1.type()); - GPU_ON; - ocl::phase(d_src1, d_src2, d_dst, 1); - GPU_OFF; + TEST_CYCLE() cv::ocl::phase(oclSrc1, oclSrc2, oclDst, 1); - 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; + oclDst.download(dst); - TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 1e-2); - } + SANITY_CHECK(dst, 1e-2); + } + else if (RUN_PLAIN_IMPL) + { + TEST_CYCLE() cv::phase(src1, src2, dst, 1); + SANITY_CHECK(dst, 1e-2); } + else + OCL_PERF_ELSE } ///////////// 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"}; - - 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); - gen(dst, size, size, all_type[j], 0, 256); +typedef Size_MatType BitwiseAndFixture; - bitwise_and(src1, src2, dst); +PERF_TEST_P(BitwiseAndFixture, bitwise_and, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + OCL_PERF_ENUM(CV_8UC1, CV_32SC1))) +{ + const Size_MatType_t params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params); - CPU_ON; - bitwise_and(src1, src2, dst); - CPU_OFF; - d_src1.upload(src1); - d_src2.upload(src2); + Mat src1(srcSize, type), src2(srcSize, type), dst(srcSize, type); + declare.in(src1, src2).out(dst); + randu(src1, 0, 256); + randu(src2, 0, 256); - WARMUP_ON; - ocl::bitwise_and(d_src1, d_src2, d_dst); - WARMUP_OFF; + if (RUN_OCL_IMPL) + { + ocl::oclMat oclSrc1(src1), oclSrc2(src2), oclDst(srcSize, src1.type()); - GPU_ON; - ocl::bitwise_and(d_src1, d_src2, d_dst); - GPU_OFF; + TEST_CYCLE() cv::ocl::bitwise_and(oclSrc1, oclSrc2, oclDst); - 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; + oclDst.download(dst); - TestSystem::instance().ExpectedMatNear(ocl_dst, dst, 0.0); - } + SANITY_CHECK(dst); + } + else if (RUN_PLAIN_IMPL) + { + TEST_CYCLE() cv::bitwise_and(src1, src2, dst); + SANITY_CHECK(dst); } + else + OCL_PERF_ELSE } ///////////// 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"}; - 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 Size_MatType BitwiseNotFixture; - gen(src1, size, size, all_type[j], 0, 256); - gen(dst, size, size, all_type[j], 0, 256); - - bitwise_not(src1, dst); +PERF_TEST_P(BitwiseAndFixture, bitwise_not, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + OCL_PERF_ENUM(CV_8UC1, CV_32SC1))) +{ + const Size_MatType_t params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params); - CPU_ON; - bitwise_not(src1, dst); - CPU_OFF; - d_src1.upload(src1); + Mat src(srcSize, type), dst(srcSize, type); + declare.in(src, WARMUP_RNG).out(dst); - WARMUP_ON; - ocl::bitwise_not(d_src1, d_dst); - WARMUP_OFF; + if (RUN_OCL_IMPL) + { + ocl::oclMat oclSrc(src), oclDst(srcSize, type); - GPU_ON; - ocl::bitwise_not(d_src1, d_dst); - GPU_OFF; + TEST_CYCLE() cv::ocl::bitwise_not(oclSrc, oclDst); - GPU_FULL_ON; - d_src1.upload(src1); - ocl::bitwise_not(d_src1, 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 (RUN_PLAIN_IMPL) + { + TEST_CYCLE() cv::bitwise_not(src, dst); + SANITY_CHECK(dst); } + else + OCL_PERF_ELSE } ///////////// 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"}; - - 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); - gen(dst, size, size, all_type[j], 0, 256); - compare(src1, src2, dst, CMP_EQ); +typedef Size_MatType CompareFixture; - CPU_ON; - compare(src1, src2, dst, CMP_EQ); - CPU_OFF; +PERF_TEST_P(CompareFixture, compare, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + OCL_PERF_ENUM(CV_8UC1, CV_32FC1))) +{ + const Size_MatType_t params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params); - d_src1.upload(src1); - d_src2.upload(src2); + Mat src1(srcSize, type), src2(srcSize, type), dst(srcSize, CV_8UC1); + declare.in(src1, src2, WARMUP_RNG).out(dst); - WARMUP_ON; - ocl::compare(d_src1, d_src2, d_dst, CMP_EQ); - WARMUP_OFF; + if (RUN_OCL_IMPL) + { + 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 (RUN_PLAIN_IMPL) + { + TEST_CYCLE() cv::compare(src1, src2, dst, CMP_EQ); + SANITY_CHECK(dst); } + else + OCL_PERF_ELSE } ///////////// 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) +{ + const Size srcSize = GetParam(); - CPU_ON; - pow(src, -2.0, dst); - CPU_OFF; - d_src.upload(src); - d_dst.upload(dst); + 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; + if (RUN_OCL_IMPL) + { + 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 (RUN_PLAIN_IMPL) + { + TEST_CYCLE() cv::pow(src, -2.0, dst); + SANITY_CHECK(dst, 5e-2); } + else + OCL_PERF_ELSE } ///////////// 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]; - 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); +typedef TestBaseWithParam MagnitudeSqrFixture; - 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) +{ + const Size srcSize = GetParam(); - } - CPU_OFF; + 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); + if (RUN_OCL_IMPL) + { + 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 (RUN_PLAIN_IMPL) + { + 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); } + else + OCL_PERF_ELSE } ///////////// AddWeighted//////////////////////// -PERFTEST(AddWeighted) + +typedef Size_MatType AddWeightedFixture; + +PERF_TEST_P(AddWeightedFixture, AddWeighted, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + OCL_PERF_ENUM(CV_8UC1, CV_32FC1))) { - Mat src1, src2, dst, ocl_dst; - ocl::oclMat d_src1, d_src2, d_dst; + const Size_MatType_t params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params); + 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) + if (RUN_OCL_IMPL) { - 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 (RUN_PLAIN_IMPL) + { + TEST_CYCLE() cv::addWeighted(src1, alpha, src2, beta, gama, dst); + SANITY_CHECK(dst); } + else + OCL_PERF_ELSE } diff --git a/modules/ocl/perf/perf_blend.cpp b/modules/ocl/perf/perf_blend.cpp index 11eea64fbf..ea53c8a66d 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,46 @@ 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; + const Size srcSize = GetParam(); + const int type = CV_8UC1; + + 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) + if (RUN_OCL_IMPL) { - 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 (RUN_PLAIN_IMPL) + { + TEST_CYCLE() blendLinearGold(src1, src2, weights1, weights2, dst); + + SANITY_CHECK(dst); } + else + OCL_PERF_ELSE } diff --git a/modules/ocl/perf/perf_brute_force_matcher.cpp b/modules/ocl/perf/perf_brute_force_matcher.cpp index 14df629e96..af93b1b103 100644 --- a/modules/ocl/perf/perf_brute_force_matcher.cpp +++ b/modules/ocl/perf/perf_brute_force_matcher.cpp @@ -45,123 +45,119 @@ //M*/ #include "perf_precomp.hpp" -//////////////////// BruteForceMatch ///////////////// -PERFTEST(BruteForceMatcher) -{ - Mat trainIdx_cpu; - Mat distance_cpu; - Mat allDist_cpu; - Mat nMatches_cpu; - - for (int size = Min_Size; size <= Max_Size; size *= Multiple) - { - // Init CPU matcher - int desc_len = 64; - - BFMatcher matcher(NORM_L2); - - 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); - // Init GPU matcher - ocl::BruteForceMatcher_OCL_base d_matcher(ocl::BruteForceMatcher_OCL_base::L2Dist); +using namespace perf; - ocl::oclMat d_query(query); - ocl::oclMat d_train(train); +#define OCL_BFMATCHER_TYPICAL_MAT_SIZES ::testing::Values(cv::Size(128, 500), cv::Size(128, 1000), cv::Size(128, 2000)) - ocl::oclMat d_trainIdx, d_distance, d_allDist, d_nMatches; - - SUBTEST << size << "; match"; - - matcher.match(query, train, matches[0]); +//////////////////// BruteForceMatch ///////////////// - CPU_ON; - matcher.match(query, train, matches[0]); - CPU_OFF; +typedef TestBaseWithParam BruteForceMatcherFixture; - WARMUP_ON; - d_matcher.matchSingle(d_query, d_train, d_trainIdx, d_distance); - WARMUP_OFF; +PERF_TEST_P(BruteForceMatcherFixture, DISABLED_match, + OCL_BFMATCHER_TYPICAL_MAT_SIZES) // TODO too big difference between implementations +{ + const Size srcSize = GetParam(); - GPU_ON; - d_matcher.matchSingle(d_query, d_train, d_trainIdx, d_distance); - GPU_OFF; + 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); - 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 (RUN_PLAIN_IMPL) + { + BFMatcher matcher(NORM_L2); + TEST_CYCLE() matcher.match(query, train, matches); - 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); + SANITY_CHECK_MATCHES(matches); + } + else if (RUN_OCL_IMPL) + { + ocl::BruteForceMatcher_OCL_base oclMatcher(ocl::BruteForceMatcher_OCL_base::L2Dist); + ocl::oclMat oclQuery(query), oclTrain(train); - SUBTEST << size << "; knnMatch"; + TEST_CYCLE() oclMatcher.match(oclQuery, oclTrain, matches); - matcher.knnMatch(query, train, matches, 2); + SANITY_CHECK_MATCHES(matches); + } + else + OCL_PERF_ELSE +} - CPU_ON; - matcher.knnMatch(query, train, matches, 2); - CPU_OFF; +PERF_TEST_P(BruteForceMatcherFixture, DISABLED_knnMatch, + OCL_BFMATCHER_TYPICAL_MAT_SIZES) // TODO too many outliers +{ + const Size srcSize = GetParam(); - WARMUP_ON; - d_matcher.knnMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_allDist, 2); - 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.knnMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_allDist, 2); - 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.knnMatch(d_query, d_train, d_matches, 2); - GPU_FULL_OFF; + if (RUN_PLAIN_IMPL) + { + BFMatcher matcher (NORM_L2); + TEST_CYCLE() matcher.knnMatch(query, train, matches, 2); - 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 (RUN_OCL_IMPL) + { + ocl::BruteForceMatcher_OCL_base oclMatcher(ocl::BruteForceMatcher_OCL_base::L2Dist); + ocl::oclMat oclQuery(query), oclTrain(train); - SUBTEST << size << "; radiusMatch"; + TEST_CYCLE() oclMatcher.knnMatch(oclQuery, oclTrain, matches, 2); - float max_distance = 2.0f; + std::vector & matches0 = matches[0], & matches1 = matches[1]; + SANITY_CHECK_MATCHES(matches0); + SANITY_CHECK_MATCHES(matches1); + } + else + OCL_PERF_ELSE +} - matcher.radiusMatch(query, train, matches, max_distance); +PERF_TEST_P(BruteForceMatcherFixture, DISABLED_radiusMatch, + OCL_BFMATCHER_TYPICAL_MAT_SIZES) // TODO too many outliers +{ + const Size srcSize = GetParam(); - 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 (RUN_PLAIN_IMPL) + { + 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 (RUN_OCL_IMPL) + { + 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); } + else + OCL_PERF_ELSE } + +#undef OCL_BFMATCHER_TYPICAL_MAT_SIZES diff --git a/modules/ocl/perf/perf_calib3d.cpp b/modules/ocl/perf/perf_calib3d.cpp index ff6c6f2615..a155fc371a 100644 --- a/modules/ocl/perf/perf_calib3d.cpp +++ b/modules/ocl/perf/perf_calib3d.cpp @@ -45,48 +45,44 @@ //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) // TODO doesn't work properly +{ + 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 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 (RUN_OCL_IMPL) + { + 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 (RUN_PLAIN_IMPL) + { + 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); + } + else + OCL_PERF_ELSE } diff --git a/modules/ocl/perf/perf_canny.cpp b/modules/ocl/perf/perf_canny.cpp index 6f85ee8a43..3a5c633f56 100644 --- a/modules/ocl/perf/perf_canny.cpp +++ b/modules/ocl/perf/perf_canny.cpp @@ -45,41 +45,33 @@ //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, DISABLED_Canny) // TODO difference between implmentations +{ + Mat img = imread(getDataPath("gpu/stereobm/aloe-L.png"), cv::IMREAD_GRAYSCALE), + edges(img.size(), CV_8UC1); + ASSERT_TRUE(!img.empty()) << "can't open aloe-L.png"; - ocl::oclMat d_img(img); - ocl::oclMat d_edges; - ocl::CannyBuf d_buf; + declare.in(img).out(edges); - WARMUP_ON; - ocl::Canny(d_img, d_buf, d_edges, 50.0, 100.0); - WARMUP_OFF; + if (RUN_OCL_IMPL) + { + 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() ocl::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 (RUN_PLAIN_IMPL) + { + TEST_CYCLE() Canny(img, edges, 50.0, 100.0); - TestSystem::instance().ExceptedMatSimilar(edges, ocl_edges, 2e-2); + SANITY_CHECK(edges); + } + else + OCL_PERF_ELSE } diff --git a/modules/ocl/perf/perf_color.cpp b/modules/ocl/perf/perf_color.cpp index 1934417448..703cc36cec 100644 --- a/modules/ocl/perf/perf_color.cpp +++ b/modules/ocl/perf/perf_color.cpp @@ -45,49 +45,34 @@ //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(); - 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, WARMUP_RNG).out(dst); - TestSystem::instance().ExceptedMatSimilar(dst, ocl_dst, 1e-5); - } + if (RUN_OCL_IMPL) + { + 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 (RUN_PLAIN_IMPL) + { + TEST_CYCLE() cv::cvtColor(src, dst, CV_RGBA2GRAY, 4); - + SANITY_CHECK(dst); + } + else + OCL_PERF_ELSE } diff --git a/modules/ocl/perf/perf_fft.cpp b/modules/ocl/perf/perf_fft.cpp index ce9949b7a0..ae0291c3e6 100644 --- a/modules/ocl/perf/perf_fft.cpp +++ b/modules/ocl/perf/perf_fft.cpp @@ -45,47 +45,39 @@ //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"}; +using namespace perf; - 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"; +///////////// dft //////////////////////// - gen(src, size, size, all_type[j], Scalar::all(0), Scalar::all(1)); +typedef TestBaseWithParam dftFixture; - dft(src, dst); +PERF_TEST_P(dftFixture, DISABLED_dft, OCL_TYPICAL_MAT_SIZES) // TODO not implemented +{ + const Size srcSize = GetParam(); - CPU_ON; - dft(src, dst); - CPU_OFF; + Mat src(srcSize, CV_32FC2), dst; + randu(src, 0.0f, 1.0f); + declare.in(src); - d_src.upload(src); + if (srcSize == OCL_SIZE_4000) + declare.time(7.4); - WARMUP_ON; - ocl::dft(d_src, d_dst, Size(size, size)); - WARMUP_OFF; + if (RUN_OCL_IMPL) + { + ocl::oclMat oclSrc(src), oclDst; - GPU_ON; - ocl::dft(d_src, d_dst, Size(size, size)); - GPU_OFF; + 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 (RUN_PLAIN_IMPL) + { + TEST_CYCLE() cv::dft(src, dst); + SANITY_CHECK(dst); } + else + OCL_PERF_ELSE } diff --git a/modules/ocl/perf/perf_filters.cpp b/modules/ocl/perf/perf_filters.cpp index e4204cbbd1..588c0569ea 100644 --- a/modules/ocl/perf/perf_filters.cpp +++ b/modules/ocl/perf/perf_filters.cpp @@ -45,333 +45,279 @@ //M*/ #include "perf_precomp.hpp" -///////////// Blur//////////////////////// -PERFTEST(Blur) -{ - Mat src1, dst, ocl_dst; - ocl::oclMat d_src1, d_dst; +using namespace perf; +using std::tr1::get; +using std::tr1::tuple; - Size ksize = Size(3, 3); - 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) - { - for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++) - { - SUBTEST << size << 'x' << size << "; " << type_name[j] ; +///////////// Blur//////////////////////// - gen(src1, size, size, all_type[j], 0, 256); - gen(dst, size, size, all_type[j], 0, 256); +typedef Size_MatType BlurFixture; - blur(src1, dst, ksize, Point(-1, -1), bordertype); +PERF_TEST_P(BlurFixture, Blur, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + OCL_PERF_ENUM(CV_8UC1, CV_8UC4))) +{ + const Size_MatType_t params = GetParam(); + const Size srcSize = get<0>(params), ksize(3, 3); + const int type = get<1>(params), bordertype = BORDER_CONSTANT; - 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 (RUN_OCL_IMPL) + { + 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 (RUN_PLAIN_IMPL) + { + TEST_CYCLE() cv::blur(src, dst, ksize, Point(-1, -1), bordertype); + SANITY_CHECK(dst, 1 + DBL_EPSILON); } + else + OCL_PERF_ELSE } -///////////// 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"}; - 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] ; +///////////// Laplacian//////////////////////// - gen(src1, size, size, all_type[j], 0, 256); - gen(dst, size, size, all_type[j], 0, 256); +typedef Size_MatType LaplacianFixture; - Laplacian(src1, dst, -1, ksize, 1); +PERF_TEST_P(LaplacianFixture, Laplacian, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + OCL_PERF_ENUM(CV_8UC1, CV_8UC4))) +{ + const Size_MatType_t params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params), ksize = 3; - 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 (RUN_OCL_IMPL) + { + 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 (RUN_PLAIN_IMPL) + { + TEST_CYCLE() cv::Laplacian(src, dst, -1, ksize, 1); + SANITY_CHECK(dst); } + else + OCL_PERF_ELSE } ///////////// 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"}; - 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], Scalar::all(0), Scalar::all(256)); - ker = getStructuringElement(MORPH_RECT, Size(3, 3)); +typedef Size_MatType ErodeFixture; - erode(src, dst, ker); +PERF_TEST_P(ErodeFixture, Erode, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + OCL_PERF_ENUM(CV_8UC1, CV_8UC4, CV_32FC1, CV_32FC4))) +{ + const Size_MatType_t 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)); - 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 (RUN_OCL_IMPL) + { + 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 (RUN_PLAIN_IMPL) + { + TEST_CYCLE() cv::erode(src, dst, ker); + SANITY_CHECK(dst); } + else + OCL_PERF_ELSE } ///////////// 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] ; - - gen(src, size, size, all_type[j], 0, 256); +typedef Size_MatType SobelFixture; - Sobel(src, dst, -1, dx, dy); +PERF_TEST_P(SobelFixture, Sobel, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + OCL_PERF_ENUM(CV_8UC1, CV_8UC4))) +{ + const Size_MatType_t params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params), dx = 1, dy = 1; - 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 (RUN_OCL_IMPL) + { + 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 (RUN_PLAIN_IMPL) + { + TEST_CYCLE() cv::Sobel(src, dst, -1, dx, dy); + SANITY_CHECK(dst); } + else + OCL_PERF_ELSE } -///////////// 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"}; - - 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] ; +///////////// Scharr //////////////////////// - gen(src, size, size, all_type[j], 0, 256); +typedef Size_MatType ScharrFixture; - Scharr(src, dst, -1, dx, dy); +PERF_TEST_P(ScharrFixture, Scharr, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + OCL_PERF_ENUM(CV_8UC1, CV_8UC4))) +{ + const Size_MatType_t params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params), dx = 1, dy = 0; - 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 (RUN_OCL_IMPL) + { + 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 (RUN_PLAIN_IMPL) + { + TEST_CYCLE() cv::Scharr(src, dst, -1, dx, dy); + SANITY_CHECK(dst); } + else + OCL_PERF_ELSE } ///////////// 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] ; - - gen(src, size, size, all_type[j], 0, 256); +typedef Size_MatType GaussianBlurFixture; - GaussianBlur(src, dst, Size(ksize, ksize), 0); +PERF_TEST_P(GaussianBlurFixture, GaussianBlur, + ::testing::Combine(::testing::Values(OCL_SIZE_1000, OCL_SIZE_2000), + OCL_PERF_ENUM(CV_8UC1, CV_8UC4, CV_32FC1, CV_32FC4))) +{ + const Size_MatType_t params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params), ksize = 7; - 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 (RUN_OCL_IMPL) + { + 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 (RUN_PLAIN_IMPL) + { + TEST_CYCLE() cv::GaussianBlur(src, dst, Size(ksize, ksize), 0); + SANITY_CHECK(dst, eps); } + else + OCL_PERF_ELSE } ///////////// 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 Size_MatType filter2DFixture; - Mat dst, ocl_dst; - - cv::filter2D(src, dst, -1, kernel); - - CPU_ON; - cv::filter2D(src, dst, -1, kernel); - CPU_OFF; - - ocl::oclMat d_src(src), d_dst; +PERF_TEST_P(filter2DFixture, filter2D, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + OCL_PERF_ENUM(CV_8UC1, CV_8UC4))) +{ + const Size_MatType_t params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params), ksize = 3; - 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 (RUN_OCL_IMPL) + { + 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 (RUN_PLAIN_IMPL) + { + TEST_CYCLE() cv::filter2D(src, dst, -1, kernel); + SANITY_CHECK(dst); } + else + OCL_PERF_ELSE } diff --git a/modules/ocl/perf/perf_gemm.cpp b/modules/ocl/perf/perf_gemm.cpp index aa04b9c3ae..fb68b92f72 100644 --- a/modules/ocl/perf/perf_gemm.cpp +++ b/modules/ocl/perf/perf_gemm.cpp @@ -45,46 +45,40 @@ //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) // TODO not implemented +{ + const Size srcSize = GetParam(); - 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 (RUN_OCL_IMPL) + { + 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 (RUN_PLAIN_IMPL) + { + 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); } + else + OCL_PERF_ELSE } diff --git a/modules/ocl/perf/perf_gftt.cpp b/modules/ocl/perf/perf_gftt.cpp index 430d441430..7fe16c2082 100644 --- a/modules/ocl/perf/perf_gftt.cpp +++ b/modules/ocl/perf/perf_gftt.cpp @@ -46,56 +46,50 @@ #include "perf_precomp.hpp" -///////////// GoodFeaturesToTrack //////////////////////// -PERFTEST(GoodFeaturesToTrack) -{ - using namespace cv; - - int maxCorners = 2000; - double qualityLevel = 0.01; +using namespace perf; +using std::tr1::tuple; +using std::tr1::get; - 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()); +///////////// GoodFeaturesToTrack //////////////////////// - for(float minDistance = 0; minDistance < 4; minDistance += 3.0) - { - SUBTEST << "image = " << images[imgIdx] << "; "; - SUBTEST << "minDistance = " << minDistance << "; "; +typedef tuple GoodFeaturesToTrackParams; +typedef TestBaseWithParam GoodFeaturesToTrackFixture; - cv::goodFeaturesToTrack(frame, pts_gold, maxCorners, qualityLevel, minDistance); +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))) +{ - CPU_ON; - cv::goodFeaturesToTrack(frame, pts_gold, maxCorners, qualityLevel, minDistance); - CPU_OFF; + const GoodFeaturesToTrackParams param = GetParam(); + const string fileName = getDataPath(get<0>(param)); + const int maxCorners = 2000; + const double qualityLevel = 0.01, minDistance = get<1>(param); - cv::ocl::GoodFeaturesToTrackDetector_OCL detector(maxCorners, qualityLevel, minDistance); + Mat frame = imread(fileName, IMREAD_GRAYSCALE); + ASSERT_TRUE(!frame.empty()) << "no input image"; - ocl::oclMat frame_ocl(frame), pts_oclmat; + vector pts_gold; + declare.in(frame); - WARMUP_ON; - detector(frame_ocl, pts_oclmat); - WARMUP_OFF; + if (RUN_OCL_IMPL) + { + ocl::oclMat oclFrame(frame), pts_oclmat; + 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 (RUN_PLAIN_IMPL) + { + 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); } + else + OCL_PERF_ELSE } diff --git a/modules/ocl/perf/perf_haar.cpp b/modules/ocl/perf/perf_haar.cpp index ea1a4745a5..eac2b516fd 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,39 @@ public: } } -PERFTEST(Haar) -{ - Mat img = imread(abspath("basketball1.png"), CV_LOAD_IMAGE_GRAYSCALE); - - if (img.empty()) - { - throw runtime_error("can't open basketball1.png"); - } - - CascadeClassifier faceCascadeCPU; - - if (!faceCascadeCPU.load(abspath("haarcascade_frontalface_alt.xml"))) - { - throw runtime_error("can't load haarcascade_frontalface_alt.xml"); - } +PERF_TEST(HaarFixture, Haar) +{ vector faces; - 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; + 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 (RUN_PLAIN_IMPL) + { + CascadeClassifier faceCascade; + 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(img, 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); } + else if (RUN_OCL_IMPL) + { + ocl::CascadeClassifier_GPU faceCascade; + ocl::oclMat oclImg(img); - ocl::oclMat d_img(img); + ASSERT_TRUE(faceCascade.load(getDataPath("gpu/haarcascade/haarcascade_frontalface_alt.xml"))) + << "can't load haarcascade_frontalface_alt.xml"; - WARMUP_ON; - faceCascade.detectMultiScale(d_img, oclfaces, - 1.1, 2, 0 | CV_HAAR_SCALE_IMAGE, Size(30, 30)); - WARMUP_OFF; + TEST_CYCLE() faceCascade.detectMultiScale(oclImg, faces, + 1.1, 2, 0 | CV_HAAR_SCALE_IMAGE, Size(30, 30)); - if(faces.size() == oclfaces.size()) - TestSystem::instance().setAccurate(1, 0); + SANITY_CHECK(faces, 4 + 1e-4); + } 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; + OCL_PERF_ELSE } diff --git a/modules/ocl/perf/perf_hog.cpp b/modules/ocl/perf/perf_hog.cpp index e6d85b5dc0..2288215f48 100644 --- a/modules/ocl/perf/perf_hog.cpp +++ b/modules/ocl/perf/perf_hog.cpp @@ -45,50 +45,37 @@ //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"); - } - - cv::HOGDescriptor hog; - hog.setSVMDetector(hog.getDefaultPeopleDetector()); - std::vector found_locations; - std::vector d_found_locations; + Mat src = imread(getDataPath("gpu/hog/road.png"), cv::IMREAD_GRAYSCALE); + ASSERT_TRUE(!src.empty()) << "can't open input image road.png"; - SUBTEST << src.cols << 'x' << src.rows << "; road.png"; + vector found_locations; + declare.in(src).time(5); - hog.detectMultiScale(src, found_locations); + if (RUN_PLAIN_IMPL) + { + 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 (RUN_OCL_IMPL) + { + 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); + } 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; + OCL_PERF_ELSE } diff --git a/modules/ocl/perf/perf_imgproc.cpp b/modules/ocl/perf/perf_imgproc.cpp index 2ed64ce325..f530e2602b 100644 --- a/modules/ocl/perf/perf_imgproc.cpp +++ b/modules/ocl/perf/perf_imgproc.cpp @@ -45,295 +45,237 @@ //M*/ #include "perf_precomp.hpp" -///////////// equalizeHist //////////////////////// -PERFTEST(equalizeHist) -{ - Mat src, dst, ocl_dst; - int all_type[] = {CV_8UC1}; - std::string type_name[] = {"CV_8UC1"}; - - 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); +using namespace perf; +using std::tr1::tuple; +using std::tr1::get; - 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) +{ + const Size srcSize = GetParam(); - WARMUP_ON; - ocl::equalizeHist(d_src, d_dst); - WARMUP_OFF; + 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; + if (RUN_OCL_IMPL) + { + 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 (RUN_PLAIN_IMPL) { - 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); + } + else + OCL_PERF_ELSE +} - gen(src, size, size, all_type[j], 0, 256); +/////////// CopyMakeBorder ////////////////////// - copyMakeBorder(src, dst, 7, 5, 5, 7, bordertype, cv::Scalar(1.0)); +typedef Size_MatType CopyMakeBorderFixture; - CPU_ON; - copyMakeBorder(src, dst, 7, 5, 5, 7, bordertype, cv::Scalar(1.0)); - CPU_OFF; +PERF_TEST_P(CopyMakeBorderFixture, CopyMakeBorder, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + OCL_PERF_ENUM(CV_8UC1, CV_8UC4))) +{ + const Size_MatType_t params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params), borderType = BORDER_CONSTANT; - ocl::oclMat d_src(src); + Mat src(srcSize, type), dst; + const Size dstSize = srcSize + Size(12, 12); + dst.create(dstSize, type); + declare.in(src, WARMUP_RNG).out(dst); - WARMUP_ON; - ocl::copyMakeBorder(d_src, d_dst, 7, 5, 5, 7, bordertype, cv::Scalar(1.0)); - WARMUP_OFF; + if (RUN_OCL_IMPL) + { + 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 (RUN_PLAIN_IMPL) + { + TEST_CYCLE() cv::copyMakeBorder(src, dst, 7, 5, 5, 7, borderType, cv::Scalar(1.0)); + SANITY_CHECK(dst); } + else + OCL_PERF_ELSE } -///////////// 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"}; - - 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); +///////////// cornerMinEigenVal //////////////////////// - cornerMinEigenVal(src, dst, blockSize, apertureSize, borderType); +typedef Size_MatType cornerMinEigenValFixture; - CPU_ON; - cornerMinEigenVal(src, dst, blockSize, apertureSize, borderType); - CPU_OFF; +PERF_TEST_P(cornerMinEigenValFixture, cornerMinEigenVal, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + OCL_PERF_ENUM(CV_8UC1, CV_32FC1))) +{ + const Size_MatType_t 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; - ocl::oclMat d_src(src); + 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; + if (RUN_OCL_IMPL) + { + 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 (RUN_PLAIN_IMPL) { - 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); + } + else + OCL_PERF_ELSE +} - cornerHarris(src, dst, 5, 7, 0.1, BORDER_REFLECT); +///////////// cornerHarris //////////////////////// - CPU_ON; - cornerHarris(src, dst, 5, 7, 0.1, BORDER_REFLECT); - CPU_OFF; +typedef Size_MatType cornerHarrisFixture; - d_src.upload(src); +PERF_TEST_P(cornerHarrisFixture, cornerHarris, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + OCL_PERF_ENUM(CV_8UC1, CV_32FC1))) +{ + const Size_MatType_t 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; + 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_ON; - ocl::cornerHarris(d_src, d_dst, 5, 7, 0.1, BORDER_REFLECT); - GPU_OFF; + if (RUN_OCL_IMPL) + { + ocl::oclMat oclSrc(src), oclDst(srcSize, CV_32FC1); - 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; - - 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 (RUN_PLAIN_IMPL) { - 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); + } + else + OCL_PERF_ELSE +} - 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) // TODO does not work properly +{ + const Size srcSize = GetParam(); - WARMUP_ON; - ocl::integral(d_src, d_sum); - WARMUP_OFF; + Mat src(srcSize, CV_8UC1), dst; + declare.in(src, WARMUP_RNG); - GPU_ON; - ocl::integral(d_src, d_sum); - GPU_OFF; + if (RUN_OCL_IMPL) + { + 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 (RUN_PLAIN_IMPL) + { + TEST_CYCLE() cv::integral(src, dst); + SANITY_CHECK(dst); } + else + OCL_PERF_ELSE } + ///////////// WarpAffine //////////////////////// -PERFTEST(WarpAffine) -{ - Mat src, dst, ocl_dst; - ocl::oclMat d_src, d_dst; +typedef Size_MatType WarpAffineFixture; + +PERF_TEST_P(WarpAffineFixture, WarpAffine, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + OCL_PERF_ENUM(CV_8UC1, CV_8UC4))) +{ 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"}; + const Size_MatType_t params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params); + Mat src(srcSize, type), dst(srcSize, type); + declare.in(src, WARMUP_RNG).out(dst); - for (int size = Min_Size; size <= Max_Size; size *= Multiple) + if (RUN_OCL_IMPL) { - 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); + ocl::oclMat oclSrc(src), oclDst(srcSize, type); - CPU_ON; - warpAffine(src, dst, M, size1, interpolation); - CPU_OFF; + TEST_CYCLE() cv::ocl::warpAffine(oclSrc, oclDst, M, srcSize, interpolation); - d_src.upload(src); + oclDst.download(dst); - WARMUP_ON; - ocl::warpAffine(d_src, d_dst, M, size1, interpolation); - WARMUP_OFF; - - GPU_ON; - ocl::warpAffine(d_src, d_dst, M, size1, interpolation); - GPU_OFF; - - 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 (RUN_PLAIN_IMPL) + { + TEST_CYCLE() cv::warpAffine(src, dst, M, srcSize, interpolation); + SANITY_CHECK(dst); } + else + OCL_PERF_ELSE } + ///////////// WarpPerspective //////////////////////// -PERFTEST(WarpPerspective) -{ - Mat src, dst, ocl_dst; - ocl::oclMat d_src, d_dst; +typedef Size_MatType WarpPerspectiveFixture; + +PERF_TEST_P(WarpPerspectiveFixture, WarpPerspective, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + OCL_PERF_ENUM(CV_8UC1, CV_8UC4))) +{ static const double coeffs[3][3] = { {cos(CV_PI / 6), -sin(CV_PI / 6), 100.0}, @@ -341,199 +283,129 @@ 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"}; + const int interpolation = INTER_LINEAR; - 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); + const Size_MatType_t params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params); - warpPerspective(src, dst, M, size1, interpolation); + 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); - CPU_ON; - warpPerspective(src, dst, M, size1, interpolation); - CPU_OFF; - - d_src.upload(src); - - WARMUP_ON; - ocl::warpPerspective(d_src, d_dst, M, size1, interpolation); - WARMUP_OFF; + if (RUN_OCL_IMPL) + { + 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 (RUN_PLAIN_IMPL) + { + TEST_CYCLE() cv::warpPerspective(src, dst, M, srcSize, interpolation); + SANITY_CHECK(dst); } + else + OCL_PERF_ELSE } ///////////// 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 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, + OCL_PERF_ENUM(CV_8UC1, CV_8UC4), + resizeInterType::all(), + ::testing::Values(0.5, 2.0))) +{ + const resizeParams params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params), interType = get<2>(params); + double scale = get<3>(params); + + 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); + + if (RUN_OCL_IMPL) { - 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); - - resize(src, dst, Size(), 2.0, 2.0); - - 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; + ocl::oclMat oclSrc(src), oclDst(dstSize, type); - GPU_ON; - ocl::resize(d_src, d_dst, Size(), 2.0, 2.0); - GPU_OFF; + TEST_CYCLE() cv::ocl::resize(oclSrc, oclDst, Size(), scale, scale, interType); - 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 (RUN_PLAIN_IMPL) { - 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); } + else + OCL_PERF_ELSE } -///////////// 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"; +///////////// threshold//////////////////////// - gen(src, size, size, CV_8U, 0, 100); +CV_ENUM(ThreshType, THRESH_BINARY, THRESH_TRUNC) - threshold(src, dst, 50.0, 0.0, THRESH_BINARY); +typedef tuple ThreshParams; +typedef TestBaseWithParam ThreshFixture; - CPU_ON; - threshold(src, dst, 50.0, 0.0, THRESH_BINARY); - CPU_OFF; +PERF_TEST_P(ThreshFixture, threshold, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + ThreshType::all())) +{ + const ThreshParams params = GetParam(); + const Size srcSize = get<0>(params); + const int threshType = get<1>(params); - d_src.upload(src); + Mat src(srcSize, CV_8U), dst(srcSize, CV_8U); + randu(src, 0, 100); + declare.in(src).out(dst); - WARMUP_ON; - ocl::threshold(d_src, d_dst, 50.0, 0.0, THRESH_BINARY); - WARMUP_OFF; + if (RUN_OCL_IMPL) + { + 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 (RUN_PLAIN_IMPL) { - 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; + TEST_CYCLE() cv::threshold(src, dst, 50.0, 0.0, threshType); - d_src.upload(src); - - 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); } + else + OCL_PERF_ELSE } + ///////////// 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 _COOR +{ + 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 +587,41 @@ 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; + 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 (RUN_PLAIN_IMPL) { - 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 (RUN_OCL_IMPL) + { + 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); } + else + OCL_PERF_ELSE } -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 +679,184 @@ 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 "; +typedef TestBaseWithParam meanShiftProcFixture; - gen(src, size, size, CV_8UC4, Scalar::all(0), Scalar::all(256)); - - meanShiftProc_(src, dst[0], dst[1], 5, 6, crit); +PERF_TEST_P(meanShiftProcFixture, meanShiftProc, + OCL_TYPICAL_MAT_SIZES) +{ + const Size srcSize = GetParam(); + 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 (RUN_PLAIN_IMPL) + { + 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 (RUN_OCL_IMPL) + { + 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); } + else + OCL_PERF_ELSE } ///////////// 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 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, + OCL_PERF_ENUM(CV_8UC1, CV_8UC4), + RemapInterType::all())) +{ + const remapParams params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params), interpolation = get<2>(params); - xmap.create(size, size, CV_32FC1); - dst.create(size, size, CV_32FC1); - ymap.create(size, size, CV_32FC1); + 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; + if (RUN_OCL_IMPL) + { + 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 (RUN_PLAIN_IMPL) + { + TEST_CYCLE() cv::remap(src, dst, xmap, ymap, interpolation, borderMode); + SANITY_CHECK(dst, 1 + DBL_EPSILON); } + else + OCL_PERF_ELSE } -///////////// 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) +{ + const Size srcSize = GetParam(); + const string impl = getSelectedImpl(); - CPU_ON; - clahe->apply(src, dst); - CPU_OFF; + 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; + if (RUN_OCL_IMPL) + { + 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 (RUN_PLAIN_IMPL) + { + 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); } + else + OCL_PERF_ELSE } ///////////// 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) +{ + const Size srcSize = GetParam(); - CPU_ON; - dst.create(src.size(), src.type()); - for (int j = 0; j < src.cols; j++) - dst.at(0, j) = src.at(0, j); + 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); + if (RUN_OCL_IMPL) + { + 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 (RUN_PLAIN_IMPL) + { + TEST_CYCLE() columnSumPerfTest(src, dst); - TestSystem::instance().ExpectedMatNear(dst, ocl_dst, 5e-1); + SANITY_CHECK(dst); } + else + OCL_PERF_ELSE } diff --git a/modules/ocl/perf/perf_match_template.cpp b/modules/ocl/perf/perf_match_template.cpp index 8caf4b4f55..2cf06a4d76 100644 --- a/modules/ocl/perf/perf_match_template.cpp +++ b/modules/ocl/perf/perf_match_template.cpp @@ -45,101 +45,77 @@ //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"; +using namespace perf; +using std::tr1::tuple; +using std::tr1::get; - 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; +/////////// matchTemplate //////////////////////// - GPU_ON; - ocl::matchTemplate(d_src, d_templ, d_dst, CV_TM_CCORR); - GPU_OFF; +typedef Size_MatType CV_TM_CCORRFixture; - 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; +PERF_TEST_P(CV_TM_CCORRFixture, matchTemplate, + ::testing::Combine(::testing::Values(OCL_SIZE_1000, OCL_SIZE_2000), + OCL_PERF_ENUM(CV_32FC1, CV_32FC4))) +{ + const Size_MatType_t params = GetParam(); + const Size srcSize = get<0>(params), templSize(5, 5); + const int type = get<1>(params); + + 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); + + if (RUN_OCL_IMPL) + { + ocl::oclMat oclSrc(src), oclTempl(templ), oclDst(dstSize, CV_32F); - TestSystem::instance().ExpectedMatNear(dst, ocl_dst, templ.rows * templ.cols * 1e-1); - } - } + TEST_CYCLE() cv::ocl::matchTemplate(oclSrc, oclTempl, oclDst, CV_TM_CCORR); - int all_type_8U[] = {CV_8UC1}; - std::string type_name_8U[] = {"CV_8UC1"}; + oclDst.download(dst); - 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"; + SANITY_CHECK(dst, 1e-4); + } + else if (RUN_PLAIN_IMPL) + { + TEST_CYCLE() cv::matchTemplate(src, templ, dst, CV_TM_CCORR); - gen(src, size, size, all_type_8U[j], 0, 255); + SANITY_CHECK(dst, 1e-4); + } + else + OCL_PERF_ELSE +} - gen(templ, templ_size, templ_size, all_type_8U[j], 0, 255); +typedef TestBaseWithParam CV_TM_CCORR_NORMEDFixture; - matchTemplate(src, templ, dst, CV_TM_CCORR_NORMED); +PERF_TEST_P(CV_TM_CCORR_NORMEDFixture, matchTemplate, OCL_TYPICAL_MAT_SIZES) +{ + const Size srcSize = GetParam(), templSize(5, 5); - CPU_ON; - matchTemplate(src, templ, dst, CV_TM_CCORR_NORMED); - CPU_OFF; + 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); - ocl::oclMat d_src(src); - ocl::oclMat d_templ(templ), d_dst; + if (RUN_OCL_IMPL) + { + 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 (RUN_PLAIN_IMPL) + { + 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); } + else + OCL_PERF_ELSE } diff --git a/modules/ocl/perf/perf_matrix_operation.cpp b/modules/ocl/perf/perf_matrix_operation.cpp index 092e548940..1fe4616ac3 100644 --- a/modules/ocl/perf/perf_matrix_operation.cpp +++ b/modules/ocl/perf/perf_matrix_operation.cpp @@ -45,142 +45,113 @@ //M*/ #include "perf_precomp.hpp" -///////////// ConvertTo//////////////////////// -PERFTEST(ConvertTo) -{ - 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] << " to 32FC1"; +using namespace perf; +using std::tr1::tuple; +using std::tr1::get; - gen(src, size, size, all_type[j], 0, 256); - //gen(dst, size, size, all_type[j], 0, 256); - - //d_dst.upload(dst); - - src.convertTo(dst, CV_32FC1); +///////////// ConvertTo//////////////////////// - CPU_ON; - src.convertTo(dst, CV_32FC1); - CPU_OFF; +typedef Size_MatType ConvertToFixture; - d_src.upload(src); +PERF_TEST_P(ConvertToFixture, ConvertTo, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + OCL_PERF_ENUM(CV_8UC1, CV_8UC4))) +{ + const Size_MatType_t params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params); - WARMUP_ON; - d_src.convertTo(d_dst, CV_32FC1); - WARMUP_OFF; + 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); - GPU_ON; - d_src.convertTo(d_dst, CV_32FC1); - GPU_OFF; + if (RUN_OCL_IMPL) + { + ocl::oclMat oclSrc(src), oclDst(srcSize, dstType); - GPU_FULL_ON; - d_src.upload(src); - d_src.convertTo(d_dst, CV_32FC1); - d_dst.download(ocl_dst); - GPU_FULL_OFF; + TEST_CYCLE() oclSrc.convertTo(oclDst, dstType); - TestSystem::instance().ExpectedMatNear(dst, ocl_dst, 0.0); - } + oclDst.download(dst); + SANITY_CHECK(dst); } -} -///////////// 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) + else if (RUN_PLAIN_IMPL) { - for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++) - { - SUBTEST << size << 'x' << size << "; " << type_name[j] ; + TEST_CYCLE() src.convertTo(dst, dstType); - gen(src, size, size, all_type[j], 0, 256); - //gen(dst, size, size, all_type[j], 0, 256); - - //d_dst.upload(dst); + SANITY_CHECK(dst); + } + else + OCL_PERF_ELSE +} - src.copyTo(dst); +///////////// copyTo//////////////////////// - CPU_ON; - src.copyTo(dst); - CPU_OFF; +typedef Size_MatType copyToFixture; - d_src.upload(src); +PERF_TEST_P(copyToFixture, copyTo, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + OCL_PERF_ENUM(CV_8UC1, CV_8UC4))) +{ + const Size_MatType_t params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params); - WARMUP_ON; - d_src.copyTo(d_dst); - WARMUP_OFF; + Mat src(srcSize, type), dst(srcSize, type); + declare.in(src, WARMUP_RNG).out(dst); - GPU_ON; - d_src.copyTo(d_dst); - GPU_OFF; + if (RUN_OCL_IMPL) + { + ocl::oclMat oclSrc(src), oclDst(srcSize, type); - GPU_FULL_ON; - d_src.upload(src); - d_src.copyTo(d_dst); - d_dst.download(ocl_dst); - GPU_FULL_OFF; + TEST_CYCLE() oclSrc.copyTo(oclDst); - TestSystem::instance().ExpectedMatNear(dst, ocl_dst, 0.0); - } + oclDst.download(dst); + SANITY_CHECK(dst); } -} -///////////// 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) + else if (RUN_PLAIN_IMPL) { - for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++) - { - SUBTEST << size << 'x' << size << "; " << type_name[j] ; + TEST_CYCLE() src.copyTo(dst); - gen(src, size, size, all_type[j], 0, 256); + SANITY_CHECK(dst); + } + else + OCL_PERF_ELSE +} - src.setTo(val); +///////////// setTo//////////////////////// - CPU_ON; - src.setTo(val); - CPU_OFF; +typedef Size_MatType setToFixture; - d_src.upload(src); +PERF_TEST_P(setToFixture, setTo, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + OCL_PERF_ENUM(CV_8UC1, CV_8UC4))) +{ + const Size_MatType_t params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params); + const Scalar val(1, 2, 3, 4); - WARMUP_ON; - d_src.setTo(val); - WARMUP_OFF; + Mat src(srcSize, type); + declare.in(src); - d_src.download(ocl_src); - TestSystem::instance().ExpectedMatNear(src, ocl_src, 1.0); + if (RUN_OCL_IMPL) + { + 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 (RUN_PLAIN_IMPL) + { + TEST_CYCLE() src.setTo(val); + SANITY_CHECK(src); } + else + OCL_PERF_ELSE } diff --git a/modules/ocl/perf/perf_moments.cpp b/modules/ocl/perf/perf_moments.cpp index a1515b879b..200a27db82 100644 --- a/modules/ocl/perf/perf_moments.cpp +++ b/modules/ocl/perf/perf_moments.cpp @@ -43,50 +43,47 @@ // 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"}; - - 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]; +#include "perf_precomp.hpp" - gen(src, size, size, all_type[j], 0, 256); +using namespace perf; +using std::tr1::tuple; +using std::tr1::get; - cv::Moments CvMom = moments(src, binaryImage); +///////////// Moments //////////////////////// - CPU_ON; - moments(src, binaryImage); - CPU_OFF; +typedef Size_MatType MomentsFixture; - cv::Moments oclMom; - WARMUP_ON; - oclMom = ocl::ocl_moments(src, binaryImage); - WARMUP_OFF; +PERF_TEST_P(MomentsFixture, DISABLED_Moments, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + OCL_PERF_ENUM(CV_8UC1, CV_16SC1, CV_32FC1, CV_64FC1))) // TODO does not work properly (see below) +{ + const Size_MatType_t params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params); - Mat gpu_dst, cpu_dst; - HuMoments(CvMom, cpu_dst); - HuMoments(oclMom, gpu_dst); + 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; + if (RUN_OCL_IMPL) + { + ocl::oclMat oclSrc(src); - TestSystem::instance().ExpectedMatNear(gpu_dst, cpu_dst, .5); + TEST_CYCLE() mom = cv::ocl::ocl_moments(oclSrc, binaryImage); // TODO Use oclSrc + cv::HuMoments(mom, dst); - } + SANITY_CHECK(dst); + } + else if (RUN_PLAIN_IMPL) + { + TEST_CYCLE() mom = cv::moments(src, binaryImage); + cv::HuMoments(mom, dst); + SANITY_CHECK(dst); } + else + OCL_PERF_ELSE } diff --git a/modules/ocl/perf/perf_norm.cpp b/modules/ocl/perf/perf_norm.cpp index a80ab13547..736645d904 100644 --- a/modules/ocl/perf/perf_norm.cpp +++ b/modules/ocl/perf/perf_norm.cpp @@ -45,43 +45,39 @@ //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) // TODO doesn't work properly +{ + const Size srcSize = GetParam(); + const std::string impl = getSelectedImpl(); + double value = 0.0; - d_src1.upload(src1); - d_src2.upload(src2); + 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; + if (RUN_OCL_IMPL) + { + 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 (RUN_PLAIN_IMPL) + { + 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); } + else + OCL_PERF_ELSE } diff --git a/modules/ocl/perf/perf_opticalflow.cpp b/modules/ocl/perf/perf_opticalflow.cpp index a6724c8123..34651d1af8 100644 --- a/modules/ocl/perf/perf_opticalflow.cpp +++ b/modules/ocl/perf/perf_opticalflow.cpp @@ -46,311 +46,228 @@ #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); +using namespace perf; +using std::tr1::get; +using std::tr1::tuple; +using std::tr1::make_tuple; - if (frame0.empty()) - { - std::string errstr = "can't open " + images1[i]; - throw runtime_error(errstr); - } +template +static vector & MatToVector(const ocl::oclMat & oclSrc, vector & instance) +{ + Mat src; + oclSrc.download(src); - Mat frame1 = imread(abspath(images2[i]), i == 0 ? IMREAD_COLOR : IMREAD_GRAYSCALE); + for (int i = 0; i < src.cols; ++i) + instance.push_back(src.at(0, i)); - if (frame1.empty()) - { - std::string errstr = "can't open " + images2[i]; - throw runtime_error(errstr); - } + return instance; +} - Mat gray_frame; +CV_ENUM(LoadMode, IMREAD_GRAYSCALE, IMREAD_COLOR) + +typedef tuple > PyrLKOpticalFlowParamType; +typedef TestBaseWithParam PyrLKOpticalFlowFixture; + +PERF_TEST_P(PyrLKOpticalFlowFixture, + DISABLED_PyrLKOpticalFlow, + ::testing::Combine( + ::testing::Values(1000, 2000, 4000), + ::testing::Values( + make_tuple + ( + string("gpu/opticalflow/rubberwhale1.png"), + string("gpu/opticalflow/rubberwhale2.png"), + LoadMode(IMREAD_COLOR) + ) + , make_tuple + ( + string("gpu/stereobm/aloe-L.png"), + string("gpu/stereobm/aloe-R.png"), + LoadMode(IMREAD_GRAYSCALE) + ) + ) + ) + ) // TODO to big difference between implementations +{ + 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); + + 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; + + vector pts, nextPts; + vector status; + vector err; + goodFeaturesToTrack(grayFrame, pts, pointsCount, 0.01, 0.0); + + if (RUN_PLAIN_IMPL) + { + TEST_CYCLE() + cv::calcOpticalFlowPyrLK(frame0, frame1, pts, nextPts, status, err); - if (i == 0) - { - cvtColor(frame0, gray_frame, COLOR_BGR2GRAY); - } + SANITY_CHECK(nextPts); + SANITY_CHECK(status); + SANITY_CHECK(err); + } + else if (RUN_OCL_IMPL) + { + 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; - 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; - - 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; - - WARMUP_ON; - d_pyrLK.sparse(d_frame0, d_frame1, d_pts, d_nextPts, d_status, &d_err); - WARMUP_OFF; - - GPU_ON; - d_pyrLK.sparse(d_frame0, d_frame1, d_pts, d_nextPts, d_status, &d_err); - GPU_OFF; - - 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); - - if (!d_nextPts.empty()) - d_nextPts.download(ocl_nextPts); - - if (!d_status.empty()) - d_status.download(ocl_status); - GPU_FULL_OFF; - - 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); - } + TEST_CYCLE() + oclPyrLK.sparse(oclFrame0, oclFrame1, oclPts, oclNextPts, oclStatus, &oclErr); + + MatToVector(oclNextPts, nextPts); + MatToVector(oclStatus, status); + MatToVector(oclErr, err); + SANITY_CHECK(nextPts); + SANITY_CHECK(status); + SANITY_CHECK(err); } + else + OCL_PERF_ELSE } - -PERFTEST(tvl1flow) +PERF_TEST(tvl1flowFixture, tvl1flow) { - cv::Mat frame0 = imread("rubberwhale1.png", cv::IMREAD_GRAYSCALE); - assert(!frame0.empty()); + Mat frame0 = imread(getDataPath("gpu/opticalflow/rubberwhale1.png"), cv::IMREAD_GRAYSCALE); + ASSERT_FALSE(frame0.empty()) << "can't load rubberwhale1.png"; - cv::Mat frame1 = imread("rubberwhale2.png", cv::IMREAD_GRAYSCALE); - assert(!frame1.empty()); + Mat frame1 = imread(getDataPath("gpu/opticalflow/rubberwhale2.png"), cv::IMREAD_GRAYSCALE); + ASSERT_FALSE(frame1.empty()) << "can't load rubberwhale2.png"; - cv::ocl::OpticalFlowDual_TVL1_OCL d_alg; - cv::ocl::oclMat d_flowx(frame0.size(), CV_32FC1); - cv::ocl::oclMat d_flowy(frame1.size(), CV_32FC1); + const Size srcSize = frame0.size(); + const double eps = 1.2; + Mat flow(srcSize, CV_32FC2), flow1(srcSize, CV_32FC1), flow2(srcSize, CV_32FC1); + declare.in(frame0, frame1).out(flow1, flow2).time(159); - cv::Ptr alg = cv::createOptFlow_DualTVL1(); - cv::Mat flow; + if (RUN_PLAIN_IMPL) + { + Ptr alg = createOptFlow_DualTVL1(); + TEST_CYCLE() alg->calc(frame0, frame1, flow); - SUBTEST << frame0.cols << 'x' << frame0.rows << "; rubberwhale1.png; "<collectGarbage(); + Mat flows[2] = { flow1, flow2 }; + split(flow, flows); - alg->calc(frame0, frame1, flow); + SANITY_CHECK(flow1, eps); + SANITY_CHECK(flow2, eps); + } + else if (RUN_OCL_IMPL) + { + ocl::OpticalFlowDual_TVL1_OCL oclAlg; + ocl::oclMat oclFrame0(frame0), oclFrame1(frame1), oclFlow1(srcSize, CV_32FC1), + oclFlow2(srcSize, CV_32FC1); - CPU_ON; - alg->calc(frame0, frame1, flow); - CPU_OFF; + TEST_CYCLE() oclAlg(oclFrame0, oclFrame1, oclFlow1, oclFlow2); - cv::Mat gold[2]; - cv::split(flow, gold); + oclAlg.collectGarbage(); - cv::ocl::oclMat d0(frame0.size(), CV_32FC1); - d0.upload(frame0); - cv::ocl::oclMat d1(frame1.size(), CV_32FC1); - d1.upload(frame1); + oclFlow1.download(flow1); + oclFlow2.download(flow2); - WARMUP_ON; - d_alg(d0, d1, d_flowx, d_flowy); - WARMUP_OFF; - /* - double diff1 = 0.0, diff2 = 0.0; - if(ExceptedMatSimilar(gold[0], cv::Mat(d_flowx), 3e-3, diff1) == 1 - &&ExceptedMatSimilar(gold[1], cv::Mat(d_flowy), 3e-3, diff2) == 1) - TestSystem::instance().setAccurate(1); - else - TestSystem::instance().setAccurate(0); + SANITY_CHECK(flow1, eps); + SANITY_CHECK(flow2, eps); + } + else + OCL_PERF_ELSE +} - TestSystem::instance().setDiff(diff1); - TestSystem::instance().setDiff(diff2); - */ +///////////// FarnebackOpticalFlow //////////////////////// +CV_ENUM(farneFlagType, 0, OPTFLOW_FARNEBACK_GAUSSIAN) - GPU_ON; - d_alg(d0, d1, d_flowx, d_flowy); - d_alg.collectGarbage(); - GPU_OFF; +typedef tuple, farneFlagType, bool> FarnebackOpticalFlowParams; +typedef TestBaseWithParam FarnebackOpticalFlowFixture; +PERF_TEST_P(FarnebackOpticalFlowFixture, FarnebackOpticalFlow, + ::testing::Combine( + ::testing::Values(make_tuple(5, 1.1), + make_tuple(7, 1.5)), + farneFlagType::all(), + ::testing::Bool())) +{ + Mat frame0 = imread(getDataPath("gpu/opticalflow/rubberwhale1.png"), cv::IMREAD_GRAYSCALE); + ASSERT_FALSE(frame0.empty()) << "can't load rubberwhale1.png"; - cv::Mat flowx, flowy; + Mat frame1 = imread(getDataPath("gpu/opticalflow/rubberwhale2.png"), cv::IMREAD_GRAYSCALE); + ASSERT_FALSE(frame1.empty()) << "can't load rubberwhale2.png"; - GPU_FULL_ON; - d0.upload(frame0); - d1.upload(frame1); - d_alg(d0, d1, d_flowx, d_flowy); - d_alg.collectGarbage(); - d_flowx.download(flowx); - d_flowy.download(flowy); - GPU_FULL_OFF; + const Size srcSize = frame0.size(); - TestSystem::instance().ExceptedMatSimilar(gold[0], flowx, 3e-3); - TestSystem::instance().ExceptedMatSimilar(gold[1], flowy, 3e-3); -} + const FarnebackOpticalFlowParams params = GetParam(); + const tuple polyParams = get<0>(params); + const int polyN = get<0>(polyParams), flags = get<1>(params); + const double polySigma = get<1>(polyParams), pyrScale = 0.5; + const bool useInitFlow = get<2>(params); + const double eps = 1.5; -///////////// FarnebackOpticalFlow //////////////////////// -PERFTEST(FarnebackOpticalFlow) -{ - cv::Mat frame0 = imread("rubberwhale1.png", cv::IMREAD_GRAYSCALE); - ASSERT_FALSE(frame0.empty()); + Mat flowx(srcSize, CV_32FC1), flowy(srcSize, CV_32FC1), flow(srcSize, CV_32FC2); + declare.in(frame0, frame1).out(flowx, flowy); - cv::Mat frame1 = imread("rubberwhale2.png", cv::IMREAD_GRAYSCALE); - ASSERT_FALSE(frame1.empty()); + ocl::FarnebackOpticalFlow farn; + farn.pyrScale = pyrScale; + farn.polyN = polyN; + farn.polySigma = polySigma; + farn.flags = flags; - cv::ocl::oclMat d_frame0(frame0), d_frame1(frame1); + if (RUN_PLAIN_IMPL) + { + if (useInitFlow) + { + calcOpticalFlowFarneback( + frame0, frame1, flow, farn.pyrScale, farn.numLevels, farn.winSize, + farn.numIters, farn.polyN, farn.polySigma, farn.flags); + farn.flags |= OPTFLOW_USE_INITIAL_FLOW; + } - int polyNs[2] = { 5, 7 }; - double polySigmas[2] = { 1.1, 1.5 }; - int farneFlags[2] = { 0, cv::OPTFLOW_FARNEBACK_GAUSSIAN }; - bool UseInitFlows[2] = { false, true }; - double pyrScale = 0.5; + TEST_CYCLE() + calcOpticalFlowFarneback( + frame0, frame1, flow, farn.pyrScale, farn.numLevels, farn.winSize, + farn.numIters, farn.polyN, farn.polySigma, farn.flags); - string farneFlagStrs[2] = { "BoxFilter", "GaussianBlur" }; - string useInitFlowStrs[2] = { "", "UseInitFlow" }; + Mat flowxy[2] = { flowx, flowy }; + split(flow, flowxy); - for ( int i = 0; i < 2; ++i) + SANITY_CHECK(flowx, eps); + SANITY_CHECK(flowy, eps); + } + else if (RUN_OCL_IMPL) { - int polyN = polyNs[i]; - double polySigma = polySigmas[i]; + ocl::oclMat oclFrame0(frame0), oclFrame1(frame1), + oclFlowx(srcSize, CV_32FC1), oclFlowy(srcSize, CV_32FC1); - for ( int j = 0; j < 2; ++j) + if (useInitFlow) { - int flags = farneFlags[j]; - - for ( int k = 0; k < 2; ++k) - { - bool useInitFlow = UseInitFlows[k]; - SUBTEST << "polyN(" << polyN << "); " << farneFlagStrs[j] << "; " << useInitFlowStrs[k]; - - cv::ocl::FarnebackOpticalFlow farn; - farn.pyrScale = pyrScale; - farn.polyN = polyN; - farn.polySigma = polySigma; - farn.flags = flags; - - cv::ocl::oclMat d_flowx, d_flowy; - cv::Mat flow, flowBuf, flowxBuf, flowyBuf; - - WARMUP_ON; - farn(d_frame0, d_frame1, d_flowx, d_flowy); - - if (useInitFlow) - { - cv::Mat flowxy[] = {cv::Mat(d_flowx), cv::Mat(d_flowy)}; - cv::merge(flowxy, 2, flow); - flow.copyTo(flowBuf); - flowxy[0].copyTo(flowxBuf); - flowxy[1].copyTo(flowyBuf); - - farn.flags |= cv::OPTFLOW_USE_INITIAL_FLOW; - farn(d_frame0, d_frame1, d_flowx, d_flowy); - } - WARMUP_OFF; - - cv::calcOpticalFlowFarneback( - frame0, frame1, flow, farn.pyrScale, farn.numLevels, farn.winSize, - farn.numIters, farn.polyN, farn.polySigma, farn.flags); - - std::vector flowxy; - cv::split(flow, flowxy); + farn(oclFrame0, oclFrame1, oclFlowx, oclFlowy); + farn.flags |= OPTFLOW_USE_INITIAL_FLOW; + } - Mat md_flowx = cv::Mat(d_flowx); - Mat md_flowy = cv::Mat(d_flowy); - TestSystem::instance().ExceptedMatSimilar(flowxy[0], md_flowx, 0.1); - TestSystem::instance().ExceptedMatSimilar(flowxy[1], md_flowy, 0.1); + TEST_CYCLE() + farn(oclFrame0, oclFrame1, oclFlowx, oclFlowy); - if (useInitFlow) - { - cv::Mat flowx, flowy; - farn.flags = (flags | cv::OPTFLOW_USE_INITIAL_FLOW); + oclFlowx.download(flowx); + oclFlowy.download(flowy); - CPU_ON; - cv::calcOpticalFlowFarneback( - frame0, frame1, flowBuf, farn.pyrScale, farn.numLevels, farn.winSize, - farn.numIters, farn.polyN, farn.polySigma, farn.flags); - CPU_OFF; - - GPU_ON; - farn(d_frame0, d_frame1, d_flowx, d_flowy); - GPU_OFF; - - GPU_FULL_ON; - d_frame0.upload(frame0); - d_frame1.upload(frame1); - d_flowx.upload(flowxBuf); - d_flowy.upload(flowyBuf); - farn(d_frame0, d_frame1, d_flowx, d_flowy); - d_flowx.download(flowx); - d_flowy.download(flowy); - GPU_FULL_OFF; - } - else - { - cv::Mat flow, flowx, flowy; - cv::ocl::oclMat d_flowx, d_flowy; - - farn.flags = flags; - - CPU_ON; - cv::calcOpticalFlowFarneback( - frame0, frame1, flow, farn.pyrScale, farn.numLevels, farn.winSize, - farn.numIters, farn.polyN, farn.polySigma, farn.flags); - CPU_OFF; - - GPU_ON; - farn(d_frame0, d_frame1, d_flowx, d_flowy); - GPU_OFF; - - GPU_FULL_ON; - d_frame0.upload(frame0); - d_frame1.upload(frame1); - farn(d_frame0, d_frame1, d_flowx, d_flowy); - d_flowx.download(flowx); - d_flowy.download(flowy); - GPU_FULL_OFF; - } - } - } + SANITY_CHECK(flowx, eps); + SANITY_CHECK(flowy, eps); } + else + OCL_PERF_ELSE } diff --git a/modules/ocl/perf/perf_precomp.cpp b/modules/ocl/perf/perf_precomp.cpp index c5679a429f..74f3f0f33c 100644 --- a/modules/ocl/perf/perf_precomp.cpp +++ b/modules/ocl/perf/perf_precomp.cpp @@ -41,452 +41,3 @@ //M*/ #include "perf_precomp.hpp" -#if GTEST_OS_WINDOWS -#ifndef NOMINMAX -#define NOMINMAX -#endif -# include -#endif - -// This program test most of the functions in ocl module and generate data metrix of x-factor in .csv files -// All images needed in this test are in samples/gpu folder. -// For haar template, haarcascade_frontalface_alt.xml shouold be in working directory -void TestSystem::run() -{ - if (is_list_mode_) - { - for (vector::iterator it = tests_.begin(); it != tests_.end(); ++it) - { - cout << (*it)->name() << endl; - } - - return; - } - - // Run test initializers - for (vector::iterator it = inits_.begin(); it != inits_.end(); ++it) - { - if ((*it)->name().find(test_filter_, 0) != string::npos) - { - (*it)->run(); - } - } - - printHeading(); - writeHeading(); - - // Run tests - for (vector::iterator it = tests_.begin(); it != tests_.end(); ++it) - { - try - { - if ((*it)->name().find(test_filter_, 0) != string::npos) - { - cout << endl << (*it)->name() << ":\n"; - - setCurrentTest((*it)->name()); - //fprintf(record_,"%s\n",(*it)->name().c_str()); - - (*it)->run(); - finishCurrentSubtest(); - } - } - catch (const Exception &) - { - // Message is printed via callback - resetCurrentSubtest(); - } - catch (const runtime_error &e) - { - printError(e.what()); - resetCurrentSubtest(); - } - } - - printSummary(); - writeSummary(); -} - - -void TestSystem::finishCurrentSubtest() -{ - if (cur_subtest_is_empty_) - // There is no need to print subtest statistics - { - return; - } - - double cpu_time = cpu_elapsed_ / getTickFrequency() * 1000.0; - double gpu_time = gpu_elapsed_ / getTickFrequency() * 1000.0; - double gpu_full_time = gpu_full_elapsed_ / getTickFrequency() * 1000.0; - - double speedup = static_cast(cpu_elapsed_) / std::max(1.0, gpu_elapsed_); - speedup_total_ += speedup; - - double fullspeedup = static_cast(cpu_elapsed_) / std::max(1.0, gpu_full_elapsed_); - speedup_full_total_ += fullspeedup; - - if (speedup > top_) - { - speedup_faster_count_++; - } - else if (speedup < bottom_) - { - speedup_slower_count_++; - } - else - { - speedup_equal_count_++; - } - - if (fullspeedup > top_) - { - speedup_full_faster_count_++; - } - else if (fullspeedup < bottom_) - { - speedup_full_slower_count_++; - } - else - { - speedup_full_equal_count_++; - } - - // compute min, max and - std::sort(gpu_times_.begin(), gpu_times_.end()); - double gpu_min = gpu_times_.front() / getTickFrequency() * 1000.0; - double gpu_max = gpu_times_.back() / getTickFrequency() * 1000.0; - double deviation = 0; - - if (gpu_times_.size() > 1) - { - double sum = 0; - - for (size_t i = 0; i < gpu_times_.size(); i++) - { - int64 diff = gpu_times_[i] - static_cast(gpu_elapsed_); - double diff_time = diff * 1000 / getTickFrequency(); - sum += diff_time * diff_time; - } - - deviation = std::sqrt(sum / gpu_times_.size()); - } - - printMetrics(is_accurate_, cpu_time, gpu_time, gpu_full_time, speedup, fullspeedup); - writeMetrics(cpu_time, gpu_time, gpu_full_time, speedup, fullspeedup, gpu_min, gpu_max, deviation); - - num_subtests_called_++; - resetCurrentSubtest(); -} - - -double TestSystem::meanTime(const vector &samples) -{ - double sum = accumulate(samples.begin(), samples.end(), 0.); - return sum / samples.size(); -} - - -void TestSystem::printHeading() -{ - cout << endl; - cout<< setiosflags(ios_base::left); - -#if 0 - cout<(0, 0) - 1.f); -} diff --git a/modules/ocl/perf/perf_precomp.hpp b/modules/ocl/perf/perf_precomp.hpp index 216ebe5c5d..5e6cd2266c 100644 --- a/modules/ocl/perf/perf_precomp.hpp +++ b/modules/ocl/perf/perf_precomp.hpp @@ -40,6 +40,14 @@ // //M*/ +#ifdef __GNUC__ +# pragma GCC diagnostic ignored "-Wmissing-declarations" +# 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 +58,7 @@ #include #include #include + #include "opencv2/core/core.hpp" #include "opencv2/imgproc/imgproc.hpp" #include "opencv2/highgui/highgui.hpp" @@ -59,455 +68,38 @@ #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 Min_Size 1000 -#define Max_Size 4000 -#define Multiple 2 -#define TAB " " using namespace std; using namespace cv; -void gen(Mat &mat, int rows, int cols, int type, Scalar low, Scalar high); -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); - - -template -int ExpectedEQ(T1 expected, T2 actual) -{ - if(expected == actual) - return 1; - - return 0; -} - -template -int EeceptDoubleEQ(T1 expected, T1 actual) -{ - testing::internal::Double lhs(expected); - testing::internal::Double rhs(actual); - - if (lhs.AlmostEquals(rhs)) - { - return 1; - } - - return 0; -} - -template -int AssertEQ(T expected, T actual) -{ - if(expected == actual) - { - return 1; - } - return 0; -} - -int ExceptDoubleNear(double val1, double val2, double abs_error); -bool match_rect(cv::Rect r1, cv::Rect r2, int threshold); - -double checkNorm(const cv::Mat &m); -double checkNorm(const cv::Mat &m1, const cv::Mat &m2); -double checkSimilarity(const cv::Mat &m1, const cv::Mat &m2); - -int ExpectedMatNear(cv::Mat dst, cv::Mat cpu_dst, double eps); -int ExceptedMatSimilar(cv::Mat dst, cv::Mat cpu_dst, double eps); - -class Runnable -{ -public: - explicit Runnable(const std::string &runname): name_(runname) {} - virtual ~Runnable() {} - - const std::string &name() const - { - return name_; - } - - virtual void run() = 0; - -private: - std::string name_; -}; - -class TestSystem -{ -public: - static TestSystem &instance() - { - static TestSystem me; - return me; - } - - void setWorkingDir(const std::string &val) - { - working_dir_ = val; - } - const std::string &workingDir() const - { - return working_dir_; - } - - void setTestFilter(const std::string &val) - { - test_filter_ = val; - } - const std::string &testFilter() const - { - return test_filter_; - } - - void setNumIters(int num_iters) - { - num_iters_ = num_iters; - } - void setGPUWarmupIters(int num_iters) - { - gpu_warmup_iters_ = num_iters; - } - void setCPUIters(int num_iters) - { - cpu_num_iters_ = num_iters; - } - - void setTopThreshold(double top) - { - top_ = top; - } - void setBottomThreshold(double bottom) - { - bottom_ = bottom; - } - - void addInit(Runnable *init) - { - inits_.push_back(init); - } - void addTest(Runnable *test) - { - tests_.push_back(test); - } - void run(); - - // It's public because OpenCV callback uses it - void printError(const std::string &msg); - - std::stringstream &startNewSubtest() - { - finishCurrentSubtest(); - return cur_subtest_description_; - } - - bool stop() const - { - return cur_iter_idx_ >= num_iters_; - } - - bool cpu_stop() const - { - return cur_iter_idx_ >= cpu_num_iters_; - } - - int get_cur_iter_idx() - { - return cur_iter_idx_; - } - - int get_cpu_num_iters() - { - return cpu_num_iters_; - } - - bool warmupStop() - { - return cur_warmup_idx_++ >= gpu_warmup_iters_; - } - - void warmupComplete() - { - cur_warmup_idx_ = 0; - } +#define OCL_SIZE_1000 Size(1000, 1000) +#define OCL_SIZE_2000 Size(2000, 2000) +#define OCL_SIZE_4000 Size(4000, 4000) - void cpuOn() - { - cpu_started_ = cv::getTickCount(); - } - void cpuOff() - { - int64 delta = cv::getTickCount() - cpu_started_; - cpu_times_.push_back(delta); - ++cur_iter_idx_; - } - void cpuComplete() - { - cpu_elapsed_ += meanTime(cpu_times_); - cur_subtest_is_empty_ = false; - cur_iter_idx_ = 0; - } +#define OCL_TYPICAL_MAT_SIZES ::testing::Values(OCL_SIZE_1000, OCL_SIZE_2000, OCL_SIZE_4000) - void gpuOn() - { - gpu_started_ = cv::getTickCount(); - } - void gpuOff() - { - int64 delta = cv::getTickCount() - gpu_started_; - gpu_times_.push_back(delta); - ++cur_iter_idx_; - } - void gpuComplete() - { - gpu_elapsed_ += meanTime(gpu_times_); - cur_subtest_is_empty_ = false; - cur_iter_idx_ = 0; - } +#define OCL_PERF_ENUM(type, ...) ::testing::Values(type, ## __VA_ARGS__ ) - void gpufullOn() - { - gpu_full_started_ = cv::getTickCount(); - } - void gpufullOff() - { - int64 delta = cv::getTickCount() - gpu_full_started_; - gpu_full_times_.push_back(delta); - ++cur_iter_idx_; - } - void gpufullComplete() - { - gpu_full_elapsed_ += meanTime(gpu_full_times_); - cur_subtest_is_empty_ = false; - cur_iter_idx_ = 0; - } +#define IMPL_OCL "ocl" +#define IMPL_GPU "gpu" +#define IMPL_PLAIN "plain" - bool isListMode() const - { - return is_list_mode_; - } - void setListMode(bool value) - { - is_list_mode_ = value; - } +#define RUN_OCL_IMPL (IMPL_OCL == getSelectedImpl()) +#define RUN_PLAIN_IMPL (IMPL_PLAIN == getSelectedImpl()) - void setRecordName(const std::string &name) - { - recordname_ = name; - } - - void setCurrentTest(const std::string &name) - { - itname_ = name; - itname_changed_ = true; - } - - void setAccurate(int accurate, double diff) - { - is_accurate_ = accurate; - accurate_diff_ = diff; - } - - void ExpectMatsNear(vector& dst, vector& cpu_dst, vector& eps) - { - assert(dst.size() == cpu_dst.size()); - assert(cpu_dst.size() == eps.size()); - is_accurate_ = 1; - for(size_t i=0; i eps[i]) - is_accurate_ = 0; - } - } - - void ExpectedMatNear(cv::Mat& dst, cv::Mat& cpu_dst, double eps) - { - assert(dst.type() == cpu_dst.type()); - assert(dst.size() == cpu_dst.size()); - accurate_diff_ = checkNorm(dst, cpu_dst); - if(accurate_diff_ <= eps) - is_accurate_ = 1; - else - is_accurate_ = 0; - } - - void ExceptedMatSimilar(cv::Mat& dst, cv::Mat& cpu_dst, double eps) - { - assert(dst.type() == cpu_dst.type()); - assert(dst.size() == cpu_dst.size()); - accurate_diff_ = checkSimilarity(cpu_dst, dst); - if(accurate_diff_ <= eps) - is_accurate_ = 1; - else - is_accurate_ = 0; - } - - std::stringstream &getCurSubtestDescription() - { - return cur_subtest_description_; - } - -private: - TestSystem(): - cur_subtest_is_empty_(true), cpu_elapsed_(0), - gpu_elapsed_(0), gpu_full_elapsed_(0), speedup_total_(0.0), - num_subtests_called_(0), - speedup_faster_count_(0), speedup_slower_count_(0), speedup_equal_count_(0), - speedup_full_faster_count_(0), speedup_full_slower_count_(0), speedup_full_equal_count_(0), is_list_mode_(false), - num_iters_(10), cpu_num_iters_(2), - gpu_warmup_iters_(1), cur_iter_idx_(0), cur_warmup_idx_(0), - record_(0), recordname_("performance"), itname_changed_(true), - is_accurate_(-1), accurate_diff_(0.) - { - cpu_times_.reserve(num_iters_); - gpu_times_.reserve(num_iters_); - gpu_full_times_.reserve(num_iters_); - } - - void finishCurrentSubtest(); - void resetCurrentSubtest() - { - cpu_elapsed_ = 0; - gpu_elapsed_ = 0; - gpu_full_elapsed_ = 0; - cur_subtest_description_.str(""); - cur_subtest_is_empty_ = true; - cur_iter_idx_ = 0; - cur_warmup_idx_ = 0; - cpu_times_.clear(); - gpu_times_.clear(); - gpu_full_times_.clear(); - is_accurate_ = -1; - accurate_diff_ = 0.; - } - - double meanTime(const std::vector &samples); - - void printHeading(); - void printSummary(); - void printMetrics(int is_accurate, double cpu_time, double gpu_time = 0.0f, double gpu_full_time = 0.0f, double speedup = 0.0f, double fullspeedup = 0.0f); - - void writeHeading(); - void writeSummary(); - void writeMetrics(double cpu_time, double gpu_time = 0.0f, double gpu_full_time = 0.0f, - double speedup = 0.0f, double fullspeedup = 0.0f, - double gpu_min = 0.0f, double gpu_max = 0.0f, double std_dev = 0.0f); - - std::string working_dir_; - std::string test_filter_; - - std::vector inits_; - std::vector tests_; - - std::stringstream cur_subtest_description_; - bool cur_subtest_is_empty_; - - int64 cpu_started_; - int64 gpu_started_; - int64 gpu_full_started_; - double cpu_elapsed_; - double gpu_elapsed_; - double gpu_full_elapsed_; - - double speedup_total_; - double speedup_full_total_; - int num_subtests_called_; - - int speedup_faster_count_; - int speedup_slower_count_; - int speedup_equal_count_; - - int speedup_full_faster_count_; - int speedup_full_slower_count_; - int speedup_full_equal_count_; - - bool is_list_mode_; - - double top_; - double bottom_; - - int num_iters_; - int cpu_num_iters_; //there's no need to set cpu running same times with gpu - int gpu_warmup_iters_; //gpu warm up times, default is 1 - int cur_iter_idx_; - int cur_warmup_idx_; //current gpu warm up times - std::vector cpu_times_; - std::vector gpu_times_; - std::vector gpu_full_times_; - - FILE *record_; - std::string recordname_; - std::string itname_; - bool itname_changed_; - - int is_accurate_; - double accurate_diff_; -}; - - -#define GLOBAL_INIT(name) \ -struct name##_init: Runnable { \ - name##_init(): Runnable(#name) { \ - TestSystem::instance().addInit(this); \ -} \ - void run(); \ -} name##_init_instance; \ - void name##_init::run() - - -#define PERFTEST(name) \ -struct name##_test: Runnable { \ - name##_test(): Runnable(#name) { \ - TestSystem::instance().addTest(this); \ -} \ - void run(); \ -} name##_test_instance; \ - void name##_test::run() - -#define SUBTEST TestSystem::instance().startNewSubtest() - -#define CPU_ON \ - while (!TestSystem::instance().cpu_stop()) { \ - TestSystem::instance().cpuOn() -#define CPU_OFF \ - TestSystem::instance().cpuOff(); \ - } TestSystem::instance().cpuComplete() - -#define GPU_ON \ - while (!TestSystem::instance().stop()) { \ - TestSystem::instance().gpuOn() -#define GPU_OFF \ - ocl::finish();\ - TestSystem::instance().gpuOff(); \ - } TestSystem::instance().gpuComplete() - -#define GPU_FULL_ON \ - while (!TestSystem::instance().stop()) { \ - TestSystem::instance().gpufullOn() -#define GPU_FULL_OFF \ - TestSystem::instance().gpufullOff(); \ - } TestSystem::instance().gpufullComplete() +#ifdef HAVE_OPENCV_GPU +# define RUN_GPU_IMPL (IMPL_GPU == getSelectedImpl()) +#endif -#define WARMUP_ON \ - while (!TestSystem::instance().warmupStop()) { -#define WARMUP_OFF \ - ocl::finish();\ - } TestSystem::instance().warmupComplete() +#ifdef HAVE_OPENCV_GPU +#define OCL_PERF_ELSE \ + if (RUN_GPU_IMPL) \ + CV_TEST_FAIL_NO_IMPL(); \ + else \ + CV_TEST_FAIL_NO_IMPL(); +#else +#define OCL_PERF_ELSE \ + CV_TEST_FAIL_NO_IMPL(); +#endif #endif diff --git a/modules/ocl/perf/perf_pyramid.cpp b/modules/ocl/perf/perf_pyramid.cpp index 10262799f1..c7f949d2c8 100644 --- a/modules/ocl/perf/perf_pyramid.cpp +++ b/modules/ocl/perf/perf_pyramid.cpp @@ -45,88 +45,80 @@ //M*/ #include "perf_precomp.hpp" -///////////// pyrDown ////////////////////// -PERFTEST(pyrDown) -{ - Mat src, dst, ocl_dst; - int all_type[] = {CV_8UC1, CV_8UC4}; - std::string type_name[] = {"CV_8UC1", "CV_8UC4"}; +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] ; +///////////// pyrDown ////////////////////// - gen(src, size, size, all_type[j], 0, 256); +typedef Size_MatType pyrDownFixture; - pyrDown(src, dst); +PERF_TEST_P(pyrDownFixture, pyrDown, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + OCL_PERF_ENUM(CV_8UC1, CV_8UC4))) +{ + const Size_MatType_t params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params); - CPU_ON; - pyrDown(src, dst); - CPU_OFF; + Mat src(srcSize, type), dst; + Size dstSize((srcSize.height + 1) >> 1, (srcSize.width + 1) >> 1); + dst.create(dstSize, type); + declare.in(src, WARMUP_RNG).out(dst); - ocl::oclMat d_src(src); - ocl::oclMat d_dst; + if (RUN_OCL_IMPL) + { + ocl::oclMat oclSrc(src), oclDst(dstSize, type); - WARMUP_ON; - ocl::pyrDown(d_src, d_dst); - WARMUP_OFF; + TEST_CYCLE() 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 (RUN_PLAIN_IMPL) + { + TEST_CYCLE() pyrDown(src, dst); - TestSystem::instance().ExpectedMatNear(dst, ocl_dst, dst.depth() == CV_32F ? 1e-4f : 1.0f); - } + SANITY_CHECK(dst); } + else + OCL_PERF_ELSE } ///////////// 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] ; - gen(src, size, size, all_type[j], 0, 256); +typedef Size_MatType pyrUpFixture; - pyrUp(src, dst); +PERF_TEST_P(pyrUpFixture, pyrUp, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + OCL_PERF_ENUM(CV_8UC1, CV_8UC4))) +{ + const Size_MatType_t params = GetParam(); + const Size srcSize = get<0>(params); + const int type = get<1>(params); - CPU_ON; - pyrUp(src, dst); - CPU_OFF; + Mat src(srcSize, type), dst; + Size dstSize(srcSize.height << 1, srcSize.width << 1); + dst.create(dstSize, type); + declare.in(src, WARMUP_RNG).out(dst); - ocl::oclMat d_src(src); - ocl::oclMat d_dst; + if (RUN_OCL_IMPL) + { + ocl::oclMat oclSrc(src), oclDst(dstSize, type); - WARMUP_ON; - ocl::pyrUp(d_src, d_dst); - WARMUP_OFF; + TEST_CYCLE() 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 (RUN_PLAIN_IMPL) + { + TEST_CYCLE() pyrDown(src, dst); - TestSystem::instance().ExpectedMatNear(dst, ocl_dst, (src.depth() == CV_32F ? 1e-4f : 1.0)); - } + SANITY_CHECK(dst); } + else + OCL_PERF_ELSE } diff --git a/modules/ocl/perf/perf_split_merge.cpp b/modules/ocl/perf/perf_split_merge.cpp index 736125ec6c..48d64c100e 100644 --- a/modules/ocl/perf/perf_split_merge.cpp +++ b/modules/ocl/perf/perf_split_merge.cpp @@ -45,110 +45,97 @@ //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"}; +typedef Size_MatType MergeFixture; - for (int size = Min_Size; size <= Max_Size; size *= Multiple) +PERF_TEST_P(MergeFixture, Merge, + ::testing::Combine(::testing::Values(OCL_SIZE_1000, OCL_SIZE_2000), + OCL_PERF_ENUM(CV_8U, CV_32F))) +{ + const Size_MatType_t params = GetParam(); + const Size srcSize = get<0>(params); + const int depth = get<1>(params), channels = 3; + + 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) { - 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); - } - + i->create(srcSize, CV_MAKE_TYPE(depth, 1)); + declare.in(*i, WARMUP_RNG); } -} + declare.out(dst); -///////////// Split//////////////////////// -PERFTEST(Split) -{ - //int channels = 4; - 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) + if (RUN_OCL_IMPL) { - for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++) - { - SUBTEST << size << 'x' << size << "; " << type_name[j]; - Size size1 = Size(size, size); - - Mat src(size1, CV_MAKE_TYPE(all_type[j], 4), cv::Scalar(1, 2, 3, 4)); + 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]; - std::vector dst, ocl_dst(4); + TEST_CYCLE() cv::ocl::merge(oclSrc, oclDst); - split(src, dst); + oclDst.download(dst); - CPU_ON; - split(src, dst); - CPU_OFF; + SANITY_CHECK(dst); + } + else if (RUN_PLAIN_IMPL) + { + TEST_CYCLE() cv::merge(src, dst); - ocl::oclMat d_src(size1, CV_MAKE_TYPE(all_type[j], 4), cv::Scalar(1, 2, 3, 4)); - std::vector d_dst; + SANITY_CHECK(dst); + } + else + OCL_PERF_ELSE +} - WARMUP_ON; - ocl::split(d_src, d_dst); - WARMUP_OFF; +///////////// Split//////////////////////// - GPU_ON; - ocl::split(d_src, d_dst); - GPU_OFF; +typedef Size_MatType SplitFixture; - 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; +PERF_TEST_P(SplitFixture, Split, + ::testing::Combine(OCL_TYPICAL_MAT_SIZES, + OCL_PERF_ENUM(CV_8U, CV_32F))) +{ + const Size_MatType_t params = GetParam(); + const Size srcSize = get<0>(params); + const int depth = get<1>(params), channels = 3; - vector eps(4, 0.); - TestSystem::instance().ExpectMatsNear(dst, ocl_dst, eps); - } + Mat src(srcSize, CV_MAKE_TYPE(depth, channels)); + declare.in(src, WARMUP_RNG); + if (RUN_OCL_IMPL) + { + ocl::oclMat oclSrc(src); + vector oclDst(channels, ocl::oclMat(srcSize, CV_MAKE_TYPE(depth, 1))); + + TEST_CYCLE() cv::ocl::split(oclSrc, oclDst); + + ASSERT_EQ(3, channels); + 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 (RUN_PLAIN_IMPL) + { + vector dst(channels, Mat(srcSize, CV_MAKE_TYPE(depth, 1))); + TEST_CYCLE() cv::split(src, dst); + + ASSERT_EQ(3, channels); + Mat & dst0 = dst[0], & dst1 = dst[1], & dst2 = dst[2]; + SANITY_CHECK(dst0); + SANITY_CHECK(dst1); + SANITY_CHECK(dst2); } + else + OCL_PERF_ELSE } diff --git a/modules/ocl/src/arithm.cpp b/modules/ocl/src/arithm.cpp index a591c82319..11e9c50f43 100644 --- a/modules/ocl/src/arithm.cpp +++ b/modules/ocl/src/arithm.cpp @@ -2336,7 +2336,7 @@ void cv::ocl::pow(const oclMat &x, double p, oclMat &y) return; } - CV_Assert((x.type() == y.type() && x.size() == y.size() && x.depth() == CV_32F) || x.depth() == CV_64F); + CV_Assert(x.depth() == CV_32F || x.depth() == CV_64F); y.create(x.size(), x.type()); string kernelName = "arithm_pow"; diff --git a/modules/ocl/test/test_norm.cpp b/modules/ocl/test/test_norm.cpp new file mode 100644 index 0000000000..2bd847068e --- /dev/null +++ b/modules/ocl/test/test_norm.cpp @@ -0,0 +1,63 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// Intel License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2000, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of Intel Corporation may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +#include "test_precomp.hpp" + +typedef ::testing::TestWithParam normFixture; + +TEST_P(normFixture, DISABLED_accuracy) +{ + const cv::Size srcSize = GetParam(); + + cv::Mat src1(srcSize, CV_8UC1), src2(srcSize, CV_8UC1); + cv::randu(src1, 0, 2); + cv::randu(src2, 0, 2); + + cv::ocl::oclMat oclSrc1(src1), oclSrc2(src2); + + double value = cv::norm(src1, src2, cv::NORM_INF); + double oclValue = cv::ocl::norm(oclSrc1, oclSrc2, cv::NORM_INF); + + ASSERT_EQ(value, oclValue); +} + +INSTANTIATE_TEST_CASE_P(oclNormTest, normFixture, + ::testing::Values(cv::Size(500, 500), cv::Size(1000, 1000)));