updated gpu-vs-cpu performance tests

cmake/OpenCVModule.cmake

@@ -513,7 +513,7 @@ macro(ocv_add_precompiled_headers the_target)
     if("${the_target}" MATCHES "^opencv_test_.*$")
         SET(pch_path "test/test_")
 	elseif("${the_target}" MATCHES "opencv_perf_gpu_cpu")
-	    SET(pch_path "perf_cpu/perf_")
+	    SET(pch_path "perf_cpu/perf_cpu_")
     elseif("${the_target}" MATCHES "^opencv_perf_.*$")
         SET(pch_path "perf/perf_")
     else()

modules/gpu/CMakeLists.txt

@@ -125,7 +125,7 @@ ocv_add_perf_tests()
 set(perf_cpu_path "${CMAKE_CURRENT_SOURCE_DIR}/perf_cpu")
 if(BUILD_PERF_TESTS AND EXISTS "${perf_cpu_path}")
     # opencv_highgui is required for imread/imwrite
-    set(perf_deps ${the_module} opencv_ts opencv_highgui)
+    set(perf_deps ${the_module} opencv_ts opencv_highgui opencv_imgproc opencv_calib3d opencv_objdetect opencv_video opencv_nonfree)
     ocv_check_dependencies(${perf_deps})
 
     if(OCV_DEPENDENCIES_FOUND)

modules/gpu/perf_cpu/perf_calib3d.cpp

-#include "perf_precomp.hpp"
+#include "perf_cpu_precomp.hpp"
 
 #ifdef HAVE_CUDA
 
