merged gpu_perf_cpu into gpu_perf

modules/gpu/perf/perf_calib3d.cpp

@@ -15,13 +15,19 @@ PERF_TEST_P(ImagePair, Calib3D_StereoBM, Values(make_pair<string, string>("gpu/p
 {
     declare.time(5.0);
 
-    cv::Mat imgLeft = readImage(GetParam().first, cv::IMREAD_GRAYSCALE);
+    const cv::Mat imgLeft = readImage(GetParam().first, cv::IMREAD_GRAYSCALE);
     ASSERT_FALSE(imgLeft.empty());
 
-    cv::Mat imgRight = readImage(GetParam().second, cv::IMREAD_GRAYSCALE);
+    const cv::Mat imgRight = readImage(GetParam().second, cv::IMREAD_GRAYSCALE);
     ASSERT_FALSE(imgRight.empty());
 
-    cv::gpu::StereoBM_GPU d_bm(0, 256);
+    const int preset = 0;
+    const int ndisp = 256;
+
+    if (runOnGpu)
+    {
+        cv::gpu::StereoBM_GPU d_bm(preset, ndisp);
+
         cv::gpu::GpuMat d_imgLeft(imgLeft);
         cv::gpu::GpuMat d_imgRight(imgRight);
         cv::gpu::GpuMat d_dst;
@@ -33,6 +39,20 @@ PERF_TEST_P(ImagePair, Calib3D_StereoBM, Values(make_pair<string, string>("gpu/p
             d_bm(d_imgLeft, d_imgRight, d_dst);
         }
     }
+    else
+    {
+        cv::StereoBM bm(preset, ndisp);
+
+        cv::Mat dst;
+
+        bm(imgLeft, imgRight, dst);
+
+        TEST_CYCLE()
+        {
+            bm(imgLeft, imgRight, dst);
+        }
+    }
+}
 
 //////////////////////////////////////////////////////////////////////
 // StereoBeliefPropagation
@@ -41,13 +61,18 @@ PERF_TEST_P(ImagePair, Calib3D_StereoBeliefPropagation, Values(make_pair<string,
 {
     declare.time(10.0);
 
-    cv::Mat imgLeft = readImage(GetParam().first);
+    const cv::Mat imgLeft = readImage(GetParam().first);
     ASSERT_FALSE(imgLeft.empty());
 
-    cv::Mat imgRight = readImage(GetParam().second);
+    const cv::Mat imgRight = readImage(GetParam().second);
     ASSERT_FALSE(imgRight.empty());
 
-    cv::gpu::StereoBeliefPropagation d_bp(64);
+    const int ndisp = 64;
+
+    if (runOnGpu)
+    {
+        cv::gpu::StereoBeliefPropagation d_bp(ndisp);
+
         cv::gpu::GpuMat d_imgLeft(imgLeft);
         cv::gpu::GpuMat d_imgRight(imgRight);
         cv::gpu::GpuMat d_dst;
@@ -59,6 +84,11 @@ PERF_TEST_P(ImagePair, Calib3D_StereoBeliefPropagation, Values(make_pair<string,
             d_bp(d_imgLeft, d_imgRight, d_dst);
         }
     }
+    else
+    {
+        FAIL();
+    }
+}
 
 //////////////////////////////////////////////////////////////////////
 // StereoConstantSpaceBP
@@ -67,13 +97,18 @@ PERF_TEST_P(ImagePair, Calib3D_StereoConstantSpaceBP, Values(make_pair<string, s
 {
     declare.time(10.0);
 
-    cv::Mat imgLeft = readImage(GetParam().first, cv::IMREAD_GRAYSCALE);
+    const cv::Mat imgLeft = readImage(GetParam().first, cv::IMREAD_GRAYSCALE);
     ASSERT_FALSE(imgLeft.empty());
 
-    cv::Mat imgRight = readImage(GetParam().second, cv::IMREAD_GRAYSCALE);
+    const cv::Mat imgRight = readImage(GetParam().second, cv::IMREAD_GRAYSCALE);
     ASSERT_FALSE(imgRight.empty());
 
-    cv::gpu::StereoConstantSpaceBP d_csbp(128);
+    const int ndisp = 128;
+
+    if (runOnGpu)
+    {
+        cv::gpu::StereoConstantSpaceBP d_csbp(ndisp);
+
         cv::gpu::GpuMat d_imgLeft(imgLeft);
         cv::gpu::GpuMat d_imgRight(imgRight);
         cv::gpu::GpuMat d_dst;
@@ -85,19 +120,29 @@ PERF_TEST_P(ImagePair, Calib3D_StereoConstantSpaceBP, Values(make_pair<string, s
             d_csbp(d_imgLeft, d_imgRight, d_dst);
         }
     }
+    else
+    {
+        FAIL();
+    }
+}
 
 //////////////////////////////////////////////////////////////////////
 // DisparityBilateralFilter
 
 PERF_TEST_P(ImagePair, Calib3D_DisparityBilateralFilter, Values(make_pair<string, string>("gpu/stereobm/aloe-L.png", "gpu/stereobm/aloe-disp.png")))
 {
-    cv::Mat img = readImage(GetParam().first, cv::IMREAD_GRAYSCALE);
+    const cv::Mat img = readImage(GetParam().first, cv::IMREAD_GRAYSCALE);
     ASSERT_FALSE(img.empty());
 
-    cv::Mat disp = readImage(GetParam().second, cv::IMREAD_GRAYSCALE);
+    const cv::Mat disp = readImage(GetParam().second, cv::IMREAD_GRAYSCALE);
     ASSERT_FALSE(disp.empty());
 
-    cv::gpu::DisparityBilateralFilter d_filter(128);
+    const int ndisp = 128;
+
+    if (runOnGpu)
+    {
+        cv::gpu::DisparityBilateralFilter d_filter(ndisp);
+
         cv::gpu::GpuMat d_img(img);
         cv::gpu::GpuMat d_disp(disp);
         cv::gpu::GpuMat d_dst;
@@ -109,6 +154,11 @@ PERF_TEST_P(ImagePair, Calib3D_DisparityBilateralFilter, Values(make_pair<string
             d_filter(d_disp, d_img, d_dst);
         }
     }
+    else
+    {
+        FAIL();
+    }
+}
 
 //////////////////////////////////////////////////////////////////////
 // TransformPoints
@@ -117,14 +167,16 @@ DEF_PARAM_TEST_1(Count, int);
 
 PERF_TEST_P(Count, Calib3D_TransformPoints, Values(5000, 10000, 20000))
 {
-    int count = GetParam();
+    const int count = GetParam();
 
     cv::Mat src(1, count, CV_32FC3);
     fillRandom(src, -100, 100);
 
-    cv::Mat rvec = cv::Mat::ones(1, 3, CV_32FC1);
+    const cv::Mat rvec = cv::Mat::ones(1, 3, CV_32FC1);
-    cv::Mat tvec = cv::Mat::ones(1, 3, CV_32FC1);
+    const cv::Mat tvec = cv::Mat::ones(1, 3, CV_32FC1);
 
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_dst;
 
@@ -135,21 +187,28 @@ PERF_TEST_P(Count, Calib3D_TransformPoints, Values(5000, 10000, 20000))
             cv::gpu::transformPoints(d_src, rvec, tvec, d_dst);
         }
     }
+    else
+    {
+        FAIL();
+    }
+}
 
 //////////////////////////////////////////////////////////////////////
 // ProjectPoints
 
 PERF_TEST_P(Count, Calib3D_ProjectPoints, Values(5000, 10000, 20000))
 {
-    int count = GetParam();
+    const int count = GetParam();
 
     cv::Mat src(1, count, CV_32FC3);
     fillRandom(src, -100, 100);
 
-    cv::Mat rvec = cv::Mat::ones(1, 3, CV_32FC1);
+    const cv::Mat rvec = cv::Mat::ones(1, 3, CV_32FC1);
-    cv::Mat tvec = cv::Mat::ones(1, 3, CV_32FC1);
+    const cv::Mat tvec = cv::Mat::ones(1, 3, CV_32FC1);
-    cv::Mat camera_mat = cv::Mat::ones(3, 3, CV_32FC1);
+    const cv::Mat camera_mat = cv::Mat::ones(3, 3, CV_32FC1);
 
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_dst;
 
@@ -160,15 +219,27 @@ PERF_TEST_P(Count, Calib3D_ProjectPoints, Values(5000, 10000, 20000))
             cv::gpu::projectPoints(d_src, rvec, tvec, camera_mat, cv::Mat(), d_dst);
         }
     }
+    else
+    {
+        cv::Mat dst;
+
+        cv::projectPoints(src, rvec, tvec, camera_mat, cv::noArray(), dst);
+
+        TEST_CYCLE()
+        {
+            cv::projectPoints(src, rvec, tvec, camera_mat, cv::noArray(), dst);
+        }
+    }
+}
 
 //////////////////////////////////////////////////////////////////////
 // SolvePnPRansac
 
 PERF_TEST_P(Count, Calib3D_SolvePnPRansac, Values(5000, 10000, 20000))
 {
-    declare.time(3.0);
+    declare.time(10.0);
 
-    int count = GetParam();
+    const int count = GetParam();
 
     cv::Mat object(1, count, CV_32FC3);
     fillRandom(object, -100, 100);
@@ -180,7 +251,7 @@ PERF_TEST_P(Count, Calib3D_SolvePnPRansac, Values(5000, 10000, 20000))
     camera_mat.at<float>(2, 0) = 0.f;
     camera_mat.at<float>(2, 1) = 0.f;
 
-    cv::Mat dist_coef(1, 8, CV_32F, cv::Scalar::all(0));
+    const cv::Mat dist_coef(1, 8, CV_32F, cv::Scalar::all(0));
 
     std::vector<cv::Point2f> image_vec;
     cv::Mat rvec_gold(1, 3, CV_32FC1);
@@ -194,6 +265,8 @@ PERF_TEST_P(Count, Calib3D_SolvePnPRansac, Values(5000, 10000, 20000))
     cv::Mat rvec;
     cv::Mat tvec;
 
+    if (runOnGpu)
+    {
         cv::gpu::solvePnPRansac(object, image, camera_mat, dist_coef, rvec, tvec);
 
         TEST_CYCLE()
@@ -201,14 +274,24 @@ PERF_TEST_P(Count, Calib3D_SolvePnPRansac, Values(5000, 10000, 20000))
             cv::gpu::solvePnPRansac(object, image, camera_mat, dist_coef, rvec, tvec);
         }
     }
+    else
+    {
+        cv::solvePnPRansac(object, image, camera_mat, dist_coef, rvec, tvec);
+
+        TEST_CYCLE()
+        {
+            cv::solvePnPRansac(object, image, camera_mat, dist_coef, rvec, tvec);
+        }
+    }
+}
 
 //////////////////////////////////////////////////////////////////////
 // ReprojectImageTo3D
 
 PERF_TEST_P(Sz_Depth, Calib3D_ReprojectImageTo3D, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U, CV_16S)))
 {
-    cv::Size size = GET_PARAM(0);
+    const cv::Size size = GET_PARAM(0);
-    int depth = GET_PARAM(1);
+    const int depth = GET_PARAM(1);
 
     cv::Mat src(size, depth);
     fillRandom(src, 5.0, 30.0);
@@ -216,6 +299,8 @@ PERF_TEST_P(Sz_Depth, Calib3D_ReprojectImageTo3D, Combine(GPU_TYPICAL_MAT_SIZES,
     cv::Mat Q(4, 4, CV_32FC1);
     fillRandom(Q, 0.1, 1.0);
 
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_dst;
 
@@ -226,18 +311,32 @@ PERF_TEST_P(Sz_Depth, Calib3D_ReprojectImageTo3D, Combine(GPU_TYPICAL_MAT_SIZES,
             cv::gpu::reprojectImageTo3D(d_src, d_dst, Q);
         }
     }
+    else
+    {
+        cv::Mat dst;
+
+        cv::reprojectImageTo3D(src, dst, Q);
+
+        TEST_CYCLE()
+        {
+            cv::reprojectImageTo3D(src, dst, Q);
+        }
+    }
+}
 
 //////////////////////////////////////////////////////////////////////
 // DrawColorDisp
 
 PERF_TEST_P(Sz_Depth, Calib3D_DrawColorDisp, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U, CV_16S)))
 {
-    cv::Size size = GET_PARAM(0);
+    const cv::Size size = GET_PARAM(0);
-    int type = GET_PARAM(1);
+    const int type = GET_PARAM(1);
 
     cv::Mat src(size, type);
     fillRandom(src, 0, 255);
 
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_dst;
 
@@ -248,5 +347,10 @@ PERF_TEST_P(Sz_Depth, Calib3D_DrawColorDisp, Combine(GPU_TYPICAL_MAT_SIZES, Valu
             cv::gpu::drawColorDisp(d_src, d_dst, 255);
         }
     }
+    else
+    {
+        FAIL();
+    }
+}
 
 } // namespace

modules/gpu/perf/perf_features2d.cpp

@@ -12,11 +12,13 @@ DEF_PARAM_TEST_1(Image, string);
 
 PERF_TEST_P(Image, Features2D_SURF, Values<string>("gpu/perf/aloe.jpg"))
 {
-    declare.time(2.0);
+    declare.time(50.0);
 
     cv::Mat img = readImage(GetParam(), cv::IMREAD_GRAYSCALE);
     ASSERT_FALSE(img.empty());
 
+    if (runOnGpu)
+    {
         cv::gpu::SURF_GPU d_surf;
 
         cv::gpu::GpuMat d_img(img);
@@ -29,6 +31,22 @@ PERF_TEST_P(Image, Features2D_SURF, Values<string>("gpu/perf/aloe.jpg"))
             d_surf(d_img, cv::gpu::GpuMat(), d_keypoints, d_descriptors);
         }
     }
+    else
+    {
+        cv::SURF surf;
+
+        std::vector<cv::KeyPoint> keypoints;
+        cv::Mat descriptors;
+
+        surf(img, cv::noArray(), keypoints, descriptors);
+
+        TEST_CYCLE()
+        {
+            keypoints.clear();
+            surf(img, cv::noArray(), keypoints, descriptors);
+        }
+    }
+}
 
 //////////////////////////////////////////////////////////////////////
 // FAST
@@ -38,6 +56,8 @@ PERF_TEST_P(Image, Features2D_FAST, Values<string>("gpu/perf/aloe.jpg"))
     cv::Mat img = readImage(GetParam(), cv::IMREAD_GRAYSCALE);
     ASSERT_FALSE(img.empty());
 
+    if (runOnGpu)
+    {
         cv::gpu::FAST_GPU d_fast(20);
 
         cv::gpu::GpuMat d_img(img);
@@ -50,6 +70,19 @@ PERF_TEST_P(Image, Features2D_FAST, Values<string>("gpu/perf/aloe.jpg"))
             d_fast(d_img, cv::gpu::GpuMat(), d_keypoints);
         }
     }
+    else
+    {
+        std::vector<cv::KeyPoint> keypoints;
+
+        cv::FAST(img, keypoints, 20);
+
+        TEST_CYCLE()
+        {
+            keypoints.clear();
+            cv::FAST(img, keypoints, 20);
+        }
+    }
+}
 
 //////////////////////////////////////////////////////////////////////
 // ORB
@@ -59,6 +92,8 @@ PERF_TEST_P(Image, Features2D_ORB, Values<string>("gpu/perf/aloe.jpg"))
     cv::Mat img = readImage(GetParam(), cv::IMREAD_GRAYSCALE);
     ASSERT_FALSE(img.empty());
 
+    if (runOnGpu)
+    {
         cv::gpu::ORB_GPU d_orb(4000);
 
         cv::gpu::GpuMat d_img(img);
@@ -71,6 +106,22 @@ PERF_TEST_P(Image, Features2D_ORB, Values<string>("gpu/perf/aloe.jpg"))
             d_orb(d_img, cv::gpu::GpuMat(), d_keypoints, d_descriptors);
         }
     }
+    else
+    {
+        cv::ORB orb(4000);
+
+        std::vector<cv::KeyPoint> keypoints;
+        cv::Mat descriptors;
+
+        orb(img, cv::noArray(), keypoints, descriptors);
+
+        TEST_CYCLE()
+        {
+            keypoints.clear();
+            orb(img, cv::noArray(), keypoints, descriptors);
+        }
+    }
+}
 
 //////////////////////////////////////////////////////////////////////
 // BFMatch
@@ -79,7 +130,7 @@ DEF_PARAM_TEST(DescSize_Norm, int, NormType);
 
 PERF_TEST_P(DescSize_Norm, Features2D_BFMatch, Combine(Values(64, 128, 256), Values(NormType(cv::NORM_L1), NormType(cv::NORM_L2), NormType(cv::NORM_HAMMING))))
 {
-    declare.time(3.0);
+    declare.time(20.0);
 
     int desc_size = GET_PARAM(0);
     int normType = GET_PARAM(1);
@@ -92,6 +143,8 @@ PERF_TEST_P(DescSize_Norm, Features2D_BFMatch, Combine(Values(64, 128, 256), Val
     cv::Mat train(3000, desc_size, type);
     fillRandom(train);
 
+    if (runOnGpu)
+    {
         cv::gpu::BFMatcher_GPU d_matcher(normType);
 
         cv::gpu::GpuMat d_query(query);
@@ -105,6 +158,20 @@ PERF_TEST_P(DescSize_Norm, Features2D_BFMatch, Combine(Values(64, 128, 256), Val
             d_matcher.matchSingle(d_query, d_train, d_trainIdx, d_distance);
         }
     }
+    else
+    {
+        cv::BFMatcher matcher(normType);
+
+        std::vector<cv::DMatch> matches;
+
+        matcher.match(query, train, matches);
+
+        TEST_CYCLE()
+        {
+            matcher.match(query, train, matches);
+        }
+    }
+}
 
 //////////////////////////////////////////////////////////////////////
 // BFKnnMatch
@@ -116,7 +183,7 @@ PERF_TEST_P(DescSize_K_Norm, Features2D_BFKnnMatch, Combine(
     Values(2, 3),
     Values(NormType(cv::NORM_L1), NormType(cv::NORM_L2), NormType(cv::NORM_HAMMING))))
 {
-    declare.time(3.0);
+    declare.time(30.0);
 
     int desc_size = GET_PARAM(0);
     int k = GET_PARAM(1);
@@ -130,6 +197,8 @@ PERF_TEST_P(DescSize_K_Norm, Features2D_BFKnnMatch, Combine(
     cv::Mat train(3000, desc_size, type);
     fillRandom(train);
 
+    if (runOnGpu)
+    {
         cv::gpu::BFMatcher_GPU d_matcher(normType);
 
         cv::gpu::GpuMat d_query(query);
@@ -143,13 +212,27 @@ PERF_TEST_P(DescSize_K_Norm, Features2D_BFKnnMatch, Combine(
             d_matcher.knnMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_allDist, k);
         }
     }
+    else
+    {
+        cv::BFMatcher matcher(normType);
+
+        std::vector< std::vector<cv::DMatch> > matches;
+
+        matcher.knnMatch(query, train, matches, k);
+
+        TEST_CYCLE()
+        {
+            matcher.knnMatch(query, train, matches, k);
+        }
+    }
+}
 
 //////////////////////////////////////////////////////////////////////
 // BFRadiusMatch
 
 PERF_TEST_P(DescSize_Norm, Features2D_BFRadiusMatch, Combine(Values(64, 128, 256), Values(NormType(cv::NORM_L1), NormType(cv::NORM_L2), NormType(cv::NORM_HAMMING))))
 {
-    declare.time(3.0);
+    declare.time(30.0);
 
     int desc_size = GET_PARAM(0);
     int normType = GET_PARAM(1);
@@ -162,6 +245,8 @@ PERF_TEST_P(DescSize_Norm, Features2D_BFRadiusMatch, Combine(Values(64, 128, 256
     cv::Mat train(3000, desc_size, type);
     fillRandom(train, 0.0, 1.0);
 
+    if (runOnGpu)
+    {
         cv::gpu::BFMatcher_GPU d_matcher(normType);
 
         cv::gpu::GpuMat d_query(query);
@@ -175,5 +260,19 @@ PERF_TEST_P(DescSize_Norm, Features2D_BFRadiusMatch, Combine(Values(64, 128, 256
             d_matcher.radiusMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_nMatches, 2.0);
         }
     }
+    else
+    {
+        cv::BFMatcher matcher(normType);
+
+        std::vector< std::vector<cv::DMatch> > matches;
+
+        matcher.radiusMatch(query, train, matches, 2.0);
+
+        TEST_CYCLE()
+        {
+            matcher.radiusMatch(query, train, matches, 2.0);
+        }
+    }
+}
 
 } // namespace

modules/gpu/perf/perf_filters.cpp

@@ -12,6 +12,8 @@ DEF_PARAM_TEST(Sz_Type_KernelSz, cv::Size, MatType, int);
 
 PERF_TEST_P(Sz_Type_KernelSz, Filters_Blur, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8UC1, CV_8UC4), Values(3, 5, 7)))
 {
+    declare.time(20.0);
+
     cv::Size size = GET_PARAM(0);
     int type = GET_PARAM(1);
     int ksize = GET_PARAM(2);
@@ -19,6 +21,8 @@ PERF_TEST_P(Sz_Type_KernelSz, Filters_Blur, Combine(GPU_TYPICAL_MAT_SIZES, Value
     cv::Mat src(size, type);
     fillRandom(src);
 
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_dst;
 
@@ -29,12 +33,26 @@ PERF_TEST_P(Sz_Type_KernelSz, Filters_Blur, Combine(GPU_TYPICAL_MAT_SIZES, Value
             cv::gpu::blur(d_src, d_dst, cv::Size(ksize, ksize));
         }
     }
+    else
+    {
+        cv::Mat dst;
+
+        cv::blur(src, dst, cv::Size(ksize, ksize));
+
+        TEST_CYCLE()
+        {
+            cv::blur(src, dst, cv::Size(ksize, ksize));
+        }
+    }
+}
 
 //////////////////////////////////////////////////////////////////////
 // Sobel
 
 PERF_TEST_P(Sz_Type_KernelSz, Filters_Sobel, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8UC1, CV_8UC4, CV_32FC1), Values(3, 5, 7, 9, 11, 13, 15)))
 {
+    declare.time(20.0);
+
     cv::Size size = GET_PARAM(0);
     int type = GET_PARAM(1);
     int ksize = GET_PARAM(2);
@@ -42,6 +60,8 @@ PERF_TEST_P(Sz_Type_KernelSz, Filters_Sobel, Combine(GPU_TYPICAL_MAT_SIZES, Valu
     cv::Mat src(size, type);
     fillRandom(src);
 
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_dst;
         cv::gpu::GpuMat d_buf;
@@ -53,18 +73,34 @@ PERF_TEST_P(Sz_Type_KernelSz, Filters_Sobel, Combine(GPU_TYPICAL_MAT_SIZES, Valu
             cv::gpu::Sobel(d_src, d_dst, -1, 1, 1, d_buf, ksize);
         }
     }
+    else
+    {
+        cv::Mat dst;
+
+        cv::Sobel(src, dst, -1, 1, 1, ksize);
+
+        TEST_CYCLE()
+        {
+            cv::Sobel(src, dst, -1, 1, 1, ksize);
+        }
+    }
+}
 
 //////////////////////////////////////////////////////////////////////
 // Scharr
 
 PERF_TEST_P(Sz_Type, Filters_Scharr, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8UC1, CV_8UC4, CV_32FC1)))
 {
+    declare.time(20.0);
+
     cv::Size size = GET_PARAM(0);
     int type = GET_PARAM(1);
 
     cv::Mat src(size, type);
     fillRandom(src);
 
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_dst;
         cv::gpu::GpuMat d_buf;
@@ -76,12 +112,26 @@ PERF_TEST_P(Sz_Type, Filters_Scharr, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U
             cv::gpu::Scharr(d_src, d_dst, -1, 1, 0, d_buf);
         }
     }
+    else
+    {
+        cv::Mat dst;
+
+        cv::Scharr(src, dst, -1, 1, 0);
+
+        TEST_CYCLE()
+        {
+            cv::Scharr(src, dst, -1, 1, 0);
+        }
+    }
+}
 
 //////////////////////////////////////////////////////////////////////
 // GaussianBlur
 
 PERF_TEST_P(Sz_Type_KernelSz, Filters_GaussianBlur, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8UC1, CV_8UC4, CV_32FC1), Values(3, 5, 7, 9, 11, 13, 15)))
 {
+    declare.time(20.0);
+
     cv::Size size = GET_PARAM(0);
     int type = GET_PARAM(1);
     int ksize = GET_PARAM(2);
@@ -89,6 +139,8 @@ PERF_TEST_P(Sz_Type_KernelSz, Filters_GaussianBlur, Combine(GPU_TYPICAL_MAT_SIZE
     cv::Mat src(size, type);
     fillRandom(src);
 
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_dst;
         cv::gpu::GpuMat d_buf;
@@ -100,12 +152,26 @@ PERF_TEST_P(Sz_Type_KernelSz, Filters_GaussianBlur, Combine(GPU_TYPICAL_MAT_SIZE
             cv::gpu::GaussianBlur(d_src, d_dst, cv::Size(ksize, ksize), d_buf, 0.5);
         }
     }
+    else
+    {
+        cv::Mat dst;
+
+        cv::GaussianBlur(src, dst, cv::Size(ksize, ksize), 0.5);
+
+        TEST_CYCLE()
+        {
+            cv::GaussianBlur(src, dst, cv::Size(ksize, ksize), 0.5);
+        }
+    }
+}
 
 //////////////////////////////////////////////////////////////////////
 // Laplacian
 
 PERF_TEST_P(Sz_Type_KernelSz, Filters_Laplacian, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8UC1, CV_8UC4, CV_32FC1, CV_32FC4), Values(1, 3)))
 {
+    declare.time(20.0);
+
     cv::Size size = GET_PARAM(0);
     int type = GET_PARAM(1);
     int ksize = GET_PARAM(2);
@@ -113,6 +179,8 @@ PERF_TEST_P(Sz_Type_KernelSz, Filters_Laplacian, Combine(GPU_TYPICAL_MAT_SIZES,
     cv::Mat src(size, type);
     fillRandom(src);
 
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_dst;
 
@@ -123,12 +191,26 @@ PERF_TEST_P(Sz_Type_KernelSz, Filters_Laplacian, Combine(GPU_TYPICAL_MAT_SIZES,
             cv::gpu::Laplacian(d_src, d_dst, -1, ksize);
         }
     }
+    else
+    {
+        cv::Mat dst;
+
+        cv::Laplacian(src, dst, -1, ksize);
+
+        TEST_CYCLE()
+        {
+            cv::Laplacian(src, dst, -1, ksize);
+        }
+    }
+}
 
 //////////////////////////////////////////////////////////////////////
 // Erode
 
 PERF_TEST_P(Sz_Type, Filters_Erode, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8UC1, CV_8UC4)))
 {
+    declare.time(20.0);
+
     cv::Size size = GET_PARAM(0);
     int type = GET_PARAM(1);
 
@@ -137,6 +219,8 @@ PERF_TEST_P(Sz_Type, Filters_Erode, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8UC
 
     cv::Mat ker = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(3, 3));
 
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_dst;
         cv::gpu::GpuMat d_buf;
@@ -148,12 +232,26 @@ PERF_TEST_P(Sz_Type, Filters_Erode, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8UC
             cv::gpu::erode(d_src, d_dst, ker, d_buf);
         }
     }
+    else
+    {
+        cv::Mat dst;
+
+        cv::erode(src, dst, ker);
+
+        TEST_CYCLE()
+        {
+            cv::erode(src, dst, ker);
+        }
+    }
+}
 
 //////////////////////////////////////////////////////////////////////
 // Dilate
 
 PERF_TEST_P(Sz_Type, Filters_Dilate, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8UC1, CV_8UC4)))
 {
+    declare.time(20.0);
+
     cv::Size size = GET_PARAM(0);
     int type = GET_PARAM(1);
 
@@ -162,6 +260,8 @@ PERF_TEST_P(Sz_Type, Filters_Dilate, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U
 
     cv::Mat ker = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(3, 3));
 
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_dst;
         cv::gpu::GpuMat d_buf;
@@ -173,6 +273,18 @@ PERF_TEST_P(Sz_Type, Filters_Dilate, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U
             cv::gpu::dilate(d_src, d_dst, ker, d_buf);
         }
     }
