From 6763bd6d01fda8a0e64408ff6486b930f04b967b Mon Sep 17 00:00:00 2001 From: Vladislav Vinogradov Date: Mon, 12 Sep 2011 07:48:09 +0000 Subject: [PATCH] added padded performance tests for gpu module --- modules/gpu/perf/perf_arithm.cpp | 291 +++++++++++++++++++++++++++ modules/gpu/perf/perf_calib3d.cpp | 199 ++++++++++++++++++ modules/gpu/perf/perf_features2d.cpp | 132 ++++++++++++ modules/gpu/perf/perf_imgproc.cpp | 209 ++++++++++++++++++- modules/gpu/perf/perf_main.cpp | 1 - modules/gpu/perf/perf_objdetect.cpp | 23 +++ modules/gpu/perf/perf_utility.hpp | 5 + 7 files changed, 850 insertions(+), 10 deletions(-) create mode 100644 modules/gpu/perf/perf_calib3d.cpp create mode 100644 modules/gpu/perf/perf_features2d.cpp create mode 100644 modules/gpu/perf/perf_objdetect.cpp diff --git a/modules/gpu/perf/perf_arithm.cpp b/modules/gpu/perf/perf_arithm.cpp index be434d20a..f5c4da3b0 100644 --- 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); } +PERF_TEST_P(DevInfo_Size_MatType, subtractMat, testing::Combine(testing::ValuesIn(devices()), + testing::Values(GPU_TYPICAL_MAT_SIZES), + testing::Values(CV_8UC1, CV_8UC4, CV_16SC1, CV_32FC1))) +{ + DeviceInfo devInfo = std::tr1::get<0>(GetParam()); + Size size = std::tr1::get<1>(GetParam()); + int type = std::tr1::get<2>(GetParam()); + + setDevice(devInfo.deviceID()); + + Mat a_host(size, type); + Mat b_host(size, type); + + declare.in(a_host, b_host, WARMUP_RNG); + + GpuMat a(a_host); + GpuMat b(b_host); + GpuMat c(size, type); + + declare.time(0.5).iterations(100); + + SIMPLE_TEST_CYCLE() + { + subtract(a, b, c); + } + + Mat c_host = c; + + SANITY_CHECK(c_host); +} + +PERF_TEST_P(DevInfo_Size, multiplyMat, testing::Combine(testing::ValuesIn(devices()), + testing::Values(GPU_TYPICAL_MAT_SIZES))) +{ + DeviceInfo devInfo = std::tr1::get<0>(GetParam()); + Size size = std::tr1::get<1>(GetParam()); + + setDevice(devInfo.deviceID()); + + Mat a_host(size, CV_8UC1); + Mat b_host(size, CV_32FC1); + + declare.in(a_host, b_host, WARMUP_RNG); + + GpuMat a(a_host); + GpuMat b(b_host); + GpuMat c; + + declare.time(0.5).iterations(100); + + SIMPLE_TEST_CYCLE() + { + multiply(a, b, c); + } + + Mat c_host = c; + + SANITY_CHECK(c_host); +} + +PERF_TEST_P(DevInfo_Size_MatType, multiplyScalar, testing::Combine(testing::ValuesIn(devices()), + testing::Values(GPU_TYPICAL_MAT_SIZES), + testing::Values(CV_8UC1, CV_32FC1))) +{ + DeviceInfo devInfo = std::tr1::get<0>(GetParam()); + Size size = std::tr1::get<1>(GetParam()); + int type = std::tr1::get<2>(GetParam()); + + setDevice(devInfo.deviceID()); + + Mat a_host(size, type); + + declare.in(a_host, WARMUP_RNG); + + GpuMat a(a_host); + Scalar b(1,2,3,4); + GpuMat c(size, type); + + declare.time(0.5).iterations(100); + + SIMPLE_TEST_CYCLE() + { + multiply(a, b, c); + } + + Mat c_host = c; + + SANITY_CHECK(c_host); +} + PERF_TEST_P(DevInfo_Size, exp, testing::Combine(testing::ValuesIn(devices()), testing::Values(GPU_TYPICAL_MAT_SIZES))) { @@ -394,3 +484,204 @@ PERF_TEST_P(DevInfo_Size_MatType, min, testing::Combine(testing::ValuesIn(device SANITY_CHECK(dst_host); } + +PERF_TEST_P(DevInfo_Size, meanStdDev, testing::Combine(testing::ValuesIn(devices()), + testing::Values(GPU_TYPICAL_MAT_SIZES))) +{ + DeviceInfo devInfo = std::tr1::get<0>(GetParam()); + Size size = std::tr1::get<1>(GetParam()); + + setDevice(devInfo.deviceID()); + + Mat src_host(size, CV_8UC1); + + declare.in(src_host, WARMUP_RNG); + + GpuMat src(src_host); + Scalar mean; + Scalar stddev; + + declare.time(0.5).iterations(100); + + SIMPLE_TEST_CYCLE() + { + meanStdDev(src, mean, stddev); + } + + SANITY_CHECK(mean); + SANITY_CHECK(stddev); +} + +PERF_TEST_P(DevInfo_Size_MatType_NormType, norm, testing::Combine(testing::ValuesIn(devices()), + testing::Values(GPU_TYPICAL_MAT_SIZES), + testing::Values(CV_8UC1, CV_16UC1, CV_32SC1), + testing::Values((int)NORM_INF, (int)NORM_L1, (int)NORM_L2))) +{ + DeviceInfo devInfo = std::tr1::get<0>(GetParam()); + Size size = std::tr1::get<1>(GetParam()); + int type = std::tr1::get<2>(GetParam()); + int normType = std::tr1::get<3>(GetParam()); + + setDevice(devInfo.deviceID()); + + Mat src_host(size, type); + + declare.in(src_host, WARMUP_RNG); + + GpuMat src(src_host); + double dst; + GpuMat buf; + + declare.time(0.5).iterations(100); + + SIMPLE_TEST_CYCLE() + { + dst = norm(src, normType, buf); + } + + SANITY_CHECK(dst); +} + +PERF_TEST_P(DevInfo_Size_NormType, normDiff, testing::Combine(testing::ValuesIn(devices()), + testing::Values(GPU_TYPICAL_MAT_SIZES), + testing::Values((int)NORM_INF, (int)NORM_L1, (int)NORM_L2))) +{ + DeviceInfo devInfo = std::tr1::get<0>(GetParam()); + Size size = std::tr1::get<1>(GetParam()); + int normType = std::tr1::get<2>(GetParam()); + + setDevice(devInfo.deviceID()); + + Mat src1_host(size, CV_8UC1); + Mat src2_host(size, CV_8UC1); + + declare.in(src1_host, src2_host, WARMUP_RNG); + + GpuMat src1(src1_host); + GpuMat src2(src2_host); + double dst; + + declare.time(0.5).iterations(100); + + SIMPLE_TEST_CYCLE() + { + dst = norm(src1, src2, normType); + } + + SANITY_CHECK(dst); +} + +PERF_TEST_P(DevInfo_Size_MatType, sum, testing::Combine(testing::ValuesIn(devices()), + testing::Values(GPU_TYPICAL_MAT_SIZES), + testing::Values(CV_8UC1, CV_16UC1, CV_32FC1))) +{ + DeviceInfo devInfo = std::tr1::get<0>(GetParam()); + Size size = std::tr1::get<1>(GetParam()); + int type = std::tr1::get<2>(GetParam()); + + setDevice(devInfo.deviceID()); + + Mat src_host(size, type); + + declare.in(src_host, WARMUP_RNG); + + GpuMat src(src_host); + Scalar dst; + GpuMat buf; + + declare.time(0.5).iterations(100); + + SIMPLE_TEST_CYCLE() + { + dst = sum(src, buf); + } + + SANITY_CHECK(dst); +} + +PERF_TEST_P(DevInfo_Size_MatType, minMax, testing::Combine(testing::ValuesIn(devices()), + testing::Values(GPU_TYPICAL_MAT_SIZES), + testing::Values(CV_8UC1, CV_16UC1, CV_32FC1))) +{ + DeviceInfo devInfo = std::tr1::get<0>(GetParam()); + Size size = std::tr1::get<1>(GetParam()); + int type = std::tr1::get<2>(GetParam()); + + setDevice(devInfo.deviceID()); + + Mat src_host(size, type); + + declare.in(src_host, WARMUP_RNG); + + GpuMat src(src_host); + double minVal, maxVal; + GpuMat buf; + + declare.time(0.5).iterations(100); + + SIMPLE_TEST_CYCLE() + { + minMax(src, &minVal, &maxVal, GpuMat(), buf); + } + + SANITY_CHECK(minVal); + SANITY_CHECK(maxVal); +} + +PERF_TEST_P(DevInfo_Size_MatType, minMaxLoc, testing::Combine(testing::ValuesIn(devices()), + testing::Values(GPU_TYPICAL_MAT_SIZES), + testing::Values(CV_8UC1, CV_16UC1, CV_32FC1))) +{ + DeviceInfo devInfo = std::tr1::get<0>(GetParam()); + Size size = std::tr1::get<1>(GetParam()); + int type = std::tr1::get<2>(GetParam()); + + setDevice(devInfo.deviceID()); + + Mat src_host(size, type); + + declare.in(src_host, WARMUP_RNG); + + GpuMat src(src_host); + double minVal, maxVal; + Point minLoc, maxLoc; + GpuMat valbuf, locbuf; + + declare.time(0.5).iterations(100); + + SIMPLE_TEST_CYCLE() + { + minMaxLoc(src, &minVal, &maxVal, &minLoc, &maxLoc, GpuMat(), valbuf, locbuf); + } + + SANITY_CHECK(minVal); + SANITY_CHECK(maxVal); +} + +PERF_TEST_P(DevInfo_Size_MatType, countNonZero, testing::Combine(testing::ValuesIn(devices()), + testing::Values(GPU_TYPICAL_MAT_SIZES), + testing::Values(CV_8UC1, CV_16UC1, CV_32FC1))) +{ + DeviceInfo devInfo = std::tr1::get<0>(GetParam()); + Size size = std::tr1::get<1>(GetParam()); + int type = std::tr1::get<2>(GetParam()); + + setDevice(devInfo.deviceID()); + + Mat src_host(size, type); + + declare.in(src_host, WARMUP_RNG); + + GpuMat src(src_host); + int dst; + GpuMat buf; + + declare.time(0.5).iterations(100); + + SIMPLE_TEST_CYCLE() + { + dst = countNonZero(src, buf); + } + + SANITY_CHECK(dst); +} diff --git a/modules/gpu/perf/perf_calib3d.cpp b/modules/gpu/perf/perf_calib3d.cpp new file mode 100644 index 000000000..e84f87b3b --- /dev/null +++ b/modules/gpu/perf/perf_calib3d.cpp @@ -0,0 +1,199 @@ +#include "perf_precomp.hpp" + +PERF_TEST_P(DevInfo, transformPoints, testing::ValuesIn(devices())) +{ + DeviceInfo devInfo = GetParam(); + + setDevice(devInfo.deviceID()); + + Mat src_host(1, 10000, CV_32FC3); + + declare.in(src_host, WARMUP_RNG); + + GpuMat src(src_host); + GpuMat dst; + + declare.time(0.5).iterations(100); + + SIMPLE_TEST_CYCLE() + { + transformPoints(src, Mat::ones(1, 3, CV_32FC1), Mat::ones(1, 3, CV_32FC1), dst); + } + + Mat dst_host = dst; + + SANITY_CHECK(dst_host); +} + +PERF_TEST_P(DevInfo, projectPoints, testing::ValuesIn(devices())) +{ + DeviceInfo devInfo = GetParam(); + + setDevice(devInfo.deviceID()); + + Mat src_host(1, 10000, CV_32FC3); + + declare.in(src_host, WARMUP_RNG); + + GpuMat src(src_host); + GpuMat dst; + + declare.time(0.5).iterations(100); + + SIMPLE_TEST_CYCLE() + { + projectPoints(src, Mat::ones(1, 3, CV_32FC1), Mat::ones(1, 3, CV_32FC1), Mat::ones(3, 3, CV_32FC1), Mat(), dst); + } + + Mat dst_host = dst; + + SANITY_CHECK(dst_host); +} + +PERF_TEST_P(DevInfo, solvePnPRansac, testing::ValuesIn(devices())) +{ + DeviceInfo devInfo = GetParam(); + + setDevice(devInfo.deviceID()); + + Mat object(1, 10000, CV_32FC3); + Mat image(1, 10000, CV_32FC2); + + declare.in(object, image, WARMUP_RNG); + + Mat rvec, tvec; + + declare.time(3.0); + + SIMPLE_TEST_CYCLE() + { + solvePnPRansac(object, image, Mat::ones(3, 3, CV_32FC1), Mat(1, 8, CV_32F, Scalar::all(0)), rvec, tvec); + } + + SANITY_CHECK(rvec); + SANITY_CHECK(tvec); +} + +PERF_TEST_P(DevInfo, StereoBM, testing::ValuesIn(devices())) +{ + DeviceInfo devInfo = GetParam(); + + setDevice(devInfo.deviceID()); + + Mat img_l_host = readImage("gpu/perf/aloe.jpg", CV_LOAD_IMAGE_GRAYSCALE); + Mat img_r_host = readImage("gpu/perf/aloeR.jpg", CV_LOAD_IMAGE_GRAYSCALE); + + ASSERT_FALSE(img_l_host.empty()); + ASSERT_FALSE(img_r_host.empty()); + + GpuMat img_l(img_l_host); + GpuMat img_r(img_r_host); + + GpuMat dst; + + StereoBM_GPU bm(0, 256); + + declare.time(0.5).iterations(100); + + SIMPLE_TEST_CYCLE() + { + bm(img_l, img_r, dst); + } + + Mat dst_host(dst); + + SANITY_CHECK(dst_host); +} + +PERF_TEST_P(DevInfo, StereoBeliefPropagation, testing::ValuesIn(devices())) +{ + DeviceInfo devInfo = GetParam(); + + setDevice(devInfo.deviceID()); + + Mat img_l_host = readImage("gpu/stereobm/aloe-L.png", CV_LOAD_IMAGE_GRAYSCALE); + Mat img_r_host = readImage("gpu/stereobm/aloe-R.png", CV_LOAD_IMAGE_GRAYSCALE); + + ASSERT_FALSE(img_l_host.empty()); + ASSERT_FALSE(img_r_host.empty()); + + GpuMat img_l(img_l_host); + GpuMat img_r(img_r_host); + + GpuMat dst; + + StereoBeliefPropagation bp(128); + + declare.time(10.0); + + SIMPLE_TEST_CYCLE() + { + bp(img_l, img_r, dst); + } + + Mat dst_host(dst); + + SANITY_CHECK(dst_host); +} + +PERF_TEST_P(DevInfo, StereoConstantSpaceBP, testing::ValuesIn(devices())) +{ + DeviceInfo devInfo = GetParam(); + + setDevice(devInfo.deviceID()); + + Mat img_l_host = readImage("gpu/perf/aloe.jpg", CV_LOAD_IMAGE_GRAYSCALE); + Mat img_r_host = readImage("gpu/perf/aloeR.jpg", CV_LOAD_IMAGE_GRAYSCALE); + + ASSERT_FALSE(img_l_host.empty()); + ASSERT_FALSE(img_r_host.empty()); + + GpuMat img_l(img_l_host); + GpuMat img_r(img_r_host); + + GpuMat dst; + + StereoConstantSpaceBP bp(128); + + declare.time(10.0); + + SIMPLE_TEST_CYCLE() + { + bp(img_l, img_r, dst); + } + + Mat dst_host(dst); + + SANITY_CHECK(dst_host); +} + +PERF_TEST_P(DevInfo, DisparityBilateralFilter, testing::ValuesIn(devices())) +{ + DeviceInfo devInfo = GetParam(); + + setDevice(devInfo.deviceID()); + + Mat img_host = readImage("gpu/stereobm/aloe-L.png", CV_LOAD_IMAGE_GRAYSCALE); + Mat disp_host = readImage("gpu/stereobm/aloe-disp.png", CV_LOAD_IMAGE_GRAYSCALE); + + ASSERT_FALSE(img_host.empty()); + ASSERT_FALSE(disp_host.empty()); + + GpuMat img(img_host); + GpuMat disp(disp_host); + + GpuMat dst; + + DisparityBilateralFilter f(128); + + declare.time(0.5).iterations(100); + + SIMPLE_TEST_CYCLE() + { + f(disp, img, dst); + } + + Mat dst_host(dst); + + SANITY_CHECK(dst_host); +} diff --git a/modules/gpu/perf/perf_features2d.cpp b/modules/gpu/perf/perf_features2d.cpp new file mode 100644 index 000000000..d2505374d --- /dev/null +++ b/modules/gpu/perf/perf_features2d.cpp @@ -0,0 +1,132 @@ +#include "perf_precomp.hpp" + +PERF_TEST_P(DevInfo_DescSize, BruteForceMatcher_match, testing::Combine(testing::ValuesIn(devices()), + testing::Values(64, 128))) +{ + DeviceInfo devInfo = std::tr1::get<0>(GetParam()); + int desc_size = std::tr1::get<1>(GetParam()); + + setDevice(devInfo.deviceID()); + + Mat query_host(3000, desc_size, CV_32FC1); + Mat train_host(3000, desc_size, CV_32FC1); + + declare.in(query_host, train_host, WARMUP_RNG); + + GpuMat query(query_host); + GpuMat train(train_host); + GpuMat trainIdx, distance; + + BruteForceMatcher_GPU< L2 > matcher; + + declare.time(0.5).iterations(100); + + SIMPLE_TEST_CYCLE() + { + matcher.matchSingle(query, train, trainIdx, distance); + } + + Mat trainIdx_host(trainIdx); + Mat distance_host(distance); + + SANITY_CHECK(trainIdx_host); + SANITY_CHECK(distance_host); +} + +PERF_TEST_P(DevInfo_K_DescSize, BruteForceMatcher_knnMatch, testing::Combine(testing::ValuesIn(devices()), + testing::Values(2, 3), + testing::Values(64, 128))) +{ + DeviceInfo devInfo = std::tr1::get<0>(GetParam()); + int k = std::tr1::get<1>(GetParam()); + int desc_size = std::tr1::get<2>(GetParam()); + + setDevice(devInfo.deviceID()); + + Mat query_host(3000, desc_size, CV_32FC1); + Mat train_host(3000, desc_size, CV_32FC1); + + declare.in(query_host, train_host, WARMUP_RNG); + + GpuMat query(query_host); + GpuMat train(train_host); + GpuMat trainIdx, distance, allDist; + + BruteForceMatcher_GPU< L2 > matcher; + + declare.time(0.5).iterations(100); + + SIMPLE_TEST_CYCLE() + { + matcher.knnMatch(query, train, trainIdx, distance, allDist, k); + } + + Mat trainIdx_host(trainIdx); + Mat distance_host(distance); + + SANITY_CHECK(trainIdx_host); + SANITY_CHECK(distance_host); +} + +PERF_TEST_P(DevInfo_DescSize, BruteForceMatcher_radiusMatch, testing::Combine(testing::ValuesIn(devices(GLOBAL_ATOMICS)), + testing::Values(64, 128))) +{ + DeviceInfo devInfo = std::tr1::get<0>(GetParam()); + int desc_size = std::tr1::get<1>(GetParam()); + + setDevice(devInfo.deviceID()); + + Mat query_host = cvtest::randomMat(theRNG(), Size(desc_size, 3000), CV_32FC1, 0, 1, false); + Mat train_host = cvtest::randomMat(theRNG(), Size(desc_size, 3000), CV_32FC1, 0, 1, false); + + GpuMat query(query_host); + GpuMat train(train_host); + GpuMat trainIdx, nMatches, distance; + + BruteForceMatcher_GPU< L2 > matcher; + + declare.time(0.5).iterations(100); + + SIMPLE_TEST_CYCLE() + { + matcher.radiusMatch(query, train, trainIdx, nMatches, distance, 2.0); + } + + Mat trainIdx_host(trainIdx); + Mat nMatches_host(nMatches); + Mat distance_host(distance); + + SANITY_CHECK(trainIdx_host); + SANITY_CHECK(nMatches_host); + SANITY_CHECK(distance_host); +} + +PERF_TEST_P(DevInfo, SURF, testing::ValuesIn(devices())) +{ + DeviceInfo devInfo = GetParam(); + + setDevice(devInfo.deviceID()); + + Mat img_host = readImage("gpu/perf/aloe.jpg", CV_LOAD_IMAGE_GRAYSCALE); + + ASSERT_FALSE(img_host.empty()); + + GpuMat img(img_host); + GpuMat keypoints, descriptors; + + SURF_GPU surf; + + declare.time(2.0); + + SIMPLE_TEST_CYCLE() + { + surf(img, GpuMat(), keypoints, descriptors); + } + + Mat keypoints_host(keypoints); + Mat descriptors_host(descriptors); + + SANITY_CHECK(keypoints_host); + SANITY_CHECK(descriptors_host); +} + diff --git a/modules/gpu/perf/perf_imgproc.cpp b/modules/gpu/perf/perf_imgproc.cpp index 3a6d165ff..67e746684 100644 --- 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())) setDevice(devInfo.deviceID()); - Mat img = readImage("meanshift/cones.png"); + Mat img = readImage("gpu/meanshift/cones.png"); ASSERT_FALSE(img.empty()); Mat rgba; @@ -74,7 +74,7 @@ PERF_TEST_P(DevInfo, meanShiftProc, testing::ValuesIn(devices())) setDevice(devInfo.deviceID()); - Mat img = readImage("meanshift/cones.png"); + Mat img = readImage("gpu/meanshift/cones.png"); ASSERT_FALSE(img.empty()); Mat rgba; @@ -104,7 +104,7 @@ PERF_TEST_P(DevInfo, meanShiftSegmentation, testing::ValuesIn(devices())) setDevice(devInfo.deviceID()); - Mat img = readImage("meanshift/cones.png"); + Mat img = readImage("gpu/meanshift/cones.png"); ASSERT_FALSE(img.empty()); Mat rgba; @@ -123,6 +123,35 @@ PERF_TEST_P(DevInfo, meanShiftSegmentation, testing::ValuesIn(devices())) SANITY_CHECK(dst); } +PERF_TEST_P(DevInfo_Size_MatType, drawColorDisp, testing::Combine(testing::ValuesIn(devices()), + testing::Values(GPU_TYPICAL_MAT_SIZES), + testing::Values(CV_8UC1, CV_16SC1))) +{ + DeviceInfo devInfo = std::tr1::get<0>(GetParam()); + Size size = std::tr1::get<1>(GetParam()); + int type = std::tr1::get<2>(GetParam()); + + setDevice(devInfo.deviceID()); + + Mat src_host(size, CV_8UC1); + declare.in(src_host, WARMUP_RNG); + src_host.convertTo(src_host, type); + + GpuMat src(src_host); + GpuMat dst(size, CV_8UC4); + + declare.time(0.5).iterations(100); + + SIMPLE_TEST_CYCLE() + { + drawColorDisp(src, dst, 255); + } + + Mat dst_host(dst); + + SANITY_CHECK(dst_host); +} + PERF_TEST_P(DevInfo_Size_MatType, reprojectImageTo3D, testing::Combine(testing::ValuesIn(devices()), testing::Values(GPU_TYPICAL_MAT_SIZES), testing::Values(CV_8UC1, CV_16SC1))) @@ -156,7 +185,8 @@ PERF_TEST_P(DevInfo_Size_MatType_CvtColorInfo, cvtColor, testing::Combine(testin testing::Values(GPU_TYPICAL_MAT_SIZES), testing::Values(CV_8UC1, CV_16UC1, CV_32FC1), testing::Values(CvtColorInfo(4, 4, CV_RGBA2BGRA), CvtColorInfo(4, 1, CV_BGRA2GRAY), CvtColorInfo(1, 4, CV_GRAY2BGRA), - CvtColorInfo(4, 4, CV_BGR2XYZ), CvtColorInfo(4, 4, CV_BGR2YCrCb), CvtColorInfo(4, 4, CV_BGR2HSV)))) + CvtColorInfo(4, 4, CV_BGR2XYZ), CvtColorInfo(4, 4, CV_BGR2YCrCb), CvtColorInfo(4, 4, CV_YCrCb2BGR), + CvtColorInfo(4, 4, CV_BGR2HSV), CvtColorInfo(4, 4, CV_HSV2BGR)))) { DeviceInfo devInfo = std::tr1::get<0>(GetParam()); Size size = std::tr1::get<1>(GetParam()); @@ -321,6 +351,81 @@ PERF_TEST_P(DevInfo_Size_MatType_Interpolation, warpPerspective, testing::Combin SANITY_CHECK(dst_host); } +PERF_TEST_P(DevInfo_Size, buildWarpPlaneMaps, testing::Combine(testing::ValuesIn(devices()), + testing::Values(GPU_TYPICAL_MAT_SIZES))) +{ + DeviceInfo devInfo = std::tr1::get<0>(GetParam()); + Size size = std::tr1::get<1>(GetParam()); + + setDevice(devInfo.deviceID()); + + GpuMat map_x(size, CV_32FC1); + GpuMat map_y(size, CV_32FC1); + + declare.time(0.5).iterations(100); + + SIMPLE_TEST_CYCLE() + { + 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); + } + + Mat map_x_host(map_x); + Mat map_y_host(map_y); + + SANITY_CHECK(map_x_host); + SANITY_CHECK(map_y_host); +} + +PERF_TEST_P(DevInfo_Size, buildWarpCylindricalMaps, testing::Combine(testing::ValuesIn(devices()), + testing::Values(GPU_TYPICAL_MAT_SIZES))) +{ + DeviceInfo devInfo = std::tr1::get<0>(GetParam()); + Size size = std::tr1::get<1>(GetParam()); + + setDevice(devInfo.deviceID()); + + GpuMat map_x(size, CV_32FC1); + GpuMat map_y(size, CV_32FC1); + + declare.time(0.5).iterations(100); + + SIMPLE_TEST_CYCLE() + { + buildWarpCylindricalMaps(size, Rect(0, 0, size.width, size.height), Mat::ones(3, 3, CV_32FC1), 1.0, 1.0, map_x, map_y); + } + + Mat map_x_host(map_x); + Mat map_y_host(map_y); + + SANITY_CHECK(map_x_host); + SANITY_CHECK(map_y_host); +} + +PERF_TEST_P(DevInfo_Size, buildWarpSphericalMaps, testing::Combine(testing::ValuesIn(devices()), + testing::Values(GPU_TYPICAL_MAT_SIZES))) +{ + DeviceInfo devInfo = std::tr1::get<0>(GetParam()); + Size size = std::tr1::get<1>(GetParam()); + + setDevice(devInfo.deviceID()); + + GpuMat map_x(size, CV_32FC1); + GpuMat map_y(size, CV_32FC1); + + declare.time(0.5).iterations(100); + + SIMPLE_TEST_CYCLE() + { + buildWarpSphericalMaps(size, Rect(0, 0, size.width, size.height), Mat::ones(3, 3, CV_32FC1), 1.0, 1.0, map_x, map_y); + } + + Mat map_x_host(map_x); + Mat map_y_host(map_y); + + SANITY_CHECK(map_x_host); + SANITY_CHECK(map_y_host); +} + PERF_TEST_P(DevInfo_Size_MatType_Interpolation, rotate, testing::Combine(testing::ValuesIn(devices()), testing::Values(GPU_TYPICAL_MAT_SIZES), testing::Values(CV_8UC1, CV_8UC4), @@ -381,8 +486,8 @@ PERF_TEST_P(DevInfo_Size_MatType, copyMakeBorder, testing::Combine(testing::Valu SANITY_CHECK(dst_host); } -PERF_TEST_P(DevInfo_Size, integral, testing::Combine(testing::ValuesIn(devices()), - testing::Values(GPU_TYPICAL_MAT_SIZES))) +PERF_TEST_P(DevInfo_Size, integralBuffered, testing::Combine(testing::ValuesIn(devices()), + testing::Values(GPU_TYPICAL_MAT_SIZES))) { DeviceInfo devInfo = std::tr1::get<0>(GetParam()); Size size = std::tr1::get<1>(GetParam()); @@ -409,6 +514,35 @@ PERF_TEST_P(DevInfo_Size, integral, testing::Combine(testing::ValuesIn(devices() SANITY_CHECK(dst_host); } +PERF_TEST_P(DevInfo_Size, integral, testing::Combine(testing::ValuesIn(devices()), + testing::Values(GPU_TYPICAL_MAT_SIZES))) +{ + DeviceInfo devInfo = std::tr1::get<0>(GetParam()); + Size size = std::tr1::get<1>(GetParam()); + + setDevice(devInfo.deviceID()); + + Mat src_host(size, CV_8UC1); + + declare.in(src_host, WARMUP_RNG); + + GpuMat src(src_host); + GpuMat sum, sqsum; + + declare.time(0.5).iterations(100); + + SIMPLE_TEST_CYCLE() + { + integral(src, sum, sqsum); + } + + Mat sum_host(sum); + Mat sqsum_host(sqsum); + + SANITY_CHECK(sum_host); + SANITY_CHECK(sqsum_host); +} + PERF_TEST_P(DevInfo_Size, sqrIntegral, testing::Combine(testing::ValuesIn(devices()), testing::Values(GPU_TYPICAL_MAT_SIZES))) { @@ -471,7 +605,7 @@ PERF_TEST_P(DevInfo_MatType, cornerHarris, testing::Combine(testing::ValuesIn(de setDevice(devInfo.deviceID()); - Mat img = readImage("stereobm/aloe-L.png", CV_LOAD_IMAGE_GRAYSCALE); + Mat img = readImage("gpu/stereobm/aloe-L.png", CV_LOAD_IMAGE_GRAYSCALE); ASSERT_FALSE(img.empty()); img.convertTo(img, type, type == CV_32F ? 1.0 / 255.0 : 1.0); @@ -509,7 +643,7 @@ PERF_TEST_P(DevInfo_MatType, cornerMinEigenVal, testing::Combine(testing::Values setDevice(devInfo.deviceID()); - Mat img = readImage("stereobm/aloe-L.png", CV_LOAD_IMAGE_GRAYSCALE); + Mat img = readImage("gpu/stereobm/aloe-L.png", CV_LOAD_IMAGE_GRAYSCALE); ASSERT_FALSE(img.empty()); img.convertTo(img, type, type == CV_32F ? 1.0 / 255.0 : 1.0); @@ -723,7 +857,7 @@ PERF_TEST_P(DevInfo, Canny, testing::ValuesIn(devices())) setDevice(devInfo.deviceID()); - Mat image_host = readImage("perf/aloe.jpg", CV_LOAD_IMAGE_GRAYSCALE); + Mat image_host = readImage("gpu/perf/aloe.jpg", CV_LOAD_IMAGE_GRAYSCALE); ASSERT_FALSE(image_host.empty()); GpuMat image(image_host); @@ -741,3 +875,60 @@ PERF_TEST_P(DevInfo, Canny, testing::ValuesIn(devices())) SANITY_CHECK(dst_host); } + +PERF_TEST_P(DevInfo_Size, calcHist, testing::Combine(testing::ValuesIn(devices()), + testing::Values(GPU_TYPICAL_MAT_SIZES))) +{ + DeviceInfo devInfo = std::tr1::get<0>(GetParam()); + Size size = std::tr1::get<1>(GetParam()); + + setDevice(devInfo.deviceID()); + + Mat src_host(size, CV_8UC1); + + declare.in(src_host, WARMUP_RNG); + + GpuMat src(src_host); + GpuMat hist; + GpuMat buf; + + declare.time(0.5).iterations(100); + + SIMPLE_TEST_CYCLE() + { + calcHist(src, hist, buf); + } + + Mat hist_host(hist); + + SANITY_CHECK(hist_host); +} + +PERF_TEST_P(DevInfo_Size, equalizeHist, testing::Combine(testing::ValuesIn(devices()), + testing::Values(GPU_TYPICAL_MAT_SIZES))) +{ + DeviceInfo devInfo = std::tr1::get<0>(GetParam()); + Size size = std::tr1::get<1>(GetParam()); + + setDevice(devInfo.deviceID()); + + Mat src_host(size, CV_8UC1); + + declare.in(src_host, WARMUP_RNG); + + GpuMat src(src_host); + GpuMat dst; + GpuMat hist; + GpuMat buf; + + declare.time(0.5).iterations(100); + + SIMPLE_TEST_CYCLE() + { + equalizeHist(src, dst, hist, buf); + } + + Mat dst_host(dst); + + SANITY_CHECK(dst_host); +} diff --git a/modules/gpu/perf/perf_main.cpp b/modules/gpu/perf/perf_main.cpp index 8092deb83..89ea36874 100644 --- a/modules/gpu/perf/perf_main.cpp +++ b/modules/gpu/perf/perf_main.cpp @@ -5,7 +5,6 @@ int main(int argc, char **argv) { testing::InitGoogleTest(&argc, argv); - //cvtest::TS::ptr()->init("gpu"); Regression::Init("gpu"); TestBase::Init(argc, argv); return RUN_ALL_TESTS(); diff --git a/modules/gpu/perf/perf_objdetect.cpp b/modules/gpu/perf/perf_objdetect.cpp new file mode 100644 index 000000000..50470d8ab --- /dev/null +++ b/modules/gpu/perf/perf_objdetect.cpp @@ -0,0 +1,23 @@ +#include "perf_precomp.hpp" + +PERF_TEST_P(DevInfo, HOGDescriptor, testing::ValuesIn(devices())) +{ + DeviceInfo devInfo = GetParam(); + + setDevice(devInfo.deviceID()); + + Mat img_host = readImage("gpu/hog/road.png", CV_LOAD_IMAGE_GRAYSCALE); + + GpuMat img(img_host); + vector found_locations; + + declare.time(0.5).iterations(100); + + gpu::HOGDescriptor hog; + hog.setSVMDetector(gpu::HOGDescriptor::getDefaultPeopleDetector()); + + SIMPLE_TEST_CYCLE() + { + hog.detectMultiScale(img, found_locations); + } +} diff --git a/modules/gpu/perf/perf_utility.hpp b/modules/gpu/perf/perf_utility.hpp index 66063bc85..883bd4a39 100644 --- 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) CV_ENUM(Interpolation, INTER_NEAREST, INTER_LINEAR, INTER_CUBIC) CV_ENUM(MatchMethod, TM_SQDIFF, TM_SQDIFF_NORMED, TM_CCORR, TM_CCORR_NORMED, TM_CCOEFF, TM_CCOEFF_NORMED) +CV_ENUM(NormType, NORM_INF, NORM_L1, NORM_L2) struct CvtColorInfo { @@ -44,6 +45,10 @@ typedef TestBaseWithParam< std::tr1::tuple > DevInfo_Size_MatType_Interpolation_BorderMode; typedef TestBaseWithParam< std::tr1::tuple > DevInfo_Size_MatType_CvtColorInfo; typedef TestBaseWithParam< std::tr1::tuple > DevInfo_Size_MatType_MatchMethod; +typedef TestBaseWithParam< std::tr1::tuple > DevInfo_Size_NormType; +typedef TestBaseWithParam< std::tr1::tuple > DevInfo_Size_MatType_NormType; +typedef TestBaseWithParam< std::tr1::tuple > DevInfo_DescSize; +typedef TestBaseWithParam< std::tr1::tuple > DevInfo_K_DescSize; const cv::Size sz1800x1500 = cv::Size(1800, 1500); const cv::Size sz4700x3000 = cv::Size(4700, 3000);