-//////////////////////////////////////////////////////////////////////
-// TransformPoints
-
-GPU_PERF_TEST_1(TransformPoints, cv::gpu::DeviceInfo)
-{
-    cv::gpu::DeviceInfo devInfo = GetParam();
-
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Mat src_host(1, 10000, CV_32FC3);
-
-    declare.in(src_host, WARMUP_RNG);
-
-    cv::gpu::GpuMat src(src_host);
-    cv::gpu::GpuMat dst;
-
-    TEST_CYCLE()
-    {
-        cv::gpu::transformPoints(src, cv::Mat::ones(1, 3, CV_32FC1), cv::Mat::ones(1, 3, CV_32FC1), dst);
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(Calib3D, TransformPoints, ALL_DEVICES);
-
 //////////////////////////////////////////////////////////////////////
 // ProjectPoints
 
 GPU_PERF_TEST_1(ProjectPoints, cv::gpu::DeviceInfo)
 {
-    cv::gpu::DeviceInfo devInfo = GetParam();
-
-    cv::gpu::setDevice(devInfo.deviceID());
+    cv::Mat src(1, 10000, CV_32FC3);
 
-    cv::Mat src_host(1, 10000, CV_32FC3);
+    declare.in(src, WARMUP_RNG);
 
-    declare.in(src_host, WARMUP_RNG);
-
-    cv::gpu::GpuMat src(src_host);
-    cv::gpu::GpuMat dst;
+    cv::Mat dst;
 
     TEST_CYCLE()
     {
-        cv::gpu::projectPoints(src, cv::Mat::ones(1, 3, CV_32FC1), cv::Mat::ones(1, 3, CV_32FC1), cv::Mat::ones(3, 3, CV_32FC1), cv::Mat(), dst);
+        cv::projectPoints(src, cv::Mat::ones(1, 3, CV_32FC1), cv::Mat::ones(1, 3, CV_32FC1), cv::Mat::ones(3, 3, CV_32FC1), cv::Mat(), dst);
     }
 }
 
@@ -55,10 +26,6 @@ INSTANTIATE_TEST_CASE_P(Calib3D, ProjectPoints, ALL_DEVICES);
 
 GPU_PERF_TEST_1(SolvePnPRansac, cv::gpu::DeviceInfo)
 {
-    cv::gpu::DeviceInfo devInfo = GetParam();
-
-    cv::gpu::setDevice(devInfo.deviceID());
-
     cv::Mat object(1, 10000, CV_32FC3);
     cv::Mat image(1, 10000, CV_32FC2);
 
@@ -70,7 +37,7 @@ GPU_PERF_TEST_1(SolvePnPRansac, cv::gpu::DeviceInfo)
 
     TEST_CYCLE()
     {
-        cv::gpu::solvePnPRansac(object, image, cv::Mat::ones(3, 3, CV_32FC1), cv::Mat(1, 8, CV_32F, cv::Scalar::all(0)), rvec, tvec);
+        cv::solvePnPRansac(object, image, cv::Mat::ones(3, 3, CV_32FC1), cv::Mat(1, 8, CV_32F, cv::Scalar::all(0)), rvec, tvec);
     }
 }
 
@@ -81,21 +48,15 @@ INSTANTIATE_TEST_CASE_P(Calib3D, SolvePnPRansac, ALL_DEVICES);
 
 GPU_PERF_TEST_1(StereoBM, cv::gpu::DeviceInfo)
 {
-    cv::gpu::DeviceInfo devInfo = GetParam();
-
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Mat img_l_host = readImage("gpu/perf/aloe.jpg", cv::IMREAD_GRAYSCALE);
-    cv::Mat img_r_host = readImage("gpu/perf/aloeR.jpg", cv::IMREAD_GRAYSCALE);
+    cv::Mat img_l = readImage("gpu/perf/aloe.jpg", cv::IMREAD_GRAYSCALE);
+    cv::Mat img_r = readImage("gpu/perf/aloeR.jpg", cv::IMREAD_GRAYSCALE);
 
-    ASSERT_FALSE(img_l_host.empty());
-    ASSERT_FALSE(img_r_host.empty());
+    ASSERT_FALSE(img_l.empty());
+    ASSERT_FALSE(img_r.empty());
 
-    cv::gpu::GpuMat img_l(img_l_host);
-    cv::gpu::GpuMat img_r(img_r_host);
-    cv::gpu::GpuMat dst;
+    cv::Mat dst;
 
-    cv::gpu::StereoBM_GPU bm(0, 256);
+    cv::StereoBM bm(0, 256);
 
     declare.time(5.0);
 
@@ -107,96 +68,5 @@ GPU_PERF_TEST_1(StereoBM, cv::gpu::DeviceInfo)
 
 INSTANTIATE_TEST_CASE_P(Calib3D, StereoBM, ALL_DEVICES);
 
-//////////////////////////////////////////////////////////////////////
-// StereoBeliefPropagation
-
-GPU_PERF_TEST_1(StereoBeliefPropagation, cv::gpu::DeviceInfo)
-{
-    cv::gpu::DeviceInfo devInfo = GetParam();
-
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Mat img_l_host = readImage("gpu/stereobp/aloe-L.png");
-    cv::Mat img_r_host = readImage("gpu/stereobp/aloe-R.png");
-
-    ASSERT_FALSE(img_l_host.empty());
-    ASSERT_FALSE(img_r_host.empty());
-
-    cv::gpu::GpuMat img_l(img_l_host);
-    cv::gpu::GpuMat img_r(img_r_host);
-    cv::gpu::GpuMat dst;
-
-    cv::gpu::StereoBeliefPropagation bp(64);
-
-    declare.time(10.0);
-
-    TEST_CYCLE()
-    {
-        bp(img_l, img_r, dst);
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(Calib3D, StereoBeliefPropagation, ALL_DEVICES);
-
-//////////////////////////////////////////////////////////////////////
-// StereoConstantSpaceBP
-
-GPU_PERF_TEST_1(StereoConstantSpaceBP, cv::gpu::DeviceInfo)
-{
-    cv::gpu::DeviceInfo devInfo = GetParam();
-
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Mat img_l_host = readImage("gpu/stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE);
-    cv::Mat img_r_host = readImage("gpu/stereobm/aloe-R.png", cv::IMREAD_GRAYSCALE);
-
-    ASSERT_FALSE(img_l_host.empty());
-    ASSERT_FALSE(img_r_host.empty());
-
-    cv::gpu::GpuMat img_l(img_l_host);
-    cv::gpu::GpuMat img_r(img_r_host);
-    cv::gpu::GpuMat dst;
-
-    cv::gpu::StereoConstantSpaceBP bp(128);
-
-    declare.time(10.0);
-
-    TEST_CYCLE()
-    {
-        bp(img_l, img_r, dst);
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(Calib3D, StereoConstantSpaceBP, ALL_DEVICES);
-
-//////////////////////////////////////////////////////////////////////
-// DisparityBilateralFilter
-
-GPU_PERF_TEST_1(DisparityBilateralFilter, cv::gpu::DeviceInfo)
-{
-    cv::gpu::DeviceInfo devInfo = GetParam();
-
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Mat img_host = readImage("gpu/stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE);
-    cv::Mat disp_host = readImage("gpu/stereobm/aloe-disp.png", cv::IMREAD_GRAYSCALE);
-
-    ASSERT_FALSE(img_host.empty());
-    ASSERT_FALSE(disp_host.empty());
-
-    cv::gpu::GpuMat img(img_host);
-    cv::gpu::GpuMat disp(disp_host);
-    cv::gpu::GpuMat dst;
-
-    cv::gpu::DisparityBilateralFilter f(128);
-
-    TEST_CYCLE()
-    {
-        f(disp, img, dst);
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(Calib3D, DisparityBilateralFilter, ALL_DEVICES);
-
 #endif
 

modules/gpu/perf_cpu/perf_cpu_precomp.cpp

+#include "perf_cpu_precomp.hpp"

modules/gpu/perf_cpu/perf_precomp.hpp → modules/gpu/perf_cpu/perf_cpu_precomp.hpp

-#ifndef __OPENCV_PERF_PRECOMP_HPP__
-#define __OPENCV_PERF_PRECOMP_HPP__
+#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 "perf_utility.hpp"
 
 #if GTEST_CREATE_SHARED_LIBRARY

modules/gpu/perf_cpu/perf_features2d.cpp

-#include "perf_precomp.hpp"
+#include "perf_cpu_precomp.hpp"
 
 #ifdef HAVE_CUDA
 
@@ -7,32 +7,26 @@
 
 GPU_PERF_TEST(BruteForceMatcher_match, cv::gpu::DeviceInfo, int)
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
     int desc_size = GET_PARAM(1);
 
-    cv::gpu::setDevice(devInfo.deviceID());
+    cv::Mat query(3000, desc_size, CV_32FC1);
+    cv::Mat train(3000, desc_size, CV_32FC1);
 
-    cv::Mat query_host(3000, desc_size, CV_32FC1);
-    cv::Mat train_host(3000, desc_size, CV_32FC1);
+    declare.in(query, train, WARMUP_RNG);
 
-    declare.in(query_host, train_host, WARMUP_RNG);
+    cv::BFMatcher matcher(cv::NORM_L2);
+    std::vector<cv::DMatch> matches;
 
-    cv::gpu::GpuMat query(query_host);
-    cv::gpu::GpuMat train(train_host);
-    cv::gpu::GpuMat trainIdx, distance;
-
-    cv::gpu::BFMatcher_GPU matcher(cv::NORM_L2);
-
-    declare.time(3.0);
+    declare.time(10.0);
 
     TEST_CYCLE()
     {
-        matcher.matchSingle(query, train, trainIdx, distance);
+        matcher.match(query, train, matches);
     }
 }
 
 INSTANTIATE_TEST_CASE_P(Features2D, BruteForceMatcher_match, testing::Combine(
-                        ALL_DEVICES, 
+                        ALL_DEVICES,
                         testing::Values(64, 128, 256)));
 
 //////////////////////////////////////////////////////////////////////
@@ -40,33 +34,27 @@ INSTANTIATE_TEST_CASE_P(Features2D, BruteForceMatcher_match, testing::Combine(
 
 GPU_PERF_TEST(BruteForceMatcher_knnMatch, cv::gpu::DeviceInfo, int, int)
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
     int desc_size = GET_PARAM(1);
     int k = GET_PARAM(2);
 
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Mat query_host(3000, desc_size, CV_32FC1);
-    cv::Mat train_host(3000, desc_size, CV_32FC1);
-
-    declare.in(query_host, train_host, WARMUP_RNG);
+    cv::Mat query(3000, desc_size, CV_32FC1);
+    cv::Mat train(3000, desc_size, CV_32FC1);
 
-    cv::gpu::GpuMat query(query_host);
-    cv::gpu::GpuMat train(train_host);
-    cv::gpu::GpuMat trainIdx, distance, allDist;
+    declare.in(query, train, WARMUP_RNG);
 
-    cv::gpu::BFMatcher_GPU matcher(cv::NORM_L2);
+    cv::BFMatcher matcher(cv::NORM_L2);
+    std::vector< std::vector<cv::DMatch> > matches;
 
-    declare.time(3.0);
+    declare.time(10.0);
 
     TEST_CYCLE()
     {
-        matcher.knnMatchSingle(query, train, trainIdx, distance, allDist, k);
+        matcher.knnMatch(query, train, matches, k);
     }
 }
 
 INSTANTIATE_TEST_CASE_P(Features2D, BruteForceMatcher_knnMatch, testing::Combine(
-                        ALL_DEVICES, 
+                        ALL_DEVICES,
                         testing::Values(64, 128, 256),
                         testing::Values(2, 3)));
 
@@ -75,33 +63,27 @@ INSTANTIATE_TEST_CASE_P(Features2D, BruteForceMatcher_knnMatch, testing::Combine
 
 GPU_PERF_TEST(BruteForceMatcher_radiusMatch, cv::gpu::DeviceInfo, int)
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
     int desc_size = GET_PARAM(1);
 
-    cv::gpu::setDevice(devInfo.deviceID());
+    cv::Mat query(3000, desc_size, CV_32FC1);
+    cv::Mat train(3000, desc_size, CV_32FC1);
 
-    cv::Mat query_host(3000, desc_size, CV_32FC1);
-    cv::Mat train_host(3000, desc_size, CV_32FC1);
+    fill(query, 0, 1);
+    fill(train, 0, 1);
 
-    fill(query_host, 0, 1);
-    fill(train_host, 0, 1);
+    cv::BFMatcher matcher(cv::NORM_L2);
+    std::vector< std::vector<cv::DMatch> > matches;
 
-    cv::gpu::GpuMat query(query_host);
-    cv::gpu::GpuMat train(train_host);
-    cv::gpu::GpuMat trainIdx, nMatches, distance;
-
-    cv::gpu::BFMatcher_GPU matcher(cv::NORM_L2);
-
-    declare.time(3.0);
+    declare.time(10.0);
 
     TEST_CYCLE()
     {
-        matcher.radiusMatchSingle(query, train, trainIdx, distance, nMatches, 2.0);
+        matcher.radiusMatch(query, train, matches, 2.0);
     }
 }
 
 INSTANTIATE_TEST_CASE_P(Features2D, BruteForceMatcher_radiusMatch, testing::Combine(
-                        ALL_DEVICES, 
+                        ALL_DEVICES,
                         testing::Values(64, 128, 256)));
 
 //////////////////////////////////////////////////////////////////////
@@ -109,24 +91,20 @@ INSTANTIATE_TEST_CASE_P(Features2D, BruteForceMatcher_radiusMatch, testing::Comb
 
 GPU_PERF_TEST_1(SURF, cv::gpu::DeviceInfo)
 {
-    cv::gpu::DeviceInfo devInfo = GetParam();
-
-    cv::gpu::setDevice(devInfo.deviceID());
+    cv::Mat img = readImage("gpu/perf/aloe.jpg", cv::IMREAD_GRAYSCALE);
 
-    cv::Mat img_host = readImage("gpu/perf/aloe.jpg", cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(img.empty());
 
-    ASSERT_FALSE(img_host.empty());
+    std::vector<cv::KeyPoint> keypoints;
+    cv::Mat descriptors;
 
-    cv::gpu::GpuMat img(img_host);
-    cv::gpu::GpuMat keypoints, descriptors;
+    cv::SURF surf;
 
-    cv::gpu::SURF_GPU surf;
-
-    declare.time(2.0);
+    declare.time(10.0);
 
     TEST_CYCLE()
     {
-        surf(img, cv::gpu::GpuMat(), keypoints, descriptors);
+        surf(img, cv::noArray(), keypoints, descriptors);
     }
 }
 
@@ -137,22 +115,15 @@ INSTANTIATE_TEST_CASE_P(Features2D, SURF, DEVICES(cv::gpu::GLOBAL_ATOMICS));
 
 GPU_PERF_TEST_1(FAST, cv::gpu::DeviceInfo)
 {
-    cv::gpu::DeviceInfo devInfo = GetParam();
-
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Mat img_host = readImage("gpu/perf/aloe.jpg", cv::IMREAD_GRAYSCALE);
+    cv::Mat img = readImage("gpu/perf/aloe.jpg", cv::IMREAD_GRAYSCALE);
 
-    ASSERT_FALSE(img_host.empty());
+    ASSERT_FALSE(img.empty());
 
-    cv::gpu::GpuMat img(img_host);
-    cv::gpu::GpuMat keypoints, descriptors;
-
-    cv::gpu::FAST_GPU fastGPU(20);
+    std::vector<cv::KeyPoint> keypoints;
 
     TEST_CYCLE()
     {
-        fastGPU(img, cv::gpu::GpuMat(), keypoints);
+        cv::FAST(img, keypoints, 20);
     }
 }
 
@@ -163,22 +134,18 @@ INSTANTIATE_TEST_CASE_P(Features2D, FAST, DEVICES(cv::gpu::GLOBAL_ATOMICS));
 
 GPU_PERF_TEST_1(ORB, cv::gpu::DeviceInfo)
 {
-    cv::gpu::DeviceInfo devInfo = GetParam();
-
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Mat img_host = readImage("gpu/perf/aloe.jpg", cv::IMREAD_GRAYSCALE);
+    cv::Mat img = readImage("gpu/perf/aloe.jpg", cv::IMREAD_GRAYSCALE);
 
-    ASSERT_FALSE(img_host.empty());
+    ASSERT_FALSE(img.empty());
 
-    cv::gpu::GpuMat img(img_host);
-    cv::gpu::GpuMat keypoints, descriptors;
+    std::vector<cv::KeyPoint> keypoints;
+    cv::Mat descriptors;
 
-    cv::gpu::ORB_GPU orbGPU(4000);
+    cv::ORB orb(4000);
 
     TEST_CYCLE()
     {
-        orbGPU(img, cv::gpu::GpuMat(), keypoints, descriptors);
+        orb(img, cv::noArray(), keypoints, descriptors);
     }
 }
 

modules/gpu/perf_cpu/perf_filters.cpp

-#include "perf_precomp.hpp"
+#include "perf_cpu_precomp.hpp"
 
 #ifdef HAVE_CUDA
 
@@ -7,21 +7,17 @@
 
 GPU_PERF_TEST(BoxFilter, cv::gpu::DeviceInfo, cv::Size, perf::MatType, int)
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
     cv::Size size = GET_PARAM(1);
     int type = GET_PARAM(2);
     int ksize = GET_PARAM(3);
 
-    cv::gpu::setDevice(devInfo.deviceID());
+    cv::Mat src(size, type);
 
-    cv::Mat src_host(size, type);
+    declare.in(src, WARMUP_RNG);
 
-    declare.in(src_host, WARMUP_RNG);
+    cv::Mat dst(src.size(), src.type());
 
-    cv::gpu::GpuMat src(src_host);
-    cv::gpu::GpuMat dst;
-
-    cv::Ptr<cv::gpu::FilterEngine_GPU> filter = cv::gpu::createBoxFilter_GPU(type, type, cv::Size(ksize, ksize));
+    cv::Ptr<cv::FilterEngine> filter = cv::createBoxFilter(type, type, cv::Size(ksize, ksize));
 
     TEST_CYCLE()
     {
@@ -30,8 +26,8 @@ GPU_PERF_TEST(BoxFilter, cv::gpu::DeviceInfo, cv::Size, perf::MatType, int)
 }
 
 INSTANTIATE_TEST_CASE_P(Filter, BoxFilter, testing::Combine(
-                        ALL_DEVICES, 
-                        GPU_TYPICAL_MAT_SIZES, 
+                        ALL_DEVICES,
+                        GPU_TYPICAL_MAT_SIZES,
                         testing::Values(CV_8UC1, CV_8UC4),
                         testing::Values(3, 5)));
 
@@ -40,22 +36,18 @@ INSTANTIATE_TEST_CASE_P(Filter, BoxFilter, testing::Combine(
 
 GPU_PERF_TEST(MorphologyFilter, cv::gpu::DeviceInfo, cv::Size, perf::MatType, MorphOp, int)
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
     cv::Size size = GET_PARAM(1);
     int type = GET_PARAM(2);
     int op = GET_PARAM(3);
     int ksize = GET_PARAM(4);
 
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Mat src_host(size, type);
+    cv::Mat src(size, type);
 
-    declare.in(src_host, WARMUP_RNG);
+    declare.in(src, WARMUP_RNG);
 
-    cv::gpu::GpuMat src(src_host);
-    cv::gpu::GpuMat dst;
+    cv::Mat dst(src.size(), src.type());
 
-    cv::Ptr<cv::gpu::FilterEngine_GPU> filter = cv::gpu::createMorphologyFilter_GPU(op, type, cv::Mat::ones(ksize, ksize, CV_8U));
+    cv::Ptr<cv::FilterEngine> filter = cv::createMorphologyFilter(op, type, cv::Mat::ones(ksize, ksize, CV_8U));
 
     TEST_CYCLE()
     {
@@ -64,8 +56,8 @@ GPU_PERF_TEST(MorphologyFilter, cv::gpu::DeviceInfo, cv::Size, perf::MatType, Mo
 }
 
 INSTANTIATE_TEST_CASE_P(Filter, MorphologyFilter, testing::Combine(
-                        ALL_DEVICES, 
-                        GPU_TYPICAL_MAT_SIZES, 
+                        ALL_DEVICES,
+                        GPU_TYPICAL_MAT_SIZES,
                         testing::Values(CV_8UC1, CV_8UC4),
                         testing::Values((int) cv::MORPH_ERODE, (int) cv::MORPH_DILATE),
                         testing::Values(3, 5)));
@@ -75,21 +67,17 @@ INSTANTIATE_TEST_CASE_P(Filter, MorphologyFilter, testing::Combine(
 
 GPU_PERF_TEST(LinearFilter, cv::gpu::DeviceInfo, cv::Size, perf::MatType, int)
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
     cv::Size size = GET_PARAM(1);
     int type = GET_PARAM(2);
     int ksize = GET_PARAM(3);
 
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Mat src_host(size, type);
+    cv::Mat src(size, type);
 
-    declare.in(src_host, WARMUP_RNG);
+    declare.in(src, WARMUP_RNG);
 
-    cv::gpu::GpuMat src(src_host);
-    cv::gpu::GpuMat dst;
+    cv::Mat dst(src.size(), src.type());
 
-    cv::Ptr<cv::gpu::FilterEngine_GPU> filter = cv::gpu::createLinearFilter_GPU(type, type, cv::Mat::ones(ksize, ksize, CV_8U));
+    cv::Ptr<cv::FilterEngine> filter = cv::createLinearFilter(type, type, cv::Mat::ones(ksize, ksize, CV_8U));
 
     declare.time(1.0);
 
@@ -100,8 +88,8 @@ GPU_PERF_TEST(LinearFilter, cv::gpu::DeviceInfo, cv::Size, perf::MatType, int)
 }
 
 INSTANTIATE_TEST_CASE_P(Filter, LinearFilter, testing::Combine(
-                        ALL_DEVICES, 
-                        GPU_TYPICAL_MAT_SIZES, 
+                        ALL_DEVICES,
+                        GPU_TYPICAL_MAT_SIZES,
                         testing::Values(CV_8UC1, CV_8UC4, CV_32FC1),
                         testing::Values(3, 5, 7, 9)));
 
@@ -110,34 +98,30 @@ INSTANTIATE_TEST_CASE_P(Filter, LinearFilter, testing::Combine(
 
 GPU_PERF_TEST(SeparableLinearFilter, cv::gpu::DeviceInfo, cv::Size, perf::MatType, int)
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
     cv::Size size = GET_PARAM(1);
     int type = GET_PARAM(2);
     int ksize = GET_PARAM(3);
 
-    cv::gpu::setDevice(devInfo.deviceID());
+    cv::Mat src(size, type);
 
-    cv::Mat src_host(size, type);
+    declare.in(src, WARMUP_RNG);
 
-    declare.in(src_host, WARMUP_RNG);
-
-    cv::gpu::GpuMat src(src_host);
-    cv::gpu::GpuMat dst;
+    cv::Mat dst(src.size(), src.type());
 
     cv::Mat kernel = cv::getGaussianKernel(ksize, 0.5, CV_32F);
-    cv::Ptr<cv::gpu::FilterEngine_GPU> filter = cv::gpu::createSeparableLinearFilter_GPU(type, type, kernel, kernel);
+    cv::Ptr<cv::FilterEngine> filter = cv::createSeparableLinearFilter(type, type, kernel, kernel);
 
     declare.time(1.0);
 
     TEST_CYCLE()
     {
-        filter->apply(src, dst, cv::Rect(0, 0, src.cols, src.rows));
+        filter->apply(src, dst);
     }
 }
 
 INSTANTIATE_TEST_CASE_P(Filter, SeparableLinearFilter, testing::Combine(
-                        ALL_DEVICES, 
-                        GPU_TYPICAL_MAT_SIZES, 
+                        ALL_DEVICES,
+                        GPU_TYPICAL_MAT_SIZES,
                         testing::Values(CV_8UC1, CV_8UC4, CV_32FC1),
                         testing::Values(3, 5, 7, 9, 11, 13, 15)));
 

modules/gpu/perf_cpu/perf_main.cpp

-#include "perf_precomp.hpp"
+#include "perf_cpu_precomp.hpp"
 
 #ifdef HAVE_CUDA
 

modules/gpu/perf_cpu/perf_matop.cpp

-#include "perf_precomp.hpp"
+#include "perf_cpu_precomp.hpp"
 
 #ifdef HAVE_CUDA
 
@@ -7,29 +7,26 @@
 
 GPU_PERF_TEST(Merge, cv::gpu::DeviceInfo, cv::Size, perf::MatType)
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
     cv::Size size = GET_PARAM(1);
     int type = GET_PARAM(2);
 
-    cv::gpu::setDevice(devInfo.deviceID());
-
     const int num_channels = 4;
 
-    std::vector<cv::gpu::GpuMat> src(num_channels);
+    std::vector<cv::Mat> src(num_channels);
     for (int i = 0; i < num_channels; ++i)
-        src[i] = cv::gpu::GpuMat(size, type, cv::Scalar::all(i)); 
+        src[i] = cv::Mat(size, type, cv::Scalar::all(i));
 
-    cv::gpu::GpuMat dst;
+    cv::Mat dst;
 
     TEST_CYCLE()
     {
-        cv::gpu::merge(src, dst);
+        cv::merge(src, dst);
     }
 }
 
 INSTANTIATE_TEST_CASE_P(MatOp, Merge, testing::Combine(
-                        ALL_DEVICES, 
-                        GPU_TYPICAL_MAT_SIZES, 
+                        ALL_DEVICES,
+                        GPU_TYPICAL_MAT_SIZES,
                         testing::Values(CV_8UC1, CV_16UC1, CV_32FC1)));
 
 //////////////////////////////////////////////////////////////////////
@@ -37,29 +34,26 @@ INSTANTIATE_TEST_CASE_P(MatOp, Merge, testing::Combine(
 
 GPU_PERF_TEST(Split, cv::gpu::DeviceInfo, cv::Size, perf::MatType)
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
     cv::Size size = GET_PARAM(1);
     int type = GET_PARAM(2);
 
-    cv::gpu::setDevice(devInfo.deviceID());
-
     const int num_channels = 4;
 
-    cv::gpu::GpuMat src(size, CV_MAKETYPE(type, num_channels), cv::Scalar(1, 2, 3, 4));
+    cv::Mat src(size, CV_MAKETYPE(type, num_channels), cv::Scalar(1, 2, 3, 4));
 
-    std::vector<cv::gpu::GpuMat> dst(num_channels);
+    std::vector<cv::Mat> dst(num_channels);
     for (int i = 0; i < num_channels; ++i)
-        dst[i] = cv::gpu::GpuMat(size, type); 
+        dst[i] = cv::Mat(size, type);
 
     TEST_CYCLE()
     {
-        cv::gpu::split(src, dst);
+        cv::split(src, dst);
     }
 }
 
 INSTANTIATE_TEST_CASE_P(MatOp, Split, testing::Combine(
-                        ALL_DEVICES, 
-                        GPU_TYPICAL_MAT_SIZES, 
+                        ALL_DEVICES,
+                        GPU_TYPICAL_MAT_SIZES,
                         testing::Values(CV_8UC1, CV_16UC1, CV_32FC1)));
 
 //////////////////////////////////////////////////////////////////////
@@ -67,13 +61,10 @@ INSTANTIATE_TEST_CASE_P(MatOp, Split, testing::Combine(
 
 GPU_PERF_TEST(SetTo, cv::gpu::DeviceInfo, cv::Size, perf::MatType)
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
     cv::Size size = GET_PARAM(1);
     int type = GET_PARAM(2);
 
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::gpu::GpuMat src(size, type);
+    cv::Mat src(size, type);
     cv::Scalar val(1, 2, 3, 4);
 
     TEST_CYCLE()
@@ -83,8 +74,8 @@ GPU_PERF_TEST(SetTo, cv::gpu::DeviceInfo, cv::Size, perf::MatType)
 }
 
 INSTANTIATE_TEST_CASE_P(MatOp, SetTo, testing::Combine(
-                        ALL_DEVICES, 
-                        GPU_TYPICAL_MAT_SIZES, 
+                        ALL_DEVICES,
+                        GPU_TYPICAL_MAT_SIZES,
                         testing::Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_16UC1, CV_16UC3, CV_16UC4, CV_32FC1, CV_32FC3, CV_32FC4)));
 
 //////////////////////////////////////////////////////////////////////
@@ -92,22 +83,17 @@ INSTANTIATE_TEST_CASE_P(MatOp, SetTo, testing::Combine(
 
 GPU_PERF_TEST(SetToMasked, cv::gpu::DeviceInfo, cv::Size, perf::MatType)
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
     cv::Size size = GET_PARAM(1);
     int type = GET_PARAM(2);
 
-    cv::gpu::setDevice(devInfo.deviceID());
+    cv::Mat src(size, type);
+    cv::Mat mask(size, CV_8UC1);
 
-    cv::Mat src_host(size, type);
-    cv::Mat mask_host(size, CV_8UC1);
+    declare.in(src, WARMUP_RNG);
+    fill(mask, 0, 2);
 
-    declare.in(src_host, WARMUP_RNG);
-    fill(mask_host, 0, 2);
-
-    cv::gpu::GpuMat src(src_host);
     cv::Scalar val(1, 2, 3, 4);
-    cv::gpu::GpuMat mask(mask_host);
-    
+
     TEST_CYCLE()
     {
         src.setTo(val, mask);
@@ -115,8 +101,8 @@ GPU_PERF_TEST(SetToMasked, cv::gpu::DeviceInfo, cv::Size, perf::MatType)
 }
 
 INSTANTIATE_TEST_CASE_P(MatOp, SetToMasked, testing::Combine(
-                        ALL_DEVICES, 
-                        GPU_TYPICAL_MAT_SIZES, 
+                        ALL_DEVICES,
+                        GPU_TYPICAL_MAT_SIZES,
                         testing::Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_16UC1, CV_16UC3, CV_16UC4, CV_32FC1, CV_32FC3, CV_32FC4)));
 
 //////////////////////////////////////////////////////////////////////
@@ -124,22 +110,17 @@ INSTANTIATE_TEST_CASE_P(MatOp, SetToMasked, testing::Combine(
 
 GPU_PERF_TEST(CopyToMasked, cv::gpu::DeviceInfo, cv::Size, perf::MatType)
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
     cv::Size size = GET_PARAM(1);
     int type = GET_PARAM(2);
 
-    cv::gpu::setDevice(devInfo.deviceID());
+    cv::Mat src(size, type);
+    cv::Mat mask(size, CV_8UC1);
 
-    cv::Mat src_host(size, type);
-    cv::Mat mask_host(size, CV_8UC1);
+    declare.in(src, WARMUP_RNG);
+    fill(mask, 0, 2);
 
-    declare.in(src_host, WARMUP_RNG);
-    fill(mask_host, 0, 2);
+    cv::Mat dst;
 
-    cv::gpu::GpuMat src(src_host);
-    cv::gpu::GpuMat mask(mask_host);
-    cv::gpu::GpuMat dst;
-    
     TEST_CYCLE()
     {
         src.copyTo(dst, mask);
@@ -147,8 +128,8 @@ GPU_PERF_TEST(CopyToMasked, cv::gpu::DeviceInfo, cv::Size, perf::MatType)
 }
 
 INSTANTIATE_TEST_CASE_P(MatOp, CopyToMasked, testing::Combine(
-                        ALL_DEVICES, 
-                        GPU_TYPICAL_MAT_SIZES, 
+                        ALL_DEVICES,
+                        GPU_TYPICAL_MAT_SIZES,
                         testing::Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_16UC1, CV_16UC3, CV_16UC4, CV_32FC1, CV_32FC3, CV_32FC4)));
 
 //////////////////////////////////////////////////////////////////////
@@ -156,20 +137,16 @@ INSTANTIATE_TEST_CASE_P(MatOp, CopyToMasked, testing::Combine(
 
 GPU_PERF_TEST(ConvertTo, cv::gpu::DeviceInfo, cv::Size, perf::MatType, perf::MatType)
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
     cv::Size size = GET_PARAM(1);
     int type1 = GET_PARAM(2);
     int type2 = GET_PARAM(3);
 
-    cv::gpu::setDevice(devInfo.deviceID());
+    cv::Mat src(size, type1);
 
-    cv::Mat src_host(size, type1);
+    declare.in(src, WARMUP_RNG);
 
-    declare.in(src_host, WARMUP_RNG);
+    cv::Mat dst;
 
-    cv::gpu::GpuMat src(src_host);
-    cv::gpu::GpuMat dst;
-    
     TEST_CYCLE()
     {
         src.convertTo(dst, type2, 0.5, 1.0);
@@ -177,9 +154,9 @@ GPU_PERF_TEST(ConvertTo, cv::gpu::DeviceInfo, cv::Size, perf::MatType, perf::Mat
 }
 
 INSTANTIATE_TEST_CASE_P(MatOp, ConvertTo, testing::Combine(
-                        ALL_DEVICES, 
-                        GPU_TYPICAL_MAT_SIZES, 
-                        testing::Values(CV_8UC1, CV_16UC1, CV_32FC1), 
+                        ALL_DEVICES,
+                        GPU_TYPICAL_MAT_SIZES,
+                        testing::Values(CV_8UC1, CV_16UC1, CV_32FC1),
                         testing::Values(CV_8UC1, CV_16UC1, CV_32FC1)));
 
 #endif

modules/gpu/perf_cpu/perf_objdetect.cpp

-#include "perf_precomp.hpp"
+#include "perf_cpu_precomp.hpp"
 
 #ifdef HAVE_CUDA
 
 GPU_PERF_TEST_1(HOG, cv::gpu::DeviceInfo)
 {
-    cv::gpu::DeviceInfo devInfo = GetParam();
+    cv::Mat img = readImage("gpu/hog/road.png", cv::IMREAD_GRAYSCALE);
 
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Mat img_host = readImage("gpu/hog/road.png", cv::IMREAD_GRAYSCALE);
-
-    cv::gpu::GpuMat img(img_host);
     std::vector<cv::Rect> found_locations;
 
-    cv::gpu::HOGDescriptor hog;
+    cv::HOGDescriptor hog;
     hog.setSVMDetector(cv::gpu::HOGDescriptor::getDefaultPeopleDetector());
 
     TEST_CYCLE()

modules/gpu/perf_cpu/perf_precomp.cpp

-#include "perf_precomp.hpp"

modules/gpu/perf_cpu/perf_utility.cpp

-#include "perf_precomp.hpp"
+#include "perf_cpu_precomp.hpp"
 
 using namespace std;
 using namespace cv;
@@ -12,7 +12,7 @@ void fill(Mat& m, double a, double b)
 
 void PrintTo(const CvtColorInfo& info, ostream* os)
 {
-    static const char* str[] = 
+    static const char* str[] =
     {
         "BGR2BGRA",
         "BGRA2BGR",
@@ -89,7 +89,7 @@ void PrintTo(const CvtColorInfo& info, ostream* os)
         0,
         0,
         0,
-        
+
         "HLS2BGR",
         "HLS2RGB",
 
@@ -131,7 +131,7 @@ void PrintTo(const CvtColorInfo& info, ostream* os)
         0,
         0,
         0,
-        0 
+        0
     };
 
     *os << str[info.code];
@@ -179,7 +179,7 @@ const vector<DeviceInfo>& devices()
 vector<DeviceInfo> devices(FeatureSet feature)
 {
     const vector<DeviceInfo>& d = devices();
-    
+
     vector<DeviceInfo> devs_filtered;
 
     if (TargetArchs::builtWith(feature))

modules/gpu/perf_cpu/perf_video.cpp

-#include "perf_precomp.hpp"
+#include "perf_cpu_precomp.hpp"
 
 #ifdef HAVE_CUDA
 
-//////////////////////////////////////////////////////
-// BroxOpticalFlow
-
-GPU_PERF_TEST_1(BroxOpticalFlow, cv::gpu::DeviceInfo)
-{
-    cv::gpu::DeviceInfo devInfo = GetParam();
-
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Mat frame0_host = readImage("gpu/opticalflow/frame0.png", cv::IMREAD_GRAYSCALE);
-    cv::Mat frame1_host = readImage("gpu/opticalflow/frame1.png", cv::IMREAD_GRAYSCALE);
-
-    ASSERT_FALSE(frame0_host.empty());
-    ASSERT_FALSE(frame1_host.empty());
-
-    frame0_host.convertTo(frame0_host, CV_32FC1, 1.0 / 255.0);
-    frame1_host.convertTo(frame1_host, CV_32FC1, 1.0 / 255.0);
-
-    cv::gpu::GpuMat frame0(frame0_host);
-    cv::gpu::GpuMat frame1(frame1_host);
-    cv::gpu::GpuMat u; 
-    cv::gpu::GpuMat v;
-
-    cv::gpu::BroxOpticalFlow d_flow(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/, 
-                                    10 /*inner_iterations*/, 77 /*outer_iterations*/, 10 /*solver_iterations*/);
-
-    declare.time(10);
-
-    TEST_CYCLE()
-    {
-        d_flow(frame0, frame1, u, v);
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(Video, BroxOpticalFlow, ALL_DEVICES);
-
-//////////////////////////////////////////////////////
-// InterpolateFrames
-
-GPU_PERF_TEST_1(InterpolateFrames, cv::gpu::DeviceInfo)
-{
-    cv::gpu::DeviceInfo devInfo = GetParam();
-
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Mat frame0_host = readImage("gpu/perf/aloe.jpg", cv::IMREAD_GRAYSCALE);
-    cv::Mat frame1_host = readImage("gpu/perf/aloeR.jpg", cv::IMREAD_GRAYSCALE);
-
-    ASSERT_FALSE(frame0_host.empty());
-    ASSERT_FALSE(frame1_host.empty());
-
-    frame0_host.convertTo(frame0_host, CV_32FC1, 1.0 / 255.0);
-    frame1_host.convertTo(frame1_host, CV_32FC1, 1.0 / 255.0);
-
-    cv::gpu::GpuMat frame0(frame0_host);
-    cv::gpu::GpuMat frame1(frame1_host);
-    cv::gpu::GpuMat fu, fv; 
-    cv::gpu::GpuMat bu, bv;
-
-    cv::gpu::BroxOpticalFlow d_flow(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/, 
-                                    10 /*inner_iterations*/, 77 /*outer_iterations*/, 10 /*solver_iterations*/);
-    
-    d_flow(frame0, frame1, fu, fv);
-    d_flow(frame1, frame0, bu, bv);
-
-    cv::gpu::GpuMat newFrame;
-    cv::gpu::GpuMat buf;
-
-    TEST_CYCLE()
-    {
-        cv::gpu::interpolateFrames(frame0, frame1, fu, fv, bu, bv, 0.5f, newFrame, buf);
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(Video, InterpolateFrames, ALL_DEVICES);
-
-//////////////////////////////////////////////////////
-// CreateOpticalFlowNeedleMap
-
-GPU_PERF_TEST_1(CreateOpticalFlowNeedleMap, cv::gpu::DeviceInfo)
-{
-    cv::gpu::DeviceInfo devInfo = GetParam();
-
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Mat frame0_host = readImage("gpu/perf/aloe.jpg", cv::IMREAD_GRAYSCALE);
-    cv::Mat frame1_host = readImage("gpu/perf/aloeR.jpg", cv::IMREAD_GRAYSCALE);
-
-    ASSERT_FALSE(frame0_host.empty());
-    ASSERT_FALSE(frame1_host.empty());
-
-    frame0_host.convertTo(frame0_host, CV_32FC1, 1.0 / 255.0);
-    frame1_host.convertTo(frame1_host, CV_32FC1, 1.0 / 255.0);
-
-    cv::gpu::GpuMat frame0(frame0_host);
-    cv::gpu::GpuMat frame1(frame1_host);
-    cv::gpu::GpuMat u, v;
-
-    cv::gpu::BroxOpticalFlow d_flow(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/, 
-                                    10 /*inner_iterations*/, 77 /*outer_iterations*/, 10 /*solver_iterations*/);
-    
-    d_flow(frame0, frame1, u, v);
-
-    cv::gpu::GpuMat vertex, colors;
-
-    TEST_CYCLE()
-    {
-        cv::gpu::createOpticalFlowNeedleMap(u, v, vertex, colors);
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(Video, CreateOpticalFlowNeedleMap, ALL_DEVICES);
-
 //////////////////////////////////////////////////////
 // GoodFeaturesToTrack
 
 GPU_PERF_TEST(GoodFeaturesToTrack, cv::gpu::DeviceInfo, double)
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
     double minDistance = GET_PARAM(1);
 
-    cv::gpu::setDevice(devInfo.deviceID());
-    
-    cv::Mat image_host = readImage("gpu/perf/aloe.jpg", cv::IMREAD_GRAYSCALE);
+    cv::Mat image = readImage("gpu/perf/aloe.jpg", cv::IMREAD_GRAYSCALE);
 
-    ASSERT_FALSE(image_host.empty());
+    ASSERT_FALSE(image.empty());
 
-    cv::gpu::GoodFeaturesToTrackDetector_GPU detector(8000, 0.01, minDistance);
-
-    cv::gpu::GpuMat image(image_host);
-    cv::gpu::GpuMat pts;
+    cv::Mat corners;
 
     TEST_CYCLE()
     {
-        detector(image, pts);
+        cv::goodFeaturesToTrack(image, corners, 8000, 0.01, minDistance);
     }
 }
 
@@ -147,112 +28,66 @@ INSTANTIATE_TEST_CASE_P(Video, GoodFeaturesToTrack, testing::Combine(ALL_DEVICES
 
 GPU_PERF_TEST(PyrLKOpticalFlowSparse, cv::gpu::DeviceInfo, bool, int, int)
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
     bool useGray = GET_PARAM(1);
     int points = GET_PARAM(2);
     int win_size = GET_PARAM(3);
 
-    cv::gpu::setDevice(devInfo.deviceID());
-    
-    cv::Mat frame0_host = readImage("gpu/opticalflow/frame0.png", useGray ? cv::IMREAD_GRAYSCALE : cv::IMREAD_COLOR);
-    cv::Mat frame1_host = readImage("gpu/opticalflow/frame1.png", useGray ? cv::IMREAD_GRAYSCALE : cv::IMREAD_COLOR);
+    cv::Mat frame0 = readImage("gpu/opticalflow/frame0.png", useGray ? cv::IMREAD_GRAYSCALE : cv::IMREAD_COLOR);
+    cv::Mat frame1 = readImage("gpu/opticalflow/frame1.png", useGray ? cv::IMREAD_GRAYSCALE : cv::IMREAD_COLOR);
 
-    ASSERT_FALSE(frame0_host.empty());
-    ASSERT_FALSE(frame1_host.empty());
+    ASSERT_FALSE(frame0.empty());
+    ASSERT_FALSE(frame1.empty());
 
     cv::Mat gray_frame;
     if (useGray)
-        gray_frame = frame0_host;
+        gray_frame = frame0;
     else
-        cv::cvtColor(frame0_host, gray_frame, cv::COLOR_BGR2GRAY);
-
-    cv::gpu::GpuMat pts;
-
-    cv::gpu::GoodFeaturesToTrackDetector_GPU detector(points, 0.01, 0.0);
-    detector(cv::gpu::GpuMat(gray_frame), pts);
-
-    cv::gpu::PyrLKOpticalFlow pyrLK;
-    pyrLK.winSize = cv::Size(win_size, win_size);
-
-    cv::gpu::GpuMat frame0(frame0_host);
-    cv::gpu::GpuMat frame1(frame1_host);
-    cv::gpu::GpuMat nextPts;
-    cv::gpu::GpuMat status;
-
-    TEST_CYCLE()
-    {
-        pyrLK.sparse(frame0, frame1, pts, nextPts, status);
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(Video, PyrLKOpticalFlowSparse, testing::Combine
-                        (
-                            ALL_DEVICES, 
-                            testing::Bool(), 
-                            testing::Values(1000, 2000, 4000, 8000), 
-                            testing::Values(17, 21)
-                        ));
-
-//////////////////////////////////////////////////////
-// PyrLKOpticalFlowDense
-
-GPU_PERF_TEST_1(PyrLKOpticalFlowDense, cv::gpu::DeviceInfo)
-{
-    cv::gpu::DeviceInfo devInfo = GetParam();
-
-    cv::gpu::setDevice(devInfo.deviceID());
+        cv::cvtColor(frame0, gray_frame, cv::COLOR_BGR2GRAY);
 
-    cv::Mat frame0_host = readImage("gpu/opticalflow/frame0.png", cv::IMREAD_GRAYSCALE);
-    cv::Mat frame1_host = readImage("gpu/opticalflow/frame1.png", cv::IMREAD_GRAYSCALE);
+    cv::Mat pts;
+    cv::goodFeaturesToTrack(gray_frame, pts, points, 0.01, 0.0);
 
-    ASSERT_FALSE(frame0_host.empty());
-    ASSERT_FALSE(frame1_host.empty());
-
-    cv::gpu::GpuMat frame0(frame0_host);
-    cv::gpu::GpuMat frame1(frame1_host);
-    cv::gpu::GpuMat u; 
-    cv::gpu::GpuMat v;
-
-    cv::gpu::PyrLKOpticalFlow pyrLK;
-
-    declare.time(10);
+    cv::Mat nextPts;
+    cv::Mat status;
 
     TEST_CYCLE()
     {
-        pyrLK.dense(frame0, frame1, u, v);
+        cv::calcOpticalFlowPyrLK(frame0, frame1, pts, nextPts, status, cv::noArray(), cv::Size(win_size, win_size));
     }
 }
 
-INSTANTIATE_TEST_CASE_P(Video, PyrLKOpticalFlowDense, ALL_DEVICES);
-
+INSTANTIATE_TEST_CASE_P(Video, PyrLKOpticalFlowSparse, testing::Combine(
+                        ALL_DEVICES,
+                        testing::Bool(),
+                        testing::Values(1000, 2000, 4000, 8000),
+                        testing::Values(17, 21)));
 
 //////////////////////////////////////////////////////
 // FarnebackOpticalFlowTest
 
 GPU_PERF_TEST_1(FarnebackOpticalFlowTest, cv::gpu::DeviceInfo)
 {
-    cv::gpu::DeviceInfo devInfo = GetParam();
+    cv::Mat frame0 = readImage("gpu/opticalflow/frame0.png", cv::IMREAD_GRAYSCALE);
+    cv::Mat frame1 = readImage("gpu/opticalflow/frame1.png", cv::IMREAD_GRAYSCALE);
 
-    cv::gpu::setDevice(devInfo.deviceID());
+    ASSERT_FALSE(frame0.empty());
+    ASSERT_FALSE(frame1.empty());
 
-    cv::Mat frame0_host = readImage("gpu/opticalflow/frame0.png", cv::IMREAD_GRAYSCALE);
-    cv::Mat frame1_host = readImage("gpu/opticalflow/frame1.png", cv::IMREAD_GRAYSCALE);
-
-    ASSERT_FALSE(frame0_host.empty());
-    ASSERT_FALSE(frame1_host.empty());
-
-    cv::gpu::GpuMat frame0(frame0_host);
-    cv::gpu::GpuMat frame1(frame1_host);
-    cv::gpu::GpuMat u;
-    cv::gpu::GpuMat v;
-
-    cv::gpu::FarnebackOpticalFlow calc;
+    cv::Mat flow;
 
     declare.time(10);
 
+    int numLevels = 5;
+    double pyrScale = 0.5;
+    int winSize = 13;
+    int numIters = 10;
+    int polyN = 5;
+    double polySigma = 1.1;
+    int flags = 0;
+
     TEST_CYCLE()
     {
-        calc(frame0, frame1, u, v);
+        cv::calcOpticalFlowFarneback(frame0, frame1, flow, pyrScale, numLevels, winSize, numIters, polyN, polySigma, flags);
     }
 }