+    else
+    {
+        cv::Mat dst;
+
+        cv::dilate(src, dst, ker);
+
+        TEST_CYCLE()
+        {
+            cv::dilate(src, dst, ker);
+        }
+    }
+}
 
 //////////////////////////////////////////////////////////////////////
 // MorphologyEx
@@ -184,6 +296,8 @@ DEF_PARAM_TEST(Sz_Type_Op, cv::Size, MatType, MorphOp);
 
 PERF_TEST_P(Sz_Type_Op, Filters_MorphologyEx, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8UC1, CV_8UC4), ALL_MORPH_OPS))
 {
+    declare.time(20.0);
+
     cv::Size size = GET_PARAM(0);
     int type = GET_PARAM(1);
     int morphOp = GET_PARAM(2);
@@ -193,6 +307,8 @@ PERF_TEST_P(Sz_Type_Op, Filters_MorphologyEx, Combine(GPU_TYPICAL_MAT_SIZES, Val
 
     cv::Mat ker = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(3, 3));
 
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_dst;
         cv::gpu::GpuMat d_buf1;
@@ -205,12 +321,26 @@ PERF_TEST_P(Sz_Type_Op, Filters_MorphologyEx, Combine(GPU_TYPICAL_MAT_SIZES, Val
             cv::gpu::morphologyEx(d_src, d_dst, morphOp, ker, d_buf1, d_buf2);
         }
     }
+    else
+    {
+        cv::Mat dst;
+
+        cv::morphologyEx(src, dst, morphOp, ker);
+
+        TEST_CYCLE()
+        {
+            cv::morphologyEx(src, dst, morphOp, ker);
+        }
+    }
+}
 
 //////////////////////////////////////////////////////////////////////
 // Filter2D
 
 PERF_TEST_P(Sz_Type_KernelSz, Filters_Filter2D, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8UC1, CV_8UC4, CV_32FC1, CV_32FC4), Values(3, 5, 7, 9, 11, 13, 15)))
 {
+    declare.time(20.0);
+
     cv::Size size = GET_PARAM(0);
     int type = GET_PARAM(1);
     int ksize = GET_PARAM(2);
@@ -221,6 +351,8 @@ PERF_TEST_P(Sz_Type_KernelSz, Filters_Filter2D, Combine(GPU_TYPICAL_MAT_SIZES, V
     cv::Mat kernel(ksize, ksize, CV_32FC1);
     fillRandom(kernel, 0.0, 1.0);
 
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_dst;
 
@@ -231,5 +363,17 @@ PERF_TEST_P(Sz_Type_KernelSz, Filters_Filter2D, Combine(GPU_TYPICAL_MAT_SIZES, V
             cv::gpu::filter2D(d_src, d_dst, -1, kernel);
         }
     }
+    else
+    {
+        cv::Mat dst;
+
+        cv::filter2D(src, dst, -1, kernel);
+
+        TEST_CYCLE()
+        {
+            cv::filter2D(src, dst, -1, kernel);
+        }
+    }
+}
 
 } // namespace

modules/gpu/perf/perf_imgproc.cpp

@@ -59,7 +59,7 @@ PERF_TEST_P(Sz_Depth_Cn_Inter_Border_Mode, ImgProc_Remap, Combine(
     ALL_BORDER_MODES,
     ALL_REMAP_MODES))
 {
-    declare.time(3.0);
+    declare.time(20.0);
 
     cv::Size size = GET_PARAM(0);
     int depth = GET_PARAM(1);
@@ -78,6 +78,8 @@ PERF_TEST_P(Sz_Depth_Cn_Inter_Border_Mode, ImgProc_Remap, Combine(
 
     generateMap(xmap, ymap, remapMode);
 
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_xmap(xmap);
         cv::gpu::GpuMat d_ymap(ymap);
@@ -90,6 +92,18 @@ PERF_TEST_P(Sz_Depth_Cn_Inter_Border_Mode, ImgProc_Remap, Combine(
             cv::gpu::remap(d_src, d_dst, d_xmap, d_ymap, interpolation, borderMode);
         }
     }
+    else
+    {
+        cv::Mat dst;
+
+        cv::remap(src, dst, xmap, ymap, interpolation, borderMode);
+
+        TEST_CYCLE()
+        {
+            cv::remap(src, dst, xmap, ymap, interpolation, borderMode);
+        }
+    }
+}
 
 //////////////////////////////////////////////////////////////////////
 // Resize
@@ -103,7 +117,7 @@ PERF_TEST_P(Sz_Depth_Cn_Inter_Scale, ImgProc_Resize, Combine(
     ALL_INTERPOLATIONS,
     Values(0.5, 0.3, 2.0)))
 {
-    declare.time(1.0);
+    declare.time(20.0);
 
     cv::Size size = GET_PARAM(0);
     int depth = GET_PARAM(1);
@@ -116,6 +130,8 @@ PERF_TEST_P(Sz_Depth_Cn_Inter_Scale, ImgProc_Resize, Combine(
     cv::Mat src(size, type);
     fillRandom(src);
 
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_dst;
 
@@ -126,6 +142,18 @@ PERF_TEST_P(Sz_Depth_Cn_Inter_Scale, ImgProc_Resize, Combine(
             cv::gpu::resize(d_src, d_dst, cv::Size(), f, f, interpolation);
         }
     }
+    else
+    {
+        cv::Mat dst;
+
+        cv::resize(src, dst, cv::Size(), f, f, interpolation);
+
+        TEST_CYCLE()
+        {
+            cv::resize(src, dst, cv::Size(), f, f, interpolation);
+        }
+    }
+}
 
 //////////////////////////////////////////////////////////////////////
 // ResizeArea
@@ -151,6 +179,8 @@ PERF_TEST_P(Sz_Depth_Cn_Scale, ImgProc_ResizeArea, Combine(
     cv::Mat src(size, type);
     fillRandom(src);
 
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_dst;
 
@@ -161,6 +191,18 @@ PERF_TEST_P(Sz_Depth_Cn_Scale, ImgProc_ResizeArea, Combine(
             cv::gpu::resize(d_src, d_dst, cv::Size(), f, f, interpolation);
         }
     }
+    else
+    {
+        cv::Mat dst;
+
+        cv::resize(src, dst, cv::Size(), f, f, interpolation);
+
+        TEST_CYCLE()
+        {
+            cv::resize(src, dst, cv::Size(), f, f, interpolation);
+        }
+    }
+}
 
 //////////////////////////////////////////////////////////////////////
 // WarpAffine
@@ -174,6 +216,8 @@ PERF_TEST_P(Sz_Depth_Cn_Inter_Border, ImgProc_WarpAffine, Combine(
     Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)),
     ALL_BORDER_MODES))
 {
+    declare.time(20.0);
+
     cv::Size size = GET_PARAM(0);
     int depth = GET_PARAM(1);
     int channels = GET_PARAM(2);
@@ -190,6 +234,8 @@ PERF_TEST_P(Sz_Depth_Cn_Inter_Border, ImgProc_WarpAffine, Combine(
                          {std::sin(aplha),  std::cos(aplha), 0}};
     cv::Mat M(2, 3, CV_64F, (void*) mat);
 
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_dst;
 
@@ -200,6 +246,18 @@ PERF_TEST_P(Sz_Depth_Cn_Inter_Border, ImgProc_WarpAffine, Combine(
             cv::gpu::warpAffine(d_src, d_dst, M, size, interpolation, borderMode);
         }
     }
+    else
+    {
+        cv::Mat dst;
+
+        cv::warpAffine(src, dst, M, size, interpolation, borderMode);
+
+        TEST_CYCLE()
+        {
+            cv::warpAffine(src, dst, M, size, interpolation, borderMode);
+        }
+    }
+}
 
 //////////////////////////////////////////////////////////////////////
 // WarpPerspective
@@ -211,6 +269,8 @@ PERF_TEST_P(Sz_Depth_Cn_Inter_Border, ImgProc_WarpPerspective, Combine(
     Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)),
     ALL_BORDER_MODES))
 {
+    declare.time(20.0);
+
     cv::Size size = GET_PARAM(0);
     int depth = GET_PARAM(1);
     int channels = GET_PARAM(2);
@@ -228,6 +288,8 @@ PERF_TEST_P(Sz_Depth_Cn_Inter_Border, ImgProc_WarpPerspective, Combine(
                          {0.0,              0.0,             1.0}};
     cv::Mat M(3, 3, CV_64F, (void*) mat);
 
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_dst;
 
@@ -238,6 +300,18 @@ PERF_TEST_P(Sz_Depth_Cn_Inter_Border, ImgProc_WarpPerspective, Combine(
             cv::gpu::warpPerspective(d_src, d_dst, M, size, interpolation, borderMode);
         }
     }
+    else
+    {
+        cv::Mat dst;
+
+        cv::warpPerspective(src, dst, M, size, interpolation, borderMode);
+
+        TEST_CYCLE()
+        {
+            cv::warpPerspective(src, dst, M, size, interpolation, borderMode);
+        }
+    }
+}
 
 //////////////////////////////////////////////////////////////////////
 // CopyMakeBorder
@@ -260,6 +334,8 @@ PERF_TEST_P(Sz_Depth_Cn_Border, ImgProc_CopyMakeBorder, Combine(
     cv::Mat src(size, type);
     fillRandom(src);
 
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_dst;
 
@@ -270,6 +346,18 @@ PERF_TEST_P(Sz_Depth_Cn_Border, ImgProc_CopyMakeBorder, Combine(
             cv::gpu::copyMakeBorder(d_src, d_dst, 5, 5, 5, 5, borderMode);
         }
     }
+    else
+    {
+        cv::Mat dst;
+
+        cv::copyMakeBorder(src, dst, 5, 5, 5, 5, borderMode);
+
+        TEST_CYCLE()
+        {
+            cv::copyMakeBorder(src, dst, 5, 5, 5, 5, borderMode);
+        }
+    }
+}
 
 //////////////////////////////////////////////////////////////////////
 // Threshold
@@ -291,6 +379,8 @@ PERF_TEST_P(Sz_Depth_Op, ImgProc_Threshold, Combine(
     cv::Mat src(size, depth);
     fillRandom(src);
 
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_dst;
 
@@ -301,6 +391,18 @@ PERF_TEST_P(Sz_Depth_Op, ImgProc_Threshold, Combine(
             cv::gpu::threshold(d_src, d_dst, 100.0, 255.0, threshOp);
         }
     }
+    else
+    {
+        cv::Mat dst;
+
+        cv::threshold(src, dst, 100.0, 255.0, threshOp);
+
+        TEST_CYCLE()
+        {
+            cv::threshold(src, dst, 100.0, 255.0, threshOp);
+        }
+    }
+}
 
 //////////////////////////////////////////////////////////////////////
 // Integral
@@ -312,6 +414,8 @@ PERF_TEST_P(Sz, ImgProc_Integral, GPU_TYPICAL_MAT_SIZES)
     cv::Mat src(size, CV_8UC1);
     fillRandom(src);
 
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_dst;
         cv::gpu::GpuMat d_buf;
@@ -323,6 +427,18 @@ PERF_TEST_P(Sz, ImgProc_Integral, GPU_TYPICAL_MAT_SIZES)
             cv::gpu::integralBuffered(d_src, d_dst, d_buf);
         }
     }
+    else
+    {
+        cv::Mat dst;
+
+        cv::integral(src, dst);
+
+        TEST_CYCLE()
+        {
+            cv::integral(src, dst);
+        }
+    }
+}
 
 //////////////////////////////////////////////////////////////////////
 // IntegralSqr
@@ -334,6 +450,8 @@ PERF_TEST_P(Sz, ImgProc_IntegralSqr, GPU_TYPICAL_MAT_SIZES)
     cv::Mat src(size, CV_8UC1);
     fillRandom(src);
 
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_dst;
 
@@ -344,6 +462,11 @@ PERF_TEST_P(Sz, ImgProc_IntegralSqr, GPU_TYPICAL_MAT_SIZES)
             cv::gpu::sqrIntegral(d_src, d_dst);
         }
     }
+    else
+    {
+        FAIL();
+    }
+}
 
 //////////////////////////////////////////////////////////////////////
 // HistEvenC1
@@ -356,6 +479,8 @@ PERF_TEST_P(Sz_Depth, ImgProc_HistEvenC1, Combine(GPU_TYPICAL_MAT_SIZES, Values(
     cv::Mat src(size, depth);
     fillRandom(src);
 
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_hist;
         cv::gpu::GpuMat d_buf;
@@ -367,6 +492,24 @@ PERF_TEST_P(Sz_Depth, ImgProc_HistEvenC1, Combine(GPU_TYPICAL_MAT_SIZES, Values(
             cv::gpu::histEven(d_src, d_hist, d_buf, 30, 0, 180);
         }
     }
+    else
+    {
+        int hbins = 30;
+        float hranges[] = {0.0f, 180.0f};
+        int histSize[] = {hbins};
+        const float* ranges[] = {hranges};
+        int channels[] = {0};
+
+        cv::Mat hist;
+
+        cv::calcHist(&src, 1, channels, cv::Mat(), hist, 1, histSize, ranges);
+
+        TEST_CYCLE()
+        {
+            cv::calcHist(&src, 1, channels, cv::Mat(), hist, 1, histSize, ranges);
+        }
+    }
+}
 
 //////////////////////////////////////////////////////////////////////
 // HistEvenC4
@@ -383,6 +526,8 @@ PERF_TEST_P(Sz_Depth, ImgProc_HistEvenC4, Combine(GPU_TYPICAL_MAT_SIZES, Values(
     int lowerLevel[] = {0, 0, 0, 0};
     int upperLevel[] = {180, 180, 180, 180};
 
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_hist[4];
         cv::gpu::GpuMat d_buf;
@@ -394,6 +539,11 @@ PERF_TEST_P(Sz_Depth, ImgProc_HistEvenC4, Combine(GPU_TYPICAL_MAT_SIZES, Values(
             cv::gpu::histEven(d_src, d_hist, d_buf, histSize, lowerLevel, upperLevel);
         }
     }
+    else
+    {
+        FAIL();
+    }
+}
 
 //////////////////////////////////////////////////////////////////////
 // CalcHist
@@ -405,6 +555,8 @@ PERF_TEST_P(Sz, ImgProc_CalcHist, GPU_TYPICAL_MAT_SIZES)
     cv::Mat src(size, CV_8UC1);
     fillRandom(src);
 
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_hist;
         cv::gpu::GpuMat d_buf;
@@ -416,6 +568,11 @@ PERF_TEST_P(Sz, ImgProc_CalcHist, GPU_TYPICAL_MAT_SIZES)
             cv::gpu::calcHist(d_src, d_hist, d_buf);
         }
     }
+    else
+    {
+        FAIL();
+    }
+}
 
 //////////////////////////////////////////////////////////////////////
 // EqualizeHist
@@ -427,6 +584,8 @@ PERF_TEST_P(Sz, ImgProc_EqualizeHist, GPU_TYPICAL_MAT_SIZES)
     cv::Mat src(size, CV_8UC1);
     fillRandom(src);
 
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_dst;
         cv::gpu::GpuMat d_hist;
@@ -439,6 +598,18 @@ PERF_TEST_P(Sz, ImgProc_EqualizeHist, GPU_TYPICAL_MAT_SIZES)
             cv::gpu::equalizeHist(d_src, d_dst, d_hist, d_buf);
         }
     }
+    else
+    {
+        cv::Mat dst;
+
+        cv::equalizeHist(src, dst);
+
+        TEST_CYCLE()
+        {
+            cv::equalizeHist(src, dst);
+        }
+    }
+}
 
 //////////////////////////////////////////////////////////////////////
 // ColumnSum
@@ -450,6 +621,8 @@ PERF_TEST_P(Sz, ImgProc_ColumnSum, GPU_TYPICAL_MAT_SIZES)
     cv::Mat src(size, CV_32FC1);
     fillRandom(src);
 
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_dst;
 
@@ -460,6 +633,11 @@ PERF_TEST_P(Sz, ImgProc_ColumnSum, GPU_TYPICAL_MAT_SIZES)
             cv::gpu::columnSum(d_src, d_dst);
         }
     }
+    else
+    {
+        FAIL();
+    }
+}
 
 //////////////////////////////////////////////////////////////////////
 // Canny
