most of the performance tests was rewritten in google-test manner

modules/ocl/perf/main.cpp

@@ -42,7 +42,7 @@
 
 #include "perf_precomp.hpp"
 
-int main(int argc, const char *argv[])
+static int old_main(int argc, const char *argv[])
 {
     const char *keys =
         "{ h | help    | false | print help message }"
@@ -99,7 +99,7 @@ int main(int argc, const char *argv[])
 
     // set this to overwrite binary cache every time the test starts
     ocl::setBinaryDiskCache(ocl::CACHE_UPDATE);
-
+    
     if (cmd.get<bool>("verify"))
     {
         TestSystem::instance().setNumIters(1);
@@ -162,3 +162,33 @@ END_DEV:
 
     return 0;
 }
+
+const char * impls[] =
+{
+    "ocl",
+    "plain",
+#ifdef HAVE_OPENCV_GPU
+    "gpu"
+#endif
+};
+
+int main(int argc, char **argv)
+{
+    // temp solution: if no '--gtest_' and '--perf_' args switch to old behavior
+    bool useGTest = false;
+
+    for(int i=1; i<argc; i++)
+    {
+        std::string arg( argv[i] );
+        if( arg.find("--gtest_")==0 || arg.find("--perf_")==0 )
+            useGTest = true;
+
+//        if (arg == "--perf_verify_sanity")
+//            argv[i] = (char*)"--perf_no_verify_sanity";
+    }
+
+    if( !useGTest )
+        return old_main(argc, (const char**)argv);
+
+    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,54 @@ void blendLinearGold(const cv::Mat &img1, const cv::Mat &img2, const cv::Mat &we
 
         for (int x = 0; x < img1.cols * cn; ++x)
         {
-            float w1 = weights1_row[x / cn];
-            float w2 = weights2_row[x / cn];
-            result_gold_row[x] = static_cast<T>((img1_row[x] * w1 + img2_row[x] * w2) / (w1 + w2 + 1e-5f));
+            int x1 = x * cn;
+            float w1 = weights1_row[x];
+            float w2 = weights2_row[x];
+            result_gold_row[x] = static_cast<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;
-    ocl::oclMat d_src1, d_src2, d_weights1, d_weights2, d_dst;
+    // getting params
+    const Size srcSize = GetParam();
+    const int type = CV_8UC1;
+    const std::string impl = getSelectedImpl();
+
+    // creating src data
+    Mat src1(srcSize, type), src2(srcSize, CV_8UC1), dst;
+    Mat weights1(srcSize, CV_32FC1), weights2(srcSize, CV_32FC1);
 
-    int all_type[] = {CV_8UC1, CV_8UC4};
-    std::string type_name[] = {"CV_8UC1", "CV_8UC4"};
+    declare.in(src1, src2, WARMUP_RNG);
+    randu(weights1, 0.0f, 1.0f);
+    randu(weights2, 0.0f, 1.0f);
 
-    for (int size = Min_Size; size <= Max_Size; size *= Multiple)
+    // select implementation
+    if (impl == "ocl")
     {
-        for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
-        {
-            SUBTEST << size << 'x' << size << "; " << type_name[j] << " and CV_32FC1";
-
-            gen(src1, size, size, all_type[j], 0, 256);
-            gen(src2, size, size, all_type[j], 0, 256);
-            gen(weights1, size, size, CV_32FC1, 0, 1);
-            gen(weights2, size, size, CV_32FC1, 0, 1);
-
-            blendLinearGold<uchar>(src1, src2, weights1, weights2, dst);
-
-            CPU_ON;
-            blendLinearGold<uchar>(src1, src2, weights1, weights2, dst);
-            CPU_OFF;
-
-            d_src1.upload(src1);
-            d_src2.upload(src2);
-            d_weights1.upload(weights1);
-            d_weights2.upload(weights2);
-
-            WARMUP_ON;
-            ocl::blendLinear(d_src1, d_src2, d_weights1, d_weights2, d_dst);
-            WARMUP_OFF;
-
-            GPU_ON;
-            ocl::blendLinear(d_src1, d_src2, d_weights1, d_weights2, d_dst);
-            GPU_OFF;
-
-            GPU_FULL_ON;
-            d_src1.upload(src1);
-            d_src2.upload(src2);
-            d_weights1.upload(weights1);
-            d_weights2.upload(weights2);
-            ocl::blendLinear(d_src1, d_src2, d_weights1, d_weights2, d_dst);
-            d_dst.download(ocl_dst);
-            GPU_FULL_OFF;
-
-            TestSystem::instance().ExpectedMatNear(dst, ocl_dst, 1.f);
-        }
+        ocl::oclMat oclSrc1(src1), oclSrc2(src2), oclDst;
+        ocl::oclMat oclWeights1(weights1), oclWeights2(weights2);
+
+        TEST_CYCLE() cv::ocl::blendLinear(oclSrc1, oclSrc2, oclWeights1, oclWeights2, oclDst);
+
+        oclDst.download(dst);
+
+        SANITY_CHECK(dst);
+    }
+    else if (impl == "plain")
+    {
+        TEST_CYCLE() blendLinearGold<uchar>(src1, src2, weights1, weights2, dst);
+
+        SANITY_CHECK(dst);
     }
+#ifdef HAVE_OPENCV_GPU
+    else if (impl == "gpu")
+        CV_TEST_FAIL_NO_IMPL();
+#endif
+    else
+        CV_TEST_FAIL_NO_IMPL();
 }

modules/ocl/perf/perf_calib3d.cpp

@@ -45,48 +45,49 @@
 //M*/
 
 #include "perf_precomp.hpp"
+
 ///////////// StereoMatchBM ////////////////////////
-PERFTEST(StereoMatchBM)
-{
-    Mat left_image = imread(abspath("aloeL.jpg"), cv::IMREAD_GRAYSCALE);
-    Mat right_image = imread(abspath("aloeR.jpg"), cv::IMREAD_GRAYSCALE);
-    Mat disp,dst;
-    ocl::oclMat d_left, d_right,d_disp;
-    int n_disp= 128;
-    int winSize =19;
 
-    SUBTEST << left_image.cols << 'x' << left_image.rows << "; aloeL.jpg ;"<< right_image.cols << 'x' << right_image.rows << "; aloeR.jpg ";
+PERF_TEST(StereoMatchBMFixture, DISABLED_StereoMatchBM)
+{
+    Mat left_image = imread(getDataPath("gpu/stereobm/aloe-L.png"), cv::IMREAD_GRAYSCALE);
+    Mat right_image = imread(getDataPath("gpu/stereobm/aloe-R.png"), cv::IMREAD_GRAYSCALE);
 
-    StereoBM bm(0, n_disp, winSize);
-    bm(left_image, right_image, dst);
+    ASSERT_TRUE(!left_image.empty()) << "no input image";
+    ASSERT_TRUE(!right_image.empty()) << "no input image";
+    ASSERT_TRUE(right_image.size() == left_image.size());
+    ASSERT_TRUE(right_image.size() == left_image.size());
 
-    CPU_ON;
-    bm(left_image, right_image, dst);
-    CPU_OFF;
+    const std::string impl = getSelectedImpl();
+    const int n_disp = 128, winSize = 19;
+    Mat disp(left_image.size(), CV_16SC1);
 
-    d_left.upload(left_image);
-    d_right.upload(right_image);
+    declare.in(left_image, right_image).out(disp);
 
-    ocl::StereoBM_OCL d_bm(0, n_disp, winSize);
+    if (impl == "ocl")
+    {
+        ocl::oclMat oclLeft(left_image), oclRight(right_image),
+                oclDisp(left_image.size(), CV_16SC1);
+        ocl::StereoBM_OCL oclBM(0, n_disp, winSize);
 
-    WARMUP_ON;
-    d_bm(d_left, d_right, d_disp);
-    WARMUP_OFF;
+        TEST_CYCLE() oclBM(oclLeft, oclRight, oclDisp);
 
-    cv::Mat ocl_mat;
-    d_disp.download(ocl_mat);
-    ocl_mat.convertTo(ocl_mat, dst.type());
+        oclDisp.download(disp);
 
-    GPU_ON;
-    d_bm(d_left, d_right, d_disp);
-    GPU_OFF;
+        SANITY_CHECK(disp);
+    }
+    else if (impl == "plain")
+    {
+        StereoBM bm(0, n_disp, winSize);
 
-    GPU_FULL_ON;
-    d_left.upload(left_image);
-    d_right.upload(right_image);
-    d_bm(d_left, d_right, d_disp);
-    d_disp.download(disp);
-    GPU_FULL_OFF;
+        TEST_CYCLE() bm(left_image, right_image, disp);
 
-    TestSystem::instance().setAccurate(-1, 0.);
+        SANITY_CHECK(disp);
+    }
+#ifdef HAVE_OPENCV_GPU
+        else if (impl == "gpu")
+            CV_TEST_FAIL_NO_IMPL();
+    #endif
+        else
+            CV_TEST_FAIL_NO_IMPL();
 }

modules/ocl/perf/perf_canny.cpp

@@ -45,41 +45,38 @@
 //M*/
 #include "perf_precomp.hpp"
 
-///////////// Canny ////////////////////////
-PERFTEST(Canny)
-{
-    Mat img = imread(abspath("aloeL.jpg"), CV_LOAD_IMAGE_GRAYSCALE);
-
-    if (img.empty())
-    {
-        throw runtime_error("can't open aloeL.jpg");
-    }
-
-    SUBTEST << img.cols << 'x' << img.rows << "; aloeL.jpg" << "; edges" << "; CV_8UC1";
+using namespace perf;
 
-    Mat edges(img.size(), CV_8UC1), ocl_edges;
+///////////// Canny ////////////////////////
 
-    CPU_ON;
-    Canny(img, edges, 50.0, 100.0);
-    CPU_OFF;
+PERF_TEST(CannyFixture, Canny)
+{
+    Mat img = imread(getDataPath("gpu/stereobm/aloe-L.png"), cv::IMREAD_GRAYSCALE),
+            edges(img.size(), CV_8UC1);
+    ASSERT_TRUE(!img.empty()) << "can't open aloeL.jpg";
 
-    ocl::oclMat d_img(img);
-    ocl::oclMat d_edges;
-    ocl::CannyBuf d_buf;
+    const std::string impl = getSelectedImpl();
+    declare.in(img).out(edges);
 
-    WARMUP_ON;
-    ocl::Canny(d_img, d_buf, d_edges, 50.0, 100.0);
-    WARMUP_OFF;
+    if (impl == "ocl")
+    {
+        ocl::oclMat oclImg(img), oclEdges(img.size(), CV_8UC1);
 
-    GPU_ON;
-    ocl::Canny(d_img, d_buf, d_edges, 50.0, 100.0);
-    GPU_OFF;
+        TEST_CYCLE() Canny(oclImg, oclEdges, 50.0, 100.0);
+        oclEdges.download(edges);
 
-    GPU_FULL_ON;
-    d_img.upload(img);
-    ocl::Canny(d_img, d_buf, d_edges, 50.0, 100.0);
-    d_edges.download(ocl_edges);
-    GPU_FULL_OFF;
+        SANITY_CHECK(edges);
+    }
+    else if (impl == "plain")
+    {
+        TEST_CYCLE() Canny(img, edges, 50.0, 100.0);
 
-    TestSystem::instance().ExceptedMatSimilar(edges, ocl_edges, 2e-2);
+        SANITY_CHECK(edges);
+    }
+#ifdef HAVE_OPENCV_GPU
+    else if (impl == "gpu")
+        CV_TEST_FAIL_NO_IMPL();
+#endif
+    else
+        CV_TEST_FAIL_NO_IMPL();
 }

modules/ocl/perf/perf_color.cpp

@@ -45,49 +45,39 @@
 //M*/
 #include "perf_precomp.hpp"
 
-///////////// cvtColor////////////////////////
-PERFTEST(cvtColor)
-{
-    Mat src, dst, ocl_dst;
-    ocl::oclMat d_src, d_dst;
-
-    int all_type[] = {CV_8UC4};
-    std::string type_name[] = {"CV_8UC4"};
-
-    for (int size = Min_Size; size <= Max_Size; size *= Multiple)
-    {
-        for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
-        {
-            gen(src, size, size, all_type[j], 0, 256);
-            SUBTEST << size << "x" << size << "; " << type_name[j] << " ; CV_RGBA2GRAY";
-
-            cvtColor(src, dst, CV_RGBA2GRAY, 4);
-
-            CPU_ON;
-            cvtColor(src, dst, CV_RGBA2GRAY, 4);
-            CPU_OFF;
+using namespace perf;
 
-            d_src.upload(src);
+///////////// cvtColor////////////////////////
 
-            WARMUP_ON;
-            ocl::cvtColor(d_src, d_dst, CV_RGBA2GRAY, 4);
-            WARMUP_OFF;
+typedef TestBaseWithParam<Size> cvtColorFixture;
 
-            GPU_ON;
-            ocl::cvtColor(d_src, d_dst, CV_RGBA2GRAY, 4);
-            GPU_OFF;
+PERF_TEST_P(cvtColorFixture, cvtColor, OCL_TYPICAL_MAT_SIZES)
+{
+    const Size srcSize = GetParam();
+    const std::string impl = getSelectedImpl();
 
-            GPU_FULL_ON;
-            d_src.upload(src);
-            ocl::cvtColor(d_src, d_dst, CV_RGBA2GRAY, 4);
-            d_dst.download(ocl_dst);
-            GPU_FULL_OFF;
+    Mat src(srcSize, CV_8UC4), dst(srcSize, CV_8UC4);
+    declare.in(src).out(dst);
 
-            TestSystem::instance().ExceptedMatSimilar(dst, ocl_dst, 1e-5);
-        }
+    if (impl == "ocl")
+    {
+        ocl::oclMat oclSrc(src), oclDst(src.size(), CV_8UC4);
 
+        TEST_CYCLE() ocl::cvtColor(oclSrc, oclDst, CV_RGBA2GRAY, 4);
+        oclDst.download(dst);
 
+        SANITY_CHECK(dst);
     }
+    else if (impl == "plain")
+    {
+        TEST_CYCLE() cv::cvtColor(src, dst, CV_RGBA2GRAY, 4);
 
-
+        SANITY_CHECK(dst);
+    }
+#ifdef HAVE_OPENCV_GPU
+    else if (impl == "gpu")
+        CV_TEST_FAIL_NO_IMPL();
+#endif
+    else
+        CV_TEST_FAIL_NO_IMPL();
 }

modules/ocl/perf/perf_fft.cpp

@@ -45,47 +45,43 @@
 //M*/
 #include "perf_precomp.hpp"
 
-///////////// dft ////////////////////////
-PERFTEST(dft)
-{
-    Mat src, dst, ocl_dst;
-    ocl::oclMat d_src, d_dst;
-
-    int all_type[] = {CV_32FC2};
-    std::string type_name[] = {"CV_32FC2"};
-
-    for (int size = Min_Size; size <= Max_Size; size *= Multiple)
-    {
-        for (size_t j = 0; j < sizeof(all_type) / sizeof(int); j++)
-        {
-            SUBTEST << size << 'x' << size << "; " << type_name[j] << " ; complex-to-complex";
+using namespace perf;
 
-            gen(src, size, size, all_type[j], Scalar::all(0), Scalar::all(1));
+///////////// dft ////////////////////////
 
-            dft(src, dst);
+typedef TestBaseWithParam<Size> dftFixture;
 
-            CPU_ON;
-            dft(src, dst);
-            CPU_OFF;
+PERF_TEST_P(dftFixture, DISABLED_dft, OCL_TYPICAL_MAT_SIZES)
+{
+    const std::string impl = getSelectedImpl();
+    Size srcSize = GetParam();
 
-            d_src.upload(src);
+    Mat src(srcSize, CV_32FC2), dst;
+    randu(src, 0.0f, 1.0f);
+    declare.in(src);
 
-            WARMUP_ON;
-            ocl::dft(d_src, d_dst, Size(size, size));
-            WARMUP_OFF;
+    if (impl == "ocl")
+    {
+        ocl::oclMat oclSrc(src), oclDst;
 
-            GPU_ON;
-            ocl::dft(d_src, d_dst, Size(size, size));
-            GPU_OFF;
+        EXPECT_NO_THROW({
+            TEST_CYCLE() cv::ocl::dft(oclSrc, oclDst);
+        });
 
-            GPU_FULL_ON;
-            d_src.upload(src);
-            ocl::dft(d_src, d_dst, Size(size, size));
-            d_dst.download(ocl_dst);
-            GPU_FULL_OFF;
+        oclDst.download(dst);
 
-            TestSystem::instance().ExpectedMatNear(dst, ocl_dst, src.size().area() * 1e-4);
-        }
+        SANITY_CHECK(dst);
+    }
+    else if (impl == "plain")
+    {
+        TEST_CYCLE() cv::dft(src, dst);
 
+        SANITY_CHECK(dst);
     }
+#ifdef HAVE_OPENCV_GPU
+    else if (impl == "gpu")
+        CV_TEST_FAIL_NO_IMPL();
+#endif
+    else
+        CV_TEST_FAIL_NO_IMPL();
 }

modules/ocl/perf/perf_gemm.cpp

@@ -45,46 +45,46 @@
 //M*/
 #include "perf_precomp.hpp"
 
-///////////// gemm ////////////////////////
-PERFTEST(gemm)
-{
-    Mat src1, src2, src3, dst, ocl_dst;
-    ocl::oclMat d_src1, d_src2, d_src3, d_dst;
+using namespace perf;
 
-    for (int size = Min_Size; size <= Max_Size; size *= Multiple)
-    {
-        SUBTEST << size << 'x' << size;
+///////////// gemm ////////////////////////
 
-        gen(src1, size, size, CV_32FC1, Scalar::all(-10), Scalar::all(10));
-        gen(src2, size, size, CV_32FC1, Scalar::all(-10), Scalar::all(10));
-        gen(src3, size, size, CV_32FC1, Scalar::all(-10), Scalar::all(10));
+typedef TestBaseWithParam<Size> gemmFixture;
 
-        gemm(src1, src2, 1.0, src3, 1.0, dst);
+PERF_TEST_P(gemmFixture, DISABLED_gemm, OCL_TYPICAL_MAT_SIZES)
+{
+    // getting params
+    const Size srcSize = GetParam();
+    const std::string impl = getSelectedImpl();
 
-        CPU_ON;
-        gemm(src1, src2, 1.0, src3, 1.0, dst);
-        CPU_OFF;
+    Mat src1(srcSize, CV_32FC1), src2(srcSize, CV_32FC1),
+            src3(srcSize, CV_32FC1), dst(srcSize, CV_32FC1);
+    declare.in(src1, src2, src3).out(dst);
+    randu(src1, -10.0f, 10.0f);
+    randu(src2, -10.0f, 10.0f);
+    randu(src3, -10.0f, 10.0f);
 
-        d_src1.upload(src1);
-        d_src2.upload(src2);
-        d_src3.upload(src3);
+    if (impl == "ocl")
+    {
+        ocl::oclMat oclSrc1(src1), oclSrc2(src2),
+                oclSrc3(src3), oclDst(srcSize, CV_32FC1);
 
-        WARMUP_ON;
-        ocl::gemm(d_src1, d_src2, 1.0, d_src3, 1.0, d_dst);
-        WARMUP_OFF;
+        TEST_CYCLE() cv::ocl::gemm(oclSrc1, oclSrc2, 1.0, oclSrc3, 1.0, oclDst);
 
-        GPU_ON;
-        ocl::gemm(d_src1, d_src2, 1.0, d_src3, 1.0, d_dst);
-        GPU_OFF;
+        oclDst.download(dst);
 
-        GPU_FULL_ON;
-        d_src1.upload(src1);
-        d_src2.upload(src2);
-        d_src3.upload(src3);
-        ocl::gemm(d_src1, d_src2, 1.0, d_src3, 1.0, d_dst);
-        d_dst.download(ocl_dst);
-        GPU_FULL_OFF;
+        SANITY_CHECK(dst);
+    }
+    else if (impl == "plain")
+    {
+        TEST_CYCLE() cv::gemm(src1, src2, 1.0, src3, 1.0, dst);
 
-        TestSystem::instance().ExpectedMatNear(ocl_dst, dst, src1.cols * src1.rows * 1e-4);
+        SANITY_CHECK(dst);
     }
+ #ifdef HAVE_OPENCV_GPU
+    else if (impl == "gpu")
+        CV_TEST_FAIL_NO_IMPL();
+#endif
+    else
+        CV_TEST_FAIL_NO_IMPL();
 }

modules/ocl/perf/perf_gftt.cpp

@@ -46,56 +46,54 @@
 
 #include "perf_precomp.hpp"
 
-///////////// GoodFeaturesToTrack ////////////////////////
-PERFTEST(GoodFeaturesToTrack)
-{
-    using namespace cv;
-
-    int maxCorners = 2000;
-    double qualityLevel = 0.01;
-
-    std::string images[] = { "rubberwhale1.png", "aloeL.jpg" };
-
-    std::vector<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());
+using namespace perf;
+using std::tr1::tuple;
+using std::tr1::get;
 
-        for(float minDistance = 0; minDistance < 4; minDistance += 3.0)
-        {
-            SUBTEST << "image = " << images[imgIdx] << "; ";
-            SUBTEST << "minDistance = " << minDistance << "; ";
+///////////// GoodFeaturesToTrack ////////////////////////
 
-            cv::goodFeaturesToTrack(frame, pts_gold, maxCorners, qualityLevel, minDistance);
+typedef tuple<string, double> GoodFeaturesToTrackParams;
+typedef TestBaseWithParam<GoodFeaturesToTrackParams> GoodFeaturesToTrackFixture;
 
-            CPU_ON;
-            cv::goodFeaturesToTrack(frame, pts_gold, maxCorners, qualityLevel, minDistance);
-            CPU_OFF;
+PERF_TEST_P(GoodFeaturesToTrackFixture, GoodFeaturesToTrack,
+            ::testing::Combine(::testing::Values(string("gpu/opticalflow/rubberwhale1.png"),
+                                                 string("gpu/stereobm/aloe-L.png")),
+                               ::testing::Range(0.0, 4.0, 3.0)))
+{
+    std::vector<cv::Point2f> pts_gold;
 
-            cv::ocl::GoodFeaturesToTrackDetector_OCL detector(maxCorners, qualityLevel, minDistance);
+    // getting params
+    GoodFeaturesToTrackParams param = GetParam();
+    const string fileName = getDataPath(get<0>(param)), impl = getSelectedImpl();
+    const int maxCorners = 2000;
+    const double qualityLevel = 0.01, minDistance = get<1>(param);
 
-            ocl::oclMat frame_ocl(frame), pts_oclmat;
+    Mat frame = imread(fileName, IMREAD_GRAYSCALE);
+    declare.in(frame);
+    ASSERT_TRUE(!frame.empty()) << "no input image";
 
-            WARMUP_ON;
-            detector(frame_ocl, pts_oclmat);
-            WARMUP_OFF;
+    if (impl == "ocl")
+    {
+        ocl::oclMat oclFrame(frame), pts_oclmat;
+        cv::ocl::GoodFeaturesToTrackDetector_OCL detector(maxCorners, qualityLevel, minDistance);
 
-            detector.downloadPoints(pts_oclmat, pts_ocl);
+        TEST_CYCLE() detector(oclFrame, pts_oclmat);
 
-            double diff = abs(static_cast<float>(pts_gold.size() - pts_ocl.size()));
-            TestSystem::instance().setAccurate(diff == 0.0, diff);
+        detector.downloadPoints(pts_oclmat, pts_gold);
 
-            GPU_ON;
-            detector(frame_ocl, pts_oclmat);
-            GPU_OFF;
+        SANITY_CHECK(pts_gold);
+    }
+    else if (impl == "plain")
+    {
+        TEST_CYCLE() cv::goodFeaturesToTrack(frame, pts_gold,
+                                             maxCorners, qualityLevel, minDistance);
 
-            GPU_FULL_ON;
-            frame_ocl.upload(frame);
-            detector(frame_ocl, pts_oclmat);
-            detector.downloadPoints(pts_oclmat, pts_ocl);
-            GPU_FULL_OFF;
-        }
+        SANITY_CHECK(pts_gold);
     }
+ #ifdef HAVE_OPENCV_GPU
+    else if (impl == "gpu")
+        CV_TEST_FAIL_NO_IMPL();
+#endif
+    else
+        CV_TEST_FAIL_NO_IMPL();
 }

modules/ocl/perf/perf_haar.cpp

@@ -45,6 +45,8 @@
 //M*/
 #include "perf_precomp.hpp"
 
+using namespace perf;
+
 ///////////// Haar ////////////////////////
 namespace cv
 {
@@ -83,61 +85,45 @@ public:
 
 }
 }
-PERFTEST(Haar)
-{
-    Mat img = imread(abspath("basketball1.png"), CV_LOAD_IMAGE_GRAYSCALE);
 
-    if (img.empty())
-    {
-        throw runtime_error("can't open basketball1.png");
-    }
+PERF_TEST(HaarFixture, Haar)
+{
+    const std::string impl = getSelectedImpl();
+    vector<Rect> faces;
 
-    CascadeClassifier faceCascadeCPU;
+    Mat img = imread(getDataPath("gpu/haarcascade/basketball1.png"), CV_LOAD_IMAGE_GRAYSCALE);
+    ASSERT_TRUE(!img.empty()) << "can't open basketball1.png";
+    declare.in(img);
 
-    if (!faceCascadeCPU.load(abspath("haarcascade_frontalface_alt.xml")))
+    if (impl == "plain")
     {
-        throw runtime_error("can't load haarcascade_frontalface_alt.xml");
-    }
+        CascadeClassifier faceCascade;
+        ASSERT_TRUE(faceCascade.load(getDataPath("gpu/haarcascade/haarcascade_frontalface_alt.xml")))
+                << "can't load haarcascade_frontalface_alt.xml";
 
-    vector<Rect> faces;
+        TEST_CYCLE() faceCascade.detectMultiScale(img, faces,
+                                                     1.1, 2, 0 | CV_HAAR_SCALE_IMAGE, Size(30, 30));
 
-    SUBTEST << img.cols << "x" << img.rows << "; scale image";
-    CPU_ON;
-    faceCascadeCPU.detectMultiScale(img, faces,
-                                    1.1, 2, 0 | CV_HAAR_SCALE_IMAGE, Size(30, 30));
-    CPU_OFF;
+        SANITY_CHECK(faces, 4 + 1e-4);
+    }
+    else if (impl == "ocl")
+    {
+        ocl::CascadeClassifier_GPU faceCascade;
+        ocl::oclMat oclImg(img);
 
+        ASSERT_TRUE(faceCascade.load(getDataPath("gpu/haarcascade/haarcascade_frontalface_alt.xml")))
+                << "can't load haarcascade_frontalface_alt.xml";
 
-    vector<Rect> oclfaces;
-    ocl::CascadeClassifier_GPU faceCascade;
+        TEST_CYCLE() faceCascade.detectMultiScale(oclImg, faces,
+                                     1.1, 2, 0 | CV_HAAR_SCALE_IMAGE, Size(30, 30));
 
-    if (!faceCascade.load(abspath("haarcascade_frontalface_alt.xml")))
-    {
-        throw runtime_error("can't load haarcascade_frontalface_alt.xml");
+        SANITY_CHECK(faces, 4 + 1e-4);
     }
 
-    ocl::oclMat d_img(img);
-
-    WARMUP_ON;
-    faceCascade.detectMultiScale(d_img, oclfaces,
-                                 1.1, 2, 0 | CV_HAAR_SCALE_IMAGE, Size(30, 30));
-    WARMUP_OFF;
-
-    if(faces.size() == oclfaces.size())
-        TestSystem::instance().setAccurate(1, 0);
+#ifdef HAVE_OPENCV_GPU
+    else if (impl == "gpu")
+        CV_TEST_FAIL_NO_IMPL();
+#endif
     else
-        TestSystem::instance().setAccurate(0, abs((int)faces.size() - (int)oclfaces.size()));
-
-    faces.clear();
-
-    GPU_ON;
-    faceCascade.detectMultiScale(d_img, oclfaces,
-                                 1.1, 2, 0 | CV_HAAR_SCALE_IMAGE, Size(30, 30));
-    GPU_OFF;
-
-    GPU_FULL_ON;
-    d_img.upload(img);
-    faceCascade.detectMultiScale(d_img, oclfaces,
-                                 1.1, 2, 0 | CV_HAAR_SCALE_IMAGE, Size(30, 30));
-    GPU_FULL_OFF;
+        CV_TEST_FAIL_NO_IMPL();
 }

modules/ocl/perf/perf_hog.cpp

@@ -45,50 +45,42 @@
 //M*/
 #include "perf_precomp.hpp"
 
+using namespace perf;
+
 ///////////// HOG////////////////////////
 
-PERFTEST(HOG)
+PERF_TEST(HOGFixture, HOG)
 {
-    Mat src = imread(abspath("road.png"), cv::IMREAD_GRAYSCALE);
-
-    if (src.empty())
-    {
-        throw runtime_error("can't open road.png");
-    }
+    Mat src = imread(getDataPath("gpu/hog/road.png"), cv::IMREAD_GRAYSCALE);
+    ASSERT_TRUE(!src.empty()) << "can't open input image road.png";
 
-    cv::HOGDescriptor hog;
-    hog.setSVMDetector(hog.getDefaultPeopleDetector());
+    const std::string impl = getSelectedImpl();
     std::vector<cv::Rect> found_locations;
-    std::vector<cv::Rect> d_found_locations;
-
-    SUBTEST << src.cols << 'x' << src.rows << "; road.png";
+    declare.in(src).time(5);
 
-    hog.detectMultiScale(src, found_locations);
+    if (impl == "plain")
+    {
+        cv::HOGDescriptor hog;
+        hog.setSVMDetector(hog.getDefaultPeopleDetector());
 
-    CPU_ON;
-    hog.detectMultiScale(src, found_locations);
-    CPU_OFF;
+        TEST_CYCLE() hog.detectMultiScale(src, found_locations);
 
-    cv::ocl::HOGDescriptor ocl_hog;
-    ocl_hog.setSVMDetector(ocl_hog.getDefaultPeopleDetector());
-    ocl::oclMat d_src;
-    d_src.upload(src);
+        SANITY_CHECK(found_locations, 1 + DBL_EPSILON);
+    }
+    else if (impl == "ocl")
+    {
+        cv::ocl::HOGDescriptor ocl_hog;
+        ocl_hog.setSVMDetector(ocl_hog.getDefaultPeopleDetector());
+        ocl::oclMat oclSrc(src);
 
-    WARMUP_ON;
-    ocl_hog.detectMultiScale(d_src, d_found_locations);
-    WARMUP_OFF;
+        TEST_CYCLE() ocl_hog.detectMultiScale(oclSrc, found_locations);
 
-    if(d_found_locations.size() == found_locations.size())
-        TestSystem::instance().setAccurate(1, 0);
+        SANITY_CHECK(found_locations, 1 + DBL_EPSILON);
+    }
+#ifdef HAVE_OPENCV_GPU
+    else if (impl == "gpu")
+        CV_TEST_FAIL_NO_IMPL();
+#endif
     else
-        TestSystem::instance().setAccurate(0, abs((int)found_locations.size() - (int)d_found_locations.size()));
-
-    GPU_ON;
-    ocl_hog.detectMultiScale(d_src, found_locations);
-    GPU_OFF;
-
-    GPU_FULL_ON;
-    d_src.upload(src);
-    ocl_hog.detectMultiScale(d_src, found_locations);
-    GPU_FULL_OFF;
+        CV_TEST_FAIL_NO_IMPL();
 }