Merge pull request #1326 from ilya-lavrenov:perf_ocl

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 =
+    IMPL_OCL,
-        "{ h | help    | false | print help message }"
+    IMPL_PLAIN,
-        "{ f | filter  |       | filter for test }"
+#ifdef HAVE_OPENCV_GPU
-        "{ w | workdir |       | set working directory }"
+    IMPL_GPU
-        "{ l | list    | false | show all tests }"
+#endif
-        "{ d | device  | 0     | device id }"
+};
-        "{ c | cpu_ocl | false | use cpu as ocl device}"
+
-        "{ i | iters   | 10    | iteration count }"
+int main(int argc, char ** argv)
-        "{ m | warmup  | 1     | gpu warm up iteration count}"
+{
-        "{ t | xtop    | 1.1   | xfactor top boundary}"
+    const char * keys =
-        "{ b | xbottom | 0.9   | xfactor bottom boundary}"
+        "{ h | help     | false              | print help message }"
-        "{ v | verify  | false | only run gpu once to verify if problems occur}";
+        "{ 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<bool>("help"))
     {
-        cout << "Avaible options:" << endl;
+        cout << "Available options besides google test option:" << endl;
         cmd.printParams();
         return 0;
     }
 
-    // get ocl devices
+    string type = cmd.get<string>("type");
-    bool use_cpu = cmd.get<bool>("c");
+    unsigned int pid = cmd.get<unsigned int>("platform");
-    vector<ocl::Info> 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;
-        }
-    }
-
     int device = cmd.get<int>("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
+    int flag = type == "cpu" ? cv::ocl::CVCL_DEVICE_TYPE_CPU :
-    ocl::setBinaryDiskCache(ocl::CACHE_UPDATE);
+                               cv::ocl::CVCL_DEVICE_TYPE_GPU;
-
-    if (cmd.get<bool>("verify"))
-    {
-        TestSystem::instance().setNumIters(1);
-        TestSystem::instance().setGPUWarmupIters(0);
-        TestSystem::instance().setCPUIters(0);
-    }
 
-    devidx = 0;
+    std::vector<cv::ocl::Info> oclinfo;
-    for (size_t i = 0; i < oclinfo.size(); i++)
+    int devnums = cv::ocl::getDevice(oclinfo, flag);
+    if (devnums <= device || device < 0)
     {
-        for (size_t j = 0; j < oclinfo[i].DeviceName.size(); j++, devidx++)
+        std::cout << "device invalid\n";
-        {
+        return -1;
-            if (device == devidx)
-            {
-                ocl::setDevice(oclinfo[i], (int)j);
-                TestSystem::instance().setRecordName(oclinfo[i].DeviceName[j]);
-                cout << "use " << devidx << ": " <<oclinfo[i].DeviceName[j] << endl;
-                goto END_DEV;
-            }
-        }
-    }
-
-END_DEV:
-
-    string filter = cmd.get<string>("filter");
-    string workdir = cmd.get<string>("workdir");
-    bool list = cmd.get<bool>("list");
-    int iters = cmd.get<int>("iters");
-    int wu_iters = cmd.get<int>("warmup");
-    double x_top = cmd.get<double>("xtop");
-    double x_bottom = cmd.get<double>("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);
     }
 
-    if (list)
+    if (pid >= oclinfo.size())
     {
-        TestSystem::instance().setListMode(true);
+        std::cout << "platform invalid\n";
+        return -1;
     }
 
-    TestSystem::instance().setNumIters(iters);
+    cv::ocl::setDevice(oclinfo[pid], device);
-    TestSystem::instance().setGPUWarmupIters(wu_iters);
+    cv::ocl::setBinaryDiskCache(cv::ocl::CACHE_UPDATE);
-
-    TestSystem::instance().run();
 
-    return 0;
+    CV_PERF_TEST_MAIN_INTERNALS(ocl, impls)
 }

modules/ocl/perf/perf_blend.cpp

@@ -45,9 +45,15 @@
 //M*/
 
 #include "perf_precomp.hpp"
+
+using namespace perf;
+
 ///////////// blend ////////////////////////
+
 template <typename T>
-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];
+            int x1 = x * cn;
-            float w2 = weights2_row[x / cn];
+            float w1 = weights1_row[x];
-            result_gold_row[x] = static_cast<T>((img1_row[x] * w1 + img2_row[x] * w2) / (w1 + w2 + 1e-5f));
+            float w2 = weights2_row[x];
+            result_gold_row[x] = static_cast<T>((img1_row[x1] * w1
+                                                 + img2_row[x1] * w2) / (w1 + w2 + 1e-5f));
         }
     }
 }
-PERFTEST(blend)
+
+typedef TestBaseWithParam<Size> blendLinearFixture;
+
+PERF_TEST_P(blendLinearFixture, blendLinear, OCL_TYPICAL_MAT_SIZES)
 {
-    Mat src1, src2, weights1, weights2, dst, ocl_dst;
+    const Size srcSize = GetParam();
-    ocl::oclMat d_src1, d_src2, d_weights1, d_weights2, d_dst;
+    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};
+    declare.in(src1, src2, WARMUP_RNG);
-    std::string type_name[] = {"CV_8UC1", "CV_8UC4"};
+    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++)
+        ocl::oclMat oclSrc1(src1), oclSrc2(src2), oclDst;
-        {
+        ocl::oclMat oclWeights1(weights1), oclWeights2(weights2);
-            SUBTEST << size << 'x' << size << "; " << type_name[j] << " and CV_32FC1";
+
-
+        TEST_CYCLE() cv::ocl::blendLinear(oclSrc1, oclSrc2, oclWeights1, oclWeights2, oclDst);
-            gen(src1, size, size, all_type[j], 0, 256);
+
-            gen(src2, size, size, all_type[j], 0, 256);
+        oclDst.download(dst);
-            gen(weights1, size, size, CV_32FC1, 0, 1);
+
-            gen(weights2, size, size, CV_32FC1, 0, 1);
+        SANITY_CHECK(dst);
-
+    }
-            blendLinearGold<uchar>(src1, src2, weights1, weights2, dst);
+    else if (RUN_PLAIN_IMPL)
-
+    {
-            CPU_ON;
+        TEST_CYCLE() blendLinearGold<uchar>(src1, src2, weights1, weights2, dst);
-            blendLinearGold<uchar>(src1, src2, weights1, weights2, dst);
+
-            CPU_OFF;
+        SANITY_CHECK(dst);
-
-            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);
-        }
     }
+    else
+        OCL_PERF_ELSE
 }

modules/ocl/perf/perf_brute_force_matcher.cpp

@@ -45,123 +45,119 @@
 //M*/
 #include "perf_precomp.hpp"
 
-//////////////////// BruteForceMatch /////////////////
+using namespace perf;
-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<DMatch> > matches(2);
-        vector< vector<DMatch> > d_matches(2);
-        // Init GPU matcher
-        ocl::BruteForceMatcher_OCL_base d_matcher(ocl::BruteForceMatcher_OCL_base::L2Dist);
 
-        ocl::oclMat d_query(query);
+#define OCL_BFMATCHER_TYPICAL_MAT_SIZES ::testing::Values(cv::Size(128, 500), cv::Size(128, 1000), cv::Size(128, 2000))
-        ocl::oclMat d_train(train);
 
-        ocl::oclMat d_trainIdx, d_distance, d_allDist, d_nMatches;
+//////////////////// BruteForceMatch /////////////////
-
-        SUBTEST << size << "; match";
-
-        matcher.match(query, train, matches[0]);
 
-        CPU_ON;
+typedef TestBaseWithParam<Size> BruteForceMatcherFixture;
-        matcher.match(query, train, matches[0]);
-        CPU_OFF;
 
-        WARMUP_ON;
+PERF_TEST_P(BruteForceMatcherFixture, DISABLED_match,
-        d_matcher.matchSingle(d_query, d_train, d_trainIdx, d_distance);
+            OCL_BFMATCHER_TYPICAL_MAT_SIZES) // TODO too big difference between implementations
-        WARMUP_OFF;
+{
+    const Size srcSize = GetParam();
 
-        GPU_ON;
+    vector<DMatch> matches;
-        d_matcher.matchSingle(d_query, d_train, d_trainIdx, d_distance);
+    Mat query(srcSize, CV_32F), train(srcSize, CV_32F);
-        GPU_OFF;
+    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;
+    if (RUN_PLAIN_IMPL)
-        d_query.upload(query);
+    {
-        d_train.upload(train);
+        BFMatcher matcher(NORM_L2);
-        d_matcher.match(d_query, d_train, d_matches[0]);
+        TEST_CYCLE() matcher.match(query, train, matches);
-        GPU_FULL_OFF;
 
-        int diff = abs((int)d_matches[0].size() - (int)matches[0].size());
+        SANITY_CHECK_MATCHES(matches);
-        if(diff == 0)
+    }
-            TestSystem::instance().setAccurate(1, 0);
+    else if (RUN_OCL_IMPL)
-        else
+    {
-            TestSystem::instance().setAccurate(0, diff);
+        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;
+PERF_TEST_P(BruteForceMatcherFixture, DISABLED_knnMatch,
-        matcher.knnMatch(query, train, matches, 2);
+            OCL_BFMATCHER_TYPICAL_MAT_SIZES)  // TODO too many outliers
-        CPU_OFF;
+{
+    const Size srcSize = GetParam();
 
-        WARMUP_ON;
+    vector<vector<DMatch> > matches(2);
-        d_matcher.knnMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_allDist, 2);
+    Mat query(srcSize, CV_32F), train(srcSize, CV_32F);
-        WARMUP_OFF;
+    randu(query, 0.0f, 1.0f);
+    randu(train, 0.0f, 1.0f);
 
-        GPU_ON;
+    declare.in(query, train);
-        d_matcher.knnMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_allDist, 2);
+    if (srcSize.height == 2000)
-        GPU_OFF;
+        declare.time(8);
 
-        GPU_FULL_ON;
+    if (RUN_PLAIN_IMPL)
-        d_query.upload(query);
+    {
-        d_train.upload(train);
+        BFMatcher matcher (NORM_L2);
-        d_matcher.knnMatch(d_query, d_train, d_matches, 2);
+        TEST_CYCLE() matcher.knnMatch(query, train, matches, 2);
-        GPU_FULL_OFF;
 
-        diff = abs((int)d_matches[0].size() - (int)matches[0].size());
+        std::vector<DMatch> & matches0 = matches[0], & matches1 = matches[1];
-        if(diff == 0)
+        SANITY_CHECK_MATCHES(matches0);
-            TestSystem::instance().setAccurate(1, 0);
+        SANITY_CHECK_MATCHES(matches1);
-        else
+    }
-            TestSystem::instance().setAccurate(0, diff);
+    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<DMatch> & 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;
+    const float max_distance = 2.0f;
-        matcher.radiusMatch(query, train, matches, max_distance);
+    vector<vector<DMatch> > matches(2);
-        CPU_OFF;
+    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;
+    if (RUN_PLAIN_IMPL)
-        d_matcher.radiusMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_nMatches, max_distance);
+    {
-        WARMUP_OFF;
+        BFMatcher matcher (NORM_L2);
+        TEST_CYCLE() matcher.radiusMatch(query, matches, max_distance);
 
-        GPU_ON;
+        std::vector<DMatch> & matches0 = matches[0], & matches1 = matches[1];
-        d_matcher.radiusMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_nMatches, max_distance);
+        SANITY_CHECK_MATCHES(matches0);
-        GPU_OFF;
+        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;
+        TEST_CYCLE() oclMatcher.radiusMatch(oclQuery, oclTrain, matches, max_distance);
-        d_query.upload(query);
-        d_train.upload(train);
-        d_matcher.radiusMatch(d_query, d_train, d_matches, max_distance);
-        GPU_FULL_OFF;
 