@@ -478,6 +656,8 @@ PERF_TEST_P(Image_AppertureSz_L2gradient, ImgProc_Canny, Combine(
     cv::Mat image = readImage(fileName, cv::IMREAD_GRAYSCALE);
     ASSERT_FALSE(image.empty());
 
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_image(image);
         cv::gpu::GpuMat d_dst;
         cv::gpu::CannyBuf d_buf;
@@ -489,6 +669,18 @@ PERF_TEST_P(Image_AppertureSz_L2gradient, ImgProc_Canny, Combine(
             cv::gpu::Canny(d_image, d_buf, d_dst, 50.0, 100.0, apperture_size, useL2gradient);
         }
     }
+    else
+    {
+        cv::Mat dst;
+
+        cv::Canny(image, dst, 50.0, 100.0, apperture_size, useL2gradient);
+
+        TEST_CYCLE()
+        {
+            cv::Canny(image, dst, 50.0, 100.0, apperture_size, useL2gradient);
+        }
+    }
+}
 
 //////////////////////////////////////////////////////////////////////
 // MeanShiftFiltering
@@ -497,7 +689,7 @@ DEF_PARAM_TEST_1(Image, string);
 
 PERF_TEST_P(Image, ImgProc_MeanShiftFiltering, Values<string>("gpu/meanshift/cones.png"))
 {
-    declare.time(5.0);
+    declare.time(15.0);
 
     cv::Mat img = readImage(GetParam());
     ASSERT_FALSE(img.empty());
@@ -505,6 +697,8 @@ PERF_TEST_P(Image, ImgProc_MeanShiftFiltering, Values<string>("gpu/meanshift/con
     cv::Mat rgba;
     cv::cvtColor(img, rgba, cv::COLOR_BGR2BGRA);
 
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_src(rgba);
         cv::gpu::GpuMat d_dst;
 
@@ -515,6 +709,18 @@ PERF_TEST_P(Image, ImgProc_MeanShiftFiltering, Values<string>("gpu/meanshift/con
             cv::gpu::meanShiftFiltering(d_src, d_dst, 50, 50);
         }
     }
+    else
+    {
+        cv::Mat dst;
+
+        cv::pyrMeanShiftFiltering(img, dst, 50, 50);
+
+        TEST_CYCLE()
+        {
+            cv::pyrMeanShiftFiltering(img, dst, 50, 50);
+        }
+    }
+}
 
 //////////////////////////////////////////////////////////////////////
 // MeanShiftProc
@@ -529,6 +735,8 @@ PERF_TEST_P(Image, ImgProc_MeanShiftProc, Values<string>("gpu/meanshift/cones.pn
     cv::Mat rgba;
     cv::cvtColor(img, rgba, cv::COLOR_BGR2BGRA);
 
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_src(rgba);
         cv::gpu::GpuMat d_dstr;
         cv::gpu::GpuMat d_dstsp;
@@ -540,6 +748,11 @@ PERF_TEST_P(Image, ImgProc_MeanShiftProc, Values<string>("gpu/meanshift/cones.pn
             cv::gpu::meanShiftProc(d_src, d_dstr, d_dstsp, 50, 50);
         }
     }
+    else
+    {
+        FAIL();
+    }
+}
 
 //////////////////////////////////////////////////////////////////////
 // MeanShiftSegmentation
@@ -556,6 +769,8 @@ PERF_TEST_P(Image, ImgProc_MeanShiftSegmentation, Values<string>("gpu/meanshift/
 
     cv::Mat dst;
 
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_src(rgba);
 
         cv::gpu::meanShiftSegmentation(d_src, dst, 10, 10, 20);
@@ -565,6 +780,11 @@ PERF_TEST_P(Image, ImgProc_MeanShiftSegmentation, Values<string>("gpu/meanshift/
             cv::gpu::meanShiftSegmentation(d_src, dst, 10, 10, 20);
         }
     }
+    else
+    {
+        FAIL();
+    }
+}
 
 //////////////////////////////////////////////////////////////////////
 // BlendLinear
@@ -583,6 +803,8 @@ PERF_TEST_P(Sz_Depth_Cn, ImgProc_BlendLinear, Combine(GPU_TYPICAL_MAT_SIZES, Val
     cv::Mat img2(size, type);
     fillRandom(img2);
 
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_img1(img1);
         cv::gpu::GpuMat d_img2(img2);
         cv::gpu::GpuMat d_weights1(size, CV_32FC1, cv::Scalar::all(0.5));
@@ -596,6 +818,11 @@ PERF_TEST_P(Sz_Depth_Cn, ImgProc_BlendLinear, Combine(GPU_TYPICAL_MAT_SIZES, Val
             cv::gpu::blendLinear(d_img1, d_img2, d_weights1, d_weights2, d_dst);
         }
     }
+    else
+    {
+        FAIL();
+    }
+}
 
 //////////////////////////////////////////////////////////////////////
 // Convolve
@@ -604,17 +831,25 @@ DEF_PARAM_TEST(Sz_KernelSz_Ccorr, cv::Size, int, bool);
 
 PERF_TEST_P(Sz_KernelSz_Ccorr, ImgProc_Convolve, Combine(GPU_TYPICAL_MAT_SIZES, Values(17, 27, 32, 64), Bool()))
 {
-    declare.time(2.0);
+    declare.time(10.0);
 
     cv::Size size = GET_PARAM(0);
     int templ_size = GET_PARAM(1);
     bool ccorr = GET_PARAM(2);
 
+    cv::Mat image(size, CV_32FC1);
+    image.setTo(1.0);
+
+    cv::Mat templ(templ_size, templ_size, CV_32FC1);
+    templ.setTo(1.0);
+
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_image = cv::gpu::createContinuous(size, CV_32FC1);
-    d_image.setTo(cv::Scalar(1.0));
+        d_image.upload(image);
 
         cv::gpu::GpuMat d_templ = cv::gpu::createContinuous(templ_size, templ_size, CV_32FC1);
-    d_templ.setTo(cv::Scalar(1.0));
+        d_templ.upload(templ);
 
         cv::gpu::GpuMat d_dst;
         cv::gpu::ConvolveBuf d_buf;
@@ -626,6 +861,20 @@ PERF_TEST_P(Sz_KernelSz_Ccorr, ImgProc_Convolve, Combine(GPU_TYPICAL_MAT_SIZES,
             cv::gpu::convolve(d_image, d_templ, d_dst, ccorr, d_buf);
         }
     }
+    else
+    {
+        ASSERT_FALSE(ccorr);
+
+        cv::Mat dst;
+
+        cv::filter2D(image, dst, image.depth(), templ);
+
+        TEST_CYCLE()
+        {
+            cv::filter2D(image, dst, image.depth(), templ);
+        }
+    }
+}
 
 ////////////////////////////////////////////////////////////////////////////////
 // MatchTemplate8U
@@ -652,6 +901,8 @@ PERF_TEST_P(Sz_TemplateSz_Cn_Method, ImgProc_MatchTemplate8U, Combine(
     cv::Mat templ(templ_size, CV_MAKE_TYPE(CV_8U, cn));
     fillRandom(templ);
 
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_image(image);
         cv::gpu::GpuMat d_templ(templ);
         cv::gpu::GpuMat d_dst;
@@ -662,6 +913,18 @@ PERF_TEST_P(Sz_TemplateSz_Cn_Method, ImgProc_MatchTemplate8U, Combine(
         {
             cv::gpu::matchTemplate(d_image, d_templ, d_dst, method);
         }
+    }
+    else
+    {
+        cv::Mat dst;
+
+        cv::matchTemplate(image, templ, dst, method);
+
+        TEST_CYCLE()
+        {
+            cv::matchTemplate(image, templ, dst, method);
+        }
+    }
 };
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -684,6 +947,8 @@ PERF_TEST_P(Sz_TemplateSz_Cn_Method, ImgProc_MatchTemplate32F, Combine(
     cv::Mat templ(templ_size, CV_MAKE_TYPE(CV_32F, cn));
     fillRandom(templ);
 
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_image(image);
         cv::gpu::GpuMat d_templ(templ);
         cv::gpu::GpuMat d_dst;
@@ -694,6 +959,18 @@ PERF_TEST_P(Sz_TemplateSz_Cn_Method, ImgProc_MatchTemplate32F, Combine(
         {
             cv::gpu::matchTemplate(d_image, d_templ, d_dst, method);
         }
+    }
+    else
+    {
+        cv::Mat dst;
+
+        cv::matchTemplate(image, templ, dst, method);
+
+        TEST_CYCLE()
+        {
+            cv::matchTemplate(image, templ, dst, method);
+        }
+    }
 };
 
 //////////////////////////////////////////////////////////////////////
@@ -716,6 +993,8 @@ PERF_TEST_P(Sz_Flags, ImgProc_MulSpectrums, Combine(
     cv::Mat b(size, CV_32FC2);
     fillRandom(b, 0, 100);
 
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_a(a);
         cv::gpu::GpuMat d_b(b);
         cv::gpu::GpuMat d_dst;
@@ -727,6 +1006,18 @@ PERF_TEST_P(Sz_Flags, ImgProc_MulSpectrums, Combine(
             cv::gpu::mulSpectrums(d_a, d_b, d_dst, flag);
         }
     }
+    else
+    {
+        cv::Mat dst;
+
+        cv::mulSpectrums(a, b, dst, flag);
+
+        TEST_CYCLE()
+        {
+            cv::mulSpectrums(a, b, dst, flag);
+        }
+    }
+}
 
 //////////////////////////////////////////////////////////////////////
 // MulAndScaleSpectrums
@@ -743,6 +1034,8 @@ PERF_TEST_P(Sz, ImgProc_MulAndScaleSpectrums, GPU_TYPICAL_MAT_SIZES)
     cv::Mat src2(size, CV_32FC2);
     fillRandom(src2, 0, 100);
 
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_src1(src1);
         cv::gpu::GpuMat d_src2(src2);
         cv::gpu::GpuMat d_dst;
@@ -754,6 +1047,11 @@ PERF_TEST_P(Sz, ImgProc_MulAndScaleSpectrums, GPU_TYPICAL_MAT_SIZES)
             cv::gpu::mulAndScaleSpectrums(d_src1, d_src2, d_dst, cv::DFT_ROWS, scale, false);
         }
     }
+    else
+    {
+        FAIL();
+    }
+}
 
 //////////////////////////////////////////////////////////////////////
 // Dft
@@ -762,7 +1060,7 @@ PERF_TEST_P(Sz_Flags, ImgProc_Dft, Combine(
     GPU_TYPICAL_MAT_SIZES,
     Values(0, DftFlags(cv::DFT_ROWS), DftFlags(cv::DFT_INVERSE))))
 {
-    declare.time(2.0);
+    declare.time(10.0);
 
     cv::Size size = GET_PARAM(0);
     int flag = GET_PARAM(1);
@@ -770,6 +1068,8 @@ PERF_TEST_P(Sz_Flags, ImgProc_Dft, Combine(
     cv::Mat src(size, CV_32FC2);
     fillRandom(src, 0, 100);
 
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_dst;
 
@@ -780,6 +1080,18 @@ PERF_TEST_P(Sz_Flags, ImgProc_Dft, Combine(
             cv::gpu::dft(d_src, d_dst, size, flag);
         }
     }
+    else
+    {
+        cv::Mat dst;
+
+        cv::dft(src, dst, flag);
+
+        TEST_CYCLE()
+        {
+            cv::dft(src, dst, flag);
+        }
+    }
+}
 
 //////////////////////////////////////////////////////////////////////
 // CornerHarris
@@ -793,8 +1105,6 @@ PERF_TEST_P(Image_Type_Border_BlockSz_ApertureSz, ImgProc_CornerHarris, Combine(
     Values(3, 5, 7),
     Values(0, 3, 5, 7)))
 {
-    double k = 0.5;
-
     string fileName = GET_PARAM(0);
     int type = GET_PARAM(1);
     int borderMode = GET_PARAM(2);
@@ -803,9 +1113,12 @@ PERF_TEST_P(Image_Type_Border_BlockSz_ApertureSz, ImgProc_CornerHarris, Combine(
 
     cv::Mat img = readImage(fileName, cv::IMREAD_GRAYSCALE);
     ASSERT_FALSE(img.empty());
-
     img.convertTo(img, type, type == CV_32F ? 1.0 / 255.0 : 1.0);
 
+    double k = 0.5;
+
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_img(img);
         cv::gpu::GpuMat d_dst;
         cv::gpu::GpuMat d_Dx;
@@ -819,6 +1132,18 @@ PERF_TEST_P(Image_Type_Border_BlockSz_ApertureSz, ImgProc_CornerHarris, Combine(
             cv::gpu::cornerHarris(d_img, d_dst, d_Dx, d_Dy, d_buf, blockSize, apertureSize, k, borderMode);
         }
     }
+    else
+    {
+        cv::Mat dst;
+
+        cv::cornerHarris(img, dst, blockSize, apertureSize, k, borderMode);
+
+        TEST_CYCLE()
+        {
+            cv::cornerHarris(img, dst, blockSize, apertureSize, k, borderMode);
+        }
+    }
+}
 
 //////////////////////////////////////////////////////////////////////
 // CornerMinEigenVal
@@ -841,6 +1166,8 @@ PERF_TEST_P(Image_Type_Border_BlockSz_ApertureSz, ImgProc_CornerMinEigenVal, Com
 
     img.convertTo(img, type, type == CV_32F ? 1.0 / 255.0 : 1.0);
 
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_img(img);
         cv::gpu::GpuMat d_dst;
         cv::gpu::GpuMat d_Dx;
@@ -854,6 +1181,18 @@ PERF_TEST_P(Image_Type_Border_BlockSz_ApertureSz, ImgProc_CornerMinEigenVal, Com
             cv::gpu::cornerMinEigenVal(d_img, d_dst, d_Dx, d_Dy, d_buf, blockSize, apertureSize, borderMode);
         }
     }
+    else
+    {
+        cv::Mat dst;
+
+        cv::cornerMinEigenVal(img, dst, blockSize, apertureSize, borderMode);
+
+        TEST_CYCLE()
+        {
+            cv::cornerMinEigenVal(img, dst, blockSize, apertureSize, borderMode);
+        }
+    }
+}
 
 //////////////////////////////////////////////////////////////////////
 // BuildWarpPlaneMaps
@@ -866,6 +1205,8 @@ PERF_TEST_P(Sz, ImgProc_BuildWarpPlaneMaps, GPU_TYPICAL_MAT_SIZES)
     cv::Mat R = cv::Mat::ones(3, 3, CV_32FC1);
     cv::Mat T = cv::Mat::zeros(1, 3, CV_32F);
 
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_map_x;
         cv::gpu::GpuMat d_map_y;
 
@@ -876,6 +1217,11 @@ PERF_TEST_P(Sz, ImgProc_BuildWarpPlaneMaps, GPU_TYPICAL_MAT_SIZES)
             cv::gpu::buildWarpPlaneMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, T, 1.0, d_map_x, d_map_y);
         }
     }
+    else
+    {
+        FAIL();
+    }
+}
 
 //////////////////////////////////////////////////////////////////////
 // BuildWarpCylindricalMaps
@@ -887,6 +1233,8 @@ PERF_TEST_P(Sz, ImgProc_BuildWarpCylindricalMaps, GPU_TYPICAL_MAT_SIZES)
     cv::Mat K = cv::Mat::eye(3, 3, CV_32FC1);
     cv::Mat R = cv::Mat::ones(3, 3, CV_32FC1);
 
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_map_x;
         cv::gpu::GpuMat d_map_y;
 
@@ -897,6 +1245,11 @@ PERF_TEST_P(Sz, ImgProc_BuildWarpCylindricalMaps, GPU_TYPICAL_MAT_SIZES)
             cv::gpu::buildWarpCylindricalMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, 1.0, d_map_x, d_map_y);
         }
     }
+    else
+    {
+        FAIL();
+    }
+}
 
 //////////////////////////////////////////////////////////////////////
 // BuildWarpSphericalMaps
@@ -908,6 +1261,8 @@ PERF_TEST_P(Sz, ImgProc_BuildWarpSphericalMaps, GPU_TYPICAL_MAT_SIZES)
     cv::Mat K = cv::Mat::eye(3, 3, CV_32FC1);
     cv::Mat R = cv::Mat::ones(3, 3, CV_32FC1);
 
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_map_x;
         cv::gpu::GpuMat d_map_y;
 
@@ -918,6 +1273,11 @@ PERF_TEST_P(Sz, ImgProc_BuildWarpSphericalMaps, GPU_TYPICAL_MAT_SIZES)
             cv::gpu::buildWarpSphericalMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, 1.0, d_map_x, d_map_y);
         }
     }
+    else
+    {
+        FAIL();
+    }
+}
 
 //////////////////////////////////////////////////////////////////////
 // Rotate
