From 73c152abc40c8a1e7a6119c32f1c16f0348abc00 Mon Sep 17 00:00:00 2001 From: Andrey Kamaev Date: Fri, 15 Jun 2012 08:52:08 +0000 Subject: [PATCH] Merged the trunk r8575:8583 (INTER_AREA interpolation for GPU resize) --- modules/gpu/perf/perf_imgproc.cpp | 1141 +++++++++++++-------- modules/gpu/perf/perf_utility.hpp | 27 +- modules/gpu/src/cuda/resize.cu | 72 +- modules/gpu/src/opencv2/gpu/device/filters.hpp | 111 +- modules/gpu/src/opencv2/gpu/device/vec_traits.hpp | 4 +- modules/gpu/src/resize.cpp | 5 +- modules/gpu/test/test_resize.cpp | 48 +- modules/gpu/test/utility.hpp | 2 +- modules/imgproc/src/imgwarp.cpp | 47 +- modules/imgproc/test/test_imgwarp.cpp | 43 + 10 files changed, 1019 insertions(+), 481 deletions(-) diff --git a/modules/gpu/perf/perf_imgproc.cpp b/modules/gpu/perf/perf_imgproc.cpp index 5472acf..b261ad0 100644 --- a/modules/gpu/perf/perf_imgproc.cpp +++ b/modules/gpu/perf/perf_imgproc.cpp @@ -5,27 +5,32 @@ ////////////////////////////////////////////////////////////////////// // Remap -GPU_PERF_TEST(Remap, cv::gpu::DeviceInfo, cv::Size, perf::MatType, Interpolation, BorderMode) +GPU_PERF_TEST(Remap, cv::gpu::DeviceInfo, cv::Size, MatType, Interpolation, BorderMode) { cv::gpu::DeviceInfo devInfo = GET_PARAM(0); + cv::gpu::setDevice(devInfo.deviceID()); + cv::Size size = GET_PARAM(1); int type = GET_PARAM(2); int interpolation = GET_PARAM(3); int borderMode = GET_PARAM(4); - cv::gpu::setDevice(devInfo.deviceID()); - cv::Mat src_host(size, type); + fill(src_host, 0, 255); + cv::Mat xmap_host(size, CV_32FC1); - cv::Mat ymap_host(size, CV_32FC1); + fill(xmap_host, 0, size.width); - declare.in(src_host, xmap_host, ymap_host, WARMUP_RNG); + cv::Mat ymap_host(size, CV_32FC1); + fill(ymap_host, 0, size.height); cv::gpu::GpuMat src(src_host); cv::gpu::GpuMat xmap(xmap_host); cv::gpu::GpuMat ymap(ymap_host); cv::gpu::GpuMat dst; + cv::gpu::remap(src, dst, xmap, ymap, interpolation, borderMode); + declare.time(3.0); TEST_CYCLE() @@ -35,578 +40,815 @@ GPU_PERF_TEST(Remap, cv::gpu::DeviceInfo, cv::Size, perf::MatType, Interpolation } INSTANTIATE_TEST_CASE_P(ImgProc, Remap, testing::Combine( - ALL_DEVICES, - GPU_TYPICAL_MAT_SIZES, - testing::Values(CV_8UC1, CV_8UC4, CV_16UC1, CV_32FC1), - testing::Values((int) cv::INTER_NEAREST, (int) cv::INTER_LINEAR, (int) cv::INTER_CUBIC), - testing::Values((int) cv::BORDER_REFLECT101, (int) cv::BORDER_REPLICATE, (int) cv::BORDER_CONSTANT))); + ALL_DEVICES, + GPU_TYPICAL_MAT_SIZES, + testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), + MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4), + MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)), + testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)), + testing::Values(BorderMode(cv::BORDER_REFLECT101), BorderMode(cv::BORDER_REPLICATE), BorderMode(cv::BORDER_CONSTANT), BorderMode(cv::BORDER_REFLECT), BorderMode(cv::BORDER_WRAP)))); + ////////////////////////////////////////////////////////////////////// -// MeanShiftFiltering +// Resize -GPU_PERF_TEST_1(MeanShiftFiltering, cv::gpu::DeviceInfo) -{ - cv::gpu::DeviceInfo devInfo = GetParam(); +IMPLEMENT_PARAM_CLASS(Scale, double) +GPU_PERF_TEST(Resize, cv::gpu::DeviceInfo, cv::Size, MatType, Interpolation, Scale) +{ + cv::gpu::DeviceInfo devInfo = GET_PARAM(0); cv::gpu::setDevice(devInfo.deviceID()); - cv::Mat img = readImage("gpu/meanshift/cones.png"); - ASSERT_FALSE(img.empty()); + cv::Size size = GET_PARAM(1); + int type = GET_PARAM(2); + int interpolation = GET_PARAM(3); + double f = GET_PARAM(4); - cv::Mat rgba; - cv::cvtColor(img, rgba, cv::COLOR_BGR2BGRA); + cv::Mat src_host(size, type); + fill(src_host, 0, 255); - cv::gpu::GpuMat src(rgba); + cv::gpu::GpuMat src(src_host); cv::gpu::GpuMat dst; - declare.time(5.0); + cv::gpu::resize(src, dst, cv::Size(), f, f, interpolation); + + declare.time(1.0); TEST_CYCLE() { - cv::gpu::meanShiftFiltering(src, dst, 50, 50); + cv::gpu::resize(src, dst, cv::Size(), f, f, interpolation); } } -INSTANTIATE_TEST_CASE_P(ImgProc, MeanShiftFiltering, ALL_DEVICES); +INSTANTIATE_TEST_CASE_P(ImgProc, Resize, testing::Combine( + ALL_DEVICES, + GPU_TYPICAL_MAT_SIZES, + testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), + MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4), + MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)), + testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), + Interpolation(cv::INTER_CUBIC), Interpolation(cv::INTER_AREA)), + testing::Values(Scale(0.5), Scale(0.3), Scale(2.0)))); ////////////////////////////////////////////////////////////////////// -// MeanShiftProc +// WarpAffine -GPU_PERF_TEST_1(MeanShiftProc, cv::gpu::DeviceInfo) +GPU_PERF_TEST(WarpAffine, cv::gpu::DeviceInfo, cv::Size, MatType, Interpolation, BorderMode) { - cv::gpu::DeviceInfo devInfo = GetParam(); - + cv::gpu::DeviceInfo devInfo = GET_PARAM(0); cv::gpu::setDevice(devInfo.deviceID()); - cv::Mat img = readImage("gpu/meanshift/cones.png"); - ASSERT_FALSE(img.empty()); + cv::Size size = GET_PARAM(1); + int type = GET_PARAM(2); + int interpolation = GET_PARAM(3); + int borderMode = GET_PARAM(4); - cv::Mat rgba; - cv::cvtColor(img, rgba, cv::COLOR_BGR2BGRA); + cv::Mat src_host(size, type); + fill(src_host, 0, 255); - cv::gpu::GpuMat src(rgba); - cv::gpu::GpuMat dstr; - cv::gpu::GpuMat dstsp; + cv::gpu::GpuMat src(src_host); + cv::gpu::GpuMat dst; - declare.time(5.0); + const double aplha = CV_PI / 4; + double mat[2][3] = { {std::cos(aplha), -std::sin(aplha), src.cols / 2}, + {std::sin(aplha), std::cos(aplha), 0}}; + cv::Mat M(2, 3, CV_64F, (void*) mat); + + cv::gpu::warpAffine(src, dst, M, size, interpolation, borderMode); TEST_CYCLE() { - cv::gpu::meanShiftProc(src, dstr, dstsp, 50, 50); + cv::gpu::warpAffine(src, dst, M, size, interpolation, borderMode); } } -INSTANTIATE_TEST_CASE_P(ImgProc, MeanShiftProc, ALL_DEVICES); +INSTANTIATE_TEST_CASE_P(ImgProc, WarpAffine, testing::Combine( + ALL_DEVICES, + GPU_TYPICAL_MAT_SIZES, + testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), + MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4), + MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)), + testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)), + testing::Values(BorderMode(cv::BORDER_REFLECT101), BorderMode(cv::BORDER_REPLICATE), BorderMode(cv::BORDER_CONSTANT), BorderMode(cv::BORDER_REFLECT), BorderMode(cv::BORDER_WRAP)))); ////////////////////////////////////////////////////////////////////// -// MeanShiftSegmentation +// WarpPerspective -GPU_PERF_TEST_1(MeanShiftSegmentation, cv::gpu::DeviceInfo) +GPU_PERF_TEST(WarpPerspective, cv::gpu::DeviceInfo, cv::Size, MatType, Interpolation, BorderMode) { - cv::gpu::DeviceInfo devInfo = GetParam(); - + cv::gpu::DeviceInfo devInfo = GET_PARAM(0); cv::gpu::setDevice(devInfo.deviceID()); - cv::Mat img = readImage("gpu/meanshift/cones.png"); - ASSERT_FALSE(img.empty()); + cv::Size size = GET_PARAM(1); + int type = GET_PARAM(2); + int interpolation = GET_PARAM(3); + int borderMode = GET_PARAM(4); - cv::Mat rgba; - cv::cvtColor(img, rgba, cv::COLOR_BGR2BGRA); + cv::Mat src_host(size, type); + fill(src_host, 0, 255); - cv::gpu::GpuMat src(rgba); - cv::Mat dst; + cv::gpu::GpuMat src(src_host); + cv::gpu::GpuMat dst; - declare.time(5.0); + const double aplha = CV_PI / 4; + double mat[3][3] = { {std::cos(aplha), -std::sin(aplha), src.cols / 2}, + {std::sin(aplha), std::cos(aplha), 0}, + {0.0, 0.0, 1.0}}; + cv::Mat M(3, 3, CV_64F, (void*) mat); + + cv::gpu::warpPerspective(src, dst, M, size, interpolation, borderMode); TEST_CYCLE() { - meanShiftSegmentation(src, dst, 10, 10, 20); + cv::gpu::warpPerspective(src, dst, M, size, interpolation, borderMode); } } -INSTANTIATE_TEST_CASE_P(ImgProc, MeanShiftSegmentation, ALL_DEVICES); +INSTANTIATE_TEST_CASE_P(ImgProc, WarpPerspective, testing::Combine( + ALL_DEVICES, + GPU_TYPICAL_MAT_SIZES, + testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), + MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4), + MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)), + testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)), + testing::Values(BorderMode(cv::BORDER_REFLECT101), BorderMode(cv::BORDER_REPLICATE), BorderMode(cv::BORDER_CONSTANT), BorderMode(cv::BORDER_REFLECT), BorderMode(cv::BORDER_WRAP)))); ////////////////////////////////////////////////////////////////////// -// DrawColorDisp +// CopyMakeBorder -GPU_PERF_TEST(DrawColorDisp, cv::gpu::DeviceInfo, cv::Size, perf::MatType) +GPU_PERF_TEST(CopyMakeBorder, cv::gpu::DeviceInfo, cv::Size, MatType, BorderMode) { cv::gpu::DeviceInfo devInfo = GET_PARAM(0); + cv::gpu::setDevice(devInfo.deviceID()); + cv::Size size = GET_PARAM(1); int type = GET_PARAM(2); - - cv::gpu::setDevice(devInfo.deviceID()); + int borderType = GET_PARAM(3); cv::Mat src_host(size, type); - fill(src_host, 0, 255); cv::gpu::GpuMat src(src_host); cv::gpu::GpuMat dst; + cv::gpu::copyMakeBorder(src, dst, 5, 5, 5, 5, borderType); + TEST_CYCLE() { - cv::gpu::drawColorDisp(src, dst, 255); + cv::gpu::copyMakeBorder(src, dst, 5, 5, 5, 5, borderType); } } -INSTANTIATE_TEST_CASE_P(ImgProc, DrawColorDisp, testing::Combine( - ALL_DEVICES, - GPU_TYPICAL_MAT_SIZES, - testing::Values(CV_8UC1, CV_16SC1))); +INSTANTIATE_TEST_CASE_P(ImgProc, CopyMakeBorder, testing::Combine( + ALL_DEVICES, + GPU_TYPICAL_MAT_SIZES, + testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), + MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4), + MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)), + testing::Values(BorderMode(cv::BORDER_REFLECT101), BorderMode(cv::BORDER_REPLICATE), BorderMode(cv::BORDER_CONSTANT), BorderMode(cv::BORDER_REFLECT), BorderMode(cv::BORDER_WRAP)))); ////////////////////////////////////////////////////////////////////// -// ReprojectImageTo3D +// Threshold + +CV_ENUM(ThreshOp, cv::THRESH_BINARY, cv::THRESH_BINARY_INV, cv::THRESH_TRUNC, cv::THRESH_TOZERO, cv::THRESH_TOZERO_INV) +#define ALL_THRESH_OPS testing::Values(ThreshOp(cv::THRESH_BINARY), ThreshOp(cv::THRESH_BINARY_INV), ThreshOp(cv::THRESH_TRUNC), ThreshOp(cv::THRESH_TOZERO), ThreshOp(cv::THRESH_TOZERO_INV)) -GPU_PERF_TEST(ReprojectImageTo3D, cv::gpu::DeviceInfo, cv::Size, perf::MatType) +GPU_PERF_TEST(Threshold, cv::gpu::DeviceInfo, cv::Size, MatDepth, ThreshOp) { 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_host(size, type); + cv::Size size = GET_PARAM(1); + int depth = GET_PARAM(2); + int threshOp = GET_PARAM(3); - declare.in(src_host, WARMUP_RNG); + cv::Mat src_host(size, depth); + fill(src_host, 0, 255); cv::gpu::GpuMat src(src_host); cv::gpu::GpuMat dst; + cv::gpu::threshold(src, dst, 100.0, 255.0, threshOp); + TEST_CYCLE() { - cv::gpu::reprojectImageTo3D(src, dst, cv::Mat::ones(4, 4, CV_32FC1)); + cv::gpu::threshold(src, dst, 100.0, 255.0, threshOp); } } -INSTANTIATE_TEST_CASE_P(ImgProc, ReprojectImageTo3D, testing::Combine( - ALL_DEVICES, - GPU_TYPICAL_MAT_SIZES, - testing::Values(CV_8UC1, CV_16SC1))); +INSTANTIATE_TEST_CASE_P(ImgProc, Threshold, testing::Combine( + ALL_DEVICES, + GPU_TYPICAL_MAT_SIZES, + testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_32F), MatDepth(CV_64F)), + ALL_THRESH_OPS)); ////////////////////////////////////////////////////////////////////// -// CvtColor +// Integral -GPU_PERF_TEST(CvtColor, cv::gpu::DeviceInfo, cv::Size, perf::MatType, CvtColorInfo) +GPU_PERF_TEST(Integral, cv::gpu::DeviceInfo, cv::Size) { cv::gpu::DeviceInfo devInfo = GET_PARAM(0); - cv::Size size = GET_PARAM(1); - int type = GET_PARAM(2); - CvtColorInfo info = GET_PARAM(3); - cv::gpu::setDevice(devInfo.deviceID()); - cv::Mat src_host(size, CV_MAKETYPE(type, info.scn)); + cv::Size size = GET_PARAM(1); - declare.in(src_host, WARMUP_RNG); + cv::Mat src_host(size, CV_8UC1); + fill(src_host, 0, 255); cv::gpu::GpuMat src(src_host); cv::gpu::GpuMat dst; + cv::gpu::GpuMat buf; + + cv::gpu::integralBuffered(src, dst, buf); TEST_CYCLE() { - cv::gpu::cvtColor(src, dst, info.code, info.dcn); + cv::gpu::integralBuffered(src, dst, buf); } } -INSTANTIATE_TEST_CASE_P(ImgProc, CvtColor, testing::Combine( - ALL_DEVICES, - GPU_TYPICAL_MAT_SIZES, - testing::Values(CV_8UC1, CV_16UC1, CV_32FC1), - testing::Values( - CvtColorInfo(4, 4, cv::COLOR_RGBA2BGRA), CvtColorInfo(4, 1, cv::COLOR_BGRA2GRAY), CvtColorInfo(1, 4, cv::COLOR_GRAY2BGRA), - CvtColorInfo(4, 4, cv::COLOR_BGR2XYZ), CvtColorInfo(4, 4, cv::COLOR_BGR2YCrCb), CvtColorInfo(4, 4, cv::COLOR_YCrCb2BGR), - CvtColorInfo(4, 4, cv::COLOR_BGR2HSV), CvtColorInfo(4, 4, cv::COLOR_HSV2BGR)))); +INSTANTIATE_TEST_CASE_P(ImgProc, Integral, testing::Combine( + ALL_DEVICES, + GPU_TYPICAL_MAT_SIZES)); ////////////////////////////////////////////////////////////////////// -// SwapChannels +// Integral_Sqr -GPU_PERF_TEST(SwapChannels, cv::gpu::DeviceInfo, cv::Size) +GPU_PERF_TEST(Integral_Sqr, cv::gpu::DeviceInfo, cv::Size) { cv::gpu::DeviceInfo devInfo = GET_PARAM(0); - cv::Size size = GET_PARAM(1); - cv::gpu::setDevice(devInfo.deviceID()); - cv::Mat src_host(size, CV_8UC4); + cv::Size size = GET_PARAM(1); - declare.in(src_host, WARMUP_RNG); + cv::Mat src_host(size, CV_8UC1); + fill(src_host, 0, 255); cv::gpu::GpuMat src(src_host); + cv::gpu::GpuMat dst; - const int dstOrder[] = {2, 1, 0, 3}; + cv::gpu::sqrIntegral(src, dst); TEST_CYCLE() { - cv::gpu::swapChannels(src, dstOrder); + cv::gpu::sqrIntegral(src, dst); } } -INSTANTIATE_TEST_CASE_P(ImgProc, SwapChannels, testing::Combine(ALL_DEVICES, GPU_TYPICAL_MAT_SIZES)); +INSTANTIATE_TEST_CASE_P(ImgProc, Integral_Sqr, testing::Combine( + ALL_DEVICES, + GPU_TYPICAL_MAT_SIZES)); ////////////////////////////////////////////////////////////////////// -// Threshold +// HistEven_OneChannel -GPU_PERF_TEST(Threshold, cv::gpu::DeviceInfo, cv::Size, perf::MatType) +GPU_PERF_TEST(HistEven_OneChannel, cv::gpu::DeviceInfo, cv::Size, MatDepth) { 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_host(size, type); + cv::Size size = GET_PARAM(1); + int depth = GET_PARAM(2); - declare.in(src_host, WARMUP_RNG); + cv::Mat src_host(size, depth); + fill(src_host, 0, 255); cv::gpu::GpuMat src(src_host); - cv::gpu::GpuMat dst(size, type); + cv::gpu::GpuMat hist; + cv::gpu::GpuMat buf; + + cv::gpu::histEven(src, hist, buf, 30, 0, 180); TEST_CYCLE() { - cv::gpu::threshold(src, dst, 100.0, 255.0, cv::THRESH_BINARY); + cv::gpu::histEven(src, hist, buf, 30, 0, 180); } } -INSTANTIATE_TEST_CASE_P(ImgProc, Threshold, testing::Combine( - ALL_DEVICES, - GPU_TYPICAL_MAT_SIZES, - testing::Values(CV_8UC1, CV_16UC1, CV_32FC1))); +INSTANTIATE_TEST_CASE_P(ImgProc, HistEven_OneChannel, testing::Combine( + ALL_DEVICES, + GPU_TYPICAL_MAT_SIZES, + testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_16S)))); ////////////////////////////////////////////////////////////////////// -// Resize +// HistEven_FourChannel -GPU_PERF_TEST(Resize, cv::gpu::DeviceInfo, cv::Size, perf::MatType, Interpolation, double) +GPU_PERF_TEST(HistEven_FourChannel, cv::gpu::DeviceInfo, cv::Size, MatDepth) { cv::gpu::DeviceInfo devInfo = GET_PARAM(0); - cv::Size size = GET_PARAM(1); - int type = GET_PARAM(2); - int interpolation = GET_PARAM(3); - double f = GET_PARAM(4); - cv::gpu::setDevice(devInfo.deviceID()); - cv::Mat src_host(size, type); + cv::Size size = GET_PARAM(1); + int depth = GET_PARAM(2); - declare.in(src_host, WARMUP_RNG); + cv::Mat src_host(size, CV_MAKE_TYPE(depth, 4)); + fill(src_host, 0, 255); cv::gpu::GpuMat src(src_host); - cv::gpu::GpuMat dst; + cv::gpu::GpuMat hist[4]; + cv::gpu::GpuMat buf; + int histSize[] = {30, 30, 30, 30}; + int lowerLevel[] = {0, 0, 0, 0}; + int upperLevel[] = {180, 180, 180, 180}; - declare.time(1.0); + cv::gpu::histEven(src, hist, buf, histSize, lowerLevel, upperLevel); TEST_CYCLE() { - cv::gpu::resize(src, dst, cv::Size(), f, f, interpolation); + cv::gpu::histEven(src, hist, buf, histSize, lowerLevel, upperLevel); } } -INSTANTIATE_TEST_CASE_P(ImgProc, Resize, testing::Combine( - ALL_DEVICES, - testing::Values(perf::szSXGA, perf::sz1080p), - testing::Values(CV_8UC1, CV_8UC4, CV_16UC1, CV_32FC1), - testing::Values((int) cv::INTER_NEAREST, (int) cv::INTER_LINEAR, (int) cv::INTER_CUBIC), - testing::Values(0.5, 2.0))); +INSTANTIATE_TEST_CASE_P(ImgProc, HistEven_FourChannel, testing::Combine( + ALL_DEVICES, + GPU_TYPICAL_MAT_SIZES, + testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_16S)))); ////////////////////////////////////////////////////////////////////// -// WarpAffine +// CalcHist -GPU_PERF_TEST(WarpAffine, cv::gpu::DeviceInfo, cv::Size, perf::MatType, Interpolation) +GPU_PERF_TEST(CalcHist, cv::gpu::DeviceInfo, cv::Size) { cv::gpu::DeviceInfo devInfo = GET_PARAM(0); - cv::Size size = GET_PARAM(1); - int type = GET_PARAM(2); - int interpolation = GET_PARAM(3); - cv::gpu::setDevice(devInfo.deviceID()); - cv::Mat src_host(size, type); + cv::Size size = GET_PARAM(1); - declare.in(src_host, WARMUP_RNG); + cv::Mat src_host(size, CV_8UC1); + fill(src_host, 0, 255); cv::gpu::GpuMat src(src_host); - cv::gpu::GpuMat dst; + cv::gpu::GpuMat hist; + cv::gpu::GpuMat buf; - const double aplha = CV_PI / 4; - double mat[2][3] = { {std::cos(aplha), -std::sin(aplha), src.cols / 2}, - {std::sin(aplha), std::cos(aplha), 0}}; - cv::Mat M(2, 3, CV_64F, (void*) mat); + cv::gpu::calcHist(src, hist, buf); TEST_CYCLE() { - cv::gpu::warpAffine(src, dst, M, size, interpolation, cv::BORDER_CONSTANT, cv::Scalar()); + cv::gpu::calcHist(src, hist, buf); } } -INSTANTIATE_TEST_CASE_P(ImgProc, WarpAffine, testing::Combine( - 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), - testing::Values((int) cv::INTER_NEAREST, (int) cv::INTER_LINEAR, (int) cv::INTER_CUBIC))); +INSTANTIATE_TEST_CASE_P(ImgProc, CalcHist, testing::Combine( + ALL_DEVICES, + GPU_TYPICAL_MAT_SIZES)); ////////////////////////////////////////////////////////////////////// -// WarpPerspective +// EqualizeHist -GPU_PERF_TEST(WarpPerspective, cv::gpu::DeviceInfo, cv::Size, perf::MatType, Interpolation) +GPU_PERF_TEST(EqualizeHist, cv::gpu::DeviceInfo, cv::Size) { cv::gpu::DeviceInfo devInfo = GET_PARAM(0); - cv::Size size = GET_PARAM(1); - int type = GET_PARAM(2); - int interpolation = GET_PARAM(3); - cv::gpu::setDevice(devInfo.deviceID()); - cv::Mat src_host(size, type); + cv::Size size = GET_PARAM(1); - declare.in(src_host, WARMUP_RNG); + cv::Mat src_host(size, CV_8UC1); + fill(src_host, 0, 255); cv::gpu::GpuMat src(src_host); cv::gpu::GpuMat dst; + cv::gpu::GpuMat hist; + cv::gpu::GpuMat buf; - const double aplha = CV_PI / 4; - double mat[3][3] = { {std::cos(aplha), -std::sin(aplha), src.cols / 2}, - {std::sin(aplha), std::cos(aplha), 0}, - {0.0, 0.0, 1.0}}; - cv::Mat M(3, 3, CV_64F, (void*) mat); + cv::gpu::equalizeHist(src, dst, hist, buf); TEST_CYCLE() { - cv::gpu::warpPerspective(src, dst, M, size, interpolation, cv::BORDER_CONSTANT, cv::Scalar()); + cv::gpu::equalizeHist(src, dst, hist, buf); } } -INSTANTIATE_TEST_CASE_P(ImgProc, WarpPerspective, testing::Combine( - 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), - testing::Values((int) cv::INTER_NEAREST, (int) cv::INTER_LINEAR, (int) cv::INTER_CUBIC))); +INSTANTIATE_TEST_CASE_P(ImgProc, EqualizeHist, testing::Combine( + ALL_DEVICES, + GPU_TYPICAL_MAT_SIZES)); ////////////////////////////////////////////////////////////////////// -// BuildWarpPlaneMaps +// ColumnSum -GPU_PERF_TEST(BuildWarpPlaneMaps, cv::gpu::DeviceInfo, cv::Size) +GPU_PERF_TEST(ColumnSum, cv::gpu::DeviceInfo, cv::Size) { cv::gpu::DeviceInfo devInfo = GET_PARAM(0); + cv::gpu::setDevice(devInfo.deviceID()); + cv::Size size = GET_PARAM(1); - cv::gpu::setDevice(devInfo.deviceID()); + cv::Mat src_host(size, CV_32FC1); + fill(src_host, 0, 255); - cv::gpu::GpuMat map_x; - cv::gpu::GpuMat map_y; + cv::gpu::GpuMat src(src_host); + cv::gpu::GpuMat dst; + + cv::gpu::columnSum(src, dst); TEST_CYCLE() { - cv::gpu::buildWarpPlaneMaps(size, cv::Rect(0, 0, size.width, size.height), cv::Mat::eye(3, 3, CV_32FC1), - cv::Mat::ones(3, 3, CV_32FC1), cv::Mat::zeros(1, 3, CV_32F), 1.0, map_x, map_y); + cv::gpu::columnSum(src, dst); } } -INSTANTIATE_TEST_CASE_P(ImgProc, BuildWarpPlaneMaps, testing::Combine( - ALL_DEVICES, - GPU_TYPICAL_MAT_SIZES)); +INSTANTIATE_TEST_CASE_P(ImgProc, ColumnSum, testing::Combine( + ALL_DEVICES, + GPU_TYPICAL_MAT_SIZES)); ////////////////////////////////////////////////////////////////////// -// BuildWarpCylindricalMaps +// Canny -GPU_PERF_TEST(BuildWarpCylindricalMaps, cv::gpu::DeviceInfo, cv::Size) +IMPLEMENT_PARAM_CLASS(AppertureSize, int) +IMPLEMENT_PARAM_CLASS(L2gradient, bool) + +GPU_PERF_TEST(Canny, cv::gpu::DeviceInfo, AppertureSize, L2gradient) { cv::gpu::DeviceInfo devInfo = GET_PARAM(0); - cv::Size size = GET_PARAM(1); + cv::gpu::setDevice(devInfo.deviceID()); + + int apperture_size = GET_PARAM(1); + bool useL2gradient = GET_PARAM(2); + + cv::Mat image_host = readImage("perf/1280x1024.jpg", cv::IMREAD_GRAYSCALE); + ASSERT_FALSE(image_host.empty()); + + cv::gpu::GpuMat image(image_host); + cv::gpu::GpuMat dst; + cv::gpu::CannyBuf buf; + + cv::gpu::Canny(image, buf, dst, 50.0, 100.0, apperture_size, useL2gradient); + + TEST_CYCLE() + { + cv::gpu::Canny(image, buf, dst, 50.0, 100.0, apperture_size, useL2gradient); + } +} +INSTANTIATE_TEST_CASE_P(ImgProc, Canny, testing::Combine( + ALL_DEVICES, + testing::Values(AppertureSize(3), AppertureSize(5)), + testing::Values(L2gradient(false), L2gradient(true)))); + +////////////////////////////////////////////////////////////////////// +// MeanShiftFiltering + +GPU_PERF_TEST_1(MeanShiftFiltering, cv::gpu::DeviceInfo) +{ + cv::gpu::DeviceInfo devInfo = GetParam(); cv::gpu::setDevice(devInfo.deviceID()); - cv::gpu::GpuMat map_x; - cv::gpu::GpuMat map_y; + cv::Mat img = readImage("gpu/meanshift/cones.png"); + ASSERT_FALSE(img.empty()); + + cv::Mat rgba; + cv::cvtColor(img, rgba, cv::COLOR_BGR2BGRA); + + cv::gpu::GpuMat src(rgba); + cv::gpu::GpuMat dst; + + cv::gpu::meanShiftFiltering(src, dst, 50, 50); + + declare.time(5.0); TEST_CYCLE() { - cv::gpu::buildWarpCylindricalMaps(size, cv::Rect(0, 0, size.width, size.height), cv::Mat::eye(3, 3, CV_32FC1), - cv::Mat::ones(3, 3, CV_32FC1), 1.0, map_x, map_y); + cv::gpu::meanShiftFiltering(src, dst, 50, 50); } } -INSTANTIATE_TEST_CASE_P(ImgProc, BuildWarpCylindricalMaps, testing::Combine( - ALL_DEVICES, - GPU_TYPICAL_MAT_SIZES)); +INSTANTIATE_TEST_CASE_P(ImgProc, MeanShiftFiltering, ALL_DEVICES); ////////////////////////////////////////////////////////////////////// -// BuildWarpSphericalMaps +// MeanShiftProc -GPU_PERF_TEST(BuildWarpSphericalMaps, cv::gpu::DeviceInfo, cv::Size) +GPU_PERF_TEST_1(MeanShiftProc, cv::gpu::DeviceInfo) { - cv::gpu::DeviceInfo devInfo = GET_PARAM(0); - cv::Size size = GET_PARAM(1); + cv::gpu::DeviceInfo devInfo = GetParam(); + cv::gpu::setDevice(devInfo.deviceID()); + + cv::Mat img = readImage("gpu/meanshift/cones.png"); + ASSERT_FALSE(img.empty()); + + cv::Mat rgba; + cv::cvtColor(img, rgba, cv::COLOR_BGR2BGRA); + + cv::gpu::GpuMat src(rgba); + cv::gpu::GpuMat dstr; + cv::gpu::GpuMat dstsp; + + cv::gpu::meanShiftProc(src, dstr, dstsp, 50, 50); + declare.time(5.0); + + TEST_CYCLE() + { + cv::gpu::meanShiftProc(src, dstr, dstsp, 50, 50); + } +} + +INSTANTIATE_TEST_CASE_P(ImgProc, MeanShiftProc, ALL_DEVICES); + +////////////////////////////////////////////////////////////////////// +// MeanShiftSegmentation + +GPU_PERF_TEST_1(MeanShiftSegmentation, cv::gpu::DeviceInfo) +{ + cv::gpu::DeviceInfo devInfo = GetParam(); cv::gpu::setDevice(devInfo.deviceID()); - cv::gpu::GpuMat map_x; - cv::gpu::GpuMat map_y; + cv::Mat img = readImage("gpu/meanshift/cones.png"); + ASSERT_FALSE(img.empty()); + + cv::Mat rgba; + cv::cvtColor(img, rgba, cv::COLOR_BGR2BGRA); + + cv::gpu::GpuMat src(rgba); + cv::Mat dst; + + meanShiftSegmentation(src, dst, 10, 10, 20); + + declare.time(5.0); TEST_CYCLE() { - cv::gpu::buildWarpSphericalMaps(size, cv::Rect(0, 0, size.width, size.height), cv::Mat::eye(3, 3, CV_32FC1), - cv::Mat::ones(3, 3, CV_32FC1), 1.0, map_x, map_y); + meanShiftSegmentation(src, dst, 10, 10, 20); } } -INSTANTIATE_TEST_CASE_P(ImgProc, BuildWarpSphericalMaps, testing::Combine( - ALL_DEVICES, - GPU_TYPICAL_MAT_SIZES)); +INSTANTIATE_TEST_CASE_P(ImgProc, MeanShiftSegmentation, ALL_DEVICES); ////////////////////////////////////////////////////////////////////// -// Rotate +// BlendLinear -GPU_PERF_TEST(Rotate, cv::gpu::DeviceInfo, cv::Size, perf::MatType, Interpolation) +GPU_PERF_TEST(BlendLinear, cv::gpu::DeviceInfo, cv::Size, MatType) { cv::gpu::DeviceInfo devInfo = GET_PARAM(0); + cv::gpu::setDevice(devInfo.deviceID()); + cv::Size size = GET_PARAM(1); int type = GET_PARAM(2); - int interpolation = GET_PARAM(3); + cv::Mat img1_host(size, type); + fill(img1_host, 0, 255); + + cv::Mat img2_host(size, type); + fill(img2_host, 0, 255); + + cv::gpu::GpuMat img1(img1_host); + cv::gpu::GpuMat img2(img2_host); + cv::gpu::GpuMat weights1(size, CV_32FC1, cv::Scalar::all(0.5)); + cv::gpu::GpuMat weights2(size, CV_32FC1, cv::Scalar::all(0.5)); + cv::gpu::GpuMat dst; + + cv::gpu::blendLinear(img1, img2, weights1, weights2, dst); + + TEST_CYCLE() + { + cv::gpu::blendLinear(img1, img2, weights1, weights2, dst); + } +} + +INSTANTIATE_TEST_CASE_P(ImgProc, BlendLinear, testing::Combine( + ALL_DEVICES, + GPU_TYPICAL_MAT_SIZES, + testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), + MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)))); + +////////////////////////////////////////////////////////////////////// +// Convolve + +IMPLEMENT_PARAM_CLASS(KSize, int) +IMPLEMENT_PARAM_CLASS(Ccorr, bool) + +GPU_PERF_TEST(Convolve, cv::gpu::DeviceInfo, cv::Size, KSize, Ccorr) +{ + cv::gpu::DeviceInfo devInfo = GET_PARAM(0); cv::gpu::setDevice(devInfo.deviceID()); - cv::Mat src_host(size, type); + cv::Size size = GET_PARAM(1); + int templ_size = GET_PARAM(2); + bool ccorr = GET_PARAM(3); - declare.in(src_host, WARMUP_RNG); + cv::gpu::GpuMat image = cv::gpu::createContinuous(size, CV_32FC1); + image.setTo(cv::Scalar(1.0)); + + cv::gpu::GpuMat templ = cv::gpu::createContinuous(templ_size, templ_size, CV_32FC1); + templ.setTo(cv::Scalar(1.0)); - cv::gpu::GpuMat src(src_host); cv::gpu::GpuMat dst; + cv::gpu::ConvolveBuf buf; + + cv::gpu::convolve(image, templ, dst, ccorr, buf); + + declare.time(2.0); TEST_CYCLE() { - cv::gpu::rotate(src, dst, size, 30.0, 0, 0, interpolation); + cv::gpu::convolve(image, templ, dst, ccorr, buf); } } -INSTANTIATE_TEST_CASE_P(ImgProc, Rotate, testing::Combine( - 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), - testing::Values((int) cv::INTER_NEAREST, (int) cv::INTER_LINEAR, (int) cv::INTER_CUBIC))); +INSTANTIATE_TEST_CASE_P(ImgProc, Convolve, testing::Combine( + ALL_DEVICES, + GPU_TYPICAL_MAT_SIZES, + testing::Values(KSize(3), KSize(9), KSize(17), KSize(27), KSize(32), KSize(64)), + testing::Values(Ccorr(false), Ccorr(true)))); -////////////////////////////////////////////////////////////////////// -// CopyMakeBorder +//////////////////////////////////////////////////////////////////////////////// +// MatchTemplate_8U -GPU_PERF_TEST(CopyMakeBorder, cv::gpu::DeviceInfo, cv::Size, perf::MatType, BorderMode) +CV_ENUM(TemplateMethod, cv::TM_SQDIFF, cv::TM_SQDIFF_NORMED, cv::TM_CCORR, cv::TM_CCORR_NORMED, cv::TM_CCOEFF, cv::TM_CCOEFF_NORMED) +#define ALL_TEMPLATE_METHODS testing::Values(TemplateMethod(cv::TM_SQDIFF), TemplateMethod(cv::TM_SQDIFF_NORMED), TemplateMethod(cv::TM_CCORR), TemplateMethod(cv::TM_CCORR_NORMED), TemplateMethod(cv::TM_CCOEFF), TemplateMethod(cv::TM_CCOEFF_NORMED)) + +IMPLEMENT_PARAM_CLASS(TemplateSize, cv::Size) + +GPU_PERF_TEST(MatchTemplate_8U, cv::gpu::DeviceInfo, cv::Size, TemplateSize, Channels, TemplateMethod) { cv::gpu::DeviceInfo devInfo = GET_PARAM(0); + cv::gpu::setDevice(devInfo.deviceID()); + cv::Size size = GET_PARAM(1); - int type = GET_PARAM(2); - int borderType = GET_PARAM(3); + cv::Size templ_size = GET_PARAM(2); + int cn = GET_PARAM(3); + int method = GET_PARAM(4); + + cv::Mat image_host(size, CV_MAKE_TYPE(CV_8U, cn)); + fill(image_host, 0, 255); + + cv::Mat templ_host(templ_size, CV_MAKE_TYPE(CV_8U, cn)); + fill(templ_host, 0, 255); + + cv::gpu::GpuMat image(image_host); + cv::gpu::GpuMat templ(templ_host); + cv::gpu::GpuMat dst; + + cv::gpu::matchTemplate(image, templ, dst, method); + + TEST_CYCLE() + { + cv::gpu::matchTemplate(image, templ, dst, method); + } +}; + +INSTANTIATE_TEST_CASE_P(ImgProc, MatchTemplate_8U, testing::Combine( + ALL_DEVICES, + GPU_TYPICAL_MAT_SIZES, + testing::Values(TemplateSize(cv::Size(5, 5)), TemplateSize(cv::Size(16, 16)), TemplateSize(cv::Size(30, 30))), + testing::Values(Channels(1), Channels(3), Channels(4)), + ALL_TEMPLATE_METHODS)); + +//////////////////////////////////////////////////////////////////////////////// +// MatchTemplate_32F +GPU_PERF_TEST(MatchTemplate_32F, cv::gpu::DeviceInfo, cv::Size, TemplateSize, Channels, TemplateMethod) +{ + cv::gpu::DeviceInfo devInfo = GET_PARAM(0); cv::gpu::setDevice(devInfo.deviceID()); - cv::Mat src_host(size, type); + cv::Size size = GET_PARAM(1); + cv::Size templ_size = GET_PARAM(2); + int cn = GET_PARAM(3); + int method = GET_PARAM(4); - declare.in(src_host, WARMUP_RNG); + cv::Mat image_host(size, CV_MAKE_TYPE(CV_32F, cn)); + fill(image_host, 0, 255); - cv::gpu::GpuMat src(src_host); + cv::Mat templ_host(templ_size, CV_MAKE_TYPE(CV_32F, cn)); + fill(templ_host, 0, 255); + + cv::gpu::GpuMat image(image_host); + cv::gpu::GpuMat templ(templ_host); cv::gpu::GpuMat dst; + cv::gpu::matchTemplate(image, templ, dst, method); + TEST_CYCLE() { - cv::gpu::copyMakeBorder(src, dst, 5, 5, 5, 5, borderType); + cv::gpu::matchTemplate(image, templ, dst, method); } -} +}; -INSTANTIATE_TEST_CASE_P(ImgProc, CopyMakeBorder, testing::Combine( - ALL_DEVICES, - GPU_TYPICAL_MAT_SIZES, - testing::Values(CV_8UC1, CV_8UC4, CV_32FC1), - testing::Values((int) cv::BORDER_REPLICATE, (int) cv::BORDER_REFLECT, (int) cv::BORDER_WRAP, (int) cv::BORDER_CONSTANT))); +INSTANTIATE_TEST_CASE_P(ImgProc, MatchTemplate_32F, testing::Combine( + ALL_DEVICES, + GPU_TYPICAL_MAT_SIZES, + testing::Values(TemplateSize(cv::Size(5, 5)), TemplateSize(cv::Size(16, 16)), TemplateSize(cv::Size(30, 30))), + testing::Values(Channels(1), Channels(3), Channels(4)), + testing::Values(TemplateMethod(cv::TM_SQDIFF), TemplateMethod(cv::TM_CCORR)))); ////////////////////////////////////////////////////////////////////// -// Integral +// MulSpectrums -GPU_PERF_TEST(Integral, cv::gpu::DeviceInfo, cv::Size) +CV_FLAGS(DftFlags, 0, cv::DFT_INVERSE, cv::DFT_SCALE, cv::DFT_ROWS, cv::DFT_COMPLEX_OUTPUT, cv::DFT_REAL_OUTPUT) + +GPU_PERF_TEST(MulSpectrums, cv::gpu::DeviceInfo, cv::Size, DftFlags) { cv::gpu::DeviceInfo devInfo = GET_PARAM(0); - cv::Size size = GET_PARAM(1); - cv::gpu::setDevice(devInfo.deviceID()); - cv::Mat src_host(size, CV_8UC1); + cv::Size size = GET_PARAM(1); + int flag = GET_PARAM(2); + + cv::Mat a_host(size, CV_32FC2); + fill(a_host, 0, 100); - declare.in(src_host, WARMUP_RNG); + cv::Mat b_host(size, CV_32FC2); + fill(b_host, 0, 100); - cv::gpu::GpuMat src(src_host); + cv::gpu::GpuMat a(a_host); + cv::gpu::GpuMat b(b_host); cv::gpu::GpuMat dst; - cv::gpu::GpuMat buf; + + cv::gpu::mulSpectrums(a, b, dst, flag); TEST_CYCLE() { - cv::gpu::integralBuffered(src, dst, buf); + cv::gpu::mulSpectrums(a, b, dst, flag); } } -INSTANTIATE_TEST_CASE_P(ImgProc, Integral, testing::Combine( - ALL_DEVICES, - GPU_TYPICAL_MAT_SIZES)); +INSTANTIATE_TEST_CASE_P(ImgProc, MulSpectrums, testing::Combine( + ALL_DEVICES, + GPU_TYPICAL_MAT_SIZES, + testing::Values(DftFlags(0), DftFlags(cv::DFT_ROWS)))); ////////////////////////////////////////////////////////////////////// -// IntegralSqr +// MulAndScaleSpectrums -GPU_PERF_TEST(IntegralSqr, cv::gpu::DeviceInfo, cv::Size) +GPU_PERF_TEST(MulAndScaleSpectrums, cv::gpu::DeviceInfo, cv::Size) { cv::gpu::DeviceInfo devInfo = GET_PARAM(0); + cv::gpu::setDevice(devInfo.deviceID()); + cv::Size size = GET_PARAM(1); - cv::gpu::setDevice(devInfo.deviceID()); + float scale = 1.f / size.area(); - cv::Mat src_host(size, CV_8UC1); + cv::Mat src1_host(size, CV_32FC2); + fill(src1_host, 0, 100); - declare.in(src_host, WARMUP_RNG); + cv::Mat src2_host(size, CV_32FC2); + fill(src2_host, 0, 100); - cv::gpu::GpuMat src(src_host); + cv::gpu::GpuMat src1(src1_host); + cv::gpu::GpuMat src2(src2_host); cv::gpu::GpuMat dst; + cv::gpu::mulAndScaleSpectrums(src1, src2, dst, cv::DFT_ROWS, scale, false); + TEST_CYCLE() { - cv::gpu::sqrIntegral(src, dst); + cv::gpu::mulAndScaleSpectrums(src1, src2, dst, cv::DFT_ROWS, scale, false); } } -INSTANTIATE_TEST_CASE_P(ImgProc, IntegralSqr, testing::Combine( - ALL_DEVICES, - GPU_TYPICAL_MAT_SIZES)); +INSTANTIATE_TEST_CASE_P(ImgProc, MulAndScaleSpectrums, testing::Combine( + ALL_DEVICES, + GPU_TYPICAL_MAT_SIZES)); ////////////////////////////////////////////////////////////////////// -// ColumnSum +// Dft -GPU_PERF_TEST(ColumnSum, cv::gpu::DeviceInfo, cv::Size) +GPU_PERF_TEST(Dft, cv::gpu::DeviceInfo, cv::Size, DftFlags) { cv::gpu::DeviceInfo devInfo = GET_PARAM(0); - cv::Size size = GET_PARAM(1); - cv::gpu::setDevice(devInfo.deviceID()); - cv::Mat src_host(size, CV_32FC1); + cv::Size size = GET_PARAM(1); + int flag = GET_PARAM(2); - declare.in(src_host, WARMUP_RNG); + cv::Mat src_host(size, CV_32FC2); + fill(src_host, 0, 100); cv::gpu::GpuMat src(src_host); cv::gpu::GpuMat dst; + cv::gpu::dft(src, dst, size, flag); + + declare.time(2.0); + TEST_CYCLE() { - cv::gpu::columnSum(src, dst); + cv::gpu::dft(src, dst, size, flag); } } -INSTANTIATE_TEST_CASE_P(ImgProc, ColumnSum, testing::Combine( - ALL_DEVICES, - GPU_TYPICAL_MAT_SIZES)); +INSTANTIATE_TEST_CASE_P(ImgProc, Dft, testing::Combine( + ALL_DEVICES, + GPU_TYPICAL_MAT_SIZES, + testing::Values(DftFlags(0), DftFlags(cv::DFT_ROWS), DftFlags(cv::DFT_INVERSE)))); ////////////////////////////////////////////////////////////////////// // CornerHarris -GPU_PERF_TEST(CornerHarris, cv::gpu::DeviceInfo, perf::MatType) +IMPLEMENT_PARAM_CLASS(BlockSize, int) +IMPLEMENT_PARAM_CLASS(ApertureSize, int) + +GPU_PERF_TEST(CornerHarris, cv::gpu::DeviceInfo, MatType, BorderMode, BlockSize, ApertureSize) { cv::gpu::DeviceInfo devInfo = GET_PARAM(0); - int type = GET_PARAM(1); - cv::gpu::setDevice(devInfo.deviceID()); + int type = GET_PARAM(1); + int borderType = GET_PARAM(2); + int blockSize = GET_PARAM(3); + int apertureSize = GET_PARAM(4); + cv::Mat img = readImage("gpu/stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE); ASSERT_FALSE(img.empty()); @@ -616,31 +858,38 @@ GPU_PERF_TEST(CornerHarris, cv::gpu::DeviceInfo, perf::MatType) cv::gpu::GpuMat dst; cv::gpu::GpuMat Dx; cv::gpu::GpuMat Dy; + cv::gpu::GpuMat buf; - int blockSize = 3; - int ksize = 7; double k = 0.5; + cv::gpu::cornerHarris(src, dst, Dx, Dy, buf, blockSize, apertureSize, k, borderType); + TEST_CYCLE() { - cv::gpu::cornerHarris(src, dst, Dx, Dy, blockSize, ksize, k); + cv::gpu::cornerHarris(src, dst, Dx, Dy, buf, blockSize, apertureSize, k, borderType); } } INSTANTIATE_TEST_CASE_P(ImgProc, CornerHarris, testing::Combine( - ALL_DEVICES, - testing::Values(CV_8UC1, CV_32FC1))); + ALL_DEVICES, + testing::Values(MatType(CV_8UC1), MatType(CV_32FC1)), + testing::Values(BorderMode(cv::BORDER_REFLECT101), BorderMode(cv::BORDER_REPLICATE), BorderMode(cv::BORDER_REFLECT)), + testing::Values(BlockSize(3), BlockSize(5), BlockSize(7)), + testing::Values(ApertureSize(0), ApertureSize(3), ApertureSize(5), ApertureSize(7)))); ////////////////////////////////////////////////////////////////////// // CornerMinEigenVal -GPU_PERF_TEST(CornerMinEigenVal, cv::gpu::DeviceInfo, perf::MatType) +GPU_PERF_TEST(CornerMinEigenVal, cv::gpu::DeviceInfo, MatType, BorderMode, BlockSize, ApertureSize) { cv::gpu::DeviceInfo devInfo = GET_PARAM(0); - int type = GET_PARAM(1); - cv::gpu::setDevice(devInfo.deviceID()); + int type = GET_PARAM(1); + int borderType = GET_PARAM(2); + int blockSize = GET_PARAM(3); + int apertureSize = GET_PARAM(4); + cv::Mat img = readImage("gpu/stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE); ASSERT_FALSE(img.empty()); @@ -650,337 +899,344 @@ GPU_PERF_TEST(CornerMinEigenVal, cv::gpu::DeviceInfo, perf::MatType) cv::gpu::GpuMat dst; cv::gpu::GpuMat Dx; cv::gpu::GpuMat Dy; + cv::gpu::GpuMat buf; - int blockSize = 3; - int ksize = 7; + cv::gpu::cornerMinEigenVal(src, dst, Dx, Dy, buf, blockSize, apertureSize, borderType); TEST_CYCLE() { - cv::gpu::cornerMinEigenVal(src, dst, Dx, Dy, blockSize, ksize); + cv::gpu::cornerMinEigenVal(src, dst, Dx, Dy, buf, blockSize, apertureSize, borderType); } } INSTANTIATE_TEST_CASE_P(ImgProc, CornerMinEigenVal, testing::Combine( - ALL_DEVICES, - testing::Values(CV_8UC1, CV_32FC1))); + ALL_DEVICES, + testing::Values(MatType(CV_8UC1), MatType(CV_32FC1)), + testing::Values(BorderMode(cv::BORDER_REFLECT101), BorderMode(cv::BORDER_REPLICATE), BorderMode(cv::BORDER_REFLECT)), + testing::Values(BlockSize(3), BlockSize(5), BlockSize(7)), + testing::Values(ApertureSize(0), ApertureSize(3), ApertureSize(5), ApertureSize(7)))); ////////////////////////////////////////////////////////////////////// -// MulSpectrums +// BuildWarpPlaneMaps -GPU_PERF_TEST(MulSpectrums, cv::gpu::DeviceInfo, cv::Size) +GPU_PERF_TEST(BuildWarpPlaneMaps, cv::gpu::DeviceInfo, cv::Size) { cv::gpu::DeviceInfo devInfo = GET_PARAM(0); - cv::Size size = GET_PARAM(1); - cv::gpu::setDevice(devInfo.deviceID()); - cv::Mat a_host(size, CV_32FC2); - cv::Mat b_host(size, CV_32FC2); + cv::Size size = GET_PARAM(1); - declare.in(a_host, b_host, WARMUP_RNG); + cv::Mat K = cv::Mat::eye(3, 3, CV_32FC1); + cv::Mat R = cv::Mat::ones(3, 3, CV_32FC1); + cv::Mat T = cv::Mat::zeros(1, 3, CV_32F); + cv::gpu::GpuMat map_x; + cv::gpu::GpuMat map_y; - cv::gpu::GpuMat a(a_host); - cv::gpu::GpuMat b(b_host); - cv::gpu::GpuMat dst; + cv::gpu::buildWarpPlaneMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, T, 1.0, map_x, map_y); TEST_CYCLE() { - cv::gpu::mulSpectrums(a, b, dst, 0); + cv::gpu::buildWarpPlaneMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, T, 1.0, map_x, map_y); } } -INSTANTIATE_TEST_CASE_P(ImgProc, MulSpectrums, testing::Combine( - ALL_DEVICES, - GPU_TYPICAL_MAT_SIZES)); +INSTANTIATE_TEST_CASE_P(ImgProc, BuildWarpPlaneMaps, testing::Combine( + ALL_DEVICES, + GPU_TYPICAL_MAT_SIZES)); ////////////////////////////////////////////////////////////////////// -// Dft +// BuildWarpCylindricalMaps -GPU_PERF_TEST(Dft, cv::gpu::DeviceInfo, cv::Size) +GPU_PERF_TEST(BuildWarpCylindricalMaps, cv::gpu::DeviceInfo, cv::Size) { cv::gpu::DeviceInfo devInfo = GET_PARAM(0); - cv::Size size = GET_PARAM(1); - cv::gpu::setDevice(devInfo.deviceID()); - cv::Mat src_host(size, CV_32FC2); - - declare.in(src_host, WARMUP_RNG); + cv::Size size = GET_PARAM(1); - cv::gpu::GpuMat src(src_host); - cv::gpu::GpuMat dst; + cv::Mat K = cv::Mat::eye(3, 3, CV_32FC1); + cv::Mat R = cv::Mat::ones(3, 3, CV_32FC1); + cv::gpu::GpuMat map_x; + cv::gpu::GpuMat map_y; - declare.time(2.0); + cv::gpu::buildWarpCylindricalMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, 1.0, map_x, map_y); TEST_CYCLE() { - cv::gpu::dft(src, dst, size); + cv::gpu::buildWarpCylindricalMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, 1.0, map_x, map_y); } } -INSTANTIATE_TEST_CASE_P(ImgProc, Dft, testing::Combine( - ALL_DEVICES, - GPU_TYPICAL_MAT_SIZES)); +INSTANTIATE_TEST_CASE_P(ImgProc, BuildWarpCylindricalMaps, testing::Combine( + ALL_DEVICES, + GPU_TYPICAL_MAT_SIZES)); ////////////////////////////////////////////////////////////////////// -// Convolve +// BuildWarpSphericalMaps -GPU_PERF_TEST(Convolve, cv::gpu::DeviceInfo, cv::Size, int, bool) +GPU_PERF_TEST(BuildWarpSphericalMaps, cv::gpu::DeviceInfo, cv::Size) { cv::gpu::DeviceInfo devInfo = GET_PARAM(0); - cv::Size size = GET_PARAM(1); - int templ_size = GET_PARAM(2); - bool ccorr = GET_PARAM(3); - cv::gpu::setDevice(devInfo.deviceID()); - cv::gpu::GpuMat image = cv::gpu::createContinuous(size, CV_32FC1); - cv::gpu::GpuMat templ = cv::gpu::createContinuous(templ_size, templ_size, CV_32FC1); - - image.setTo(cv::Scalar(1.0)); - templ.setTo(cv::Scalar(1.0)); + cv::Size size = GET_PARAM(1); - cv::gpu::GpuMat dst; - cv::gpu::ConvolveBuf buf; + cv::Mat K = cv::Mat::eye(3, 3, CV_32FC1); + cv::Mat R = cv::Mat::ones(3, 3, CV_32FC1); + cv::gpu::GpuMat map_x; + cv::gpu::GpuMat map_y; - declare.time(2.0); + cv::gpu::buildWarpSphericalMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, 1.0, map_x, map_y); TEST_CYCLE() { - cv::gpu::convolve(image, templ, dst, ccorr, buf); + cv::gpu::buildWarpSphericalMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, 1.0, map_x, map_y); } } -INSTANTIATE_TEST_CASE_P(ImgProc, Convolve, testing::Combine( - ALL_DEVICES, - GPU_TYPICAL_MAT_SIZES, - testing::Values(3, 9, 27, 32, 64), - testing::Bool())); +INSTANTIATE_TEST_CASE_P(ImgProc, BuildWarpSphericalMaps, testing::Combine( + ALL_DEVICES, + GPU_TYPICAL_MAT_SIZES)); ////////////////////////////////////////////////////////////////////// -// PyrDown +// Rotate -GPU_PERF_TEST(PyrDown, cv::gpu::DeviceInfo, cv::Size, perf::MatType) +GPU_PERF_TEST(Rotate, cv::gpu::DeviceInfo, cv::Size, MatType, Interpolation) { cv::gpu::DeviceInfo devInfo = GET_PARAM(0); + cv::gpu::setDevice(devInfo.deviceID()); + cv::Size size = GET_PARAM(1); int type = GET_PARAM(2); - - cv::gpu::setDevice(devInfo.deviceID()); + int interpolation = GET_PARAM(3); cv::Mat src_host(size, type); - - declare.in(src_host, WARMUP_RNG); + fill(src_host, 0, 255); cv::gpu::GpuMat src(src_host); cv::gpu::GpuMat dst; + cv::gpu::rotate(src, dst, size, 30.0, 0, 0, interpolation); + TEST_CYCLE() { - cv::gpu::pyrDown(src, dst); + cv::gpu::rotate(src, dst, size, 30.0, 0, 0, interpolation); } } -INSTANTIATE_TEST_CASE_P(ImgProc, PyrDown, testing::Combine( - ALL_DEVICES, - GPU_TYPICAL_MAT_SIZES, - testing::Values(CV_8UC1, CV_8UC4, CV_16SC3, CV_32FC1))); +INSTANTIATE_TEST_CASE_P(ImgProc, Rotate, testing::Combine( + ALL_DEVICES, + GPU_TYPICAL_MAT_SIZES, + testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), + MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4), + MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)), + testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)))); ////////////////////////////////////////////////////////////////////// -// PyrUp +// PyrDown -GPU_PERF_TEST(PyrUp, cv::gpu::DeviceInfo, cv::Size, perf::MatType) +GPU_PERF_TEST(PyrDown, cv::gpu::DeviceInfo, cv::Size, MatType) { cv::gpu::DeviceInfo devInfo = GET_PARAM(0); + cv::gpu::setDevice(devInfo.deviceID()); + cv::Size size = GET_PARAM(1); int type = GET_PARAM(2); - cv::gpu::setDevice(devInfo.deviceID()); - cv::Mat src_host(size, type); - - declare.in(src_host, WARMUP_RNG); + fill(src_host, 0, 255); cv::gpu::GpuMat src(src_host); cv::gpu::GpuMat dst; + cv::gpu::pyrDown(src, dst); + TEST_CYCLE() { - cv::gpu::pyrUp(src, dst); + cv::gpu::pyrDown(src, dst); } } -INSTANTIATE_TEST_CASE_P(ImgProc, PyrUp, testing::Combine( - ALL_DEVICES, - GPU_TYPICAL_MAT_SIZES, - testing::Values(CV_8UC1, CV_8UC4, CV_16SC3, CV_32FC1))); +INSTANTIATE_TEST_CASE_P(ImgProc, PyrDown, testing::Combine( + ALL_DEVICES, + GPU_TYPICAL_MAT_SIZES, + testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), + MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4), + MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)))); ////////////////////////////////////////////////////////////////////// -// BlendLinear +// PyrUp -GPU_PERF_TEST(BlendLinear, cv::gpu::DeviceInfo, cv::Size, perf::MatType) +GPU_PERF_TEST(PyrUp, cv::gpu::DeviceInfo, cv::Size, 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 img1_host(size, type); - cv::Mat img2_host(size, type); + cv::Size size = GET_PARAM(1); + int type = GET_PARAM(2); - declare.in(img1_host, img2_host, WARMUP_RNG); + cv::Mat src_host(size, type); + fill(src_host, 0, 255); - cv::gpu::GpuMat img1(img1_host); - cv::gpu::GpuMat img2(img2_host); - cv::gpu::GpuMat weights1(size, CV_32FC1, cv::Scalar::all(0.5)); - cv::gpu::GpuMat weights2(size, CV_32FC1, cv::Scalar::all(0.5)); + cv::gpu::GpuMat src(src_host); cv::gpu::GpuMat dst; + cv::gpu::pyrUp(src, dst); + TEST_CYCLE() { - cv::gpu::blendLinear(img1, img2, weights1, weights2, dst); + cv::gpu::pyrUp(src, dst); } } -INSTANTIATE_TEST_CASE_P(ImgProc, BlendLinear, testing::Combine( - ALL_DEVICES, - GPU_TYPICAL_MAT_SIZES, - testing::Values(CV_8UC1, CV_32FC1))); +INSTANTIATE_TEST_CASE_P(ImgProc, PyrUp, testing::Combine( + ALL_DEVICES, + GPU_TYPICAL_MAT_SIZES, + testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), + MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4), + MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)))); ////////////////////////////////////////////////////////////////////// -// AlphaComp +// CvtColor -GPU_PERF_TEST(AlphaComp, cv::gpu::DeviceInfo, cv::Size, perf::MatType, AlphaOp) +GPU_PERF_TEST(CvtColor, cv::gpu::DeviceInfo, cv::Size, MatDepth, CvtColorInfo) { cv::gpu::DeviceInfo devInfo = GET_PARAM(0); - cv::Size size = GET_PARAM(1); - int type = GET_PARAM(2); - int alpha_op = GET_PARAM(3); - cv::gpu::setDevice(devInfo.deviceID()); - cv::Mat img1_host(size, type); - cv::Mat img2_host(size, type); + cv::Size size = GET_PARAM(1); + int depth = GET_PARAM(2); + CvtColorInfo info = GET_PARAM(3); - declare.in(img1_host, img2_host, WARMUP_RNG); + cv::Mat src_host(size, CV_MAKETYPE(depth, info.scn)); + fill(src_host, 0, 255); - cv::gpu::GpuMat img1(img1_host); - cv::gpu::GpuMat img2(img2_host); + cv::gpu::GpuMat src(src_host); cv::gpu::GpuMat dst; - TEST_CYCLE() - { - cv::gpu::alphaComp(img1, img2, dst, alpha_op); - } -} - -INSTANTIATE_TEST_CASE_P(ImgProc, AlphaComp, testing::Combine( - ALL_DEVICES, - GPU_TYPICAL_MAT_SIZES, - testing::Values(CV_8UC4, CV_16UC4, CV_32SC4, CV_32FC4), - testing::Values((int)cv::gpu::ALPHA_OVER, (int)cv::gpu::ALPHA_IN, (int)cv::gpu::ALPHA_OUT, (int)cv::gpu::ALPHA_ATOP, (int)cv::gpu::ALPHA_XOR, (int)cv::gpu::ALPHA_PLUS, (int)cv::gpu::ALPHA_OVER_PREMUL, (int)cv::gpu::ALPHA_IN_PREMUL, (int)cv::gpu::ALPHA_OUT_PREMUL, (int)cv::gpu::ALPHA_ATOP_PREMUL, (int)cv::gpu::ALPHA_XOR_PREMUL, (int)cv::gpu::ALPHA_PLUS_PREMUL, (int)cv::gpu::ALPHA_PREMUL))); - -////////////////////////////////////////////////////////////////////// -// Canny - -GPU_PERF_TEST_1(Canny, cv::gpu::DeviceInfo) -{ - cv::gpu::DeviceInfo devInfo = GetParam(); - - cv::gpu::setDevice(devInfo.deviceID()); - - cv::Mat image_host = readImage("perf/1280x1024.jpg", cv::IMREAD_GRAYSCALE); - ASSERT_FALSE(image_host.empty()); - - cv::gpu::GpuMat image(image_host); - cv::gpu::GpuMat dst; - cv::gpu::CannyBuf buf; + cv::gpu::cvtColor(src, dst, info.code, info.dcn); TEST_CYCLE() { - cv::gpu::Canny(image, buf, dst, 50.0, 100.0); + cv::gpu::cvtColor(src, dst, info.code, info.dcn); } } -INSTANTIATE_TEST_CASE_P(ImgProc, Canny, ALL_DEVICES); +INSTANTIATE_TEST_CASE_P(ImgProc, CvtColor, testing::Combine( + ALL_DEVICES, + GPU_TYPICAL_MAT_SIZES, + testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_32F)), + testing::Values(CvtColorInfo(4, 4, cv::COLOR_RGBA2BGRA), + CvtColorInfo(4, 1, cv::COLOR_BGRA2GRAY), + CvtColorInfo(1, 4, cv::COLOR_GRAY2BGRA), + CvtColorInfo(3, 3, cv::COLOR_BGR2XYZ), + CvtColorInfo(3, 3, cv::COLOR_XYZ2BGR), + CvtColorInfo(3, 3, cv::COLOR_BGR2YCrCb), + CvtColorInfo(3, 3, cv::COLOR_YCrCb2BGR), + CvtColorInfo(3, 3, cv::COLOR_BGR2YUV), + CvtColorInfo(3, 3, cv::COLOR_YUV2BGR), + CvtColorInfo(3, 3, cv::COLOR_BGR2HSV), + CvtColorInfo(3, 3, cv::COLOR_HSV2BGR), + CvtColorInfo(3, 3, cv::COLOR_BGR2HLS), + CvtColorInfo(3, 3, cv::COLOR_HLS2BGR)))); ////////////////////////////////////////////////////////////////////// -// CalcHist +// SwapChannels -GPU_PERF_TEST(CalcHist, cv::gpu::DeviceInfo, cv::Size) +GPU_PERF_TEST(SwapChannels, cv::gpu::DeviceInfo, cv::Size) { cv::gpu::DeviceInfo devInfo = GET_PARAM(0); - cv::Size size = GET_PARAM(1); - cv::gpu::setDevice(devInfo.deviceID()); - cv::Mat src_host(size, CV_8UC1); + cv::Size size = GET_PARAM(1); - declare.in(src_host, WARMUP_RNG); + cv::Mat src_host(size, CV_8UC4); + fill(src_host, 0, 255); cv::gpu::GpuMat src(src_host); - cv::gpu::GpuMat hist; - cv::gpu::GpuMat buf; + + const int dstOrder[] = {2, 1, 0, 3}; + + cv::gpu::swapChannels(src, dstOrder); TEST_CYCLE() { - cv::gpu::calcHist(src, hist, buf); + cv::gpu::swapChannels(src, dstOrder); } } -INSTANTIATE_TEST_CASE_P(ImgProc, CalcHist, testing::Combine( - ALL_DEVICES, - GPU_TYPICAL_MAT_SIZES)); +INSTANTIATE_TEST_CASE_P(ImgProc, SwapChannels, testing::Combine(ALL_DEVICES, GPU_TYPICAL_MAT_SIZES)); ////////////////////////////////////////////////////////////////////// -// EqualizeHist +// AlphaComp -GPU_PERF_TEST(EqualizeHist, cv::gpu::DeviceInfo, cv::Size) +CV_ENUM(AlphaOp, cv::gpu::ALPHA_OVER, cv::gpu::ALPHA_IN, cv::gpu::ALPHA_OUT, cv::gpu::ALPHA_ATOP, cv::gpu::ALPHA_XOR, cv::gpu::ALPHA_PLUS, cv::gpu::ALPHA_OVER_PREMUL, cv::gpu::ALPHA_IN_PREMUL, cv::gpu::ALPHA_OUT_PREMUL, cv::gpu::ALPHA_ATOP_PREMUL, cv::gpu::ALPHA_XOR_PREMUL, cv::gpu::ALPHA_PLUS_PREMUL, cv::gpu::ALPHA_PREMUL) + +GPU_PERF_TEST(AlphaComp, cv::gpu::DeviceInfo, cv::Size, MatType, AlphaOp) { cv::gpu::DeviceInfo devInfo = GET_PARAM(0); - cv::Size size = GET_PARAM(1); - cv::gpu::setDevice(devInfo.deviceID()); - cv::Mat src_host(size, CV_8UC1); + cv::Size size = GET_PARAM(1); + int type = GET_PARAM(2); + int alpha_op = GET_PARAM(3); - declare.in(src_host, WARMUP_RNG); + cv::Mat img1_host(size, type); + fill(img1_host, 0, 255); - cv::gpu::GpuMat src(src_host); + cv::Mat img2_host(size, type); + fill(img2_host, 0, 255); + + cv::gpu::GpuMat img1(img1_host); + cv::gpu::GpuMat img2(img2_host); cv::gpu::GpuMat dst; - cv::gpu::GpuMat hist; - cv::gpu::GpuMat buf; + + cv::gpu::alphaComp(img1, img2, dst, alpha_op); TEST_CYCLE() { - cv::gpu::equalizeHist(src, dst, hist, buf); + cv::gpu::alphaComp(img1, img2, dst, alpha_op); } } -INSTANTIATE_TEST_CASE_P(ImgProc, EqualizeHist, testing::Combine( - ALL_DEVICES, - GPU_TYPICAL_MAT_SIZES)); +INSTANTIATE_TEST_CASE_P(ImgProc, AlphaComp, testing::Combine( + ALL_DEVICES, + GPU_TYPICAL_MAT_SIZES, + testing::Values(MatType(CV_8UC4), MatType(CV_16UC4), MatType(CV_32SC4), MatType(CV_32FC4)), + testing::Values(AlphaOp(cv::gpu::ALPHA_OVER), + AlphaOp(cv::gpu::ALPHA_IN), + AlphaOp(cv::gpu::ALPHA_OUT), + AlphaOp(cv::gpu::ALPHA_ATOP), + AlphaOp(cv::gpu::ALPHA_XOR), + AlphaOp(cv::gpu::ALPHA_PLUS), + AlphaOp(cv::gpu::ALPHA_OVER_PREMUL), + AlphaOp(cv::gpu::ALPHA_IN_PREMUL), + AlphaOp(cv::gpu::ALPHA_OUT_PREMUL), + AlphaOp(cv::gpu::ALPHA_ATOP_PREMUL), + AlphaOp(cv::gpu::ALPHA_XOR_PREMUL), + AlphaOp(cv::gpu::ALPHA_PLUS_PREMUL), + AlphaOp(cv::gpu::ALPHA_PREMUL)))); ////////////////////////////////////////////////////////////////////// // ImagePyramid -GPU_PERF_TEST(ImagePyramid_build, cv::gpu::DeviceInfo, cv::Size, perf::MatType) +GPU_PERF_TEST(ImagePyramid_build, cv::gpu::DeviceInfo, cv::Size, MatType) { cv::gpu::DeviceInfo devInfo = GET_PARAM(0); + cv::gpu::setDevice(devInfo.deviceID()); + cv::Size size = GET_PARAM(1); int type = GET_PARAM(2); - cv::gpu::setDevice(devInfo.deviceID()); - cv::Mat src_host(size, type); - - declare.in(src_host, WARMUP_RNG); + fill(src_host, 0, 255); cv::gpu::GpuMat src(src_host); cv::gpu::ImagePyramid pyr; + pyr.build(src, 5); + TEST_CYCLE() { pyr.build(src, 5); @@ -988,27 +1244,30 @@ GPU_PERF_TEST(ImagePyramid_build, cv::gpu::DeviceInfo, cv::Size, perf::MatType) } INSTANTIATE_TEST_CASE_P(ImgProc, ImagePyramid_build, testing::Combine( - 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))); + ALL_DEVICES, + GPU_TYPICAL_MAT_SIZES, + testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), + MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4), + MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)))); -GPU_PERF_TEST(ImagePyramid_getLayer, cv::gpu::DeviceInfo, cv::Size, perf::MatType) +GPU_PERF_TEST(ImagePyramid_getLayer, cv::gpu::DeviceInfo, cv::Size, MatType) { cv::gpu::DeviceInfo devInfo = GET_PARAM(0); + cv::gpu::setDevice(devInfo.deviceID()); + cv::Size size = GET_PARAM(1); int type = GET_PARAM(2); - cv::gpu::setDevice(devInfo.deviceID()); - cv::Mat src_host(size, type); - - declare.in(src_host, WARMUP_RNG); + fill(src_host, 0, 255); cv::gpu::GpuMat src(src_host); cv::gpu::GpuMat dst; cv::gpu::ImagePyramid pyr(src, 3); + pyr.getLayer(dst, cv::Size(size.width / 2 + 10, size.height / 2 + 10)); + TEST_CYCLE() { pyr.getLayer(dst, cv::Size(size.width / 2 + 10, size.height / 2 + 10)); @@ -1016,8 +1275,10 @@ GPU_PERF_TEST(ImagePyramid_getLayer, cv::gpu::DeviceInfo, cv::Size, perf::MatTyp } INSTANTIATE_TEST_CASE_P(ImgProc, ImagePyramid_getLayer, testing::Combine( - 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))); + ALL_DEVICES, + GPU_TYPICAL_MAT_SIZES, + testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), + MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4), + MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)))); #endif diff --git a/modules/gpu/perf/perf_utility.hpp b/modules/gpu/perf/perf_utility.hpp index f15610b..41be787 100644 --- a/modules/gpu/perf/perf_utility.hpp +++ b/modules/gpu/perf/perf_utility.hpp @@ -3,15 +3,16 @@ void fill(cv::Mat& m, double a, double b); +using perf::MatType; +using perf::MatDepth; + enum {HORIZONTAL_AXIS = 0, VERTICAL_AXIS = 1, BOTH_AXIS = -1}; CV_ENUM(MorphOp, cv::MORPH_ERODE, cv::MORPH_DILATE) CV_ENUM(BorderMode, cv::BORDER_REFLECT101, cv::BORDER_REPLICATE, cv::BORDER_CONSTANT, cv::BORDER_REFLECT, cv::BORDER_WRAP) CV_ENUM(FlipCode, HORIZONTAL_AXIS, VERTICAL_AXIS, BOTH_AXIS) -CV_ENUM(Interpolation, cv::INTER_NEAREST, cv::INTER_LINEAR, cv::INTER_CUBIC) -CV_ENUM(MatchMethod, cv::TM_SQDIFF, cv::TM_SQDIFF_NORMED, cv::TM_CCORR, cv::TM_CCORR_NORMED, cv::TM_CCOEFF, cv::TM_CCOEFF_NORMED) -CV_ENUM(NormType, cv::NORM_INF, cv::NORM_L1, cv::NORM_L2) -CV_ENUM(AlphaOp, cv::gpu::ALPHA_OVER, cv::gpu::ALPHA_IN, cv::gpu::ALPHA_OUT, cv::gpu::ALPHA_ATOP, cv::gpu::ALPHA_XOR, cv::gpu::ALPHA_PLUS, cv::gpu::ALPHA_OVER_PREMUL, cv::gpu::ALPHA_IN_PREMUL, cv::gpu::ALPHA_OUT_PREMUL, cv::gpu::ALPHA_ATOP_PREMUL, cv::gpu::ALPHA_XOR_PREMUL, cv::gpu::ALPHA_PLUS_PREMUL, cv::gpu::ALPHA_PREMUL) +CV_ENUM(Interpolation, cv::INTER_NEAREST, cv::INTER_LINEAR, cv::INTER_CUBIC, cv::INTER_AREA) +CV_ENUM(NormType, cv::NORM_INF, cv::NORM_L1, cv::NORM_L2, cv::NORM_HAMMING) struct CvtColorInfo { @@ -24,6 +25,22 @@ struct CvtColorInfo void PrintTo(const CvtColorInfo& info, std::ostream* os); +#define IMPLEMENT_PARAM_CLASS(name, type) \ + class name \ + { \ + public: \ + name ( type arg = type ()) : val_(arg) {} \ + operator type () const {return val_;} \ + private: \ + type val_; \ + }; \ + inline void PrintTo( name param, std::ostream* os) \ + { \ + *os << #name << " = " << testing::PrintToString(static_cast< type >(param)); \ + } + +IMPLEMENT_PARAM_CLASS(Channels, int) + namespace cv { namespace gpu { void PrintTo(const cv::gpu::DeviceInfo& info, std::ostream* os); @@ -55,8 +72,6 @@ namespace cv { namespace gpu cv::Mat readImage(const std::string& fileName, int flags = cv::IMREAD_COLOR); -bool supportFeature(const cv::gpu::DeviceInfo& info, cv::gpu::FeatureSet feature); - const std::vector& devices(); std::vector devices(cv::gpu::FeatureSet feature); diff --git a/modules/gpu/src/cuda/resize.cu b/modules/gpu/src/cuda/resize.cu index 732b0f7..a51c043 100644 --- a/modules/gpu/src/cuda/resize.cu +++ b/modules/gpu/src/cuda/resize.cu @@ -46,6 +46,7 @@ #include "opencv2/gpu/device/vec_math.hpp" #include "opencv2/gpu/device/saturate_cast.hpp" #include "opencv2/gpu/device/filters.hpp" +# include namespace cv { namespace gpu { namespace device { @@ -65,6 +66,17 @@ namespace cv { namespace gpu { namespace device } } + template __global__ void resize_area(const Ptr2D src, float fx, float fy, DevMem2D_ dst) + { + const int x = blockDim.x * blockIdx.x + threadIdx.x; + const int y = blockDim.y * blockIdx.y + threadIdx.y; + + if (x < dst.cols && y < dst.rows) + { + dst(y, x) = saturate_cast(src(y, x)); + } + } + template