-        diff = abs((int)d_matches[0].size() - (int)matches[0].size());
+        std::vector<DMatch> & matches0 = matches[0], & matches1 = matches[1];
-        if(diff == 0)
+        SANITY_CHECK_MATCHES(matches0);
-            TestSystem::instance().setAccurate(1, 0);
+        SANITY_CHECK_MATCHES(matches1);
-        else
-            TestSystem::instance().setAccurate(0, diff);
     }
+    else
+        OCL_PERF_ELSE
 }
+
+#undef OCL_BFMATCHER_TYPICAL_MAT_SIZES

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);
+    ASSERT_TRUE(!left_image.empty()) << "no input image";
-    bm(left_image, right_image, dst);
+    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;
+    const int n_disp = 128, winSize = 19;
-    bm(left_image, right_image, dst);
+    Mat disp(left_image.size(), CV_16SC1);
-    CPU_OFF;
 
-    d_left.upload(left_image);
+    declare.in(left_image, right_image).out(disp);
-    d_right.upload(right_image);
 
-    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;
+        TEST_CYCLE() oclBM(oclLeft, oclRight, oclDisp);
-    d_bm(d_left, d_right, d_disp);
-    WARMUP_OFF;
 
-    cv::Mat ocl_mat;
+        oclDisp.download(disp);
-    d_disp.download(ocl_mat);
-    ocl_mat.convertTo(ocl_mat, dst.type());
 
-    GPU_ON;
+        SANITY_CHECK(disp);
-    d_bm(d_left, d_right, d_disp);
+    }
-    GPU_OFF;
+    else if (RUN_PLAIN_IMPL)
+    {
+        StereoBM bm(0, n_disp, winSize);
 
-    GPU_FULL_ON;
+        TEST_CYCLE() bm(left_image, right_image, disp);
-    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;
 
-    TestSystem::instance().setAccurate(-1, 0.);
+        SANITY_CHECK(disp);
+    }
+    else
+        OCL_PERF_ELSE
 }

modules/ocl/perf/perf_canny.cpp

@@ -45,41 +45,33 @@
 //M*/
 #include "perf_precomp.hpp"
 
-///////////// Canny ////////////////////////
+using namespace perf;
-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";
 
-    Mat edges(img.size(), CV_8UC1), ocl_edges;
+///////////// Canny ////////////////////////
 
-    CPU_ON;
+PERF_TEST(CannyFixture, DISABLED_Canny) // TODO difference between implmentations
-    Canny(img, edges, 50.0, 100.0);
+{
-    CPU_OFF;
+    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);
+    declare.in(img).out(edges);
-    ocl::oclMat d_edges;
-    ocl::CannyBuf d_buf;
 
-    WARMUP_ON;
+    if (RUN_OCL_IMPL)
-    ocl::Canny(d_img, d_buf, d_edges, 50.0, 100.0);
+    {
-    WARMUP_OFF;
+        ocl::oclMat oclImg(img), oclEdges(img.size(), CV_8UC1);
 
-    GPU_ON;
+        TEST_CYCLE() ocl::Canny(oclImg, oclEdges, 50.0, 100.0);
-    ocl::Canny(d_img, d_buf, d_edges, 50.0, 100.0);
+        oclEdges.download(edges);
-    GPU_OFF;
 
-    GPU_FULL_ON;
+        SANITY_CHECK(edges);
-    d_img.upload(img);
+    }
-    ocl::Canny(d_img, d_buf, d_edges, 50.0, 100.0);
+    else if (RUN_PLAIN_IMPL)
-    d_edges.download(ocl_edges);
+    {
-    GPU_FULL_OFF;
+        TEST_CYCLE() Canny(img, edges, 50.0, 100.0);
 
-    TestSystem::instance().ExceptedMatSimilar(edges, ocl_edges, 2e-2);
+        SANITY_CHECK(edges);
+    }
+    else
+        OCL_PERF_ELSE
 }

modules/ocl/perf/perf_color.cpp

@@ -45,49 +45,34 @@
 //M*/
 #include "perf_precomp.hpp"
 
-///////////// cvtColor////////////////////////
+using namespace perf;
-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;
 
-            d_src.upload(src);
+///////////// cvtColor////////////////////////
 
-            WARMUP_ON;
+typedef TestBaseWithParam<Size> cvtColorFixture;
-            ocl::cvtColor(d_src, d_dst, CV_RGBA2GRAY, 4);
-            WARMUP_OFF;
 
-            GPU_ON;
+PERF_TEST_P(cvtColorFixture, cvtColor, OCL_TYPICAL_MAT_SIZES)
-            ocl::cvtColor(d_src, d_dst, CV_RGBA2GRAY, 4);
+{
-            GPU_OFF;
+    const Size srcSize = GetParam();
 
-            GPU_FULL_ON;
+    Mat src(srcSize, CV_8UC4), dst(srcSize, CV_8UC4);
-            d_src.upload(src);
+    declare.in(src, WARMUP_RNG).out(dst);
-            ocl::cvtColor(d_src, d_dst, CV_RGBA2GRAY, 4);
-            d_dst.download(ocl_dst);
-            GPU_FULL_OFF;
 
-            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
 }

modules/ocl/perf/perf_fft.cpp

@@ -45,47 +45,39 @@
 //M*/
 #include "perf_precomp.hpp"
 