@@ -940,6 +1300,8 @@ PERF_TEST_P(Sz_Depth_Cn_Inter, ImgProc_Rotate, Combine(
     cv::Mat src(size, type);
     fillRandom(src);
 
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_dst;
 
@@ -950,6 +1312,11 @@ PERF_TEST_P(Sz_Depth_Cn_Inter, ImgProc_Rotate, Combine(
             cv::gpu::rotate(d_src, d_dst, size, 30.0, 0, 0, interpolation);
         }
     }
+    else
+    {
+        FAIL();
+    }
+}
 
 //////////////////////////////////////////////////////////////////////
 // PyrDown
@@ -968,6 +1335,8 @@ PERF_TEST_P(Sz_Depth_Cn, ImgProc_PyrDown, Combine(
     cv::Mat src(size, type);
     fillRandom(src);
 
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_dst;
 
@@ -978,6 +1347,18 @@ PERF_TEST_P(Sz_Depth_Cn, ImgProc_PyrDown, Combine(
             cv::gpu::pyrDown(d_src, d_dst);
         }
     }
+    else
+    {
+        cv::Mat dst;
+
+        cv::pyrDown(src, dst);
+
+        TEST_CYCLE()
+        {
+            cv::pyrDown(src, dst);
+        }
+    }
+}
 
 //////////////////////////////////////////////////////////////////////
 // PyrUp
@@ -996,6 +1377,8 @@ PERF_TEST_P(Sz_Depth_Cn, ImgProc_PyrUp, Combine(
     cv::Mat src(size, type);
     fillRandom(src);
 
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_dst;
 
@@ -1006,6 +1389,18 @@ PERF_TEST_P(Sz_Depth_Cn, ImgProc_PyrUp, Combine(
             cv::gpu::pyrUp(d_src, d_dst);
         }
     }
+    else
+    {
+        cv::Mat dst;
+
+        cv::pyrUp(src, dst);
+
+        TEST_CYCLE()
+        {
+            cv::pyrUp(src, dst);
+        }
+    }
+}
 
 //////////////////////////////////////////////////////////////////////
 // CvtColor
@@ -1049,6 +1444,8 @@ PERF_TEST_P(Sz_Depth_Code, ImgProc_CvtColor, Combine(
     cv::Mat src(size, CV_MAKETYPE(depth, info.scn));
     fillRandom(src);
 
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_dst;
 
@@ -1059,6 +1456,18 @@ PERF_TEST_P(Sz_Depth_Code, ImgProc_CvtColor, Combine(
             cv::gpu::cvtColor(d_src, d_dst, info.code, info.dcn);
         }
     }
+    else
+    {
+        cv::Mat dst;
+
+        cv::cvtColor(src, dst, info.code, info.dcn);
+
+        TEST_CYCLE()
+        {
+            cv::cvtColor(src, dst, info.code, info.dcn);
+        }
+    }
+}
 
 //////////////////////////////////////////////////////////////////////
 // SwapChannels
@@ -1072,6 +1481,8 @@ PERF_TEST_P(Sz, ImgProc_SwapChannels, GPU_TYPICAL_MAT_SIZES)
 
     const int dstOrder[] = {2, 1, 0, 3};
 
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_src(src);
 
         cv::gpu::swapChannels(d_src, dstOrder);
@@ -1081,6 +1492,11 @@ PERF_TEST_P(Sz, ImgProc_SwapChannels, GPU_TYPICAL_MAT_SIZES)
             cv::gpu::swapChannels(d_src, dstOrder);
         }
     }
+    else
+    {
+        FAIL();
+    }
+}
 
 //////////////////////////////////////////////////////////////////////
 // AlphaComp
@@ -1102,6 +1518,8 @@ PERF_TEST_P(Sz_Type_Op, ImgProc_AlphaComp, Combine(GPU_TYPICAL_MAT_SIZES, Values
     cv::Mat img2(size, type);
     fillRandom(img2);
 
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_img1(img1);
         cv::gpu::GpuMat d_img2(img2);
         cv::gpu::GpuMat d_dst;
@@ -1113,6 +1531,11 @@ PERF_TEST_P(Sz_Type_Op, ImgProc_AlphaComp, Combine(GPU_TYPICAL_MAT_SIZES, Values
             cv::gpu::alphaComp(d_img1, d_img2, d_dst, alpha_op);
         }
     }
+    else
+    {
+        FAIL();
+    }
+}
 
 //////////////////////////////////////////////////////////////////////
 // ImagePyramidBuild
@@ -1128,6 +1551,8 @@ PERF_TEST_P(Sz_Depth_Cn, ImgProc_ImagePyramidBuild, Combine(GPU_TYPICAL_MAT_SIZE
     cv::Mat src(size, type);
     fillRandom(src);
 
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_src(src);
 
         cv::gpu::ImagePyramid d_pyr;
@@ -1139,6 +1564,11 @@ PERF_TEST_P(Sz_Depth_Cn, ImgProc_ImagePyramidBuild, Combine(GPU_TYPICAL_MAT_SIZE
             d_pyr.build(d_src, 5);
         }
     }
+    else
+    {
+        FAIL();
+    }
+}
 
 //////////////////////////////////////////////////////////////////////
 // ImagePyramidGetLayer
@@ -1156,6 +1586,8 @@ PERF_TEST_P(Sz_Depth_Cn, ImgProc_ImagePyramidGetLayer, Combine(GPU_TYPICAL_MAT_S
 
     cv::Size dstSize(size.width / 2 + 10, size.height / 2 + 10);
 
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_dst;
 
@@ -1168,6 +1600,11 @@ PERF_TEST_P(Sz_Depth_Cn, ImgProc_ImagePyramidGetLayer, Combine(GPU_TYPICAL_MAT_S
             d_pyr.getLayer(d_dst, dstSize);
         }
     }
+    else
+    {
+        FAIL();
+    }
+}
 
 //////////////////////////////////////////////////////////////////////
 // HoughLines
@@ -1197,6 +1634,8 @@ PERF_TEST_P(Sz_DoSort, ImgProc_HoughLines, Combine(GPU_TYPICAL_MAT_SIZES, Bool()
         cv::line(src, p1, p2, cv::Scalar::all(255), 2);
     }
 
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_lines;
         cv::gpu::GpuMat d_accum;
@@ -1209,5 +1648,16 @@ PERF_TEST_P(Sz_DoSort, ImgProc_HoughLines, Combine(GPU_TYPICAL_MAT_SIZES, Bool()
             cv::gpu::HoughLines(d_src, d_lines, d_accum, d_buf, rho, theta, threshold, doSort);
         }
     }
+    else
+    {
+        std::vector<cv::Vec2f> lines;
+        cv::HoughLines(src, lines, rho, theta, threshold);
+
+        TEST_CYCLE()
+        {
+            cv::HoughLines(src, lines, rho, theta, threshold);
+        }
+    }
+}
 
 } // namespace

modules/gpu/perf/perf_labeling.cpp

@@ -7,12 +7,102 @@ namespace {
 
 DEF_PARAM_TEST_1(Image, string);
 
+struct GreedyLabeling
+{
+    struct dot
+    {
+        int x;
+        int y;
+
+        static dot make(int i, int j)
+        {
+            dot d; d.x = i; d.y = j;
+            return d;
+        }
+    };
+
+    struct InInterval
+    {
+        InInterval(const int& _lo, const int& _hi) : lo(-_lo), hi(_hi) {};
+        const int lo, hi;
+
+        bool operator() (const unsigned char a, const unsigned char b) const
+        {
+            int d = a - b;
+            return lo <= d && d <= hi;
+        }
+    };
+
+    GreedyLabeling(cv::Mat img)
+    : image(img), _labels(image.size(), CV_32SC1, cv::Scalar::all(-1)) {stack = new dot[image.cols * image.rows];}
+
+    ~GreedyLabeling(){delete[] stack;}
+
+    void operator() (cv::Mat labels) const
+    {
+        labels.setTo(cv::Scalar::all(-1));
+        InInterval inInt(0, 2);
+        int cc = -1;
+
+        int* dist_labels = (int*)labels.data;
+        int pitch = labels.step1();
+
+        unsigned char* source = (unsigned char*)image.data;
+        int width = image.cols;
+        int height = image.rows;
+
+        for (int j = 0; j < image.rows; ++j)
+            for (int i = 0; i < image.cols; ++i)
+            {
+                if (dist_labels[j * pitch + i] != -1) continue;
+
+                dot* top = stack;
+                dot p = dot::make(i, j);
+                cc++;
+
+                dist_labels[j * pitch + i] = cc;
+
+                while (top >= stack)
+                {
+                    int*  dl = &dist_labels[p.y * pitch + p.x];
+                    unsigned char* sp = &source[p.y * image.step1() + p.x];
+
+                    dl[0] = cc;
+
+                    //right
+                    if( p.x < (width - 1) && dl[ +1] == -1 && inInt(sp[0], sp[+1]))
+                        *top++ = dot::make(p.x + 1, p.y);
+
+                    //left
+                    if( p.x > 0 && dl[-1] == -1 && inInt(sp[0], sp[-1]))
+                        *top++ = dot::make(p.x - 1, p.y);
+
+                    //bottom
+                    if( p.y < (height - 1) && dl[+pitch] == -1 && inInt(sp[0], sp[+image.step1()]))
+                        *top++ = dot::make(p.x, p.y + 1);
+
+                    //top
+                    if( p.y > 0 && dl[-pitch] == -1 && inInt(sp[0], sp[-image.step1()]))
+                        *top++ = dot::make(p.x, p.y - 1);
+
+                    p = *--top;
+                }
+            }
+    }
+
+    cv::Mat image;
+    cv::Mat _labels;
+    dot* stack;
+};
+
 PERF_TEST_P(Image, Labeling_ConnectedComponents, Values<string>("gpu/labeling/aloe-disp.png"))
 {
+    declare.time(1.0);
+
     cv::Mat image = readImage(GetParam(), cv::IMREAD_GRAYSCALE);
 
-    // cv::threshold(image, image, 150, 255, CV_THRESH_BINARY);
+    if (runOnGpu)
-
+    {
         cv::gpu::GpuMat mask;
         mask.create(image.rows, image.cols, CV_8UC1);
 
@@ -23,12 +113,24 @@ PERF_TEST_P(Image, Labeling_ConnectedComponents, Values<string>("gpu/labeling/al
 
         ASSERT_NO_THROW(cv::gpu::labelComponents(mask, components));
 
-    declare.time(1.0);
-
         TEST_CYCLE()
         {
             cv::gpu::labelComponents(mask, components);
         }
     }
+    else
+    {
+        GreedyLabeling host(image);
+
+        host(host._labels);
+
+        declare.time(1.0);
+
+        TEST_CYCLE()
+        {
+            host(host._labels);
+        }
+    }
+}
 
 } // namespace

modules/gpu/perf/perf_matop.cpp

@@ -18,6 +18,8 @@ PERF_TEST_P(Sz_Depth_Cn, MatOp_SetTo, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8
 
     cv::Scalar val(1, 2, 3, 4);
 
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_src(size, type);
 
         d_src.setTo(val);
@@ -27,6 +29,18 @@ PERF_TEST_P(Sz_Depth_Cn, MatOp_SetTo, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8
             d_src.setTo(val);
         }
     }
+    else
+    {
+        cv::Mat src(size, type);
+
+        src.setTo(val);
+
+        TEST_CYCLE()
+        {
+            src.setTo(val);
+        }
+    }
+}
 
 //////////////////////////////////////////////////////////////////////
 // SetToMasked
@@ -47,6 +61,8 @@ PERF_TEST_P(Sz_Depth_Cn, MatOp_SetToMasked, Combine(GPU_TYPICAL_MAT_SIZES, Value
 
     cv::Scalar val(1, 2, 3, 4);
 
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_mask(mask);
 
@@ -57,6 +73,16 @@ PERF_TEST_P(Sz_Depth_Cn, MatOp_SetToMasked, Combine(GPU_TYPICAL_MAT_SIZES, Value
             d_src.setTo(val, d_mask);
         }
     }
+    else
+    {
+        src.setTo(val, mask);
+
+        TEST_CYCLE()
+        {
+            src.setTo(val, mask);
+        }
+    }
+}
 
 //////////////////////////////////////////////////////////////////////
 // CopyToMasked
@@ -75,6 +101,8 @@ PERF_TEST_P(Sz_Depth_Cn, MatOp_CopyToMasked, Combine(GPU_TYPICAL_MAT_SIZES, Valu
     cv::Mat mask(size, CV_8UC1);
     fillRandom(mask, 0, 2);
 
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_mask(mask);
         cv::gpu::GpuMat d_dst;
@@ -86,6 +114,18 @@ PERF_TEST_P(Sz_Depth_Cn, MatOp_CopyToMasked, Combine(GPU_TYPICAL_MAT_SIZES, Valu
             d_src.copyTo(d_dst, d_mask);
         }
     }
+    else
+    {
+        cv::Mat dst;
+
+        src.copyTo(dst, mask);
+
+        TEST_CYCLE()
+        {
+            src.copyTo(dst, mask);
+        }
+    }
+}
 
 //////////////////////////////////////////////////////////////////////
 // ConvertTo
@@ -101,6 +141,8 @@ PERF_TEST_P(Sz_2Depth, MatOp_ConvertTo, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV
     cv::Mat src(size, depth1);
     fillRandom(src);
 
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_dst;
 
@@ -111,5 +153,17 @@ PERF_TEST_P(Sz_2Depth, MatOp_ConvertTo, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV
             d_src.convertTo(d_dst, depth2, 0.5, 1.0);
         }
     }
+    else
+    {
+        cv::Mat dst;
+
+        src.convertTo(dst, depth2, 0.5, 1.0);
+
+        TEST_CYCLE()
+        {
+            src.convertTo(dst, depth2, 0.5, 1.0);
+        }
+    }
+}
 
 } // namespace

modules/gpu/perf/perf_objdetect.cpp

@@ -17,6 +17,8 @@ PERF_TEST_P(Image, ObjDetect_HOG, Values<string>("gpu/hog/road.png"))
 
     std::vector<cv::Rect> found_locations;
 
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_img(img);
 
         cv::gpu::HOGDescriptor d_hog;
@@ -29,6 +31,19 @@ PERF_TEST_P(Image, ObjDetect_HOG, Values<string>("gpu/hog/road.png"))
             d_hog.detectMultiScale(d_img, found_locations);
         }
     }
+    else
+    {
+        cv::HOGDescriptor hog;
+        hog.setSVMDetector(cv::gpu::HOGDescriptor::getDefaultPeopleDetector());
+
+        hog.detectMultiScale(img, found_locations);
+
+        TEST_CYCLE()
+        {
+            hog.detectMultiScale(img, found_locations);
+        }
+    }
+}
 
 ///////////////////////////////////////////////////////////////
 // HaarClassifier
@@ -42,8 +57,9 @@ PERF_TEST_P(ImageAndCascade, ObjDetect_HaarClassifier,
     cv::Mat img = readImage(GetParam().first, cv::IMREAD_GRAYSCALE);
     ASSERT_FALSE(img.empty());
 
+    if (runOnGpu)
+    {
         cv::gpu::CascadeClassifier_GPU d_cascade;
-
         ASSERT_TRUE(d_cascade.load(perf::TestBase::getDataPath(GetParam().second)));
 
         cv::gpu::GpuMat d_img(img);
@@ -56,6 +72,21 @@ PERF_TEST_P(ImageAndCascade, ObjDetect_HaarClassifier,
             d_cascade.detectMultiScale(d_img, d_objects_buffer);
         }
     }
+    else
+    {
+        cv::CascadeClassifier cascade;
+        ASSERT_TRUE(cascade.load(perf::TestBase::getDataPath("gpu/perf/haarcascade_frontalface_alt.xml")));
+
+        std::vector<cv::Rect> rects;
+
+        cascade.detectMultiScale(img, rects);
+
+        TEST_CYCLE()
+        {
+            cascade.detectMultiScale(img, rects);
+        }
+    }
+}
 
 ///////////////////////////////////////////////////////////////
 // LBP cascade
@@ -66,8 +97,9 @@ PERF_TEST_P(ImageAndCascade, ObjDetect_LBPClassifier,
     cv::Mat img = readImage(GetParam().first, cv::IMREAD_GRAYSCALE);
     ASSERT_FALSE(img.empty());
 
+    if (runOnGpu)
+    {
         cv::gpu::CascadeClassifier_GPU d_cascade;
-
         ASSERT_TRUE(d_cascade.load(perf::TestBase::getDataPath(GetParam().second)));
 
         cv::gpu::GpuMat d_img(img);
@@ -80,5 +112,20 @@ PERF_TEST_P(ImageAndCascade, ObjDetect_LBPClassifier,
             d_cascade.detectMultiScale(d_img, d_gpu_rects);
         }
     }
+    else
+    {
+        cv::CascadeClassifier cascade;
+        ASSERT_TRUE(cascade.load(perf::TestBase::getDataPath("gpu/lbpcascade/lbpcascade_frontalface.xml")));
+
+        std::vector<cv::Rect> rects;
+
+        cascade.detectMultiScale(img, rects);
+
+        TEST_CYCLE()
+        {
+            cascade.detectMultiScale(img, rects);
+        }
+    }
+}
 
 } // namespace

modules/gpu/perf/perf_video.cpp

@@ -3,6 +3,14 @@
 using namespace std;
 using namespace testing;
 
