added padded performance tests for gpu module

diff --git a/modules/gpu/perf/perf_arithm.cpp b/modules/gpu/perf/perf_arithm.cpp
index be434d2..f5c4da3 100644 (file)
--- a/modules/gpu/perf/perf_arithm.cpp
+++ b/modules/gpu/perf/perf_arithm.cpp
@@ -215,6 +215,96 @@ PERF_TEST_P(DevInfo_Size_MatType, addScalar, testing::Combine(testing::ValuesIn(
     SANITY_CHECK(c_host);\r
 }\r
 \r
+PERF_TEST_P(DevInfo_Size_MatType, subtractMat, testing::Combine(testing::ValuesIn(devices()), \r
+                                                                testing::Values(GPU_TYPICAL_MAT_SIZES), \r
+                                                                testing::Values(CV_8UC1, CV_8UC4, CV_16SC1, CV_32FC1)))\r
+{\r
+    DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
+    Size size = std::tr1::get<1>(GetParam());\r
+    int type = std::tr1::get<2>(GetParam());\r
+\r
+    setDevice(devInfo.deviceID());\r
+\r
+    Mat a_host(size, type);\r
+    Mat b_host(size, type);\r
+\r
+    declare.in(a_host, b_host, WARMUP_RNG);\r
+\r
+    GpuMat a(a_host);\r
+    GpuMat b(b_host);\r
+    GpuMat c(size, type);\r
+\r
+    declare.time(0.5).iterations(100);\r
+\r
+    SIMPLE_TEST_CYCLE()\r
+    {\r
+        subtract(a, b, c);\r
+    }\r
+\r
+    Mat c_host = c;\r
+\r
+    SANITY_CHECK(c_host);\r
+}\r
+\r
+PERF_TEST_P(DevInfo_Size, multiplyMat, testing::Combine(testing::ValuesIn(devices()), \r
+                                                        testing::Values(GPU_TYPICAL_MAT_SIZES)))\r
+{\r
+    DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
+    Size size = std::tr1::get<1>(GetParam());\r
+\r
+    setDevice(devInfo.deviceID());\r
+\r
+    Mat a_host(size, CV_8UC1);\r
+    Mat b_host(size, CV_32FC1);\r
+\r
+    declare.in(a_host, b_host, WARMUP_RNG);\r
+\r
+    GpuMat a(a_host);\r
+    GpuMat b(b_host);\r
+    GpuMat c;\r
+\r
+    declare.time(0.5).iterations(100);\r
+\r
+    SIMPLE_TEST_CYCLE()\r
+    {\r
+        multiply(a, b, c);\r
+    }\r
+\r
+    Mat c_host = c;\r
+\r
+    SANITY_CHECK(c_host);\r
+}\r
+\r
+PERF_TEST_P(DevInfo_Size_MatType, multiplyScalar, testing::Combine(testing::ValuesIn(devices()), \r
+                                                                   testing::Values(GPU_TYPICAL_MAT_SIZES), \r
+                                                                   testing::Values(CV_8UC1, CV_32FC1)))\r
+{\r
+    DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
+    Size size = std::tr1::get<1>(GetParam());\r
+    int type = std::tr1::get<2>(GetParam());\r
+\r
+    setDevice(devInfo.deviceID());\r
+\r
+    Mat a_host(size, type);\r
+\r
+    declare.in(a_host, WARMUP_RNG);\r
+\r
+    GpuMat a(a_host);\r
+    Scalar b(1,2,3,4);\r
+    GpuMat c(size, type);\r
+\r
+    declare.time(0.5).iterations(100);\r
+\r
+    SIMPLE_TEST_CYCLE()\r
+    {\r
+        multiply(a, b, c);\r
+    }\r
+\r
+    Mat c_host = c;\r
+\r
+    SANITY_CHECK(c_host);\r
+}\r
+\r
 PERF_TEST_P(DevInfo_Size, exp, testing::Combine(testing::ValuesIn(devices()), \r
                                                 testing::Values(GPU_TYPICAL_MAT_SIZES)))\r
 {\r
@@ -394,3 +484,204 @@ PERF_TEST_P(DevInfo_Size_MatType, min, testing::Combine(testing::ValuesIn(device
 \r
     SANITY_CHECK(dst_host);\r
 }\r
+\r
+PERF_TEST_P(DevInfo_Size, meanStdDev, testing::Combine(testing::ValuesIn(devices()), \r
+                                                       testing::Values(GPU_TYPICAL_MAT_SIZES)))\r
+{\r
+    DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
+    Size size = std::tr1::get<1>(GetParam());\r
+\r
+    setDevice(devInfo.deviceID());\r
+\r
+    Mat src_host(size, CV_8UC1);\r
+\r
+    declare.in(src_host, WARMUP_RNG);\r
+\r
+    GpuMat src(src_host); \r
+    Scalar mean;\r
+    Scalar stddev;\r
+\r
+    declare.time(0.5).iterations(100);\r
+\r
+    SIMPLE_TEST_CYCLE()\r
+    {\r
+        meanStdDev(src, mean, stddev);\r
+    }\r
+\r
+    SANITY_CHECK(mean);\r
+    SANITY_CHECK(stddev);\r
+}\r
+\r
+PERF_TEST_P(DevInfo_Size_MatType_NormType, norm, testing::Combine(testing::ValuesIn(devices()), \r
+                                                                  testing::Values(GPU_TYPICAL_MAT_SIZES), \r
+                                                                  testing::Values(CV_8UC1, CV_16UC1, CV_32SC1),\r
+                                                                  testing::Values((int)NORM_INF, (int)NORM_L1, (int)NORM_L2)))\r
+{\r
+    DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
+    Size size = std::tr1::get<1>(GetParam());\r
+    int type = std::tr1::get<2>(GetParam());\r
+    int normType = std::tr1::get<3>(GetParam());\r
+\r
+    setDevice(devInfo.deviceID());\r
+\r
+    Mat src_host(size, type);\r
+\r
+    declare.in(src_host, WARMUP_RNG);\r
+\r
+    GpuMat src(src_host);\r
+    double dst;\r
+    GpuMat buf;\r
+\r
+    declare.time(0.5).iterations(100);\r
+\r
+    SIMPLE_TEST_CYCLE()\r
+    {\r
+        dst = norm(src, normType, buf);\r
+    }\r
+\r
+    SANITY_CHECK(dst);\r
+}\r
+\r
+PERF_TEST_P(DevInfo_Size_NormType, normDiff, testing::Combine(testing::ValuesIn(devices()), \r
+                                                              testing::Values(GPU_TYPICAL_MAT_SIZES), \r
+                                                              testing::Values((int)NORM_INF, (int)NORM_L1, (int)NORM_L2)))\r
+{\r
+    DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
+    Size size = std::tr1::get<1>(GetParam());\r
+    int normType = std::tr1::get<2>(GetParam());\r
+\r
+    setDevice(devInfo.deviceID());\r
+\r
+    Mat src1_host(size, CV_8UC1);\r
+    Mat src2_host(size, CV_8UC1);\r
+\r
+    declare.in(src1_host, src2_host, WARMUP_RNG);\r
+\r
+    GpuMat src1(src1_host);\r
+    GpuMat src2(src2_host);\r
+    double dst;\r
+\r
+    declare.time(0.5).iterations(100);\r
+\r
+    SIMPLE_TEST_CYCLE()\r
+    {\r
+        dst = norm(src1, src2, normType);\r
+    }\r
+\r
+    SANITY_CHECK(dst);\r
+}\r
+\r
+PERF_TEST_P(DevInfo_Size_MatType, sum, testing::Combine(testing::ValuesIn(devices()), \r
+                                                        testing::Values(GPU_TYPICAL_MAT_SIZES), \r
+                                                        testing::Values(CV_8UC1, CV_16UC1, CV_32FC1)))\r
+{\r
+    DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
+    Size size = std::tr1::get<1>(GetParam());\r
+    int type = std::tr1::get<2>(GetParam());\r
+\r
+    setDevice(devInfo.deviceID());\r
+\r
+    Mat src_host(size, type);\r
+\r
+    declare.in(src_host, WARMUP_RNG);\r
+\r
+    GpuMat src(src_host);\r
+    Scalar dst;\r
+    GpuMat buf;\r
+\r
+    declare.time(0.5).iterations(100);\r
+\r
+    SIMPLE_TEST_CYCLE()\r
+    {\r
+        dst = sum(src, buf);\r
+    }\r
+\r
+    SANITY_CHECK(dst);\r
+}\r
+\r
+PERF_TEST_P(DevInfo_Size_MatType, minMax, testing::Combine(testing::ValuesIn(devices()), \r
+                                                           testing::Values(GPU_TYPICAL_MAT_SIZES), \r
+                                                           testing::Values(CV_8UC1, CV_16UC1, CV_32FC1)))\r
+{\r
+    DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
+    Size size = std::tr1::get<1>(GetParam());\r
+    int type = std::tr1::get<2>(GetParam());\r
+\r
+    setDevice(devInfo.deviceID());\r
+\r
+    Mat src_host(size, type);\r
+\r
+    declare.in(src_host, WARMUP_RNG);\r
+\r
+    GpuMat src(src_host);\r
+    double minVal, maxVal;\r
+    GpuMat buf;\r
+\r
+    declare.time(0.5).iterations(100);\r
+\r
+    SIMPLE_TEST_CYCLE()\r
+    {\r
+        minMax(src, &minVal, &maxVal, GpuMat(), buf);\r
+    }\r
+\r
+    SANITY_CHECK(minVal);\r
+    SANITY_CHECK(maxVal);\r
+}\r
+\r
+PERF_TEST_P(DevInfo_Size_MatType, minMaxLoc, testing::Combine(testing::ValuesIn(devices()), \r
+                                                              testing::Values(GPU_TYPICAL_MAT_SIZES), \r
+                                                              testing::Values(CV_8UC1, CV_16UC1, CV_32FC1)))\r
+{\r
+    DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
+    Size size = std::tr1::get<1>(GetParam());\r
+    int type = std::tr1::get<2>(GetParam());\r
+\r
+    setDevice(devInfo.deviceID());\r
+\r
+    Mat src_host(size, type);\r
+\r
+    declare.in(src_host, WARMUP_RNG);\r
+\r
+    GpuMat src(src_host);\r
+    double minVal, maxVal;\r
+    Point minLoc, maxLoc;\r
+    GpuMat valbuf, locbuf;\r
+\r
+    declare.time(0.5).iterations(100);\r
+\r
+    SIMPLE_TEST_CYCLE()\r
+    {\r
+        minMaxLoc(src, &minVal, &maxVal, &minLoc, &maxLoc, GpuMat(), valbuf, locbuf);\r
+    }\r
+\r
+    SANITY_CHECK(minVal);\r
+    SANITY_CHECK(maxVal);\r
+}\r
+\r
+PERF_TEST_P(DevInfo_Size_MatType, countNonZero, testing::Combine(testing::ValuesIn(devices()), \r
+                                                                 testing::Values(GPU_TYPICAL_MAT_SIZES), \r
+                                                                 testing::Values(CV_8UC1, CV_16UC1, CV_32FC1)))\r
+{\r
+    DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
+    Size size = std::tr1::get<1>(GetParam());\r
+    int type = std::tr1::get<2>(GetParam());\r
+\r
+    setDevice(devInfo.deviceID());\r
+\r
+    Mat src_host(size, type);\r
+\r
+    declare.in(src_host, WARMUP_RNG);\r
+\r
+    GpuMat src(src_host);\r
+    int dst;\r
+    GpuMat buf;\r
+\r
+    declare.time(0.5).iterations(100);\r
+\r
+    SIMPLE_TEST_CYCLE()\r
+    {\r
+        dst = countNonZero(src, buf);\r
+    }\r
+\r
+    SANITY_CHECK(dst);\r
+}\r

diff --git a/modules/gpu/perf/perf_calib3d.cpp b/modules/gpu/perf/perf_calib3d.cpp
new file mode 100644 (file)
index 0000000..e84f87b
--- /dev/null
+++ b/modules/gpu/perf/perf_calib3d.cpp
@@ -0,0 +1,199 @@
+#include "perf_precomp.hpp"\r
+\r
+PERF_TEST_P(DevInfo, transformPoints, testing::ValuesIn(devices()))\r
+{\r
+    DeviceInfo devInfo = GetParam();\r
+\r
+    setDevice(devInfo.deviceID());\r
+\r
+    Mat src_host(1, 10000, CV_32FC3);\r
+\r
+    declare.in(src_host, WARMUP_RNG);\r
+\r
+    GpuMat src(src_host);\r
+    GpuMat dst;\r
+\r
+    declare.time(0.5).iterations(100);\r
+\r
+    SIMPLE_TEST_CYCLE()\r
+    {\r
+        transformPoints(src, Mat::ones(1, 3, CV_32FC1), Mat::ones(1, 3, CV_32FC1), dst);\r
+    }\r
+\r
+    Mat dst_host = dst;\r
+\r
+    SANITY_CHECK(dst_host);\r
+}\r
+\r
+PERF_TEST_P(DevInfo, projectPoints, testing::ValuesIn(devices()))\r
+{\r
+    DeviceInfo devInfo = GetParam();\r
+\r
+    setDevice(devInfo.deviceID());\r
+\r
+    Mat src_host(1, 10000, CV_32FC3);\r
+\r
+    declare.in(src_host, WARMUP_RNG);\r
+\r
+    GpuMat src(src_host);\r
+    GpuMat dst;\r
+\r
+    declare.time(0.5).iterations(100);\r
+\r
+    SIMPLE_TEST_CYCLE()\r
+    {\r
+        projectPoints(src, Mat::ones(1, 3, CV_32FC1), Mat::ones(1, 3, CV_32FC1), Mat::ones(3, 3, CV_32FC1), Mat(), dst);\r
+    }\r
+\r
+    Mat dst_host = dst;\r
+\r
+    SANITY_CHECK(dst_host);\r
+}\r
+\r
+PERF_TEST_P(DevInfo, solvePnPRansac, testing::ValuesIn(devices()))\r
+{\r
+    DeviceInfo devInfo = GetParam();\r
+\r
+    setDevice(devInfo.deviceID());\r
+\r
+    Mat object(1, 10000, CV_32FC3);\r
+    Mat image(1, 10000, CV_32FC2);\r
+\r
+    declare.in(object, image, WARMUP_RNG);\r
+\r
+    Mat rvec, tvec;\r
+\r
+    declare.time(3.0);\r
+\r
+    SIMPLE_TEST_CYCLE()\r
+    {\r
+        solvePnPRansac(object, image, Mat::ones(3, 3, CV_32FC1), Mat(1, 8, CV_32F, Scalar::all(0)), rvec, tvec);\r
+    }\r
+\r
+    SANITY_CHECK(rvec);\r
+    SANITY_CHECK(tvec);\r
+}\r
+\r
+PERF_TEST_P(DevInfo, StereoBM, testing::ValuesIn(devices()))\r
+{\r
+    DeviceInfo devInfo = GetParam();\r
+\r
+    setDevice(devInfo.deviceID());\r
+\r
+    Mat img_l_host = readImage("gpu/perf/aloe.jpg", CV_LOAD_IMAGE_GRAYSCALE);\r
+    Mat img_r_host = readImage("gpu/perf/aloeR.jpg", CV_LOAD_IMAGE_GRAYSCALE);\r
+\r
+    ASSERT_FALSE(img_l_host.empty());\r
+    ASSERT_FALSE(img_r_host.empty());\r
+\r
+    GpuMat img_l(img_l_host);\r
+    GpuMat img_r(img_r_host);\r
+\r
+    GpuMat dst;\r
+\r
+    StereoBM_GPU bm(0, 256);\r
+\r
+    declare.time(0.5).iterations(100);\r
+\r
+    SIMPLE_TEST_CYCLE()\r
+    {\r
+        bm(img_l, img_r, dst);\r
+    }\r
+\r
+    Mat dst_host(dst);\r
+    \r
+    SANITY_CHECK(dst_host);\r
+}\r
+\r
+PERF_TEST_P(DevInfo, StereoBeliefPropagation, testing::ValuesIn(devices()))\r
+{\r
+    DeviceInfo devInfo = GetParam();\r
+\r
+    setDevice(devInfo.deviceID());\r
+\r
+    Mat img_l_host = readImage("gpu/stereobm/aloe-L.png", CV_LOAD_IMAGE_GRAYSCALE);\r
+    Mat img_r_host = readImage("gpu/stereobm/aloe-R.png", CV_LOAD_IMAGE_GRAYSCALE);\r
+\r
+    ASSERT_FALSE(img_l_host.empty());\r
+    ASSERT_FALSE(img_r_host.empty());\r
+\r
+    GpuMat img_l(img_l_host);\r
+    GpuMat img_r(img_r_host);\r
+\r
+    GpuMat dst;\r
+\r
+    StereoBeliefPropagation bp(128);\r
+\r
+    declare.time(10.0);\r
+\r
+    SIMPLE_TEST_CYCLE()\r
+    {\r
+        bp(img_l, img_r, dst);\r
+    }\r
+\r
+    Mat dst_host(dst);\r
+    \r
+    SANITY_CHECK(dst_host);\r
+}\r
+\r
+PERF_TEST_P(DevInfo, StereoConstantSpaceBP, testing::ValuesIn(devices()))\r
+{\r
+    DeviceInfo devInfo = GetParam();\r
+\r
+    setDevice(devInfo.deviceID());\r
+\r
+    Mat img_l_host = readImage("gpu/perf/aloe.jpg", CV_LOAD_IMAGE_GRAYSCALE);\r
+    Mat img_r_host = readImage("gpu/perf/aloeR.jpg", CV_LOAD_IMAGE_GRAYSCALE);\r
+\r
+    ASSERT_FALSE(img_l_host.empty());\r
+    ASSERT_FALSE(img_r_host.empty());\r
+\r
+    GpuMat img_l(img_l_host);\r
+    GpuMat img_r(img_r_host);\r
+\r
+    GpuMat dst;\r
+\r
+    StereoConstantSpaceBP bp(128);\r
+\r
+    declare.time(10.0);\r
+\r
+    SIMPLE_TEST_CYCLE()\r
+    {\r
+        bp(img_l, img_r, dst);\r
+    }\r
+\r
+    Mat dst_host(dst);\r
+    \r
+    SANITY_CHECK(dst_host);\r
+}\r
+\r
+PERF_TEST_P(DevInfo, DisparityBilateralFilter, testing::ValuesIn(devices()))\r
+{\r
+    DeviceInfo devInfo = GetParam();\r
+\r
+    setDevice(devInfo.deviceID());\r
+\r
+    Mat img_host = readImage("gpu/stereobm/aloe-L.png", CV_LOAD_IMAGE_GRAYSCALE);\r
+    Mat disp_host = readImage("gpu/stereobm/aloe-disp.png", CV_LOAD_IMAGE_GRAYSCALE);\r
+\r
+    ASSERT_FALSE(img_host.empty());\r
+    ASSERT_FALSE(disp_host.empty());\r
+\r
+    GpuMat img(img_host);\r
+    GpuMat disp(disp_host);\r
+\r
+    GpuMat dst;\r
+\r
+    DisparityBilateralFilter f(128);\r
+\r
+    declare.time(0.5).iterations(100);\r
+\r
+    SIMPLE_TEST_CYCLE()\r
+    {\r
+        f(disp, img, dst);\r
+    }\r
+\r
+    Mat dst_host(dst);\r
+    \r
+    SANITY_CHECK(dst_host);\r
+}\r

diff --git a/modules/gpu/perf/perf_features2d.cpp b/modules/gpu/perf/perf_features2d.cpp
new file mode 100644 (file)
index 0000000..d250537
--- /dev/null
+++ b/modules/gpu/perf/perf_features2d.cpp
@@ -0,0 +1,132 @@
+#include "perf_precomp.hpp"\r
+\r
+PERF_TEST_P(DevInfo_DescSize, BruteForceMatcher_match, testing::Combine(testing::ValuesIn(devices()),\r
+                                                                        testing::Values(64, 128)))\r
+{\r
+    DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
+    int desc_size = std::tr1::get<1>(GetParam());\r
+\r
+    setDevice(devInfo.deviceID());\r
+\r
+    Mat query_host(3000, desc_size, CV_32FC1);\r
+    Mat train_host(3000, desc_size, CV_32FC1);\r
+\r
+    declare.in(query_host, train_host, WARMUP_RNG);\r
+\r
+    GpuMat query(query_host);\r
+    GpuMat train(train_host);\r
+    GpuMat trainIdx, distance;\r
+\r
+    BruteForceMatcher_GPU< L2<float> > matcher;\r
+\r
+    declare.time(0.5).iterations(100);\r
+\r
+    SIMPLE_TEST_CYCLE()\r
+    {\r
+        matcher.matchSingle(query, train, trainIdx, distance);\r
+    }\r
+\r
+    Mat trainIdx_host(trainIdx);\r
+    Mat distance_host(distance);\r
+\r
+    SANITY_CHECK(trainIdx_host);\r
+    SANITY_CHECK(distance_host);\r
+}\r
+\r
+PERF_TEST_P(DevInfo_K_DescSize, BruteForceMatcher_knnMatch, testing::Combine(testing::ValuesIn(devices()),\r
+                                                                             testing::Values(2, 3),\r
+                                                                             testing::Values(64, 128)))\r
+{\r
+    DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
+    int k = std::tr1::get<1>(GetParam());\r
+    int desc_size = std::tr1::get<2>(GetParam());\r
+\r
+    setDevice(devInfo.deviceID());\r
+\r
+    Mat query_host(3000, desc_size, CV_32FC1);\r
+    Mat train_host(3000, desc_size, CV_32FC1);\r
+\r
+    declare.in(query_host, train_host, WARMUP_RNG);\r
+\r
+    GpuMat query(query_host);\r
+    GpuMat train(train_host);\r
+    GpuMat trainIdx, distance, allDist;\r
+\r
+    BruteForceMatcher_GPU< L2<float> > matcher;\r
+\r
+    declare.time(0.5).iterations(100);\r
+\r
+    SIMPLE_TEST_CYCLE()\r
+    {\r
+        matcher.knnMatch(query, train, trainIdx, distance, allDist, k);\r
+    }\r
+\r
+    Mat trainIdx_host(trainIdx);\r
+    Mat distance_host(distance);\r
+\r
+    SANITY_CHECK(trainIdx_host);\r
+    SANITY_CHECK(distance_host);\r
+}\r
+\r
+PERF_TEST_P(DevInfo_DescSize, BruteForceMatcher_radiusMatch, testing::Combine(testing::ValuesIn(devices(GLOBAL_ATOMICS)),\r
+                                                                        testing::Values(64, 128)))\r
+{\r
+    DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
+    int desc_size = std::tr1::get<1>(GetParam());\r
+\r
+    setDevice(devInfo.deviceID());\r
+\r
+    Mat query_host = cvtest::randomMat(theRNG(), Size(desc_size, 3000), CV_32FC1, 0, 1, false);\r
+    Mat train_host = cvtest::randomMat(theRNG(), Size(desc_size, 3000), CV_32FC1, 0, 1, false);\r
+\r
+    GpuMat query(query_host);\r
+    GpuMat train(train_host);\r
+    GpuMat trainIdx, nMatches, distance;\r
+\r
+    BruteForceMatcher_GPU< L2<float> > matcher;\r
+\r
+    declare.time(0.5).iterations(100);\r
+\r
+    SIMPLE_TEST_CYCLE()\r
+    {\r
+        matcher.radiusMatch(query, train, trainIdx, nMatches, distance, 2.0);\r
+    }\r
+\r
+    Mat trainIdx_host(trainIdx);\r
+    Mat nMatches_host(nMatches);\r
+    Mat distance_host(distance);\r
+\r
+    SANITY_CHECK(trainIdx_host);\r
+    SANITY_CHECK(nMatches_host);\r
+    SANITY_CHECK(distance_host);\r
+}\r
+\r
+PERF_TEST_P(DevInfo, SURF, testing::ValuesIn(devices()))\r
+{\r
+    DeviceInfo devInfo = GetParam();\r
+\r
+    setDevice(devInfo.deviceID());\r
+\r
+    Mat img_host = readImage("gpu/perf/aloe.jpg", CV_LOAD_IMAGE_GRAYSCALE);\r
+\r
+    ASSERT_FALSE(img_host.empty());\r
+\r
+    GpuMat img(img_host);\r
+    GpuMat keypoints, descriptors;\r
+\r
+    SURF_GPU surf;\r
+\r
+    declare.time(2.0);\r
+\r
+    SIMPLE_TEST_CYCLE()\r
+    {\r
+        surf(img, GpuMat(), keypoints, descriptors);\r
+    }\r
+\r
+    Mat keypoints_host(keypoints);\r
+    Mat descriptors_host(descriptors);\r
+    \r
+    SANITY_CHECK(keypoints_host);\r
+    SANITY_CHECK(descriptors_host);\r
+}\r
+\r

diff --git a/modules/gpu/perf/perf_imgproc.cpp b/modules/gpu/perf/perf_imgproc.cpp
index 3a6d165..67e7466 100644 (file)
--- a/modules/gpu/perf/perf_imgproc.cpp
+++ b/modules/gpu/perf/perf_imgproc.cpp
@@ -47,7 +47,7 @@ PERF_TEST_P(DevInfo, meanShiftFiltering, testing::ValuesIn(devices()))
 \r
     setDevice(devInfo.deviceID());\r
 \r
-    Mat img = readImage("meanshift/cones.png");\r
+    Mat img = readImage("gpu/meanshift/cones.png");\r
     ASSERT_FALSE(img.empty());\r
     \r
     Mat rgba;\r
@@ -74,7 +74,7 @@ PERF_TEST_P(DevInfo, meanShiftProc, testing::ValuesIn(devices()))
 \r
     setDevice(devInfo.deviceID());\r
 \r
-    Mat img = readImage("meanshift/cones.png");\r
+    Mat img = readImage("gpu/meanshift/cones.png");\r
     ASSERT_FALSE(img.empty());\r
     \r
     Mat rgba;\r
@@ -104,7 +104,7 @@ PERF_TEST_P(DevInfo, meanShiftSegmentation, testing::ValuesIn(devices()))
 \r
     setDevice(devInfo.deviceID());\r
 \r
-    Mat img = readImage("meanshift/cones.png");\r
+    Mat img = readImage("gpu/meanshift/cones.png");\r
     ASSERT_FALSE(img.empty());\r
     \r
     Mat rgba;\r
@@ -123,6 +123,35 @@ PERF_TEST_P(DevInfo, meanShiftSegmentation, testing::ValuesIn(devices()))
     SANITY_CHECK(dst);\r
 }\r
 \r
+PERF_TEST_P(DevInfo_Size_MatType, drawColorDisp, testing::Combine(testing::ValuesIn(devices()),\r
+                                                                  testing::Values(GPU_TYPICAL_MAT_SIZES), \r
+                                                                  testing::Values(CV_8UC1, CV_16SC1)))\r
+{\r
+    DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
+    Size size = std::tr1::get<1>(GetParam());\r
+    int type = std::tr1::get<2>(GetParam());\r
+\r
+    setDevice(devInfo.deviceID());\r
+\r
+    Mat src_host(size, CV_8UC1);\r
+    declare.in(src_host, WARMUP_RNG);\r
+    src_host.convertTo(src_host, type);\r
+\r
+    GpuMat src(src_host);\r
+    GpuMat dst(size, CV_8UC4);\r
+\r
+    declare.time(0.5).iterations(100);\r
+\r
+    SIMPLE_TEST_CYCLE()\r
+    {\r
+        drawColorDisp(src, dst, 255);\r
+    }\r
+\r
+    Mat dst_host(dst);\r
+\r
+    SANITY_CHECK(dst_host);\r
+}\r
+\r
 PERF_TEST_P(DevInfo_Size_MatType, reprojectImageTo3D, testing::Combine(testing::ValuesIn(devices()),\r
                                                                        testing::Values(GPU_TYPICAL_MAT_SIZES), \r
                                                                        testing::Values(CV_8UC1, CV_16SC1)))\r
@@ -156,7 +185,8 @@ PERF_TEST_P(DevInfo_Size_MatType_CvtColorInfo, cvtColor, testing::Combine(testin
             testing::Values(GPU_TYPICAL_MAT_SIZES), \r
             testing::Values(CV_8UC1, CV_16UC1, CV_32FC1),\r
             testing::Values(CvtColorInfo(4, 4, CV_RGBA2BGRA), CvtColorInfo(4, 1, CV_BGRA2GRAY), CvtColorInfo(1, 4, CV_GRAY2BGRA), \r
-                            CvtColorInfo(4, 4, CV_BGR2XYZ), CvtColorInfo(4, 4, CV_BGR2YCrCb), CvtColorInfo(4, 4, CV_BGR2HSV))))\r
+                            CvtColorInfo(4, 4, CV_BGR2XYZ), CvtColorInfo(4, 4, CV_BGR2YCrCb), CvtColorInfo(4, 4, CV_YCrCb2BGR), \r
+                            CvtColorInfo(4, 4, CV_BGR2HSV), CvtColorInfo(4, 4, CV_HSV2BGR))))\r
 {\r
     DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
     Size size = std::tr1::get<1>(GetParam());\r
@@ -321,6 +351,81 @@ PERF_TEST_P(DevInfo_Size_MatType_Interpolation, warpPerspective, testing::Combin
     SANITY_CHECK(dst_host);\r
 }\r
 \r
+PERF_TEST_P(DevInfo_Size, buildWarpPlaneMaps, testing::Combine(testing::ValuesIn(devices()),\r
+                                                               testing::Values(GPU_TYPICAL_MAT_SIZES)))\r
+{\r
+    DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
+    Size size = std::tr1::get<1>(GetParam());\r
+\r
+    setDevice(devInfo.deviceID());\r
+\r
+    GpuMat map_x(size, CV_32FC1);\r
+    GpuMat map_y(size, CV_32FC1);\r
+\r
+    declare.time(0.5).iterations(100);\r
+\r
+    SIMPLE_TEST_CYCLE()\r
+    {\r
+        buildWarpPlaneMaps(size, Rect(0, 0, size.width, size.height), Mat::ones(3, 3, CV_32FC1), 1.0, 1.0, 1.0, map_x, map_y);\r
+    }\r
+\r
+    Mat map_x_host(map_x);\r
+    Mat map_y_host(map_y);\r
+\r
+    SANITY_CHECK(map_x_host);\r
+    SANITY_CHECK(map_y_host);\r
+}\r
+\r
+PERF_TEST_P(DevInfo_Size, buildWarpCylindricalMaps, testing::Combine(testing::ValuesIn(devices()),\r
+                                                               testing::Values(GPU_TYPICAL_MAT_SIZES)))\r
+{\r
+    DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
+    Size size = std::tr1::get<1>(GetParam());\r
+\r
+    setDevice(devInfo.deviceID());\r
+\r
+    GpuMat map_x(size, CV_32FC1);\r
+    GpuMat map_y(size, CV_32FC1);\r
+\r
+    declare.time(0.5).iterations(100);\r
+\r
+    SIMPLE_TEST_CYCLE()\r
+    {\r
+        buildWarpCylindricalMaps(size, Rect(0, 0, size.width, size.height), Mat::ones(3, 3, CV_32FC1), 1.0, 1.0, map_x, map_y);\r
+    }\r
+\r
+    Mat map_x_host(map_x);\r
+    Mat map_y_host(map_y);\r
+\r
+    SANITY_CHECK(map_x_host);\r
+    SANITY_CHECK(map_y_host);\r
+}\r
+\r
+PERF_TEST_P(DevInfo_Size, buildWarpSphericalMaps, testing::Combine(testing::ValuesIn(devices()),\r
+                                                               testing::Values(GPU_TYPICAL_MAT_SIZES)))\r
+{\r
+    DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
+    Size size = std::tr1::get<1>(GetParam());\r
+\r
+    setDevice(devInfo.deviceID());\r
+\r
+    GpuMat map_x(size, CV_32FC1);\r
+    GpuMat map_y(size, CV_32FC1);\r
+\r
+    declare.time(0.5).iterations(100);\r
+\r
+    SIMPLE_TEST_CYCLE()\r
+    {\r
+        buildWarpSphericalMaps(size, Rect(0, 0, size.width, size.height), Mat::ones(3, 3, CV_32FC1), 1.0, 1.0, map_x, map_y);\r
+    }\r
+\r
+    Mat map_x_host(map_x);\r
+    Mat map_y_host(map_y);\r
+\r
+    SANITY_CHECK(map_x_host);\r
+    SANITY_CHECK(map_y_host);\r
+}\r
+\r
 PERF_TEST_P(DevInfo_Size_MatType_Interpolation, rotate, testing::Combine(testing::ValuesIn(devices()),\r
                                                                          testing::Values(GPU_TYPICAL_MAT_SIZES), \r
                                                                          testing::Values(CV_8UC1, CV_8UC4),\r
@@ -381,8 +486,8 @@ PERF_TEST_P(DevInfo_Size_MatType, copyMakeBorder, testing::Combine(testing::Valu
     SANITY_CHECK(dst_host);\r
 }\r
 \r
-PERF_TEST_P(DevInfo_Size, integral, testing::Combine(testing::ValuesIn(devices()),\r
-                                                     testing::Values(GPU_TYPICAL_MAT_SIZES)))\r
+PERF_TEST_P(DevInfo_Size, integralBuffered, testing::Combine(testing::ValuesIn(devices()),\r
+                                                             testing::Values(GPU_TYPICAL_MAT_SIZES)))\r
 {\r
     DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
     Size size = std::tr1::get<1>(GetParam());\r
@@ -409,6 +514,35 @@ PERF_TEST_P(DevInfo_Size, integral, testing::Combine(testing::ValuesIn(devices()
     SANITY_CHECK(dst_host);\r
 }\r
 \r
+PERF_TEST_P(DevInfo_Size, integral, testing::Combine(testing::ValuesIn(devices()),\r
+                                                     testing::Values(GPU_TYPICAL_MAT_SIZES)))\r
+{\r
+    DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
+    Size size = std::tr1::get<1>(GetParam());\r
+\r
+    setDevice(devInfo.deviceID());\r
+\r
+    Mat src_host(size, CV_8UC1);\r
+\r
+    declare.in(src_host, WARMUP_RNG);\r
+\r
+    GpuMat src(src_host);\r
+    GpuMat sum, sqsum;\r
+\r
+    declare.time(0.5).iterations(100);\r
+\r
+    SIMPLE_TEST_CYCLE()\r
+    {\r
+        integral(src, sum, sqsum);\r
+    }\r
+\r
+    Mat sum_host(sum);\r
+    Mat sqsum_host(sqsum);\r
+\r
+    SANITY_CHECK(sum_host);\r
+    SANITY_CHECK(sqsum_host);\r
+}\r
+\r
 PERF_TEST_P(DevInfo_Size, sqrIntegral, testing::Combine(testing::ValuesIn(devices()),\r
                                                         testing::Values(GPU_TYPICAL_MAT_SIZES)))\r
 {\r
@@ -471,7 +605,7 @@ PERF_TEST_P(DevInfo_MatType, cornerHarris, testing::Combine(testing::ValuesIn(de
 \r
     setDevice(devInfo.deviceID());\r
     \r
-    Mat img = readImage("stereobm/aloe-L.png", CV_LOAD_IMAGE_GRAYSCALE);\r
+    Mat img = readImage("gpu/stereobm/aloe-L.png", CV_LOAD_IMAGE_GRAYSCALE);\r
     ASSERT_FALSE(img.empty());\r
 \r
     img.convertTo(img, type, type == CV_32F ? 1.0 / 255.0 : 1.0);\r
@@ -509,7 +643,7 @@ PERF_TEST_P(DevInfo_MatType, cornerMinEigenVal, testing::Combine(testing::Values
 \r
     setDevice(devInfo.deviceID());\r
     \r
-    Mat img = readImage("stereobm/aloe-L.png", CV_LOAD_IMAGE_GRAYSCALE);\r
+    Mat img = readImage("gpu/stereobm/aloe-L.png", CV_LOAD_IMAGE_GRAYSCALE);\r
     ASSERT_FALSE(img.empty());\r
 \r
     img.convertTo(img, type, type == CV_32F ? 1.0 / 255.0 : 1.0);\r
@@ -723,7 +857,7 @@ PERF_TEST_P(DevInfo, Canny, testing::ValuesIn(devices()))
 \r
     setDevice(devInfo.deviceID());\r
 \r
-    Mat image_host = readImage("perf/aloe.jpg", CV_LOAD_IMAGE_GRAYSCALE);\r
+    Mat image_host = readImage("gpu/perf/aloe.jpg", CV_LOAD_IMAGE_GRAYSCALE);\r
     ASSERT_FALSE(image_host.empty());\r
 \r
     GpuMat image(image_host);\r
@@ -741,3 +875,60 @@ PERF_TEST_P(DevInfo, Canny, testing::ValuesIn(devices()))
 \r
     SANITY_CHECK(dst_host);\r
 }\r
+\r
+PERF_TEST_P(DevInfo_Size, calcHist, testing::Combine(testing::ValuesIn(devices()),\r
+                                                     testing::Values(GPU_TYPICAL_MAT_SIZES)))\r
+{\r
+    DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
+    Size size = std::tr1::get<1>(GetParam());\r
+\r
+    setDevice(devInfo.deviceID());\r
+\r
+    Mat src_host(size, CV_8UC1);\r
+\r
+    declare.in(src_host, WARMUP_RNG);\r
+\r
+    GpuMat src(src_host);\r
+    GpuMat hist;\r
+    GpuMat buf;\r
+\r
+    declare.time(0.5).iterations(100);\r
+\r
+    SIMPLE_TEST_CYCLE()\r
+    {\r
+        calcHist(src, hist, buf);\r
+    }\r
+\r
+    Mat hist_host(hist);\r
+\r
+    SANITY_CHECK(hist_host);\r
+}\r
+\r
+PERF_TEST_P(DevInfo_Size, equalizeHist, testing::Combine(testing::ValuesIn(devices()),\r
+                                                         testing::Values(GPU_TYPICAL_MAT_SIZES)))\r
+{\r
+    DeviceInfo devInfo = std::tr1::get<0>(GetParam());\r
+    Size size = std::tr1::get<1>(GetParam());\r
+\r
+    setDevice(devInfo.deviceID());\r
+\r
+    Mat src_host(size, CV_8UC1);\r
+\r
+    declare.in(src_host, WARMUP_RNG);\r
+\r
+    GpuMat src(src_host);\r
+    GpuMat dst;\r
+    GpuMat hist;\r
+    GpuMat buf;\r
+\r
+    declare.time(0.5).iterations(100);\r
+\r
+    SIMPLE_TEST_CYCLE()\r
+    {\r
+        equalizeHist(src, dst, hist, buf);\r
+    }\r
+\r
+    Mat dst_host(dst);\r
+\r
+    SANITY_CHECK(dst_host);\r
+}\r

diff --git a/modules/gpu/perf/perf_main.cpp b/modules/gpu/perf/perf_main.cpp
index 8092deb..89ea368 100644 (file)
--- a/modules/gpu/perf/perf_main.cpp
+++ b/modules/gpu/perf/perf_main.cpp
@@ -5,7 +5,6 @@
 int main(int argc, char **argv)\r
 {\r
     testing::InitGoogleTest(&argc, argv);\r
-    //cvtest::TS::ptr()->init("gpu");\r
     Regression::Init("gpu");\r
     TestBase::Init(argc, argv);\r
     return RUN_ALL_TESTS();\r

diff --git a/modules/gpu/perf/perf_objdetect.cpp b/modules/gpu/perf/perf_objdetect.cpp
new file mode 100644 (file)
index 0000000..50470d8
--- /dev/null
+++ b/modules/gpu/perf/perf_objdetect.cpp
@@ -0,0 +1,23 @@
+#include "perf_precomp.hpp"\r
+\r
+PERF_TEST_P(DevInfo, HOGDescriptor, testing::ValuesIn(devices()))\r
+{\r
+    DeviceInfo devInfo = GetParam();\r
+\r
+    setDevice(devInfo.deviceID());\r
+\r
+    Mat img_host = readImage("gpu/hog/road.png", CV_LOAD_IMAGE_GRAYSCALE);\r
+\r
+    GpuMat img(img_host);\r
+    vector<Rect> found_locations;\r
+\r
+    declare.time(0.5).iterations(100);\r
+\r
+    gpu::HOGDescriptor hog;\r
+    hog.setSVMDetector(gpu::HOGDescriptor::getDefaultPeopleDetector());\r
+\r
+    SIMPLE_TEST_CYCLE()\r
+    {\r
+        hog.detectMultiScale(img, found_locations);\r
+    }\r
+}\r

diff --git a/modules/gpu/perf/perf_utility.hpp b/modules/gpu/perf/perf_utility.hpp
index 66063bc..883bd4a 100644 (file)
--- a/modules/gpu/perf/perf_utility.hpp
+++ b/modules/gpu/perf/perf_utility.hpp
@@ -19,6 +19,7 @@ CV_ENUM(FlipCode, HORIZONTAL_AXIS, VERTICAL_AXIS, BOTH_AXIS)
 CV_ENUM(CmpOp, CMP_EQ, CMP_GT, CMP_GE, CMP_LT, CMP_LE, CMP_NE)\r
 CV_ENUM(Interpolation, INTER_NEAREST, INTER_LINEAR, INTER_CUBIC)\r
 CV_ENUM(MatchMethod, TM_SQDIFF, TM_SQDIFF_NORMED, TM_CCORR, TM_CCORR_NORMED, TM_CCOEFF, TM_CCOEFF_NORMED)\r
+CV_ENUM(NormType, NORM_INF, NORM_L1, NORM_L2)\r
 \r
 struct CvtColorInfo\r
 {\r
@@ -44,6 +45,10 @@ typedef TestBaseWithParam< std::tr1::tuple<DeviceInfo, Size, MatType, Interpolat
 typedef TestBaseWithParam< std::tr1::tuple<DeviceInfo, Size, MatType, Interpolation, BorderMode> > DevInfo_Size_MatType_Interpolation_BorderMode;\r
 typedef TestBaseWithParam< std::tr1::tuple<DeviceInfo, Size, MatType, CvtColorInfo> > DevInfo_Size_MatType_CvtColorInfo;\r
 typedef TestBaseWithParam< std::tr1::tuple<DeviceInfo, Size, MatType, MatchMethod> > DevInfo_Size_MatType_MatchMethod;\r
+typedef TestBaseWithParam< std::tr1::tuple<DeviceInfo, Size, NormType> > DevInfo_Size_NormType;\r
+typedef TestBaseWithParam< std::tr1::tuple<DeviceInfo, Size, MatType, NormType> > DevInfo_Size_MatType_NormType;\r
+typedef TestBaseWithParam< std::tr1::tuple<DeviceInfo, int> > DevInfo_DescSize;\r
+typedef TestBaseWithParam< std::tr1::tuple<DeviceInfo, int, int> > DevInfo_K_DescSize;\r
 \r
 const cv::Size sz1800x1500 = cv::Size(1800, 1500);\r
 const cv::Size sz4700x3000 = cv::Size(4700, 3000);\r