-///////////// dft ////////////////////////
+using namespace perf;
-PERFTEST(dft)
-{
-    Mat src, dst, ocl_dst;
-    ocl::oclMat d_src, d_dst;
-
-    int all_type[] = {CV_32FC2};
-    std::string type_name[] = {"CV_32FC2"};
 
-    for (int size = Min_Size; size <= Max_Size; size *= Multiple)
+///////////// dft ////////////////////////
-    {
-        for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
-        {
-            SUBTEST << size << 'x' << size << "; " << type_name[j] << " ; complex-to-complex";
 
-            gen(src, size, size, all_type[j], Scalar::all(0), Scalar::all(1));
+typedef TestBaseWithParam<Size> dftFixture;
 
-            dft(src, dst);
+PERF_TEST_P(dftFixture, DISABLED_dft, OCL_TYPICAL_MAT_SIZES) // TODO not implemented
+{
+    const Size srcSize = GetParam();
 
-            CPU_ON;
+    Mat src(srcSize, CV_32FC2), dst;
-            dft(src, dst);
+    randu(src, 0.0f, 1.0f);
-            CPU_OFF;
+    declare.in(src);
 
-            d_src.upload(src);
+    if (srcSize == OCL_SIZE_4000)
+        declare.time(7.4);
 
-            WARMUP_ON;
+    if (RUN_OCL_IMPL)
-            ocl::dft(d_src, d_dst, Size(size, size));
+    {
-            WARMUP_OFF;
+        ocl::oclMat oclSrc(src), oclDst;
 
-            GPU_ON;
+        TEST_CYCLE() cv::ocl::dft(oclSrc, oclDst);
-            ocl::dft(d_src, d_dst, Size(size, size));
-            GPU_OFF;
 
-            GPU_FULL_ON;
+        oclDst.download(dst);
-            d_src.upload(src);
-            ocl::dft(d_src, d_dst, Size(size, size));
-            d_dst.download(ocl_dst);
-            GPU_FULL_OFF;
 
-            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
 }

modules/ocl/perf/perf_filters.cpp

@@ -45,333 +45,279 @@
 //M*/
 #include "perf_precomp.hpp"
 
-///////////// Blur////////////////////////
+using namespace perf;
-PERFTEST(Blur)
+using std::tr1::get;
-{
+using std::tr1::tuple;
-    Mat src1, dst, ocl_dst;
-    ocl::oclMat d_src1, d_dst;
 
-    Size ksize = Size(3, 3);
+///////////// Blur////////////////////////
-    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] ;
 
-            gen(src1, size, size, all_type[j], 0, 256);
+typedef Size_MatType BlurFixture;
-            gen(dst, size, size, all_type[j], 0, 256);
 
-            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;
+    Mat src(srcSize, type), dst(srcSize, type);
-            blur(src1, dst, ksize, Point(-1, -1), bordertype);
+    declare.in(src, WARMUP_RNG).out(dst);
-            CPU_OFF;
 
-            d_src1.upload(src1);
+    if (srcSize == OCL_SIZE_4000 && type == CV_8UC4)
+        declare.time(5);
 
-            WARMUP_ON;
+    if (RUN_OCL_IMPL)
-            ocl::blur(d_src1, d_dst, ksize, Point(-1, -1), bordertype);
+    {
-            WARMUP_OFF;
+        ocl::oclMat oclSrc(src), oclDst(srcSize, type);
 
-            GPU_ON;
+        TEST_CYCLE() cv::ocl::blur(oclSrc, oclDst, ksize, Point(-1, -1), bordertype);
-            ocl::blur(d_src1, d_dst, ksize, Point(-1, -1), bordertype);
-            GPU_OFF;
 
-            GPU_FULL_ON;
+        oclDst.download(dst);
-            d_src1.upload(src1);
-            ocl::blur(d_src1, d_dst, ksize, Point(-1, -1), bordertype);
-            d_dst.download(ocl_dst);
-            GPU_FULL_OFF;
 
-            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)
+///////////// Laplacian////////////////////////
-    {
-        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);
+typedef Size_MatType LaplacianFixture;
-            gen(dst, size, size, all_type[j], 0, 256);
 
-            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;
+    Mat src(srcSize, type), dst(srcSize, type);
-            Laplacian(src1, dst, -1, ksize, 1);
+    declare.in(src, WARMUP_RNG).out(dst);
-            CPU_OFF;
 
-            d_src1.upload(src1);
+    if (srcSize == OCL_SIZE_4000 && type == CV_8UC4)
+        declare.time(6);
 
-            WARMUP_ON;
+    if (RUN_OCL_IMPL)
-            ocl::Laplacian(d_src1, d_dst, -1, ksize, 1);
+    {
-            WARMUP_OFF;
+        ocl::oclMat oclSrc(src), oclDst(srcSize, type);
 
-            GPU_ON;
+        TEST_CYCLE() cv::ocl::Laplacian(oclSrc, oclDst, -1, ksize, 1);
-            ocl::Laplacian(d_src1, d_dst, -1, ksize, 1);
-            GPU_OFF;
 
-            GPU_FULL_ON;
+        oclDst.download(dst);
-            d_src1.upload(src1);
-            ocl::Laplacian(d_src1, d_dst, -1, ksize, 1);
-            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::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)
+typedef Size_MatType ErodeFixture;
-    {
-        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));
 
-            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;
+    Mat src(srcSize, type), dst(srcSize, type);
-            erode(src, dst, ker);
+    declare.in(src, WARMUP_RNG).out(dst).in(ker);
-            CPU_OFF;
 
-            d_src.upload(src);
+    if (srcSize == OCL_SIZE_4000 && type == CV_8UC4)
+        declare.time(5);
 
-            WARMUP_ON;
+    if (RUN_OCL_IMPL)
-            ocl::erode(d_src, d_dst, ker);
+    {
-            WARMUP_OFF;
+        ocl::oclMat oclSrc(src), oclDst(srcSize, type), oclKer(ker);
 
-            GPU_ON;
+        TEST_CYCLE() cv::ocl::erode(oclSrc, oclDst, oclKer);
-            ocl::erode(d_src, d_dst, ker);
-            GPU_OFF;
 
-            GPU_FULL_ON;
+        oclDst.download(dst);
-            d_src.upload(src);
-            ocl::erode(d_src, d_dst, ker);
-            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::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)
+typedef Size_MatType SobelFixture;
-    {
-        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);
 
-            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;
+    Mat src(srcSize, type), dst(srcSize, type);
-            Sobel(src, dst, -1, dx, dy);
+    declare.in(src, WARMUP_RNG).out(dst);
-            CPU_OFF;
 
-            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;
+    if (RUN_OCL_IMPL)
-            ocl::Sobel(d_src, d_dst, -1, dx, dy);
+    {
-            WARMUP_OFF;
+        ocl::oclMat oclSrc(src), oclDst(srcSize, type);
 
-            GPU_ON;
+        TEST_CYCLE() cv::ocl::Sobel(oclSrc, oclDst, -1, dx, dy);
-            ocl::Sobel(d_src, d_dst, -1, dx, dy);
-            GPU_OFF;
 
-            GPU_FULL_ON;
+        oclDst.download(dst);
-            d_src.upload(src);
-            ocl::Sobel(d_src, d_dst, -1, dx, dy);
-            d_dst.download(ocl_dst);
-            GPU_FULL_OFF;
 
-            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;
+///////////// Scharr ////////////////////////
-    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] ;
 
-            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;
+    Mat src(srcSize, type), dst(srcSize, type);
-            Scharr(src, dst, -1, dx, dy);
+    declare.in(src, WARMUP_RNG).out(dst);
-            CPU_OFF;
 
-            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;
+    if (RUN_OCL_IMPL)
-            ocl::Scharr(d_src, d_dst, -1, dx, dy);
+    {
-            WARMUP_OFF;
+        ocl::oclMat oclSrc(src), oclDst(srcSize, type);
 
-            GPU_ON;
+        TEST_CYCLE() cv::ocl::Scharr(oclSrc, oclDst, -1, dx, dy);
-            ocl::Scharr(d_src, d_dst, -1, dx, dy);
-            GPU_OFF;
 
-            GPU_FULL_ON;
+        oclDst.download(dst);
-            d_src.upload(src);
-            ocl::Scharr(d_src, d_dst, -1, dx, dy);
-            d_dst.download(ocl_dst);
-            GPU_FULL_OFF;
 
-            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)
+typedef Size_MatType GaussianBlurFixture;
-    {
-        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);
 
-            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;
+    Mat src(srcSize, type), dst(srcSize, type);
-            GaussianBlur(src, dst, Size(ksize, ksize), 0);
+    declare.in(src, WARMUP_RNG).out(dst);
-            CPU_OFF;
 
-            ocl::oclMat d_src(src);
+    const double eps = src.depth() == CV_8U ? 1 + DBL_EPSILON : 3e-4;
-            ocl::oclMat d_dst;
 
-            WARMUP_ON;
+    if (RUN_OCL_IMPL)
-            ocl::GaussianBlur(d_src, d_dst, Size(ksize, ksize), 0);
+    {
-            WARMUP_OFF;
+        ocl::oclMat oclSrc(src), oclDst(srcSize, type);
 
-            GPU_ON;
+        TEST_CYCLE() cv::ocl::GaussianBlur(oclSrc, oclDst, Size(ksize, ksize), 0);
-            ocl::GaussianBlur(d_src, d_dst, Size(ksize, ksize), 0);
-            GPU_OFF;
 
-            GPU_FULL_ON;
+        oclDst.download(dst);
-            d_src.upload(src);
-            ocl::GaussianBlur(d_src, d_dst, Size(ksize, ksize), 0);
-            d_dst.download(ocl_dst);
-            GPU_FULL_OFF;
 
-            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;
+typedef Size_MatType filter2DFixture;
-            gen(kernel, ksize, ksize, CV_32SC1, -3.0, 3.0);
 
-            Mat dst, ocl_dst;
+PERF_TEST_P(filter2DFixture, filter2D,
-
+            ::testing::Combine(OCL_TYPICAL_MAT_SIZES,
-            cv::filter2D(src, dst, -1, kernel);
+                               OCL_PERF_ENUM(CV_8UC1, CV_8UC4)))
-
+{
-            CPU_ON;
+    const Size_MatType_t params = GetParam();
-            cv::filter2D(src, dst, -1, kernel);
+    const Size srcSize = get<0>(params);
-            CPU_OFF;
+    const int type = get<1>(params), ksize = 3;
-
-            ocl::oclMat d_src(src), d_dst;
 
-            WARMUP_ON;
+    Mat src(srcSize, type), dst(srcSize, type), kernel(ksize, ksize, CV_32SC1);
-            ocl::filter2D(d_src, d_dst, -1, kernel);
+    declare.in(src, WARMUP_RNG).in(kernel).out(dst);
-            WARMUP_OFF;
+    randu(kernel, -3.0, 3.0);
 
-            GPU_ON;
+    if (srcSize == OCL_SIZE_4000 && type == CV_8UC4)
-            ocl::filter2D(d_src, d_dst, -1, kernel);
+        declare.time(8);
-            GPU_OFF;
 
-            GPU_FULL_ON;
+    if (RUN_OCL_IMPL)
-            d_src.upload(src);
+    {
-            ocl::filter2D(d_src, d_dst, -1, kernel);
+        ocl::oclMat oclSrc(src), oclDst(srcSize, type), oclKernel(kernel);
-            d_dst.download(ocl_dst);
-            GPU_FULL_OFF;
 
-            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
 }

modules/ocl/perf/perf_gemm.cpp

@@ -45,46 +45,40 @@
 //M*/
 #include "perf_precomp.hpp"
 
-///////////// gemm ////////////////////////
+using namespace perf;
-PERFTEST(gemm)
-{
-    Mat src1, src2, src3, dst, ocl_dst;
-    ocl::oclMat d_src1, d_src2, d_src3, d_dst;
 
-    for (int size = Min_Size; size <= Max_Size; size *= Multiple)
+///////////// gemm ////////////////////////
-    {
-        SUBTEST << size << 'x' << size;
 
-        gen(src1, size, size, CV_32FC1, Scalar::all(-10), Scalar::all(10));
+typedef TestBaseWithParam<Size> gemmFixture;
-        gen(src2, size, size, CV_32FC1, Scalar::all(-10), Scalar::all(10));
-        gen(src3, size, size, CV_32FC1, Scalar::all(-10), Scalar::all(10));
 
-        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;
+    Mat src1(srcSize, CV_32FC1), src2(srcSize, CV_32FC1),
-        gemm(src1, src2, 1.0, src3, 1.0, dst);
+            src3(srcSize, CV_32FC1), dst(srcSize, CV_32FC1);
-        CPU_OFF;
+    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);
+    if (RUN_OCL_IMPL)
-        d_src2.upload(src2);
+    {
-        d_src3.upload(src3);
+        ocl::oclMat oclSrc1(src1), oclSrc2(src2),
+                oclSrc3(src3), oclDst(srcSize, CV_32FC1);
 
-        WARMUP_ON;
+        TEST_CYCLE() cv::ocl::gemm(oclSrc1, oclSrc2, 1.0, oclSrc3, 1.0, oclDst);
-        ocl::gemm(d_src1, d_src2, 1.0, d_src3, 1.0, d_dst);
-        WARMUP_OFF;
 
-        GPU_ON;
+        oclDst.download(dst);
-        ocl::gemm(d_src1, d_src2, 1.0, d_src3, 1.0, d_dst);
-        GPU_OFF;
 
-        GPU_FULL_ON;
+        SANITY_CHECK(dst);
-        d_src1.upload(src1);
+    }
-        d_src2.upload(src2);
+    else if (RUN_PLAIN_IMPL)
-        d_src3.upload(src3);
+    {
-        ocl::gemm(d_src1, d_src2, 1.0, d_src3, 1.0, d_dst);
+        TEST_CYCLE() cv::gemm(src1, src2, 1.0, src3, 1.0, dst);
-        d_dst.download(ocl_dst);
-        GPU_FULL_OFF;
 
-        TestSystem::instance().ExpectedMatNear(ocl_dst, dst, src1.cols * src1.rows * 1e-4);
+        SANITY_CHECK(dst);
     }
+    else
+        OCL_PERF_ELSE
 }

modules/ocl/perf/perf_gftt.cpp

@@ -46,56 +46,50 @@
 
 #include "perf_precomp.hpp"
 
-///////////// GoodFeaturesToTrack ////////////////////////
+using namespace perf;
-PERFTEST(GoodFeaturesToTrack)
+using std::tr1::tuple;
-{
+using std::tr1::get;
-    using namespace cv;
-
-    int maxCorners = 2000;
-    double qualityLevel = 0.01;
 
-    std::string images[] = { "rubberwhale1.png", "aloeL.jpg" };
+///////////// GoodFeaturesToTrack ////////////////////////
-
-    std::vector<cv::Point2f> 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());
 
-        for(float minDistance = 0; minDistance < 4; minDistance += 3.0)
+typedef tuple<string, double> GoodFeaturesToTrackParams;
-        {
+typedef TestBaseWithParam<GoodFeaturesToTrackParams> GoodFeaturesToTrackFixture;
-            SUBTEST << "image = " << images[imgIdx] << "; ";
-            SUBTEST << "minDistance = " << minDistance << "; ";
 
-            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;
+    const GoodFeaturesToTrackParams param = GetParam();
-            cv::goodFeaturesToTrack(frame, pts_gold, maxCorners, qualityLevel, minDistance);
+    const string fileName = getDataPath(get<0>(param));
-            CPU_OFF;
+    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<Point2f> pts_gold;
+    declare.in(frame);
 
-            WARMUP_ON;
+    if (RUN_OCL_IMPL)
-            detector(frame_ocl, pts_oclmat);
+    {
-            WARMUP_OFF;
+        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<float>(pts_gold.size() - pts_ocl.size()));
+        detector.downloadPoints(pts_oclmat, pts_gold);
-            TestSystem::instance().setAccurate(diff == 0.0, diff);
 
-            GPU_ON;
+        SANITY_CHECK(pts_gold);
-            detector(frame_ocl, pts_oclmat);
+    }
-            GPU_OFF;
+    else if (RUN_PLAIN_IMPL)
+    {
+        TEST_CYCLE() cv::goodFeaturesToTrack(frame, pts_gold,
+                                             maxCorners, qualityLevel, minDistance);
 
-            GPU_FULL_ON;
+        SANITY_CHECK(pts_gold);
-            frame_ocl.upload(frame);
-            detector(frame_ocl, pts_oclmat);
-            detector.downloadPoints(pts_oclmat, pts_ocl);
-            GPU_FULL_OFF;
-        }
     }
+    else
+        OCL_PERF_ELSE
 }

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<Rect> faces;
 
-    SUBTEST << img.cols << "x" << img.rows << "; scale image";
+    Mat img = imread(getDataPath("gpu/haarcascade/basketball1.png"), CV_LOAD_IMAGE_GRAYSCALE);
-    CPU_ON;
+    ASSERT_TRUE(!img.empty()) << "can't open basketball1.png";
-    faceCascadeCPU.detectMultiScale(img, faces,
+    declare.in(img);
-                                    1.1, 2, 0 | CV_HAAR_SCALE_IMAGE, Size(30, 30));
-    CPU_OFF;
 
+    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<Rect> oclfaces;
+        TEST_CYCLE() faceCascade.detectMultiScale(img, faces,
-    ocl::CascadeClassifier_GPU faceCascade;
+                                                     1.1, 2, 0 | CV_HAAR_SCALE_IMAGE, Size(30, 30));
 
-    if (!faceCascade.load(abspath("haarcascade_frontalface_alt.xml")))
+        SANITY_CHECK(faces, 4 + 1e-4);
-    {
-        throw runtime_error("can't load haarcascade_frontalface_alt.xml");
     }
+    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;
+        TEST_CYCLE() faceCascade.detectMultiScale(oclImg, faces,
-    faceCascade.detectMultiScale(d_img, oclfaces,
+                                     1.1, 2, 0 | CV_HAAR_SCALE_IMAGE, Size(30, 30));
-                                 1.1, 2, 0 | CV_HAAR_SCALE_IMAGE, Size(30, 30));
-    WARMUP_OFF;
 
-    if(faces.size() == oclfaces.size())
+        SANITY_CHECK(faces, 4 + 1e-4);
-        TestSystem::instance().setAccurate(1, 0);
+    }
     else
-        TestSystem::instance().setAccurate(0, abs((int)faces.size() - (int)oclfaces.size()));
+        OCL_PERF_ELSE
-
-    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;
 }

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);
+    Mat src = imread(getDataPath("gpu/hog/road.png"), cv::IMREAD_GRAYSCALE);
-
+    ASSERT_TRUE(!src.empty()) << "can't open input image road.png";
-    if (src.empty())
-    {
-        throw runtime_error("can't open road.png");
-    }
-
-    cv::HOGDescriptor hog;
-    hog.setSVMDetector(hog.getDefaultPeopleDetector());
-    std::vector<cv::Rect> found_locations;
-    std::vector<cv::Rect> d_found_locations;
 