+namespace cv
+{
+    template<> void Ptr<CvBGStatModel>::delete_obj()
+    {
+        cvReleaseBGStatModel(&obj);
+    }
+}
+
 namespace {
 
 //////////////////////////////////////////////////////
@@ -25,6 +33,8 @@ PERF_TEST_P(ImagePair, Video_BroxOpticalFlow, Values<pair_string>(make_pair("gpu
     frame0.convertTo(frame0, CV_32FC1, 1.0 / 255.0);
     frame1.convertTo(frame1, CV_32FC1, 1.0 / 255.0);
 
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_frame0(frame0);
         cv::gpu::GpuMat d_frame1(frame1);
         cv::gpu::GpuMat d_u;
@@ -40,6 +50,11 @@ PERF_TEST_P(ImagePair, Video_BroxOpticalFlow, Values<pair_string>(make_pair("gpu
             d_flow(d_frame0, d_frame1, d_u, d_v);
         }
     }
+    else
+    {
+        FAIL();
+    }
+}
 
 //////////////////////////////////////////////////////
 // InterpolateFrames
@@ -55,6 +70,8 @@ PERF_TEST_P(ImagePair, Video_InterpolateFrames, Values<pair_string>(make_pair("g
     frame0.convertTo(frame0, CV_32FC1, 1.0 / 255.0);
     frame1.convertTo(frame1, CV_32FC1, 1.0 / 255.0);
 
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_frame0(frame0);
         cv::gpu::GpuMat d_frame1(frame1);
         cv::gpu::GpuMat d_fu, d_fv;
@@ -76,6 +93,11 @@ PERF_TEST_P(ImagePair, Video_InterpolateFrames, Values<pair_string>(make_pair("g
             cv::gpu::interpolateFrames(d_frame0, d_frame1, d_fu, d_fv, d_bu, d_bv, 0.5f, d_newFrame, d_buf);
         }
     }
+    else
+    {
+        FAIL();
+    }
+}
 
 //////////////////////////////////////////////////////
 // CreateOpticalFlowNeedleMap
@@ -91,6 +113,8 @@ PERF_TEST_P(ImagePair, Video_CreateOpticalFlowNeedleMap, Values<pair_string>(mak
     frame0.convertTo(frame0, CV_32FC1, 1.0 / 255.0);
     frame1.convertTo(frame1, CV_32FC1, 1.0 / 255.0);
 
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_frame0(frame0);
         cv::gpu::GpuMat d_frame1(frame1);
         cv::gpu::GpuMat d_u;
@@ -110,6 +134,11 @@ PERF_TEST_P(ImagePair, Video_CreateOpticalFlowNeedleMap, Values<pair_string>(mak
             cv::gpu::createOpticalFlowNeedleMap(d_u, d_v, d_vertex, d_colors);
         }
     }
+    else
+    {
+        FAIL();
+    }
+}
 
 //////////////////////////////////////////////////////
 // GoodFeaturesToTrack
@@ -124,6 +153,8 @@ PERF_TEST_P(Image_MinDistance, Video_GoodFeaturesToTrack, Combine(Values<string>
     cv::Mat image = readImage(fileName, cv::IMREAD_GRAYSCALE);
     ASSERT_FALSE(image.empty());
 
+    if (runOnGpu)
+    {
         cv::gpu::GoodFeaturesToTrackDetector_GPU d_detector(8000, 0.01, minDistance);
 
         cv::gpu::GpuMat d_image(image);
@@ -136,6 +167,18 @@ PERF_TEST_P(Image_MinDistance, Video_GoodFeaturesToTrack, Combine(Values<string>
             d_detector(d_image, d_pts);
         }
     }
+    else
+    {
+        cv::Mat pts;
+
+        cv::goodFeaturesToTrack(image, pts, 8000, 0.01, minDistance);
+
+        TEST_CYCLE()
+        {
+            cv::goodFeaturesToTrack(image, pts, 8000, 0.01, minDistance);
+        }
+    }
+}
 
 //////////////////////////////////////////////////////
 // PyrLKOpticalFlowSparse
@@ -150,6 +193,8 @@ PERF_TEST_P(ImagePair_Gray_NPts_WinSz_Levels_Iters, Video_PyrLKOpticalFlowSparse
     Values(1, 2, 3),
     Values(1, 10, 30)))
 {
+    declare.time(20.0);
+
     pair_string imagePair = GET_PARAM(0);
     bool useGray = GET_PARAM(1);
     int points = GET_PARAM(2);
@@ -169,10 +214,12 @@ PERF_TEST_P(ImagePair_Gray_NPts_WinSz_Levels_Iters, Video_PyrLKOpticalFlowSparse
     else
         cv::cvtColor(frame0, gray_frame, cv::COLOR_BGR2GRAY);
 
-    cv::gpu::GpuMat d_pts;
+    cv::Mat pts;
+    cv::goodFeaturesToTrack(gray_frame, pts, points, 0.01, 0.0);
 
-    cv::gpu::GoodFeaturesToTrackDetector_GPU d_detector(points, 0.01, 0.0);
+    if (runOnGpu)
-    d_detector(cv::gpu::GpuMat(gray_frame), d_pts);
+    {
+        cv::gpu::GpuMat d_pts(pts);
 
         cv::gpu::PyrLKOpticalFlow d_pyrLK;
         d_pyrLK.winSize = cv::Size(winSize, winSize);
@@ -191,6 +238,23 @@ PERF_TEST_P(ImagePair_Gray_NPts_WinSz_Levels_Iters, Video_PyrLKOpticalFlowSparse
             d_pyrLK.sparse(d_frame0, d_frame1, d_pts, d_nextPts, d_status);
         }
     }
+    else
+    {
+        cv::Mat nextPts;
+        cv::Mat status;
+
+        cv::calcOpticalFlowPyrLK(frame0, frame1, pts, nextPts, status, cv::noArray(),
+                                 cv::Size(winSize, winSize), levels - 1,
+                                 cv::TermCriteria(cv::TermCriteria::COUNT + cv::TermCriteria::EPS, iters, 0.01));
+
+        TEST_CYCLE()
+        {
+            cv::calcOpticalFlowPyrLK(frame0, frame1, pts, nextPts, status, cv::noArray(),
+                                     cv::Size(winSize, winSize), levels - 1,
+                                     cv::TermCriteria(cv::TermCriteria::COUNT + cv::TermCriteria::EPS, iters, 0.01));
+        }
+    }
+}
 
 //////////////////////////////////////////////////////
 // PyrLKOpticalFlowDense
@@ -216,6 +280,8 @@ PERF_TEST_P(ImagePair_WinSz_Levels_Iters, Video_PyrLKOpticalFlowDense, Combine(
     cv::Mat frame1 = readImage(imagePair.second, cv::IMREAD_GRAYSCALE);
     ASSERT_FALSE(frame1.empty());
 
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_frame0(frame0);
         cv::gpu::GpuMat d_frame1(frame1);
         cv::gpu::GpuMat d_u;
@@ -233,6 +299,11 @@ PERF_TEST_P(ImagePair_WinSz_Levels_Iters, Video_PyrLKOpticalFlowDense, Combine(
             d_pyrLK.dense(d_frame0, d_frame1, d_u, d_v);
         }
     }
+    else
+    {
+        FAIL();
+    }
+}
 
 //////////////////////////////////////////////////////
 // FarnebackOpticalFlow
@@ -247,12 +318,29 @@ PERF_TEST_P(ImagePair, Video_FarnebackOpticalFlow, Values<pair_string>(make_pair
     cv::Mat frame1 = readImage(GetParam().second, cv::IMREAD_GRAYSCALE);
     ASSERT_FALSE(frame1.empty());
 
+    int numLevels = 5;
+    double pyrScale = 0.5;
+    int winSize = 13;
+    int numIters = 10;
+    int polyN = 5;
+    double polySigma = 1.1;
+    int flags = 0;
+
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_frame0(frame0);
         cv::gpu::GpuMat d_frame1(frame1);
         cv::gpu::GpuMat d_u;
         cv::gpu::GpuMat d_v;
 
         cv::gpu::FarnebackOpticalFlow d_farneback;
+        d_farneback.numLevels = numLevels;
+        d_farneback.pyrScale = pyrScale;
+        d_farneback.winSize = winSize;
+        d_farneback.numIters = numIters;
+        d_farneback.polyN = polyN;
+        d_farneback.polySigma = polySigma;
+        d_farneback.flags = flags;
 
         d_farneback(d_frame0, d_frame1, d_u, d_v);
 
@@ -261,6 +349,18 @@ PERF_TEST_P(ImagePair, Video_FarnebackOpticalFlow, Values<pair_string>(make_pair
             d_farneback(d_frame0, d_frame1, d_u, d_v);
         }
     }
+    else
+    {
+        cv::Mat flow;
+
+        cv::calcOpticalFlowFarneback(frame0, frame1, flow, pyrScale, numLevels, winSize, numIters, polyN, polySigma, flags);
+
+        TEST_CYCLE()
+        {
+            cv::calcOpticalFlowFarneback(frame0, frame1, flow, pyrScale, numLevels, winSize, numIters, polyN, polySigma, flags);
+        }
+    }
+}
 
 //////////////////////////////////////////////////////
 // FGDStatModel
@@ -269,7 +369,7 @@ DEF_PARAM_TEST_1(Video, string);
 
 PERF_TEST_P(Video, Video_FGDStatModel, Values("gpu/video/768x576.avi", "gpu/video/1920x1080.avi"))
 {
-    declare.time(10);
+    declare.time(60);
 
     string inputFile = perf::TestBase::getDataPath(GetParam());
 
@@ -280,7 +380,10 @@ PERF_TEST_P(Video, Video_FGDStatModel, Values("gpu/video/768x576.avi", "gpu/vide
     cap >> frame;
     ASSERT_FALSE(frame.empty());
 
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_frame(frame);
+
         cv::gpu::FGDStatModel d_model(4);
         d_model.create(d_frame);
 
@@ -296,6 +399,24 @@ PERF_TEST_P(Video, Video_FGDStatModel, Values("gpu/video/768x576.avi", "gpu/vide
             stopTimer();
         }
     }
+    else
+    {
+        IplImage ipl_frame = frame;
+        cv::Ptr<CvBGStatModel> model(cvCreateFGDStatModel(&ipl_frame));
+
+        for (int i = 0; i < 10; ++i)
+        {
+            cap >> frame;
+            ASSERT_FALSE(frame.empty());
+
+            ipl_frame = frame;
+
+            startTimer(); next();
+            cvUpdateBGStatModel(&ipl_frame, model);
+            stopTimer();
+        }
+    }
+}
 
 //////////////////////////////////////////////////////
 // MOG
@@ -313,10 +434,6 @@ PERF_TEST_P(Video_Cn_LearningRate, Video_MOG, Combine(Values("gpu/video/768x576.
 
     cv::Mat frame;
 
-    cv::gpu::GpuMat d_frame;
-    cv::gpu::MOG_GPU d_mog;
-    cv::gpu::GpuMat d_foreground;
-
     cap >> frame;
     ASSERT_FALSE(frame.empty());
 
@@ -330,7 +447,11 @@ PERF_TEST_P(Video_Cn_LearningRate, Video_MOG, Combine(Values("gpu/video/768x576.
         cv::swap(temp, frame);
     }
 
-    d_frame.upload(frame);
+    if (runOnGpu)
+    {
+        cv::gpu::GpuMat d_frame(frame);
+        cv::gpu::MOG_GPU d_mog;
+        cv::gpu::GpuMat d_foreground;
 
         d_mog(d_frame, d_foreground, learningRate);
 
@@ -356,6 +477,34 @@ PERF_TEST_P(Video_Cn_LearningRate, Video_MOG, Combine(Values("gpu/video/768x576.
             stopTimer();
         }
     }
+    else
+    {
+        cv::BackgroundSubtractorMOG mog;
+        cv::Mat foreground;
+
+        mog(frame, foreground, learningRate);
+
+        for (int i = 0; i < 10; ++i)
+        {
+            cap >> frame;
+            ASSERT_FALSE(frame.empty());
+
+            if (cn != 3)
+            {
+                cv::Mat temp;
+                if (cn == 1)
+                    cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
+                else
+                    cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);
+                cv::swap(temp, frame);
+            }
+
+            startTimer(); next();
+            mog(frame, foreground, learningRate);
+            stopTimer();
+        }
+    }
+}
 
 //////////////////////////////////////////////////////
 // MOG2
@@ -372,10 +521,6 @@ PERF_TEST_P(Video_Cn, Video_MOG2, Combine(Values("gpu/video/768x576.avi", "gpu/v
 
     cv::Mat frame;
 
-    cv::gpu::GpuMat d_frame;
-    cv::gpu::MOG2_GPU d_mog2;
-    cv::gpu::GpuMat d_foreground;
-
     cap >> frame;
     ASSERT_FALSE(frame.empty());
 
@@ -389,7 +534,11 @@ PERF_TEST_P(Video_Cn, Video_MOG2, Combine(Values("gpu/video/768x576.avi", "gpu/v
         cv::swap(temp, frame);
     }
 
-    d_frame.upload(frame);
+    if (runOnGpu)
+    {
+        cv::gpu::GpuMat d_frame(frame);
+        cv::gpu::MOG2_GPU d_mog2;
+        cv::gpu::GpuMat d_foreground;
 
         d_mog2(d_frame, d_foreground);
 
@@ -415,6 +564,34 @@ PERF_TEST_P(Video_Cn, Video_MOG2, Combine(Values("gpu/video/768x576.avi", "gpu/v
             stopTimer();
         }
     }
+    else
+    {
+        cv::BackgroundSubtractorMOG2 mog2;
+        cv::Mat foreground;
+
+        mog2(frame, foreground);
+
+        for (int i = 0; i < 10; ++i)
+        {
+            cap >> frame;
+            ASSERT_FALSE(frame.empty());
+
+            if (cn != 3)
+            {
+                cv::Mat temp;
+                if (cn == 1)
+                    cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
+                else
+                    cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);
+                cv::swap(temp, frame);
+            }
+
+            startTimer(); next();
+            mog2(frame, foreground);
+            stopTimer();
+        }
+    }
+}
 
 //////////////////////////////////////////////////////
 // MOG2GetBackgroundImage
@@ -429,6 +606,8 @@ PERF_TEST_P(Video_Cn, Video_MOG2GetBackgroundImage, Combine(Values("gpu/video/76
 
     cv::Mat frame;
 
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_frame;
         cv::gpu::MOG2_GPU d_mog2;
         cv::gpu::GpuMat d_foreground;
@@ -461,6 +640,38 @@ PERF_TEST_P(Video_Cn, Video_MOG2GetBackgroundImage, Combine(Values("gpu/video/76
             d_mog2.getBackgroundImage(d_background);
         }
     }
+    else
+    {
+        cv::BackgroundSubtractorMOG2 mog2;
+        cv::Mat foreground;
+
+        for (int i = 0; i < 10; ++i)
+        {
+            cap >> frame;
+            ASSERT_FALSE(frame.empty());
+
+            if (cn != 3)
+            {
+                cv::Mat temp;
+                if (cn == 1)
+                    cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
+                else
+                    cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);
+                cv::swap(temp, frame);
+            }
+
+            mog2(frame, foreground);
+        }
+
+        cv::Mat background;
+        mog2.getBackgroundImage(background);
+
+        TEST_CYCLE()
+        {
+            mog2.getBackgroundImage(background);
+        }
+    }
+}
 
 //////////////////////////////////////////////////////
 // VIBE
@@ -487,6 +698,8 @@ PERF_TEST_P(Video_Cn, Video_VIBE, Combine(Values("gpu/video/768x576.avi", "gpu/v
         cv::swap(temp, frame);
     }
 
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_frame(frame);
         cv::gpu::VIBE_GPU d_vibe;
         cv::gpu::GpuMat d_foreground;
@@ -515,6 +728,11 @@ PERF_TEST_P(Video_Cn, Video_VIBE, Combine(Values("gpu/video/768x576.avi", "gpu/v
             stopTimer();
         }
     }
+    else
+    {
+        FAIL();
+    }
+}
 
 //////////////////////////////////////////////////////
 // GMG
@@ -544,6 +762,8 @@ PERF_TEST_P(Video_Cn_MaxFeatures, Video_GMG, Combine(Values("gpu/video/768x576.a
         cv::swap(temp, frame);
     }
 
+    if (runOnGpu)
+    {
         cv::gpu::GpuMat d_frame(frame);
         cv::gpu::GpuMat d_fgmask;
 
@@ -578,12 +798,50 @@ PERF_TEST_P(Video_Cn_MaxFeatures, Video_GMG, Combine(Values("gpu/video/768x576.a
             stopTimer();
         }
     }
+    else
+    {
+        cv::Mat fgmask;
+        cv::Mat zeros(frame.size(), CV_8UC1, cv::Scalar::all(0));
+
+        cv::BackgroundSubtractorGMG gmg;
+        gmg.set("maxFeatures", maxFeatures);
+        gmg.initialize(frame.size(), 0.0, 255.0);
+
+        gmg(frame, fgmask);
+
+        for (int i = 0; i < 150; ++i)
+        {
+            cap >> frame;
+            if (frame.empty())
+            {
+                cap.open(inputFile);
+                cap >> frame;
+            }
+
+            if (cn != 3)
+            {
+                cv::Mat temp;
+                if (cn == 1)
+                    cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
+                else
+                    cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);
+                cv::swap(temp, frame);
+            }
+
+            startTimer(); next();
+            gmg(frame, fgmask);
+            stopTimer();
+        }
+    }
+}
 
 //////////////////////////////////////////////////////
 // VideoWriter
 
 PERF_TEST_P(Video, Video_VideoWriter, Values("gpu/video/768x576.avi", "gpu/video/1920x1080.avi"))
 {
+    declare.time(30);
+
     string inputFile = perf::TestBase::getDataPath(GetParam());
     string outputFile = cv::tempfile(".avi");
 
@@ -592,13 +850,14 @@ PERF_TEST_P(Video, Video_VideoWriter, Values("gpu/video/768x576.avi", "gpu/video
     cv::VideoCapture reader(inputFile);
     ASSERT_TRUE( reader.isOpened() );
 
+    cv::Mat frame;
+
+    if (runOnGpu)
+    {
         cv::gpu::VideoWriter_GPU d_writer;
 
-    cv::Mat frame;
         cv::gpu::GpuMat d_frame;
 
-    declare.time(10);
-
         for (int i = 0; i < 10; ++i)
         {
             reader >> frame;
@@ -614,6 +873,24 @@ PERF_TEST_P(Video, Video_VideoWriter, Values("gpu/video/768x576.avi", "gpu/video
             stopTimer();
         }
     }
+    else
+    {
+        cv::VideoWriter writer;
+
+        for (int i = 0; i < 10; ++i)
+        {
+            reader >> frame;
+            ASSERT_FALSE(frame.empty());
+
+            if (!writer.isOpened())
+                writer.open(outputFile, CV_FOURCC('X', 'V', 'I', 'D'), FPS, frame.size());
+
+            startTimer(); next();
+            writer.write(frame);
+            stopTimer();
+        }
+    }
+}
 
 //////////////////////////////////////////////////////
 // VideoReader
@@ -624,6 +901,8 @@ PERF_TEST_P(Video, Video_VideoReader, Values("gpu/video/768x576.avi", "gpu/video
 
     string inputFile = perf::TestBase::getDataPath(GetParam());
 
+    if (runOnGpu)
+    {
         cv::gpu::VideoReader_GPU d_reader(inputFile);
         ASSERT_TRUE( d_reader.isOpened() );
 
@@ -636,5 +915,20 @@ PERF_TEST_P(Video, Video_VideoReader, Values("gpu/video/768x576.avi", "gpu/video
             d_reader.read(d_frame);
         }
     }
+    else
+    {
+        cv::VideoCapture reader(inputFile);
+        ASSERT_TRUE( reader.isOpened() );
+
+        cv::Mat frame;
+
+        reader >> frame;
+
+        TEST_CYCLE_N(10)
+        {
+            reader >> frame;
+        }
+    }
+}
 
 } // namespace

modules/gpu/perf_cpu/perf_calib3d.cpp

@@ -1,136 +0,0 @@
-#include "perf_cpu_precomp.hpp"
-
-#ifdef HAVE_CUDA
-
-//////////////////////////////////////////////////////////////////////
-// StereoBM
-
-GPU_PERF_TEST_1(StereoBM, cv::gpu::DeviceInfo)
-{
-    cv::Mat img_l = readImage("gpu/perf/aloe.jpg", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(img_l.empty());
-
-    cv::Mat img_r = readImage("gpu/perf/aloeR.jpg", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(img_r.empty());
-
-    cv::StereoBM bm(0, 256);
-
-    cv::Mat dst;
-
-    bm(img_l, img_r, dst);
-
-    declare.time(5.0);
-
-    TEST_CYCLE()
-    {
-        bm(img_l, img_r, dst);
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(Calib3D, StereoBM, ALL_DEVICES);
-
-//////////////////////////////////////////////////////////////////////
-// ProjectPoints
-
-IMPLEMENT_PARAM_CLASS(Count, int)
-
-GPU_PERF_TEST(ProjectPoints, cv::gpu::DeviceInfo, Count)
-{
-    int count = GET_PARAM(1);
-
-    cv::Mat src(1, count, CV_32FC3);
-    fill(src, -100, 100);
-
-    cv::Mat rvec = cv::Mat::ones(1, 3, CV_32FC1);
-    cv::Mat tvec = cv::Mat::ones(1, 3, CV_32FC1);
-    cv::Mat camera_mat = cv::Mat::ones(3, 3, CV_32FC1);
-    cv::Mat dst;
-
-    cv::projectPoints(src, rvec, tvec, camera_mat, cv::noArray(), dst);
-
-    TEST_CYCLE()
-    {
-        cv::projectPoints(src, rvec, tvec, camera_mat, cv::noArray(), dst);
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(Calib3D, ProjectPoints, testing::Combine(
-    ALL_DEVICES,
-    testing::Values<Count>(5000, 10000, 20000)));
-
-//////////////////////////////////////////////////////////////////////
-// SolvePnPRansac
-
-GPU_PERF_TEST(SolvePnPRansac, cv::gpu::DeviceInfo, Count)
-{
-    int count = GET_PARAM(1);
-
-    cv::Mat object(1, count, CV_32FC3);
-    fill(object, -100, 100);
-
-    cv::Mat camera_mat(3, 3, CV_32FC1);
-    fill(camera_mat, 0.5, 1);
-    camera_mat.at<float>(0, 1) = 0.f;
-    camera_mat.at<float>(1, 0) = 0.f;
-    camera_mat.at<float>(2, 0) = 0.f;
-    camera_mat.at<float>(2, 1) = 0.f;
-
-    cv::Mat dist_coef(1, 8, CV_32F, cv::Scalar::all(0));
-
-    std::vector<cv::Point2f> image_vec;
-    cv::Mat rvec_gold(1, 3, CV_32FC1);
-    fill(rvec_gold, 0, 1);
-    cv::Mat tvec_gold(1, 3, CV_32FC1);
-    fill(tvec_gold, 0, 1);
-    cv::projectPoints(object, rvec_gold, tvec_gold, camera_mat, dist_coef, image_vec);
-
-    cv::Mat image(1, count, CV_32FC2, &image_vec[0]);
-
-    cv::Mat rvec;
-    cv::Mat tvec;
-
-    cv::solvePnPRansac(object, image, camera_mat, dist_coef, rvec, tvec);
-
-    declare.time(10.0);
-
-    TEST_CYCLE()
-    {
-        cv::solvePnPRansac(object, image, camera_mat, dist_coef, rvec, tvec);
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(Calib3D, SolvePnPRansac, testing::Combine(
-    ALL_DEVICES,
-    testing::Values<Count>(5000, 10000, 20000)));
-
-//////////////////////////////////////////////////////////////////////
-// ReprojectImageTo3D
-
-GPU_PERF_TEST(ReprojectImageTo3D, cv::gpu::DeviceInfo, cv::Size, MatDepth)
-{
-    cv::Size size = GET_PARAM(1);
-    int depth = GET_PARAM(2);
-
-    cv::Mat src(size, depth);
-    fill(src, 5.0, 30.0);
-
-    cv::Mat Q(4, 4, CV_32FC1);
-    fill(Q, 0.1, 1.0);
-
-    cv::Mat dst;
-
-    cv::reprojectImageTo3D(src, dst, Q);
-
-    TEST_CYCLE()
-    {
-        cv::reprojectImageTo3D(src, dst, Q);
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(Calib3D, ReprojectImageTo3D, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values<MatDepth>(CV_8U, CV_16S)));
-
-#endif
-

modules/gpu/perf_cpu/perf_cpu_precomp.cpp

@@ -1 +0,0 @@
-#include "perf_cpu_precomp.hpp"

modules/gpu/perf_cpu/perf_cpu_precomp.hpp

@@ -1,32 +0,0 @@
-#ifdef __GNUC__
-#  pragma GCC diagnostic ignored "-Wmissing-declarations"
-#  pragma GCC diagnostic ignored "-Wmissing-prototypes" //OSX
-#endif
-
-#ifndef __OPENCV_PERF_CPU_PRECOMP_HPP__
-#define __OPENCV_PERF_CPU_PRECOMP_HPP__
-
-#include <cstdio>
-#include <iostream>
-
-#include "cvconfig.h"
-
-#include "opencv2/ts/ts.hpp"
-#include "opencv2/ts/ts_perf.hpp"
-
-#include "opencv2/core/core.hpp"
-#include "opencv2/highgui/highgui.hpp"
-#include "opencv2/gpu/gpu.hpp"
-#include "opencv2/imgproc/imgproc.hpp"
-#include "opencv2/video/video.hpp"
-#include "opencv2/calib3d/calib3d.hpp"
-#include "opencv2/nonfree/nonfree.hpp"
-#include "opencv2/legacy/legacy.hpp"
-
-#include "perf_utility.hpp"
-
-#ifdef GTEST_CREATE_SHARED_LIBRARY
-#error no modules except ts should have GTEST_CREATE_SHARED_LIBRARY defined
-#endif
-
-#endif

modules/gpu/perf_cpu/perf_features2d.cpp

@@ -1,187 +0,0 @@
-#include "perf_cpu_precomp.hpp"
-
-#ifdef HAVE_CUDA
-
-//////////////////////////////////////////////////////////////////////
-// SURF
-
-GPU_PERF_TEST_1(SURF, cv::gpu::DeviceInfo)
-{
-    cv::Mat img = readImage("gpu/perf/aloe.jpg", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(img.empty());
-
-    cv::SURF surf;
-
-    std::vector<cv::KeyPoint> keypoints;
-    cv::Mat descriptors;
-
-    surf(img, cv::noArray(), keypoints, descriptors);
-
-    declare.time(50.0);
-
-    TEST_CYCLE()
-    {
-        keypoints.clear();
-        surf(img, cv::noArray(), keypoints, descriptors);
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(Features2D, SURF, ALL_DEVICES);
-
-//////////////////////////////////////////////////////////////////////
-// FAST
-
-GPU_PERF_TEST_1(FAST, cv::gpu::DeviceInfo)
-{
-    cv::Mat img = readImage("gpu/perf/aloe.jpg", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(img.empty());
-
-    std::vector<cv::KeyPoint> keypoints;
-
-    cv::FAST(img, keypoints, 20);
-
-    TEST_CYCLE()
-    {
-        keypoints.clear();
-        cv::FAST(img, keypoints, 20);
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(Features2D, FAST, ALL_DEVICES);
-
-//////////////////////////////////////////////////////////////////////
-// ORB
-
-GPU_PERF_TEST_1(ORB, cv::gpu::DeviceInfo)
-{
-    cv::Mat img = readImage("gpu/perf/aloe.jpg", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(img.empty());
-
-    cv::ORB orb(4000);
-
-    std::vector<cv::KeyPoint> keypoints;
-    cv::Mat descriptors;
-
-    orb(img, cv::noArray(), keypoints, descriptors);
-
-    TEST_CYCLE()
-    {
-        keypoints.clear();
-        orb(img, cv::noArray(), keypoints, descriptors);
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(Features2D, ORB, ALL_DEVICES);
-
-//////////////////////////////////////////////////////////////////////
-// BruteForceMatcher_match
-
-IMPLEMENT_PARAM_CLASS(DescriptorSize, int)
-
-GPU_PERF_TEST(BruteForceMatcher_match, cv::gpu::DeviceInfo, DescriptorSize, NormType)
-{
-    int desc_size = GET_PARAM(1);
-    int normType = GET_PARAM(2);
-
-    int type = normType == cv::NORM_HAMMING ? CV_8U : CV_32F;
-
-    cv::Mat query(3000, desc_size, type);
-    fill(query, 0.0, 10.0);
-
-    cv::Mat train(3000, desc_size, type);
-    fill(train, 0.0, 10.0);
-
-    cv::BFMatcher matcher(normType);
-
-    std::vector<cv::DMatch> matches;
-
-    matcher.match(query, train, matches);
-
-    declare.time(20.0);
-
-    TEST_CYCLE()
-    {
-        matcher.match(query, train, matches);
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(Features2D, BruteForceMatcher_match, testing::Combine(
-    ALL_DEVICES,
-    testing::Values(DescriptorSize(64), DescriptorSize(128), DescriptorSize(256)),
-    testing::Values(NormType(cv::NORM_L1), NormType(cv::NORM_L2), NormType(cv::NORM_HAMMING))));
-
-//////////////////////////////////////////////////////////////////////
-// BruteForceMatcher_knnMatch
-
-IMPLEMENT_PARAM_CLASS(K, int)
-
-GPU_PERF_TEST(BruteForceMatcher_knnMatch, cv::gpu::DeviceInfo, DescriptorSize, K, NormType)
-{
-    int desc_size = GET_PARAM(1);
-    int k = GET_PARAM(2);
-    int normType = GET_PARAM(3);
-
-    int type = normType == cv::NORM_HAMMING ? CV_8U : CV_32F;
-
-    cv::Mat query(3000, desc_size, type);
-    fill(query, 0.0, 10.0);
-
-    cv::Mat train(3000, desc_size, type);
-    fill(train, 0.0, 10.0);
-
-    cv::BFMatcher matcher(normType);
-
-    std::vector< std::vector<cv::DMatch> > matches;
-
-    matcher.knnMatch(query, train, matches, k);
-
-    declare.time(30.0);
-
-    TEST_CYCLE()
-    {
-        matcher.knnMatch(query, train, matches, k);
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(Features2D, BruteForceMatcher_knnMatch, testing::Combine(
-    ALL_DEVICES,
-    testing::Values(DescriptorSize(64), DescriptorSize(128), DescriptorSize(256)),
-    testing::Values(K(2), K(3)),
-    testing::Values(NormType(cv::NORM_L1), NormType(cv::NORM_L2), NormType(cv::NORM_HAMMING))));
-
-//////////////////////////////////////////////////////////////////////
-// BruteForceMatcher_radiusMatch
-
-GPU_PERF_TEST(BruteForceMatcher_radiusMatch, cv::gpu::DeviceInfo, DescriptorSize, NormType)
-{
-    int desc_size = GET_PARAM(1);
-    int normType = GET_PARAM(2);
-
-    int type = normType == cv::NORM_HAMMING ? CV_8U : CV_32F;
-
-    cv::Mat query(3000, desc_size, type);
-    fill(query, 0.0, 1.0);
-
-    cv::Mat train(3000, desc_size, type);
-    fill(train, 0.0, 1.0);
-
-    cv::BFMatcher matcher(normType);
-
-    std::vector< std::vector<cv::DMatch> > matches;
-
-    matcher.radiusMatch(query, train, matches, 2.0);
-
-    declare.time(30.0);
-
-    TEST_CYCLE()
-    {
-        matcher.radiusMatch(query, train, matches, 2.0);
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(Features2D, BruteForceMatcher_radiusMatch, testing::Combine(
-    ALL_DEVICES,
-    testing::Values(DescriptorSize(64), DescriptorSize(128), DescriptorSize(256)),
-    testing::Values(NormType(cv::NORM_L1), NormType(cv::NORM_L2), NormType(cv::NORM_HAMMING))));
-
-#endif

modules/gpu/perf_cpu/perf_filters.cpp

@@ -1,283 +0,0 @@
-#include "perf_cpu_precomp.hpp"
-
-#ifdef HAVE_CUDA
-
-IMPLEMENT_PARAM_CLASS(KernelSize, int)
-
-//////////////////////////////////////////////////////////////////////
-// Blur
-
-GPU_PERF_TEST(Blur, cv::gpu::DeviceInfo, cv::Size, MatType, KernelSize)
-{
-    cv::Size size = GET_PARAM(1);
-    int type = GET_PARAM(2);
-    int ksize = GET_PARAM(3);
-
-    cv::Mat src(size, type);
-    fill(src, 0.0, 255.0);
-
-    cv::Mat dst;
-
-    cv::blur(src, dst, cv::Size(ksize, ksize));
-
-    declare.time(20.0);
-
-    TEST_CYCLE()
-    {
-        cv::blur(src, dst, cv::Size(ksize, ksize));
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(Filters, Blur, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(MatType(CV_8UC1), MatType(CV_8UC4)),
-    testing::Values(KernelSize(3), KernelSize(5), KernelSize(7))));
-
-//////////////////////////////////////////////////////////////////////
-// Sobel
-
-GPU_PERF_TEST(Sobel, cv::gpu::DeviceInfo, cv::Size, MatType, KernelSize)
-{
-    cv::Size size = GET_PARAM(1);
-    int type = GET_PARAM(2);
-    int ksize = GET_PARAM(3);
-
-    cv::Mat src(size, type);
-    fill(src, 0.0, 255.0);
-
-    cv::Mat dst;
-
-    cv::Sobel(src, dst, -1, 1, 1, ksize);
-
-    declare.time(20.0);
-
-    TEST_CYCLE()
-    {
-        cv::Sobel(src, dst, -1, 1, 1, ksize);
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(Filters, Sobel, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(MatType(CV_8UC1), MatType(CV_8UC4), MatType(CV_32FC1)),
-    testing::Values(KernelSize(3), KernelSize(5), KernelSize(7), KernelSize(9), KernelSize(11), KernelSize(13), KernelSize(15))));
-
-//////////////////////////////////////////////////////////////////////
-// Scharr
-
-GPU_PERF_TEST(Scharr, cv::gpu::DeviceInfo, cv::Size, MatType)
-{
-    cv::Size size = GET_PARAM(1);
-    int type = GET_PARAM(2);
-
-    cv::Mat src(size, type);
-    fill(src, 0.0, 255.0);
-
-    cv::Mat dst;
-
-    cv::Scharr(src, dst, -1, 1, 0);
-
-    declare.time(20.0);
-
-    TEST_CYCLE()
-    {
-        cv::Scharr(src, dst, -1, 1, 0);
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(Filters, Scharr, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(MatType(CV_8UC1), MatType(CV_8UC4), MatType(CV_32FC1))));
-
-//////////////////////////////////////////////////////////////////////
-// GaussianBlur
-
-GPU_PERF_TEST(GaussianBlur, cv::gpu::DeviceInfo, cv::Size, MatType, KernelSize)
-{
-    cv::Size size = GET_PARAM(1);
-    int type = GET_PARAM(2);
-    int ksize = GET_PARAM(3);
-
-    cv::Mat src(size, type);
-    fill(src, 0.0, 255.0);
-
-    cv::Mat dst;
-
-    cv::GaussianBlur(src, dst, cv::Size(ksize, ksize), 0.5);
-
-    declare.time(20.0);
-
-    TEST_CYCLE()
-    {
-        cv::GaussianBlur(src, dst, cv::Size(ksize, ksize), 0.5);
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(Filters, GaussianBlur, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(MatType(CV_8UC1), MatType(CV_8UC4), MatType(CV_32FC1)),
-    testing::Values(KernelSize(3), KernelSize(5), KernelSize(7), KernelSize(9), KernelSize(11), KernelSize(13), KernelSize(15))));
-
-//////////////////////////////////////////////////////////////////////
-// Laplacian
-
-GPU_PERF_TEST(Laplacian, cv::gpu::DeviceInfo, cv::Size, MatType, KernelSize)
-{
-    cv::Size size = GET_PARAM(1);
-    int type = GET_PARAM(2);
-    int ksize = GET_PARAM(3);
-
-    cv::Mat src(size, type);
-    fill(src, 0.0, 255.0);
-
-    cv::Mat dst;
-
-    cv::Laplacian(src, dst, -1, ksize);
-
-    declare.time(20.0);
-
-    TEST_CYCLE()
-    {
-        cv::Laplacian(src, dst, -1, ksize);
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(Filters, Laplacian, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(MatType(CV_8UC1), MatType(CV_8UC4), MatType(CV_32FC1), MatType(CV_32FC4)),
-    testing::Values(KernelSize(1), KernelSize(3))));
-
-//////////////////////////////////////////////////////////////////////
-// Erode
-
-GPU_PERF_TEST(Erode, cv::gpu::DeviceInfo, cv::Size, MatType)
-{
-    cv::Size size = GET_PARAM(1);
-    int type = GET_PARAM(2);
-
-    cv::Mat src(size, type);
-    fill(src, 0.0, 255.0);
-
-    cv::Mat ker = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(3, 3));
-
-    cv::Mat dst;
-
-    cv::erode(src, dst, ker);
-
-    declare.time(20.0);
-
-    TEST_CYCLE()
-    {
-        cv::erode(src, dst, ker);
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(Filters, Erode, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(MatType(CV_8UC1), MatType(CV_8UC4))));
-
-//////////////////////////////////////////////////////////////////////
-// Dilate
-
-GPU_PERF_TEST(Dilate, cv::gpu::DeviceInfo, cv::Size, MatType)
-{
-    cv::Size size = GET_PARAM(1);
-    int type = GET_PARAM(2);
-
-    cv::Mat src(size, type);
-    fill(src, 0.0, 255.0);
-
-    cv::Mat ker = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(3, 3));
-
-    cv::Mat dst;
-
-    cv::dilate(src, dst, ker);
-
-    declare.time(20.0);
-
-    TEST_CYCLE()
-    {
-        cv::dilate(src, dst, ker);
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(Filters, Dilate, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(MatType(CV_8UC1), MatType(CV_8UC4))));
-
-//////////////////////////////////////////////////////////////////////
-// MorphologyEx
-
-CV_ENUM(MorphOp, cv::MORPH_OPEN, cv::MORPH_CLOSE, cv::MORPH_GRADIENT, cv::MORPH_TOPHAT, cv::MORPH_BLACKHAT)
-#define ALL_MORPH_OPS testing::Values(MorphOp(cv::MORPH_OPEN), MorphOp(cv::MORPH_CLOSE), MorphOp(cv::MORPH_GRADIENT), MorphOp(cv::MORPH_TOPHAT), MorphOp(cv::MORPH_BLACKHAT))
-
-GPU_PERF_TEST(MorphologyEx, cv::gpu::DeviceInfo, cv::Size, MatType, MorphOp)
-{
-    cv::Size size = GET_PARAM(1);
-    int type = GET_PARAM(2);
-    int morphOp = GET_PARAM(3);
-
-    cv::Mat src(size, type);
-    fill(src, 0.0, 255.0);
-
-    cv::Mat dst;
-
-    cv::Mat ker = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(3, 3));
-
-    cv::morphologyEx(src, dst, morphOp, ker);
-
-    declare.time(20.0);
-
-    TEST_CYCLE()
-    {
-        cv::morphologyEx(src, dst, morphOp, ker);
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(Filters, MorphologyEx, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(MatType(CV_8UC1), MatType(CV_8UC4)),
-    ALL_MORPH_OPS));
-
-//////////////////////////////////////////////////////////////////////
-// Filter2D
-
-GPU_PERF_TEST(Filter2D, cv::gpu::DeviceInfo, cv::Size, MatType, KernelSize)
-{
-    cv::Size size = GET_PARAM(1);
-    int type = GET_PARAM(2);
-    int ksize = GET_PARAM(3);
-
-    cv::Mat src(size, type);
-    fill(src, 0.0, 255.0);
-
-    cv::Mat kernel(ksize, ksize, CV_32FC1);
-    fill(kernel, 0.0, 1.0);
-
-    cv::Mat dst;
-
-    cv::filter2D(src, dst, -1, kernel);
-
-    declare.time(20.0);
-
-    TEST_CYCLE()
-    {
-        cv::filter2D(src, dst, -1, kernel);
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(Filters, Filter2D, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(MatType(CV_8UC1), MatType(CV_8UC4), MatType(CV_32FC1), MatType(CV_32FC4)),
-    testing::Values(KernelSize(3), KernelSize(5), KernelSize(7), KernelSize(9), KernelSize(11), KernelSize(13), KernelSize(15))));
-
-#endif

modules/gpu/perf_cpu/perf_imgproc.cpp

@@ -1,771 +0,0 @@
-#include "perf_cpu_precomp.hpp"
-
-#ifdef HAVE_CUDA
-
-//////////////////////////////////////////////////////////////////////
-// Remap
-
-GPU_PERF_TEST(Remap, cv::gpu::DeviceInfo, cv::Size, MatType, Interpolation, BorderMode)
-{
-    cv::Size size = GET_PARAM(1);
-    int type = GET_PARAM(2);
-    int interpolation = GET_PARAM(3);
-    int borderMode = GET_PARAM(4);
-
-    cv::Mat src(size, type);
-    fill(src, 0, 255);
-
-    cv::Mat xmap(size, CV_32FC1);
-    fill(xmap, 0, size.width);
-
-    cv::Mat ymap(size, CV_32FC1);
-    fill(ymap, 0, size.height);
-
-    cv::Mat dst;
-
-    cv::remap(src, dst, xmap, ymap, interpolation, borderMode);
-
-    declare.time(20.0);
-
-    TEST_CYCLE()
-    {
-        cv::remap(src, dst, xmap, ymap, interpolation, borderMode);
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(ImgProc, Remap, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),
-                    MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),
-                    MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),
-    testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)),
-    testing::Values(BorderMode(cv::BORDER_REFLECT101), BorderMode(cv::BORDER_REPLICATE), BorderMode(cv::BORDER_CONSTANT), BorderMode(cv::BORDER_REFLECT), BorderMode(cv::BORDER_WRAP))));
-
-
-//////////////////////////////////////////////////////////////////////
-// Resize
-
-IMPLEMENT_PARAM_CLASS(Scale, double)
-
-GPU_PERF_TEST(Resize, cv::gpu::DeviceInfo, cv::Size, MatType, Interpolation, Scale)
-{
-    cv::Size size = GET_PARAM(1);
-    int type = GET_PARAM(2);
-    int interpolation = GET_PARAM(3);
-    double f = GET_PARAM(4);
-
-    cv::Mat src(size, type);
-    fill(src, 0, 255);
-
-    cv::Mat dst;
-
-    cv::resize(src, dst, cv::Size(), f, f, interpolation);
-
-    declare.time(20.0);
-
-    TEST_CYCLE()
-    {
-        cv::resize(src, dst, cv::Size(), f, f, interpolation);
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(ImgProc, Resize, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),
-                    MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),
-                    MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),
-    testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR),
-                    Interpolation(cv::INTER_CUBIC),   Interpolation(cv::INTER_AREA)),
-    testing::Values(Scale(0.5), Scale(0.3), Scale(2.0))));
-
-GPU_PERF_TEST(ResizeArea, cv::gpu::DeviceInfo, cv::Size, MatType, Scale)
-{
-    cv::Size size = GET_PARAM(1);
-    int type = GET_PARAM(2);
-    int interpolation = cv::INTER_AREA;
-    double f = GET_PARAM(3);
-
-    cv::Mat src_host(size, type);
-    fill(src_host, 0, 255);
-
-    cv::Mat src(src_host);
-    cv::Mat dst;
-
-    cv::resize(src, dst, cv::Size(), f, f, interpolation);
-
-    declare.time(1.0);
-
-    TEST_CYCLE()
-    {
-        cv::resize(src, dst, cv::Size(), f, f, interpolation);
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(ImgProc, ResizeArea, testing::Combine(
-    ALL_DEVICES,
-    testing::Values(perf::sz1080p, cv::Size(4096, 2048)),
-    testing::Values(MatType(CV_8UC1)/*,  MatType(CV_8UC3), MatType(CV_8UC4),
-                    MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),
-                    MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)*/),
-    testing::Values(Scale(0.2),Scale(0.1),Scale(0.05))));
-
-//////////////////////////////////////////////////////////////////////
-// WarpAffine
-
-GPU_PERF_TEST(WarpAffine, cv::gpu::DeviceInfo, cv::Size, MatType, Interpolation, BorderMode)
-{
-    cv::Size size = GET_PARAM(1);
-    int type = GET_PARAM(2);
-    int interpolation = GET_PARAM(3);
-    int borderMode = GET_PARAM(4);
-
-    cv::Mat src(size, type);
-    fill(src, 0, 255);
-
-    cv::Mat dst;
-
-    const double aplha = CV_PI / 4;
-    double mat[2][3] = { {std::cos(aplha), -std::sin(aplha), src.cols / 2},
-                         {std::sin(aplha),  std::cos(aplha), 0}};
-    cv::Mat M(2, 3, CV_64F, (void*) mat);
-
-    cv::warpAffine(src, dst, M, size, interpolation, borderMode);
-
-    declare.time(20.0);
-
-    TEST_CYCLE()
-    {
-        cv::warpAffine(src, dst, M, size, interpolation, borderMode);
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(ImgProc, WarpAffine, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),
-                    MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),
-                    MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),
-    testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)),
-    testing::Values(BorderMode(cv::BORDER_REFLECT101), BorderMode(cv::BORDER_REPLICATE), BorderMode(cv::BORDER_CONSTANT), BorderMode(cv::BORDER_REFLECT), BorderMode(cv::BORDER_WRAP))));
-
-//////////////////////////////////////////////////////////////////////
-// WarpPerspective
-
-GPU_PERF_TEST(WarpPerspective, cv::gpu::DeviceInfo, cv::Size, MatType, Interpolation, BorderMode)
-{
-    cv::Size size = GET_PARAM(1);
-    int type = GET_PARAM(2);
-    int interpolation = GET_PARAM(3);
-    int borderMode = GET_PARAM(4);
-
-    cv::Mat src(size, type);
-    fill(src, 0, 255);
-
-    cv::Mat dst;
-
-    const double aplha = CV_PI / 4;
-    double mat[3][3] = { {std::cos(aplha), -std::sin(aplha), src.cols / 2},
-                         {std::sin(aplha),  std::cos(aplha), 0},
-                         {0.0,              0.0,             1.0}};
-    cv::Mat M(3, 3, CV_64F, (void*) mat);
-
-    cv::warpPerspective(src, dst, M, size, interpolation, borderMode);
-
-    declare.time(20.0);
-
-    TEST_CYCLE()
-    {
-        cv::warpPerspective(src, dst, M, size, interpolation, borderMode);
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(ImgProc, WarpPerspective, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),
-                    MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),
-                    MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),
-    testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)),
-    testing::Values(BorderMode(cv::BORDER_REFLECT101), BorderMode(cv::BORDER_REPLICATE), BorderMode(cv::BORDER_CONSTANT), BorderMode(cv::BORDER_REFLECT), BorderMode(cv::BORDER_WRAP))));
-
-//////////////////////////////////////////////////////////////////////
-// CopyMakeBorder
-
-GPU_PERF_TEST(CopyMakeBorder, cv::gpu::DeviceInfo, cv::Size, MatType, BorderMode)
-{
-    cv::Size size = GET_PARAM(1);
-    int type = GET_PARAM(2);
-    int borderType = GET_PARAM(3);
-
-    cv::Mat src(size, type);
-    fill(src, 0, 255);
-
-    cv::Mat dst;
-
-    cv::copyMakeBorder(src, dst, 5, 5, 5, 5, borderType);
-
-    TEST_CYCLE()
-    {
-        cv::copyMakeBorder(src, dst, 5, 5, 5, 5, borderType);
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(ImgProc, CopyMakeBorder, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),
-                    MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),
-                    MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),
-    testing::Values(BorderMode(cv::BORDER_REFLECT101), BorderMode(cv::BORDER_REPLICATE), BorderMode(cv::BORDER_CONSTANT), BorderMode(cv::BORDER_REFLECT), BorderMode(cv::BORDER_WRAP))));
-
-//////////////////////////////////////////////////////////////////////
-// Threshold
-
-CV_ENUM(ThreshOp, cv::THRESH_BINARY, cv::THRESH_BINARY_INV, cv::THRESH_TRUNC, cv::THRESH_TOZERO, cv::THRESH_TOZERO_INV)
-#define ALL_THRESH_OPS testing::Values(ThreshOp(cv::THRESH_BINARY), ThreshOp(cv::THRESH_BINARY_INV), ThreshOp(cv::THRESH_TRUNC), ThreshOp(cv::THRESH_TOZERO), ThreshOp(cv::THRESH_TOZERO_INV))
-
-GPU_PERF_TEST(Threshold, cv::gpu::DeviceInfo, cv::Size, MatDepth, ThreshOp)
-{
-    cv::Size size = GET_PARAM(1);
-    int depth = GET_PARAM(2);
-    int threshOp = GET_PARAM(3);
-
-    cv::Mat src(size, depth);
-    fill(src, 0, 255);
-
-    cv::Mat dst;
-
-    cv::threshold(src, dst, 100.0, 255.0, threshOp);
-
-    TEST_CYCLE()
-    {
-        cv::threshold(src, dst, 100.0, 255.0, threshOp);
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(ImgProc, Threshold, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_32F), MatDepth(CV_64F)),
-    ALL_THRESH_OPS));
-
-//////////////////////////////////////////////////////////////////////
-// Integral
-
-GPU_PERF_TEST(Integral, cv::gpu::DeviceInfo, cv::Size)
-{
-    cv::Size size = GET_PARAM(1);
-
-    cv::Mat src(size, CV_8UC1);
-    fill(src, 0, 255);
-
-    cv::Mat dst;
-
-    cv::integral(src, dst);
-
-    TEST_CYCLE()
-    {
-        cv::integral(src, dst);
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(ImgProc, Integral, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES));
-
-//////////////////////////////////////////////////////////////////////
-// HistEven_OneChannel
-
-GPU_PERF_TEST(HistEven_OneChannel, cv::gpu::DeviceInfo, cv::Size, MatDepth)
-{
-    cv::Size size = GET_PARAM(1);
-    int depth = GET_PARAM(2);
-
-    cv::Mat src(size, depth);
-    fill(src, 0, 255);
-
-    int hbins = 30;
-    float hranges[] = {0.0f, 180.0f};
-    cv::Mat hist;
-    int histSize[] = {hbins};
-    const float* ranges[] = {hranges};
-    int channels[] = {0};
-
-    cv::calcHist(&src, 1, channels, cv::Mat(), hist, 1, histSize, ranges);
-
-    TEST_CYCLE()
-    {
-        cv::calcHist(&src, 1, channels, cv::Mat(), hist, 1, histSize, ranges);
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(ImgProc, HistEven_OneChannel, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_16S))));
-
-//////////////////////////////////////////////////////////////////////
-// EqualizeHist
-
-GPU_PERF_TEST(EqualizeHist, cv::gpu::DeviceInfo, cv::Size)
-{
-    cv::Size size = GET_PARAM(1);
-
-    cv::Mat src(size, CV_8UC1);
-    fill(src, 0, 255);
-
-    cv::Mat dst;
-
-    cv::equalizeHist(src, dst);
-
-    TEST_CYCLE()
-    {
-        cv::equalizeHist(src, dst);
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(ImgProc, EqualizeHist, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES));
-
-//////////////////////////////////////////////////////////////////////
-// Canny
-
-IMPLEMENT_PARAM_CLASS(AppertureSize, int)
-IMPLEMENT_PARAM_CLASS(L2gradient, bool)
-
-GPU_PERF_TEST(Canny, cv::gpu::DeviceInfo, AppertureSize, L2gradient)
-{
-    int apperture_size = GET_PARAM(1);
-    bool useL2gradient = GET_PARAM(2);
-
-    cv::Mat image = readImage("perf/1280x1024.jpg", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(image.empty());
-
-    cv::Mat dst;
-
-    cv::Canny(image, dst, 50.0, 100.0, apperture_size, useL2gradient);
-
-    TEST_CYCLE()
-    {
-        cv::Canny(image, dst, 50.0, 100.0, apperture_size, useL2gradient);
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(ImgProc, Canny, testing::Combine(
-    ALL_DEVICES,
-    testing::Values(AppertureSize(3), AppertureSize(5)),
-    testing::Values(L2gradient(false), L2gradient(true))));
-
-//////////////////////////////////////////////////////////////////////
-// MeanShiftFiltering
-
-GPU_PERF_TEST_1(MeanShiftFiltering, cv::gpu::DeviceInfo)
-{
-    cv::Mat img = readImage("gpu/meanshift/cones.png");
-    ASSERT_FALSE(img.empty());
-
-    cv::Mat dst;
-
-    cv::pyrMeanShiftFiltering(img, dst, 50, 50);
-
-    declare.time(15.0);
-
-    TEST_CYCLE()
-    {
-        cv::pyrMeanShiftFiltering(img, dst, 50, 50);
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(ImgProc, MeanShiftFiltering, ALL_DEVICES);
-
-//////////////////////////////////////////////////////////////////////
-// Convolve
-
-IMPLEMENT_PARAM_CLASS(KSize, int)
-IMPLEMENT_PARAM_CLASS(Ccorr, bool)
-
-GPU_PERF_TEST(Convolve, cv::gpu::DeviceInfo, cv::Size, KSize, Ccorr)
-{
-    cv::Size size = GET_PARAM(1);
-    int templ_size = GET_PARAM(2);
-    bool ccorr = GET_PARAM(3);
-
-    ASSERT_FALSE(ccorr);
-
-    cv::Mat image(size, CV_32FC1);
-    image.setTo(1.0);
-
-    cv::Mat templ(templ_size, templ_size, CV_32FC1);
-    templ.setTo(1.0);
-
-    cv::Mat dst;
-
-    cv::filter2D(image, dst, image.depth(), templ);
-
-    declare.time(10.0);
-
-    TEST_CYCLE()
-    {
-        cv::filter2D(image, dst, image.depth(), templ);
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(ImgProc, Convolve, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(KSize(3), KSize(9), KSize(17), KSize(27), KSize(32), KSize(64)),
-    testing::Values(Ccorr(false), Ccorr(true))));
-
-////////////////////////////////////////////////////////////////////////////////
-// MatchTemplate_8U
-
-CV_ENUM(TemplateMethod, cv::TM_SQDIFF, cv::TM_SQDIFF_NORMED, cv::TM_CCORR, cv::TM_CCORR_NORMED, cv::TM_CCOEFF, cv::TM_CCOEFF_NORMED)
-#define ALL_TEMPLATE_METHODS testing::Values(TemplateMethod(cv::TM_SQDIFF), TemplateMethod(cv::TM_SQDIFF_NORMED), TemplateMethod(cv::TM_CCORR), TemplateMethod(cv::TM_CCORR_NORMED), TemplateMethod(cv::TM_CCOEFF), TemplateMethod(cv::TM_CCOEFF_NORMED))
-
-IMPLEMENT_PARAM_CLASS(TemplateSize, cv::Size)
-
-GPU_PERF_TEST(MatchTemplate_8U, cv::gpu::DeviceInfo, cv::Size, TemplateSize, Channels, TemplateMethod)
-{
-    cv::Size size = GET_PARAM(1);
-    cv::Size templ_size = GET_PARAM(2);
-    int cn = GET_PARAM(3);
-    int method = GET_PARAM(4);
-
-    cv::Mat image(size, CV_MAKE_TYPE(CV_8U, cn));
-    fill(image, 0, 255);
-
-    cv::Mat templ(templ_size, CV_MAKE_TYPE(CV_8U, cn));
-    fill(templ, 0, 255);
-
-    cv::Mat dst;
-
-    cv::matchTemplate(image, templ, dst, method);
-
-    TEST_CYCLE()
-    {
-        cv::matchTemplate(image, templ, dst, method);
-    }
-};
-
-INSTANTIATE_TEST_CASE_P(ImgProc, MatchTemplate_8U, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(TemplateSize(cv::Size(5, 5)), TemplateSize(cv::Size(16, 16)), TemplateSize(cv::Size(30, 30))),
-    testing::Values(Channels(1), Channels(3), Channels(4)),
-    ALL_TEMPLATE_METHODS));
-
-////////////////////////////////////////////////////////////////////////////////
-// MatchTemplate_32F
-
-GPU_PERF_TEST(MatchTemplate_32F, cv::gpu::DeviceInfo, cv::Size, TemplateSize, Channels, TemplateMethod)
-{
-    cv::Size size = GET_PARAM(1);
-    cv::Size templ_size = GET_PARAM(2);
-    int cn = GET_PARAM(3);
-    int method = GET_PARAM(4);
-
-    cv::Mat image(size, CV_MAKE_TYPE(CV_32F, cn));
-    fill(image, 0, 255);
-
-    cv::Mat templ(templ_size, CV_MAKE_TYPE(CV_32F, cn));
-    fill(templ, 0, 255);
-
-    cv::Mat dst;
-
-    cv::matchTemplate(image, templ, dst, method);
-
-    TEST_CYCLE()
-    {
-        cv::matchTemplate(image, templ, dst, method);
-    }
-};
-
-INSTANTIATE_TEST_CASE_P(ImgProc, MatchTemplate_32F, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(TemplateSize(cv::Size(5, 5)), TemplateSize(cv::Size(16, 16)), TemplateSize(cv::Size(30, 30))),
-    testing::Values(Channels(1), Channels(3), Channels(4)),
-    testing::Values(TemplateMethod(cv::TM_SQDIFF), TemplateMethod(cv::TM_CCORR))));
-
-//////////////////////////////////////////////////////////////////////
-// MulSpectrums
-
-CV_FLAGS(DftFlags, 0, cv::DFT_INVERSE, cv::DFT_SCALE, cv::DFT_ROWS, cv::DFT_COMPLEX_OUTPUT, cv::DFT_REAL_OUTPUT)
-
-GPU_PERF_TEST(MulSpectrums, cv::gpu::DeviceInfo, cv::Size, DftFlags)
-{
-    cv::Size size = GET_PARAM(1);
-    int flag = GET_PARAM(2);
-
-    cv::Mat a(size, CV_32FC2);
-    fill(a, 0, 100);
-
-    cv::Mat b(size, CV_32FC2);
-    fill(b, 0, 100);
-
-    cv::Mat dst;
-
-    cv::mulSpectrums(a, b, dst, flag);
-
-    TEST_CYCLE()
-    {
-        cv::mulSpectrums(a, b, dst, flag);
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(ImgProc, MulSpectrums, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(DftFlags(0), DftFlags(cv::DFT_ROWS))));
-
-//////////////////////////////////////////////////////////////////////
-// Dft
-
-GPU_PERF_TEST(Dft, cv::gpu::DeviceInfo, cv::Size, DftFlags)
-{
-    cv::Size size = GET_PARAM(1);
-    int flag = GET_PARAM(2);
-
-    cv::Mat src(size, CV_32FC2);
-    fill(src, 0, 100);
-
-    cv::Mat dst;
-
-    cv::dft(src, dst, flag);
-
-    declare.time(10.0);
-
-    TEST_CYCLE()
-    {
-        cv::dft(src, dst, flag);
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(ImgProc, Dft, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(DftFlags(0), DftFlags(cv::DFT_ROWS), DftFlags(cv::DFT_INVERSE))));
-
-//////////////////////////////////////////////////////////////////////
-// CornerHarris
-
-IMPLEMENT_PARAM_CLASS(BlockSize, int)
-IMPLEMENT_PARAM_CLASS(ApertureSize, int)
-
-GPU_PERF_TEST(CornerHarris, cv::gpu::DeviceInfo, MatType, BorderMode, BlockSize, ApertureSize)
-{
-    int type = GET_PARAM(1);
-    int borderType = GET_PARAM(2);
-    int blockSize = GET_PARAM(3);
-    int apertureSize = GET_PARAM(4);
-
-    cv::Mat img = readImage("gpu/stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(img.empty());
-
-    img.convertTo(img, type, type == CV_32F ? 1.0 / 255.0 : 1.0);
-
-    cv::Mat dst;
-
-    double k = 0.5;
-
-    cv::cornerHarris(img, dst, blockSize, apertureSize, k, borderType);
-
-    TEST_CYCLE()
-    {
-        cv::cornerHarris(img, dst, blockSize, apertureSize, k, borderType);
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(ImgProc, CornerHarris, testing::Combine(
-    ALL_DEVICES,
-    testing::Values(MatType(CV_8UC1), MatType(CV_32FC1)),
-    testing::Values(BorderMode(cv::BORDER_REFLECT101), BorderMode(cv::BORDER_REPLICATE), BorderMode(cv::BORDER_REFLECT)),
-    testing::Values(BlockSize(3), BlockSize(5), BlockSize(7)),
-    testing::Values(ApertureSize(0), ApertureSize(3), ApertureSize(5), ApertureSize(7))));
-
-//////////////////////////////////////////////////////////////////////
-// CornerMinEigenVal
-
-GPU_PERF_TEST(CornerMinEigenVal, cv::gpu::DeviceInfo, MatType, BorderMode, BlockSize, ApertureSize)
-{
-    int type = GET_PARAM(1);
-    int borderType = GET_PARAM(2);
-    int blockSize = GET_PARAM(3);
-    int apertureSize = GET_PARAM(4);
-
-    cv::Mat img = readImage("gpu/stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(img.empty());
-
-    img.convertTo(img, type, type == CV_32F ? 1.0 / 255.0 : 1.0);
-
-    cv::Mat dst;
-
-    cv::cornerMinEigenVal(img, dst, blockSize, apertureSize, borderType);
-
-    TEST_CYCLE()
-    {
-        cv::cornerMinEigenVal(img, dst, blockSize, apertureSize, borderType);
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(ImgProc, CornerMinEigenVal, testing::Combine(
-    ALL_DEVICES,
-    testing::Values(MatType(CV_8UC1), MatType(CV_32FC1)),
-    testing::Values(BorderMode(cv::BORDER_REFLECT101), BorderMode(cv::BORDER_REPLICATE), BorderMode(cv::BORDER_REFLECT)),
-    testing::Values(BlockSize(3), BlockSize(5), BlockSize(7)),
-    testing::Values(ApertureSize(0), ApertureSize(3), ApertureSize(5), ApertureSize(7))));
-
-//////////////////////////////////////////////////////////////////////
-// PyrDown
-
-GPU_PERF_TEST(PyrDown, cv::gpu::DeviceInfo, cv::Size, MatType)
-{
-    cv::Size size = GET_PARAM(1);
-    int type = GET_PARAM(2);
-
-    cv::Mat src(size, type);
-    fill(src, 0, 255);
-
-    cv::Mat dst;
-
-    cv::pyrDown(src, dst);
-
-    TEST_CYCLE()
-    {
-        cv::pyrDown(src, dst);
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(ImgProc, PyrDown, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),
-                    MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),
-                    MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4))));
-
-//////////////////////////////////////////////////////////////////////
-// PyrUp
-
-GPU_PERF_TEST(PyrUp, cv::gpu::DeviceInfo, cv::Size, MatType)
-{
-    cv::Size size = GET_PARAM(1);
-    int type = GET_PARAM(2);
-
-    cv::Mat src(size, type);
-    fill(src, 0, 255);
-
-    cv::Mat dst;
-
-    cv::pyrUp(src, dst);
-
-    TEST_CYCLE()
-    {
-        cv::pyrUp(src, dst);
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(ImgProc, PyrUp, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),
-                    MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),
-                    MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4))));
-
-//////////////////////////////////////////////////////////////////////
-// CvtColor
-
-GPU_PERF_TEST(CvtColor, cv::gpu::DeviceInfo, cv::Size, MatDepth, CvtColorInfo)
-{
-    cv::Size size = GET_PARAM(1);
-    int depth = GET_PARAM(2);
-    CvtColorInfo info = GET_PARAM(3);
-
-    cv::Mat src(size, CV_MAKETYPE(depth, info.scn));
-    fill(src, 0, 255);
-
-    cv::Mat dst;
-
-    cv::cvtColor(src, dst, info.code, info.dcn);
-
-    TEST_CYCLE()
-    {
-        cv::cvtColor(src, dst, info.code, info.dcn);
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(ImgProc, CvtColor, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_32F)),
-    testing::Values(CvtColorInfo(4, 4, cv::COLOR_RGBA2BGRA),
-                    CvtColorInfo(4, 1, cv::COLOR_BGRA2GRAY),
-                    CvtColorInfo(1, 4, cv::COLOR_GRAY2BGRA),
-                    CvtColorInfo(3, 3, cv::COLOR_BGR2XYZ),
-                    CvtColorInfo(3, 3, cv::COLOR_XYZ2BGR),
-                    CvtColorInfo(3, 3, cv::COLOR_BGR2YCrCb),
-                    CvtColorInfo(3, 3, cv::COLOR_YCrCb2BGR),
-                    CvtColorInfo(3, 3, cv::COLOR_BGR2YUV),
-                    CvtColorInfo(3, 3, cv::COLOR_YUV2BGR),
-                    CvtColorInfo(3, 3, cv::COLOR_BGR2HSV),
-                    CvtColorInfo(3, 3, cv::COLOR_HSV2BGR),
-                    CvtColorInfo(3, 3, cv::COLOR_BGR2HLS),
-                    CvtColorInfo(3, 3, cv::COLOR_HLS2BGR),
-                    CvtColorInfo(3, 3, cv::COLOR_BGR2Lab),
-                    CvtColorInfo(3, 3, cv::COLOR_RGB2Lab),
-                    CvtColorInfo(3, 3, cv::COLOR_BGR2Luv),
-                    CvtColorInfo(3, 3, cv::COLOR_RGB2Luv),
-                    CvtColorInfo(3, 3, cv::COLOR_Lab2BGR),
-                    CvtColorInfo(3, 3, cv::COLOR_Lab2RGB),
-                    CvtColorInfo(3, 3, cv::COLOR_Luv2BGR),
-                    CvtColorInfo(3, 3, cv::COLOR_Luv2RGB),
-                    CvtColorInfo(1, 3, cv::COLOR_BayerBG2BGR),
-                    CvtColorInfo(1, 3, cv::COLOR_BayerGB2BGR),
-                    CvtColorInfo(1, 3, cv::COLOR_BayerRG2BGR),
-                    CvtColorInfo(1, 3, cv::COLOR_BayerGR2BGR),
-                    CvtColorInfo(4, 4, cv::COLOR_RGBA2mRGBA))));
-
-//////////////////////////////////////////////////////////////////////
-// HoughLines
-
-IMPLEMENT_PARAM_CLASS(DoSort, bool)
-
-GPU_PERF_TEST(HoughLines, cv::gpu::DeviceInfo, cv::Size, DoSort)
-{
-    declare.time(30.0);
-
-    const cv::Size size = GET_PARAM(1);
-
-    const float rho = 1.0f;
-    const float theta = CV_PI / 180.0f;
-    const int threshold = 300;
-
-    cv::RNG rng(123456789);
-
-    cv::Mat src(size, CV_8UC1, cv::Scalar::all(0));
-
-    const int numLines = rng.uniform(500, 2000);
-    for (int i = 0; i < numLines; ++i)
-    {
-        cv::Point p1(rng.uniform(0, src.cols), rng.uniform(0, src.rows));
-        cv::Point p2(rng.uniform(0, src.cols), rng.uniform(0, src.rows));
-        cv::line(src, p1, p2, cv::Scalar::all(255), 2);
-    }
-
-    std::vector<cv::Vec2f> lines;
-    cv::HoughLines(src, lines, rho, theta, threshold);
-
-    TEST_CYCLE()
-    {
-        cv::HoughLines(src, lines, rho, theta, threshold);
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(ImgProc, HoughLines, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(DoSort(false), DoSort(true))));
-
-#endif

modules/gpu/perf_cpu/perf_labeling.cpp

@@ -1,158 +0,0 @@
-/*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.
-//
-//
-//                          License Agreement
-//               For Open Source Computer Vision Library
-//
-// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
-// Copyright (C) 2008-2011, Willow Garage Inc., 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:
-//
-//  * Redistributions of source code must retain the above copyright notice,
-//    this list of conditions and the following disclaimer.
-//
-//  * Redistributions 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 the copyright holders 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 "perf_precomp.hpp"
-
-#ifdef HAVE_CUDA
-
-namespace {
-
-    struct GreedyLabeling
-    {
-        struct dot
-        {
-            int x;
-            int y;
-
-            static dot make(int i, int j)
-            {
-                dot d; d.x = i; d.y = j;
-                return d;
-            }
-        };
-
-        struct InInterval
-        {
-            InInterval(const int& _lo, const int& _hi) : lo(-_lo), hi(_hi) {};
-            const int lo, hi;
-
-            bool operator() (const unsigned char a, const unsigned char b) const
-            {
-                int d = a - b;
-                return lo <= d && d <= hi;
-            }
-        };
-
-        GreedyLabeling(cv::Mat img)
-        : image(img), _labels(image.size(), CV_32SC1, cv::Scalar::all(-1)) {stack = new dot[image.cols * image.rows];}
-
-        ~GreedyLabeling(){delete[] stack;}
-
-        void operator() (cv::Mat labels) const
-        {
-            labels.setTo(cv::Scalar::all(-1));
-            InInterval inInt(0, 2);
-            int cc = -1;
-
-            int* dist_labels = (int*)labels.data;
-            int pitch = labels.step1();
-
-            unsigned char* source = (unsigned char*)image.data;
-            int width = image.cols;
-            int height = image.rows;
-
-            for (int j = 0; j < image.rows; ++j)
-                for (int i = 0; i < image.cols; ++i)
-                {
-                    if (dist_labels[j * pitch + i] != -1) continue;
-
-                    dot* top = stack;
-                    dot p = dot::make(i, j);
-                    cc++;
-
-                    dist_labels[j * pitch + i] = cc;
-
-                    while (top >= stack)
-                    {
-                        int*  dl = &dist_labels[p.y * pitch + p.x];
-                        unsigned char* sp = &source[p.y * image.step1() + p.x];
-
-                        dl[0] = cc;
-
-                        //right
-                        if( p.x < (width - 1) && dl[ +1] == -1 && inInt(sp[0], sp[+1]))
-                            *top++ = dot::make(p.x + 1, p.y);
-
-                        //left
-                        if( p.x > 0 && dl[-1] == -1 && inInt(sp[0], sp[-1]))
-                            *top++ = dot::make(p.x - 1, p.y);
-
-                        //bottom
-                        if( p.y < (height - 1) && dl[+pitch] == -1 && inInt(sp[0], sp[+image.step1()]))
-                            *top++ = dot::make(p.x, p.y + 1);
-
-                        //top
-                        if( p.y > 0 && dl[-pitch] == -1 && inInt(sp[0], sp[-image.step1()]))
-                            *top++ = dot::make(p.x, p.y - 1);
-
-                        p = *--top;
-                    }
-                }
-        }
-
-        cv::Mat image;
-        cv::Mat _labels;
-        dot* stack;
-    };
-}
-
-GPU_PERF_TEST(ConnectedComponents, cv::gpu::DeviceInfo, cv::Size)
-{
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Mat image = readImage("gpu/labeling/aloe-disp.png", cv::IMREAD_GRAYSCALE);
-
-    GreedyLabeling host(image);
-
-    host(host._labels);
-
-    declare.time(1.0);
-
-    TEST_CYCLE()
-    {
-        host(host._labels);
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(Labeling, ConnectedComponents, testing::Combine(ALL_DEVICES, testing::Values(cv::Size(261, 262))));
-
-#endif

modules/gpu/perf_cpu/perf_main.cpp

@@ -1,20 +0,0 @@
-#include "perf_cpu_precomp.hpp"
-
-#ifdef HAVE_CUDA
-
-int main(int argc, char **argv)
-{
-    testing::InitGoogleTest(&argc, argv);
-    perf::TestBase::Init(argc, argv);
-    return RUN_ALL_TESTS();
-}
-
-#else
-
-int main()
-{
-    printf("OpenCV was built without CUDA support\n");
-    return 0;
-}
-
-#endif

modules/gpu/perf_cpu/perf_matop.cpp

@@ -1,124 +0,0 @@
-#include "perf_cpu_precomp.hpp"
-
-#ifdef HAVE_CUDA
-
-//////////////////////////////////////////////////////////////////////
-// SetTo
-
-GPU_PERF_TEST(SetTo, cv::gpu::DeviceInfo, cv::Size, MatType)
-{
-    cv::Size size = GET_PARAM(1);
-    int type = GET_PARAM(2);
-
-    cv::Mat src(size, type);
-    cv::Scalar val(1, 2, 3, 4);
-
-    src.setTo(val);
-
-    TEST_CYCLE()
-    {
-        src.setTo(val);
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(MatOp, SetTo, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),
-                    MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),
-                    MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4),
-                    MatType(CV_64FC1), MatType(CV_64FC3), MatType(CV_64FC4))));
-
-//////////////////////////////////////////////////////////////////////
-// SetToMasked
-
-GPU_PERF_TEST(SetToMasked, cv::gpu::DeviceInfo, cv::Size, MatType)
-{
-    cv::Size size = GET_PARAM(1);
-    int type = GET_PARAM(2);
-
-    cv::Mat src(size, type);
-    fill(src, 0, 255);
-
-    cv::Mat mask(size, CV_8UC1);
-    fill(mask, 0, 2);
-
-    cv::Scalar val(1, 2, 3, 4);
-
-    src.setTo(val, mask);
-
-    TEST_CYCLE()
-    {
-        src.setTo(val, mask);
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(MatOp, SetToMasked, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),
-                    MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),
-                    MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4),
-                    MatType(CV_64FC1), MatType(CV_64FC3), MatType(CV_64FC4))));
-
-//////////////////////////////////////////////////////////////////////
-// CopyToMasked
-
-GPU_PERF_TEST(CopyToMasked, cv::gpu::DeviceInfo, cv::Size, MatType)
-{
-    cv::Size size = GET_PARAM(1);
-    int type = GET_PARAM(2);
-
-    cv::Mat src(size, type);
-    fill(src, 0, 255);
-
-    cv::Mat mask(size, CV_8UC1);
-    fill(mask, 0, 2);
-
-    cv::Mat dst;
-
-    src.copyTo(dst, mask);
-
-    TEST_CYCLE()
-    {
-        src.copyTo(dst, mask);
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(MatOp, CopyToMasked, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),
-                    MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),
-                    MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4),
-                    MatType(CV_64FC1), MatType(CV_64FC3), MatType(CV_64FC4))));
-
-//////////////////////////////////////////////////////////////////////
-// ConvertTo
-
-GPU_PERF_TEST(ConvertTo, cv::gpu::DeviceInfo, cv::Size, MatDepth, MatDepth)
-{
-    cv::Size size = GET_PARAM(1);
-    int depth1 = GET_PARAM(2);
-    int depth2 = GET_PARAM(3);
-
-    cv::Mat src(size, depth1);
-    fill(src, 0, 255);
-
-    cv::Mat dst;
-
-    src.convertTo(dst, depth2, 0.5, 1.0);
-
-    TEST_CYCLE()
-    {
-        src.convertTo(dst, depth2, 0.5, 1.0);
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(MatOp, ConvertTo, testing::Combine(
-    ALL_DEVICES,
-    GPU_TYPICAL_MAT_SIZES,
-    testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_32F), MatDepth(CV_64F)),
-    testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_32F), MatDepth(CV_64F))));
-
-#endif

modules/gpu/perf_cpu/perf_objdetect.cpp

@@ -1,74 +0,0 @@
-#include "perf_cpu_precomp.hpp"
-
-#ifdef HAVE_CUDA
-
-///////////////////////////////////////////////////////////////
-// HOG
-
-GPU_PERF_TEST_1(HOG, cv::gpu::DeviceInfo)
-{
-    cv::Mat img = readImage("gpu/hog/road.png", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(img.empty());
-
-    std::vector<cv::Rect> found_locations;
-
-    cv::HOGDescriptor hog;
-    hog.setSVMDetector(cv::gpu::HOGDescriptor::getDefaultPeopleDetector());
-
-    hog.detectMultiScale(img, found_locations);
-
-    TEST_CYCLE()
-    {
-        hog.detectMultiScale(img, found_locations);
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(ObjDetect, HOG, ALL_DEVICES);
-
-///////////////////////////////////////////////////////////////
-// HaarClassifier
-
-GPU_PERF_TEST_1(HaarClassifier, cv::gpu::DeviceInfo)
-{
-    cv::Mat img = readImage("gpu/haarcascade/group_1_640x480_VGA.pgm", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(img.empty());
-
-    cv::CascadeClassifier cascade;
-
-    ASSERT_TRUE(cascade.load(perf::TestBase::getDataPath("gpu/perf/haarcascade_frontalface_alt.xml")));
-
-    std::vector<cv::Rect> rects;
-
-    cascade.detectMultiScale(img, rects);
-
-    TEST_CYCLE()
-    {
-        cascade.detectMultiScale(img, rects);
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(ObjDetect, HaarClassifier, ALL_DEVICES);
-
-//===================== LBP cascade ==========================//
-GPU_PERF_TEST_1(LBPClassifier, cv::gpu::DeviceInfo)
-{
-    cv::Mat img = readImage("gpu/haarcascade/group_1_640x480_VGA.pgm", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(img.empty());
-
-    cv::CascadeClassifier cascade;
-
-    ASSERT_TRUE(cascade.load(perf::TestBase::getDataPath("gpu/lbpcascade/lbpcascade_frontalface.xml")));
-
-    std::vector<cv::Rect> rects;
-
-    cascade.detectMultiScale(img, rects);
-
-    TEST_CYCLE()
-    {
-        cascade.detectMultiScale(img, rects);
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(ObjDetect, LBPClassifier, ALL_DEVICES);
-
-#endif

modules/gpu/perf_cpu/perf_utility.cpp

@@ -1,220 +0,0 @@
-#include "perf_cpu_precomp.hpp"
-
-using namespace std;
-using namespace cv;
-using namespace cv::gpu;
-
-void fill(Mat& m, double a, double b)
-{
-    RNG rng(123456789);
-    rng.fill(m, RNG::UNIFORM, a, b);
-}
-
-void PrintTo(const CvtColorInfo& info, ostream* os)
-{
-    static const char* str[] =
-    {
-        "BGR2BGRA",
-        "BGRA2BGR",
-        "BGR2RGBA",
-        "RGBA2BGR",
-        "BGR2RGB",
-        "BGRA2RGBA",
-
-        "BGR2GRAY",
-        "RGB2GRAY",
-        "GRAY2BGR",
-        "GRAY2BGRA",
-        "BGRA2GRAY",
-        "RGBA2GRAY",
-
-        "BGR2BGR565",
-        "RGB2BGR565",
-        "BGR5652BGR",
-        "BGR5652RGB",
-        "BGRA2BGR565",
-        "RGBA2BGR565",
-        "BGR5652BGRA",
-        "BGR5652RGBA",
-
-        "GRAY2BGR565",
-        "BGR5652GRAY",
-
-        "BGR2BGR555",
-        "RGB2BGR555",
-        "BGR5552BGR",
-        "BGR5552RGB",
-        "BGRA2BGR555",
-        "RGBA2BGR555",
-        "BGR5552BGRA",
-        "BGR5552RGBA",
-
-        "GRAY2BGR555",
-        "BGR5552GRAY",
-
-        "BGR2XYZ",
-        "RGB2XYZ",
-        "XYZ2BGR",
-        "XYZ2RGB",
-
-        "BGR2YCrCb",
-        "RGB2YCrCb",
-        "YCrCb2BGR",
-        "YCrCb2RGB",
-
-        "BGR2HSV",
-        "RGB2HSV",
-
-        "",
-        "",
-
-        "BGR2Lab",
-        "RGB2Lab",
-
-        "BayerBG2BGR",
-        "BayerGB2BGR",
-        "BayerRG2BGR",
-        "BayerGR2BGR",
-
-        "BGR2Luv",
-        "RGB2Luv",
-
-        "BGR2HLS",
-        "RGB2HLS",
-
-        "HSV2BGR",
-        "HSV2RGB",
-
-        "Lab2BGR",
-        "Lab2RGB",
-        "Luv2BGR",
-        "Luv2RGB",
-
-        "HLS2BGR",
-        "HLS2RGB",
-
-        "BayerBG2BGR_VNG",
-        "BayerGB2BGR_VNG",
-        "BayerRG2BGR_VNG",
-        "BayerGR2BGR_VNG",
-
-        "BGR2HSV_FULL",
-        "RGB2HSV_FULL",
-        "BGR2HLS_FULL",
-        "RGB2HLS_FULL",
-
-        "HSV2BGR_FULL",
-        "HSV2RGB_FULL",
-        "HLS2BGR_FULL",
-        "HLS2RGB_FULL",
-
-        "LBGR2Lab",
-        "LRGB2Lab",
-        "LBGR2Luv",
-        "LRGB2Luv",
-
-        "Lab2LBGR",
-        "Lab2LRGB",
-        "Luv2LBGR",
-        "Luv2LRGB",
-
-        "BGR2YUV",
-        "RGB2YUV",
-        "YUV2BGR",
-        "YUV2RGB",
-
-        "BayerBG2GRAY",
-        "BayerGB2GRAY",
-        "BayerRG2GRAY",
-        "BayerGR2GRAY",
-
-        //YUV 4:2:0 formats family
-        "YUV2RGB_NV12",
-        "YUV2BGR_NV12",
-        "YUV2RGB_NV21",
-        "YUV2BGR_NV21",
-
-        "YUV2RGBA_NV12",
-        "YUV2BGRA_NV12",
-        "YUV2RGBA_NV21",
-        "YUV2BGRA_NV21",
-
-        "YUV2RGB_YV12",
-        "YUV2BGR_YV12",
-        "YUV2RGB_IYUV",
-        "YUV2BGR_IYUV",
-
-        "YUV2RGBA_YV12",
-        "YUV2BGRA_YV12",
-        "YUV2RGBA_IYUV",
-        "YUV2BGRA_IYUV",
-
-        "YUV2GRAY_420",
-
-        //YUV 4:2:2 formats family
-        "YUV2RGB_UYVY",
-        "YUV2BGR_UYVY",
-        "YUV2RGB_VYUY",
-        "YUV2BGR_VYUY",
-
-        "YUV2RGBA_UYVY",
-        "YUV2BGRA_UYVY",
-        "YUV2RGBA_VYUY",
-        "YUV2BGRA_VYUY",
-
-        "YUV2RGB_YUY2",
-        "YUV2BGR_YUY2",
-        "YUV2RGB_YVYU",
-        "YUV2BGR_YVYU",
-
-        "YUV2RGBA_YUY2",
-        "YUV2BGRA_YUY2",
-        "YUV2RGBA_YVYU",
-        "YUV2BGRA_YVYU",
-
-        "YUV2GRAY_UYVY",
-        "YUV2GRAY_YUY2",
-
-        // alpha premultiplication
-        "RGBA2mRGBA",
-        "mRGBA2RGBA",
-
-        "COLORCVT_MAX"
-    };
-
-    *os << str[info.code];
-}
-
-void cv::gpu::PrintTo(const DeviceInfo& info, ostream* os)
-{
-    *os << info.name();
-}
-
-Mat readImage(const string& fileName, int flags)
-{
-    return imread(perf::TestBase::getDataPath(fileName), flags);
-}
-
-const vector<DeviceInfo>& devices()
-{
-    static vector<DeviceInfo> devs;
-    static bool first = true;
-
-    if (first)
-    {
-        int deviceCount = getCudaEnabledDeviceCount();
-
-        devs.reserve(deviceCount);
-
-        for (int i = 0; i < deviceCount; ++i)
-        {
-            DeviceInfo info(i);
-            if (info.isCompatible())
-                devs.push_back(info);
-        }
-
-        first = false;
-    }
-
-    return devs;
-}

modules/gpu/perf_cpu/perf_utility.hpp

@@ -1,77 +0,0 @@
-#ifndef __OPENCV_PERF_GPU_UTILITY_HPP__
-#define __OPENCV_PERF_GPU_UTILITY_HPP__
-
-void fill(cv::Mat& m, double a, double b);
-
-using perf::MatType;
-using perf::MatDepth;
-
-CV_ENUM(BorderMode, cv::BORDER_REFLECT101, cv::BORDER_REPLICATE, cv::BORDER_CONSTANT, cv::BORDER_REFLECT, cv::BORDER_WRAP)
-        CV_ENUM(Interpolation, cv::INTER_NEAREST, cv::INTER_LINEAR, cv::INTER_CUBIC, cv::INTER_AREA)
-CV_ENUM(NormType, cv::NORM_INF, cv::NORM_L1, cv::NORM_L2, cv::NORM_HAMMING)
-
-struct CvtColorInfo
-{
-    int scn;
-    int dcn;
-    int code;
-
-    explicit CvtColorInfo(int scn_=0, int dcn_=0, int code_=0) : scn(scn_), dcn(dcn_), code(code_) {}
-};
-
-void PrintTo(const CvtColorInfo& info, std::ostream* os);
-
-#define IMPLEMENT_PARAM_CLASS(name, type) \
-    class name \
-    { \
-    public: \
-        name ( type arg = type ()) : val_(arg) {} \
-        operator type () const {return val_;} \
-    private: \
-        type val_; \
-    }; \
-    inline void PrintTo( name param, std::ostream* os) \
-    { \
-        *os << #name <<  " = " << testing::PrintToString(static_cast< type >(param)); \
-    }
-
-IMPLEMENT_PARAM_CLASS(Channels, int)
-
-namespace cv { namespace gpu
-{
-    void PrintTo(const cv::gpu::DeviceInfo& info, std::ostream* os);
-}}
-
-#define GPU_PERF_TEST(name, ...) \
-    struct name : perf::TestBaseWithParam< std::tr1::tuple< __VA_ARGS__ > > \
-    { \
-    public: \
-        name() {} \
-    protected: \
-        void PerfTestBody(); \
-    }; \
-    TEST_P(name, perf){ RunPerfTestBody(); } \
-    void name :: PerfTestBody()
-
-#define GPU_PERF_TEST_1(name, param_type) \
-    struct name : perf::TestBaseWithParam< param_type > \
-    { \
-    public: \
-        name() {} \
-    protected: \
-        void PerfTestBody(); \
-    }; \
-    TEST_P(name, perf){ RunPerfTestBody(); } \
-    void name :: PerfTestBody()
-
-#define GPU_TYPICAL_MAT_SIZES testing::Values(perf::szSXGA, perf::sz1080p, cv::Size(1800, 1500))
-
-cv::Mat readImage(const std::string& fileName, int flags = cv::IMREAD_COLOR);
-
-const std::vector<cv::gpu::DeviceInfo>& devices();
-
-#define ALL_DEVICES testing::ValuesIn(devices())
-
-#define GET_PARAM(k) std::tr1::get< k >(GetParam())
-
-#endif // __OPENCV_PERF_GPU_UTILITY_HPP__

modules/gpu/perf_cpu/perf_video.cpp

@@ -1,466 +0,0 @@
-#include "perf_cpu_precomp.hpp"
-
-#ifdef HAVE_CUDA
-
-//////////////////////////////////////////////////////
-// GoodFeaturesToTrack
-
-IMPLEMENT_PARAM_CLASS(MinDistance, double)
-
-GPU_PERF_TEST(GoodFeaturesToTrack, cv::gpu::DeviceInfo, MinDistance)
-{
-    double minDistance = GET_PARAM(1);
-
-    cv::Mat image = readImage("gpu/perf/aloe.jpg", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(image.empty());
-
-    cv::Mat corners;
-
-    cv::goodFeaturesToTrack(image, corners, 8000, 0.01, minDistance);
-
-    TEST_CYCLE()
-    {
-        cv::goodFeaturesToTrack(image, corners, 8000, 0.01, minDistance);
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(Video, GoodFeaturesToTrack, testing::Combine(
-    ALL_DEVICES,
-    testing::Values(MinDistance(0.0), MinDistance(3.0))));
-
-//////////////////////////////////////////////////////
-// PyrLKOpticalFlowSparse
-
-IMPLEMENT_PARAM_CLASS(GraySource, bool)
-IMPLEMENT_PARAM_CLASS(Points, int)
-IMPLEMENT_PARAM_CLASS(WinSize, int)
-IMPLEMENT_PARAM_CLASS(Levels, int)
-IMPLEMENT_PARAM_CLASS(Iters, int)
-
-GPU_PERF_TEST(PyrLKOpticalFlowSparse, cv::gpu::DeviceInfo, GraySource, Points, WinSize, Levels, Iters)
-{
-    bool useGray = GET_PARAM(1);
-    int points = GET_PARAM(2);
-    int win_size = GET_PARAM(3);
-    int levels = GET_PARAM(4);
-    int iters = GET_PARAM(5);
-
-    cv::Mat frame0 = readImage("gpu/opticalflow/frame0.png", useGray ? cv::IMREAD_GRAYSCALE : cv::IMREAD_COLOR);
-    ASSERT_FALSE(frame0.empty());
-
-    cv::Mat frame1 = readImage("gpu/opticalflow/frame1.png", useGray ? cv::IMREAD_GRAYSCALE : cv::IMREAD_COLOR);
-    ASSERT_FALSE(frame1.empty());
-
-    cv::Mat gray_frame;
-    if (useGray)
-        gray_frame = frame0;
-    else
-        cv::cvtColor(frame0, gray_frame, cv::COLOR_BGR2GRAY);
-
-    cv::Mat pts;
-    cv::goodFeaturesToTrack(gray_frame, pts, points, 0.01, 0.0);
-
-    cv::Mat nextPts;
-    cv::Mat status;
-
-    cv::calcOpticalFlowPyrLK(frame0, frame1, pts, nextPts, status, cv::noArray(),
-                             cv::Size(win_size, win_size), levels - 1,
-                             cv::TermCriteria(cv::TermCriteria::COUNT + cv::TermCriteria::EPS, iters, 0.01));
-
-    declare.time(20.0);
-
-    TEST_CYCLE()
-    {
-        cv::calcOpticalFlowPyrLK(frame0, frame1, pts, nextPts, status, cv::noArray(),
-                                 cv::Size(win_size, win_size), levels - 1,
-                                 cv::TermCriteria(cv::TermCriteria::COUNT + cv::TermCriteria::EPS, iters, 0.01));
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(Video, PyrLKOpticalFlowSparse, testing::Combine(
-    ALL_DEVICES,
-    testing::Values(GraySource(true), GraySource(false)),
-    testing::Values(Points(1000), Points(2000), Points(4000), Points(8000)),
-    testing::Values(WinSize(9), WinSize(13), WinSize(17), WinSize(21)),
-    testing::Values(Levels(1), Levels(2), Levels(3)),
-    testing::Values(Iters(1), Iters(10), Iters(30))));
-
-//////////////////////////////////////////////////////
-// FarnebackOpticalFlowTest
-
-GPU_PERF_TEST_1(FarnebackOpticalFlowTest, cv::gpu::DeviceInfo)
-{
-    cv::Mat frame0 = readImage("gpu/opticalflow/frame0.png", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(frame0.empty());
-
-    cv::Mat frame1 = readImage("gpu/opticalflow/frame1.png", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(frame1.empty());
-
-    cv::Mat flow;
-
-    int numLevels = 5;
-    double pyrScale = 0.5;
-    int winSize = 13;
-    int numIters = 10;
-    int polyN = 5;
-    double polySigma = 1.1;
-    int flags = 0;
-
-    cv::calcOpticalFlowFarneback(frame0, frame1, flow, pyrScale, numLevels, winSize, numIters, polyN, polySigma, flags);
-
-    declare.time(10);
-
-    TEST_CYCLE()
-    {
-        cv::calcOpticalFlowFarneback(frame0, frame1, flow, pyrScale, numLevels, winSize, numIters, polyN, polySigma, flags);
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(Video, FarnebackOpticalFlowTest, ALL_DEVICES);
-
-//////////////////////////////////////////////////////
-// FGDStatModel
-
-namespace cv
-{
-    template<> void Ptr<CvBGStatModel>::delete_obj()
-    {
-        cvReleaseBGStatModel(&obj);
-    }
-}
-
-GPU_PERF_TEST(FGDStatModel, cv::gpu::DeviceInfo, std::string)
-{
-    std::string inputFile = perf::TestBase::getDataPath(std::string("gpu/video/") + GET_PARAM(1));
-
-    cv::VideoCapture cap(inputFile);
-    ASSERT_TRUE(cap.isOpened());
-
-    cv::Mat frame;
-    cap >> frame;
-    ASSERT_FALSE(frame.empty());
-
-    IplImage ipl_frame = frame;
-    cv::Ptr<CvBGStatModel> model(cvCreateFGDStatModel(&ipl_frame));
-
-    declare.time(60);
-
-    for (int i = 0; i < 10; ++i)
-    {
-        cap >> frame;
-        ASSERT_FALSE(frame.empty());
-
-        ipl_frame = frame;
-
-        startTimer();
-        next();
-
-        cvUpdateBGStatModel(&ipl_frame, model);
-
-        stopTimer();
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(Video, FGDStatModel, testing::Combine(
-    ALL_DEVICES,
-    testing::Values(std::string("768x576.avi"), std::string("1920x1080.avi"))));
-
-//////////////////////////////////////////////////////
-// MOG
-
-IMPLEMENT_PARAM_CLASS(LearningRate, double)
-
-GPU_PERF_TEST(MOG, cv::gpu::DeviceInfo, std::string, Channels, LearningRate)
-{
-    std::string inputFile = perf::TestBase::getDataPath(std::string("gpu/video/") + GET_PARAM(1));
-    int cn = GET_PARAM(2);
-    double learningRate = GET_PARAM(3);
-
-    cv::VideoCapture cap(inputFile);
-    ASSERT_TRUE(cap.isOpened());
-
-    cv::Mat frame;
-
-    cv::BackgroundSubtractorMOG mog;
-    cv::Mat foreground;
-
-    cap >> frame;
-    ASSERT_FALSE(frame.empty());
-
-    if (cn != 3)
-    {
-        cv::Mat temp;
-        if (cn == 1)
-            cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
-        else
-            cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);
-        cv::swap(temp, frame);
-    }
-
-    mog(frame, foreground, learningRate);
-
-    for (int i = 0; i < 10; ++i)
-    {
-        cap >> frame;
-        ASSERT_FALSE(frame.empty());
-
-        if (cn != 3)
-        {
-            cv::Mat temp;
-            if (cn == 1)
-                cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
-            else
-                cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);
-            cv::swap(temp, frame);
-        }
-
-        startTimer(); next();
-        mog(frame, foreground, learningRate);
-        stopTimer();
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(Video, MOG, testing::Combine(
-    ALL_DEVICES,
-    testing::Values(std::string("768x576.avi"), std::string("1920x1080.avi")),
-    testing::Values(Channels(1), Channels(3)/*, Channels(4)*/),
-    testing::Values(LearningRate(0.0), LearningRate(0.01))));
-
-//////////////////////////////////////////////////////
-// MOG2
-
-GPU_PERF_TEST(MOG2_update, cv::gpu::DeviceInfo, std::string, Channels)
-{
-    std::string inputFile = perf::TestBase::getDataPath(std::string("gpu/video/") + GET_PARAM(1));
-    int cn = GET_PARAM(2);
-
-    cv::VideoCapture cap(inputFile);
-    ASSERT_TRUE(cap.isOpened());
-
-    cv::Mat frame;
-
-    cv::BackgroundSubtractorMOG2 mog2;
-    cv::Mat foreground;
-
-    cap >> frame;
-    ASSERT_FALSE(frame.empty());
-
-    if (cn != 3)
-    {
-        cv::Mat temp;
-        if (cn == 1)
-            cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
-        else
-            cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);
-        cv::swap(temp, frame);
-    }
-
-    mog2(frame, foreground);
-
-    for (int i = 0; i < 10; ++i)
-    {
-        cap >> frame;
-        ASSERT_FALSE(frame.empty());
-
-        if (cn != 3)
-        {
-            cv::Mat temp;
-            if (cn == 1)
-                cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
-            else
-                cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);
-            cv::swap(temp, frame);
-        }
-
-        startTimer(); next();
-        mog2(frame, foreground);
-        stopTimer();
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(Video, MOG2_update, testing::Combine(
-    ALL_DEVICES,
-    testing::Values(std::string("768x576.avi"), std::string("1920x1080.avi")),
-    testing::Values(Channels(1), Channels(3)/*, Channels(4)*/)));
-
-GPU_PERF_TEST(MOG2_getBackgroundImage, cv::gpu::DeviceInfo, std::string, Channels)
-{
-    std::string inputFile = perf::TestBase::getDataPath(std::string("gpu/video/") + GET_PARAM(1));
-    int cn = GET_PARAM(2);
-
-    cv::VideoCapture cap(inputFile);
-    ASSERT_TRUE(cap.isOpened());
-
-    cv::Mat frame;
-
-    cv::BackgroundSubtractorMOG2 mog2;
-    cv::Mat foreground;
-
-    for (int i = 0; i < 10; ++i)
-    {
-        cap >> frame;
-        ASSERT_FALSE(frame.empty());
-
-        if (cn != 3)
-        {
-            cv::Mat temp;
-            if (cn == 1)
-                cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
-            else
-                cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);
-            cv::swap(temp, frame);
-        }
-
-        mog2(frame, foreground);
-    }
-
-    cv::Mat background;
-    mog2.getBackgroundImage(background);
-
-    TEST_CYCLE()
-    {
-        mog2.getBackgroundImage(background);
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(Video, MOG2_getBackgroundImage, testing::Combine(
-    ALL_DEVICES,
-    testing::Values(std::string("768x576.avi"), std::string("1920x1080.avi")),
-    testing::Values(/*Channels(1),*/ Channels(3)/*, Channels(4)*/)));
-
-//////////////////////////////////////////////////////
-// GMG
-
-IMPLEMENT_PARAM_CLASS(MaxFeatures, int)
-
-GPU_PERF_TEST(GMG, cv::gpu::DeviceInfo, std::string, Channels, MaxFeatures)
-{
-    std::string inputFile = perf::TestBase::getDataPath(std::string("gpu/video/") + GET_PARAM(1));
-    int cn = GET_PARAM(2);
-    int maxFeatures = GET_PARAM(3);
-
-    cv::VideoCapture cap(inputFile);
-    ASSERT_TRUE(cap.isOpened());
-
-    cv::Mat frame;
-    cap >> frame;
-    ASSERT_FALSE(frame.empty());
-
-    if (cn != 3)
-    {
-        cv::Mat temp;
-        if (cn == 1)
-            cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
-        else
-            cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);
-        cv::swap(temp, frame);
-    }
-
-    cv::Mat fgmask;
-    cv::Mat zeros(frame.size(), CV_8UC1, cv::Scalar::all(0));
-
-    cv::BackgroundSubtractorGMG gmg;
-    gmg.set("maxFeatures", maxFeatures);
-    gmg.initialize(frame.size(), 0.0, 255.0);
-
-    gmg(frame, fgmask);
-
-    for (int i = 0; i < 150; ++i)
-    {
-        cap >> frame;
-        if (frame.empty())
-        {
-            cap.open(inputFile);
-            cap >> frame;
-        }
-
-        if (cn != 3)
-        {
-            cv::Mat temp;
-            if (cn == 1)
-                cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
-            else
-                cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);
-            cv::swap(temp, frame);
-        }
-
-        startTimer(); next();
-        gmg(frame, fgmask);
-        stopTimer();
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(Video, GMG, testing::Combine(
-    ALL_DEVICES,
-    testing::Values(std::string("768x576.avi"), std::string("1920x1080.avi")),
-    testing::Values(Channels(1), Channels(3), Channels(4)),
-    testing::Values(MaxFeatures(20), MaxFeatures(40), MaxFeatures(60))));
-
-//////////////////////////////////////////////////////
-// VideoWriter
-
-#ifdef WIN32
-
-GPU_PERF_TEST(VideoWriter, cv::gpu::DeviceInfo, std::string)
-{
-    const double FPS = 25.0;
-
-    std::string inputFile = perf::TestBase::getDataPath(std::string("gpu/video/") + GET_PARAM(1));
-    std::string outputFile = cv::tempfile(".avi");
-
-    cv::VideoCapture reader(inputFile);
-    ASSERT_TRUE( reader.isOpened() );
-
-    cv::VideoWriter writer;
-
-    cv::Mat frame;
-
-    declare.time(30);
-
-    for (int i = 0; i < 10; ++i)
-    {
-        reader >> frame;
-        ASSERT_FALSE(frame.empty());
-
-        if (!writer.isOpened())
-            writer.open(outputFile, CV_FOURCC('X', 'V', 'I', 'D'), FPS, frame.size());
-
-        startTimer(); next();
-        writer.write(frame);
-        stopTimer();
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(Video, VideoWriter, testing::Combine(
-    ALL_DEVICES,
-    testing::Values(std::string("768x576.avi"), std::string("1920x1080.avi"))));
-
-#endif // WIN32
-
-//////////////////////////////////////////////////////
-// VideoReader
-
-GPU_PERF_TEST(VideoReader, cv::gpu::DeviceInfo, std::string)
-{
-    std::string inputFile = perf::TestBase::getDataPath(std::string("gpu/video/") + GET_PARAM(1));
-
-    cv::VideoCapture reader(inputFile);
-    ASSERT_TRUE( reader.isOpened() );
-
-    cv::Mat frame;
-
-    reader >> frame;
-
-    declare.time(20);
-
-    TEST_CYCLE_N(10)
-    {
-        reader >> frame;
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(Video, VideoReader, testing::Combine(
-    ALL_DEVICES,
-    testing::Values(std::string("768x576.avi"), std::string("1920x1080.avi"))));
-
-#endif