-    SUBTEST << src.cols << 'x' << src.rows << "; road.png";
+    vector<cv::Rect> found_locations;
+    declare.in(src).time(5);
 
-    hog.detectMultiScale(src, found_locations);
+    if (RUN_PLAIN_IMPL)
+    {
+        HOGDescriptor hog;
+        hog.setSVMDetector(hog.getDefaultPeopleDetector());
 
-    CPU_ON;
+        TEST_CYCLE() hog.detectMultiScale(src, found_locations);
-    hog.detectMultiScale(src, found_locations);
-    CPU_OFF;
 
-    cv::ocl::HOGDescriptor ocl_hog;
+        SANITY_CHECK(found_locations, 1 + DBL_EPSILON);
-    ocl_hog.setSVMDetector(ocl_hog.getDefaultPeopleDetector());
+    }
-    ocl::oclMat d_src;
+    else if (RUN_OCL_IMPL)
-    d_src.upload(src);
+    {
+        ocl::HOGDescriptor ocl_hog;
+        ocl_hog.setSVMDetector(ocl_hog.getDefaultPeopleDetector());
+        ocl::oclMat oclSrc(src);
 
-    WARMUP_ON;
+        TEST_CYCLE() ocl_hog.detectMultiScale(oclSrc, found_locations);
-    ocl_hog.detectMultiScale(d_src, d_found_locations);
-    WARMUP_OFF;
 
-    if(d_found_locations.size() == found_locations.size())
+        SANITY_CHECK(found_locations, 1 + DBL_EPSILON);
-        TestSystem::instance().setAccurate(1, 0);
+    }
     else
-        TestSystem::instance().setAccurate(0, abs((int)found_locations.size() - (int)d_found_locations.size()));
+        OCL_PERF_ELSE
-
-    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;
 }

modules/ocl/perf/perf_match_template.cpp

@@ -45,101 +45,77 @@
 //M*/
 #include "perf_precomp.hpp"
 
-/////////// matchTemplate ////////////////////////
+using namespace perf;
-//void InitMatchTemplate()
+using std::tr1::tuple;
-//{
+using std::tr1::get;
-//	Mat src; gen(src, 500, 500, CV_32F, 0, 1);
-//	Mat templ; gen(templ, 500, 500, CV_32F, 0, 1);
-//	ocl::oclMat d_src(src), d_templ(templ), d_dst;
-//	ocl::matchTemplate(d_src, d_templ, d_dst, CV_TM_CCORR);
-//}
-PERFTEST(matchTemplate)
-{
-    //InitMatchTemplate();
-    Mat src, templ, dst, ocl_dst;
-    int templ_size = 5;
-
-    for (int size = Min_Size; size <= Max_Size; size *= Multiple)
-    {
-        int all_type[] = {CV_32FC1, CV_32FC4};
-        std::string type_name[] = {"CV_32FC1", "CV_32FC4"};
-
-        for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
-        {
-            for(templ_size = 5; templ_size <= 5; templ_size *= 5)
-            {
-                gen(src, size, size, all_type[j], 0, 1);
-
-                SUBTEST << src.cols << 'x' << src.rows << "; " << type_name[j] << "; templ " << templ_size << 'x' << templ_size << "; CCORR";
 
-                gen(templ, templ_size, templ_size, all_type[j], 0, 1);
+/////////// matchTemplate ////////////////////////
-
-                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;
 
-                GPU_ON;
+typedef Size_MatType CV_TM_CCORRFixture;
-                ocl::matchTemplate(d_src, d_templ, d_dst, CV_TM_CCORR);
-                GPU_OFF;
 
-                GPU_FULL_ON;
+PERF_TEST_P(CV_TM_CCORRFixture, matchTemplate,
-                d_src.upload(src);
+            ::testing::Combine(::testing::Values(OCL_SIZE_1000, OCL_SIZE_2000),
-                d_templ.upload(templ);
+                               OCL_PERF_ENUM(CV_32FC1, CV_32FC4)))
-                ocl::matchTemplate(d_src, d_templ, d_dst, CV_TM_CCORR);
+{
-                d_dst.download(ocl_dst);
+    const Size_MatType_t params = GetParam();
-                GPU_FULL_OFF;
+    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};
+        oclDst.download(dst);
-        std::string type_name_8U[] = {"CV_8UC1"};
 
-        for (size_t j = 0; j < sizeof(all_type_8U) / sizeof(int); j++)
+        SANITY_CHECK(dst, 1e-4);
-        {
+    }
-            for(templ_size = 5; templ_size <= 5; templ_size *= 5)
+    else if (RUN_PLAIN_IMPL)
-            {
+    {
-                SUBTEST << src.cols << 'x' << src.rows << "; " << type_name_8U[j] << "; templ " << templ_size << 'x' << templ_size << "; CCORR_NORMED";
+        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<Size> 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;
+    Mat src(srcSize, CV_8UC1), templ(templSize, CV_8UC1), dst;
-                matchTemplate(src, templ, dst, CV_TM_CCORR_NORMED);
+    const Size dstSize(src.cols - templ.cols + 1, src.rows - templ.rows + 1);
-                CPU_OFF;
+    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);
+    if (RUN_OCL_IMPL)
-                ocl::oclMat d_templ(templ), d_dst;
+    {
+        ocl::oclMat oclSrc(src), oclTempl(templ), oclDst(dstSize, CV_8UC1);
 
-                WARMUP_ON;
+        TEST_CYCLE() cv::ocl::matchTemplate(oclSrc, oclTempl, oclDst, CV_TM_CCORR_NORMED);
-                ocl::matchTemplate(d_src, d_templ, d_dst, CV_TM_CCORR_NORMED);
-                WARMUP_OFF;
 
-                GPU_ON;
+        oclDst.download(dst);
-                ocl::matchTemplate(d_src, d_templ, d_dst, CV_TM_CCORR_NORMED);
-                GPU_OFF;
 
-                GPU_FULL_ON;
+        SANITY_CHECK(dst, 2e-2);
-                d_src.upload(src);
+    }
-                d_templ.upload(templ);
+    else if (RUN_PLAIN_IMPL)
-                ocl::matchTemplate(d_src, d_templ, d_dst, CV_TM_CCORR_NORMED);
+    {
-                d_dst.download(ocl_dst);
+        TEST_CYCLE() cv::matchTemplate(src, templ, dst, CV_TM_CCORR_NORMED);
-                GPU_FULL_OFF;
 
-                TestSystem::instance().ExpectedMatNear(dst, ocl_dst, templ.rows * templ.cols * 1e-1);
+        SANITY_CHECK(dst, 2e-2);
-            }
-        }
     }
+    else
+        OCL_PERF_ELSE
 }

modules/ocl/perf/perf_matrix_operation.cpp

@@ -45,142 +45,113 @@
 //M*/
 #include "perf_precomp.hpp"
 
-///////////// ConvertTo////////////////////////
+using namespace perf;
-PERFTEST(ConvertTo)
+using std::tr1::tuple;
-{
+using std::tr1::get;
-    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";
 
-            gen(src, size, size, all_type[j], 0, 256);
+///////////// ConvertTo////////////////////////
-            //gen(dst, size, size, all_type[j], 0, 256);
-
-            //d_dst.upload(dst);
-
-            src.convertTo(dst, CV_32FC1);
 
-            CPU_ON;
+typedef Size_MatType ConvertToFixture;
-            src.convertTo(dst, CV_32FC1);
-            CPU_OFF;
 
-            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;
+    Mat src(srcSize, type), dst;
-            d_src.convertTo(d_dst, CV_32FC1);
+    const int dstType = CV_MAKE_TYPE(CV_32F, src.channels());
-            WARMUP_OFF;
+    dst.create(srcSize, dstType);
+    declare.in(src, WARMUP_RNG).out(dst);
 
-            GPU_ON;
+    if (RUN_OCL_IMPL)
-            d_src.convertTo(d_dst, CV_32FC1);
+    {
-            GPU_OFF;
+        ocl::oclMat oclSrc(src), oclDst(srcSize, dstType);
 
-            GPU_FULL_ON;
+        TEST_CYCLE() oclSrc.convertTo(oclDst, dstType);
-            d_src.upload(src);
-            d_src.convertTo(d_dst, CV_32FC1);
-            d_dst.download(ocl_dst);
-            GPU_FULL_OFF;
 
-            TestSystem::instance().ExpectedMatNear(dst, ocl_dst, 0.0);
+        oclDst.download(dst);
-        }
 
+        SANITY_CHECK(dst);
     }
-}
+    else if (RUN_PLAIN_IMPL)
-///////////// copyTo////////////////////////
-PERFTEST(copyTo)
-{
-    Mat src, dst, ocl_dst;
-    ocl::oclMat d_src, d_dst;
-
-    int all_type[] = {CV_8UC1, CV_8UC4};
-    std::string type_name[] = {"CV_8UC1", "CV_8UC4"};
-
-    for (int size = Min_Size; size <= Max_Size; size *= Multiple)
     {
-        for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
+        TEST_CYCLE() src.convertTo(dst, dstType);
-        {
-            SUBTEST << size << 'x' << size << "; " << type_name[j] ;
 
-            gen(src, size, size, all_type[j], 0, 256);
+        SANITY_CHECK(dst);
-            //gen(dst, size, size, all_type[j], 0, 256);
+    }
-
+    else
-            //d_dst.upload(dst);
+        OCL_PERF_ELSE
+}
 
-            src.copyTo(dst);
+///////////// copyTo////////////////////////
 
-            CPU_ON;
+typedef Size_MatType copyToFixture;
-            src.copyTo(dst);
-            CPU_OFF;
 
-            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;
+    Mat src(srcSize, type), dst(srcSize, type);
-            d_src.copyTo(d_dst);
+    declare.in(src, WARMUP_RNG).out(dst);
-            WARMUP_OFF;
 
-            GPU_ON;
+    if (RUN_OCL_IMPL)
-            d_src.copyTo(d_dst);
+    {
-            GPU_OFF;
+        ocl::oclMat oclSrc(src), oclDst(srcSize, type);
 
-            GPU_FULL_ON;
+        TEST_CYCLE() oclSrc.copyTo(oclDst);
-            d_src.upload(src);
-            d_src.copyTo(d_dst);
-            d_dst.download(ocl_dst);
-            GPU_FULL_OFF;
 
-            TestSystem::instance().ExpectedMatNear(dst, ocl_dst, 0.0);
+        oclDst.download(dst);
-        }
 
+        SANITY_CHECK(dst);
     }
-}
+    else if (RUN_PLAIN_IMPL)
-///////////// setTo////////////////////////
-PERFTEST(setTo)
-{
-    Mat src, ocl_src;
-    Scalar val(1, 2, 3, 4);
-    ocl::oclMat d_src;
-
-    int all_type[] = {CV_8UC1, CV_8UC4};
-    std::string type_name[] = {"CV_8UC1", "CV_8UC4"};
-
-    for (int size = Min_Size; size <= Max_Size; size *= Multiple)
     {
-        for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
+        TEST_CYCLE() src.copyTo(dst);
-        {
-            SUBTEST << size << 'x' << size << "; " << type_name[j] ;
 
-            gen(src, size, size, all_type[j], 0, 256);
+        SANITY_CHECK(dst);
+    }
+    else
+        OCL_PERF_ELSE
+}
 
-            src.setTo(val);
+///////////// setTo////////////////////////
 
-            CPU_ON;
+typedef Size_MatType setToFixture;
-            src.setTo(val);
-            CPU_OFF;
 
-            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;
+    Mat src(srcSize, type);
-            d_src.setTo(val);
+    declare.in(src);
-            WARMUP_OFF;
 
-            d_src.download(ocl_src);
+    if (RUN_OCL_IMPL)
-            TestSystem::instance().ExpectedMatNear(src, ocl_src, 1.0);
+    {
+        ocl::oclMat oclSrc(srcSize, type);
 
-            GPU_ON;;
+        TEST_CYCLE() oclSrc.setTo(val);
-            d_src.setTo(val);
+        oclSrc.download(src);
-            GPU_OFF;
 
-            GPU_FULL_ON;
+        SANITY_CHECK(src);
-            d_src.upload(src);
+    }
-            d_src.setTo(val);
+    else if (RUN_PLAIN_IMPL)
-            GPU_FULL_OFF;
+    {
-        }
+        TEST_CYCLE() src.setTo(val);
 
+        SANITY_CHECK(src);
     }
+    else
+        OCL_PERF_ELSE
 }

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};
+#include "perf_precomp.hpp"
-    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];
 
-            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;
+typedef Size_MatType MomentsFixture;
-            moments(src, binaryImage);
-            CPU_OFF;
 
-            cv::Moments oclMom;
+PERF_TEST_P(MomentsFixture, DISABLED_Moments,
-            WARMUP_ON;
+            ::testing::Combine(OCL_TYPICAL_MAT_SIZES,
-            oclMom = ocl::ocl_moments(src, binaryImage);
+                               OCL_PERF_ENUM(CV_8UC1, CV_16SC1, CV_32FC1, CV_64FC1)))  // TODO does not work properly (see below)
-            WARMUP_OFF;
+{
+    const Size_MatType_t params = GetParam();
+    const Size srcSize = get<0>(params);
+    const int type = get<1>(params);
 
-            Mat gpu_dst, cpu_dst;
+    Mat src(srcSize, type), dst(7, 1, CV_64F);
-            HuMoments(CvMom, cpu_dst);
+    const bool binaryImage = false;
-            HuMoments(oclMom, gpu_dst);
+    cv::Moments mom;
 
-            GPU_ON;
+    declare.in(src, WARMUP_RNG).out(dst);
-            ocl::ocl_moments(src, binaryImage);
-            GPU_OFF;
 
-            GPU_FULL_ON;
+    if (RUN_OCL_IMPL)
-            ocl::ocl_moments(src, binaryImage);
+    {
-            GPU_FULL_OFF;
+        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
 }

modules/ocl/perf/perf_norm.cpp

@@ -45,43 +45,39 @@
 //M*/
 #include "perf_precomp.hpp"
 
-///////////// norm////////////////////////
+using namespace perf;
-PERFTEST(norm)
+using std::tr1::tuple;
-{
+using std::tr1::get;
-    Mat src1, src2, ocl_src1;
-    ocl::oclMat d_src1, d_src2;
 
-    for (int size = Min_Size; size <= Max_Size; size *= Multiple)
+///////////// norm////////////////////////
-    {
-        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(src1, src2, NORM_INF);
+typedef TestBaseWithParam<Size> normFixture;
 
-        CPU_ON;
+PERF_TEST_P(normFixture, DISABLED_norm, OCL_TYPICAL_MAT_SIZES) // TODO doesn't work properly
-        norm(src1, src2, NORM_INF);
+{
-        CPU_OFF;
+    const Size srcSize = GetParam();
+    const std::string impl = getSelectedImpl();
+    double value = 0.0;
 
-        d_src1.upload(src1);
+    Mat src1(srcSize, CV_8UC1), src2(srcSize, CV_8UC1);
-        d_src2.upload(src2);
+    declare.in(src1, src2);
+    randu(src1, 0, 1);
+    randu(src2, 0, 1);
 
-        WARMUP_ON;
+    if (RUN_OCL_IMPL)
-        ocl::norm(d_src1, d_src2, NORM_INF);
+    {
-        WARMUP_OFF;
+        ocl::oclMat oclSrc1(src1), oclSrc2(src2);
 
-        d_src1.download(ocl_src1);
+        TEST_CYCLE() value = cv::ocl::norm(oclSrc1, oclSrc2, NORM_INF);
-        TestSystem::instance().ExpectedMatNear(src1, ocl_src1, .5);
 
-        GPU_ON;
+        SANITY_CHECK(value);
-        ocl::norm(d_src1, d_src2, NORM_INF);
+    }
-        GPU_OFF;
+    else if (RUN_PLAIN_IMPL)
+    {
+        TEST_CYCLE() value = cv::norm(src1, src2, NORM_INF);
 
-        GPU_FULL_ON;
+        SANITY_CHECK(value);
-        d_src1.upload(src1);
-        d_src2.upload(src2);
-        ocl::norm(d_src1, d_src2, NORM_INF);
-        GPU_FULL_OFF;
     }
+    else
+        OCL_PERF_ELSE
 }

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++)
+using namespace perf;
-    {
+using std::tr1::get;
-        Mat frame0 = imread(abspath(images1[i]), i == 0 ? IMREAD_COLOR : IMREAD_GRAYSCALE);
+using std::tr1::tuple;
+using std::tr1::make_tuple;
 
-        if (frame0.empty())
+template <typename T>
-        {
+static vector<T> & MatToVector(const ocl::oclMat & oclSrc, vector<T> & instance)
-            std::string errstr = "can't open " + images1[i];
+{
-            throw runtime_error(errstr);
+    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<T>(0, i));
 
-        if (frame1.empty())
+    return instance;
-        {
+}
-            std::string errstr = "can't open " + images2[i];
-            throw runtime_error(errstr);
-        }
 
-        Mat gray_frame;
+CV_ENUM(LoadMode, IMREAD_GRAYSCALE, IMREAD_COLOR)
+
+typedef tuple<int, tuple<string, string, LoadMode> > PyrLKOpticalFlowParamType;
+typedef TestBaseWithParam<PyrLKOpticalFlowParamType> PyrLKOpticalFlowFixture;
+
+PERF_TEST_P(PyrLKOpticalFlowFixture,
+            DISABLED_PyrLKOpticalFlow,
+            ::testing::Combine(
+                ::testing::Values(1000, 2000, 4000),
+                ::testing::Values(
+                    make_tuple<string, string, LoadMode>
+                    (
+                        string("gpu/opticalflow/rubberwhale1.png"),
+                        string("gpu/opticalflow/rubberwhale2.png"),
+                        LoadMode(IMREAD_COLOR)
+                        )
+                    , make_tuple<string, string, LoadMode>
+                    (
+                        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<string, string, LoadMode> fileParam = get<1>(params);
+    const int pointsCount = get<0>(params);
+    const int openMode = static_cast<int>(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<Point2f> pts, nextPts;
+    vector<unsigned char> status;
+    vector<float> 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)
+        SANITY_CHECK(nextPts);
-        {
+        SANITY_CHECK(status);
-            cvtColor(frame0, gray_frame, COLOR_BGR2GRAY);
+        SANITY_CHECK(err);
-        }
+    }
+    else if (RUN_OCL_IMPL)
+    {
+        ocl::PyrLKOpticalFlow oclPyrLK;
+        ocl::oclMat oclFrame0(frame0), oclFrame1(frame1);
+        ocl::oclMat oclPts(1, static_cast<int>(pts.size()), CV_32FC2, (void *)&pts[0]);
+        ocl::oclMat oclNextPts, oclStatus, oclErr;
 
-        for (int points = Min_Size; points <= Max_Size; points *= Multiple)
+        TEST_CYCLE()
-        {
+                oclPyrLK.sparse(oclFrame0, oclFrame1, oclPts, oclNextPts, oclStatus, &oclErr);
-            if (i == 0)
+
-                SUBTEST << frame0.cols << "x" << frame0.rows << "; color; " << points << " points";
+        MatToVector(oclNextPts, nextPts);
-            else
+        MatToVector(oclStatus, status);
-                SUBTEST << frame0.cols << "x" << frame0.rows << "; gray; " << points << " points";
+        MatToVector(oclErr, err);
-            Mat ocl_nextPts;
-            Mat ocl_status;
-
-            vector<Point2f> pts;
-            goodFeaturesToTrack(i == 0 ? gray_frame : frame0, pts, points, 0.01, 0.0);
-
-            vector<Point2f> nextPts;
-            vector<unsigned char> status;
-
-            vector<float> 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<unsigned char>(0, i))
-                {
-                    mismatch++;
-                    continue;
-                }
-                if(status[i])
-                {
-                    Point2f gpu_rst = ocl_nextPts.at<Point2f>(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);
-        }
 
+        SANITY_CHECK(nextPts);
+        SANITY_CHECK(status);
+        SANITY_CHECK(err);
     }
+    else
+        OCL_PERF_ELSE
 }
 
-
+PERF_TEST(tvl1flowFixture, tvl1flow)
-PERFTEST(tvl1flow)
 {
-    cv::Mat frame0 = imread("rubberwhale1.png", cv::IMREAD_GRAYSCALE);
+    Mat frame0 = imread(getDataPath("gpu/opticalflow/rubberwhale1.png"), cv::IMREAD_GRAYSCALE);
-    assert(!frame0.empty());
+    ASSERT_FALSE(frame0.empty()) << "can't load rubberwhale1.png";
 
-    cv::Mat frame1 = imread("rubberwhale2.png", cv::IMREAD_GRAYSCALE);
+    Mat frame1 = imread(getDataPath("gpu/opticalflow/rubberwhale2.png"), cv::IMREAD_GRAYSCALE);
-    assert(!frame1.empty());
+    ASSERT_FALSE(frame1.empty()) << "can't load rubberwhale2.png";
 
-    cv::ocl::OpticalFlowDual_TVL1_OCL d_alg;
+    const Size srcSize = frame0.size();
-    cv::ocl::oclMat d_flowx(frame0.size(), CV_32FC1);
+    const double eps = 1.2;
-    cv::ocl::oclMat d_flowy(frame1.size(), CV_32FC1);
+    Mat flow(srcSize, CV_32FC2), flow1(srcSize, CV_32FC1), flow2(srcSize, CV_32FC1);
+    declare.in(frame0, frame1).out(flow1, flow2).time(159);
 
-    cv::Ptr<cv::DenseOpticalFlow> alg = cv::createOptFlow_DualTVL1();
+    if (RUN_PLAIN_IMPL)
-    cv::Mat flow;
+    {
+        Ptr<DenseOpticalFlow> alg = createOptFlow_DualTVL1();
 
+        TEST_CYCLE() alg->calc(frame0, frame1, flow);
 
-    SUBTEST << frame0.cols << 'x' << frame0.rows << "; rubberwhale1.png; "<<frame1.cols<<'x'<<frame1.rows<<"; rubberwhale2.png";
+        alg->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;
+        TEST_CYCLE() oclAlg(oclFrame0, oclFrame1, oclFlow1, oclFlow2);
-    alg->calc(frame0, frame1, flow);
-    CPU_OFF;
 
-    cv::Mat gold[2];
+        oclAlg.collectGarbage();
-    cv::split(flow, gold);
 
-    cv::ocl::oclMat d0(frame0.size(), CV_32FC1);
+        oclFlow1.download(flow1);
-    d0.upload(frame0);
+        oclFlow2.download(flow2);
-    cv::ocl::oclMat d1(frame1.size(), CV_32FC1);
-    d1.upload(frame1);
 
-    WARMUP_ON;
+        SANITY_CHECK(flow1, eps);
-    d_alg(d0, d1, d_flowx, d_flowy);
+        SANITY_CHECK(flow2, eps);
-    WARMUP_OFF;
+    }
-    /*
+    else
-        double diff1 = 0.0, diff2 = 0.0;
+        OCL_PERF_ELSE
-        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);
 
-        TestSystem::instance().setDiff(diff1);
+///////////// FarnebackOpticalFlow ////////////////////////
-        TestSystem::instance().setDiff(diff2);
-    */
 
+CV_ENUM(farneFlagType, 0, OPTFLOW_FARNEBACK_GAUSSIAN)
 
-    GPU_ON;
+typedef tuple<tuple<int, double>, farneFlagType, bool> FarnebackOpticalFlowParams;
-    d_alg(d0, d1, d_flowx, d_flowy);
+typedef TestBaseWithParam<FarnebackOpticalFlowParams> FarnebackOpticalFlowFixture;
-    d_alg.collectGarbage();
-    GPU_OFF;
 
+PERF_TEST_P(FarnebackOpticalFlowFixture, FarnebackOpticalFlow,
+            ::testing::Combine(
+                ::testing::Values(make_tuple<int, double>(5, 1.1),
+                                  make_tuple<int, double>(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;
+    const Size srcSize = frame0.size();
-    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;
 
-    TestSystem::instance().ExceptedMatSimilar(gold[0], flowx, 3e-3);
+    const FarnebackOpticalFlowParams params = GetParam();
-    TestSystem::instance().ExceptedMatSimilar(gold[1], flowy, 3e-3);
+    const tuple<int, double> 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 ////////////////////////
+    Mat flowx(srcSize, CV_32FC1), flowy(srcSize, CV_32FC1), flow(srcSize, CV_32FC2);
-PERFTEST(FarnebackOpticalFlow)
+    declare.in(frame0, frame1).out(flowx, flowy);
-{
-    cv::Mat frame0 = imread("rubberwhale1.png", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(frame0.empty());
 
-    cv::Mat frame1 = imread("rubberwhale2.png", cv::IMREAD_GRAYSCALE);
+    ocl::FarnebackOpticalFlow farn;
-    ASSERT_FALSE(frame1.empty());
+    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 };
+        TEST_CYCLE()
-    double polySigmas[2] = { 1.1, 1.5 };
+                calcOpticalFlowFarneback(
-    int farneFlags[2] = { 0, cv::OPTFLOW_FARNEBACK_GAUSSIAN };
+                    frame0, frame1, flow, farn.pyrScale, farn.numLevels, farn.winSize,
-    bool UseInitFlows[2] = { false, true };
+                    farn.numIters, farn.polyN, farn.polySigma, farn.flags);
-    double pyrScale = 0.5;
 
-    string farneFlagStrs[2] = { "BoxFilter", "GaussianBlur" };
+        Mat flowxy[2] = { flowx, flowy };
-    string useInitFlowStrs[2] = { "", "UseInitFlow" };
+        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];
+        ocl::oclMat oclFrame0(frame0), oclFrame1(frame1),
-        double polySigma = polySigmas[i];
+                oclFlowx(srcSize, CV_32FC1), oclFlowy(srcSize, CV_32FC1);
 
-        for ( int j = 0; j < 2; ++j)
+        if (useInitFlow)
         {
-            int flags = farneFlags[j];
+            farn(oclFrame0, oclFrame1, oclFlowx, oclFlowy);
-
+            farn.flags |= OPTFLOW_USE_INITIAL_FLOW;
-            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<cv::Mat> flowxy;
-                cv::split(flow, flowxy);
 
-                Mat md_flowx = cv::Mat(d_flowx);
+        TEST_CYCLE()
-                Mat md_flowy = cv::Mat(d_flowy);
+                farn(oclFrame0, oclFrame1, oclFlowx, oclFlowy);
-                TestSystem::instance().ExceptedMatSimilar(flowxy[0], md_flowx, 0.1);
-                TestSystem::instance().ExceptedMatSimilar(flowxy[1], md_flowy, 0.1);
 
-                if (useInitFlow)
+        oclFlowx.download(flowx);
-                {
+        oclFlowy.download(flowy);
-                    cv::Mat flowx, flowy;
-                    farn.flags = (flags | cv::OPTFLOW_USE_INITIAL_FLOW);
 
-                    CPU_ON;
+        SANITY_CHECK(flowx, eps);
-                    cv::calcOpticalFlowFarneback(
+        SANITY_CHECK(flowy, eps);
-                        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;
-                }
-            }
-        }
     }
+    else
+        OCL_PERF_ELSE
 }

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 <windows.h>
-#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<Runnable *>::iterator it = tests_.begin(); it != tests_.end(); ++it)
-        {
-            cout << (*it)->name() << endl;
-        }
-
-        return;
-    }
-
-    // Run test initializers
-    for (vector<Runnable *>::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<Runnable *>::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<double>(cpu_elapsed_) / std::max(1.0, gpu_elapsed_);
-    speedup_total_ += speedup;
-
-    double fullspeedup = static_cast<double>(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<int64>(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<int64> &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<<TAB<<setw(7)<< "Accu." << setw(10) << "CPU (ms)" << setw(10) << "GPU, ms"
-        << setw(8) << "Speedup"<< setw(10)<<"GPUTotal" << setw(10) << "Total"
-        << "Description\n";
-    cout<<TAB<<setw(7)<<""<<setw(10)<<""<<setw(10)<<""<<setw(8)<<""<<setw(10)<<"(ms)"<<setw(10)<<"Speedup\n";
-#endif
-
-    cout<<TAB<< setw(10) << "CPU (ms)" << setw(10) << "GPU, ms"
-        << setw(8) << "Speedup"<< setw(10)<<"GPUTotal" << setw(10) << "Total"
-        << "Description\n";
-    cout<<TAB<<setw(10)<<""<<setw(10)<<""<<setw(8)<<""<<setw(10)<<"(ms)"<<setw(10)<<"Speedup\n";
-
-    cout << resetiosflags(ios_base::left);
-}
-
-void TestSystem::writeHeading()
-{
-    if (!record_)
-    {
-        recordname_ += "_OCL.csv";
-        record_ = fopen(recordname_.c_str(), "w");
-        if(record_ == NULL)
-        {
-            cout<<".csv file open failed.\n";
-            exit(0);
-        }
-    }
-
-    fprintf(record_, "NAME,DESCRIPTION,ACCURACY,DIFFERENCE,CPU (ms),GPU (ms),SPEEDUP,GPUTOTAL (ms),TOTALSPEEDUP,GPU Min (ms),GPU Max (ms), Standard deviation (ms)\n");
-
-    fflush(record_);
-}
-
-void TestSystem::printSummary()
-{
-    cout << setiosflags(ios_base::fixed);
-    cout << "\naverage GPU speedup: x"
-        << setprecision(3) << speedup_total_ / std::max(1, num_subtests_called_)
-        << endl;
-    cout << "\nGPU exceeded: "
-        << setprecision(3) << speedup_faster_count_
-        << "\nGPU passed: "
-        << setprecision(3) << speedup_equal_count_
-        << "\nGPU failed: "
-        << setprecision(3) << speedup_slower_count_
-        << endl;
-    cout << "\nGPU exceeded rate: "
-        << setprecision(3) << (float)speedup_faster_count_ / std::max(1, num_subtests_called_) * 100
-        << "%"
-        << "\nGPU passed rate: "
-        << setprecision(3) << (float)speedup_equal_count_ / std::max(1, num_subtests_called_) * 100
-        << "%"
-        << "\nGPU failed rate: "
-        << setprecision(3) << (float)speedup_slower_count_ / std::max(1, num_subtests_called_) * 100
-        << "%"
-        << endl;
-    cout << "\naverage GPUTOTAL speedup: x"
-        << setprecision(3) << speedup_full_total_ / std::max(1, num_subtests_called_)
-        << endl;
-    cout << "\nGPUTOTAL exceeded: "
-        << setprecision(3) << speedup_full_faster_count_
-        << "\nGPUTOTAL passed: "
-        << setprecision(3) << speedup_full_equal_count_
-        << "\nGPUTOTAL failed: "
-        << setprecision(3) << speedup_full_slower_count_
-        << endl;
-    cout << "\nGPUTOTAL exceeded rate: "
-        << setprecision(3) << (float)speedup_full_faster_count_ / std::max(1, num_subtests_called_) * 100
-        << "%"
-        << "\nGPUTOTAL passed rate: "
-        << setprecision(3) << (float)speedup_full_equal_count_ / std::max(1, num_subtests_called_) * 100
-        << "%"
-        << "\nGPUTOTAL failed rate: "
-        << setprecision(3) << (float)speedup_full_slower_count_ / std::max(1, num_subtests_called_) * 100
-        << "%"
-        << endl;
-    cout << resetiosflags(ios_base::fixed);
-}
-
-
-enum GTestColor {
-    COLOR_DEFAULT,
-    COLOR_RED,
-    COLOR_GREEN,
-    COLOR_YELLOW
-};
-#if GTEST_OS_WINDOWS&&!GTEST_OS_WINDOWS_MOBILE
-// Returns the character attribute for the given color.
-static WORD GetColorAttribute(GTestColor color) {
-    switch (color) {
-    case COLOR_RED:    return FOREGROUND_RED;
-    case COLOR_GREEN:  return FOREGROUND_GREEN;
-    case COLOR_YELLOW: return FOREGROUND_RED | FOREGROUND_GREEN;
-    default:           return 0;
-    }
-}
-#else
-static const char* GetAnsiColorCode(GTestColor color) {
-    switch (color) {
-    case COLOR_RED:     return "1";
-    case COLOR_GREEN:   return "2";
-    case COLOR_YELLOW:  return "3";
-    default:            return NULL;
-    };
-}
-#endif
-
-static void printMetricsUti(double cpu_time, double gpu_time, double gpu_full_time, double speedup, double fullspeedup, std::stringstream& stream, std::stringstream& cur_subtest_description)
-{
-    //cout <<TAB<< setw(7) << stream.str();
-    cout <<TAB;
-
-    stream.str("");
-    stream << cpu_time;
-    cout << setw(10) << stream.str();
-
-    stream.str("");
-    stream << gpu_time;
-    cout << setw(10) << stream.str();
-
-    stream.str("");
-    stream << "x" << setprecision(3) << speedup;
-    cout << setw(8) << stream.str();
-
-    stream.str("");
-    stream << gpu_full_time;
-    cout << setw(10) << stream.str();
-
-    stream.str("");
-    stream << "x" << setprecision(3) << fullspeedup;
-    cout << setw(10) << stream.str();
-
-    cout << cur_subtest_description.str();
-    cout << resetiosflags(ios_base::left) << endl;
-}
-
-void TestSystem::printMetrics(int is_accurate, double cpu_time, double gpu_time, double gpu_full_time, double speedup, double fullspeedup)
-{
-    cout << setiosflags(ios_base::left);
-    stringstream stream;
-
-    std::stringstream &cur_subtest_description = getCurSubtestDescription();
-
-#if GTEST_OS_WINDOWS&&!GTEST_OS_WINDOWS_MOBILE
-
-    WORD color;
-    const HANDLE stdout_handle = GetStdHandle(STD_OUTPUT_HANDLE);
-    // Gets the current text color.
-    CONSOLE_SCREEN_BUFFER_INFO buffer_info;
-    GetConsoleScreenBufferInfo(stdout_handle, &buffer_info);
-    const WORD old_color_attrs = buffer_info.wAttributes;
-    // We need to flush the stream buffers into the console before each
-    // SetConsoleTextAttribute call lest it affect the text that is already
-    // printed but has not yet reached the console.
-    fflush(stdout);
-
-    if(is_accurate == 1||is_accurate == -1)
-    {
-        color = old_color_attrs;
-        printMetricsUti(cpu_time, gpu_time, gpu_full_time, speedup, fullspeedup, stream, cur_subtest_description);
-
-    }else
-    {
-        color = GetColorAttribute(COLOR_RED);
-        SetConsoleTextAttribute(stdout_handle,
-            color| FOREGROUND_INTENSITY);
-
-        printMetricsUti(cpu_time, gpu_time, gpu_full_time, speedup, fullspeedup, stream, cur_subtest_description);
-        fflush(stdout);
-        // Restores the text color.
-        SetConsoleTextAttribute(stdout_handle, old_color_attrs);
-    }
-#else
-    GTestColor color = COLOR_RED;
-    if(is_accurate == 1|| is_accurate == -1)
-    {
-        printMetricsUti(cpu_time, gpu_time, gpu_full_time, speedup, fullspeedup, stream, cur_subtest_description);
-
-    }else
-    {
-        printf("\033[0;3%sm", GetAnsiColorCode(color));
-        printMetricsUti(cpu_time, gpu_time, gpu_full_time, speedup, fullspeedup, stream, cur_subtest_description);
-        printf("\033[m");  // Resets the terminal to default.
-    }
-#endif
-}
-
-void TestSystem::writeMetrics(double cpu_time, double gpu_time, double gpu_full_time, double speedup, double fullspeedup, double gpu_min, double gpu_max, double std_dev)
-{
-    if (!record_)
-    {
-        recordname_ += ".csv";
-        record_ = fopen(recordname_.c_str(), "w");
-    }
-
-    string _is_accurate_;
-
-    if(is_accurate_ == 1)
-        _is_accurate_ = "Pass";
-    else if(is_accurate_ == 0)
-        _is_accurate_ = "Fail";
-    else if(is_accurate_ == -1)
-        _is_accurate_ = " ";
-    else
-    {
-        std::cout<<"is_accurate errer: "<<is_accurate_<<"\n";
-        exit(-1);
-    }
-
-    fprintf(record_, "%s,%s,%s,%.2f,%.3f,%.3f,%.3f,%.3f,%.3f,%.3f,%.3f,%.3f\n",
-        itname_changed_ ? itname_.c_str() : "",
-        cur_subtest_description_.str().c_str(),
-        _is_accurate_.c_str(),
-        accurate_diff_,
-        cpu_time, gpu_time, speedup, gpu_full_time, fullspeedup,
-        gpu_min, gpu_max, std_dev);
-
-    if (itname_changed_)
-    {
-        itname_changed_ = false;
-    }
-
-    fflush(record_);
-}
-
-void TestSystem::writeSummary()
-{
-    if (!record_)
-    {
-        recordname_ += ".csv";
-        record_ = fopen(recordname_.c_str(), "w");
-    }
-
-    fprintf(record_, "\nAverage GPU speedup: %.3f\n"
-        "exceeded: %d (%.3f%%)\n"
-        "passed: %d (%.3f%%)\n"
-        "failed: %d (%.3f%%)\n"
-        "\nAverage GPUTOTAL speedup: %.3f\n"
-        "exceeded: %d (%.3f%%)\n"
-        "passed: %d (%.3f%%)\n"
-        "failed: %d (%.3f%%)\n",
-        speedup_total_ / std::max(1, num_subtests_called_),
-        speedup_faster_count_, (float)speedup_faster_count_ / std::max(1, num_subtests_called_) * 100,
-        speedup_equal_count_, (float)speedup_equal_count_ / std::max(1, num_subtests_called_) * 100,
-        speedup_slower_count_, (float)speedup_slower_count_ / std::max(1, num_subtests_called_) * 100,
-        speedup_full_total_ / std::max(1, num_subtests_called_),
-        speedup_full_faster_count_, (float)speedup_full_faster_count_ / std::max(1, num_subtests_called_) * 100,
-        speedup_full_equal_count_, (float)speedup_full_equal_count_ / std::max(1, num_subtests_called_) * 100,
-        speedup_full_slower_count_, (float)speedup_full_slower_count_ / std::max(1, num_subtests_called_) * 100
-        );
-    fflush(record_);
-}
-
-void TestSystem::printError(const std::string &msg)
-{
-    if(msg != "CL_INVALID_BUFFER_SIZE")
-    {
-        cout << TAB << "[error: " << msg << "] " << cur_subtest_description_.str() << endl;
-    }
-}
-
-void gen(Mat &mat, int rows, int cols, int type, Scalar low, Scalar high)
-{
-    mat.create(rows, cols, type);
-    RNG rng(0);
-    rng.fill(mat, RNG::UNIFORM, low, high);
-}
-
-string abspath(const string &relpath)
-{
-    return TestSystem::instance().workingDir() + relpath;
-}
-
-
-int CV_CDECL cvErrorCallback(int /*status*/, const char * /*func_name*/,
-    const char *err_msg, const char * /*file_name*/,
-    int /*line*/, void * /*userdata*/)
-{
-    TestSystem::instance().printError(err_msg);
-    return 0;
-}
-
-double checkNorm(const Mat &m)
-{
-    return norm(m, NORM_INF);
-}
-
-double checkNorm(const Mat &m1, const Mat &m2)
-{
-    return norm(m1, m2, NORM_INF);
-}
-
-double checkSimilarity(const Mat &m1, const Mat &m2)
-{
-    Mat diff;
-    matchTemplate(m1, m2, diff, CV_TM_CCORR_NORMED);
-    return std::abs(diff.at<float>(0, 0) - 1.f);
-}

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 <cstdio>
 #include <vector>
 #include <numeric>
+
 #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);
+#define OCL_SIZE_1000 Size(1000, 1000)
-void gen(Mat &mat, int rows, int cols, int type, int low, int high, int n);
+#define OCL_SIZE_2000 Size(2000, 2000)
-
+#define OCL_SIZE_4000 Size(4000, 4000)
-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<class T1, class T2>
-int ExpectedEQ(T1 expected, T2 actual)
-{
-    if(expected == actual)
-        return 1;
-
-    return 0;
-}
-
-template<class T1>
-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<class T>
-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;
-    }
 
-    void cpuOn()
+#define OCL_TYPICAL_MAT_SIZES ::testing::Values(OCL_SIZE_1000, OCL_SIZE_2000, OCL_SIZE_4000)
-    {
-        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;
-    }
 
-    void gpuOn()
+#define OCL_PERF_ENUM(type, ...) ::testing::Values(type, ## __VA_ARGS__ )
-    {
-        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;
-    }
 
-    void gpufullOn()
+#define IMPL_OCL "ocl"
-    {
+#define IMPL_GPU "gpu"
-        gpu_full_started_ = cv::getTickCount();
+#define IMPL_PLAIN "plain"
-    }
-    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;
-    }
 
-    bool isListMode() const
+#define RUN_OCL_IMPL (IMPL_OCL == getSelectedImpl())
-    {
+#define RUN_PLAIN_IMPL (IMPL_PLAIN == getSelectedImpl())
-        return is_list_mode_;
-    }
-    void setListMode(bool value)
-    {
-        is_list_mode_ = value;
-    }
 
-    void setRecordName(const std::string &name)
+#ifdef HAVE_OPENCV_GPU
-    {
+# define RUN_GPU_IMPL (IMPL_GPU == getSelectedImpl())
-        recordname_ = name;
+#endif
-    }
-
-    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<Mat>& dst, vector<Mat>& cpu_dst, vector<double>& eps)
-    {
-        assert(dst.size() == cpu_dst.size());
-        assert(cpu_dst.size() == eps.size());
-        is_accurate_ = 1;
-        for(size_t i=0; i<dst.size(); i++)
-        {
-            double cur_diff = checkNorm(dst[i], cpu_dst[i]);
-            accurate_diff_ = max(accurate_diff_, cur_diff);
-            if(cur_diff > 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<int64> &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<Runnable *> inits_;
-    std::vector<Runnable *> 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<int64> cpu_times_;
-    std::vector<int64> gpu_times_;
-    std::vector<int64> 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()
 
-#define WARMUP_ON \
+#ifdef HAVE_OPENCV_GPU
-    while (!TestSystem::instance().warmupStop()) {
+#define OCL_PERF_ELSE               \
-#define WARMUP_OFF \
+        if (RUN_GPU_IMPL)          \
-    ocl::finish();\
+            CV_TEST_FAIL_NO_IMPL(); \
-    } TestSystem::instance().warmupComplete()
+        else                        \
+            CV_TEST_FAIL_NO_IMPL();
+#else
+#define OCL_PERF_ELSE               \
+            CV_TEST_FAIL_NO_IMPL();
+#endif
 
 #endif

modules/ocl/perf/perf_pyramid.cpp

@@ -45,88 +45,80 @@
 //M*/
 #include "perf_precomp.hpp"
 
-///////////// pyrDown //////////////////////
+using namespace perf;
-PERFTEST(pyrDown)
+using std::tr1::tuple;
-{
+using std::tr1::get;
-    Mat src, dst, ocl_dst;
-    int all_type[] = {CV_8UC1, CV_8UC4};
-    std::string type_name[] = {"CV_8UC1", "CV_8UC4"};
 
-    for (int size = Min_Size; size <= Max_Size; size *= Multiple)
+///////////// pyrDown //////////////////////
-    {
-        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 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;
+    Mat src(srcSize, type), dst;
-            pyrDown(src, dst);
+    Size dstSize((srcSize.height + 1) >> 1, (srcSize.width + 1) >> 1);
-            CPU_OFF;
+    dst.create(dstSize, type);
+    declare.in(src, WARMUP_RNG).out(dst);
 
-            ocl::oclMat d_src(src);
+    if (RUN_OCL_IMPL)
-            ocl::oclMat d_dst;
+    {
+        ocl::oclMat oclSrc(src), oclDst(dstSize, type);
 
-            WARMUP_ON;
+        TEST_CYCLE() ocl::pyrDown(oclSrc, oclDst);
-            ocl::pyrDown(d_src, d_dst);
-            WARMUP_OFF;
 
-            GPU_ON;
+        oclDst.download(dst);
-            ocl::pyrDown(d_src, d_dst);
-            GPU_OFF;
 
-            GPU_FULL_ON;
+        SANITY_CHECK(dst);
-            d_src.upload(src);
+    }
-            ocl::pyrDown(d_src, d_dst);
+    else if (RUN_PLAIN_IMPL)
-            d_dst.download(ocl_dst);
+    {
-            GPU_FULL_OFF;
+        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;
+    Mat src(srcSize, type), dst;
-            pyrUp(src, dst);
+    Size dstSize(srcSize.height << 1, srcSize.width << 1);
-            CPU_OFF;
+    dst.create(dstSize, type);
+    declare.in(src, WARMUP_RNG).out(dst);
 
-            ocl::oclMat d_src(src);
+    if (RUN_OCL_IMPL)
-            ocl::oclMat d_dst;
+    {
+        ocl::oclMat oclSrc(src), oclDst(dstSize, type);
 
-            WARMUP_ON;
+        TEST_CYCLE() ocl::pyrDown(oclSrc, oclDst);
-            ocl::pyrUp(d_src, d_dst);
-            WARMUP_OFF;
 
-            GPU_ON;
+        oclDst.download(dst);
-            ocl::pyrUp(d_src, d_dst);
-            GPU_OFF;
 
-            GPU_FULL_ON;
+        SANITY_CHECK(dst);
-            d_src.upload(src);
+    }
-            ocl::pyrUp(d_src, d_dst);
+    else if (RUN_PLAIN_IMPL)
-            d_dst.download(ocl_dst);
+    {
-            GPU_FULL_OFF;
+        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
 }

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;
+typedef Size_MatType MergeFixture;
-    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)
+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<Mat> src(channels);
+    for (vector<Mat>::iterator i = src.begin(), end = src.end(); i != end; ++i)
     {
-        for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
+        i->create(srcSize, CV_MAKE_TYPE(depth, 1));
-        {
+        declare.in(*i, WARMUP_RNG);
-            SUBTEST << size << 'x' << size << "; " << type_name[j] ;
-            Size size1 = Size(size, size);
-            std::vector<Mat> 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<ocl::oclMat> 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);
-        }
-
     }
-}
+    declare.out(dst);
 
-///////////// Split////////////////////////
+    if (RUN_OCL_IMPL)
-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)
     {
-        for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
+        ocl::oclMat oclDst(srcSize, dstType);
-        {
+        vector<ocl::oclMat> oclSrc(src.size());
-            SUBTEST << size << 'x' << size << "; " << type_name[j];
+        for (vector<ocl::oclMat>::size_type i = 0, end = src.size(); i < end; ++i)
-            Size size1 = Size(size, size);
+            oclSrc[i] = src[i];
-
-            Mat src(size1, CV_MAKE_TYPE(all_type[j], 4), cv::Scalar(1, 2, 3, 4));
 
-            std::vector<cv::Mat> dst, ocl_dst(4);
+        TEST_CYCLE() cv::ocl::merge(oclSrc, oclDst);
 
-            split(src, dst);
+        oclDst.download(dst);
 
-            CPU_ON;
+        SANITY_CHECK(dst);
-            split(src, dst);
+    }
-            CPU_OFF;
+    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));
+        SANITY_CHECK(dst);
-            std::vector<cv::ocl::oclMat> d_dst;
+    }
+    else
+        OCL_PERF_ELSE
+}
 
-            WARMUP_ON;
+///////////// Split////////////////////////
-            ocl::split(d_src, d_dst);
-            WARMUP_OFF;
 
-            GPU_ON;
+typedef Size_MatType SplitFixture;
-            ocl::split(d_src, d_dst);
-            GPU_OFF;
 
-            GPU_FULL_ON;
+PERF_TEST_P(SplitFixture, Split,
-            d_src.upload(src);
+            ::testing::Combine(OCL_TYPICAL_MAT_SIZES,
-            ocl::split(d_src, d_dst);
+                               OCL_PERF_ENUM(CV_8U, CV_32F)))
-            for(size_t i = 0; i < dst.size(); i++)
+{
-                d_dst[i].download(ocl_dst[i]);
+    const Size_MatType_t params = GetParam();
-            GPU_FULL_OFF;
+    const Size srcSize = get<0>(params);
+    const int depth = get<1>(params), channels = 3;
 
-            vector<double> eps(4, 0.);
+    Mat src(srcSize, CV_MAKE_TYPE(depth, channels));
-            TestSystem::instance().ExpectMatsNear(dst, ocl_dst, eps);
+    declare.in(src, WARMUP_RNG);
-        }
 
+    if (RUN_OCL_IMPL)
+    {
+        ocl::oclMat oclSrc(src);
+        vector<ocl::oclMat> 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<Mat> 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
 }

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";
 

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<cv::Size> 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)));