+++ /dev/null
-#include "perf_precomp.hpp"\r
-\r
-#ifdef HAVE_CUDA\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// Transpose\r
-\r
-GPU_PERF_TEST(Transpose, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::gpu::setDevice(devInfo.deviceID());\r
-\r
- cv::Mat src_host(size, type);\r
-\r
- declare.in(src_host, WARMUP_RNG);\r
-\r
- cv::gpu::GpuMat src(src_host);\r
- cv::gpu::GpuMat dst;\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::gpu::transpose(src, dst);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, Transpose, testing::Combine(\r
- ALL_DEVICES, \r
- GPU_TYPICAL_MAT_SIZES, \r
- testing::Values(CV_8UC1, CV_32SC1, CV_64FC1)));\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// Flip\r
-\r
-GPU_PERF_TEST(Flip, cv::gpu::DeviceInfo, cv::Size, perf::MatType, FlipCode)\r
-{\r
- cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
- int flipCode = GET_PARAM(3);\r
-\r
- cv::gpu::setDevice(devInfo.deviceID());\r
-\r
- cv::Mat src_host(size, type);\r
-\r
- declare.in(src_host, WARMUP_RNG);\r
-\r
- cv::gpu::GpuMat src(src_host);\r
- cv::gpu::GpuMat dst;\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::gpu::flip(src, dst, flipCode);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, Flip, testing::Combine(\r
- ALL_DEVICES, \r
- GPU_TYPICAL_MAT_SIZES, \r
- testing::Values(CV_8UC1, CV_8UC4, CV_32FC1, CV_32FC4),\r
- testing::Values((int) HORIZONTAL_AXIS, (int) VERTICAL_AXIS, (int) BOTH_AXIS)));\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// LUT\r
-\r
-GPU_PERF_TEST(LUT, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::gpu::setDevice(devInfo.deviceID());\r
-\r
- cv::Mat src_host(size, type);\r
- cv::Mat lut(1, 256, CV_8UC1);\r
-\r
- declare.in(src_host, lut, WARMUP_RNG);\r
-\r
- cv::gpu::GpuMat src(src_host);\r
- cv::gpu::GpuMat dst;\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::gpu::LUT(src, lut, dst);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, LUT, testing::Combine(\r
- ALL_DEVICES, \r
- GPU_TYPICAL_MAT_SIZES, \r
- testing::Values(CV_8UC1, CV_8UC3)));\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// CartToPolar\r
-\r
-GPU_PERF_TEST(CartToPolar, cv::gpu::DeviceInfo, cv::Size)\r
-{\r
- cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
-\r
- cv::gpu::setDevice(devInfo.deviceID());\r
-\r
- cv::Mat x_host(size, CV_32FC1);\r
- cv::Mat y_host(size, CV_32FC1);\r
-\r
- fill(x_host, -100.0, 100.0);\r
- fill(y_host, -100.0, 100.0);\r
-\r
- cv::gpu::GpuMat x(x_host);\r
- cv::gpu::GpuMat y(y_host);\r
- cv::gpu::GpuMat magnitude;\r
- cv::gpu::GpuMat angle;\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::gpu::cartToPolar(x, y, magnitude, angle);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, CartToPolar, testing::Combine(\r
- ALL_DEVICES, \r
- GPU_TYPICAL_MAT_SIZES));\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// PolarToCart\r
-\r
-GPU_PERF_TEST(PolarToCart, cv::gpu::DeviceInfo, cv::Size)\r
-{\r
- cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
-\r
- cv::gpu::setDevice(devInfo.deviceID());\r
-\r
- cv::Mat magnitude_host(size, CV_32FC1);\r
- cv::Mat angle_host(size, CV_32FC1);\r
-\r
- fill(magnitude_host, 0.0, 100.0);\r
- fill(angle_host, 0.0, 360.0);\r
-\r
- cv::gpu::GpuMat magnitude(magnitude_host);\r
- cv::gpu::GpuMat angle(angle_host);\r
- cv::gpu::GpuMat x;\r
- cv::gpu::GpuMat y;\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::gpu::polarToCart(magnitude, angle, x, y, true);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, PolarToCart, testing::Combine(\r
- ALL_DEVICES, \r
- GPU_TYPICAL_MAT_SIZES));\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// AddMat\r
-\r
-GPU_PERF_TEST(AddMat, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::gpu::setDevice(devInfo.deviceID());\r
-\r
- cv::Mat src1_host(size, type);\r
- cv::Mat src2_host(size, type);\r
-\r
- fill(src1_host, 0.0, 100.0);\r
- fill(src2_host, 0.0, 100.0);\r
-\r
- cv::gpu::GpuMat src1(src1_host);\r
- cv::gpu::GpuMat src2(src2_host);\r
- cv::gpu::GpuMat dst;\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::gpu::add(src1, src2, dst);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, AddMat, testing::Combine(\r
- ALL_DEVICES, \r
- GPU_TYPICAL_MAT_SIZES, \r
- testing::Values(CV_8UC1, CV_16UC1, CV_32FC1)));\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// AddScalar\r
-\r
-GPU_PERF_TEST(AddScalar, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::gpu::setDevice(devInfo.deviceID());\r
-\r
- cv::Mat src_host(size, type);\r
-\r
- fill(src_host, 0.0, 100.0);\r
-\r
- cv::gpu::GpuMat src(src_host);\r
- cv::Scalar s(1,2,3,4);\r
- cv::gpu::GpuMat dst;\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::gpu::add(src, s, dst);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, AddScalar, testing::Combine(\r
- ALL_DEVICES, \r
- GPU_TYPICAL_MAT_SIZES, \r
- testing::Values(CV_8UC1, CV_16UC1, CV_32FC1)));\r
-\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// SubtractMat\r
-\r
-GPU_PERF_TEST(SubtractMat, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::gpu::setDevice(devInfo.deviceID());\r
-\r
- cv::Mat src1_host(size, type);\r
- cv::Mat src2_host(size, type);\r
-\r
- fill(src1_host, 0.0, 100.0);\r
- fill(src2_host, 0.0, 100.0);\r
-\r
- cv::gpu::GpuMat src1(src1_host);\r
- cv::gpu::GpuMat src2(src2_host);\r
- cv::gpu::GpuMat dst;\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::gpu::subtract(src1, src2, dst);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, SubtractMat, testing::Combine(\r
- ALL_DEVICES, \r
- GPU_TYPICAL_MAT_SIZES, \r
- testing::Values(CV_8UC1, CV_16UC1, CV_32FC1)));\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// SubtractScalar\r
-\r
-GPU_PERF_TEST(SubtractScalar, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::gpu::setDevice(devInfo.deviceID());\r
-\r
- cv::Mat src_host(size, type);\r
-\r
- fill(src_host, 0.0, 100.0);\r
-\r
- cv::gpu::GpuMat src(src_host);\r
- cv::Scalar s(1,2,3,4);\r
- cv::gpu::GpuMat dst;\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::gpu::subtract(src, s, dst);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, SubtractScalar, testing::Combine(\r
- ALL_DEVICES, \r
- GPU_TYPICAL_MAT_SIZES, \r
- testing::Values(CV_8UC1, CV_16UC1, CV_32FC1)));\r
-\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// MultiplyMat\r
-\r
-GPU_PERF_TEST(MultiplyMat, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::gpu::setDevice(devInfo.deviceID());\r
-\r
- cv::Mat src1_host(size, type);\r
- cv::Mat src2_host(size, type);\r
-\r
- fill(src1_host, 0.0, 100.0);\r
- fill(src2_host, 0.0, 100.0);\r
-\r
- cv::gpu::GpuMat src1(src1_host);\r
- cv::gpu::GpuMat src2(src2_host);\r
- cv::gpu::GpuMat dst;\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::gpu::multiply(src1, src2, dst);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, MultiplyMat, testing::Combine(\r
- ALL_DEVICES, \r
- GPU_TYPICAL_MAT_SIZES, \r
- testing::Values(CV_8UC1, CV_16UC1, CV_32FC1)));\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// MultiplyScalar\r
-\r
-GPU_PERF_TEST(MultiplyScalar, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::gpu::setDevice(devInfo.deviceID());\r
-\r
- cv::Mat src_host(size, type);\r
-\r
- fill(src_host, 0.0, 100.0);\r
-\r
- cv::gpu::GpuMat src(src_host);\r
- cv::Scalar s(1,2,3,4);\r
- cv::gpu::GpuMat dst;\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::gpu::multiply(src, s, dst);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, MultiplyScalar, testing::Combine(\r
- ALL_DEVICES, \r
- GPU_TYPICAL_MAT_SIZES, \r
- testing::Values(CV_8UC1, CV_16UC1, CV_32FC1)));\r
-\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// DivideMat\r
-\r
-GPU_PERF_TEST(DivideMat, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::gpu::setDevice(devInfo.deviceID());\r
-\r
- cv::Mat src1_host(size, type);\r
- cv::Mat src2_host(size, type);\r
-\r
- fill(src1_host, 0.0, 100.0);\r
- fill(src2_host, 0.0, 100.0);\r
-\r
- cv::gpu::GpuMat src1(src1_host);\r
- cv::gpu::GpuMat src2(src2_host);\r
- cv::gpu::GpuMat dst;\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::gpu::divide(src1, src2, dst);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, DivideMat, testing::Combine(\r
- ALL_DEVICES, \r
- GPU_TYPICAL_MAT_SIZES, \r
- testing::Values(CV_8UC1, CV_16UC1, CV_32FC1)));\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// DivideScalar\r
-\r
-GPU_PERF_TEST(DivideScalar, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::gpu::setDevice(devInfo.deviceID());\r
-\r
- cv::Mat src_host(size, type);\r
-\r
- fill(src_host, 0.0, 100.0);\r
-\r
- cv::gpu::GpuMat src(src_host);\r
- cv::Scalar s(1,2,3,4);\r
- cv::gpu::GpuMat dst;\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::gpu::divide(src, s, dst);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, DivideScalar, testing::Combine(\r
- ALL_DEVICES, \r
- GPU_TYPICAL_MAT_SIZES, \r
- testing::Values(CV_8UC1, CV_16UC1, CV_32FC1)));\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// Exp\r
-\r
-GPU_PERF_TEST(Exp, cv::gpu::DeviceInfo, cv::Size)\r
-{\r
- cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
-\r
- cv::gpu::setDevice(devInfo.deviceID());\r
-\r
- cv::Mat src_host(size, CV_32FC1);\r
-\r
- fill(src_host, 0.0, 10.0);\r
-\r
- cv::gpu::GpuMat src(src_host);\r
- cv::gpu::GpuMat dst;\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::gpu::exp(src, dst);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, Exp, testing::Combine(\r
- ALL_DEVICES, \r
- GPU_TYPICAL_MAT_SIZES));\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// Pow\r
-\r
-GPU_PERF_TEST(Pow, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::gpu::setDevice(devInfo.deviceID());\r
-\r
- cv::Mat src_host(size, type);\r
-\r
- declare.in(src_host, WARMUP_RNG);\r
-\r
- cv::gpu::GpuMat src(src_host);\r
- cv::gpu::GpuMat dst;\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::gpu::pow(src, 0.5, dst);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, Pow, testing::Combine(\r
- ALL_DEVICES, \r
- GPU_TYPICAL_MAT_SIZES, \r
- testing::Values(CV_8UC1, CV_8UC4, CV_16UC1, CV_32FC1)));\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// Log\r
-\r
-GPU_PERF_TEST(Log, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::gpu::setDevice(devInfo.deviceID());\r
-\r
- cv::Mat src_host(size, type);\r
-\r
- declare.in(src_host, WARMUP_RNG);\r
-\r
- cv::gpu::GpuMat src(src_host);\r
- cv::gpu::GpuMat dst;\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::gpu::log(src, dst);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, Log, testing::Combine(\r
- ALL_DEVICES, \r
- GPU_TYPICAL_MAT_SIZES, \r
- testing::Values(CV_8UC1, CV_8UC4, CV_16UC1, CV_32FC1)));\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// Sqrt\r
-\r
-GPU_PERF_TEST(Sqrt, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::gpu::setDevice(devInfo.deviceID());\r
-\r
- cv::Mat src_host(size, type);\r
-\r
- declare.in(src_host, WARMUP_RNG);\r
-\r
- cv::gpu::GpuMat src(src_host);\r
- cv::gpu::GpuMat dst;\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::gpu::sqrt(src, dst);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, Sqrt, testing::Combine(\r
- ALL_DEVICES, \r
- GPU_TYPICAL_MAT_SIZES, \r
- testing::Values(CV_8UC1, CV_8UC4, CV_16UC1, CV_32FC1)));\r
-\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// Compare\r
-\r
-GPU_PERF_TEST(Compare, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::gpu::setDevice(devInfo.deviceID());\r
-\r
- cv::Mat src1_host(size, type);\r
- cv::Mat src2_host(size, type);\r
-\r
- declare.in(src1_host, src2_host, WARMUP_RNG);\r
-\r
- cv::gpu::GpuMat src1(src1_host);\r
- cv::gpu::GpuMat src2(src2_host);\r
- cv::gpu::GpuMat dst;\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::gpu::compare(src1, src2, dst, cv::CMP_EQ);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, Compare, testing::Combine(\r
- ALL_DEVICES, \r
- GPU_TYPICAL_MAT_SIZES, \r
- testing::Values(CV_8UC1, CV_16UC1, CV_32FC1)));\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// CompareScalar\r
-\r
-GPU_PERF_TEST(CompareScalar, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::gpu::setDevice(devInfo.deviceID());\r
-\r
- cv::Mat src1_host(size, type);\r
- \r
- declare.in(src1_host, WARMUP_RNG);\r
-\r
- cv::gpu::GpuMat src1(src1_host);\r
- cv::Scalar src2 = cv::Scalar::all(123);\r
- cv::gpu::GpuMat dst;\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::gpu::compare(src1, src2, dst, cv::CMP_EQ);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, CompareScalar, testing::Combine(\r
- ALL_DEVICES, \r
- GPU_TYPICAL_MAT_SIZES, \r
- testing::Values(CV_8UC1, CV_16UC1, CV_32FC1)));\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// BitwiseNot\r
-\r
-GPU_PERF_TEST(BitwiseNot, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::gpu::setDevice(devInfo.deviceID());\r
-\r
- cv::Mat src_host(size, type);\r
-\r
- declare.in(src_host, WARMUP_RNG);\r
-\r
- cv::gpu::GpuMat src(src_host);\r
- cv::gpu::GpuMat dst;\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::gpu::bitwise_not(src, dst);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, BitwiseNot, testing::Combine(\r
- ALL_DEVICES, \r
- GPU_TYPICAL_MAT_SIZES, \r
- testing::Values(CV_8UC1, CV_16UC1, CV_32SC1)));\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// BitwiseAnd\r
-\r
-GPU_PERF_TEST(BitwiseAnd, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::gpu::setDevice(devInfo.deviceID());\r
-\r
- cv::Mat src1_host(size, type);\r
- cv::Mat src2_host(size, type);\r
-\r
- declare.in(src1_host, src2_host, WARMUP_RNG);\r
-\r
- cv::gpu::GpuMat src1(src1_host);\r
- cv::gpu::GpuMat src2(src2_host);\r
- cv::gpu::GpuMat dst;\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::gpu::bitwise_and(src1, src2, dst);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, BitwiseAnd, testing::Combine(\r
- ALL_DEVICES, \r
- GPU_TYPICAL_MAT_SIZES, \r
- testing::Values(CV_8UC1, CV_16UC1, CV_32SC1)));\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// BitwiseScalarAnd\r
-\r
-GPU_PERF_TEST(BitwiseScalarAnd, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::gpu::setDevice(devInfo.deviceID());\r
-\r
- cv::Mat src_host(size, type);\r
-\r
- declare.in(src_host, WARMUP_RNG);\r
-\r
- cv::gpu::GpuMat src(src_host);\r
- cv::gpu::GpuMat dst;\r
- cv::Scalar sc = cv::Scalar(123, 123, 123, 123);\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::gpu::bitwise_and(src, sc, dst);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, BitwiseScalarAnd, testing::Combine(\r
- ALL_DEVICES, \r
- GPU_TYPICAL_MAT_SIZES, \r
- testing::Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_16UC1, CV_16UC3, CV_16UC4, CV_32SC1, CV_32SC3, CV_32SC4)));\r
-\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// BitwiseOr\r
-\r
-GPU_PERF_TEST(BitwiseOr, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::gpu::setDevice(devInfo.deviceID());\r
-\r
- cv::Mat src1_host(size, type);\r
- cv::Mat src2_host(size, type);\r
-\r
- declare.in(src1_host, src2_host, WARMUP_RNG);\r
-\r
- cv::gpu::GpuMat src1(src1_host);\r
- cv::gpu::GpuMat src2(src2_host);\r
- cv::gpu::GpuMat dst;\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::gpu::bitwise_or(src1, src2, dst);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, BitwiseOr, testing::Combine(\r
- ALL_DEVICES, \r
- GPU_TYPICAL_MAT_SIZES, \r
- testing::Values(CV_8UC1, CV_16UC1, CV_32SC1)));\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// BitwiseScalarOr\r
-\r
-GPU_PERF_TEST(BitwiseScalarOr, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::gpu::setDevice(devInfo.deviceID());\r
-\r
- cv::Mat src_host(size, type);\r
-\r
- declare.in(src_host, WARMUP_RNG);\r
-\r
- cv::gpu::GpuMat src(src_host);\r
- cv::gpu::GpuMat dst;\r
- cv::Scalar sc = cv::Scalar(123, 123, 123, 123);\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::gpu::bitwise_or(src, sc, dst);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, BitwiseScalarOr, testing::Combine(\r
- ALL_DEVICES, \r
- GPU_TYPICAL_MAT_SIZES, \r
- testing::Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_16UC1, CV_16UC3, CV_16UC4, CV_32SC1, CV_32SC3, CV_32SC4)));\r
-\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// BitwiseXor\r
-\r
-GPU_PERF_TEST(BitwiseXor, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::gpu::setDevice(devInfo.deviceID());\r
-\r
- cv::Mat src1_host(size, type);\r
- cv::Mat src2_host(size, type);\r
-\r
- declare.in(src1_host, src2_host, WARMUP_RNG);\r
-\r
- cv::gpu::GpuMat src1(src1_host);\r
- cv::gpu::GpuMat src2(src2_host);\r
- cv::gpu::GpuMat dst;\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::gpu::bitwise_xor(src1, src2, dst);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, BitwiseXor, testing::Combine(\r
- ALL_DEVICES, \r
- GPU_TYPICAL_MAT_SIZES, \r
- testing::Values(CV_8UC1, CV_16UC1, CV_32SC1)));\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// BitwiseScalarXor\r
-\r
-GPU_PERF_TEST(BitwiseScalarXor, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::gpu::setDevice(devInfo.deviceID());\r
-\r
- cv::Mat src_host(size, type);\r
-\r
- declare.in(src_host, WARMUP_RNG);\r
-\r
- cv::gpu::GpuMat src(src_host);\r
- cv::gpu::GpuMat dst;\r
- cv::Scalar sc = cv::Scalar(123, 123, 123, 123);\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::gpu::bitwise_xor(src, sc, dst);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, BitwiseScalarXor, testing::Combine(\r
- ALL_DEVICES, \r
- GPU_TYPICAL_MAT_SIZES, \r
- testing::Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_16UC1, CV_16UC3, CV_16UC4, CV_32SC1, CV_32SC3, CV_32SC4)));\r
-\r
-\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// Min\r
-\r
-GPU_PERF_TEST(Min, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::gpu::setDevice(devInfo.deviceID());\r
-\r
- cv::Mat src1_host(size, type);\r
- cv::Mat src2_host(size, type);\r
-\r
- declare.in(src1_host, src2_host, WARMUP_RNG);\r
-\r
- cv::gpu::GpuMat src1(src1_host);\r
- cv::gpu::GpuMat src2(src2_host);\r
- cv::gpu::GpuMat dst(size, type);\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::gpu::min(src1, src2, dst);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, Min, testing::Combine(\r
- ALL_DEVICES, \r
- GPU_TYPICAL_MAT_SIZES, \r
- testing::Values(CV_8UC1, CV_16UC1, CV_32SC1)));\r
-\r
-\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// Max\r
-\r
-GPU_PERF_TEST(Max, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::gpu::setDevice(devInfo.deviceID());\r
-\r
- cv::Mat src1_host(size, type);\r
- cv::Mat src2_host(size, type);\r
-\r
- declare.in(src1_host, src2_host, WARMUP_RNG);\r
-\r
- cv::gpu::GpuMat src1(src1_host);\r
- cv::gpu::GpuMat src2(src2_host);\r
- cv::gpu::GpuMat dst(size, type);\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::gpu::max(src1, src2, dst);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, Max, testing::Combine(\r
- ALL_DEVICES, \r
- GPU_TYPICAL_MAT_SIZES, \r
- testing::Values(CV_8UC1, CV_16UC1, CV_32SC1)));\r
-\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// Abs\r
-\r
-GPU_PERF_TEST(Abs, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::gpu::setDevice(devInfo.deviceID());\r
-\r
- cv::Mat src1_host(size, type);\r
- \r
- declare.in(src1_host, WARMUP_RNG);\r
-\r
- cv::gpu::GpuMat src1(src1_host); \r
- cv::gpu::GpuMat dst(size, type);\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::gpu::abs(src1, dst);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, Abs, testing::Combine(\r
- ALL_DEVICES, \r
- GPU_TYPICAL_MAT_SIZES, \r
- testing::Values(CV_16S, CV_32F)));\r
-\r
-\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// AbsDiff\r
-\r
-GPU_PERF_TEST(AbsDiff, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::gpu::setDevice(devInfo.deviceID());\r
-\r
- cv::Mat src1_host(size, type);\r
- cv::Mat src2_host(size, type);\r
- \r
- declare.in(src1_host, src2_host, WARMUP_RNG);\r
-\r
- cv::gpu::GpuMat src1(src1_host); \r
- cv::gpu::GpuMat src2(src2_host);\r
- cv::gpu::GpuMat dst(size, type);\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::gpu::absdiff(src1, src2, dst);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, AbsDiff, testing::Combine(\r
- ALL_DEVICES, \r
- GPU_TYPICAL_MAT_SIZES, \r
- testing::Values(CV_8UC1, CV_16UC1, CV_32SC1)));\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// Phase\r
-\r
-GPU_PERF_TEST(Phase, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::Mat src1_host(size, type);\r
- cv::Mat src2_host(size, type);\r
- \r
- declare.in(src1_host, src2_host, WARMUP_RNG);\r
-\r
- cv::gpu::GpuMat src1(src1_host); \r
- cv::gpu::GpuMat src2(src2_host);\r
- cv::gpu::GpuMat dst(size, type);\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::gpu::phase(src1, src2, dst, true);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, Phase, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values<perf::MatType>(CV_32FC1)));\r
-\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// Magnitude\r
-\r
-GPU_PERF_TEST(Magnitude, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::Mat src1_host(size, type);\r
- cv::Mat src2_host(size, type);\r
- \r
- declare.in(src1_host, src2_host, WARMUP_RNG);\r
-\r
- cv::gpu::GpuMat src1(src1_host); \r
- cv::gpu::GpuMat src2(src2_host);\r
- cv::gpu::GpuMat dst(size, type);\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::gpu::magnitude(src1, src2, dst);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, Magnitude, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values<perf::MatType>(CV_32FC1)));\r
-\r
-\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// AbsDiffScalar\r
-\r
-GPU_PERF_TEST(AbsDiffScalar, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::gpu::setDevice(devInfo.deviceID());\r
-\r
- cv::Mat src1_host(size, type); \r
- declare.in(src1_host, WARMUP_RNG);\r
-\r
- cv::gpu::GpuMat src1(src1_host); \r
- cv::Scalar src2 = cv::Scalar::all(123);\r
- cv::gpu::GpuMat dst(size, type);\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::gpu::absdiff(src1, src2, dst);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, AbsDiffScalar, testing::Combine(\r
- ALL_DEVICES, \r
- GPU_TYPICAL_MAT_SIZES, \r
- testing::Values(CV_8UC1, CV_16UC1, CV_32SC1)));\r
-\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// MeanStdDev\r
-\r
-GPU_PERF_TEST(MeanStdDev, cv::gpu::DeviceInfo, cv::Size)\r
-{\r
- cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
-\r
- cv::gpu::setDevice(devInfo.deviceID());\r
-\r
- cv::Mat src_host(size, CV_8UC1);\r
-\r
- declare.in(src_host, WARMUP_RNG);\r
-\r
- cv::gpu::GpuMat src(src_host); \r
- cv::Scalar mean;\r
- cv::Scalar stddev;\r
- cv::gpu::GpuMat buf;\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::gpu::meanStdDev(src, mean, stddev, buf);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, MeanStdDev, testing::Combine(\r
- ALL_DEVICES, \r
- GPU_TYPICAL_MAT_SIZES));\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// Norm\r
-\r
-GPU_PERF_TEST(Norm, cv::gpu::DeviceInfo, cv::Size, perf::MatType, NormType)\r
-{\r
- cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
- int normType = GET_PARAM(3);\r
-\r
- cv::gpu::setDevice(devInfo.deviceID());\r
-\r
- cv::Mat src_host(size, type);\r
-\r
- declare.in(src_host, WARMUP_RNG);\r
-\r
- cv::gpu::GpuMat src(src_host);\r
- double dst;\r
- cv::gpu::GpuMat buf;\r
-\r
- TEST_CYCLE()\r
- {\r
- dst = cv::gpu::norm(src, normType, buf);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, Norm, testing::Combine(\r
- ALL_DEVICES, \r
- GPU_TYPICAL_MAT_SIZES, \r
- testing::Values(CV_8UC1, CV_16UC1, CV_32SC1),\r
- testing::Values((int) cv::NORM_INF, (int) cv::NORM_L1, (int) cv::NORM_L2)));\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// NormDiff\r
-\r
-GPU_PERF_TEST(NormDiff, cv::gpu::DeviceInfo, cv::Size, NormType)\r
-{\r
- cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
- int normType = GET_PARAM(2);\r
-\r
- cv::gpu::setDevice(devInfo.deviceID());\r
-\r
- cv::Mat src1_host(size, CV_8UC1);\r
- cv::Mat src2_host(size, CV_8UC1);\r
-\r
- declare.in(src1_host, src2_host, WARMUP_RNG);\r
-\r
- cv::gpu::GpuMat src1(src1_host);\r
- cv::gpu::GpuMat src2(src2_host);\r
- double dst;\r
-\r
- TEST_CYCLE()\r
- {\r
- dst = cv::gpu::norm(src1, src2, normType);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, NormDiff, testing::Combine(\r
- ALL_DEVICES, \r
- GPU_TYPICAL_MAT_SIZES, \r
- testing::Values((int) cv::NORM_INF, (int) cv::NORM_L1, (int) cv::NORM_L2)));\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// Sum\r
-\r
-GPU_PERF_TEST(Sum, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::gpu::setDevice(devInfo.deviceID());\r
-\r
- cv::Mat src_host(size, type);\r
-\r
- declare.in(src_host, WARMUP_RNG);\r
-\r
- cv::gpu::GpuMat src(src_host);\r
- cv::Scalar dst;\r
- cv::gpu::GpuMat buf;\r
-\r
- TEST_CYCLE()\r
- {\r
- dst = cv::gpu::sum(src, buf);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, Sum, testing::Combine(\r
- ALL_DEVICES, \r
- GPU_TYPICAL_MAT_SIZES, \r
- testing::Values(CV_8UC1, CV_16UC1, CV_32FC1)));\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// MinMax\r
-\r
-GPU_PERF_TEST(MinMax, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::gpu::setDevice(devInfo.deviceID());\r
-\r
- cv::Mat src_host(size, type);\r
-\r
- declare.in(src_host, WARMUP_RNG);\r
-\r
- cv::gpu::GpuMat src(src_host);\r
- double minVal, maxVal;\r
- cv::gpu::GpuMat buf;\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::gpu::minMax(src, &minVal, &maxVal, cv::gpu::GpuMat(), buf);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, MinMax, testing::Combine(\r
- ALL_DEVICES, \r
- GPU_TYPICAL_MAT_SIZES, \r
- testing::Values(CV_8UC1, CV_16UC1, CV_32FC1)));\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// MinMaxLoc\r
-\r
-GPU_PERF_TEST(MinMaxLoc, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::gpu::setDevice(devInfo.deviceID());\r
-\r
- cv::Mat src_host(size, type);\r
-\r
- declare.in(src_host, WARMUP_RNG);\r
-\r
- cv::gpu::GpuMat src(src_host);\r
- double minVal, maxVal;\r
- cv::Point minLoc, maxLoc;\r
- cv::gpu::GpuMat valbuf, locbuf;\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::gpu::minMaxLoc(src, &minVal, &maxVal, &minLoc, &maxLoc, cv::gpu::GpuMat(), valbuf, locbuf);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, MinMaxLoc, testing::Combine(\r
- ALL_DEVICES, \r
- GPU_TYPICAL_MAT_SIZES, \r
- testing::Values(CV_8UC1, CV_16UC1, CV_32FC1)));\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// CountNonZero\r
-\r
-GPU_PERF_TEST(CountNonZero, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::gpu::setDevice(devInfo.deviceID());\r
-\r
- cv::Mat src_host(size, type);\r
-\r
- fill(src_host, 0.0, 1.0);\r
-\r
- cv::gpu::GpuMat src(src_host);\r
- int dst;\r
- cv::gpu::GpuMat buf;\r
-\r
- TEST_CYCLE()\r
- {\r
- dst = cv::gpu::countNonZero(src, buf);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, CountNonZero, testing::Combine(\r
- ALL_DEVICES, \r
- GPU_TYPICAL_MAT_SIZES, \r
- testing::Values(CV_8UC1, CV_16UC1, CV_32FC1)));\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// AddWeighted\r
-\r
-GPU_PERF_TEST(AddWeighted, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::gpu::setDevice(devInfo.deviceID());\r
-\r
- cv::Mat src1_host(size, type);\r
- cv::Mat src2_host(size, type);\r
-\r
- fill(src1_host, 0.0, 100.0);\r
- fill(src2_host, 0.0, 100.0);\r
-\r
- cv::gpu::GpuMat src1(src1_host);\r
- cv::gpu::GpuMat src2(src2_host);\r
- cv::gpu::GpuMat dst;\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::gpu::addWeighted(src1, 0.5, src2, 0.5, 0.0, dst);\r
- }\r
-\r
- cv::Mat dst_host(dst);\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, AddWeighted, testing::Combine(\r
- ALL_DEVICES, \r
- GPU_TYPICAL_MAT_SIZES, \r
- testing::Values(CV_8UC1, CV_16UC1, CV_32FC1)));\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// Reduce\r
-\r
-GPU_PERF_TEST(Reduce, cv::gpu::DeviceInfo, cv::Size, perf::MatType, FlipCode)\r
-{\r
- cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
- int dim = GET_PARAM(3);\r
-\r
- cv::gpu::setDevice(devInfo.deviceID());\r
-\r
- cv::Mat src_host(size, type);\r
-\r
- fill(src_host, 0.0, 10.0);\r
-\r
- cv::gpu::GpuMat src(src_host);\r
- cv::gpu::GpuMat dst;\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::gpu::reduce(src, dst, dim, CV_REDUCE_MIN);\r
- }\r
-\r
- cv::Mat dst_host(dst);\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, Reduce, testing::Combine(\r
- ALL_DEVICES, \r
- GPU_TYPICAL_MAT_SIZES, \r
- testing::Values(CV_8UC1, CV_16UC1, CV_32FC1), \r
- testing::Values((int) HORIZONTAL_AXIS, (int) VERTICAL_AXIS)));\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// GEMM\r
-\r
-GPU_PERF_TEST(GEMM, cv::gpu::DeviceInfo, cv::Size)\r
-{\r
- cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
-\r
- cv::gpu::setDevice(devInfo.deviceID());\r
-\r
- cv::Mat src1_host(size, CV_32FC1);\r
- cv::Mat src2_host(size, CV_32FC1);\r
- cv::Mat src3_host(size, CV_32FC1);\r
-\r
- fill(src1_host, 0.0, 10.0);\r
- fill(src2_host, 0.0, 10.0);\r
- fill(src3_host, 0.0, 10.0);\r
-\r
- cv::gpu::GpuMat src1(src1_host);\r
- cv::gpu::GpuMat src2(src2_host);\r
- cv::gpu::GpuMat src3(src3_host);\r
- cv::gpu::GpuMat dst;\r
-\r
- declare.time(5.0);\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::gpu::gemm(src1, src2, 1.0, src3, 1.0, dst);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, GEMM, testing::Combine(\r
- ALL_DEVICES, \r
- testing::Values(cv::Size(512, 512), cv::Size(1024, 1024), cv::Size(2048, 2048))));\r
-\r
-#endif\r
#ifdef HAVE_CUDA\r
\r
//////////////////////////////////////////////////////////////////////\r
-// TransformPoints\r
+// StereoBM\r
\r
-GPU_PERF_TEST_1(TransformPoints, cv::gpu::DeviceInfo)\r
+GPU_PERF_TEST_1(StereoBM, cv::gpu::DeviceInfo)\r
{\r
cv::gpu::DeviceInfo devInfo = GetParam();\r
-\r
cv::gpu::setDevice(devInfo.deviceID());\r
\r
- cv::Mat src_host(1, 10000, CV_32FC3);\r
+ cv::Mat img_l_host = readImage("gpu/perf/aloe.jpg", cv::IMREAD_GRAYSCALE);\r
+ ASSERT_FALSE(img_l_host.empty());\r
\r
- declare.in(src_host, WARMUP_RNG);\r
+ cv::Mat img_r_host = readImage("gpu/perf/aloeR.jpg", cv::IMREAD_GRAYSCALE);\r
+ ASSERT_FALSE(img_r_host.empty());\r
\r
- cv::gpu::GpuMat src(src_host);\r
+ cv::gpu::StereoBM_GPU bm(0, 256);\r
+ cv::gpu::GpuMat img_l(img_l_host);\r
+ cv::gpu::GpuMat img_r(img_r_host);\r
cv::gpu::GpuMat dst;\r
\r
+ bm(img_l, img_r, dst);\r
+\r
+ declare.time(5.0);\r
+\r
TEST_CYCLE()\r
{\r
- cv::gpu::transformPoints(src, cv::Mat::ones(1, 3, CV_32FC1), cv::Mat::ones(1, 3, CV_32FC1), dst);\r
+ bm(img_l, img_r, dst);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(Calib3D, TransformPoints, ALL_DEVICES);\r
+INSTANTIATE_TEST_CASE_P(Calib3D, StereoBM, ALL_DEVICES);\r
\r
//////////////////////////////////////////////////////////////////////\r
-// ProjectPoints\r
+// StereoBeliefPropagation\r
\r
-GPU_PERF_TEST_1(ProjectPoints, cv::gpu::DeviceInfo)\r
+GPU_PERF_TEST_1(StereoBeliefPropagation, cv::gpu::DeviceInfo)\r
{\r
cv::gpu::DeviceInfo devInfo = GetParam();\r
-\r
cv::gpu::setDevice(devInfo.deviceID());\r
\r
- cv::Mat src_host(1, 10000, CV_32FC3);\r
+ cv::Mat img_l_host = readImage("gpu/stereobp/aloe-L.png");\r
+ ASSERT_FALSE(img_l_host.empty());\r
\r
- declare.in(src_host, WARMUP_RNG);\r
+ cv::Mat img_r_host = readImage("gpu/stereobp/aloe-R.png");\r
+ ASSERT_FALSE(img_r_host.empty());\r
\r
- cv::gpu::GpuMat src(src_host);\r
+ cv::gpu::StereoBeliefPropagation bp(64);\r
+ cv::gpu::GpuMat img_l(img_l_host);\r
+ cv::gpu::GpuMat img_r(img_r_host);\r
cv::gpu::GpuMat dst;\r
\r
+ bp(img_l, img_r, dst);\r
+\r
+ declare.time(10.0);\r
+\r
TEST_CYCLE()\r
{\r
- cv::gpu::projectPoints(src, cv::Mat::ones(1, 3, CV_32FC1), cv::Mat::ones(1, 3, CV_32FC1), cv::Mat::ones(3, 3, CV_32FC1), cv::Mat(), dst);\r
+ bp(img_l, img_r, dst);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(Calib3D, ProjectPoints, ALL_DEVICES);\r
+INSTANTIATE_TEST_CASE_P(Calib3D, StereoBeliefPropagation, ALL_DEVICES);\r
\r
//////////////////////////////////////////////////////////////////////\r
-// SolvePnPRansac\r
+// StereoConstantSpaceBP\r
\r
-GPU_PERF_TEST_1(SolvePnPRansac, cv::gpu::DeviceInfo)\r
+GPU_PERF_TEST_1(StereoConstantSpaceBP, cv::gpu::DeviceInfo)\r
{\r
cv::gpu::DeviceInfo devInfo = GetParam();\r
-\r
cv::gpu::setDevice(devInfo.deviceID());\r
\r
- cv::Mat object(1, 10000, CV_32FC3);\r
- cv::Mat image(1, 10000, CV_32FC2);\r
+ cv::Mat img_l_host = readImage("gpu/stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE);\r
+ ASSERT_FALSE(img_l_host.empty());\r
\r
- declare.in(object, image, WARMUP_RNG);\r
+ cv::Mat img_r_host = readImage("gpu/stereobm/aloe-R.png", cv::IMREAD_GRAYSCALE);\r
+ ASSERT_FALSE(img_r_host.empty());\r
+\r
+ cv::gpu::StereoConstantSpaceBP csbp(128);\r
+ cv::gpu::GpuMat img_l(img_l_host);\r
+ cv::gpu::GpuMat img_r(img_r_host);\r
+ cv::gpu::GpuMat dst;\r
\r
- cv::Mat rvec, tvec;\r
+ csbp(img_l, img_r, dst);\r
\r
- declare.time(3.0);\r
+ declare.time(10.0);\r
\r
TEST_CYCLE()\r
{\r
- cv::gpu::solvePnPRansac(object, image, cv::Mat::ones(3, 3, CV_32FC1), cv::Mat(1, 8, CV_32F, cv::Scalar::all(0)), rvec, tvec);\r
+ csbp(img_l, img_r, dst);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(Calib3D, SolvePnPRansac, ALL_DEVICES);\r
+INSTANTIATE_TEST_CASE_P(Calib3D, StereoConstantSpaceBP, ALL_DEVICES);\r
\r
//////////////////////////////////////////////////////////////////////\r
-// StereoBM\r
+// DisparityBilateralFilter\r
\r
-GPU_PERF_TEST_1(StereoBM, cv::gpu::DeviceInfo)\r
+GPU_PERF_TEST_1(DisparityBilateralFilter, cv::gpu::DeviceInfo)\r
{\r
cv::gpu::DeviceInfo devInfo = GetParam();\r
-\r
cv::gpu::setDevice(devInfo.deviceID());\r
\r
- cv::Mat img_l_host = readImage("gpu/perf/aloe.jpg", cv::IMREAD_GRAYSCALE);\r
- cv::Mat img_r_host = readImage("gpu/perf/aloeR.jpg", cv::IMREAD_GRAYSCALE);\r
+ cv::Mat img_host = readImage("gpu/stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE);\r
+ ASSERT_FALSE(img_host.empty());\r
\r
- ASSERT_FALSE(img_l_host.empty());\r
- ASSERT_FALSE(img_r_host.empty());\r
+ cv::Mat disp_host = readImage("gpu/stereobm/aloe-disp.png", cv::IMREAD_GRAYSCALE);\r
+ ASSERT_FALSE(disp_host.empty());\r
\r
- cv::gpu::GpuMat img_l(img_l_host);\r
- cv::gpu::GpuMat img_r(img_r_host);\r
+ cv::gpu::DisparityBilateralFilter f(128);\r
+ cv::gpu::GpuMat img(img_host);\r
+ cv::gpu::GpuMat disp(disp_host);\r
cv::gpu::GpuMat dst;\r
\r
- cv::gpu::StereoBM_GPU bm(0, 256);\r
-\r
- declare.time(5.0);\r
+ f(disp, img, dst);\r
\r
TEST_CYCLE()\r
{\r
- bm(img_l, img_r, dst);\r
+ f(disp, img, dst);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(Calib3D, StereoBM, ALL_DEVICES);\r
+INSTANTIATE_TEST_CASE_P(Calib3D, DisparityBilateralFilter, ALL_DEVICES);\r
\r
//////////////////////////////////////////////////////////////////////\r
-// StereoBeliefPropagation\r
+// TransformPoints\r
\r
-GPU_PERF_TEST_1(StereoBeliefPropagation, cv::gpu::DeviceInfo)\r
-{\r
- cv::gpu::DeviceInfo devInfo = GetParam();\r
+IMPLEMENT_PARAM_CLASS(Count, int)\r
\r
+GPU_PERF_TEST(TransformPoints, cv::gpu::DeviceInfo, Count)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
cv::gpu::setDevice(devInfo.deviceID());\r
\r
- cv::Mat img_l_host = readImage("gpu/stereobp/aloe-L.png");\r
- cv::Mat img_r_host = readImage("gpu/stereobp/aloe-R.png");\r
+ int count = GET_PARAM(1);\r
\r
- ASSERT_FALSE(img_l_host.empty());\r
- ASSERT_FALSE(img_r_host.empty());\r
+ cv::Mat src_host(1, count, CV_32FC3);\r
+ fill(src_host, -100, 100);\r
\r
- cv::gpu::GpuMat img_l(img_l_host);\r
- cv::gpu::GpuMat img_r(img_r_host);\r
+ cv::gpu::GpuMat src(src_host);\r
+ cv::Mat rvec = cv::Mat::ones(1, 3, CV_32FC1);\r
+ cv::Mat tvec = cv::Mat::ones(1, 3, CV_32FC1);\r
cv::gpu::GpuMat dst;\r
\r
- cv::gpu::StereoBeliefPropagation bp(64);\r
-\r
- declare.time(10.0);\r
+ cv::gpu::transformPoints(src, rvec, tvec, dst);\r
\r
TEST_CYCLE()\r
{\r
- bp(img_l, img_r, dst);\r
+ cv::gpu::transformPoints(src, rvec, tvec, dst);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(Calib3D, StereoBeliefPropagation, ALL_DEVICES);\r
+INSTANTIATE_TEST_CASE_P(Calib3D, TransformPoints, testing::Combine(\r
+ ALL_DEVICES,\r
+ testing::Values<Count>(5000, 10000, 20000)));\r
\r
//////////////////////////////////////////////////////////////////////\r
-// StereoConstantSpaceBP\r
+// ProjectPoints\r
\r
-GPU_PERF_TEST_1(StereoConstantSpaceBP, cv::gpu::DeviceInfo)\r
+GPU_PERF_TEST(ProjectPoints, cv::gpu::DeviceInfo, Count)\r
{\r
- cv::gpu::DeviceInfo devInfo = GetParam();\r
-\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
cv::gpu::setDevice(devInfo.deviceID());\r
\r
- cv::Mat img_l_host = readImage("gpu/stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE);\r
- cv::Mat img_r_host = readImage("gpu/stereobm/aloe-R.png", cv::IMREAD_GRAYSCALE);\r
+ int count = GET_PARAM(1);\r
\r
- ASSERT_FALSE(img_l_host.empty());\r
- ASSERT_FALSE(img_r_host.empty());\r
+ cv::Mat src_host(1, count, CV_32FC3);\r
+ fill(src_host, -100, 100);\r
\r
- cv::gpu::GpuMat img_l(img_l_host);\r
- cv::gpu::GpuMat img_r(img_r_host);\r
+ cv::gpu::GpuMat src(src_host);\r
+ cv::Mat rvec = cv::Mat::ones(1, 3, CV_32FC1);\r
+ cv::Mat tvec = cv::Mat::ones(1, 3, CV_32FC1);\r
+ cv::Mat camera_mat = cv::Mat::ones(3, 3, CV_32FC1);\r
cv::gpu::GpuMat dst;\r
\r
- cv::gpu::StereoConstantSpaceBP bp(128);\r
+ cv::gpu::projectPoints(src, rvec, tvec, camera_mat, cv::Mat(), dst);\r
\r
- declare.time(10.0);\r
+ TEST_CYCLE()\r
+ {\r
+ cv::gpu::projectPoints(src, rvec, tvec, camera_mat, cv::Mat(), dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Calib3D, ProjectPoints, testing::Combine(\r
+ ALL_DEVICES,\r
+ testing::Values<Count>(5000, 10000, 20000)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// SolvePnPRansac\r
+\r
+GPU_PERF_TEST(SolvePnPRansac, cv::gpu::DeviceInfo, Count)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
+ int count = GET_PARAM(1);\r
+\r
+ cv::Mat object(1, count, CV_32FC3);\r
+ fill(object, -100, 100);\r
+\r
+ cv::Mat camera_mat(3, 3, CV_32FC1);\r
+ fill(camera_mat, 0.5, 1);\r
+ camera_mat.at<float>(0, 1) = 0.f;\r
+ camera_mat.at<float>(1, 0) = 0.f;\r
+ camera_mat.at<float>(2, 0) = 0.f;\r
+ camera_mat.at<float>(2, 1) = 0.f;\r
+\r
+ cv::Mat dist_coef(1, 8, CV_32F, cv::Scalar::all(0));\r
+\r
+ std::vector<cv::Point2f> image_vec;\r
+ cv::Mat rvec_gold(1, 3, CV_32FC1);\r
+ fill(rvec_gold, 0, 1);\r
+ cv::Mat tvec_gold(1, 3, CV_32FC1);\r
+ fill(tvec_gold, 0, 1);\r
+ cv::projectPoints(object, rvec_gold, tvec_gold, camera_mat, dist_coef, image_vec);\r
+\r
+ cv::Mat image(1, count, CV_32FC2, &image_vec[0]);\r
+\r
+ cv::Mat rvec;\r
+ cv::Mat tvec;\r
+\r
+ cv::gpu::solvePnPRansac(object, image, camera_mat, dist_coef, rvec, tvec);\r
+\r
+ declare.time(3.0);\r
\r
TEST_CYCLE()\r
{\r
- bp(img_l, img_r, dst);\r
+ cv::gpu::solvePnPRansac(object, image, camera_mat, dist_coef, rvec, tvec);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(Calib3D, StereoConstantSpaceBP, ALL_DEVICES);\r
+INSTANTIATE_TEST_CASE_P(Calib3D, SolvePnPRansac, testing::Combine(\r
+ ALL_DEVICES,\r
+ testing::Values<Count>(5000, 10000, 20000)));\r
\r
//////////////////////////////////////////////////////////////////////\r
-// DisparityBilateralFilter\r
+// ReprojectImageTo3D\r
\r
-GPU_PERF_TEST_1(DisparityBilateralFilter, cv::gpu::DeviceInfo)\r
+GPU_PERF_TEST(ReprojectImageTo3D, cv::gpu::DeviceInfo, cv::Size, MatDepth)\r
{\r
- cv::gpu::DeviceInfo devInfo = GetParam();\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+\r
+ cv::Mat src_host(size, depth);\r
+ fill(src_host, 5.0, 30.0);\r
+\r
+ cv::Mat Q(4, 4, CV_32FC1);\r
+ fill(Q, 0.1, 1.0);\r
+\r
+ cv::gpu::GpuMat src(src_host);\r
+ cv::gpu::GpuMat dst;\r
+\r
+ cv::gpu::reprojectImageTo3D(src, dst, Q);\r
\r
+ TEST_CYCLE()\r
+ {\r
+ cv::gpu::reprojectImageTo3D(src, dst, Q);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Calib3D, ReprojectImageTo3D, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16S)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// DrawColorDisp\r
+\r
+GPU_PERF_TEST(DrawColorDisp, cv::gpu::DeviceInfo, cv::Size, MatDepth)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
cv::gpu::setDevice(devInfo.deviceID());\r
\r
- cv::Mat img_host = readImage("gpu/stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE);\r
- cv::Mat disp_host = readImage("gpu/stereobm/aloe-disp.png", cv::IMREAD_GRAYSCALE);\r
+ cv::Size size = GET_PARAM(1);\r
+ int type = GET_PARAM(2);\r
\r
- ASSERT_FALSE(img_host.empty());\r
- ASSERT_FALSE(disp_host.empty());\r
+ cv::Mat src_host(size, type);\r
+ fill(src_host, 0, 255);\r
\r
- cv::gpu::GpuMat img(img_host);\r
- cv::gpu::GpuMat disp(disp_host);\r
+ cv::gpu::GpuMat src(src_host);\r
cv::gpu::GpuMat dst;\r
\r
- cv::gpu::DisparityBilateralFilter f(128);\r
+ cv::gpu::drawColorDisp(src, dst, 255);\r
\r
TEST_CYCLE()\r
{\r
- f(disp, img, dst);\r
+ cv::gpu::drawColorDisp(src, dst, 255);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(Calib3D, DisparityBilateralFilter, ALL_DEVICES);\r
+INSTANTIATE_TEST_CASE_P(Calib3D, DrawColorDisp, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values(MatDepth(CV_8U), MatDepth(CV_16S))));\r
\r
#endif\r
\r
--- /dev/null
+#include "perf_precomp.hpp"\r
+\r
+#ifdef HAVE_CUDA\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Merge\r
+\r
+GPU_PERF_TEST(Merge, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+ int channels = GET_PARAM(3);\r
+\r
+ std::vector<cv::gpu::GpuMat> src(channels);\r
+ for (int i = 0; i < channels; ++i)\r
+ src[i] = cv::gpu::GpuMat(size, depth, cv::Scalar::all(i));\r
+\r
+ cv::gpu::GpuMat dst;\r
+\r
+ cv::gpu::merge(src, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::gpu::merge(src, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Merge, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F, CV_64F),\r
+ testing::Values<Channels>(2, 3, 4)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Split\r
+\r
+GPU_PERF_TEST(Split, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+ int channels = GET_PARAM(3);\r
+\r
+ cv::gpu::GpuMat src(size, CV_MAKE_TYPE(depth, channels), cv::Scalar(1, 2, 3, 4));\r
+\r
+ std::vector<cv::gpu::GpuMat> dst;\r
+\r
+ cv::gpu::split(src, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::gpu::split(src, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Split, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F, CV_64F),\r
+ testing::Values<Channels>(2, 3, 4)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Add_Mat\r
+\r
+GPU_PERF_TEST(Add_Mat, cv::gpu::DeviceInfo, cv::Size, MatDepth)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+\r
+ cv::Mat src1_host(size, depth);\r
+ fill(src1_host, 0.0, 100.0);\r
+\r
+ cv::Mat src2_host(size, depth);\r
+ fill(src2_host, 0.0, 100.0);\r
+\r
+ cv::gpu::GpuMat src1(src1_host);\r
+ cv::gpu::GpuMat src2(src2_host);\r
+ cv::gpu::GpuMat dst;\r
+\r
+ cv::gpu::add(src1, src2, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::gpu::add(src1, src2, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Add_Mat, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F, CV_64F)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Add_Scalar\r
+\r
+GPU_PERF_TEST(Add_Scalar, cv::gpu::DeviceInfo, cv::Size, MatDepth)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+\r
+ cv::Mat src_host(size, depth);\r
+ fill(src_host, 0.0, 100.0);\r
+\r
+ cv::gpu::GpuMat src(src_host);\r
+ cv::Scalar s(1, 2, 3, 4);\r
+ cv::gpu::GpuMat dst;\r
+\r
+ cv::gpu::add(src, s, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::gpu::add(src, s, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Add_Scalar, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F, CV_64F)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Subtract_Mat\r
+\r
+GPU_PERF_TEST(Subtract_Mat, cv::gpu::DeviceInfo, cv::Size, MatDepth)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+\r
+ cv::Mat src1_host(size, depth);\r
+ fill(src1_host, 0.0, 100.0);\r
+\r
+ cv::Mat src2_host(size, depth);\r
+ fill(src2_host, 0.0, 100.0);\r
+\r
+ cv::gpu::GpuMat src1(src1_host);\r
+ cv::gpu::GpuMat src2(src2_host);\r
+ cv::gpu::GpuMat dst;\r
+\r
+ cv::gpu::subtract(src1, src2, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::gpu::subtract(src1, src2, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Subtract_Mat, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F, CV_64F)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Subtract_Scalar\r
+\r
+GPU_PERF_TEST(Subtract_Scalar, cv::gpu::DeviceInfo, cv::Size, MatDepth)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+\r
+ cv::Mat src_host(size, depth);\r
+ fill(src_host, 0.0, 100.0);\r
+\r
+ cv::gpu::GpuMat src(src_host);\r
+ cv::Scalar s(1, 2, 3, 4);\r
+ cv::gpu::GpuMat dst;\r
+\r
+ cv::gpu::subtract(src, s, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::gpu::subtract(src, s, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Subtract_Scalar, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F, CV_64F)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Multiply_Mat\r
+\r
+GPU_PERF_TEST(Multiply_Mat, cv::gpu::DeviceInfo, cv::Size, MatDepth)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+\r
+ cv::Mat src1_host(size, depth);\r
+ fill(src1_host, 0.0, 100.0);\r
+\r
+ cv::Mat src2_host(size, depth);\r
+ fill(src2_host, 0.0, 100.0);\r
+\r
+ cv::gpu::GpuMat src1(src1_host);\r
+ cv::gpu::GpuMat src2(src2_host);\r
+ cv::gpu::GpuMat dst;\r
+\r
+ cv::gpu::multiply(src1, src2, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::gpu::multiply(src1, src2, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Multiply_Mat, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F, CV_64F)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Multiply_Scalar\r
+\r
+GPU_PERF_TEST(Multiply_Scalar, cv::gpu::DeviceInfo, cv::Size, MatDepth)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+\r
+ cv::Mat src_host(size, depth);\r
+ fill(src_host, 0.0, 100.0);\r
+\r
+ cv::gpu::GpuMat src(src_host);\r
+ cv::Scalar s(1, 2, 3, 4);\r
+ cv::gpu::GpuMat dst;\r
+\r
+ cv::gpu::multiply(src, s, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::gpu::multiply(src, s, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Multiply_Scalar, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F, CV_64F)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Divide_Mat\r
+\r
+GPU_PERF_TEST(Divide_Mat, cv::gpu::DeviceInfo, cv::Size, MatDepth)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+\r
+ cv::Mat src1_host(size, depth);\r
+ fill(src1_host, 0.0, 100.0);\r
+\r
+ cv::Mat src2_host(size, depth);\r
+ fill(src2_host, 0.0, 100.0);\r
+\r
+ cv::gpu::GpuMat src1(src1_host);\r
+ cv::gpu::GpuMat src2(src2_host);\r
+ cv::gpu::GpuMat dst;\r
+\r
+ cv::gpu::divide(src1, src2, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::gpu::divide(src1, src2, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Divide_Mat, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F, CV_64F)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Divide_Scalar\r
+\r
+GPU_PERF_TEST(Divide_Scalar, cv::gpu::DeviceInfo, cv::Size, MatDepth)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+\r
+ cv::Mat src_host(size, depth);\r
+ fill(src_host, 0.0, 100.0);\r
+\r
+ cv::gpu::GpuMat src(src_host);\r
+ cv::Scalar s(1, 2, 3, 4);\r
+ cv::gpu::GpuMat dst;\r
+\r
+ cv::gpu::divide(src, s, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::gpu::divide(src, s, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Divide_Scalar, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F, CV_64F)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Divide_Scalar_Inv\r
+\r
+GPU_PERF_TEST(Divide_Scalar_Inv, cv::gpu::DeviceInfo, cv::Size, MatDepth)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+\r
+ cv::Mat src_host(size, depth);\r
+ fill(src_host, 0.0, 100.0);\r
+\r
+ cv::gpu::GpuMat src(src_host);\r
+ double scale = 100.0;\r
+ cv::gpu::GpuMat dst;\r
+\r
+ cv::gpu::divide(scale, src, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::gpu::divide(scale, src, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Divide_Scalar_Inv, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F, CV_64F)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// AbsDiff_Mat\r
+\r
+GPU_PERF_TEST(AbsDiff_Mat, cv::gpu::DeviceInfo, cv::Size, MatDepth)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+\r
+ cv::Mat src1_host(size, depth);\r
+ fill(src1_host, 0.0, 100.0);\r
+\r
+ cv::Mat src2_host(size, depth);\r
+ fill(src2_host, 0.0, 100.0);\r
+\r
+ cv::gpu::GpuMat src1(src1_host);\r
+ cv::gpu::GpuMat src2(src2_host);\r
+ cv::gpu::GpuMat dst;\r
+\r
+ cv::gpu::absdiff(src1, src2, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::gpu::absdiff(src1, src2, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, AbsDiff_Mat, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F, CV_64F)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// AbsDiff_Scalar\r
+\r
+GPU_PERF_TEST(AbsDiff_Scalar, cv::gpu::DeviceInfo, cv::Size, MatDepth)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+\r
+ cv::Mat src_host(size, depth);\r
+ fill(src_host, 0.0, 100.0);\r
+\r
+ cv::gpu::GpuMat src(src_host);\r
+ cv::Scalar s(1, 2, 3, 4);\r
+ cv::gpu::GpuMat dst;\r
+\r
+ cv::gpu::absdiff(src, s, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::gpu::absdiff(src, s, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, AbsDiff_Scalar, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F, CV_64F)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Abs\r
+\r
+GPU_PERF_TEST(Abs, cv::gpu::DeviceInfo, cv::Size, MatDepth)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+\r
+ cv::Mat src_host(size, depth);\r
+ fill(src_host, 0.0, 100.0);\r
+\r
+ cv::gpu::GpuMat src(src_host);\r
+ cv::gpu::GpuMat dst;\r
+\r
+ cv::gpu::abs(src, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::gpu::abs(src, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Abs, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_16S, CV_32F)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Sqr\r
+\r
+GPU_PERF_TEST(Sqr, cv::gpu::DeviceInfo, cv::Size, MatDepth)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+\r
+ cv::Mat src_host(size, depth);\r
+ fill(src_host, 0.0, 100.0);\r
+\r
+ cv::gpu::GpuMat src(src_host);\r
+ cv::gpu::GpuMat dst;\r
+\r
+ cv::gpu::sqr(src, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::gpu::sqr(src, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Sqr, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16S, CV_32F)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Sqrt\r
+\r
+GPU_PERF_TEST(Sqrt, cv::gpu::DeviceInfo, cv::Size, MatDepth)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+\r
+ cv::Mat src_host(size, depth);\r
+ fill(src_host, 0.0, 100.0);\r
+\r
+ cv::gpu::GpuMat src(src_host);\r
+ cv::gpu::GpuMat dst;\r
+\r
+ cv::gpu::sqrt(src, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::gpu::sqrt(src, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Sqrt, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16S, CV_32F)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Log\r
+\r
+GPU_PERF_TEST(Log, cv::gpu::DeviceInfo, cv::Size, MatDepth)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+\r
+ cv::Mat src_host(size, depth);\r
+ fill(src_host, 1.0, 100.0);\r
+\r
+ cv::gpu::GpuMat src(src_host);\r
+ cv::gpu::GpuMat dst;\r
+\r
+ cv::gpu::log(src, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::gpu::log(src, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Log, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16S, CV_32F)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Exp\r
+\r
+GPU_PERF_TEST(Exp, cv::gpu::DeviceInfo, cv::Size, MatDepth)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+\r
+ cv::Mat src_host(size, depth);\r
+ fill(src_host, 1.0, 10.0);\r
+\r
+ cv::gpu::GpuMat src(src_host);\r
+ cv::gpu::GpuMat dst;\r
+\r
+ cv::gpu::exp(src, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::gpu::exp(src, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Exp, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16S, CV_32F)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Pow\r
+\r
+GPU_PERF_TEST(Pow, cv::gpu::DeviceInfo, cv::Size, MatDepth)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+\r
+ cv::Mat src_host(size, depth);\r
+ fill(src_host, 1.0, 10.0);\r
+\r
+ cv::gpu::GpuMat src(src_host);\r
+ cv::gpu::GpuMat dst;\r
+\r
+ cv::gpu::pow(src, 2.3, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::gpu::pow(src, 2.3, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Pow, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16S, CV_32F)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Compare_Mat\r
+\r
+CV_ENUM(CmpCode, cv::CMP_EQ, cv::CMP_GT, cv::CMP_GE, cv::CMP_LT, cv::CMP_LE, cv::CMP_NE)\r
+#define ALL_CMP_CODES testing::Values(CmpCode(cv::CMP_EQ), CmpCode(cv::CMP_NE), CmpCode(cv::CMP_GT), CmpCode(cv::CMP_GE), CmpCode(cv::CMP_LT), CmpCode(cv::CMP_LE))\r
+\r
+GPU_PERF_TEST(Compare_Mat, cv::gpu::DeviceInfo, cv::Size, MatDepth, CmpCode)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+ int cmp_code = GET_PARAM(3);\r
+\r
+ cv::Mat src1_host(size, depth);\r
+ fill(src1_host, 0, 100.0);\r
+\r
+ cv::Mat src2_host(size, depth);\r
+ fill(src2_host, 0, 100.0);\r
+\r
+ cv::gpu::GpuMat src1(src1_host);\r
+ cv::gpu::GpuMat src2(src2_host);\r
+ cv::gpu::GpuMat dst;\r
+\r
+ cv::gpu::compare(src1, src2, dst, cmp_code);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::gpu::compare(src1, src2, dst, cmp_code);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Compare_Mat, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F, CV_64F),\r
+ ALL_CMP_CODES));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Compare_Scalar\r
+\r
+GPU_PERF_TEST(Compare_Scalar, cv::gpu::DeviceInfo, cv::Size, MatDepth, CmpCode)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+ int cmp_code = GET_PARAM(3);\r
+\r
+ cv::Mat src_host(size, depth);\r
+ fill(src_host, 0, 100.0);\r
+\r
+ cv::gpu::GpuMat src(src_host);\r
+ cv::Scalar s = cv::Scalar::all(50);\r
+ cv::gpu::GpuMat dst;\r
+\r
+ cv::gpu::compare(src, s, dst, cmp_code);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::gpu::compare(src, s, dst, cmp_code);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Compare_Scalar, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F, CV_64F),\r
+ ALL_CMP_CODES));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Bitwise_Not\r
+\r
+GPU_PERF_TEST(Bitwise_Not, cv::gpu::DeviceInfo, cv::Size, MatDepth)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+\r
+ cv::Mat src_host(size, depth);\r
+ fill(src_host, 0, 100.0);\r
+\r
+ cv::gpu::GpuMat src(src_host);\r
+ cv::gpu::GpuMat dst;\r
+\r
+ cv::gpu::bitwise_not(src, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::gpu::bitwise_not(src, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Bitwise_Not, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32S)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Bitwise_And_Mat\r
+\r
+GPU_PERF_TEST(Bitwise_And_Mat, cv::gpu::DeviceInfo, cv::Size, MatDepth)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+\r
+ cv::Mat src1_host(size, depth);\r
+ fill(src1_host, 0, 100.0);\r
+\r
+ cv::Mat src2_host(size, depth);\r
+ fill(src2_host, 0, 100.0);\r
+\r
+ cv::gpu::GpuMat src1(src1_host);\r
+ cv::gpu::GpuMat src2(src2_host);\r
+ cv::gpu::GpuMat dst;\r
+\r
+ cv::gpu::bitwise_and(src1, src2, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::gpu::bitwise_and(src1, src2, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Bitwise_And_Mat, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32S)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Bitwise_And_Scalar\r
+\r
+GPU_PERF_TEST(Bitwise_And_Scalar, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+ int channels = GET_PARAM(3);\r
+\r
+ int type = CV_MAKE_TYPE(depth, channels);\r
+\r
+ cv::Mat src_host(size, type);\r
+ fill(src_host, 0, 100.0);\r
+\r
+ cv::gpu::GpuMat src(src_host);\r
+ cv::Scalar s = cv::Scalar(50, 50, 50, 50);\r
+ cv::gpu::GpuMat dst;\r
+\r
+ cv::gpu::bitwise_and(src, s, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::gpu::bitwise_and(src, s, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Bitwise_And_Scalar, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32S),\r
+ testing::Values<Channels>(1, 3, 4)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Bitwise_Or_Mat\r
+\r
+GPU_PERF_TEST(Bitwise_Or_Mat, cv::gpu::DeviceInfo, cv::Size, MatDepth)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+\r
+ cv::Mat src1_host(size, depth);\r
+ fill(src1_host, 0, 100.0);\r
+\r
+ cv::Mat src2_host(size, depth);\r
+ fill(src2_host, 0, 100.0);\r
+\r
+ cv::gpu::GpuMat src1(src1_host);\r
+ cv::gpu::GpuMat src2(src2_host);\r
+ cv::gpu::GpuMat dst;\r
+\r
+ cv::gpu::bitwise_or(src1, src2, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::gpu::bitwise_or(src1, src2, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Bitwise_Or_Mat, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32S)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Bitwise_Or_Scalar\r
+\r
+GPU_PERF_TEST(Bitwise_Or_Scalar, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+ int channels = GET_PARAM(3);\r
+\r
+ int type = CV_MAKE_TYPE(depth, channels);\r
+\r
+ cv::Mat src_host(size, type);\r
+ fill(src_host, 0, 100.0);\r
+\r
+ cv::gpu::GpuMat src(src_host);\r
+ cv::Scalar s = cv::Scalar(50, 50, 50, 50);\r
+ cv::gpu::GpuMat dst;\r
+\r
+ cv::gpu::bitwise_or(src, s, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::gpu::bitwise_or(src, s, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Bitwise_Or_Scalar, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32S),\r
+ testing::Values<Channels>(1, 3, 4)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Bitwise_Xor_Mat\r
+\r
+GPU_PERF_TEST(Bitwise_Xor_Mat, cv::gpu::DeviceInfo, cv::Size, MatDepth)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+\r
+ cv::Mat src1_host(size, depth);\r
+ fill(src1_host, 0, 100.0);\r
+\r
+ cv::Mat src2_host(size, depth);\r
+ fill(src2_host, 0, 100.0);\r
+\r
+ cv::gpu::GpuMat src1(src1_host);\r
+ cv::gpu::GpuMat src2(src2_host);\r
+ cv::gpu::GpuMat dst;\r
+\r
+ cv::gpu::bitwise_xor(src1, src2, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::gpu::bitwise_xor(src1, src2, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Bitwise_Xor_Mat, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32S)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Bitwise_Xor_Scalar\r
+\r
+GPU_PERF_TEST(Bitwise_Xor_Scalar, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+ int channels = GET_PARAM(3);\r
+\r
+ int type = CV_MAKE_TYPE(depth, channels);\r
+\r
+ cv::Mat src_host(size, type);\r
+ fill(src_host, 0, 100.0);\r
+\r
+ cv::gpu::GpuMat src(src_host);\r
+ cv::Scalar s = cv::Scalar(50, 50, 50, 50);\r
+ cv::gpu::GpuMat dst;\r
+\r
+ cv::gpu::bitwise_xor(src, s, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::gpu::bitwise_xor(src, s, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Bitwise_Xor_Scalar, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32S),\r
+ testing::Values<Channels>(1, 3, 4)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// RShift\r
+\r
+GPU_PERF_TEST(RShift, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+ int channels = GET_PARAM(3);\r
+\r
+ int type = CV_MAKE_TYPE(depth, channels);\r
+\r
+ cv::Mat src_host(size, type);\r
+ fill(src_host, 0, 255.0);\r
+\r
+ cv::gpu::GpuMat src(src_host);\r
+ cv::Scalar_<int> val = cv::Scalar_<int>::all(4);\r
+ cv::gpu::GpuMat dst;\r
+\r
+ cv::gpu::rshift(src, val, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::gpu::rshift(src, val, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, RShift, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32S),\r
+ testing::Values<Channels>(1, 3, 4)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// LShift\r
+\r
+GPU_PERF_TEST(LShift, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+ int channels = GET_PARAM(3);\r
+\r
+ int type = CV_MAKE_TYPE(depth, channels);\r
+\r
+ cv::Mat src_host(size, type);\r
+ fill(src_host, 0, 255.0);\r
+\r
+ cv::gpu::GpuMat src(src_host);\r
+ cv::Scalar_<int> val = cv::Scalar_<int>::all(4);\r
+ cv::gpu::GpuMat dst;\r
+\r
+ cv::gpu::lshift(src, val, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::gpu::lshift(src, val, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, LShift, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32S),\r
+ testing::Values<Channels>(1, 3, 4)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Min_Mat\r
+\r
+GPU_PERF_TEST(Min_Mat, cv::gpu::DeviceInfo, cv::Size, MatDepth)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+\r
+ cv::Mat src1_host(size, depth);\r
+ fill(src1_host, 0, 255.0);\r
+\r
+ cv::Mat src2_host(size, depth);\r
+ fill(src2_host, 0, 255.0);\r
+\r
+ cv::gpu::GpuMat src1(src1_host);\r
+ cv::gpu::GpuMat src2(src2_host);\r
+ cv::gpu::GpuMat dst;\r
+\r
+ cv::gpu::min(src1, src2, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::gpu::min(src1, src2, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Min_Mat, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Min_Scalar\r
+\r
+GPU_PERF_TEST(Min_Scalar, cv::gpu::DeviceInfo, cv::Size, MatDepth)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+\r
+ cv::Mat src_host(size, depth);\r
+ fill(src_host, 0, 255.0);\r
+\r
+ cv::gpu::GpuMat src(src_host);\r
+ double val = 50.0;\r
+ cv::gpu::GpuMat dst;\r
+\r
+ cv::gpu::min(src, val, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::gpu::min(src, val, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Min_Scalar, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Max_Mat\r
+\r
+GPU_PERF_TEST(Max_Mat, cv::gpu::DeviceInfo, cv::Size, MatDepth)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+\r
+ cv::Mat src1_host(size, depth);\r
+ fill(src1_host, 0, 255.0);\r
+\r
+ cv::Mat src2_host(size, depth);\r
+ fill(src2_host, 0, 255.0);\r
+\r
+ cv::gpu::GpuMat src1(src1_host);\r
+ cv::gpu::GpuMat src2(src2_host);\r
+ cv::gpu::GpuMat dst;\r
+\r
+ cv::gpu::max(src1, src2, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::gpu::max(src1, src2, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Max_Mat, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Max_Scalar\r
+\r
+GPU_PERF_TEST(Max_Scalar, cv::gpu::DeviceInfo, cv::Size, MatDepth)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+\r
+ cv::Mat src_host(size, depth);\r
+ fill(src_host, 0, 255.0);\r
+\r
+ cv::gpu::GpuMat src(src_host);\r
+ double val = 50.0;\r
+ cv::gpu::GpuMat dst;\r
+\r
+ cv::gpu::max(src, val, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::gpu::max(src, val, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Max_Scalar, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// AddWeighted\r
+\r
+GPU_PERF_TEST(AddWeighted, cv::gpu::DeviceInfo, cv::Size, MatDepth, MatDepth, MatDepth)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth1 = GET_PARAM(2);\r
+ int depth2 = GET_PARAM(3);\r
+ int dst_depth = GET_PARAM(4);\r
+\r
+ cv::Mat src1_host(size, depth1);\r
+ fill(src1_host, 0, 100.0);\r
+\r
+ cv::Mat src2_host(size, depth2);\r
+ fill(src2_host, 0, 100.0);\r
+\r
+ cv::gpu::GpuMat src1(src1_host);\r
+ cv::gpu::GpuMat src2(src2_host);\r
+ cv::gpu::GpuMat dst;\r
+\r
+ cv::gpu::addWeighted(src1, 0.5, src2, 0.5, 10.0, dst, dst_depth);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::gpu::addWeighted(src1, 0.5, src2, 0.5, 10.0, dst, dst_depth);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, AddWeighted, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F, CV_64F),\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F, CV_64F),\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F, CV_64F)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// GEMM\r
+\r
+CV_FLAGS(GemmFlags, 0, cv::GEMM_1_T, cv::GEMM_2_T, cv::GEMM_3_T)\r
+#define ALL_GEMM_FLAGS testing::Values(GemmFlags(0), GemmFlags(cv::GEMM_1_T), GemmFlags(cv::GEMM_2_T), GemmFlags(cv::GEMM_3_T), GemmFlags(cv::GEMM_1_T | cv::GEMM_2_T), GemmFlags(cv::GEMM_1_T | cv::GEMM_3_T), GemmFlags(cv::GEMM_1_T | cv::GEMM_2_T | cv::GEMM_3_T))\r
+\r
+GPU_PERF_TEST(GEMM, cv::gpu::DeviceInfo, cv::Size, MatType, GemmFlags)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
+ cv::Size size = GET_PARAM(1);\r
+ int type = GET_PARAM(2);\r
+ int flags = GET_PARAM(3);\r
+\r
+ cv::Mat src1_host(size, type);\r
+ fill(src1_host, 0.0, 10.0);\r
+\r
+ cv::Mat src2_host(size, type);\r
+ fill(src2_host, 0.0, 10.0);\r
+\r
+ cv::Mat src3_host(size, type);\r
+ fill(src3_host, 0.0, 10.0);\r
+\r
+ cv::gpu::GpuMat src1(src1_host);\r
+ cv::gpu::GpuMat src2(src2_host);\r
+ cv::gpu::GpuMat src3(src3_host);\r
+ cv::gpu::GpuMat dst;\r
+\r
+ cv::gpu::gemm(src1, src2, 1.0, src3, 1.0, dst, flags);\r
+\r
+ declare.time(5.0);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::gpu::gemm(src1, src2, 1.0, src3, 1.0, dst, flags);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, GEMM, testing::Combine(\r
+ ALL_DEVICES,\r
+ testing::Values(cv::Size(512, 512), cv::Size(1024, 1024)),\r
+ testing::Values<MatType>(CV_32FC1, CV_32FC2, CV_64FC1, CV_64FC2),\r
+ ALL_GEMM_FLAGS));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Transpose\r
+\r
+GPU_PERF_TEST(Transpose, cv::gpu::DeviceInfo, cv::Size, MatType)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
+ cv::Size size = GET_PARAM(1);\r
+ int type = GET_PARAM(2);\r
+\r
+ cv::Mat src_host(size, type);\r
+ fill(src_host, 0.0, 100.0);\r
+\r
+ cv::gpu::GpuMat src(src_host);\r
+ cv::gpu::GpuMat dst;\r
+\r
+ cv::gpu::transpose(src, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::gpu::transpose(src, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Transpose, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatType>(CV_8UC1, CV_8UC4, CV_16UC2, CV_16SC2, CV_32SC1, CV_32SC2, CV_64FC1)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Flip\r
+\r
+enum {FLIP_BOTH = 0, FLIP_X = 1, FLIP_Y = -1};\r
+CV_ENUM(FlipCode, FLIP_BOTH, FLIP_X, FLIP_Y)\r
+#define ALL_FLIP_CODES testing::Values(FlipCode(FLIP_BOTH), FlipCode(FLIP_X), FlipCode(FLIP_Y))\r
+\r
+GPU_PERF_TEST(Flip, cv::gpu::DeviceInfo, cv::Size, MatType, FlipCode)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
+ cv::Size size = GET_PARAM(1);\r
+ int type = GET_PARAM(2);\r
+ int flipCode = GET_PARAM(3);\r
+\r
+ cv::Mat src_host(size, type);\r
+ fill(src_host, 0.0, 100.0);\r
+\r
+ cv::gpu::GpuMat src(src_host);\r
+ cv::gpu::GpuMat dst;\r
+\r
+ cv::gpu::flip(src, dst, flipCode);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::gpu::flip(src, dst, flipCode);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Flip, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatType>(CV_8UC1, CV_8UC3, CV_8UC4, CV_16UC1, CV_16UC3, CV_16UC4, CV_32FC1, CV_32FC3, CV_32FC4),\r
+ ALL_FLIP_CODES));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// LUT_OneChannel\r
+\r
+GPU_PERF_TEST(LUT_OneChannel, cv::gpu::DeviceInfo, cv::Size, MatType)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
+ cv::Size size = GET_PARAM(1);\r
+ int type = GET_PARAM(2);\r
+\r
+ cv::Mat src_host(size, type);\r
+ fill(src_host, 0.0, 100.0);\r
+\r
+ cv::Mat lut(1, 256, CV_8UC1);\r
+ fill(lut, 0.0, 100.0);\r
+\r
+ cv::gpu::GpuMat src(src_host);\r
+ cv::gpu::GpuMat dst;\r
+\r
+ cv::gpu::LUT(src, lut, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::gpu::LUT(src, lut, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, LUT_OneChannel, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatType>(CV_8UC1, CV_8UC3)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// LUT_MultiChannel\r
+\r
+GPU_PERF_TEST(LUT_MultiChannel, cv::gpu::DeviceInfo, cv::Size, MatType)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
+ cv::Size size = GET_PARAM(1);\r
+ int type = GET_PARAM(2);\r
+\r
+ cv::Mat src_host(size, type);\r
+ fill(src_host, 0.0, 100.0);\r
+\r
+ cv::Mat lut(1, 256, CV_MAKE_TYPE(CV_8U, src_host.channels()));\r
+ fill(lut, 0.0, 100.0);\r
+\r
+ cv::gpu::GpuMat src(src_host);\r
+ cv::gpu::GpuMat dst;\r
+\r
+ cv::gpu::LUT(src, lut, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::gpu::LUT(src, lut, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, LUT_MultiChannel, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatType>(CV_8UC3)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Magnitude_Complex\r
+\r
+GPU_PERF_TEST(Magnitude_Complex, cv::gpu::DeviceInfo, cv::Size)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
+ cv::Size size = GET_PARAM(1);\r
+\r
+ cv::Mat src_host(size, CV_32FC2);\r
+ fill(src_host, -100.0, 100.0);\r
+\r
+ cv::gpu::GpuMat src(src_host);\r
+ cv::gpu::GpuMat dst;\r
+\r
+ cv::gpu::magnitude(src, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::gpu::magnitude(src, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Magnitude_Complex, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Magnitude_Sqr_Complex\r
+\r
+GPU_PERF_TEST(Magnitude_Sqr_Complex, cv::gpu::DeviceInfo, cv::Size)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
+ cv::Size size = GET_PARAM(1);\r
+\r
+ cv::Mat src_host(size, CV_32FC2);\r
+ fill(src_host, -100.0, 100.0);\r
+\r
+ cv::gpu::GpuMat src(src_host);\r
+ cv::gpu::GpuMat dst;\r
+\r
+ cv::gpu::magnitudeSqr(src, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::gpu::magnitudeSqr(src, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Magnitude_Sqr_Complex, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Magnitude\r
+\r
+GPU_PERF_TEST(Magnitude, cv::gpu::DeviceInfo, cv::Size)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
+ cv::Size size = GET_PARAM(1);\r
+\r
+ cv::Mat src1_host(size, CV_32FC1);\r
+ fill(src1_host, -100.0, 100.0);\r
+\r
+ cv::Mat src2_host(size, CV_32FC1);\r
+ fill(src2_host, -100.0, 100.0);\r
+\r
+ cv::gpu::GpuMat src1(src1_host);\r
+ cv::gpu::GpuMat src2(src2_host);\r
+ cv::gpu::GpuMat dst;\r
+\r
+ cv::gpu::magnitude(src1, src2, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::gpu::magnitude(src1, src2, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Magnitude, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Magnitude_Sqr\r
+\r
+GPU_PERF_TEST(Magnitude_Sqr, cv::gpu::DeviceInfo, cv::Size)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
+ cv::Size size = GET_PARAM(1);\r
+\r
+ cv::Mat src1_host(size, CV_32FC1);\r
+ fill(src1_host, -100.0, 100.0);\r
+\r
+ cv::Mat src2_host(size, CV_32FC1);\r
+ fill(src2_host, -100.0, 100.0);\r
+\r
+ cv::gpu::GpuMat src1(src1_host);\r
+ cv::gpu::GpuMat src2(src2_host);\r
+ cv::gpu::GpuMat dst;\r
+\r
+ cv::gpu::magnitudeSqr(src1, src2, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::gpu::magnitudeSqr(src1, src2, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Magnitude_Sqr, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Phase\r
+\r
+IMPLEMENT_PARAM_CLASS(AngleInDegrees, bool)\r
+\r
+GPU_PERF_TEST(Phase, cv::gpu::DeviceInfo, cv::Size, AngleInDegrees)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
+ cv::Size size = GET_PARAM(1);\r
+ bool angleInDegrees = GET_PARAM(2);\r
+\r
+ cv::Mat src1_host(size, CV_32FC1);\r
+ fill(src1_host, -100.0, 100.0);\r
+\r
+ cv::Mat src2_host(size, CV_32FC1);\r
+ fill(src2_host, -100.0, 100.0);\r
+\r
+ cv::gpu::GpuMat src1(src1_host);\r
+ cv::gpu::GpuMat src2(src2_host);\r
+ cv::gpu::GpuMat dst;\r
+\r
+ cv::gpu::phase(src1, src2, dst, angleInDegrees);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::gpu::phase(src1, src2, dst, angleInDegrees);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Phase, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<AngleInDegrees>(false, true)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// CartToPolar\r
+\r
+GPU_PERF_TEST(CartToPolar, cv::gpu::DeviceInfo, cv::Size, AngleInDegrees)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
+ cv::Size size = GET_PARAM(1);\r
+ bool angleInDegrees = GET_PARAM(2);\r
+\r
+ cv::Mat src1_host(size, CV_32FC1);\r
+ fill(src1_host, -100.0, 100.0);\r
+\r
+ cv::Mat src2_host(size, CV_32FC1);\r
+ fill(src2_host, -100.0, 100.0);\r
+\r
+ cv::gpu::GpuMat src1(src1_host);\r
+ cv::gpu::GpuMat src2(src2_host);\r
+ cv::gpu::GpuMat magnitude;\r
+ cv::gpu::GpuMat angle;\r
+\r
+ cv::gpu::cartToPolar(src1, src2, magnitude, angle, angleInDegrees);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::gpu::cartToPolar(src1, src2, magnitude, angle, angleInDegrees);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, CartToPolar, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<AngleInDegrees>(false, true)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// PolarToCart\r
+\r
+GPU_PERF_TEST(PolarToCart, cv::gpu::DeviceInfo, cv::Size, AngleInDegrees)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
+ cv::Size size = GET_PARAM(1);\r
+ bool angleInDegrees = GET_PARAM(2);\r
+\r
+ cv::Mat magnitude_host(size, CV_32FC1);\r
+ fill(magnitude_host, 0.0, 100.0);\r
+\r
+ cv::Mat angle_host(size, CV_32FC1);\r
+ fill(angle_host, 0.0, angleInDegrees ? 360.0 : 2 * CV_PI);\r
+\r
+ cv::gpu::GpuMat magnitude(magnitude_host);\r
+ cv::gpu::GpuMat angle(angle_host);\r
+ cv::gpu::GpuMat x;\r
+ cv::gpu::GpuMat y;\r
+\r
+ cv::gpu::polarToCart(magnitude, angle, x, y, angleInDegrees);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::gpu::polarToCart(magnitude, angle, x, y, angleInDegrees);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, PolarToCart, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<AngleInDegrees>(false, true)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// MeanStdDev\r
+\r
+GPU_PERF_TEST(MeanStdDev, cv::gpu::DeviceInfo, cv::Size)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
+ cv::Size size = GET_PARAM(1);\r
+\r
+ cv::Mat src_host(size, CV_8UC1);\r
+ fill(src_host, 0.0, 255.0);\r
+\r
+ cv::gpu::GpuMat src(src_host);\r
+ cv::Scalar mean;\r
+ cv::Scalar stddev;\r
+ cv::gpu::GpuMat buf;\r
+\r
+ cv::gpu::meanStdDev(src, mean, stddev, buf);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::gpu::meanStdDev(src, mean, stddev, buf);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, MeanStdDev, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Norm\r
+\r
+GPU_PERF_TEST(Norm, cv::gpu::DeviceInfo, cv::Size, MatDepth, NormType)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+ int normType = GET_PARAM(3);\r
+\r
+ cv::Mat src_host(size, depth);\r
+ fill(src_host, 0.0, 255.0);\r
+\r
+ cv::gpu::GpuMat src(src_host);\r
+ double dst;\r
+ cv::gpu::GpuMat buf;\r
+\r
+ dst = cv::gpu::norm(src, normType, buf);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ dst = cv::gpu::norm(src, normType, buf);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Norm, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32S, CV_32F),\r
+ testing::Values(NormType(cv::NORM_INF), NormType(cv::NORM_L1), NormType(cv::NORM_L2))));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// NormDiff\r
+\r
+GPU_PERF_TEST(NormDiff, cv::gpu::DeviceInfo, cv::Size, NormType)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
+ cv::Size size = GET_PARAM(1);\r
+ int normType = GET_PARAM(2);\r
+\r
+ cv::Mat src1_host(size, CV_8UC1);\r
+ fill(src1_host, 0.0, 255.0);\r
+\r
+ cv::Mat src2_host(size, CV_8UC1);\r
+ fill(src2_host, 0.0, 255.0);\r
+\r
+ cv::gpu::GpuMat src1(src1_host);\r
+ cv::gpu::GpuMat src2(src2_host);\r
+ double dst;\r
+\r
+ dst = cv::gpu::norm(src1, src2, normType);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ dst = cv::gpu::norm(src1, src2, normType);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, NormDiff, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values(NormType(cv::NORM_INF), NormType(cv::NORM_L1), NormType(cv::NORM_L2))));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Sum\r
+\r
+GPU_PERF_TEST(Sum, cv::gpu::DeviceInfo, cv::Size, MatType)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
+ cv::Size size = GET_PARAM(1);\r
+ int type = GET_PARAM(2);\r
+\r
+ cv::Mat src_host(size, type);\r
+ fill(src_host, 0.0, 255.0);\r
+\r
+ cv::gpu::GpuMat src(src_host);\r
+ cv::Scalar dst;\r
+ cv::gpu::GpuMat buf;\r
+\r
+ dst = cv::gpu::sum(src, buf);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ dst = cv::gpu::sum(src, buf);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Sum, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatType>(CV_8UC1, CV_8UC3, CV_8UC4, CV_16UC1, CV_16UC3, CV_16UC4, CV_32FC1, CV_32FC3, CV_32FC4)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Sum_Abs\r
+\r
+GPU_PERF_TEST(Sum_Abs, cv::gpu::DeviceInfo, cv::Size, MatType)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
+ cv::Size size = GET_PARAM(1);\r
+ int type = GET_PARAM(2);\r
+\r
+ cv::Mat src_host(size, type);\r
+ fill(src_host, 0.0, 255.0);\r
+\r
+ cv::gpu::GpuMat src(src_host);\r
+ cv::Scalar dst;\r
+ cv::gpu::GpuMat buf;\r
+\r
+ dst = cv::gpu::absSum(src, buf);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ dst = cv::gpu::absSum(src, buf);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Sum_Abs, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatType>(CV_8UC1, CV_8UC3, CV_8UC4, CV_16UC1, CV_16UC3, CV_16UC4, CV_32FC1, CV_32FC3, CV_32FC4)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Sum_Sqr\r
+\r
+GPU_PERF_TEST(Sum_Sqr, cv::gpu::DeviceInfo, cv::Size, MatType)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
+ cv::Size size = GET_PARAM(1);\r
+ int type = GET_PARAM(2);\r
+\r
+ cv::Mat src_host(size, type);\r
+ fill(src_host, 0.0, 255.0);\r
+\r
+ cv::gpu::GpuMat src(src_host);\r
+ cv::Scalar dst;\r
+ cv::gpu::GpuMat buf;\r
+\r
+ dst = cv::gpu::sqrSum(src, buf);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ dst = cv::gpu::sqrSum(src, buf);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Sum_Sqr, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatType>(CV_8UC1, CV_8UC3, CV_8UC4, CV_16UC1, CV_16UC3, CV_16UC4, CV_32FC1, CV_32FC3, CV_32FC4)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// MinMax\r
+\r
+GPU_PERF_TEST(MinMax, cv::gpu::DeviceInfo, cv::Size, MatDepth)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+\r
+ cv::Mat src_host(size, depth);\r
+ fill(src_host, 0.0, 255.0);\r
+\r
+ cv::gpu::GpuMat src(src_host);\r
+ double minVal, maxVal;\r
+ cv::gpu::GpuMat buf;\r
+\r
+ cv::gpu::minMax(src, &minVal, &maxVal, cv::gpu::GpuMat(), buf);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::gpu::minMax(src, &minVal, &maxVal, cv::gpu::GpuMat(), buf);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, MinMax, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F, CV_64F)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// MinMaxLoc\r
+\r
+GPU_PERF_TEST(MinMaxLoc, cv::gpu::DeviceInfo, cv::Size, MatDepth)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+\r
+ cv::Mat src_host(size, depth);\r
+ fill(src_host, 0.0, 255.0);\r
+\r
+ cv::gpu::GpuMat src(src_host);\r
+ double minVal, maxVal;\r
+ cv::Point minLoc, maxLoc;\r
+ cv::gpu::GpuMat valbuf, locbuf;\r
+\r
+ cv::gpu::minMaxLoc(src, &minVal, &maxVal, &minLoc, &maxLoc, cv::gpu::GpuMat(), valbuf, locbuf);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::gpu::minMaxLoc(src, &minVal, &maxVal, &minLoc, &maxLoc, cv::gpu::GpuMat(), valbuf, locbuf);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, MinMaxLoc, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F, CV_64F)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// CountNonZero\r
+\r
+GPU_PERF_TEST(CountNonZero, cv::gpu::DeviceInfo, cv::Size, MatDepth)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+\r
+ cv::Mat src_host(size, depth);\r
+ fill(src_host, 0.0, 1.5);\r
+\r
+ cv::gpu::GpuMat src(src_host);\r
+ int dst;\r
+ cv::gpu::GpuMat buf;\r
+\r
+ dst = cv::gpu::countNonZero(src, buf);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ dst = cv::gpu::countNonZero(src, buf);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, CountNonZero, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F, CV_64F)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Reduce\r
+\r
+CV_ENUM(ReduceCode, CV_REDUCE_SUM, CV_REDUCE_AVG, CV_REDUCE_MAX, CV_REDUCE_MIN)\r
+#define ALL_REDUCE_CODES testing::Values<ReduceCode>(CV_REDUCE_SUM, CV_REDUCE_AVG, CV_REDUCE_MAX, CV_REDUCE_MIN)\r
+\r
+enum {Rows = 0, Cols = 1};\r
+CV_ENUM(ReduceDim, Rows, Cols)\r
+\r
+GPU_PERF_TEST(Reduce, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, ReduceCode, ReduceDim)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+ int channels = GET_PARAM(3);\r
+ int reduceOp = GET_PARAM(4);\r
+ int dim = GET_PARAM(5);\r
+\r
+ int type = CV_MAKE_TYPE(depth, channels);\r
+\r
+ cv::Mat src_host(size, type);\r
+ fill(src_host, 0.0, 10.0);\r
+\r
+ cv::gpu::GpuMat src(src_host);\r
+ cv::gpu::GpuMat dst;\r
+\r
+ cv::gpu::reduce(src, dst, dim, reduceOp);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::gpu::reduce(src, dst, dim, reduceOp);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Reduce, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_16S, CV_32F),\r
+ testing::Values<Channels>(1, 2, 3, 4),\r
+ ALL_REDUCE_CODES,\r
+ testing::Values(ReduceDim(Rows), ReduceDim(Cols))));\r
+\r
+#endif\r
#ifdef HAVE_CUDA\r
\r
//////////////////////////////////////////////////////////////////////\r
-// BruteForceMatcher_match\r
+// SURF\r
\r
-GPU_PERF_TEST(BruteForceMatcher_match, cv::gpu::DeviceInfo, int)\r
+GPU_PERF_TEST_1(SURF, cv::gpu::DeviceInfo)\r
{\r
- cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- int desc_size = GET_PARAM(1);\r
-\r
+ cv::gpu::DeviceInfo devInfo = GetParam();\r
cv::gpu::setDevice(devInfo.deviceID());\r
\r
- cv::Mat query_host(3000, desc_size, CV_32FC1);\r
- cv::Mat train_host(3000, desc_size, CV_32FC1);\r
+ cv::Mat img_host = readImage("gpu/perf/aloe.jpg", cv::IMREAD_GRAYSCALE);\r
+ ASSERT_FALSE(img_host.empty());\r
\r
- declare.in(query_host, train_host, WARMUP_RNG);\r
+ cv::gpu::SURF_GPU surf;\r
\r
- cv::gpu::GpuMat query(query_host);\r
- cv::gpu::GpuMat train(train_host);\r
- cv::gpu::GpuMat trainIdx, distance;\r
+ cv::gpu::GpuMat img(img_host);\r
+ cv::gpu::GpuMat keypoints, descriptors;\r
\r
- cv::gpu::BFMatcher_GPU matcher(cv::NORM_L2);\r
+ surf(img, cv::gpu::GpuMat(), keypoints, descriptors);\r
\r
- declare.time(3.0);\r
+ declare.time(2.0);\r
\r
TEST_CYCLE()\r
{\r
- matcher.matchSingle(query, train, trainIdx, distance);\r
+ surf(img, cv::gpu::GpuMat(), keypoints, descriptors);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(Features2D, BruteForceMatcher_match, testing::Combine(\r
- ALL_DEVICES, \r
- testing::Values(64, 128, 256)));\r
+INSTANTIATE_TEST_CASE_P(Features2D, SURF, ALL_DEVICES);\r
\r
//////////////////////////////////////////////////////////////////////\r
-// BruteForceMatcher_knnMatch\r
+// FAST\r
\r
-GPU_PERF_TEST(BruteForceMatcher_knnMatch, cv::gpu::DeviceInfo, int, int)\r
+GPU_PERF_TEST_1(FAST, cv::gpu::DeviceInfo)\r
{\r
- cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- int desc_size = GET_PARAM(1);\r
- int k = GET_PARAM(2);\r
-\r
+ cv::gpu::DeviceInfo devInfo = GetParam();\r
cv::gpu::setDevice(devInfo.deviceID());\r
\r
- cv::Mat query_host(3000, desc_size, CV_32FC1);\r
- cv::Mat train_host(3000, desc_size, CV_32FC1);\r
+ cv::Mat img_host = readImage("gpu/perf/aloe.jpg", cv::IMREAD_GRAYSCALE);\r
+ ASSERT_FALSE(img_host.empty());\r
\r
- declare.in(query_host, train_host, WARMUP_RNG);\r
+ cv::gpu::FAST_GPU fast(20);\r
\r
- cv::gpu::GpuMat query(query_host);\r
- cv::gpu::GpuMat train(train_host);\r
- cv::gpu::GpuMat trainIdx, distance, allDist;\r
-\r
- cv::gpu::BFMatcher_GPU matcher(cv::NORM_L2);\r
+ cv::gpu::GpuMat img(img_host);\r
+ cv::gpu::GpuMat keypoints;\r
\r
- declare.time(3.0);\r
+ fast(img, cv::gpu::GpuMat(), keypoints);\r
\r
TEST_CYCLE()\r
{\r
- matcher.knnMatchSingle(query, train, trainIdx, distance, allDist, k);\r
+ fast(img, cv::gpu::GpuMat(), keypoints);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(Features2D, BruteForceMatcher_knnMatch, testing::Combine(\r
- ALL_DEVICES, \r
- testing::Values(64, 128, 256),\r
- testing::Values(2, 3)));\r
+INSTANTIATE_TEST_CASE_P(Features2D, FAST, ALL_DEVICES);\r
\r
//////////////////////////////////////////////////////////////////////\r
-// BruteForceMatcher_radiusMatch\r
+// ORB\r
\r
-GPU_PERF_TEST(BruteForceMatcher_radiusMatch, cv::gpu::DeviceInfo, int)\r
+GPU_PERF_TEST_1(ORB, cv::gpu::DeviceInfo)\r
{\r
- cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- int desc_size = GET_PARAM(1);\r
-\r
+ cv::gpu::DeviceInfo devInfo = GetParam();\r
cv::gpu::setDevice(devInfo.deviceID());\r
\r
- cv::Mat query_host(3000, desc_size, CV_32FC1);\r
- cv::Mat train_host(3000, desc_size, CV_32FC1);\r
-\r
- fill(query_host, 0, 1);\r
- fill(train_host, 0, 1);\r
-\r
- cv::gpu::GpuMat query(query_host);\r
- cv::gpu::GpuMat train(train_host);\r
- cv::gpu::GpuMat trainIdx, nMatches, distance;\r
+ cv::Mat img_host = readImage("gpu/perf/aloe.jpg", cv::IMREAD_GRAYSCALE);\r
+ ASSERT_FALSE(img_host.empty());\r
\r
- cv::gpu::BFMatcher_GPU matcher(cv::NORM_L2);\r
+ cv::gpu::ORB_GPU orb(4000);\r
\r
- declare.time(3.0);\r
+ cv::gpu::GpuMat img(img_host);\r
+ cv::gpu::GpuMat keypoints, descriptors;\r
\r
TEST_CYCLE()\r
{\r
- matcher.radiusMatchSingle(query, train, trainIdx, distance, nMatches, 2.0);\r
+ orb(img, cv::gpu::GpuMat(), keypoints, descriptors);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(Features2D, BruteForceMatcher_radiusMatch, testing::Combine(\r
- ALL_DEVICES, \r
- testing::Values(64, 128, 256)));\r
+INSTANTIATE_TEST_CASE_P(Features2D, ORB, ALL_DEVICES);\r
\r
//////////////////////////////////////////////////////////////////////\r
-// SURF\r
+// BruteForceMatcher_match\r
\r
-GPU_PERF_TEST_1(SURF, cv::gpu::DeviceInfo)\r
-{\r
- cv::gpu::DeviceInfo devInfo = GetParam();\r
+IMPLEMENT_PARAM_CLASS(DescriptorSize, int)\r
\r
+GPU_PERF_TEST(BruteForceMatcher_match, cv::gpu::DeviceInfo, DescriptorSize, NormType)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
cv::gpu::setDevice(devInfo.deviceID());\r
\r
- cv::Mat img_host = readImage("gpu/perf/aloe.jpg", cv::IMREAD_GRAYSCALE);\r
+ int desc_size = GET_PARAM(1);\r
+ int normType = GET_PARAM(2);\r
\r
- ASSERT_FALSE(img_host.empty());\r
+ int type = normType == cv::NORM_HAMMING ? CV_8U : CV_32F;\r
\r
- cv::gpu::GpuMat img(img_host);\r
- cv::gpu::GpuMat keypoints, descriptors;\r
+ cv::Mat query_host(3000, desc_size, type);\r
+ fill(query_host, 0.0, 10.0);\r
\r
- cv::gpu::SURF_GPU surf;\r
+ cv::Mat train_host(3000, desc_size, type);\r
+ fill(train_host, 0.0, 10.0);\r
\r
- declare.time(2.0);\r
+ cv::gpu::BFMatcher_GPU matcher(normType);\r
+\r
+ cv::gpu::GpuMat query(query_host);\r
+ cv::gpu::GpuMat train(train_host);\r
+ cv::gpu::GpuMat trainIdx, distance;\r
+\r
+ matcher.matchSingle(query, train, trainIdx, distance);\r
+\r
+ declare.time(3.0);\r
\r
TEST_CYCLE()\r
{\r
- surf(img, cv::gpu::GpuMat(), keypoints, descriptors);\r
+ matcher.matchSingle(query, train, trainIdx, distance);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(Features2D, SURF, DEVICES(cv::gpu::GLOBAL_ATOMICS));\r
+INSTANTIATE_TEST_CASE_P(Features2D, BruteForceMatcher_match, testing::Combine(\r
+ ALL_DEVICES,\r
+ testing::Values(DescriptorSize(64), DescriptorSize(128), DescriptorSize(256)),\r
+ testing::Values(NormType(cv::NORM_L1), NormType(cv::NORM_L2), NormType(cv::NORM_HAMMING))));\r
\r
//////////////////////////////////////////////////////////////////////\r
-// FAST\r
+// BruteForceMatcher_knnMatch\r
\r
-GPU_PERF_TEST_1(FAST, cv::gpu::DeviceInfo)\r
-{\r
- cv::gpu::DeviceInfo devInfo = GetParam();\r
+IMPLEMENT_PARAM_CLASS(K, int)\r
\r
+GPU_PERF_TEST(BruteForceMatcher_knnMatch, cv::gpu::DeviceInfo, DescriptorSize, K, NormType)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
cv::gpu::setDevice(devInfo.deviceID());\r
\r
- cv::Mat img_host = readImage("gpu/perf/aloe.jpg", cv::IMREAD_GRAYSCALE);\r
+ int desc_size = GET_PARAM(1);\r
+ int k = GET_PARAM(2);\r
+ int normType = GET_PARAM(3);\r
\r
- ASSERT_FALSE(img_host.empty());\r
+ int type = normType == cv::NORM_HAMMING ? CV_8U : CV_32F;\r
\r
- cv::gpu::GpuMat img(img_host);\r
- cv::gpu::GpuMat keypoints, descriptors;\r
+ cv::Mat query_host(3000, desc_size, type);\r
+ fill(query_host, 0.0, 10.0);\r
\r
- cv::gpu::FAST_GPU fastGPU(20);\r
+ cv::Mat train_host(3000, desc_size, type);\r
+ fill(train_host, 0.0, 10.0);\r
+\r
+ cv::gpu::BFMatcher_GPU matcher(normType);\r
+\r
+ cv::gpu::GpuMat query(query_host);\r
+ cv::gpu::GpuMat train(train_host);\r
+ cv::gpu::GpuMat trainIdx, distance, allDist;\r
+\r
+ matcher.knnMatchSingle(query, train, trainIdx, distance, allDist, k);\r
+\r
+ declare.time(3.0);\r
\r
TEST_CYCLE()\r
{\r
- fastGPU(img, cv::gpu::GpuMat(), keypoints);\r
+ matcher.knnMatchSingle(query, train, trainIdx, distance, allDist, k);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(Features2D, FAST, DEVICES(cv::gpu::GLOBAL_ATOMICS));\r
+INSTANTIATE_TEST_CASE_P(Features2D, BruteForceMatcher_knnMatch, testing::Combine(\r
+ ALL_DEVICES,\r
+ testing::Values(DescriptorSize(64), DescriptorSize(128), DescriptorSize(256)),\r
+ testing::Values(K(2), K(3)),\r
+ testing::Values(NormType(cv::NORM_L1), NormType(cv::NORM_L2), NormType(cv::NORM_HAMMING))));\r
\r
//////////////////////////////////////////////////////////////////////\r
-// ORB\r
+// BruteForceMatcher_radiusMatch\r
\r
-GPU_PERF_TEST_1(ORB, cv::gpu::DeviceInfo)\r
+GPU_PERF_TEST(BruteForceMatcher_radiusMatch, cv::gpu::DeviceInfo, DescriptorSize, NormType)\r
{\r
- cv::gpu::DeviceInfo devInfo = GetParam();\r
-\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
cv::gpu::setDevice(devInfo.deviceID());\r
\r
- cv::Mat img_host = readImage("gpu/perf/aloe.jpg", cv::IMREAD_GRAYSCALE);\r
+ int desc_size = GET_PARAM(1);\r
+ int normType = GET_PARAM(2);\r
\r
- ASSERT_FALSE(img_host.empty());\r
+ int type = normType == cv::NORM_HAMMING ? CV_8U : CV_32F;\r
\r
- cv::gpu::GpuMat img(img_host);\r
- cv::gpu::GpuMat keypoints, descriptors;\r
+ cv::Mat query_host(3000, desc_size, type);\r
+ fill(query_host, 0.0, 1.0);\r
+\r
+ cv::Mat train_host(3000, desc_size, type);\r
+ fill(train_host, 0.0, 1.0);\r
\r
- cv::gpu::ORB_GPU orbGPU(4000);\r
+ cv::gpu::BFMatcher_GPU matcher(normType);\r
+\r
+ cv::gpu::GpuMat query(query_host);\r
+ cv::gpu::GpuMat train(train_host);\r
+ cv::gpu::GpuMat trainIdx, nMatches, distance;\r
+\r
+ matcher.radiusMatchSingle(query, train, trainIdx, distance, nMatches, 2.0);\r
+\r
+ declare.time(3.0);\r
\r
TEST_CYCLE()\r
{\r
- orbGPU(img, cv::gpu::GpuMat(), keypoints, descriptors);\r
+ matcher.radiusMatchSingle(query, train, trainIdx, distance, nMatches, 2.0);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(Features2D, ORB, DEVICES(cv::gpu::GLOBAL_ATOMICS));\r
+INSTANTIATE_TEST_CASE_P(Features2D, BruteForceMatcher_radiusMatch, testing::Combine(\r
+ ALL_DEVICES,\r
+ testing::Values(DescriptorSize(64), DescriptorSize(128), DescriptorSize(256)),\r
+ testing::Values(NormType(cv::NORM_L1), NormType(cv::NORM_L2), NormType(cv::NORM_HAMMING))));\r
\r
#endif\r
\r
#ifdef HAVE_CUDA\r
\r
-IMPLEMENT_PARAM_CLASS(KernelSize, int)\r
-\r
//////////////////////////////////////////////////////////////////////\r
// Blur\r
\r
+IMPLEMENT_PARAM_CLASS(KernelSize, int)\r
+\r
GPU_PERF_TEST(Blur, cv::gpu::DeviceInfo, cv::Size, MatType, KernelSize)\r
{\r
cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
int ksize = GET_PARAM(3);\r
\r
cv::Mat src_host(size, type);\r
-\r
- declare.in(src_host, WARMUP_RNG);\r
+ fill(src_host, 0.0, 255.0);\r
\r
cv::gpu::GpuMat src(src_host);\r
cv::gpu::GpuMat dst;\r
\r
+ cv::gpu::blur(src, dst, cv::Size(ksize, ksize));\r
+\r
TEST_CYCLE()\r
{\r
cv::gpu::blur(src, dst, cv::Size(ksize, ksize));\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(Filter, Blur, testing::Combine(\r
+INSTANTIATE_TEST_CASE_P(Filters, Blur, testing::Combine(\r
ALL_DEVICES,\r
GPU_TYPICAL_MAT_SIZES,\r
testing::Values(MatType(CV_8UC1), MatType(CV_8UC4)),\r
int ksize = GET_PARAM(3);\r
\r
cv::Mat src_host(size, type);\r
-\r
- declare.in(src_host, WARMUP_RNG);\r
+ fill(src_host, 0.0, 255.0);\r
\r
cv::gpu::GpuMat src(src_host);\r
cv::gpu::GpuMat dst;\r
cv::gpu::GpuMat buf;\r
\r
+ cv::gpu::Sobel(src, dst, -1, 1, 1, buf, ksize);\r
+\r
TEST_CYCLE()\r
{\r
cv::gpu::Sobel(src, dst, -1, 1, 1, buf, ksize);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(Filter, Sobel, testing::Combine(\r
+INSTANTIATE_TEST_CASE_P(Filters, Sobel, testing::Combine(\r
ALL_DEVICES,\r
GPU_TYPICAL_MAT_SIZES,\r
testing::Values(MatType(CV_8UC1), MatType(CV_8UC4), MatType(CV_32FC1)),\r
int type = GET_PARAM(2);\r
\r
cv::Mat src_host(size, type);\r
-\r
- declare.in(src_host, WARMUP_RNG);\r
+ fill(src_host, 0.0, 255.0);\r
\r
cv::gpu::GpuMat src(src_host);\r
cv::gpu::GpuMat dst;\r
cv::gpu::GpuMat buf;\r
\r
+ cv::gpu::Scharr(src, dst, -1, 1, 0, buf);\r
+\r
TEST_CYCLE()\r
{\r
cv::gpu::Scharr(src, dst, -1, 1, 0, buf);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(Filter, Scharr, testing::Combine(\r
+INSTANTIATE_TEST_CASE_P(Filters, Scharr, testing::Combine(\r
ALL_DEVICES,\r
GPU_TYPICAL_MAT_SIZES,\r
testing::Values(MatType(CV_8UC1), MatType(CV_8UC4), MatType(CV_32FC1))));\r
int ksize = GET_PARAM(3);\r
\r
cv::Mat src_host(size, type);\r
-\r
- declare.in(src_host, WARMUP_RNG);\r
+ fill(src_host, 0.0, 255.0);\r
\r
cv::gpu::GpuMat src(src_host);\r
cv::gpu::GpuMat dst;\r
cv::gpu::GpuMat buf;\r
\r
+ cv::gpu::GaussianBlur(src, dst, cv::Size(ksize, ksize), buf, 0.5);\r
+\r
TEST_CYCLE()\r
{\r
cv::gpu::GaussianBlur(src, dst, cv::Size(ksize, ksize), buf, 0.5);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(Filter, GaussianBlur, testing::Combine(\r
+INSTANTIATE_TEST_CASE_P(Filters, GaussianBlur, testing::Combine(\r
ALL_DEVICES,\r
GPU_TYPICAL_MAT_SIZES,\r
testing::Values(MatType(CV_8UC1), MatType(CV_8UC4), MatType(CV_32FC1)),\r
int ksize = GET_PARAM(3);\r
\r
cv::Mat src_host(size, type);\r
-\r
- declare.in(src_host, WARMUP_RNG);\r
+ fill(src_host, 0.0, 255.0);\r
\r
cv::gpu::GpuMat src(src_host);\r
cv::gpu::GpuMat dst;\r
\r
+ cv::gpu::Laplacian(src, dst, -1, ksize);\r
+\r
TEST_CYCLE()\r
{\r
cv::gpu::Laplacian(src, dst, -1, ksize);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(Filter, Laplacian, testing::Combine(\r
+INSTANTIATE_TEST_CASE_P(Filters, Laplacian, testing::Combine(\r
ALL_DEVICES,\r
GPU_TYPICAL_MAT_SIZES,\r
testing::Values(MatType(CV_8UC1), MatType(CV_8UC4), MatType(CV_32FC1), MatType(CV_32FC4)),\r
int type = GET_PARAM(2);\r
\r
cv::Mat src_host(size, type);\r
-\r
- declare.in(src_host, WARMUP_RNG);\r
+ fill(src_host, 0.0, 255.0);\r
\r
cv::Mat ker = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(3, 3));\r
\r
cv::gpu::GpuMat dst;\r
cv::gpu::GpuMat buf;\r
\r
+ cv::gpu::erode(src, dst, ker, buf);\r
+\r
TEST_CYCLE()\r
{\r
cv::gpu::erode(src, dst, ker, buf);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(Filter, Erode, testing::Combine(\r
+INSTANTIATE_TEST_CASE_P(Filters, Erode, testing::Combine(\r
ALL_DEVICES,\r
GPU_TYPICAL_MAT_SIZES,\r
testing::Values(MatType(CV_8UC1), MatType(CV_8UC4))));\r
int type = GET_PARAM(2);\r
\r
cv::Mat src_host(size, type);\r
-\r
- declare.in(src_host, WARMUP_RNG);\r
+ fill(src_host, 0.0, 255.0);\r
\r
cv::Mat ker = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(3, 3));\r
\r
cv::gpu::GpuMat dst;\r
cv::gpu::GpuMat buf;\r
\r
+ cv::gpu::dilate(src, dst, ker, buf);\r
+\r
TEST_CYCLE()\r
{\r
cv::gpu::dilate(src, dst, ker, buf);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(Filter, Dilate, testing::Combine(\r
+INSTANTIATE_TEST_CASE_P(Filters, Dilate, testing::Combine(\r
ALL_DEVICES,\r
GPU_TYPICAL_MAT_SIZES,\r
testing::Values(MatType(CV_8UC1), MatType(CV_8UC4))));\r
int morphOp = GET_PARAM(3);\r
\r
cv::Mat src_host(size, type);\r
-\r
- declare.in(src_host, WARMUP_RNG);\r
+ fill(src_host, 0.0, 255.0);\r
\r
cv::Mat ker = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(3, 3));\r
\r
cv::gpu::GpuMat buf1;\r
cv::gpu::GpuMat buf2;\r
\r
+ cv::gpu::morphologyEx(src, dst, morphOp, ker, buf1, buf2);\r
+\r
TEST_CYCLE()\r
{\r
cv::gpu::morphologyEx(src, dst, morphOp, ker, buf1, buf2);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(Filter, MorphologyEx, testing::Combine(\r
+INSTANTIATE_TEST_CASE_P(Filters, MorphologyEx, testing::Combine(\r
ALL_DEVICES,\r
GPU_TYPICAL_MAT_SIZES,\r
testing::Values(MatType(CV_8UC1), MatType(CV_8UC4)),\r
int ksize = GET_PARAM(3);\r
\r
cv::Mat src_host(size, type);\r
- cv::Mat kernel(ksize, ksize, CV_32FC1);\r
+ fill(src_host, 0.0, 255.0);\r
\r
- declare.in(src_host, kernel, WARMUP_RNG);\r
+ cv::Mat kernel(ksize, ksize, CV_32FC1);\r
+ fill(kernel, 0.0, 1.0);\r
\r
cv::gpu::GpuMat src(src_host);\r
cv::gpu::GpuMat dst;\r
\r
+ cv::gpu::filter2D(src, dst, -1, kernel);\r
+\r
TEST_CYCLE()\r
{\r
cv::gpu::filter2D(src, dst, -1, kernel);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(Filter, Filter2D, testing::Combine(\r
+INSTANTIATE_TEST_CASE_P(Filters, Filter2D, testing::Combine(\r
ALL_DEVICES,\r
GPU_TYPICAL_MAT_SIZES,\r
testing::Values(MatType(CV_8UC1), MatType(CV_8UC4), MatType(CV_32FC1), MatType(CV_32FC4)),\r
//////////////////////////////////////////////////////////////////////\r
// Remap\r
\r
-GPU_PERF_TEST(Remap, cv::gpu::DeviceInfo, cv::Size, perf::MatType, Interpolation, BorderMode)\r
+GPU_PERF_TEST(Remap, cv::gpu::DeviceInfo, cv::Size, MatType, Interpolation, BorderMode)\r
{\r
cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
cv::Size size = GET_PARAM(1);\r
int type = GET_PARAM(2);\r
int interpolation = GET_PARAM(3);\r
int borderMode = GET_PARAM(4);\r
\r
- cv::gpu::setDevice(devInfo.deviceID());\r
-\r
cv::Mat src_host(size, type);\r
+ fill(src_host, 0, 255);\r
+\r
cv::Mat xmap_host(size, CV_32FC1);\r
- cv::Mat ymap_host(size, CV_32FC1);\r
+ fill(xmap_host, 0, size.width);\r
\r
- declare.in(src_host, xmap_host, ymap_host, WARMUP_RNG);\r
+ cv::Mat ymap_host(size, CV_32FC1);\r
+ fill(ymap_host, 0, size.height);\r
\r
cv::gpu::GpuMat src(src_host);\r
cv::gpu::GpuMat xmap(xmap_host);\r
cv::gpu::GpuMat ymap(ymap_host);\r
cv::gpu::GpuMat dst;\r
\r
+ cv::gpu::remap(src, dst, xmap, ymap, interpolation, borderMode);\r
+\r
declare.time(3.0);\r
\r
TEST_CYCLE()\r
}\r
\r
INSTANTIATE_TEST_CASE_P(ImgProc, Remap, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(CV_8UC1, CV_8UC4, CV_16UC1, CV_32FC1),\r
- testing::Values((int) cv::INTER_NEAREST, (int) cv::INTER_LINEAR, (int) cv::INTER_CUBIC),\r
- testing::Values((int) cv::BORDER_REFLECT101, (int) cv::BORDER_REPLICATE, (int) cv::BORDER_CONSTANT)));\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),\r
+ MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),\r
+ MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),\r
+ testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)),\r
+ testing::Values(BorderMode(cv::BORDER_REFLECT101), BorderMode(cv::BORDER_REPLICATE), BorderMode(cv::BORDER_CONSTANT), BorderMode(cv::BORDER_REFLECT), BorderMode(cv::BORDER_WRAP))));\r
+\r
\r
//////////////////////////////////////////////////////////////////////\r
-// MeanShiftFiltering\r
+// Resize\r
\r
-GPU_PERF_TEST_1(MeanShiftFiltering, cv::gpu::DeviceInfo)\r
-{\r
- cv::gpu::DeviceInfo devInfo = GetParam();\r
+IMPLEMENT_PARAM_CLASS(Scale, double)\r
\r
+GPU_PERF_TEST(Resize, cv::gpu::DeviceInfo, cv::Size, MatType, Interpolation, Scale)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
cv::gpu::setDevice(devInfo.deviceID());\r
\r
- cv::Mat img = readImage("gpu/meanshift/cones.png");\r
- ASSERT_FALSE(img.empty());\r
+ cv::Size size = GET_PARAM(1);\r
+ int type = GET_PARAM(2);\r
+ int interpolation = GET_PARAM(3);\r
+ double f = GET_PARAM(4);\r
\r
- cv::Mat rgba;\r
- cv::cvtColor(img, rgba, cv::COLOR_BGR2BGRA);\r
+ cv::Mat src_host(size, type);\r
+ fill(src_host, 0, 255);\r
\r
- cv::gpu::GpuMat src(rgba);\r
+ cv::gpu::GpuMat src(src_host);\r
cv::gpu::GpuMat dst;\r
\r
- declare.time(5.0);\r
+ cv::gpu::resize(src, dst, cv::Size(), f, f, interpolation);\r
+\r
+ declare.time(1.0);\r
\r
TEST_CYCLE()\r
{\r
- cv::gpu::meanShiftFiltering(src, dst, 50, 50);\r
+ cv::gpu::resize(src, dst, cv::Size(), f, f, interpolation);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(ImgProc, MeanShiftFiltering, ALL_DEVICES);\r
+INSTANTIATE_TEST_CASE_P(ImgProc, Resize, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),\r
+ MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),\r
+ MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),\r
+ testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)),\r
+ testing::Values(Scale(0.5), Scale(2.0))));\r
\r
//////////////////////////////////////////////////////////////////////\r
-// MeanShiftProc\r
+// WarpAffine\r
\r
-GPU_PERF_TEST_1(MeanShiftProc, cv::gpu::DeviceInfo)\r
+GPU_PERF_TEST(WarpAffine, cv::gpu::DeviceInfo, cv::Size, MatType, Interpolation, BorderMode)\r
{\r
- cv::gpu::DeviceInfo devInfo = GetParam();\r
-\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
cv::gpu::setDevice(devInfo.deviceID());\r
\r
- cv::Mat img = readImage("gpu/meanshift/cones.png");\r
- ASSERT_FALSE(img.empty());\r
+ cv::Size size = GET_PARAM(1);\r
+ int type = GET_PARAM(2);\r
+ int interpolation = GET_PARAM(3);\r
+ int borderMode = GET_PARAM(4);\r
\r
- cv::Mat rgba;\r
- cv::cvtColor(img, rgba, cv::COLOR_BGR2BGRA);\r
+ cv::Mat src_host(size, type);\r
+ fill(src_host, 0, 255);\r
\r
- cv::gpu::GpuMat src(rgba);\r
- cv::gpu::GpuMat dstr;\r
- cv::gpu::GpuMat dstsp;\r
+ cv::gpu::GpuMat src(src_host);\r
+ cv::gpu::GpuMat dst;\r
\r
- declare.time(5.0);\r
+ const double aplha = CV_PI / 4;\r
+ double mat[2][3] = { {std::cos(aplha), -std::sin(aplha), src.cols / 2},\r
+ {std::sin(aplha), std::cos(aplha), 0}};\r
+ cv::Mat M(2, 3, CV_64F, (void*) mat);\r
+\r
+ cv::gpu::warpAffine(src, dst, M, size, interpolation, borderMode);\r
\r
TEST_CYCLE()\r
{\r
- cv::gpu::meanShiftProc(src, dstr, dstsp, 50, 50);\r
+ cv::gpu::warpAffine(src, dst, M, size, interpolation, borderMode);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(ImgProc, MeanShiftProc, ALL_DEVICES);\r
+INSTANTIATE_TEST_CASE_P(ImgProc, WarpAffine, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),\r
+ MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),\r
+ MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),\r
+ testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)),\r
+ testing::Values(BorderMode(cv::BORDER_REFLECT101), BorderMode(cv::BORDER_REPLICATE), BorderMode(cv::BORDER_CONSTANT), BorderMode(cv::BORDER_REFLECT), BorderMode(cv::BORDER_WRAP))));\r
\r
//////////////////////////////////////////////////////////////////////\r
-// MeanShiftSegmentation\r
+// WarpPerspective\r
\r
-GPU_PERF_TEST_1(MeanShiftSegmentation, cv::gpu::DeviceInfo)\r
+GPU_PERF_TEST(WarpPerspective, cv::gpu::DeviceInfo, cv::Size, MatType, Interpolation, BorderMode)\r
{\r
- cv::gpu::DeviceInfo devInfo = GetParam();\r
-\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
cv::gpu::setDevice(devInfo.deviceID());\r
\r
- cv::Mat img = readImage("gpu/meanshift/cones.png");\r
- ASSERT_FALSE(img.empty());\r
+ cv::Size size = GET_PARAM(1);\r
+ int type = GET_PARAM(2);\r
+ int interpolation = GET_PARAM(3);\r
+ int borderMode = GET_PARAM(4);\r
\r
- cv::Mat rgba;\r
- cv::cvtColor(img, rgba, cv::COLOR_BGR2BGRA);\r
+ cv::Mat src_host(size, type);\r
+ fill(src_host, 0, 255);\r
\r
- cv::gpu::GpuMat src(rgba);\r
- cv::Mat dst;\r
+ cv::gpu::GpuMat src(src_host);\r
+ cv::gpu::GpuMat dst;\r
\r
- declare.time(5.0);\r
+ const double aplha = CV_PI / 4;\r
+ double mat[3][3] = { {std::cos(aplha), -std::sin(aplha), src.cols / 2},\r
+ {std::sin(aplha), std::cos(aplha), 0},\r
+ {0.0, 0.0, 1.0}};\r
+ cv::Mat M(3, 3, CV_64F, (void*) mat);\r
+\r
+ cv::gpu::warpPerspective(src, dst, M, size, interpolation, borderMode);\r
\r
TEST_CYCLE()\r
{\r
- meanShiftSegmentation(src, dst, 10, 10, 20);\r
+ cv::gpu::warpPerspective(src, dst, M, size, interpolation, borderMode);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(ImgProc, MeanShiftSegmentation, ALL_DEVICES);\r
+INSTANTIATE_TEST_CASE_P(ImgProc, WarpPerspective, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),\r
+ MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),\r
+ MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),\r
+ testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)),\r
+ testing::Values(BorderMode(cv::BORDER_REFLECT101), BorderMode(cv::BORDER_REPLICATE), BorderMode(cv::BORDER_CONSTANT), BorderMode(cv::BORDER_REFLECT), BorderMode(cv::BORDER_WRAP))));\r
\r
//////////////////////////////////////////////////////////////////////\r
-// DrawColorDisp\r
+// CopyMakeBorder\r
\r
-GPU_PERF_TEST(DrawColorDisp, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
+GPU_PERF_TEST(CopyMakeBorder, cv::gpu::DeviceInfo, cv::Size, MatType, BorderMode)\r
{\r
cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
cv::Size size = GET_PARAM(1);\r
int type = GET_PARAM(2);\r
-\r
- cv::gpu::setDevice(devInfo.deviceID());\r
+ int borderType = GET_PARAM(3);\r
\r
cv::Mat src_host(size, type);\r
-\r
fill(src_host, 0, 255);\r
\r
cv::gpu::GpuMat src(src_host);\r
cv::gpu::GpuMat dst;\r
\r
+ cv::gpu::copyMakeBorder(src, dst, 5, 5, 5, 5, borderType);\r
+\r
TEST_CYCLE()\r
{\r
- cv::gpu::drawColorDisp(src, dst, 255);\r
+ cv::gpu::copyMakeBorder(src, dst, 5, 5, 5, 5, borderType);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(ImgProc, DrawColorDisp, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(CV_8UC1, CV_16SC1)));\r
+INSTANTIATE_TEST_CASE_P(ImgProc, CopyMakeBorder, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),\r
+ MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),\r
+ MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),\r
+ testing::Values(BorderMode(cv::BORDER_REFLECT101), BorderMode(cv::BORDER_REPLICATE), BorderMode(cv::BORDER_CONSTANT), BorderMode(cv::BORDER_REFLECT), BorderMode(cv::BORDER_WRAP))));\r
\r
//////////////////////////////////////////////////////////////////////\r
-// ReprojectImageTo3D\r
+// Threshold\r
+\r
+CV_ENUM(ThreshOp, cv::THRESH_BINARY, cv::THRESH_BINARY_INV, cv::THRESH_TRUNC, cv::THRESH_TOZERO, cv::THRESH_TOZERO_INV)\r
+#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))\r
\r
-GPU_PERF_TEST(ReprojectImageTo3D, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
+GPU_PERF_TEST(Threshold, cv::gpu::DeviceInfo, cv::Size, MatDepth, ThreshOp)\r
{\r
cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
cv::gpu::setDevice(devInfo.deviceID());\r
\r
- cv::Mat src_host(size, type);\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+ int threshOp = GET_PARAM(3);\r
\r
- declare.in(src_host, WARMUP_RNG);\r
+ cv::Mat src_host(size, depth);\r
+ fill(src_host, 0, 255);\r
\r
cv::gpu::GpuMat src(src_host);\r
cv::gpu::GpuMat dst;\r
\r
+ cv::gpu::threshold(src, dst, 100.0, 255.0, threshOp);\r
+\r
TEST_CYCLE()\r
{\r
- cv::gpu::reprojectImageTo3D(src, dst, cv::Mat::ones(4, 4, CV_32FC1));\r
+ cv::gpu::threshold(src, dst, 100.0, 255.0, threshOp);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(ImgProc, ReprojectImageTo3D, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(CV_8UC1, CV_16SC1)));\r
+INSTANTIATE_TEST_CASE_P(ImgProc, Threshold, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_32F), MatDepth(CV_64F)),\r
+ ALL_THRESH_OPS));\r
\r
//////////////////////////////////////////////////////////////////////\r
-// CvtColor\r
+// Integral\r
\r
-GPU_PERF_TEST(CvtColor, cv::gpu::DeviceInfo, cv::Size, perf::MatType, CvtColorInfo)\r
+GPU_PERF_TEST(Integral, cv::gpu::DeviceInfo, cv::Size)\r
{\r
cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
- CvtColorInfo info = GET_PARAM(3);\r
-\r
cv::gpu::setDevice(devInfo.deviceID());\r
\r
- cv::Mat src_host(size, CV_MAKETYPE(type, info.scn));\r
+ cv::Size size = GET_PARAM(1);\r
\r
- declare.in(src_host, WARMUP_RNG);\r
+ cv::Mat src_host(size, CV_8UC1);\r
+ fill(src_host, 0, 255);\r
\r
cv::gpu::GpuMat src(src_host);\r
cv::gpu::GpuMat dst;\r
+ cv::gpu::GpuMat buf;\r
+\r
+ cv::gpu::integralBuffered(src, dst, buf);\r
\r
TEST_CYCLE()\r
{\r
- cv::gpu::cvtColor(src, dst, info.code, info.dcn);\r
+ cv::gpu::integralBuffered(src, dst, buf);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(ImgProc, CvtColor, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(CV_8UC1, CV_16UC1, CV_32FC1),\r
- testing::Values(\r
- CvtColorInfo(4, 4, cv::COLOR_RGBA2BGRA), CvtColorInfo(4, 1, cv::COLOR_BGRA2GRAY), CvtColorInfo(1, 4, cv::COLOR_GRAY2BGRA),\r
- CvtColorInfo(4, 4, cv::COLOR_BGR2XYZ), CvtColorInfo(4, 4, cv::COLOR_BGR2YCrCb), CvtColorInfo(4, 4, cv::COLOR_YCrCb2BGR),\r
- CvtColorInfo(4, 4, cv::COLOR_BGR2HSV), CvtColorInfo(4, 4, cv::COLOR_HSV2BGR))));\r
+INSTANTIATE_TEST_CASE_P(ImgProc, Integral, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES));\r
\r
//////////////////////////////////////////////////////////////////////\r
-// SwapChannels\r
+// Integral_Sqr\r
\r
-GPU_PERF_TEST(SwapChannels, cv::gpu::DeviceInfo, cv::Size)\r
+GPU_PERF_TEST(Integral_Sqr, cv::gpu::DeviceInfo, cv::Size)\r
{\r
cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
-\r
cv::gpu::setDevice(devInfo.deviceID());\r
\r
- cv::Mat src_host(size, CV_8UC4);\r
+ cv::Size size = GET_PARAM(1);\r
\r
- declare.in(src_host, WARMUP_RNG);\r
+ cv::Mat src_host(size, CV_8UC1);\r
+ fill(src_host, 0, 255);\r
\r
cv::gpu::GpuMat src(src_host);\r
+ cv::gpu::GpuMat dst;\r
\r
- const int dstOrder[] = {2, 1, 0, 3};\r
+ cv::gpu::sqrIntegral(src, dst);\r
\r
TEST_CYCLE()\r
{\r
- cv::gpu::swapChannels(src, dstOrder);\r
+ cv::gpu::sqrIntegral(src, dst);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(ImgProc, SwapChannels, testing::Combine(ALL_DEVICES, GPU_TYPICAL_MAT_SIZES));\r
+INSTANTIATE_TEST_CASE_P(ImgProc, Integral_Sqr, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES));\r
\r
//////////////////////////////////////////////////////////////////////\r
-// Threshold\r
+// HistEven_OneChannel\r
\r
-GPU_PERF_TEST(Threshold, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
+GPU_PERF_TEST(HistEven_OneChannel, cv::gpu::DeviceInfo, cv::Size, MatDepth)\r
{\r
cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
cv::gpu::setDevice(devInfo.deviceID());\r
\r
- cv::Mat src_host(size, type);\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
\r
- declare.in(src_host, WARMUP_RNG);\r
+ cv::Mat src_host(size, depth);\r
+ fill(src_host, 0, 255);\r
\r
cv::gpu::GpuMat src(src_host);\r
- cv::gpu::GpuMat dst(size, type);\r
+ cv::gpu::GpuMat hist;\r
+ cv::gpu::GpuMat buf;\r
+\r
+ cv::gpu::histEven(src, hist, buf, 30, 0, 180);\r
\r
TEST_CYCLE()\r
{\r
- cv::gpu::threshold(src, dst, 100.0, 255.0, cv::THRESH_BINARY);\r
+ cv::gpu::histEven(src, hist, buf, 30, 0, 180);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(ImgProc, Threshold, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(CV_8UC1, CV_16UC1, CV_32FC1)));\r
+INSTANTIATE_TEST_CASE_P(ImgProc, HistEven_OneChannel, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_16S))));\r
\r
//////////////////////////////////////////////////////////////////////\r
-// Resize\r
+// HistEven_FourChannel\r
\r
-GPU_PERF_TEST(Resize, cv::gpu::DeviceInfo, cv::Size, perf::MatType, Interpolation, double)\r
+GPU_PERF_TEST(HistEven_FourChannel, cv::gpu::DeviceInfo, cv::Size, MatDepth)\r
{\r
cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
- int interpolation = GET_PARAM(3);\r
- double f = GET_PARAM(4);\r
-\r
cv::gpu::setDevice(devInfo.deviceID());\r
\r
- cv::Mat src_host(size, type);\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
\r
- declare.in(src_host, WARMUP_RNG);\r
+ cv::Mat src_host(size, CV_MAKE_TYPE(depth, 4));\r
+ fill(src_host, 0, 255);\r
\r
cv::gpu::GpuMat src(src_host);\r
- cv::gpu::GpuMat dst;\r
+ cv::gpu::GpuMat hist[4];\r
+ cv::gpu::GpuMat buf;\r
+ int histSize[] = {30, 30, 30, 30};\r
+ int lowerLevel[] = {0, 0, 0, 0};\r
+ int upperLevel[] = {180, 180, 180, 180};\r
\r
- declare.time(1.0);\r
+ cv::gpu::histEven(src, hist, buf, histSize, lowerLevel, upperLevel);\r
\r
TEST_CYCLE()\r
{\r
- cv::gpu::resize(src, dst, cv::Size(), f, f, interpolation);\r
+ cv::gpu::histEven(src, hist, buf, histSize, lowerLevel, upperLevel);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(ImgProc, Resize, testing::Combine(\r
- ALL_DEVICES,\r
- testing::Values(perf::szSXGA, perf::sz1080p),\r
- testing::Values(CV_8UC1, CV_8UC4, CV_16UC1, CV_32FC1),\r
- testing::Values((int) cv::INTER_NEAREST, (int) cv::INTER_LINEAR, (int) cv::INTER_CUBIC),\r
- testing::Values(0.5, 2.0)));\r
+INSTANTIATE_TEST_CASE_P(ImgProc, HistEven_FourChannel, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_16S))));\r
\r
//////////////////////////////////////////////////////////////////////\r
-// WarpAffine\r
+// CalcHist\r
\r
-GPU_PERF_TEST(WarpAffine, cv::gpu::DeviceInfo, cv::Size, perf::MatType, Interpolation)\r
+GPU_PERF_TEST(CalcHist, cv::gpu::DeviceInfo, cv::Size)\r
{\r
cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
- int interpolation = GET_PARAM(3);\r
-\r
cv::gpu::setDevice(devInfo.deviceID());\r
\r
- cv::Mat src_host(size, type);\r
+ cv::Size size = GET_PARAM(1);\r
\r
- declare.in(src_host, WARMUP_RNG);\r
+ cv::Mat src_host(size, CV_8UC1);\r
+ fill(src_host, 0, 255);\r
\r
cv::gpu::GpuMat src(src_host);\r
- cv::gpu::GpuMat dst;\r
+ cv::gpu::GpuMat hist;\r
+ cv::gpu::GpuMat buf;\r
\r
- const double aplha = CV_PI / 4;\r
- double mat[2][3] = { {std::cos(aplha), -std::sin(aplha), src.cols / 2},\r
- {std::sin(aplha), std::cos(aplha), 0}};\r
- cv::Mat M(2, 3, CV_64F, (void*) mat);\r
+ cv::gpu::calcHist(src, hist, buf);\r
\r
TEST_CYCLE()\r
{\r
- cv::gpu::warpAffine(src, dst, M, size, interpolation, cv::BORDER_CONSTANT, cv::Scalar());\r
+ cv::gpu::calcHist(src, hist, buf);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(ImgProc, WarpAffine, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_16UC1, CV_16UC3, CV_16UC4, CV_32FC1, CV_32FC3, CV_32FC4),\r
- testing::Values((int) cv::INTER_NEAREST, (int) cv::INTER_LINEAR, (int) cv::INTER_CUBIC)));\r
+INSTANTIATE_TEST_CASE_P(ImgProc, CalcHist, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES));\r
\r
//////////////////////////////////////////////////////////////////////\r
-// WarpPerspective\r
+// EqualizeHist\r
\r
-GPU_PERF_TEST(WarpPerspective, cv::gpu::DeviceInfo, cv::Size, perf::MatType, Interpolation)\r
+GPU_PERF_TEST(EqualizeHist, cv::gpu::DeviceInfo, cv::Size)\r
{\r
cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
- int interpolation = GET_PARAM(3);\r
-\r
cv::gpu::setDevice(devInfo.deviceID());\r
\r
- cv::Mat src_host(size, type);\r
+ cv::Size size = GET_PARAM(1);\r
\r
- declare.in(src_host, WARMUP_RNG);\r
+ cv::Mat src_host(size, CV_8UC1);\r
+ fill(src_host, 0, 255);\r
\r
cv::gpu::GpuMat src(src_host);\r
cv::gpu::GpuMat dst;\r
+ cv::gpu::GpuMat hist;\r
+ cv::gpu::GpuMat buf;\r
\r
- const double aplha = CV_PI / 4;\r
- double mat[3][3] = { {std::cos(aplha), -std::sin(aplha), src.cols / 2},\r
- {std::sin(aplha), std::cos(aplha), 0},\r
- {0.0, 0.0, 1.0}};\r
- cv::Mat M(3, 3, CV_64F, (void*) mat);\r
+ cv::gpu::equalizeHist(src, dst, hist, buf);\r
\r
TEST_CYCLE()\r
{\r
- cv::gpu::warpPerspective(src, dst, M, size, interpolation, cv::BORDER_CONSTANT, cv::Scalar());\r
+ cv::gpu::equalizeHist(src, dst, hist, buf);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(ImgProc, WarpPerspective, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_16UC1, CV_16UC3, CV_16UC4, CV_32FC1, CV_32FC3, CV_32FC4),\r
- testing::Values((int) cv::INTER_NEAREST, (int) cv::INTER_LINEAR, (int) cv::INTER_CUBIC)));\r
+INSTANTIATE_TEST_CASE_P(ImgProc, EqualizeHist, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES));\r
\r
//////////////////////////////////////////////////////////////////////\r
-// BuildWarpPlaneMaps\r
+// ColumnSum\r
\r
-GPU_PERF_TEST(BuildWarpPlaneMaps, cv::gpu::DeviceInfo, cv::Size)\r
+GPU_PERF_TEST(ColumnSum, cv::gpu::DeviceInfo, cv::Size)\r
{\r
cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
cv::Size size = GET_PARAM(1);\r
\r
- cv::gpu::setDevice(devInfo.deviceID());\r
+ cv::Mat src_host(size, CV_32FC1);\r
+ fill(src_host, 0, 255);\r
\r
- cv::gpu::GpuMat map_x;\r
- cv::gpu::GpuMat map_y;\r
+ cv::gpu::GpuMat src(src_host);\r
+ cv::gpu::GpuMat dst;\r
+\r
+ cv::gpu::columnSum(src, dst);\r
\r
TEST_CYCLE()\r
{\r
- cv::gpu::buildWarpPlaneMaps(size, cv::Rect(0, 0, size.width, size.height), cv::Mat::eye(3, 3, CV_32FC1),\r
- cv::Mat::ones(3, 3, CV_32FC1), cv::Mat::zeros(1, 3, CV_32F), 1.0, map_x, map_y);\r
+ cv::gpu::columnSum(src, dst);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(ImgProc, BuildWarpPlaneMaps, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES));\r
+INSTANTIATE_TEST_CASE_P(ImgProc, ColumnSum, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES));\r
\r
//////////////////////////////////////////////////////////////////////\r
-// BuildWarpCylindricalMaps\r
+// Canny\r
\r
-GPU_PERF_TEST(BuildWarpCylindricalMaps, cv::gpu::DeviceInfo, cv::Size)\r
+IMPLEMENT_PARAM_CLASS(AppertureSize, int)\r
+IMPLEMENT_PARAM_CLASS(L2gradient, bool)\r
+\r
+GPU_PERF_TEST(Canny, cv::gpu::DeviceInfo, AppertureSize, L2gradient)\r
{\r
cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
+ int apperture_size = GET_PARAM(1);\r
+ bool useL2gradient = GET_PARAM(2);\r
+\r
+ cv::Mat image_host = readImage("perf/1280x1024.jpg", cv::IMREAD_GRAYSCALE);\r
+ ASSERT_FALSE(image_host.empty());\r
+\r
+ cv::gpu::GpuMat image(image_host);\r
+ cv::gpu::GpuMat dst;\r
+ cv::gpu::CannyBuf buf;\r
+\r
+ cv::gpu::Canny(image, buf, dst, 50.0, 100.0, apperture_size, useL2gradient);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::gpu::Canny(image, buf, dst, 50.0, 100.0, apperture_size, useL2gradient);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(ImgProc, Canny, testing::Combine(\r
+ ALL_DEVICES,\r
+ testing::Values(AppertureSize(3), AppertureSize(5)),\r
+ testing::Values(L2gradient(false), L2gradient(true))));\r
\r
+//////////////////////////////////////////////////////////////////////\r
+// MeanShiftFiltering\r
+\r
+GPU_PERF_TEST_1(MeanShiftFiltering, cv::gpu::DeviceInfo)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GetParam();\r
cv::gpu::setDevice(devInfo.deviceID());\r
\r
- cv::gpu::GpuMat map_x;\r
- cv::gpu::GpuMat map_y;\r
+ cv::Mat img = readImage("gpu/meanshift/cones.png");\r
+ ASSERT_FALSE(img.empty());\r
+\r
+ cv::Mat rgba;\r
+ cv::cvtColor(img, rgba, cv::COLOR_BGR2BGRA);\r
+\r
+ cv::gpu::GpuMat src(rgba);\r
+ cv::gpu::GpuMat dst;\r
+\r
+ cv::gpu::meanShiftFiltering(src, dst, 50, 50);\r
+\r
+ declare.time(5.0);\r
\r
TEST_CYCLE()\r
{\r
- cv::gpu::buildWarpCylindricalMaps(size, cv::Rect(0, 0, size.width, size.height), cv::Mat::eye(3, 3, CV_32FC1),\r
- cv::Mat::ones(3, 3, CV_32FC1), 1.0, map_x, map_y);\r
+ cv::gpu::meanShiftFiltering(src, dst, 50, 50);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(ImgProc, BuildWarpCylindricalMaps, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES));\r
+INSTANTIATE_TEST_CASE_P(ImgProc, MeanShiftFiltering, ALL_DEVICES);\r
\r
//////////////////////////////////////////////////////////////////////\r
-// BuildWarpSphericalMaps\r
+// MeanShiftProc\r
\r
-GPU_PERF_TEST(BuildWarpSphericalMaps, cv::gpu::DeviceInfo, cv::Size)\r
+GPU_PERF_TEST_1(MeanShiftProc, cv::gpu::DeviceInfo)\r
{\r
- cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
+ cv::gpu::DeviceInfo devInfo = GetParam();\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
+ cv::Mat img = readImage("gpu/meanshift/cones.png");\r
+ ASSERT_FALSE(img.empty());\r
+\r
+ cv::Mat rgba;\r
+ cv::cvtColor(img, rgba, cv::COLOR_BGR2BGRA);\r
+\r
+ cv::gpu::GpuMat src(rgba);\r
+ cv::gpu::GpuMat dstr;\r
+ cv::gpu::GpuMat dstsp;\r
+\r
+ cv::gpu::meanShiftProc(src, dstr, dstsp, 50, 50);\r
+\r
+ declare.time(5.0);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::gpu::meanShiftProc(src, dstr, dstsp, 50, 50);\r
+ }\r
+}\r
\r
+INSTANTIATE_TEST_CASE_P(ImgProc, MeanShiftProc, ALL_DEVICES);\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// MeanShiftSegmentation\r
+\r
+GPU_PERF_TEST_1(MeanShiftSegmentation, cv::gpu::DeviceInfo)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GetParam();\r
cv::gpu::setDevice(devInfo.deviceID());\r
\r
- cv::gpu::GpuMat map_x;\r
- cv::gpu::GpuMat map_y;\r
+ cv::Mat img = readImage("gpu/meanshift/cones.png");\r
+ ASSERT_FALSE(img.empty());\r
+\r
+ cv::Mat rgba;\r
+ cv::cvtColor(img, rgba, cv::COLOR_BGR2BGRA);\r
+\r
+ cv::gpu::GpuMat src(rgba);\r
+ cv::Mat dst;\r
+\r
+ meanShiftSegmentation(src, dst, 10, 10, 20);\r
+\r
+ declare.time(5.0);\r
\r
TEST_CYCLE()\r
{\r
- cv::gpu::buildWarpSphericalMaps(size, cv::Rect(0, 0, size.width, size.height), cv::Mat::eye(3, 3, CV_32FC1),\r
- cv::Mat::ones(3, 3, CV_32FC1), 1.0, map_x, map_y);\r
+ meanShiftSegmentation(src, dst, 10, 10, 20);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(ImgProc, BuildWarpSphericalMaps, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES));\r
+INSTANTIATE_TEST_CASE_P(ImgProc, MeanShiftSegmentation, ALL_DEVICES);\r
\r
//////////////////////////////////////////////////////////////////////\r
-// Rotate\r
+// BlendLinear\r
\r
-GPU_PERF_TEST(Rotate, cv::gpu::DeviceInfo, cv::Size, perf::MatType, Interpolation)\r
+GPU_PERF_TEST(BlendLinear, cv::gpu::DeviceInfo, cv::Size, MatType)\r
{\r
cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
cv::Size size = GET_PARAM(1);\r
int type = GET_PARAM(2);\r
- int interpolation = GET_PARAM(3);\r
-\r
- cv::gpu::setDevice(devInfo.deviceID());\r
\r
- cv::Mat src_host(size, type);\r
+ cv::Mat img1_host(size, type);\r
+ fill(img1_host, 0, 255);\r
\r
- declare.in(src_host, WARMUP_RNG);\r
+ cv::Mat img2_host(size, type);\r
+ fill(img2_host, 0, 255);\r
\r
- cv::gpu::GpuMat src(src_host);\r
+ cv::gpu::GpuMat img1(img1_host);\r
+ cv::gpu::GpuMat img2(img2_host);\r
+ cv::gpu::GpuMat weights1(size, CV_32FC1, cv::Scalar::all(0.5));\r
+ cv::gpu::GpuMat weights2(size, CV_32FC1, cv::Scalar::all(0.5));\r
cv::gpu::GpuMat dst;\r
\r
+ cv::gpu::blendLinear(img1, img2, weights1, weights2, dst);\r
+\r
TEST_CYCLE()\r
{\r
- cv::gpu::rotate(src, dst, size, 30.0, 0, 0, interpolation);\r
+ cv::gpu::blendLinear(img1, img2, weights1, weights2, dst);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(ImgProc, Rotate, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_16UC1, CV_16UC3, CV_16UC4, CV_32FC1, CV_32FC3, CV_32FC4),\r
- testing::Values((int) cv::INTER_NEAREST, (int) cv::INTER_LINEAR, (int) cv::INTER_CUBIC)));\r
+INSTANTIATE_TEST_CASE_P(ImgProc, BlendLinear, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),\r
+ MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4))));\r
\r
//////////////////////////////////////////////////////////////////////\r
-// CopyMakeBorder\r
+// Convolve\r
+\r
+IMPLEMENT_PARAM_CLASS(KSize, int)\r
+IMPLEMENT_PARAM_CLASS(Ccorr, bool)\r
\r
-GPU_PERF_TEST(CopyMakeBorder, cv::gpu::DeviceInfo, cv::Size, perf::MatType, BorderMode)\r
+GPU_PERF_TEST(Convolve, cv::gpu::DeviceInfo, cv::Size, KSize, Ccorr)\r
{\r
cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
- int borderType = GET_PARAM(3);\r
+ int templ_size = GET_PARAM(2);\r
+ bool ccorr = GET_PARAM(3);\r
+\r
+ cv::gpu::GpuMat image = cv::gpu::createContinuous(size, CV_32FC1);\r
+ image.setTo(cv::Scalar(1.0));\r
+\r
+ cv::gpu::GpuMat templ = cv::gpu::createContinuous(templ_size, templ_size, CV_32FC1);\r
+ templ.setTo(cv::Scalar(1.0));\r
+\r
+ cv::gpu::GpuMat dst;\r
+ cv::gpu::ConvolveBuf buf;\r
\r
+ cv::gpu::convolve(image, templ, dst, ccorr, buf);\r
+\r
+ declare.time(2.0);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::gpu::convolve(image, templ, dst, ccorr, buf);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(ImgProc, Convolve, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values(KSize(3), KSize(9), KSize(17), KSize(27), KSize(32), KSize(64)),\r
+ testing::Values(Ccorr(false), Ccorr(true))));\r
+\r
+////////////////////////////////////////////////////////////////////////////////\r
+// MatchTemplate_8U\r
+\r
+CV_ENUM(TemplateMethod, cv::TM_SQDIFF, cv::TM_SQDIFF_NORMED, cv::TM_CCORR, cv::TM_CCORR_NORMED, cv::TM_CCOEFF, cv::TM_CCOEFF_NORMED)\r
+#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))\r
+\r
+IMPLEMENT_PARAM_CLASS(TemplateSize, cv::Size)\r
+\r
+GPU_PERF_TEST(MatchTemplate_8U, cv::gpu::DeviceInfo, cv::Size, TemplateSize, Channels, TemplateMethod)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
cv::gpu::setDevice(devInfo.deviceID());\r
\r
- cv::Mat src_host(size, type);\r
+ cv::Size size = GET_PARAM(1);\r
+ cv::Size templ_size = GET_PARAM(2);\r
+ int cn = GET_PARAM(3);\r
+ int method = GET_PARAM(4);\r
\r
- declare.in(src_host, WARMUP_RNG);\r
+ cv::Mat image_host(size, CV_MAKE_TYPE(CV_8U, cn));\r
+ fill(image_host, 0, 255);\r
\r
- cv::gpu::GpuMat src(src_host);\r
+ cv::Mat templ_host(templ_size, CV_MAKE_TYPE(CV_8U, cn));\r
+ fill(templ_host, 0, 255);\r
+\r
+ cv::gpu::GpuMat image(image_host);\r
+ cv::gpu::GpuMat templ(templ_host);\r
cv::gpu::GpuMat dst;\r
\r
+ cv::gpu::matchTemplate(image, templ, dst, method);\r
+\r
TEST_CYCLE()\r
{\r
- cv::gpu::copyMakeBorder(src, dst, 5, 5, 5, 5, borderType);\r
+ cv::gpu::matchTemplate(image, templ, dst, method);\r
}\r
-}\r
+};\r
\r
-INSTANTIATE_TEST_CASE_P(ImgProc, CopyMakeBorder, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(CV_8UC1, CV_8UC4, CV_32FC1),\r
- testing::Values((int) cv::BORDER_REPLICATE, (int) cv::BORDER_REFLECT, (int) cv::BORDER_WRAP, (int) cv::BORDER_CONSTANT)));\r
+INSTANTIATE_TEST_CASE_P(ImgProc, MatchTemplate_8U, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values(TemplateSize(cv::Size(5, 5)), TemplateSize(cv::Size(16, 16)), TemplateSize(cv::Size(30, 30))),\r
+ testing::Values(Channels(1), Channels(3), Channels(4)),\r
+ ALL_TEMPLATE_METHODS));\r
\r
-//////////////////////////////////////////////////////////////////////\r
-// Integral\r
+////////////////////////////////////////////////////////////////////////////////\r
+// MatchTemplate_32F\r
\r
-GPU_PERF_TEST(Integral, cv::gpu::DeviceInfo, cv::Size)\r
+GPU_PERF_TEST(MatchTemplate_32F, cv::gpu::DeviceInfo, cv::Size, TemplateSize, Channels, TemplateMethod)\r
{\r
cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
cv::Size size = GET_PARAM(1);\r
+ cv::Size templ_size = GET_PARAM(2);\r
+ int cn = GET_PARAM(3);\r
+ int method = GET_PARAM(4);\r
+\r
+ cv::Mat image_host(size, CV_MAKE_TYPE(CV_32F, cn));\r
+ fill(image_host, 0, 255);\r
+\r
+ cv::Mat templ_host(templ_size, CV_MAKE_TYPE(CV_32F, cn));\r
+ fill(templ_host, 0, 255);\r
+\r
+ cv::gpu::GpuMat image(image_host);\r
+ cv::gpu::GpuMat templ(templ_host);\r
+ cv::gpu::GpuMat dst;\r
+\r
+ cv::gpu::matchTemplate(image, templ, dst, method);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::gpu::matchTemplate(image, templ, dst, method);\r
+ }\r
+};\r
+\r
+INSTANTIATE_TEST_CASE_P(ImgProc, MatchTemplate_32F, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values(TemplateSize(cv::Size(5, 5)), TemplateSize(cv::Size(16, 16)), TemplateSize(cv::Size(30, 30))),\r
+ testing::Values(Channels(1), Channels(3), Channels(4)),\r
+ testing::Values(TemplateMethod(cv::TM_SQDIFF), TemplateMethod(cv::TM_CCORR))));\r
\r
+//////////////////////////////////////////////////////////////////////\r
+// MulSpectrums\r
+\r
+CV_FLAGS(DftFlags, 0, cv::DFT_INVERSE, cv::DFT_SCALE, cv::DFT_ROWS, cv::DFT_COMPLEX_OUTPUT, cv::DFT_REAL_OUTPUT)\r
+\r
+GPU_PERF_TEST(MulSpectrums, cv::gpu::DeviceInfo, cv::Size, DftFlags)\r
+{\r
+ cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
cv::gpu::setDevice(devInfo.deviceID());\r
\r
- cv::Mat src_host(size, CV_8UC1);\r
+ cv::Size size = GET_PARAM(1);\r
+ int flag = GET_PARAM(2);\r
\r
- declare.in(src_host, WARMUP_RNG);\r
+ cv::Mat a_host(size, CV_32FC2);\r
+ fill(a_host, 0, 100);\r
\r
- cv::gpu::GpuMat src(src_host);\r
+ cv::Mat b_host(size, CV_32FC2);\r
+ fill(b_host, 0, 100);\r
+\r
+ cv::gpu::GpuMat a(a_host);\r
+ cv::gpu::GpuMat b(b_host);\r
cv::gpu::GpuMat dst;\r
- cv::gpu::GpuMat buf;\r
+\r
+ cv::gpu::mulSpectrums(a, b, dst, flag);\r
\r
TEST_CYCLE()\r
{\r
- cv::gpu::integralBuffered(src, dst, buf);\r
+ cv::gpu::mulSpectrums(a, b, dst, flag);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(ImgProc, Integral, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES));\r
+INSTANTIATE_TEST_CASE_P(ImgProc, MulSpectrums, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values(DftFlags(0), DftFlags(cv::DFT_ROWS))));\r
\r
//////////////////////////////////////////////////////////////////////\r
-// IntegralSqr\r
+// MulAndScaleSpectrums\r
\r
-GPU_PERF_TEST(IntegralSqr, cv::gpu::DeviceInfo, cv::Size)\r
+GPU_PERF_TEST(MulAndScaleSpectrums, cv::gpu::DeviceInfo, cv::Size)\r
{\r
cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
cv::Size size = GET_PARAM(1);\r
\r
- cv::gpu::setDevice(devInfo.deviceID());\r
+ float scale = 1.f / size.area();\r
\r
- cv::Mat src_host(size, CV_8UC1);\r
+ cv::Mat src1_host(size, CV_32FC2);\r
+ fill(src1_host, 0, 100);\r
\r
- declare.in(src_host, WARMUP_RNG);\r
+ cv::Mat src2_host(size, CV_32FC2);\r
+ fill(src2_host, 0, 100);\r
\r
- cv::gpu::GpuMat src(src_host);\r
+ cv::gpu::GpuMat src1(src1_host);\r
+ cv::gpu::GpuMat src2(src2_host);\r
cv::gpu::GpuMat dst;\r
\r
+ cv::gpu::mulAndScaleSpectrums(src1, src2, dst, cv::DFT_ROWS, scale, false);\r
+\r
TEST_CYCLE()\r
{\r
- cv::gpu::sqrIntegral(src, dst);\r
+ cv::gpu::mulAndScaleSpectrums(src1, src2, dst, cv::DFT_ROWS, scale, false);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(ImgProc, IntegralSqr, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES));\r
+INSTANTIATE_TEST_CASE_P(ImgProc, MulAndScaleSpectrums, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES));\r
\r
//////////////////////////////////////////////////////////////////////\r
-// ColumnSum\r
+// Dft\r
\r
-GPU_PERF_TEST(ColumnSum, cv::gpu::DeviceInfo, cv::Size)\r
+GPU_PERF_TEST(Dft, cv::gpu::DeviceInfo, cv::Size, DftFlags)\r
{\r
cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
-\r
cv::gpu::setDevice(devInfo.deviceID());\r
\r
- cv::Mat src_host(size, CV_32FC1);\r
+ cv::Size size = GET_PARAM(1);\r
+ int flag = GET_PARAM(2);\r
\r
- declare.in(src_host, WARMUP_RNG);\r
+ cv::Mat src_host(size, CV_32FC2);\r
+ fill(src_host, 0, 100);\r
\r
cv::gpu::GpuMat src(src_host);\r
cv::gpu::GpuMat dst;\r
\r
+ cv::gpu::dft(src, dst, size, flag);\r
+\r
+ declare.time(2.0);\r
+\r
TEST_CYCLE()\r
{\r
- cv::gpu::columnSum(src, dst);\r
+ cv::gpu::dft(src, dst, size, flag);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(ImgProc, ColumnSum, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES));\r
+INSTANTIATE_TEST_CASE_P(ImgProc, Dft, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values(DftFlags(0), DftFlags(cv::DFT_ROWS), DftFlags(cv::DFT_INVERSE))));\r
\r
//////////////////////////////////////////////////////////////////////\r
// CornerHarris\r
\r
-GPU_PERF_TEST(CornerHarris, cv::gpu::DeviceInfo, perf::MatType)\r
+IMPLEMENT_PARAM_CLASS(BlockSize, int)\r
+IMPLEMENT_PARAM_CLASS(ApertureSize, int)\r
+\r
+GPU_PERF_TEST(CornerHarris, cv::gpu::DeviceInfo, MatType, BorderMode, BlockSize, ApertureSize)\r
{\r
cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- int type = GET_PARAM(1);\r
-\r
cv::gpu::setDevice(devInfo.deviceID());\r
\r
+ int type = GET_PARAM(1);\r
+ int borderType = GET_PARAM(2);\r
+ int blockSize = GET_PARAM(3);\r
+ int apertureSize = GET_PARAM(4);\r
+\r
cv::Mat img = readImage("gpu/stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE);\r
ASSERT_FALSE(img.empty());\r
\r
cv::gpu::GpuMat dst;\r
cv::gpu::GpuMat Dx;\r
cv::gpu::GpuMat Dy;\r
+ cv::gpu::GpuMat buf;\r
\r
- int blockSize = 3;\r
- int ksize = 7;\r
double k = 0.5;\r
\r
+ cv::gpu::cornerHarris(src, dst, Dx, Dy, buf, blockSize, apertureSize, k, borderType);\r
+\r
TEST_CYCLE()\r
{\r
- cv::gpu::cornerHarris(src, dst, Dx, Dy, blockSize, ksize, k);\r
+ cv::gpu::cornerHarris(src, dst, Dx, Dy, buf, blockSize, apertureSize, k, borderType);\r
}\r
}\r
\r
INSTANTIATE_TEST_CASE_P(ImgProc, CornerHarris, testing::Combine(\r
- ALL_DEVICES,\r
- testing::Values(CV_8UC1, CV_32FC1)));\r
+ ALL_DEVICES,\r
+ testing::Values(MatType(CV_8UC1), MatType(CV_32FC1)),\r
+ testing::Values(BorderMode(cv::BORDER_REFLECT101), BorderMode(cv::BORDER_REPLICATE), BorderMode(cv::BORDER_REFLECT)),\r
+ testing::Values(BlockSize(3), BlockSize(5), BlockSize(7)),\r
+ testing::Values(ApertureSize(0), ApertureSize(3), ApertureSize(5), ApertureSize(7))));\r
\r
//////////////////////////////////////////////////////////////////////\r
// CornerMinEigenVal\r
\r
-GPU_PERF_TEST(CornerMinEigenVal, cv::gpu::DeviceInfo, perf::MatType)\r
+GPU_PERF_TEST(CornerMinEigenVal, cv::gpu::DeviceInfo, MatType, BorderMode, BlockSize, ApertureSize)\r
{\r
cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- int type = GET_PARAM(1);\r
-\r
cv::gpu::setDevice(devInfo.deviceID());\r
\r
+ int type = GET_PARAM(1);\r
+ int borderType = GET_PARAM(2);\r
+ int blockSize = GET_PARAM(3);\r
+ int apertureSize = GET_PARAM(4);\r
+\r
cv::Mat img = readImage("gpu/stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE);\r
ASSERT_FALSE(img.empty());\r
\r
cv::gpu::GpuMat dst;\r
cv::gpu::GpuMat Dx;\r
cv::gpu::GpuMat Dy;\r
+ cv::gpu::GpuMat buf;\r
\r
- int blockSize = 3;\r
- int ksize = 7;\r
+ cv::gpu::cornerMinEigenVal(src, dst, Dx, Dy, buf, blockSize, apertureSize, borderType);\r
\r
TEST_CYCLE()\r
{\r
- cv::gpu::cornerMinEigenVal(src, dst, Dx, Dy, blockSize, ksize);\r
+ cv::gpu::cornerMinEigenVal(src, dst, Dx, Dy, buf, blockSize, apertureSize, borderType);\r
}\r
}\r
\r
INSTANTIATE_TEST_CASE_P(ImgProc, CornerMinEigenVal, testing::Combine(\r
- ALL_DEVICES,\r
- testing::Values(CV_8UC1, CV_32FC1)));\r
+ ALL_DEVICES,\r
+ testing::Values(MatType(CV_8UC1), MatType(CV_32FC1)),\r
+ testing::Values(BorderMode(cv::BORDER_REFLECT101), BorderMode(cv::BORDER_REPLICATE), BorderMode(cv::BORDER_REFLECT)),\r
+ testing::Values(BlockSize(3), BlockSize(5), BlockSize(7)),\r
+ testing::Values(ApertureSize(0), ApertureSize(3), ApertureSize(5), ApertureSize(7))));\r
\r
//////////////////////////////////////////////////////////////////////\r
-// MulSpectrums\r
+// BuildWarpPlaneMaps\r
\r
-GPU_PERF_TEST(MulSpectrums, cv::gpu::DeviceInfo, cv::Size)\r
+GPU_PERF_TEST(BuildWarpPlaneMaps, cv::gpu::DeviceInfo, cv::Size)\r
{\r
cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
-\r
cv::gpu::setDevice(devInfo.deviceID());\r
\r
- cv::Mat a_host(size, CV_32FC2);\r
- cv::Mat b_host(size, CV_32FC2);\r
+ cv::Size size = GET_PARAM(1);\r
\r
- declare.in(a_host, b_host, WARMUP_RNG);\r
+ cv::Mat K = cv::Mat::eye(3, 3, CV_32FC1);\r
+ cv::Mat R = cv::Mat::ones(3, 3, CV_32FC1);\r
+ cv::Mat T = cv::Mat::zeros(1, 3, CV_32F);\r
+ cv::gpu::GpuMat map_x;\r
+ cv::gpu::GpuMat map_y;\r
\r
- cv::gpu::GpuMat a(a_host);\r
- cv::gpu::GpuMat b(b_host);\r
- cv::gpu::GpuMat dst;\r
+ cv::gpu::buildWarpPlaneMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, T, 1.0, map_x, map_y);\r
\r
TEST_CYCLE()\r
{\r
- cv::gpu::mulSpectrums(a, b, dst, 0);\r
+ cv::gpu::buildWarpPlaneMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, T, 1.0, map_x, map_y);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(ImgProc, MulSpectrums, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES));\r
+INSTANTIATE_TEST_CASE_P(ImgProc, BuildWarpPlaneMaps, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES));\r
\r
//////////////////////////////////////////////////////////////////////\r
-// Dft\r
+// BuildWarpCylindricalMaps\r
\r
-GPU_PERF_TEST(Dft, cv::gpu::DeviceInfo, cv::Size)\r
+GPU_PERF_TEST(BuildWarpCylindricalMaps, cv::gpu::DeviceInfo, cv::Size)\r
{\r
cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
-\r
cv::gpu::setDevice(devInfo.deviceID());\r
\r
- cv::Mat src_host(size, CV_32FC2);\r
-\r
- declare.in(src_host, WARMUP_RNG);\r
+ cv::Size size = GET_PARAM(1);\r
\r
- cv::gpu::GpuMat src(src_host);\r
- cv::gpu::GpuMat dst;\r
+ cv::Mat K = cv::Mat::eye(3, 3, CV_32FC1);\r
+ cv::Mat R = cv::Mat::ones(3, 3, CV_32FC1);\r
+ cv::gpu::GpuMat map_x;\r
+ cv::gpu::GpuMat map_y;\r
\r
- declare.time(2.0);\r
+ cv::gpu::buildWarpCylindricalMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, 1.0, map_x, map_y);\r
\r
TEST_CYCLE()\r
{\r
- cv::gpu::dft(src, dst, size);\r
+ cv::gpu::buildWarpCylindricalMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, 1.0, map_x, map_y);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(ImgProc, Dft, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES));\r
+INSTANTIATE_TEST_CASE_P(ImgProc, BuildWarpCylindricalMaps, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES));\r
\r
//////////////////////////////////////////////////////////////////////\r
-// Convolve\r
+// BuildWarpSphericalMaps\r
\r
-GPU_PERF_TEST(Convolve, cv::gpu::DeviceInfo, cv::Size, int, bool)\r
+GPU_PERF_TEST(BuildWarpSphericalMaps, cv::gpu::DeviceInfo, cv::Size)\r
{\r
cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
- int templ_size = GET_PARAM(2);\r
- bool ccorr = GET_PARAM(3);\r
-\r
cv::gpu::setDevice(devInfo.deviceID());\r
\r
- cv::gpu::GpuMat image = cv::gpu::createContinuous(size, CV_32FC1);\r
- cv::gpu::GpuMat templ = cv::gpu::createContinuous(templ_size, templ_size, CV_32FC1);\r
-\r
- image.setTo(cv::Scalar(1.0));\r
- templ.setTo(cv::Scalar(1.0));\r
+ cv::Size size = GET_PARAM(1);\r
\r
- cv::gpu::GpuMat dst;\r
- cv::gpu::ConvolveBuf buf;\r
+ cv::Mat K = cv::Mat::eye(3, 3, CV_32FC1);\r
+ cv::Mat R = cv::Mat::ones(3, 3, CV_32FC1);\r
+ cv::gpu::GpuMat map_x;\r
+ cv::gpu::GpuMat map_y;\r
\r
- declare.time(2.0);\r
+ cv::gpu::buildWarpSphericalMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, 1.0, map_x, map_y);\r
\r
TEST_CYCLE()\r
{\r
- cv::gpu::convolve(image, templ, dst, ccorr, buf);\r
+ cv::gpu::buildWarpSphericalMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, 1.0, map_x, map_y);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(ImgProc, Convolve, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(3, 9, 27, 32, 64),\r
- testing::Bool()));\r
+INSTANTIATE_TEST_CASE_P(ImgProc, BuildWarpSphericalMaps, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES));\r
\r
//////////////////////////////////////////////////////////////////////\r
-// PyrDown\r
+// Rotate\r
\r
-GPU_PERF_TEST(PyrDown, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
+GPU_PERF_TEST(Rotate, cv::gpu::DeviceInfo, cv::Size, MatType, Interpolation)\r
{\r
cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
cv::Size size = GET_PARAM(1);\r
int type = GET_PARAM(2);\r
-\r
- cv::gpu::setDevice(devInfo.deviceID());\r
+ int interpolation = GET_PARAM(3);\r
\r
cv::Mat src_host(size, type);\r
-\r
- declare.in(src_host, WARMUP_RNG);\r
+ fill(src_host, 0, 255);\r
\r
cv::gpu::GpuMat src(src_host);\r
cv::gpu::GpuMat dst;\r
\r
+ cv::gpu::rotate(src, dst, size, 30.0, 0, 0, interpolation);\r
+\r
TEST_CYCLE()\r
{\r
- cv::gpu::pyrDown(src, dst);\r
+ cv::gpu::rotate(src, dst, size, 30.0, 0, 0, interpolation);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(ImgProc, PyrDown, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(CV_8UC1, CV_8UC4, CV_16SC3, CV_32FC1)));\r
+INSTANTIATE_TEST_CASE_P(ImgProc, Rotate, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),\r
+ MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),\r
+ MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),\r
+ testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC))));\r
\r
//////////////////////////////////////////////////////////////////////\r
-// PyrUp\r
+// PyrDown\r
\r
-GPU_PERF_TEST(PyrUp, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
+GPU_PERF_TEST(PyrDown, cv::gpu::DeviceInfo, cv::Size, MatType)\r
{\r
cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
cv::Size size = GET_PARAM(1);\r
int type = GET_PARAM(2);\r
\r
- cv::gpu::setDevice(devInfo.deviceID());\r
-\r
cv::Mat src_host(size, type);\r
-\r
- declare.in(src_host, WARMUP_RNG);\r
+ fill(src_host, 0, 255);\r
\r
cv::gpu::GpuMat src(src_host);\r
cv::gpu::GpuMat dst;\r
\r
+ cv::gpu::pyrDown(src, dst);\r
+\r
TEST_CYCLE()\r
{\r
- cv::gpu::pyrUp(src, dst);\r
+ cv::gpu::pyrDown(src, dst);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(ImgProc, PyrUp, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(CV_8UC1, CV_8UC4, CV_16SC3, CV_32FC1)));\r
+INSTANTIATE_TEST_CASE_P(ImgProc, PyrDown, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),\r
+ MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),\r
+ MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4))));\r
\r
//////////////////////////////////////////////////////////////////////\r
-// BlendLinear\r
+// PyrUp\r
\r
-GPU_PERF_TEST(BlendLinear, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
+GPU_PERF_TEST(PyrUp, cv::gpu::DeviceInfo, cv::Size, MatType)\r
{\r
cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
cv::gpu::setDevice(devInfo.deviceID());\r
\r
- cv::Mat img1_host(size, type);\r
- cv::Mat img2_host(size, type);\r
+ cv::Size size = GET_PARAM(1);\r
+ int type = GET_PARAM(2);\r
\r
- declare.in(img1_host, img2_host, WARMUP_RNG);\r
+ cv::Mat src_host(size, type);\r
+ fill(src_host, 0, 255);\r
\r
- cv::gpu::GpuMat img1(img1_host);\r
- cv::gpu::GpuMat img2(img2_host);\r
- cv::gpu::GpuMat weights1(size, CV_32FC1, cv::Scalar::all(0.5));\r
- cv::gpu::GpuMat weights2(size, CV_32FC1, cv::Scalar::all(0.5));\r
+ cv::gpu::GpuMat src(src_host);\r
cv::gpu::GpuMat dst;\r
\r
+ cv::gpu::pyrUp(src, dst);\r
+\r
TEST_CYCLE()\r
{\r
- cv::gpu::blendLinear(img1, img2, weights1, weights2, dst);\r
+ cv::gpu::pyrUp(src, dst);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(ImgProc, BlendLinear, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(CV_8UC1, CV_32FC1)));\r
+INSTANTIATE_TEST_CASE_P(ImgProc, PyrUp, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),\r
+ MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),\r
+ MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4))));\r
\r
//////////////////////////////////////////////////////////////////////\r
-// AlphaComp\r
+// CvtColor\r
\r
-GPU_PERF_TEST(AlphaComp, cv::gpu::DeviceInfo, cv::Size, perf::MatType, AlphaOp)\r
+GPU_PERF_TEST(CvtColor, cv::gpu::DeviceInfo, cv::Size, MatDepth, CvtColorInfo)\r
{\r
cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
- int alpha_op = GET_PARAM(3);\r
-\r
cv::gpu::setDevice(devInfo.deviceID());\r
\r
- cv::Mat img1_host(size, type);\r
- cv::Mat img2_host(size, type);\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+ CvtColorInfo info = GET_PARAM(3);\r
\r
- declare.in(img1_host, img2_host, WARMUP_RNG);\r
+ cv::Mat src_host(size, CV_MAKETYPE(depth, info.scn));\r
+ fill(src_host, 0, 255);\r
\r
- cv::gpu::GpuMat img1(img1_host);\r
- cv::gpu::GpuMat img2(img2_host);\r
+ cv::gpu::GpuMat src(src_host);\r
cv::gpu::GpuMat dst;\r
\r
- TEST_CYCLE()\r
- {\r
- cv::gpu::alphaComp(img1, img2, dst, alpha_op);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(ImgProc, AlphaComp, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(CV_8UC4, CV_16UC4, CV_32SC4, CV_32FC4),\r
- 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)));\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// Canny\r
-\r
-GPU_PERF_TEST_1(Canny, cv::gpu::DeviceInfo)\r
-{\r
- cv::gpu::DeviceInfo devInfo = GetParam();\r
-\r
- cv::gpu::setDevice(devInfo.deviceID());\r
-\r
- cv::Mat image_host = readImage("perf/1280x1024.jpg", cv::IMREAD_GRAYSCALE);\r
- ASSERT_FALSE(image_host.empty());\r
-\r
- cv::gpu::GpuMat image(image_host);\r
- cv::gpu::GpuMat dst;\r
- cv::gpu::CannyBuf buf;\r
+ cv::gpu::cvtColor(src, dst, info.code, info.dcn);\r
\r
TEST_CYCLE()\r
{\r
- cv::gpu::Canny(image, buf, dst, 50.0, 100.0);\r
+ cv::gpu::cvtColor(src, dst, info.code, info.dcn);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(ImgProc, Canny, ALL_DEVICES);\r
+INSTANTIATE_TEST_CASE_P(ImgProc, CvtColor, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_32F)),\r
+ testing::Values(CvtColorInfo(4, 4, cv::COLOR_RGBA2BGRA),\r
+ CvtColorInfo(4, 1, cv::COLOR_BGRA2GRAY),\r
+ CvtColorInfo(1, 4, cv::COLOR_GRAY2BGRA),\r
+ CvtColorInfo(3, 3, cv::COLOR_BGR2XYZ),\r
+ CvtColorInfo(3, 3, cv::COLOR_XYZ2BGR),\r
+ CvtColorInfo(3, 3, cv::COLOR_BGR2YCrCb),\r
+ CvtColorInfo(3, 3, cv::COLOR_YCrCb2BGR),\r
+ CvtColorInfo(3, 3, cv::COLOR_BGR2YUV),\r
+ CvtColorInfo(3, 3, cv::COLOR_YUV2BGR),\r
+ CvtColorInfo(3, 3, cv::COLOR_BGR2HSV),\r
+ CvtColorInfo(3, 3, cv::COLOR_HSV2BGR),\r
+ CvtColorInfo(3, 3, cv::COLOR_BGR2HLS),\r
+ CvtColorInfo(3, 3, cv::COLOR_HLS2BGR))));\r
\r
//////////////////////////////////////////////////////////////////////\r
-// CalcHist\r
+// SwapChannels\r
\r
-GPU_PERF_TEST(CalcHist, cv::gpu::DeviceInfo, cv::Size)\r
+GPU_PERF_TEST(SwapChannels, cv::gpu::DeviceInfo, cv::Size)\r
{\r
cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
-\r
cv::gpu::setDevice(devInfo.deviceID());\r
\r
- cv::Mat src_host(size, CV_8UC1);\r
+ cv::Size size = GET_PARAM(1);\r
\r
- declare.in(src_host, WARMUP_RNG);\r
+ cv::Mat src_host(size, CV_8UC4);\r
+ fill(src_host, 0, 255);\r
\r
cv::gpu::GpuMat src(src_host);\r
- cv::gpu::GpuMat hist;\r
- cv::gpu::GpuMat buf;\r
+\r
+ const int dstOrder[] = {2, 1, 0, 3};\r
+\r
+ cv::gpu::swapChannels(src, dstOrder);\r
\r
TEST_CYCLE()\r
{\r
- cv::gpu::calcHist(src, hist, buf);\r
+ cv::gpu::swapChannels(src, dstOrder);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(ImgProc, CalcHist, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES));\r
+INSTANTIATE_TEST_CASE_P(ImgProc, SwapChannels, testing::Combine(ALL_DEVICES, GPU_TYPICAL_MAT_SIZES));\r
\r
//////////////////////////////////////////////////////////////////////\r
-// EqualizeHist\r
+// AlphaComp\r
\r
-GPU_PERF_TEST(EqualizeHist, cv::gpu::DeviceInfo, cv::Size)\r
+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)\r
+\r
+GPU_PERF_TEST(AlphaComp, cv::gpu::DeviceInfo, cv::Size, MatType, AlphaOp)\r
{\r
cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
-\r
cv::gpu::setDevice(devInfo.deviceID());\r
\r
- cv::Mat src_host(size, CV_8UC1);\r
+ cv::Size size = GET_PARAM(1);\r
+ int type = GET_PARAM(2);\r
+ int alpha_op = GET_PARAM(3);\r
\r
- declare.in(src_host, WARMUP_RNG);\r
+ cv::Mat img1_host(size, type);\r
+ fill(img1_host, 0, 255);\r
\r
- cv::gpu::GpuMat src(src_host);\r
+ cv::Mat img2_host(size, type);\r
+ fill(img2_host, 0, 255);\r
+\r
+ cv::gpu::GpuMat img1(img1_host);\r
+ cv::gpu::GpuMat img2(img2_host);\r
cv::gpu::GpuMat dst;\r
- cv::gpu::GpuMat hist;\r
- cv::gpu::GpuMat buf;\r
+\r
+ cv::gpu::alphaComp(img1, img2, dst, alpha_op);\r
\r
TEST_CYCLE()\r
{\r
- cv::gpu::equalizeHist(src, dst, hist, buf);\r
+ cv::gpu::alphaComp(img1, img2, dst, alpha_op);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(ImgProc, EqualizeHist, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES));\r
+INSTANTIATE_TEST_CASE_P(ImgProc, AlphaComp, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values(MatType(CV_8UC4), MatType(CV_16UC4), MatType(CV_32SC4), MatType(CV_32FC4)),\r
+ testing::Values(AlphaOp(cv::gpu::ALPHA_OVER),\r
+ AlphaOp(cv::gpu::ALPHA_IN),\r
+ AlphaOp(cv::gpu::ALPHA_OUT),\r
+ AlphaOp(cv::gpu::ALPHA_ATOP),\r
+ AlphaOp(cv::gpu::ALPHA_XOR),\r
+ AlphaOp(cv::gpu::ALPHA_PLUS),\r
+ AlphaOp(cv::gpu::ALPHA_OVER_PREMUL),\r
+ AlphaOp(cv::gpu::ALPHA_IN_PREMUL),\r
+ AlphaOp(cv::gpu::ALPHA_OUT_PREMUL),\r
+ AlphaOp(cv::gpu::ALPHA_ATOP_PREMUL),\r
+ AlphaOp(cv::gpu::ALPHA_XOR_PREMUL),\r
+ AlphaOp(cv::gpu::ALPHA_PLUS_PREMUL),\r
+ AlphaOp(cv::gpu::ALPHA_PREMUL))));\r
\r
//////////////////////////////////////////////////////////////////////\r
// ImagePyramid\r
\r
-GPU_PERF_TEST(ImagePyramid_build, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
+GPU_PERF_TEST(ImagePyramid_build, cv::gpu::DeviceInfo, cv::Size, MatType)\r
{\r
cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
cv::Size size = GET_PARAM(1);\r
int type = GET_PARAM(2);\r
\r
- cv::gpu::setDevice(devInfo.deviceID());\r
-\r
cv::Mat src_host(size, type);\r
-\r
- declare.in(src_host, WARMUP_RNG);\r
+ fill(src_host, 0, 255);\r
\r
cv::gpu::GpuMat src(src_host);\r
\r
cv::gpu::ImagePyramid pyr;\r
\r
+ pyr.build(src, 5);\r
+\r
TEST_CYCLE()\r
{\r
pyr.build(src, 5);\r
}\r
\r
INSTANTIATE_TEST_CASE_P(ImgProc, ImagePyramid_build, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_16UC1, CV_16UC3, CV_16UC4, CV_32FC1, CV_32FC3, CV_32FC4)));\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),\r
+ MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),\r
+ MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4))));\r
\r
-GPU_PERF_TEST(ImagePyramid_getLayer, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
+GPU_PERF_TEST(ImagePyramid_getLayer, cv::gpu::DeviceInfo, cv::Size, MatType)\r
{\r
cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
cv::Size size = GET_PARAM(1);\r
int type = GET_PARAM(2);\r
\r
- cv::gpu::setDevice(devInfo.deviceID());\r
-\r
cv::Mat src_host(size, type);\r
-\r
- declare.in(src_host, WARMUP_RNG);\r
+ fill(src_host, 0, 255);\r
\r
cv::gpu::GpuMat src(src_host);\r
cv::gpu::GpuMat dst;\r
\r
cv::gpu::ImagePyramid pyr(src, 3);\r
\r
+ pyr.getLayer(dst, cv::Size(size.width / 2 + 10, size.height / 2 + 10));\r
+\r
TEST_CYCLE()\r
{\r
pyr.getLayer(dst, cv::Size(size.width / 2 + 10, size.height / 2 + 10));\r
}\r
\r
INSTANTIATE_TEST_CASE_P(ImgProc, ImagePyramid_getLayer, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_16UC1, CV_16UC3, CV_16UC4, CV_32FC1, CV_32FC3, CV_32FC4)));\r
-\r
-\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// MulAndScaleSpectrums\r
-\r
-GPU_PERF_TEST(MulAndScaleSpectrums, cv::gpu::DeviceInfo, cv::Size)\r
-{\r
- cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
- \r
- cv::gpu::setDevice(devInfo.deviceID());\r
-\r
- int type = CV_32FC2;\r
-\r
- cv::Mat src1_host(size, type);\r
- cv::Mat src2_host(size, type);\r
- declare.in(src1_host, src2_host, WARMUP_RNG);\r
-\r
- cv::gpu::GpuMat src1(src1_host);\r
- cv::gpu::GpuMat src2(src2_host);\r
- cv::gpu::GpuMat dst(size, type);\r
- \r
- TEST_CYCLE()\r
- { \r
- cv::gpu::mulSpectrums(src1, src2, dst, cv::DFT_ROWS, false);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(ImgProc, MulAndScaleSpectrums, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES));\r
-\r
-\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// MulAndScaleSpectrumsScale\r
-\r
-\r
-GPU_PERF_TEST(MulAndScaleSpectrumsScale, cv::gpu::DeviceInfo, cv::Size)\r
-{\r
- cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
-\r
- float scale = 1.f / size.area();\r
- int type = CV_32FC2;\r
- \r
- cv::gpu::setDevice(devInfo.deviceID());\r
-\r
- cv::Mat src1_host(size, type);\r
- cv::Mat src2_host(size, type);\r
- declare.in(src1_host, src2_host, WARMUP_RNG);\r
-\r
- cv::gpu::GpuMat src1(src1_host);\r
- cv::gpu::GpuMat src2(src2_host);\r
- cv::gpu::GpuMat dst(size, type);\r
- \r
- TEST_CYCLE()\r
- { \r
- cv::gpu::mulAndScaleSpectrums(src1, src2, dst, cv::DFT_ROWS, scale, false);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(ImgProc, MulAndScaleSpectrumsScale, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES));\r
-\r
-\r
-\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),\r
+ MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),\r
+ MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4))));\r
\r
#endif\r
#ifdef HAVE_CUDA\r
\r
//////////////////////////////////////////////////////////////////////\r
-// Merge\r
+// SetTo\r
\r
-GPU_PERF_TEST(Merge, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
+GPU_PERF_TEST(SetTo, cv::gpu::DeviceInfo, cv::Size, MatType)\r
{\r
cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
cv::gpu::setDevice(devInfo.deviceID());\r
\r
- const int num_channels = 4;\r
-\r
- std::vector<cv::gpu::GpuMat> src(num_channels);\r
- for (int i = 0; i < num_channels; ++i)\r
- src[i] = cv::gpu::GpuMat(size, type, cv::Scalar::all(i)); \r
-\r
- cv::gpu::GpuMat dst;\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::gpu::merge(src, dst);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(MatOp, Merge, testing::Combine(\r
- ALL_DEVICES, \r
- GPU_TYPICAL_MAT_SIZES, \r
- testing::Values(CV_8UC1, CV_16UC1, CV_32FC1)));\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// Split\r
-\r
-GPU_PERF_TEST(Split, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
cv::Size size = GET_PARAM(1);\r
int type = GET_PARAM(2);\r
\r
- cv::gpu::setDevice(devInfo.deviceID());\r
-\r
- const int num_channels = 4;\r
-\r
- cv::gpu::GpuMat src(size, CV_MAKETYPE(type, num_channels), cv::Scalar(1, 2, 3, 4));\r
-\r
- std::vector<cv::gpu::GpuMat> dst(num_channels);\r
- for (int i = 0; i < num_channels; ++i)\r
- dst[i] = cv::gpu::GpuMat(size, type); \r
-\r
- TEST_CYCLE()\r
- {\r
- cv::gpu::split(src, dst);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(MatOp, Split, testing::Combine(\r
- ALL_DEVICES, \r
- GPU_TYPICAL_MAT_SIZES, \r
- testing::Values(CV_8UC1, CV_16UC1, CV_32FC1)));\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// SetTo\r
-\r
-GPU_PERF_TEST(SetTo, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::gpu::setDevice(devInfo.deviceID());\r
-\r
cv::gpu::GpuMat src(size, type);\r
cv::Scalar val(1, 2, 3, 4);\r
\r
+ src.setTo(val);\r
+\r
TEST_CYCLE()\r
{\r
src.setTo(val);\r
}\r
\r
INSTANTIATE_TEST_CASE_P(MatOp, SetTo, testing::Combine(\r
- ALL_DEVICES, \r
- GPU_TYPICAL_MAT_SIZES, \r
- testing::Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_16UC1, CV_16UC3, CV_16UC4, CV_32FC1, CV_32FC3, CV_32FC4)));\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),\r
+ MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),\r
+ MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4),\r
+ MatType(CV_64FC1), MatType(CV_64FC3), MatType(CV_64FC4))));\r
\r
//////////////////////////////////////////////////////////////////////\r
// SetToMasked\r
\r
-GPU_PERF_TEST(SetToMasked, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
+GPU_PERF_TEST(SetToMasked, cv::gpu::DeviceInfo, cv::Size, MatType)\r
{\r
cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
cv::Size size = GET_PARAM(1);\r
int type = GET_PARAM(2);\r
\r
- cv::gpu::setDevice(devInfo.deviceID());\r
-\r
cv::Mat src_host(size, type);\r
- cv::Mat mask_host(size, CV_8UC1);\r
+ fill(src_host, 0, 255);\r
\r
- declare.in(src_host, WARMUP_RNG);\r
+ cv::Mat mask_host(size, CV_8UC1);\r
fill(mask_host, 0, 2);\r
\r
cv::gpu::GpuMat src(src_host);\r
cv::Scalar val(1, 2, 3, 4);\r
cv::gpu::GpuMat mask(mask_host);\r
- \r
+\r
+ src.setTo(val, mask);\r
+\r
TEST_CYCLE()\r
{\r
src.setTo(val, mask);\r
}\r
\r
INSTANTIATE_TEST_CASE_P(MatOp, SetToMasked, testing::Combine(\r
- ALL_DEVICES, \r
- GPU_TYPICAL_MAT_SIZES, \r
- testing::Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_16UC1, CV_16UC3, CV_16UC4, CV_32FC1, CV_32FC3, CV_32FC4)));\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),\r
+ MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),\r
+ MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4),\r
+ MatType(CV_64FC1), MatType(CV_64FC3), MatType(CV_64FC4))));\r
\r
//////////////////////////////////////////////////////////////////////\r
// CopyToMasked\r
\r
-GPU_PERF_TEST(CopyToMasked, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
+GPU_PERF_TEST(CopyToMasked, cv::gpu::DeviceInfo, cv::Size, MatType)\r
{\r
cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
cv::Size size = GET_PARAM(1);\r
int type = GET_PARAM(2);\r
\r
- cv::gpu::setDevice(devInfo.deviceID());\r
-\r
cv::Mat src_host(size, type);\r
- cv::Mat mask_host(size, CV_8UC1);\r
+ fill(src_host, 0, 255);\r
\r
- declare.in(src_host, WARMUP_RNG);\r
+ cv::Mat mask_host(size, CV_8UC1);\r
fill(mask_host, 0, 2);\r
\r
cv::gpu::GpuMat src(src_host);\r
cv::gpu::GpuMat mask(mask_host);\r
cv::gpu::GpuMat dst;\r
- \r
+\r
+ src.copyTo(dst, mask);\r
+\r
TEST_CYCLE()\r
{\r
src.copyTo(dst, mask);\r
}\r
\r
INSTANTIATE_TEST_CASE_P(MatOp, CopyToMasked, testing::Combine(\r
- ALL_DEVICES, \r
- GPU_TYPICAL_MAT_SIZES, \r
- testing::Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_16UC1, CV_16UC3, CV_16UC4, CV_32FC1, CV_32FC3, CV_32FC4)));\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),\r
+ MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),\r
+ MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4),\r
+ MatType(CV_64FC1), MatType(CV_64FC3), MatType(CV_64FC4))));\r
\r
//////////////////////////////////////////////////////////////////////\r
// ConvertTo\r
\r
-GPU_PERF_TEST(ConvertTo, cv::gpu::DeviceInfo, cv::Size, perf::MatType, perf::MatType)\r
+GPU_PERF_TEST(ConvertTo, cv::gpu::DeviceInfo, cv::Size, MatDepth, MatDepth)\r
{\r
cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
- cv::Size size = GET_PARAM(1);\r
- int type1 = GET_PARAM(2);\r
- int type2 = GET_PARAM(3);\r
-\r
cv::gpu::setDevice(devInfo.deviceID());\r
\r
- cv::Mat src_host(size, type1);\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth1 = GET_PARAM(2);\r
+ int depth2 = GET_PARAM(3);\r
\r
- declare.in(src_host, WARMUP_RNG);\r
+ cv::Mat src_host(size, depth1);\r
+ fill(src_host, 0, 255);\r
\r
cv::gpu::GpuMat src(src_host);\r
cv::gpu::GpuMat dst;\r
- \r
+\r
+ src.convertTo(dst, depth2, 0.5, 1.0);\r
+\r
TEST_CYCLE()\r
{\r
- src.convertTo(dst, type2, 0.5, 1.0);\r
+ src.convertTo(dst, depth2, 0.5, 1.0);\r
}\r
}\r
\r
INSTANTIATE_TEST_CASE_P(MatOp, ConvertTo, testing::Combine(\r
- ALL_DEVICES, \r
- GPU_TYPICAL_MAT_SIZES, \r
- testing::Values(CV_8UC1, CV_16UC1, CV_32FC1), \r
- testing::Values(CV_8UC1, CV_16UC1, CV_32FC1)));\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_32F), MatDepth(CV_64F)),\r
+ testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_32F), MatDepth(CV_64F))));\r
\r
#endif\r
\r
#ifdef HAVE_CUDA\r
\r
+///////////////////////////////////////////////////////////////\r
+// HOG\r
+\r
GPU_PERF_TEST_1(HOG, cv::gpu::DeviceInfo)\r
{\r
cv::gpu::DeviceInfo devInfo = GetParam();\r
-\r
cv::gpu::setDevice(devInfo.deviceID());\r
\r
cv::Mat img_host = readImage("gpu/hog/road.png", cv::IMREAD_GRAYSCALE);\r
+ ASSERT_FALSE(img_host.empty());\r
\r
cv::gpu::GpuMat img(img_host);\r
std::vector<cv::Rect> found_locations;\r
cv::gpu::HOGDescriptor hog;\r
hog.setSVMDetector(cv::gpu::HOGDescriptor::getDefaultPeopleDetector());\r
\r
+ hog.detectMultiScale(img, found_locations);\r
+\r
TEST_CYCLE()\r
{\r
hog.detectMultiScale(img, found_locations);\r
\r
INSTANTIATE_TEST_CASE_P(ObjDetect, HOG, ALL_DEVICES);\r
\r
+///////////////////////////////////////////////////////////////\r
+// HaarClassifier\r
\r
GPU_PERF_TEST_1(HaarClassifier, cv::gpu::DeviceInfo)\r
{\r
cv::gpu::setDevice(devInfo.deviceID());\r
\r
cv::Mat img_host = readImage("gpu/haarcascade/group_1_640x480_VGA.pgm", cv::IMREAD_GRAYSCALE);\r
+ ASSERT_FALSE(img_host.empty());\r
\r
cv::gpu::CascadeClassifier_GPU cascade;\r
\r
- if (!cascade.load("haarcascade_frontalface_alt.xml"))\r
- CV_Error(0, "Can't load cascade");\r
+ ASSERT_TRUE(cascade.load(perf::TestBase::getDataPath("gpu/perf/haarcascade_frontalface_alt.xml")));\r
\r
cv::gpu::GpuMat img(img_host);\r
- cv::gpu::GpuMat objects_buffer(1, 100, cv::DataType<cv::Rect>::type);\r
+ cv::gpu::GpuMat objects_buffer;\r
+\r
+ cascade.detectMultiScale(img, objects_buffer);\r
\r
TEST_CYCLE()\r
{\r
\r
INSTANTIATE_TEST_CASE_P(ObjDetect, HaarClassifier, ALL_DEVICES);\r
\r
-\r
-\r
-\r
#endif\r
\r
#include <cstdio>\r
#include <iostream>\r
+\r
#include "cvconfig.h"\r
+\r
#include "opencv2/ts/ts.hpp"\r
#include "opencv2/ts/ts_perf.hpp"\r
+\r
#include "opencv2/core/core.hpp"\r
#include "opencv2/highgui/highgui.hpp"\r
#include "opencv2/gpu/gpu.hpp"\r
+#include "opencv2/calib3d/calib3d.hpp"\r
+\r
#include "perf_utility.hpp"\r
\r
#if GTEST_CREATE_SHARED_LIBRARY\r
void fill(Mat& m, double a, double b)\r
{\r
RNG rng(123456789);\r
- rng.fill(m, RNG::UNIFORM, a, b);\r
+ rng.fill(m, RNG::UNIFORM, Scalar::all(a), Scalar::all(b));\r
}\r
\r
void PrintTo(const CvtColorInfo& info, ostream* os)\r
{\r
- static const char* str[] = \r
+ static const char* str[] =\r
{\r
"BGR2BGRA",\r
"BGRA2BGR",\r
0,\r
0,\r
0,\r
- \r
+\r
"HLS2BGR",\r
"HLS2RGB",\r
\r
0,\r
0,\r
0,\r
- 0 \r
+ 0\r
};\r
\r
*os << str[info.code];\r
return imread(perf::TestBase::getDataPath(fileName), flags);\r
}\r
\r
-bool supportFeature(const DeviceInfo& info, FeatureSet feature)\r
-{\r
- return TargetArchs::builtWith(feature) && info.supports(feature);\r
-}\r
-\r
const vector<DeviceInfo>& devices()\r
{\r
static vector<DeviceInfo> devs;\r
\r
return devs;\r
}\r
-\r
-vector<DeviceInfo> devices(FeatureSet feature)\r
-{\r
- const vector<DeviceInfo>& d = devices();\r
- \r
- vector<DeviceInfo> devs_filtered;\r
-\r
- if (TargetArchs::builtWith(feature))\r
- {\r
- devs_filtered.reserve(d.size());\r
-\r
- for (size_t i = 0, size = d.size(); i < size; ++i)\r
- {\r
- const DeviceInfo& info = d[i];\r
-\r
- if (info.supports(feature))\r
- devs_filtered.push_back(info);\r
- }\r
- }\r
-\r
- return devs_filtered;\r
-}\r
-\r
-\r
\r
void fill(cv::Mat& m, double a, double b);\r
\r
-enum {HORIZONTAL_AXIS = 0, VERTICAL_AXIS = 1, BOTH_AXIS = -1};\r
-\r
using perf::MatType;\r
using perf::MatDepth;\r
\r
CV_ENUM(BorderMode, cv::BORDER_REFLECT101, cv::BORDER_REPLICATE, cv::BORDER_CONSTANT, cv::BORDER_REFLECT, cv::BORDER_WRAP)\r
-CV_ENUM(FlipCode, HORIZONTAL_AXIS, VERTICAL_AXIS, BOTH_AXIS)\r
CV_ENUM(Interpolation, cv::INTER_NEAREST, cv::INTER_LINEAR, cv::INTER_CUBIC)\r
-CV_ENUM(MatchMethod, cv::TM_SQDIFF, cv::TM_SQDIFF_NORMED, cv::TM_CCORR, cv::TM_CCORR_NORMED, cv::TM_CCOEFF, cv::TM_CCOEFF_NORMED)\r
-CV_ENUM(NormType, cv::NORM_INF, cv::NORM_L1, cv::NORM_L2)\r
-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)\r
+CV_ENUM(NormType, cv::NORM_INF, cv::NORM_L1, cv::NORM_L2, cv::NORM_HAMMING)\r
+\r
+struct CvtColorInfo\r
+{\r
+ int scn;\r
+ int dcn;\r
+ int code;\r
+\r
+ explicit CvtColorInfo(int scn_=0, int dcn_=0, int code_=0) : scn(scn_), dcn(dcn_), code(code_) {}\r
+};\r
+\r
+void PrintTo(const CvtColorInfo& info, std::ostream* os);\r
\r
#define IMPLEMENT_PARAM_CLASS(name, type) \\r
class name \\r
}; \\r
inline void PrintTo( name param, std::ostream* os) \\r
{ \\r
- *os << #name << "(" << testing::PrintToString(static_cast< type >(param)) << ")"; \\r
+ *os << #name << " = " << testing::PrintToString(static_cast< type >(param)); \\r
}\r
\r
-struct CvtColorInfo\r
-{\r
- int scn;\r
- int dcn;\r
- int code;\r
-\r
- explicit CvtColorInfo(int scn_=0, int dcn_=0, int code_=0) : scn(scn_), dcn(dcn_), code(code_) {}\r
-};\r
-\r
-void PrintTo(const CvtColorInfo& info, std::ostream* os);\r
+IMPLEMENT_PARAM_CLASS(Channels, int)\r
\r
namespace cv { namespace gpu\r
{\r
\r
cv::Mat readImage(const std::string& fileName, int flags = cv::IMREAD_COLOR);\r
\r
-bool supportFeature(const cv::gpu::DeviceInfo& info, cv::gpu::FeatureSet feature);\r
-\r
const std::vector<cv::gpu::DeviceInfo>& devices();\r
\r
-std::vector<cv::gpu::DeviceInfo> devices(cv::gpu::FeatureSet feature);\r
-\r
#define ALL_DEVICES testing::ValuesIn(devices())\r
-#define DEVICES(feature) testing::ValuesIn(devices(feature))\r
\r
#define GET_PARAM(k) std::tr1::get< k >(GetParam())\r
\r
GPU_PERF_TEST_1(BroxOpticalFlow, cv::gpu::DeviceInfo)\r
{\r
cv::gpu::DeviceInfo devInfo = GetParam();\r
-\r
cv::gpu::setDevice(devInfo.deviceID());\r
\r
cv::Mat frame0_host = readImage("gpu/opticalflow/frame0.png", cv::IMREAD_GRAYSCALE);\r
- cv::Mat frame1_host = readImage("gpu/opticalflow/frame1.png", cv::IMREAD_GRAYSCALE);\r
-\r
ASSERT_FALSE(frame0_host.empty());\r
+\r
+ cv::Mat frame1_host = readImage("gpu/opticalflow/frame1.png", cv::IMREAD_GRAYSCALE);\r
ASSERT_FALSE(frame1_host.empty());\r
\r
frame0_host.convertTo(frame0_host, CV_32FC1, 1.0 / 255.0);\r
\r
cv::gpu::GpuMat frame0(frame0_host);\r
cv::gpu::GpuMat frame1(frame1_host);\r
- cv::gpu::GpuMat u; \r
+ cv::gpu::GpuMat u;\r
cv::gpu::GpuMat v;\r
\r
- cv::gpu::BroxOpticalFlow d_flow(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/, \r
+ cv::gpu::BroxOpticalFlow d_flow(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/,\r
10 /*inner_iterations*/, 77 /*outer_iterations*/, 10 /*solver_iterations*/);\r
\r
+ d_flow(frame0, frame1, u, v);\r
+\r
declare.time(10);\r
\r
TEST_CYCLE()\r
GPU_PERF_TEST_1(InterpolateFrames, cv::gpu::DeviceInfo)\r
{\r
cv::gpu::DeviceInfo devInfo = GetParam();\r
-\r
cv::gpu::setDevice(devInfo.deviceID());\r
\r
cv::Mat frame0_host = readImage("gpu/perf/aloe.jpg", cv::IMREAD_GRAYSCALE);\r
- cv::Mat frame1_host = readImage("gpu/perf/aloeR.jpg", cv::IMREAD_GRAYSCALE);\r
-\r
ASSERT_FALSE(frame0_host.empty());\r
+\r
+ cv::Mat frame1_host = readImage("gpu/perf/aloeR.jpg", cv::IMREAD_GRAYSCALE);\r
ASSERT_FALSE(frame1_host.empty());\r
\r
frame0_host.convertTo(frame0_host, CV_32FC1, 1.0 / 255.0);\r
\r
cv::gpu::GpuMat frame0(frame0_host);\r
cv::gpu::GpuMat frame1(frame1_host);\r
- cv::gpu::GpuMat fu, fv; \r
+ cv::gpu::GpuMat fu, fv;\r
cv::gpu::GpuMat bu, bv;\r
\r
- cv::gpu::BroxOpticalFlow d_flow(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/, \r
+ cv::gpu::BroxOpticalFlow d_flow(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/,\r
10 /*inner_iterations*/, 77 /*outer_iterations*/, 10 /*solver_iterations*/);\r
- \r
+\r
d_flow(frame0, frame1, fu, fv);\r
d_flow(frame1, frame0, bu, bv);\r
\r
cv::gpu::GpuMat newFrame;\r
cv::gpu::GpuMat buf;\r
\r
+ cv::gpu::interpolateFrames(frame0, frame1, fu, fv, bu, bv, 0.5f, newFrame, buf);\r
+\r
TEST_CYCLE()\r
{\r
cv::gpu::interpolateFrames(frame0, frame1, fu, fv, bu, bv, 0.5f, newFrame, buf);\r
GPU_PERF_TEST_1(CreateOpticalFlowNeedleMap, cv::gpu::DeviceInfo)\r
{\r
cv::gpu::DeviceInfo devInfo = GetParam();\r
-\r
cv::gpu::setDevice(devInfo.deviceID());\r
\r
cv::Mat frame0_host = readImage("gpu/perf/aloe.jpg", cv::IMREAD_GRAYSCALE);\r
- cv::Mat frame1_host = readImage("gpu/perf/aloeR.jpg", cv::IMREAD_GRAYSCALE);\r
-\r
ASSERT_FALSE(frame0_host.empty());\r
+\r
+ cv::Mat frame1_host = readImage("gpu/perf/aloeR.jpg", cv::IMREAD_GRAYSCALE);\r
ASSERT_FALSE(frame1_host.empty());\r
\r
frame0_host.convertTo(frame0_host, CV_32FC1, 1.0 / 255.0);\r
cv::gpu::GpuMat frame1(frame1_host);\r
cv::gpu::GpuMat u, v;\r
\r
- cv::gpu::BroxOpticalFlow d_flow(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/, \r
+ cv::gpu::BroxOpticalFlow d_flow(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/,\r
10 /*inner_iterations*/, 77 /*outer_iterations*/, 10 /*solver_iterations*/);\r
- \r
+\r
d_flow(frame0, frame1, u, v);\r
\r
cv::gpu::GpuMat vertex, colors;\r
\r
+ cv::gpu::createOpticalFlowNeedleMap(u, v, vertex, colors);\r
+\r
TEST_CYCLE()\r
{\r
cv::gpu::createOpticalFlowNeedleMap(u, v, vertex, colors);\r
//////////////////////////////////////////////////////\r
// GoodFeaturesToTrack\r
\r
-GPU_PERF_TEST(GoodFeaturesToTrack, cv::gpu::DeviceInfo, double)\r
+IMPLEMENT_PARAM_CLASS(MinDistance, double)\r
+\r
+GPU_PERF_TEST(GoodFeaturesToTrack, cv::gpu::DeviceInfo, MinDistance)\r
{\r
cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
double minDistance = GET_PARAM(1);\r
\r
- cv::gpu::setDevice(devInfo.deviceID());\r
- \r
cv::Mat image_host = readImage("gpu/perf/aloe.jpg", cv::IMREAD_GRAYSCALE);\r
-\r
ASSERT_FALSE(image_host.empty());\r
\r
cv::gpu::GoodFeaturesToTrackDetector_GPU detector(8000, 0.01, minDistance);\r
cv::gpu::GpuMat image(image_host);\r
cv::gpu::GpuMat pts;\r
\r
+ detector(image, pts);\r
+\r
TEST_CYCLE()\r
{\r
detector(image, pts);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(Video, GoodFeaturesToTrack, testing::Combine(ALL_DEVICES, testing::Values(0.0, 3.0)));\r
+INSTANTIATE_TEST_CASE_P(Video, GoodFeaturesToTrack, testing::Combine(\r
+ ALL_DEVICES,\r
+ testing::Values(MinDistance(0.0), MinDistance(3.0))));\r
\r
//////////////////////////////////////////////////////\r
// PyrLKOpticalFlowSparse\r
\r
-GPU_PERF_TEST(PyrLKOpticalFlowSparse, cv::gpu::DeviceInfo, bool, int, int)\r
+IMPLEMENT_PARAM_CLASS(GraySource, bool)\r
+IMPLEMENT_PARAM_CLASS(Points, int)\r
+IMPLEMENT_PARAM_CLASS(WinSize, int)\r
+\r
+GPU_PERF_TEST(PyrLKOpticalFlowSparse, cv::gpu::DeviceInfo, GraySource, Points, WinSize)\r
{\r
cv::gpu::DeviceInfo devInfo = GET_PARAM(0);\r
+ cv::gpu::setDevice(devInfo.deviceID());\r
+\r
bool useGray = GET_PARAM(1);\r
int points = GET_PARAM(2);\r
int win_size = GET_PARAM(3);\r
\r
- cv::gpu::setDevice(devInfo.deviceID());\r
- \r
cv::Mat frame0_host = readImage("gpu/opticalflow/frame0.png", useGray ? cv::IMREAD_GRAYSCALE : cv::IMREAD_COLOR);\r
- cv::Mat frame1_host = readImage("gpu/opticalflow/frame1.png", useGray ? cv::IMREAD_GRAYSCALE : cv::IMREAD_COLOR);\r
-\r
ASSERT_FALSE(frame0_host.empty());\r
+\r
+ cv::Mat frame1_host = readImage("gpu/opticalflow/frame1.png", useGray ? cv::IMREAD_GRAYSCALE : cv::IMREAD_COLOR);\r
ASSERT_FALSE(frame1_host.empty());\r
\r
cv::Mat gray_frame;\r
cv::gpu::GpuMat nextPts;\r
cv::gpu::GpuMat status;\r
\r
+ pyrLK.sparse(frame0, frame1, pts, nextPts, status);\r
+\r
TEST_CYCLE()\r
{\r
pyrLK.sparse(frame0, frame1, pts, nextPts, status);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(Video, PyrLKOpticalFlowSparse, testing::Combine\r
- (\r
- ALL_DEVICES, \r
- testing::Bool(), \r
- testing::Values(1000, 2000, 4000, 8000), \r
- testing::Values(17, 21)\r
- ));\r
+INSTANTIATE_TEST_CASE_P(Video, PyrLKOpticalFlowSparse, testing::Combine(\r
+ ALL_DEVICES,\r
+ testing::Values(GraySource(true), GraySource(false)),\r
+ testing::Values(Points(1000), Points(2000), Points(4000), Points(8000)),\r
+ testing::Values(WinSize(17), WinSize(21))));\r
\r
//////////////////////////////////////////////////////\r
// PyrLKOpticalFlowDense\r
GPU_PERF_TEST_1(PyrLKOpticalFlowDense, cv::gpu::DeviceInfo)\r
{\r
cv::gpu::DeviceInfo devInfo = GetParam();\r
-\r
cv::gpu::setDevice(devInfo.deviceID());\r
\r
cv::Mat frame0_host = readImage("gpu/opticalflow/frame0.png", cv::IMREAD_GRAYSCALE);\r
- cv::Mat frame1_host = readImage("gpu/opticalflow/frame1.png", cv::IMREAD_GRAYSCALE);\r
-\r
ASSERT_FALSE(frame0_host.empty());\r
+\r
+ cv::Mat frame1_host = readImage("gpu/opticalflow/frame1.png", cv::IMREAD_GRAYSCALE);\r
ASSERT_FALSE(frame1_host.empty());\r
\r
cv::gpu::GpuMat frame0(frame0_host);\r
cv::gpu::GpuMat frame1(frame1_host);\r
- cv::gpu::GpuMat u; \r
+ cv::gpu::GpuMat u;\r
cv::gpu::GpuMat v;\r
\r
cv::gpu::PyrLKOpticalFlow pyrLK;\r
\r
+ pyrLK.dense(frame0, frame1, u, v);\r
+\r
declare.time(10);\r
\r
TEST_CYCLE()\r
\r
INSTANTIATE_TEST_CASE_P(Video, PyrLKOpticalFlowDense, ALL_DEVICES);\r
\r
-\r
//////////////////////////////////////////////////////\r
// FarnebackOpticalFlowTest\r
\r
GPU_PERF_TEST_1(FarnebackOpticalFlowTest, cv::gpu::DeviceInfo)\r
{\r
cv::gpu::DeviceInfo devInfo = GetParam();\r
-\r
cv::gpu::setDevice(devInfo.deviceID());\r
\r
cv::Mat frame0_host = readImage("gpu/opticalflow/frame0.png", cv::IMREAD_GRAYSCALE);\r
- cv::Mat frame1_host = readImage("gpu/opticalflow/frame1.png", cv::IMREAD_GRAYSCALE);\r
-\r
ASSERT_FALSE(frame0_host.empty());\r
+\r
+ cv::Mat frame1_host = readImage("gpu/opticalflow/frame1.png", cv::IMREAD_GRAYSCALE);\r
ASSERT_FALSE(frame1_host.empty());\r
\r
cv::gpu::GpuMat frame0(frame0_host);\r
cv::gpu::GpuMat u;\r
cv::gpu::GpuMat v;\r
\r
- cv::gpu::FarnebackOpticalFlow calc;\r
+ cv::gpu::FarnebackOpticalFlow farneback;\r
+\r
+ farneback(frame0, frame1, u, v);\r
\r
declare.time(10);\r
\r
TEST_CYCLE()\r
{\r
- calc(frame0, frame1, u, v);\r
+ farneback(frame0, frame1, u, v);\r
}\r
}\r
\r
+++ /dev/null
-#include "perf_cpu_precomp.hpp"\r
-\r
-#ifdef HAVE_CUDA\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// Transpose\r
-\r
-GPU_PERF_TEST(Transpose, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::Mat src(size, type);\r
-\r
- declare.in(src, WARMUP_RNG);\r
-\r
- cv::Mat dst;\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::transpose(src, dst);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, Transpose, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(CV_8UC1, CV_32SC1, CV_64FC1)));\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// Flip\r
-\r
-GPU_PERF_TEST(Flip, cv::gpu::DeviceInfo, cv::Size, perf::MatType, FlipCode)\r
-{\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
- int flipCode = GET_PARAM(3);\r
-\r
- cv::Mat src(size, type);\r
-\r
- declare.in(src, WARMUP_RNG);\r
-\r
- cv::Mat dst;\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::flip(src, dst, flipCode);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, Flip, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(CV_8UC1, CV_8UC4, CV_32FC1, CV_32FC4),\r
- testing::Values((int) HORIZONTAL_AXIS, (int) VERTICAL_AXIS, (int) BOTH_AXIS)));\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// LUT\r
-\r
-GPU_PERF_TEST(LUT, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::Mat src(size, type);\r
- cv::Mat lut(1, 256, CV_8UC1);\r
-\r
- declare.in(src, lut, WARMUP_RNG);\r
-\r
- cv::Mat dst;\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::LUT(src, lut, dst);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, LUT, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(CV_8UC1, CV_8UC3)));\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// CartToPolar\r
-\r
-GPU_PERF_TEST(CartToPolar, cv::gpu::DeviceInfo, cv::Size)\r
-{\r
- cv::Size size = GET_PARAM(1);\r
-\r
- cv::Mat x(size, CV_32FC1);\r
- cv::Mat y(size, CV_32FC1);\r
-\r
- fill(x, -100.0, 100.0);\r
- fill(y, -100.0, 100.0);\r
-\r
- cv::Mat magnitude;\r
- cv::Mat angle;\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::cartToPolar(x, y, magnitude, angle);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, CartToPolar, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES));\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// PolarToCart\r
-\r
-GPU_PERF_TEST(PolarToCart, cv::gpu::DeviceInfo, cv::Size)\r
-{\r
- cv::Size size = GET_PARAM(1);\r
-\r
- cv::Mat magnitude(size, CV_32FC1);\r
- cv::Mat angle(size, CV_32FC1);\r
-\r
- fill(magnitude, 0.0, 100.0);\r
- fill(angle, 0.0, 360.0);\r
-\r
- cv::Mat x;\r
- cv::Mat y;\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::polarToCart(magnitude, angle, x, y, true);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, PolarToCart, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES));\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// AddMat\r
-\r
-GPU_PERF_TEST(AddMat, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::Mat src1(size, type);\r
- cv::Mat src2(size, type);\r
-\r
- fill(src1, 0.0, 100.0);\r
- fill(src2, 0.0, 100.0);\r
-\r
- cv::Mat dst;\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::add(src1, src2, dst);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, AddMat, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(CV_8UC1, CV_16UC1, CV_32FC1)));\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// AddScalar\r
-\r
-GPU_PERF_TEST(AddScalar, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::Mat src(size, type);\r
-\r
- fill(src, 0.0, 100.0);\r
-\r
- cv::Scalar s(1,2,3,4);\r
- cv::Mat dst;\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::add(src, s, dst);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, AddScalar, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(CV_8UC1, CV_16UC1, CV_32FC1)));\r
-\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// SubtractMat\r
-\r
-GPU_PERF_TEST(SubtractMat, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::Mat src1(size, type);\r
- cv::Mat src2(size, type);\r
-\r
- fill(src1, 0.0, 100.0);\r
- fill(src2, 0.0, 100.0);\r
-\r
- cv::Mat dst;\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::subtract(src1, src2, dst);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, SubtractMat, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(CV_8UC1, CV_16UC1, CV_32FC1)));\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// SubtractScalar\r
-\r
-GPU_PERF_TEST(SubtractScalar, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::Mat src(size, type);\r
-\r
- fill(src, 0.0, 100.0);\r
-\r
- cv::Scalar s(1,2,3,4);\r
- cv::Mat dst;\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::subtract(src, s, dst);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, SubtractScalar, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(CV_8UC1, CV_16UC1, CV_32FC1)));\r
-\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// MultiplyMat\r
-\r
-GPU_PERF_TEST(MultiplyMat, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::Mat src1(size, type);\r
- cv::Mat src2(size, type);\r
-\r
- fill(src1, 0.0, 100.0);\r
- fill(src2, 0.0, 100.0);\r
-\r
- cv::Mat dst;\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::multiply(src1, src2, dst);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, MultiplyMat, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(CV_8UC1, CV_16UC1, CV_32FC1)));\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// MultiplyScalar\r
-\r
-GPU_PERF_TEST(MultiplyScalar, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::Mat src(size, type);\r
-\r
- fill(src, 0.0, 100.0);\r
-\r
- cv::Scalar s(1,2,3,4);\r
- cv::Mat dst;\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::multiply(src, s, dst);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, MultiplyScalar, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(CV_8UC1, CV_16UC1, CV_32FC1)));\r
-\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// DivideMat\r
-\r
-GPU_PERF_TEST(DivideMat, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::Mat src1(size, type);\r
- cv::Mat src2(size, type);\r
-\r
- fill(src1, 0.0, 100.0);\r
- fill(src2, 0.0, 100.0);\r
-\r
- cv::Mat dst;\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::divide(src1, src2, dst);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, DivideMat, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(CV_8UC1, CV_16UC1, CV_32FC1)));\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// DivideScalar\r
-\r
-GPU_PERF_TEST(DivideScalar, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::Mat src(size, type);\r
-\r
- fill(src, 0.0, 100.0);\r
-\r
- cv::Scalar s(1,2,3,4);\r
- cv::Mat dst;\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::divide(src, s, dst);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, DivideScalar, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(CV_8UC1, CV_16UC1, CV_32FC1)));\r
-\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// Exp\r
-\r
-GPU_PERF_TEST(Exp, cv::gpu::DeviceInfo, cv::Size)\r
-{\r
- cv::Size size = GET_PARAM(1);\r
-\r
- cv::Mat src(size, CV_32FC1);\r
-\r
- fill(src, 0.0, 10.0);\r
-\r
- cv::Mat dst;\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::exp(src, dst);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, Exp, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES));\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// Pow\r
-\r
-GPU_PERF_TEST(Pow, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::Mat src(size, type);\r
-\r
- declare.in(src, WARMUP_RNG);\r
-\r
- cv::Mat dst;\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::pow(src, 0.5, dst);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, Pow, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(perf::MatType(CV_32FC1))));\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// Log\r
-\r
-GPU_PERF_TEST(Log, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::Mat src(size, type);\r
-\r
- declare.in(src, WARMUP_RNG);\r
-\r
- cv::Mat dst;\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::log(src, dst);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, Log, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(perf::MatType(CV_32FC1))));\r
-\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// Sqrt\r
-\r
-GPU_PERF_TEST(Sqrt, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::Mat src(size, type);\r
-\r
- declare.in(src, WARMUP_RNG);\r
-\r
- cv::Mat dst;\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::sqrt(src, dst);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, Sqrt, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(perf::MatType(CV_32FC1))));\r
-\r
-\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// Compare\r
-\r
-GPU_PERF_TEST(Compare, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::Mat src1(size, type);\r
- cv::Mat src2(size, type);\r
-\r
- declare.in(src1, src2, WARMUP_RNG);\r
-\r
- cv::Mat dst;\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::compare(src1, src2, dst, cv::CMP_EQ);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, Compare, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(CV_8UC1, CV_16UC1, CV_32FC1)));\r
-\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// CompareScalar\r
-\r
-GPU_PERF_TEST(CompareScalar, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::Mat src1(size, type);\r
- cv::Scalar src2 = cv::Scalar::all(123);\r
-\r
- declare.in(src1, WARMUP_RNG);\r
-\r
- cv::Mat dst;\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::compare(src1, src2, dst, cv::CMP_EQ);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, CompareScalar, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(CV_8UC1, CV_16UC1, CV_32FC1)));\r
-\r
-\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// BitwiseNot\r
-\r
-GPU_PERF_TEST(BitwiseNot, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::Mat src(size, type);\r
-\r
- declare.in(src, WARMUP_RNG);\r
-\r
- cv::Mat dst;\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::bitwise_not(src, dst);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, BitwiseNot, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(CV_8UC1, CV_16UC1, CV_32SC1)));\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// BitwiseAnd\r
-\r
-GPU_PERF_TEST(BitwiseAnd, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::Mat src1(size, type);\r
- cv::Mat src2(size, type);\r
-\r
- declare.in(src1, src2, WARMUP_RNG);\r
-\r
- cv::Mat dst;\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::bitwise_and(src1, src2, dst);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, BitwiseAnd, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(CV_8UC1, CV_16UC1, CV_32SC1)));\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// BitwiseScalarAnd\r
-\r
-GPU_PERF_TEST(BitwiseScalarAnd, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::Mat src(size, type);\r
-\r
- declare.in(src, WARMUP_RNG);\r
-\r
- cv::Mat dst;\r
- cv::Scalar sc = cv::Scalar(123, 123, 123, 123);\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::bitwise_and(src, sc, dst);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, BitwiseScalarAnd, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_16UC1, CV_16UC3, CV_16UC4, CV_32SC1, CV_32SC3, CV_32SC4)));\r
-\r
-\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// BitwiseOr\r
-\r
-GPU_PERF_TEST(BitwiseOr, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::Mat src1(size, type);\r
- cv::Mat src2(size, type);\r
-\r
- declare.in(src1, src2, WARMUP_RNG);\r
-\r
- cv::Mat dst;\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::bitwise_or(src1, src2, dst);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, BitwiseOr, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(CV_8UC1, CV_16UC1, CV_32SC1)));\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// BitwiseScalarOr\r
-\r
-GPU_PERF_TEST(BitwiseScalarOr, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::Mat src(size, type);\r
-\r
- declare.in(src, WARMUP_RNG);\r
-\r
- cv::Mat dst;\r
- cv::Scalar sc = cv::Scalar(123, 123, 123, 123);\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::bitwise_or(src, sc, dst);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, BitwiseScalarOr, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_16UC1, CV_16UC3, CV_16UC4, CV_32SC1, CV_32SC3, CV_32SC4)));\r
-\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// BitwiseXor\r
-\r
-GPU_PERF_TEST(BitwiseXor, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::Mat src1(size, type);\r
- cv::Mat src2(size, type);\r
-\r
- declare.in(src1, src2, WARMUP_RNG);\r
-\r
- cv::Mat dst;\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::bitwise_xor(src1, src2, dst);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, BitwiseXor, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(CV_8UC1, CV_16UC1, CV_32SC1)));\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// BitwiseScalarXor\r
-\r
-GPU_PERF_TEST(BitwiseScalarXor, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::Mat src(size, type);\r
-\r
- declare.in(src, WARMUP_RNG);\r
-\r
- cv::Mat dst;\r
- cv::Scalar sc = cv::Scalar(123, 123, 123, 123);\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::bitwise_xor(src, sc, dst);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, BitwiseScalarXor, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_16UC1, CV_16UC3, CV_16UC4, CV_32SC1, CV_32SC3, CV_32SC4)));\r
-\r
-\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// Min\r
-\r
-GPU_PERF_TEST(Min, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::Mat src1(size, type);\r
- cv::Mat src2(size, type);\r
-\r
- declare.in(src1, src2, WARMUP_RNG);\r
-\r
- cv::Mat dst(size, type);\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::min(src1, src2, dst);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, Min, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(CV_8UC1, CV_16UC1, CV_32SC1)));\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// Max\r
-\r
-GPU_PERF_TEST(Max, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::Mat src1(size, type);\r
- cv::Mat src2(size, type);\r
-\r
- declare.in(src1, src2, WARMUP_RNG);\r
-\r
- cv::Mat dst(size, type);\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::max(src1, src2, dst);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, Max, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(CV_8UC1, CV_16UC1, CV_32SC1)));\r
-\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// Abs\r
-\r
-GPU_PERF_TEST(Abs, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::Mat src1(size, type);\r
- \r
- declare.in(src1, WARMUP_RNG);\r
-\r
- cv::Mat dst(size, type);\r
-\r
- TEST_CYCLE()\r
- {\r
- dst = cv::abs(src1);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, Abs, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(CV_16S, CV_32F)));\r
-\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// AbsDiff\r
-\r
-GPU_PERF_TEST(AbsDiff, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::Mat src1(size, type);\r
- cv::Mat src2(size, type);\r
- \r
- declare.in(src1, src2, WARMUP_RNG);\r
-\r
- cv::Mat dst(size, type);\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::absdiff(src1, src2, dst);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, AbsDiff, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(CV_8UC1, CV_16UC1, CV_32SC1)));\r
-\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// AbsDiffScalar\r
-\r
-GPU_PERF_TEST(AbsDiffScalar, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::Mat src1(size, type);\r
- cv::Scalar src2 = cv::Scalar::all(123);\r
- \r
- declare.in(src1, WARMUP_RNG);\r
-\r
- cv::Mat dst(size, type);\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::absdiff(src1, src2, dst);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, AbsDiffScalar, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(CV_8UC1, CV_16UC1, CV_32SC1)));\r
-\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// Phase\r
-\r
-GPU_PERF_TEST(Phase, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::Mat src1(size, type);\r
- cv::Mat src2(size, type);\r
- \r
- declare.in(src1, src2, WARMUP_RNG);\r
-\r
- cv::Mat dst(size, type);\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::phase(src1, src2, dst, true);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, Phase, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values<perf::MatType>(CV_32FC1) ));\r
-\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// Magnitude\r
-\r
-GPU_PERF_TEST(Magnitude, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::Mat src1(size, type);\r
- cv::Mat src2(size, type);\r
- \r
- declare.in(src1, src2, WARMUP_RNG);\r
-\r
- cv::Mat dst(size, type);\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::magnitude(src1, src2, dst);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, Magnitude, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values<perf::MatType>(CV_32FC1) ));\r
-\r
-\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// MeanStdDev\r
-\r
-GPU_PERF_TEST(MeanStdDev, cv::gpu::DeviceInfo, cv::Size)\r
-{\r
- cv::Size size = GET_PARAM(1);\r
-\r
- cv::Mat src(size, CV_8UC1);\r
-\r
- declare.in(src, WARMUP_RNG);\r
-\r
- cv::Scalar mean;\r
- cv::Scalar stddev;\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::meanStdDev(src, mean, stddev);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, MeanStdDev, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES));\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// Norm\r
-\r
-GPU_PERF_TEST(Norm, cv::gpu::DeviceInfo, cv::Size, perf::MatType, NormType)\r
-{\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
- int normType = GET_PARAM(3);\r
-\r
- cv::Mat src(size, type);\r
-\r
- declare.in(src, WARMUP_RNG);\r
-\r
- double dst;\r
-\r
- TEST_CYCLE()\r
- {\r
- dst = cv::norm(src, normType);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, Norm, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(CV_8UC1, CV_16UC1, CV_32SC1),\r
- testing::Values((int) cv::NORM_INF, (int) cv::NORM_L1, (int) cv::NORM_L2)));\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// NormDiff\r
-\r
-GPU_PERF_TEST(NormDiff, cv::gpu::DeviceInfo, cv::Size, NormType)\r
-{\r
- cv::Size size = GET_PARAM(1);\r
- int normType = GET_PARAM(2);\r
-\r
- cv::Mat src1(size, CV_8UC1);\r
- cv::Mat src2(size, CV_8UC1);\r
-\r
- declare.in(src1, src2, WARMUP_RNG);\r
-\r
- double dst;\r
-\r
- TEST_CYCLE()\r
- {\r
- dst = cv::norm(src1, src2, normType);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, NormDiff, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values((int) cv::NORM_INF, (int) cv::NORM_L1, (int) cv::NORM_L2)));\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// Sum\r
-\r
-GPU_PERF_TEST(Sum, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::Mat src(size, type);\r
-\r
- declare.in(src, WARMUP_RNG);\r
-\r
- cv::Scalar dst;\r
-\r
- TEST_CYCLE()\r
- {\r
- dst = cv::sum(src);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, Sum, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(CV_8UC1, CV_16UC1, CV_32FC1)));\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// MinMaxLoc\r
-\r
-GPU_PERF_TEST(MinMaxLoc, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::Mat src(size, type);\r
-\r
- declare.in(src, WARMUP_RNG);\r
-\r
- double minVal, maxVal;\r
- cv::Point minLoc, maxLoc;\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::minMaxLoc(src, &minVal, &maxVal, &minLoc, &maxLoc);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, MinMaxLoc, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(CV_8UC1, CV_16UC1, CV_32FC1)));\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// CountNonZero\r
-\r
-GPU_PERF_TEST(CountNonZero, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::Mat src(size, type);\r
-\r
- fill(src, 0.0, 1.0);\r
-\r
- int dst;\r
-\r
- TEST_CYCLE()\r
- {\r
- dst = cv::countNonZero(src);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, CountNonZero, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(CV_8UC1, CV_16UC1, CV_32FC1)));\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// AddWeighted\r
-\r
-GPU_PERF_TEST(AddWeighted, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- cv::Mat src1(size, type);\r
- cv::Mat src2(size, type);\r
-\r
- fill(src1, 0.0, 100.0);\r
- fill(src2, 0.0, 100.0);\r
-\r
- cv::Mat dst;\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::addWeighted(src1, 0.5, src2, 0.5, 0.0, dst);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, AddWeighted, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(CV_8UC1, CV_16UC1, CV_32FC1)));\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// Reduce\r
-\r
-GPU_PERF_TEST(Reduce, cv::gpu::DeviceInfo, cv::Size, perf::MatType, FlipCode)\r
-{\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
- int dim = GET_PARAM(3);\r
-\r
- cv::Mat src(size, type);\r
-\r
- fill(src, 0.0, 10.0);\r
-\r
- cv::Mat dst;\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::reduce(src, dst, dim, CV_REDUCE_MIN);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, Reduce, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(CV_8UC1, CV_16UC1, CV_32FC1),\r
- testing::Values((int) HORIZONTAL_AXIS, (int) VERTICAL_AXIS)));\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// GEMM\r
-\r
-GPU_PERF_TEST(GEMM, cv::gpu::DeviceInfo, cv::Size)\r
-{\r
- cv::Size size = GET_PARAM(1);\r
-\r
- cv::Mat src1(size, CV_32FC1);\r
- cv::Mat src2(size, CV_32FC1);\r
- cv::Mat src3(size, CV_32FC1);\r
-\r
- fill(src1, 0.0, 10.0);\r
- fill(src2, 0.0, 10.0);\r
- fill(src3, 0.0, 10.0);\r
-\r
- cv::Mat dst;\r
-\r
- declare.time(15.0);\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::gemm(src1, src2, 1.0, src3, 1.0, dst);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(Arithm, GEMM, testing::Combine(\r
- ALL_DEVICES,\r
- testing::Values(cv::Size(512, 512), cv::Size(1024, 1024))));\r
-\r
-#endif\r
#ifdef HAVE_CUDA\r
\r
//////////////////////////////////////////////////////////////////////\r
+// StereoBM\r
+\r
+GPU_PERF_TEST_1(StereoBM, cv::gpu::DeviceInfo)\r
+{\r
+ cv::Mat img_l = readImage("gpu/perf/aloe.jpg", cv::IMREAD_GRAYSCALE);\r
+ ASSERT_FALSE(img_l.empty());\r
+\r
+ cv::Mat img_r = readImage("gpu/perf/aloeR.jpg", cv::IMREAD_GRAYSCALE);\r
+ ASSERT_FALSE(img_r.empty());\r
+\r
+ cv::StereoBM bm(0, 256);\r
+\r
+ cv::Mat dst;\r
+\r
+ bm(img_l, img_r, dst);\r
+\r
+ declare.time(5.0);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ bm(img_l, img_r, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Calib3D, StereoBM, ALL_DEVICES);\r
+\r
+//////////////////////////////////////////////////////////////////////\r
// ProjectPoints\r
\r
-GPU_PERF_TEST_1(ProjectPoints, cv::gpu::DeviceInfo)\r
+IMPLEMENT_PARAM_CLASS(Count, int)\r
+\r
+GPU_PERF_TEST(ProjectPoints, cv::gpu::DeviceInfo, Count)\r
{\r
- cv::Mat src(1, 10000, CV_32FC3);\r
+ int count = GET_PARAM(1);\r
\r
- declare.in(src, WARMUP_RNG);\r
+ cv::Mat src(1, count, CV_32FC3);\r
+ fill(src, -100, 100);\r
\r
+ cv::Mat rvec = cv::Mat::ones(1, 3, CV_32FC1);\r
+ cv::Mat tvec = cv::Mat::ones(1, 3, CV_32FC1);\r
+ cv::Mat camera_mat = cv::Mat::ones(3, 3, CV_32FC1);\r
cv::Mat dst;\r
\r
+ cv::projectPoints(src, rvec, tvec, camera_mat, cv::noArray(), dst);\r
+\r
TEST_CYCLE()\r
{\r
- cv::projectPoints(src, cv::Mat::ones(1, 3, CV_32FC1), cv::Mat::ones(1, 3, CV_32FC1), cv::Mat::ones(3, 3, CV_32FC1), cv::Mat(), dst);\r
+ cv::projectPoints(src, rvec, tvec, camera_mat, cv::noArray(), dst);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(Calib3D, ProjectPoints, ALL_DEVICES);\r
+INSTANTIATE_TEST_CASE_P(Calib3D, ProjectPoints, testing::Combine(\r
+ ALL_DEVICES,\r
+ testing::Values<Count>(5000, 10000, 20000)));\r
\r
//////////////////////////////////////////////////////////////////////\r
// SolvePnPRansac\r
\r
-GPU_PERF_TEST_1(SolvePnPRansac, cv::gpu::DeviceInfo)\r
+GPU_PERF_TEST(SolvePnPRansac, cv::gpu::DeviceInfo, Count)\r
{\r
- cv::Mat object(1, 10000, CV_32FC3);\r
- cv::Mat image(1, 10000, CV_32FC2);\r
+ int count = GET_PARAM(1);\r
+\r
+ cv::Mat object(1, count, CV_32FC3);\r
+ fill(object, -100, 100);\r
\r
- declare.in(object, image, WARMUP_RNG);\r
+ cv::Mat camera_mat(3, 3, CV_32FC1);\r
+ fill(camera_mat, 0.5, 1);\r
+ camera_mat.at<float>(0, 1) = 0.f;\r
+ camera_mat.at<float>(1, 0) = 0.f;\r
+ camera_mat.at<float>(2, 0) = 0.f;\r
+ camera_mat.at<float>(2, 1) = 0.f;\r
\r
- cv::Mat rvec, tvec;\r
+ cv::Mat dist_coef(1, 8, CV_32F, cv::Scalar::all(0));\r
\r
- declare.time(3.0);\r
+ std::vector<cv::Point2f> image_vec;\r
+ cv::Mat rvec_gold(1, 3, CV_32FC1);\r
+ fill(rvec_gold, 0, 1);\r
+ cv::Mat tvec_gold(1, 3, CV_32FC1);\r
+ fill(tvec_gold, 0, 1);\r
+ cv::projectPoints(object, rvec_gold, tvec_gold, camera_mat, dist_coef, image_vec);\r
+\r
+ cv::Mat image(1, count, CV_32FC2, &image_vec[0]);\r
+\r
+ cv::Mat rvec;\r
+ cv::Mat tvec;\r
+\r
+ cv::solvePnPRansac(object, image, camera_mat, dist_coef, rvec, tvec);\r
+\r
+ declare.time(10.0);\r
\r
TEST_CYCLE()\r
{\r
- cv::solvePnPRansac(object, image, cv::Mat::ones(3, 3, CV_32FC1), cv::Mat(1, 8, CV_32F, cv::Scalar::all(0)), rvec, tvec);\r
+ cv::solvePnPRansac(object, image, camera_mat, dist_coef, rvec, tvec);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(Calib3D, SolvePnPRansac, ALL_DEVICES);\r
+INSTANTIATE_TEST_CASE_P(Calib3D, SolvePnPRansac, testing::Combine(\r
+ ALL_DEVICES,\r
+ testing::Values<Count>(5000, 10000, 20000)));\r
\r
//////////////////////////////////////////////////////////////////////\r
-// StereoBM\r
+// ReprojectImageTo3D\r
\r
-GPU_PERF_TEST_1(StereoBM, cv::gpu::DeviceInfo)\r
+GPU_PERF_TEST(ReprojectImageTo3D, cv::gpu::DeviceInfo, cv::Size, MatDepth)\r
{\r
- cv::Mat img_l = readImage("gpu/perf/aloe.jpg", cv::IMREAD_GRAYSCALE);\r
- cv::Mat img_r = readImage("gpu/perf/aloeR.jpg", cv::IMREAD_GRAYSCALE);\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
\r
- ASSERT_FALSE(img_l.empty());\r
- ASSERT_FALSE(img_r.empty());\r
+ cv::Mat src(size, depth);\r
+ fill(src, 5.0, 30.0);\r
\r
- cv::Mat dst;\r
+ cv::Mat Q(4, 4, CV_32FC1);\r
+ fill(Q, 0.1, 1.0);\r
\r
- cv::StereoBM bm(0, 256);\r
+ cv::Mat dst;\r
\r
- declare.time(5.0);\r
+ cv::reprojectImageTo3D(src, dst, Q);\r
\r
TEST_CYCLE()\r
{\r
- bm(img_l, img_r, dst);\r
+ cv::reprojectImageTo3D(src, dst, Q);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(Calib3D, StereoBM, ALL_DEVICES);\r
+INSTANTIATE_TEST_CASE_P(Calib3D, ReprojectImageTo3D, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16S)));\r
\r
#endif\r
\r
--- /dev/null
+#include "perf_cpu_precomp.hpp"\r
+\r
+#ifdef HAVE_CUDA\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Merge\r
+\r
+GPU_PERF_TEST(Merge, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels)\r
+{\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+ int channels = GET_PARAM(3);\r
+\r
+ std::vector<cv::Mat> src(channels);\r
+ for (int i = 0; i < channels; ++i)\r
+ src[i] = cv::Mat(size, depth, cv::Scalar::all(i));\r
+\r
+ cv::Mat dst;\r
+\r
+ cv::merge(src, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::merge(src, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Merge, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F, CV_64F),\r
+ testing::Values<Channels>(2, 3, 4)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Split\r
+\r
+GPU_PERF_TEST(Split, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels)\r
+{\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+ int channels = GET_PARAM(3);\r
+\r
+ cv::Mat src(size, CV_MAKE_TYPE(depth, channels), cv::Scalar(1, 2, 3, 4));\r
+\r
+ std::vector<cv::Mat> dst;\r
+\r
+ cv::split(src, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::split(src, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Split, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F, CV_64F),\r
+ testing::Values<Channels>(2, 3, 4)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Add_Mat\r
+\r
+GPU_PERF_TEST(Add_Mat, cv::gpu::DeviceInfo, cv::Size, MatDepth)\r
+{\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+\r
+ cv::Mat src1(size, depth);\r
+ fill(src1, 0.0, 100.0);\r
+\r
+ cv::Mat src2(size, depth);\r
+ fill(src2, 0.0, 100.0);\r
+\r
+ cv::Mat dst;\r
+\r
+ cv::add(src1, src2, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::add(src1, src2, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Add_Mat, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F, CV_64F)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Add_Scalar\r
+\r
+GPU_PERF_TEST(Add_Scalar, cv::gpu::DeviceInfo, cv::Size, MatDepth)\r
+{\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+\r
+ cv::Mat src(size, depth);\r
+ fill(src, 0.0, 100.0);\r
+\r
+ cv::Scalar s(1, 2, 3, 4);\r
+ cv::Mat dst;\r
+\r
+ cv::add(src, s, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::add(src, s, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Add_Scalar, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F, CV_64F)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Subtract_Mat\r
+\r
+GPU_PERF_TEST(Subtract_Mat, cv::gpu::DeviceInfo, cv::Size, MatDepth)\r
+{\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+\r
+ cv::Mat src1(size, depth);\r
+ fill(src1, 0.0, 100.0);\r
+\r
+ cv::Mat src2(size, depth);\r
+ fill(src2, 0.0, 100.0);\r
+\r
+ cv::Mat dst;\r
+\r
+ cv::subtract(src1, src2, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::subtract(src1, src2, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Subtract_Mat, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F, CV_64F)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Subtract_Scalar\r
+\r
+GPU_PERF_TEST(Subtract_Scalar, cv::gpu::DeviceInfo, cv::Size, MatDepth)\r
+{\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+\r
+ cv::Mat src(size, depth);\r
+ fill(src, 0.0, 100.0);\r
+\r
+ cv::Scalar s(1, 2, 3, 4);\r
+ cv::Mat dst;\r
+\r
+ cv::subtract(src, s, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::subtract(src, s, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Subtract_Scalar, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F, CV_64F)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Multiply_Mat\r
+\r
+GPU_PERF_TEST(Multiply_Mat, cv::gpu::DeviceInfo, cv::Size, MatDepth)\r
+{\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+\r
+ cv::Mat src1(size, depth);\r
+ fill(src1, 0.0, 100.0);\r
+\r
+ cv::Mat src2(size, depth);\r
+ fill(src2, 0.0, 100.0);\r
+\r
+ cv::Mat dst;\r
+\r
+ cv::multiply(src1, src2, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::multiply(src1, src2, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Multiply_Mat, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F, CV_64F)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Multiply_Scalar\r
+\r
+GPU_PERF_TEST(Multiply_Scalar, cv::gpu::DeviceInfo, cv::Size, MatDepth)\r
+{\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+\r
+ cv::Mat src(size, depth);\r
+ fill(src, 0.0, 100.0);\r
+\r
+ cv::Scalar s(1, 2, 3, 4);\r
+ cv::Mat dst;\r
+\r
+ cv::multiply(src, s, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::multiply(src, s, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Multiply_Scalar, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F, CV_64F)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Divide_Mat\r
+\r
+GPU_PERF_TEST(Divide_Mat, cv::gpu::DeviceInfo, cv::Size, MatDepth)\r
+{\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+\r
+ cv::Mat src1(size, depth);\r
+ fill(src1, 0.0, 100.0);\r
+\r
+ cv::Mat src2(size, depth);\r
+ fill(src2, 0.0, 100.0);\r
+\r
+ cv::Mat dst;\r
+\r
+ cv::divide(src1, src2, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::divide(src1, src2, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Divide_Mat, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F, CV_64F)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Divide_Scalar\r
+\r
+GPU_PERF_TEST(Divide_Scalar, cv::gpu::DeviceInfo, cv::Size, MatDepth)\r
+{\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+\r
+ cv::Mat src(size, depth);\r
+ fill(src, 0.0, 100.0);\r
+\r
+ cv::Scalar s(1, 2, 3, 4);\r
+ cv::Mat dst;\r
+\r
+ cv::divide(src, s, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::divide(src, s, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Divide_Scalar, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F, CV_64F)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Divide_Scalar_Inv\r
+\r
+GPU_PERF_TEST(Divide_Scalar_Inv, cv::gpu::DeviceInfo, cv::Size, MatDepth)\r
+{\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+\r
+ cv::Mat src(size, depth);\r
+ fill(src, 0.0, 100.0);\r
+\r
+ double scale = 100.0;\r
+ cv::Mat dst;\r
+\r
+ cv::divide(scale, src, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::divide(scale, src, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Divide_Scalar_Inv, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F, CV_64F)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// AbsDiff_Mat\r
+\r
+GPU_PERF_TEST(AbsDiff_Mat, cv::gpu::DeviceInfo, cv::Size, MatDepth)\r
+{\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+\r
+ cv::Mat src1(size, depth);\r
+ fill(src1, 0.0, 100.0);\r
+\r
+ cv::Mat src2(size, depth);\r
+ fill(src2, 0.0, 100.0);\r
+\r
+ cv::Mat dst;\r
+\r
+ cv::absdiff(src1, src2, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::absdiff(src1, src2, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, AbsDiff_Mat, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F, CV_64F)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// AbsDiff_Scalar\r
+\r
+GPU_PERF_TEST(AbsDiff_Scalar, cv::gpu::DeviceInfo, cv::Size, MatDepth)\r
+{\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+\r
+ cv::Mat src(size, depth);\r
+ fill(src, 0.0, 100.0);\r
+\r
+ cv::Scalar s(1, 2, 3, 4);\r
+ cv::Mat dst;\r
+\r
+ cv::absdiff(src, s, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::absdiff(src, s, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, AbsDiff_Scalar, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F, CV_64F)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Sqrt\r
+\r
+GPU_PERF_TEST(Sqrt, cv::gpu::DeviceInfo, cv::Size, MatDepth)\r
+{\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+\r
+ cv::Mat src(size, depth);\r
+ fill(src, 0.0, 100.0);\r
+\r
+ cv::Mat dst;\r
+\r
+ cv::sqrt(src, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::sqrt(src, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Sqrt, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16S, CV_32F)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Log\r
+\r
+GPU_PERF_TEST(Log, cv::gpu::DeviceInfo, cv::Size, MatDepth)\r
+{\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+\r
+ cv::Mat src(size, depth);\r
+ fill(src, 1.0, 100.0);\r
+\r
+ cv::Mat dst;\r
+\r
+ cv::log(src, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::log(src, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Log, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16S, CV_32F)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Exp\r
+\r
+GPU_PERF_TEST(Exp, cv::gpu::DeviceInfo, cv::Size, MatDepth)\r
+{\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+\r
+ cv::Mat src(size, depth);\r
+ fill(src, 1.0, 10.0);\r
+\r
+ cv::Mat dst;\r
+\r
+ cv::exp(src, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::exp(src, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Exp, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16S, CV_32F)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Pow\r
+\r
+GPU_PERF_TEST(Pow, cv::gpu::DeviceInfo, cv::Size, MatDepth)\r
+{\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+\r
+ cv::Mat src(size, depth);\r
+ fill(src, 1.0, 10.0);\r
+\r
+ cv::Mat dst;\r
+\r
+ cv::pow(src, 2.3, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::pow(src, 2.3, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Pow, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16S, CV_32F)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Compare_Mat\r
+\r
+CV_ENUM(CmpCode, cv::CMP_EQ, cv::CMP_GT, cv::CMP_GE, cv::CMP_LT, cv::CMP_LE, cv::CMP_NE)\r
+#define ALL_CMP_CODES testing::Values(CmpCode(cv::CMP_EQ), CmpCode(cv::CMP_NE), CmpCode(cv::CMP_GT), CmpCode(cv::CMP_GE), CmpCode(cv::CMP_LT), CmpCode(cv::CMP_LE))\r
+\r
+GPU_PERF_TEST(Compare_Mat, cv::gpu::DeviceInfo, cv::Size, MatDepth, CmpCode)\r
+{\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+ int cmp_code = GET_PARAM(3);\r
+\r
+ cv::Mat src1(size, depth);\r
+ fill(src1, 0, 100.0);\r
+\r
+ cv::Mat src2(size, depth);\r
+ fill(src2, 0, 100.0);\r
+\r
+ cv::Mat dst;\r
+\r
+ cv::compare(src1, src2, dst, cmp_code);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::compare(src1, src2, dst, cmp_code);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Compare_Mat, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F, CV_64F),\r
+ ALL_CMP_CODES));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Compare_Scalar\r
+\r
+GPU_PERF_TEST(Compare_Scalar, cv::gpu::DeviceInfo, cv::Size, MatDepth, CmpCode)\r
+{\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+ int cmp_code = GET_PARAM(3);\r
+\r
+ cv::Mat src(size, depth);\r
+ fill(src, 0, 100.0);\r
+\r
+ cv::Scalar s = cv::Scalar::all(50);\r
+ cv::Mat dst;\r
+\r
+ cv::compare(src, s, dst, cmp_code);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::compare(src, s, dst, cmp_code);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Compare_Scalar, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F, CV_64F),\r
+ ALL_CMP_CODES));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Bitwise_Not\r
+\r
+GPU_PERF_TEST(Bitwise_Not, cv::gpu::DeviceInfo, cv::Size, MatDepth)\r
+{\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+\r
+ cv::Mat src(size, depth);\r
+ fill(src, 0, 100.0);\r
+\r
+ cv::Mat dst;\r
+\r
+ cv::bitwise_not(src, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::bitwise_not(src, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Bitwise_Not, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32S)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Bitwise_And_Mat\r
+\r
+GPU_PERF_TEST(Bitwise_And_Mat, cv::gpu::DeviceInfo, cv::Size, MatDepth)\r
+{\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+\r
+ cv::Mat src1(size, depth);\r
+ fill(src1, 0, 100.0);\r
+\r
+ cv::Mat src2(size, depth);\r
+ fill(src2, 0, 100.0);\r
+\r
+ cv::Mat dst;\r
+\r
+ cv::bitwise_and(src1, src2, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::bitwise_and(src1, src2, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Bitwise_And_Mat, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32S)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Bitwise_And_Scalar\r
+\r
+GPU_PERF_TEST(Bitwise_And_Scalar, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels)\r
+{\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+ int channels = GET_PARAM(3);\r
+\r
+ int type = CV_MAKE_TYPE(depth, channels);\r
+\r
+ cv::Mat src(size, type);\r
+ fill(src, 0, 100.0);\r
+\r
+ cv::Scalar s = cv::Scalar(50, 50, 50, 50);\r
+ cv::Mat dst;\r
+\r
+ cv::bitwise_and(src, s, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::bitwise_and(src, s, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Bitwise_And_Scalar, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32S),\r
+ testing::Values<Channels>(1, 3, 4)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Bitwise_Or_Mat\r
+\r
+GPU_PERF_TEST(Bitwise_Or_Mat, cv::gpu::DeviceInfo, cv::Size, MatDepth)\r
+{\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+\r
+ cv::Mat src1(size, depth);\r
+ fill(src1, 0, 100.0);\r
+\r
+ cv::Mat src2(size, depth);\r
+ fill(src2, 0, 100.0);\r
+\r
+ cv::Mat dst;\r
+\r
+ cv::bitwise_or(src1, src2, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::bitwise_or(src1, src2, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Bitwise_Or_Mat, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32S)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Bitwise_Or_Scalar\r
+\r
+GPU_PERF_TEST(Bitwise_Or_Scalar, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels)\r
+{\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+ int channels = GET_PARAM(3);\r
+\r
+ int type = CV_MAKE_TYPE(depth, channels);\r
+\r
+ cv::Mat src(size, type);\r
+ fill(src, 0, 100.0);\r
+\r
+ cv::Scalar s = cv::Scalar(50, 50, 50, 50);\r
+ cv::Mat dst;\r
+\r
+ cv::bitwise_or(src, s, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::bitwise_or(src, s, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Bitwise_Or_Scalar, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32S),\r
+ testing::Values<Channels>(1, 3, 4)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Bitwise_Xor_Mat\r
+\r
+GPU_PERF_TEST(Bitwise_Xor_Mat, cv::gpu::DeviceInfo, cv::Size, MatDepth)\r
+{\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+\r
+ cv::Mat src1(size, depth);\r
+ fill(src1, 0, 100.0);\r
+\r
+ cv::Mat src2(size, depth);\r
+ fill(src2, 0, 100.0);\r
+\r
+ cv::Mat dst;\r
+\r
+ cv::bitwise_xor(src1, src2, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::bitwise_xor(src1, src2, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Bitwise_Xor_Mat, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32S)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Bitwise_Xor_Scalar\r
+\r
+GPU_PERF_TEST(Bitwise_Xor_Scalar, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels)\r
+{\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+ int channels = GET_PARAM(3);\r
+\r
+ int type = CV_MAKE_TYPE(depth, channels);\r
+\r
+ cv::Mat src(size, type);\r
+ fill(src, 0, 100.0);\r
+\r
+ cv::Scalar s = cv::Scalar(50, 50, 50, 50);\r
+ cv::Mat dst;\r
+\r
+ cv::bitwise_xor(src, s, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::bitwise_xor(src, s, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Bitwise_Xor_Scalar, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32S),\r
+ testing::Values<Channels>(1, 3, 4)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Min_Mat\r
+\r
+GPU_PERF_TEST(Min_Mat, cv::gpu::DeviceInfo, cv::Size, MatDepth)\r
+{\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+\r
+ cv::Mat src1(size, depth);\r
+ fill(src1, 0, 255.0);\r
+\r
+ cv::Mat src2(size, depth);\r
+ fill(src2, 0, 255.0);\r
+\r
+ cv::Mat dst;\r
+\r
+ cv::min(src1, src2, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::min(src1, src2, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Min_Mat, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Min_Scalar\r
+\r
+GPU_PERF_TEST(Min_Scalar, cv::gpu::DeviceInfo, cv::Size, MatDepth)\r
+{\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+\r
+ cv::Mat src(size, depth);\r
+ fill(src, 0, 255.0);\r
+\r
+ double val = 50.0;\r
+ cv::Mat dst;\r
+\r
+ cv::min(src, val, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::min(src, val, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Min_Scalar, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Max_Mat\r
+\r
+GPU_PERF_TEST(Max_Mat, cv::gpu::DeviceInfo, cv::Size, MatDepth)\r
+{\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+\r
+ cv::Mat src1(size, depth);\r
+ fill(src1, 0, 255.0);\r
+\r
+ cv::Mat src2(size, depth);\r
+ fill(src2, 0, 255.0);\r
+\r
+ cv::Mat dst;\r
+\r
+ cv::max(src1, src2, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::max(src1, src2, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Max_Mat, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Max_Scalar\r
+\r
+GPU_PERF_TEST(Max_Scalar, cv::gpu::DeviceInfo, cv::Size, MatDepth)\r
+{\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+\r
+ cv::Mat src(size, depth);\r
+ fill(src, 0, 255.0);\r
+\r
+ double val = 50.0;\r
+ cv::Mat dst;\r
+\r
+ cv::max(src, val, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::max(src, val, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Max_Scalar, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// AddWeighted\r
+\r
+GPU_PERF_TEST(AddWeighted, cv::gpu::DeviceInfo, cv::Size, MatDepth, MatDepth, MatDepth)\r
+{\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth1 = GET_PARAM(2);\r
+ int depth2 = GET_PARAM(3);\r
+ int dst_depth = GET_PARAM(4);\r
+\r
+ cv::Mat src1(size, depth1);\r
+ fill(src1, 0, 100.0);\r
+\r
+ cv::Mat src2(size, depth2);\r
+ fill(src2, 0, 100.0);\r
+\r
+ cv::Mat dst;\r
+\r
+ cv::addWeighted(src1, 0.5, src2, 0.5, 10.0, dst, dst_depth);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::addWeighted(src1, 0.5, src2, 0.5, 10.0, dst, dst_depth);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, AddWeighted, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F, CV_64F),\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F, CV_64F),\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F, CV_64F)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// GEMM\r
+\r
+CV_FLAGS(GemmFlags, 0, cv::GEMM_1_T, cv::GEMM_2_T, cv::GEMM_3_T)\r
+#define ALL_GEMM_FLAGS testing::Values(GemmFlags(0), GemmFlags(cv::GEMM_1_T), GemmFlags(cv::GEMM_2_T), GemmFlags(cv::GEMM_3_T), GemmFlags(cv::GEMM_1_T | cv::GEMM_2_T), GemmFlags(cv::GEMM_1_T | cv::GEMM_3_T), GemmFlags(cv::GEMM_1_T | cv::GEMM_2_T | cv::GEMM_3_T))\r
+\r
+GPU_PERF_TEST(GEMM, cv::gpu::DeviceInfo, cv::Size, MatType, GemmFlags)\r
+{\r
+ cv::Size size = GET_PARAM(1);\r
+ int type = GET_PARAM(2);\r
+ int flags = GET_PARAM(3);\r
+\r
+ cv::Mat src1(size, type);\r
+ fill(src1, 0.0, 10.0);\r
+\r
+ cv::Mat src2(size, type);\r
+ fill(src2, 0.0, 10.0);\r
+\r
+ cv::Mat src3(size, type);\r
+ fill(src3, 0.0, 10.0);\r
+\r
+ cv::Mat dst;\r
+\r
+ cv::gemm(src1, src2, 1.0, src3, 1.0, dst, flags);\r
+\r
+ declare.time(50.0);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::gemm(src1, src2, 1.0, src3, 1.0, dst, flags);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, GEMM, testing::Combine(\r
+ ALL_DEVICES,\r
+ testing::Values(cv::Size(512, 512), cv::Size(1024, 1024)),\r
+ testing::Values<MatType>(CV_32FC1, CV_32FC2, CV_64FC1, CV_64FC2),\r
+ ALL_GEMM_FLAGS));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Transpose\r
+\r
+GPU_PERF_TEST(Transpose, cv::gpu::DeviceInfo, cv::Size, MatType)\r
+{\r
+ cv::Size size = GET_PARAM(1);\r
+ int type = GET_PARAM(2);\r
+\r
+ cv::Mat src(size, type);\r
+ fill(src, 0.0, 100.0);\r
+\r
+ cv::Mat dst;\r
+\r
+ cv::transpose(src, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::transpose(src, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Transpose, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatType>(CV_8UC1, CV_8UC4, CV_16UC2, CV_16SC2, CV_32SC1, CV_32SC2, CV_64FC1)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Flip\r
+\r
+enum {FLIP_BOTH = 0, FLIP_X = 1, FLIP_Y = -1};\r
+CV_ENUM(FlipCode, FLIP_BOTH, FLIP_X, FLIP_Y)\r
+#define ALL_FLIP_CODES testing::Values(FlipCode(FLIP_BOTH), FlipCode(FLIP_X), FlipCode(FLIP_Y))\r
+\r
+GPU_PERF_TEST(Flip, cv::gpu::DeviceInfo, cv::Size, MatType, FlipCode)\r
+{\r
+ cv::Size size = GET_PARAM(1);\r
+ int type = GET_PARAM(2);\r
+ int flipCode = GET_PARAM(3);\r
+\r
+ cv::Mat src(size, type);\r
+ fill(src, 0.0, 100.0);\r
+\r
+ cv::Mat dst;\r
+\r
+ cv::flip(src, dst, flipCode);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::flip(src, dst, flipCode);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Flip, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatType>(CV_8UC1, CV_8UC3, CV_8UC4, CV_16UC1, CV_16UC3, CV_16UC4, CV_32FC1, CV_32FC3, CV_32FC4),\r
+ ALL_FLIP_CODES));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// LUT_OneChannel\r
+\r
+GPU_PERF_TEST(LUT_OneChannel, cv::gpu::DeviceInfo, cv::Size, MatType)\r
+{\r
+ cv::Size size = GET_PARAM(1);\r
+ int type = GET_PARAM(2);\r
+\r
+ cv::Mat src(size, type);\r
+ fill(src, 0.0, 100.0);\r
+\r
+ cv::Mat lut(1, 256, CV_8UC1);\r
+ fill(lut, 0.0, 100.0);\r
+\r
+ cv::Mat dst;\r
+\r
+ cv::LUT(src, lut, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::LUT(src, lut, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, LUT_OneChannel, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatType>(CV_8UC1, CV_8UC3)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// LUT_MultiChannel\r
+\r
+GPU_PERF_TEST(LUT_MultiChannel, cv::gpu::DeviceInfo, cv::Size, MatType)\r
+{\r
+ cv::Size size = GET_PARAM(1);\r
+ int type = GET_PARAM(2);\r
+\r
+ cv::Mat src(size, type);\r
+ fill(src, 0.0, 100.0);\r
+\r
+ cv::Mat lut(1, 256, CV_MAKE_TYPE(CV_8U, src.channels()));\r
+ fill(lut, 0.0, 100.0);\r
+\r
+ cv::Mat dst;\r
+\r
+ cv::LUT(src, lut, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::LUT(src, lut, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, LUT_MultiChannel, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatType>(CV_8UC3)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Magnitude_Complex\r
+\r
+GPU_PERF_TEST(Magnitude_Complex, cv::gpu::DeviceInfo, cv::Size)\r
+{\r
+ cv::Size size = GET_PARAM(1);\r
+\r
+ cv::Mat src(size, CV_32FC2);\r
+ fill(src, -100.0, 100.0);\r
+\r
+ cv::Mat srcs[2];\r
+ cv::split(src, srcs);\r
+\r
+ cv::Mat dst;\r
+\r
+ cv::magnitude(srcs[0], srcs[1], dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::magnitude(srcs[0], srcs[1], dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Magnitude_Complex, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Magnitude\r
+\r
+GPU_PERF_TEST(Magnitude, cv::gpu::DeviceInfo, cv::Size)\r
+{\r
+ cv::Size size = GET_PARAM(1);\r
+\r
+ cv::Mat src1(size, CV_32FC1);\r
+ fill(src1, -100.0, 100.0);\r
+\r
+ cv::Mat src2(size, CV_32FC1);\r
+ fill(src2, -100.0, 100.0);\r
+\r
+ cv::Mat dst;\r
+\r
+ cv::magnitude(src1, src2, dst);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::magnitude(src1, src2, dst);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Magnitude, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Phase\r
+\r
+IMPLEMENT_PARAM_CLASS(AngleInDegrees, bool)\r
+\r
+GPU_PERF_TEST(Phase, cv::gpu::DeviceInfo, cv::Size, AngleInDegrees)\r
+{\r
+ cv::Size size = GET_PARAM(1);\r
+ bool angleInDegrees = GET_PARAM(2);\r
+\r
+ cv::Mat src1(size, CV_32FC1);\r
+ fill(src1, -100.0, 100.0);\r
+\r
+ cv::Mat src2(size, CV_32FC1);\r
+ fill(src2, -100.0, 100.0);\r
+\r
+ cv::Mat dst;\r
+\r
+ cv::phase(src1, src2, dst, angleInDegrees);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::phase(src1, src2, dst, angleInDegrees);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Phase, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<AngleInDegrees>(false, true)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// CartToPolar\r
+\r
+GPU_PERF_TEST(CartToPolar, cv::gpu::DeviceInfo, cv::Size, AngleInDegrees)\r
+{\r
+ cv::Size size = GET_PARAM(1);\r
+ bool angleInDegrees = GET_PARAM(2);\r
+\r
+ cv::Mat src1(size, CV_32FC1);\r
+ fill(src1, -100.0, 100.0);\r
+\r
+ cv::Mat src2(size, CV_32FC1);\r
+ fill(src2, -100.0, 100.0);\r
+\r
+ cv::Mat magnitude;\r
+ cv::Mat angle;\r
+\r
+ cv::cartToPolar(src1, src2, magnitude, angle, angleInDegrees);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::cartToPolar(src1, src2, magnitude, angle, angleInDegrees);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, CartToPolar, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<AngleInDegrees>(false, true)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// PolarToCart\r
+\r
+GPU_PERF_TEST(PolarToCart, cv::gpu::DeviceInfo, cv::Size, AngleInDegrees)\r
+{\r
+ cv::Size size = GET_PARAM(1);\r
+ bool angleInDegrees = GET_PARAM(2);\r
+\r
+ cv::Mat magnitude(size, CV_32FC1);\r
+ fill(magnitude, 0.0, 100.0);\r
+\r
+ cv::Mat angle(size, CV_32FC1);\r
+ fill(angle, 0.0, angleInDegrees ? 360.0 : 2 * CV_PI);\r
+\r
+ cv::Mat x;\r
+ cv::Mat y;\r
+\r
+ cv::polarToCart(magnitude, angle, x, y, angleInDegrees);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::polarToCart(magnitude, angle, x, y, angleInDegrees);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, PolarToCart, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<AngleInDegrees>(false, true)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// MeanStdDev\r
+\r
+GPU_PERF_TEST(MeanStdDev, cv::gpu::DeviceInfo, cv::Size)\r
+{\r
+ cv::Size size = GET_PARAM(1);\r
+\r
+ cv::Mat src(size, CV_8UC1);\r
+ fill(src, 0.0, 255.0);\r
+\r
+ cv::Scalar mean;\r
+ cv::Scalar stddev;\r
+\r
+ cv::meanStdDev(src, mean, stddev);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::meanStdDev(src, mean, stddev);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, MeanStdDev, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Norm\r
+\r
+GPU_PERF_TEST(Norm, cv::gpu::DeviceInfo, cv::Size, MatDepth, NormType)\r
+{\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+ int normType = GET_PARAM(3);\r
+\r
+ cv::Mat src(size, depth);\r
+ fill(src, 0.0, 255.0);\r
+\r
+ double dst;\r
+ cv::Mat buf;\r
+\r
+ dst = cv::norm(src, normType);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ dst = cv::norm(src, normType);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Norm, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32S, CV_32F),\r
+ testing::Values(NormType(cv::NORM_INF), NormType(cv::NORM_L1), NormType(cv::NORM_L2))));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// NormDiff\r
+\r
+GPU_PERF_TEST(NormDiff, cv::gpu::DeviceInfo, cv::Size, NormType)\r
+{\r
+ cv::Size size = GET_PARAM(1);\r
+ int normType = GET_PARAM(2);\r
+\r
+ cv::Mat src1(size, CV_8UC1);\r
+ fill(src1, 0.0, 255.0);\r
+\r
+ cv::Mat src2(size, CV_8UC1);\r
+ fill(src2, 0.0, 255.0);\r
+\r
+ double dst;\r
+\r
+ dst = cv::norm(src1, src2, normType);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ dst = cv::norm(src1, src2, normType);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, NormDiff, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values(NormType(cv::NORM_INF), NormType(cv::NORM_L1), NormType(cv::NORM_L2))));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Sum\r
+\r
+GPU_PERF_TEST(Sum, cv::gpu::DeviceInfo, cv::Size, MatType)\r
+{\r
+ cv::Size size = GET_PARAM(1);\r
+ int type = GET_PARAM(2);\r
+\r
+ cv::Mat src(size, type);\r
+ fill(src, 0.0, 255.0);\r
+\r
+ cv::Scalar dst;\r
+\r
+ dst = cv::sum(src);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ dst = cv::sum(src);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Sum, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatType>(CV_8UC1, CV_8UC3, CV_8UC4, CV_16UC1, CV_16UC3, CV_16UC4, CV_32FC1, CV_32FC3, CV_32FC4)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// MinMaxLoc\r
+\r
+GPU_PERF_TEST(MinMaxLoc, cv::gpu::DeviceInfo, cv::Size, MatDepth)\r
+{\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+\r
+ cv::Mat src(size, depth);\r
+ fill(src, 0.0, 255.0);\r
+\r
+ double minVal, maxVal;\r
+ cv::Point minLoc, maxLoc;\r
+\r
+ cv::minMaxLoc(src, &minVal, &maxVal, &minLoc, &maxLoc);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::minMaxLoc(src, &minVal, &maxVal, &minLoc, &maxLoc);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, MinMaxLoc, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F, CV_64F)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// CountNonZero\r
+\r
+GPU_PERF_TEST(CountNonZero, cv::gpu::DeviceInfo, cv::Size, MatDepth)\r
+{\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+\r
+ cv::Mat src(size, depth);\r
+ fill(src, 0.0, 1.5);\r
+\r
+ int dst;\r
+\r
+ dst = cv::countNonZero(src);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ dst = cv::countNonZero(src);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, CountNonZero, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_32F, CV_64F)));\r
+\r
+//////////////////////////////////////////////////////////////////////\r
+// Reduce\r
+\r
+CV_ENUM(ReduceCode, CV_REDUCE_SUM, CV_REDUCE_AVG, CV_REDUCE_MAX, CV_REDUCE_MIN)\r
+#define ALL_REDUCE_CODES testing::Values<ReduceCode>(CV_REDUCE_SUM, CV_REDUCE_AVG, CV_REDUCE_MAX, CV_REDUCE_MIN)\r
+\r
+enum {Rows = 0, Cols = 1};\r
+CV_ENUM(ReduceDim, Rows, Cols)\r
+\r
+GPU_PERF_TEST(Reduce, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, ReduceCode, ReduceDim)\r
+{\r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+ int channels = GET_PARAM(3);\r
+ int reduceOp = GET_PARAM(4);\r
+ int dim = GET_PARAM(5);\r
+\r
+ int type = CV_MAKE_TYPE(depth, channels);\r
+\r
+ cv::Mat src(size, type);\r
+ fill(src, 0.0, 10.0);\r
+\r
+ cv::Mat dst;\r
+\r
+ cv::reduce(src, dst, dim, reduceOp);\r
+\r
+ TEST_CYCLE()\r
+ {\r
+ cv::reduce(src, dst, dim, reduceOp);\r
+ }\r
+}\r
+\r
+INSTANTIATE_TEST_CASE_P(Core, Reduce, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values<MatDepth>(CV_8U, CV_16U, CV_16S, CV_32F),\r
+ testing::Values<Channels>(1, 2, 3, 4),\r
+ ALL_REDUCE_CODES,\r
+ testing::Values(ReduceDim(Rows), ReduceDim(Cols))));\r
+\r
+#endif\r
#ifdef HAVE_CUDA\r
\r
//////////////////////////////////////////////////////////////////////\r
-// BruteForceMatcher_match\r
+// SURF\r
\r
-GPU_PERF_TEST(BruteForceMatcher_match, cv::gpu::DeviceInfo, int)\r
+GPU_PERF_TEST_1(SURF, cv::gpu::DeviceInfo)\r
{\r
- int desc_size = GET_PARAM(1);\r
+ cv::Mat img = readImage("gpu/perf/aloe.jpg", cv::IMREAD_GRAYSCALE);\r
+ ASSERT_FALSE(img.empty());\r
\r
- cv::Mat query(3000, desc_size, CV_32FC1);\r
- cv::Mat train(3000, desc_size, CV_32FC1);\r
+ cv::SURF surf;\r
\r
- declare.in(query, train, WARMUP_RNG);\r
+ std::vector<cv::KeyPoint> keypoints;\r
+ cv::Mat descriptors;\r
\r
- cv::BFMatcher matcher(cv::NORM_L2);\r
- std::vector<cv::DMatch> matches;\r
+ surf(img, cv::noArray(), keypoints, descriptors);\r
\r
- declare.time(10.0);\r
+ declare.time(50.0);\r
\r
TEST_CYCLE()\r
{\r
- matcher.match(query, train, matches);\r
+ surf(img, cv::noArray(), keypoints, descriptors);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(Features2D, BruteForceMatcher_match, testing::Combine(\r
- ALL_DEVICES,\r
- testing::Values(64, 128, 256)));\r
+INSTANTIATE_TEST_CASE_P(Features2D, SURF, ALL_DEVICES);\r
\r
//////////////////////////////////////////////////////////////////////\r
-// BruteForceMatcher_knnMatch\r
+// FAST\r
\r
-GPU_PERF_TEST(BruteForceMatcher_knnMatch, cv::gpu::DeviceInfo, int, int)\r
+GPU_PERF_TEST_1(FAST, cv::gpu::DeviceInfo)\r
{\r
- int desc_size = GET_PARAM(1);\r
- int k = GET_PARAM(2);\r
-\r
- cv::Mat query(3000, desc_size, CV_32FC1);\r
- cv::Mat train(3000, desc_size, CV_32FC1);\r
-\r
- declare.in(query, train, WARMUP_RNG);\r
+ cv::Mat img = readImage("gpu/perf/aloe.jpg", cv::IMREAD_GRAYSCALE);\r
+ ASSERT_FALSE(img.empty());\r
\r
- cv::BFMatcher matcher(cv::NORM_L2);\r
- std::vector< std::vector<cv::DMatch> > matches;\r
+ std::vector<cv::KeyPoint> keypoints;\r
\r
- declare.time(10.0);\r
+ cv::FAST(img, keypoints, 20);\r
\r
TEST_CYCLE()\r
{\r
- matcher.knnMatch(query, train, matches, k);\r
+ cv::FAST(img, keypoints, 20);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(Features2D, BruteForceMatcher_knnMatch, testing::Combine(\r
- ALL_DEVICES,\r
- testing::Values(64, 128, 256),\r
- testing::Values(2, 3)));\r
+INSTANTIATE_TEST_CASE_P(Features2D, FAST, ALL_DEVICES);\r
\r
//////////////////////////////////////////////////////////////////////\r
-// BruteForceMatcher_radiusMatch\r
+// ORB\r
\r
-GPU_PERF_TEST(BruteForceMatcher_radiusMatch, cv::gpu::DeviceInfo, int)\r
+GPU_PERF_TEST_1(ORB, cv::gpu::DeviceInfo)\r
{\r
- int desc_size = GET_PARAM(1);\r
-\r
- cv::Mat query(3000, desc_size, CV_32FC1);\r
- cv::Mat train(3000, desc_size, CV_32FC1);\r
+ cv::Mat img = readImage("gpu/perf/aloe.jpg", cv::IMREAD_GRAYSCALE);\r
+ ASSERT_FALSE(img.empty());\r
\r
- fill(query, 0, 1);\r
- fill(train, 0, 1);\r
+ cv::ORB orb(4000);\r
\r
- cv::BFMatcher matcher(cv::NORM_L2);\r
- std::vector< std::vector<cv::DMatch> > matches;\r
+ std::vector<cv::KeyPoint> keypoints;\r
+ cv::Mat descriptors;\r
\r
- declare.time(10.0);\r
+ orb(img, cv::noArray(), keypoints, descriptors);\r
\r
TEST_CYCLE()\r
{\r
- matcher.radiusMatch(query, train, matches, 2.0);\r
+ orb(img, cv::noArray(), keypoints, descriptors);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(Features2D, BruteForceMatcher_radiusMatch, testing::Combine(\r
- ALL_DEVICES,\r
- testing::Values(64, 128, 256)));\r
+INSTANTIATE_TEST_CASE_P(Features2D, ORB, ALL_DEVICES);\r
\r
//////////////////////////////////////////////////////////////////////\r
-// SURF\r
+// BruteForceMatcher_match\r
\r
-GPU_PERF_TEST_1(SURF, cv::gpu::DeviceInfo)\r
+IMPLEMENT_PARAM_CLASS(DescriptorSize, int)\r
+\r
+GPU_PERF_TEST(BruteForceMatcher_match, cv::gpu::DeviceInfo, DescriptorSize, NormType)\r
{\r
- cv::Mat img = readImage("gpu/perf/aloe.jpg", cv::IMREAD_GRAYSCALE);\r
+ int desc_size = GET_PARAM(1);\r
+ int normType = GET_PARAM(2);\r
\r
- ASSERT_FALSE(img.empty());\r
+ int type = normType == cv::NORM_HAMMING ? CV_8U : CV_32F;\r
\r
- std::vector<cv::KeyPoint> keypoints;\r
- cv::Mat descriptors;\r
+ cv::Mat query(3000, desc_size, type);\r
+ fill(query, 0.0, 10.0);\r
\r
- cv::SURF surf;\r
+ cv::Mat train(3000, desc_size, type);\r
+ fill(train, 0.0, 10.0);\r
\r
- declare.time(30.0);\r
+ cv::BFMatcher matcher(normType);\r
+\r
+ std::vector<cv::DMatch> matches;\r
+\r
+ matcher.match(query, train, matches);\r
+\r
+ declare.time(20.0);\r
\r
TEST_CYCLE()\r
{\r
- surf(img, cv::noArray(), keypoints, descriptors);\r
+ matcher.match(query, train, matches);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(Features2D, SURF, DEVICES(cv::gpu::GLOBAL_ATOMICS));\r
+INSTANTIATE_TEST_CASE_P(Features2D, BruteForceMatcher_match, testing::Combine(\r
+ ALL_DEVICES,\r
+ testing::Values(DescriptorSize(64), DescriptorSize(128), DescriptorSize(256)),\r
+ testing::Values(NormType(cv::NORM_L1), NormType(cv::NORM_L2), NormType(cv::NORM_HAMMING))));\r
\r
//////////////////////////////////////////////////////////////////////\r
-// FAST\r
+// BruteForceMatcher_knnMatch\r
\r
-GPU_PERF_TEST_1(FAST, cv::gpu::DeviceInfo)\r
+IMPLEMENT_PARAM_CLASS(K, int)\r
+\r
+GPU_PERF_TEST(BruteForceMatcher_knnMatch, cv::gpu::DeviceInfo, DescriptorSize, K, NormType)\r
{\r
- cv::Mat img = readImage("gpu/perf/aloe.jpg", cv::IMREAD_GRAYSCALE);\r
+ int desc_size = GET_PARAM(1);\r
+ int k = GET_PARAM(2);\r
+ int normType = GET_PARAM(3);\r
\r
- ASSERT_FALSE(img.empty());\r
+ int type = normType == cv::NORM_HAMMING ? CV_8U : CV_32F;\r
\r
- std::vector<cv::KeyPoint> keypoints;\r
+ cv::Mat query(3000, desc_size, type);\r
+ fill(query, 0.0, 10.0);\r
+\r
+ cv::Mat train(3000, desc_size, type);\r
+ fill(train, 0.0, 10.0);\r
+\r
+ cv::BFMatcher matcher(normType);\r
+\r
+ std::vector< std::vector<cv::DMatch> > matches;\r
+\r
+ matcher.knnMatch(query, train, matches, k);\r
+\r
+ declare.time(30.0);\r
\r
TEST_CYCLE()\r
{\r
- cv::FAST(img, keypoints, 20);\r
+ matcher.knnMatch(query, train, matches, k);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(Features2D, FAST, DEVICES(cv::gpu::GLOBAL_ATOMICS));\r
+INSTANTIATE_TEST_CASE_P(Features2D, BruteForceMatcher_knnMatch, testing::Combine(\r
+ ALL_DEVICES,\r
+ testing::Values(DescriptorSize(64), DescriptorSize(128), DescriptorSize(256)),\r
+ testing::Values(K(2), K(3)),\r
+ testing::Values(NormType(cv::NORM_L1), NormType(cv::NORM_L2), NormType(cv::NORM_HAMMING))));\r
\r
//////////////////////////////////////////////////////////////////////\r
-// ORB\r
+// BruteForceMatcher_radiusMatch\r
\r
-GPU_PERF_TEST_1(ORB, cv::gpu::DeviceInfo)\r
+GPU_PERF_TEST(BruteForceMatcher_radiusMatch, cv::gpu::DeviceInfo, DescriptorSize, NormType)\r
{\r
- cv::Mat img = readImage("gpu/perf/aloe.jpg", cv::IMREAD_GRAYSCALE);\r
+ int desc_size = GET_PARAM(1);\r
+ int normType = GET_PARAM(2);\r
\r
- ASSERT_FALSE(img.empty());\r
+ int type = normType == cv::NORM_HAMMING ? CV_8U : CV_32F;\r
\r
- std::vector<cv::KeyPoint> keypoints;\r
- cv::Mat descriptors;\r
+ cv::Mat query(3000, desc_size, type);\r
+ fill(query, 0.0, 1.0);\r
\r
- cv::ORB orb(4000);\r
+ cv::Mat train(3000, desc_size, type);\r
+ fill(train, 0.0, 1.0);\r
+\r
+ cv::BFMatcher matcher(normType);\r
+\r
+ std::vector< std::vector<cv::DMatch> > matches;\r
+\r
+ matcher.radiusMatch(query, train, matches, 2.0);\r
+\r
+ declare.time(30.0);\r
\r
TEST_CYCLE()\r
{\r
- orb(img, cv::noArray(), keypoints, descriptors);\r
+ matcher.radiusMatch(query, train, matches, 2.0);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(Features2D, ORB, DEVICES(cv::gpu::GLOBAL_ATOMICS));\r
+INSTANTIATE_TEST_CASE_P(Features2D, BruteForceMatcher_radiusMatch, testing::Combine(\r
+ ALL_DEVICES,\r
+ testing::Values(DescriptorSize(64), DescriptorSize(128), DescriptorSize(256)),\r
+ testing::Values(NormType(cv::NORM_L1), NormType(cv::NORM_L2), NormType(cv::NORM_HAMMING))));\r
\r
#endif\r
int ksize = GET_PARAM(3);\r
\r
cv::Mat src(size, type);\r
-\r
- declare.in(src, WARMUP_RNG);\r
+ fill(src, 0.0, 255.0);\r
\r
cv::Mat dst;\r
\r
+ cv::blur(src, dst, cv::Size(ksize, ksize));\r
+\r
declare.time(20.0);\r
\r
TEST_CYCLE()\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(Filter, Blur, testing::Combine(\r
+INSTANTIATE_TEST_CASE_P(Filters, Blur, testing::Combine(\r
ALL_DEVICES,\r
GPU_TYPICAL_MAT_SIZES,\r
testing::Values(MatType(CV_8UC1), MatType(CV_8UC4)),\r
int ksize = GET_PARAM(3);\r
\r
cv::Mat src(size, type);\r
-\r
- declare.in(src, WARMUP_RNG);\r
+ fill(src, 0.0, 255.0);\r
\r
cv::Mat dst;\r
\r
+ cv::Sobel(src, dst, -1, 1, 1, ksize);\r
+\r
declare.time(20.0);\r
\r
TEST_CYCLE()\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(Filter, Sobel, testing::Combine(\r
+INSTANTIATE_TEST_CASE_P(Filters, Sobel, testing::Combine(\r
ALL_DEVICES,\r
GPU_TYPICAL_MAT_SIZES,\r
testing::Values(MatType(CV_8UC1), MatType(CV_8UC4), MatType(CV_32FC1)),\r
int type = GET_PARAM(2);\r
\r
cv::Mat src(size, type);\r
-\r
- declare.in(src, WARMUP_RNG);\r
+ fill(src, 0.0, 255.0);\r
\r
cv::Mat dst;\r
\r
+ cv::Scharr(src, dst, -1, 1, 0);\r
+\r
declare.time(20.0);\r
\r
TEST_CYCLE()\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(Filter, Scharr, testing::Combine(\r
+INSTANTIATE_TEST_CASE_P(Filters, Scharr, testing::Combine(\r
ALL_DEVICES,\r
GPU_TYPICAL_MAT_SIZES,\r
testing::Values(MatType(CV_8UC1), MatType(CV_8UC4), MatType(CV_32FC1))));\r
int ksize = GET_PARAM(3);\r
\r
cv::Mat src(size, type);\r
-\r
- declare.in(src, WARMUP_RNG);\r
+ fill(src, 0.0, 255.0);\r
\r
cv::Mat dst;\r
\r
+ cv::GaussianBlur(src, dst, cv::Size(ksize, ksize), 0.5);\r
+\r
declare.time(20.0);\r
\r
TEST_CYCLE()\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(Filter, GaussianBlur, testing::Combine(\r
+INSTANTIATE_TEST_CASE_P(Filters, GaussianBlur, testing::Combine(\r
ALL_DEVICES,\r
GPU_TYPICAL_MAT_SIZES,\r
testing::Values(MatType(CV_8UC1), MatType(CV_8UC4), MatType(CV_32FC1)),\r
int ksize = GET_PARAM(3);\r
\r
cv::Mat src(size, type);\r
-\r
- declare.in(src, WARMUP_RNG);\r
+ fill(src, 0.0, 255.0);\r
\r
cv::Mat dst;\r
\r
+ cv::Laplacian(src, dst, -1, ksize);\r
+\r
declare.time(20.0);\r
\r
TEST_CYCLE()\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(Filter, Laplacian, testing::Combine(\r
+INSTANTIATE_TEST_CASE_P(Filters, Laplacian, testing::Combine(\r
ALL_DEVICES,\r
GPU_TYPICAL_MAT_SIZES,\r
testing::Values(MatType(CV_8UC1), MatType(CV_8UC4), MatType(CV_32FC1), MatType(CV_32FC4)),\r
int type = GET_PARAM(2);\r
\r
cv::Mat src(size, type);\r
-\r
- declare.in(src, WARMUP_RNG);\r
+ fill(src, 0.0, 255.0);\r
\r
cv::Mat ker = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(3, 3));\r
\r
cv::Mat dst;\r
\r
+ cv::erode(src, dst, ker);\r
+\r
declare.time(20.0);\r
\r
TEST_CYCLE()\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(Filter, Erode, testing::Combine(\r
+INSTANTIATE_TEST_CASE_P(Filters, Erode, testing::Combine(\r
ALL_DEVICES,\r
GPU_TYPICAL_MAT_SIZES,\r
testing::Values(MatType(CV_8UC1), MatType(CV_8UC4))));\r
int type = GET_PARAM(2);\r
\r
cv::Mat src(size, type);\r
-\r
- declare.in(src, WARMUP_RNG);\r
+ fill(src, 0.0, 255.0);\r
\r
cv::Mat ker = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(3, 3));\r
\r
cv::Mat dst;\r
\r
+ cv::dilate(src, dst, ker);\r
+\r
declare.time(20.0);\r
\r
TEST_CYCLE()\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(Filter, Dilate, testing::Combine(\r
+INSTANTIATE_TEST_CASE_P(Filters, Dilate, testing::Combine(\r
ALL_DEVICES,\r
GPU_TYPICAL_MAT_SIZES,\r
testing::Values(MatType(CV_8UC1), MatType(CV_8UC4))));\r
int morphOp = GET_PARAM(3);\r
\r
cv::Mat src(size, type);\r
-\r
- declare.in(src, WARMUP_RNG);\r
+ fill(src, 0.0, 255.0);\r
\r
cv::Mat dst;\r
\r
cv::Mat ker = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(3, 3));\r
\r
+ cv::morphologyEx(src, dst, morphOp, ker);\r
+\r
declare.time(20.0);\r
\r
TEST_CYCLE()\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(Filter, MorphologyEx, testing::Combine(\r
+INSTANTIATE_TEST_CASE_P(Filters, MorphologyEx, testing::Combine(\r
ALL_DEVICES,\r
GPU_TYPICAL_MAT_SIZES,\r
testing::Values(MatType(CV_8UC1), MatType(CV_8UC4)),\r
int ksize = GET_PARAM(3);\r
\r
cv::Mat src(size, type);\r
- cv::Mat kernel(ksize, ksize, CV_32FC1);\r
+ fill(src, 0.0, 255.0);\r
\r
- declare.in(src, kernel, WARMUP_RNG);\r
+ cv::Mat kernel(ksize, ksize, CV_32FC1);\r
+ fill(kernel, 0.0, 1.0);\r
\r
cv::Mat dst;\r
\r
+ cv::filter2D(src, dst, -1, kernel);\r
+\r
declare.time(20.0);\r
\r
TEST_CYCLE()\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(Filter, Filter2D, testing::Combine(\r
+INSTANTIATE_TEST_CASE_P(Filters, Filter2D, testing::Combine(\r
ALL_DEVICES,\r
GPU_TYPICAL_MAT_SIZES,\r
testing::Values(MatType(CV_8UC1), MatType(CV_8UC4), MatType(CV_32FC1), MatType(CV_32FC4)),\r
//////////////////////////////////////////////////////////////////////\r
// Remap\r
\r
-GPU_PERF_TEST(Remap, cv::gpu::DeviceInfo, cv::Size, perf::MatType, Interpolation, BorderMode)\r
+GPU_PERF_TEST(Remap, cv::gpu::DeviceInfo, cv::Size, MatType, Interpolation, BorderMode)\r
{\r
cv::Size size = GET_PARAM(1);\r
int type = GET_PARAM(2);\r
int borderMode = GET_PARAM(4);\r
\r
cv::Mat src(size, type);\r
+ fill(src, 0, 255);\r
+\r
cv::Mat xmap(size, CV_32FC1);\r
- cv::Mat ymap(size, CV_32FC1);\r
+ fill(xmap, 0, size.width);\r
\r
- declare.in(src, xmap, ymap, WARMUP_RNG);\r
+ cv::Mat ymap(size, CV_32FC1);\r
+ fill(ymap, 0, size.height);\r
\r
cv::Mat dst;\r
\r
- declare.time(10.0);\r
+ cv::remap(src, dst, xmap, ymap, interpolation, borderMode);\r
+\r
+ declare.time(3.0);\r
\r
TEST_CYCLE()\r
{\r
}\r
\r
INSTANTIATE_TEST_CASE_P(ImgProc, Remap, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(CV_8UC1, CV_8UC4, CV_16UC1, CV_32FC1),\r
- testing::Values((int) cv::INTER_NEAREST, (int) cv::INTER_LINEAR, (int) cv::INTER_CUBIC),\r
- testing::Values((int) cv::BORDER_REFLECT101, (int) cv::BORDER_REPLICATE, (int) cv::BORDER_CONSTANT)));\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),\r
+ MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),\r
+ MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),\r
+ testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)),\r
+ testing::Values(BorderMode(cv::BORDER_REFLECT101), BorderMode(cv::BORDER_REPLICATE), BorderMode(cv::BORDER_CONSTANT), BorderMode(cv::BORDER_REFLECT), BorderMode(cv::BORDER_WRAP))));\r
+\r
\r
//////////////////////////////////////////////////////////////////////\r
-// MeanShiftFiltering\r
+// Resize\r
\r
-GPU_PERF_TEST_1(MeanShiftFiltering, cv::gpu::DeviceInfo)\r
+IMPLEMENT_PARAM_CLASS(Scale, double)\r
+\r
+GPU_PERF_TEST(Resize, cv::gpu::DeviceInfo, cv::Size, MatType, Interpolation, Scale)\r
{\r
- cv::Mat img = readImage("gpu/meanshift/cones.png");\r
- ASSERT_FALSE(img.empty());\r
+ cv::Size size = GET_PARAM(1);\r
+ int type = GET_PARAM(2);\r
+ int interpolation = GET_PARAM(3);\r
+ double f = GET_PARAM(4);\r
+\r
+ cv::Mat src(size, type);\r
+ fill(src, 0, 255);\r
\r
cv::Mat dst;\r
\r
- declare.time(100.0);\r
+ cv::resize(src, dst, cv::Size(), f, f, interpolation);\r
+\r
+ declare.time(1.0);\r
\r
TEST_CYCLE()\r
{\r
- cv::pyrMeanShiftFiltering(img, dst, 50, 50);\r
+ cv::resize(src, dst, cv::Size(), f, f, interpolation);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(ImgProc, MeanShiftFiltering, ALL_DEVICES);\r
+INSTANTIATE_TEST_CASE_P(ImgProc, Resize, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),\r
+ MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),\r
+ MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),\r
+ testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)),\r
+ testing::Values(Scale(0.5), Scale(2.0))));\r
\r
//////////////////////////////////////////////////////////////////////\r
-// ReprojectImageTo3D\r
+// WarpAffine\r
\r
-GPU_PERF_TEST(ReprojectImageTo3D, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
+GPU_PERF_TEST(WarpAffine, cv::gpu::DeviceInfo, cv::Size, MatType, Interpolation, BorderMode)\r
{\r
cv::Size size = GET_PARAM(1);\r
int type = GET_PARAM(2);\r
+ int interpolation = GET_PARAM(3);\r
+ int borderMode = GET_PARAM(4);\r
\r
cv::Mat src(size, type);\r
-\r
- declare.in(src, WARMUP_RNG);\r
+ fill(src, 0, 255);\r
\r
cv::Mat dst;\r
\r
+ const double aplha = CV_PI / 4;\r
+ double mat[2][3] = { {std::cos(aplha), -std::sin(aplha), src.cols / 2},\r
+ {std::sin(aplha), std::cos(aplha), 0}};\r
+ cv::Mat M(2, 3, CV_64F, (void*) mat);\r
+\r
+ cv::warpAffine(src, dst, M, size, interpolation, borderMode);\r
+\r
TEST_CYCLE()\r
{\r
- cv::reprojectImageTo3D(src, dst, cv::Mat::ones(4, 4, CV_32FC1));\r
+ cv::warpAffine(src, dst, M, size, interpolation, borderMode);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(ImgProc, ReprojectImageTo3D, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(CV_8UC1, CV_16SC1)));\r
+INSTANTIATE_TEST_CASE_P(ImgProc, WarpAffine, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),\r
+ MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),\r
+ MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),\r
+ testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)),\r
+ testing::Values(BorderMode(cv::BORDER_REFLECT101), BorderMode(cv::BORDER_REPLICATE), BorderMode(cv::BORDER_CONSTANT), BorderMode(cv::BORDER_REFLECT), BorderMode(cv::BORDER_WRAP))));\r
\r
//////////////////////////////////////////////////////////////////////\r
-// CvtColor\r
+// WarpPerspective\r
\r
-GPU_PERF_TEST(CvtColor, cv::gpu::DeviceInfo, cv::Size, perf::MatType, CvtColorInfo)\r
+GPU_PERF_TEST(WarpPerspective, cv::gpu::DeviceInfo, cv::Size, MatType, Interpolation, BorderMode)\r
{\r
cv::Size size = GET_PARAM(1);\r
int type = GET_PARAM(2);\r
- CvtColorInfo info = GET_PARAM(3);\r
-\r
- cv::Mat src(size, CV_MAKETYPE(type, info.scn));\r
+ int interpolation = GET_PARAM(3);\r
+ int borderMode = GET_PARAM(4);\r
\r
- declare.in(src, WARMUP_RNG);\r
+ cv::Mat src(size, type);\r
+ fill(src, 0, 255);\r
\r
cv::Mat dst;\r
\r
+ const double aplha = CV_PI / 4;\r
+ double mat[3][3] = { {std::cos(aplha), -std::sin(aplha), src.cols / 2},\r
+ {std::sin(aplha), std::cos(aplha), 0},\r
+ {0.0, 0.0, 1.0}};\r
+ cv::Mat M(3, 3, CV_64F, (void*) mat);\r
+\r
+ cv::warpPerspective(src, dst, M, size, interpolation, borderMode);\r
+\r
TEST_CYCLE()\r
{\r
- cv::cvtColor(src, dst, info.code, info.dcn);\r
+ cv::warpPerspective(src, dst, M, size, interpolation, borderMode);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(ImgProc, CvtColor, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(CV_8UC1, CV_16UC1, CV_32FC1),\r
- testing::Values(\r
- CvtColorInfo(4, 4, cv::COLOR_RGBA2BGRA), CvtColorInfo(4, 1, cv::COLOR_BGRA2GRAY), CvtColorInfo(1, 4, cv::COLOR_GRAY2BGRA),\r
- CvtColorInfo(3, 3, cv::COLOR_BGR2XYZ), CvtColorInfo(3, 3, cv::COLOR_BGR2YCrCb), CvtColorInfo(3, 3, cv::COLOR_YCrCb2BGR),\r
- CvtColorInfo(3, 3, cv::COLOR_BGR2HSV), CvtColorInfo(3, 3, cv::COLOR_HSV2BGR))));\r
+INSTANTIATE_TEST_CASE_P(ImgProc, WarpPerspective, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),\r
+ MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),\r
+ MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),\r
+ testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)),\r
+ testing::Values(BorderMode(cv::BORDER_REFLECT101), BorderMode(cv::BORDER_REPLICATE), BorderMode(cv::BORDER_CONSTANT), BorderMode(cv::BORDER_REFLECT), BorderMode(cv::BORDER_WRAP))));\r
\r
//////////////////////////////////////////////////////////////////////\r
-// Threshold\r
+// CopyMakeBorder\r
\r
-GPU_PERF_TEST(Threshold, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
+GPU_PERF_TEST(CopyMakeBorder, cv::gpu::DeviceInfo, cv::Size, MatType, BorderMode)\r
{\r
cv::Size size = GET_PARAM(1);\r
int type = GET_PARAM(2);\r
+ int borderType = GET_PARAM(3);\r
\r
cv::Mat src(size, type);\r
+ fill(src, 0, 255);\r
\r
- declare.in(src, WARMUP_RNG);\r
+ cv::Mat dst;\r
\r
- cv::Mat dst(size, type);\r
+ cv::copyMakeBorder(src, dst, 5, 5, 5, 5, borderType);\r
\r
TEST_CYCLE()\r
{\r
- cv::threshold(src, dst, 100.0, 255.0, cv::THRESH_BINARY);\r
+ cv::copyMakeBorder(src, dst, 5, 5, 5, 5, borderType);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(ImgProc, Threshold, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(CV_8UC1, CV_32FC1)));\r
+INSTANTIATE_TEST_CASE_P(ImgProc, CopyMakeBorder, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),\r
+ MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),\r
+ MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),\r
+ testing::Values(BorderMode(cv::BORDER_REFLECT101), BorderMode(cv::BORDER_REPLICATE), BorderMode(cv::BORDER_CONSTANT), BorderMode(cv::BORDER_REFLECT), BorderMode(cv::BORDER_WRAP))));\r
\r
//////////////////////////////////////////////////////////////////////\r
-// Resize\r
+// Threshold\r
+\r
+CV_ENUM(ThreshOp, cv::THRESH_BINARY, cv::THRESH_BINARY_INV, cv::THRESH_TRUNC, cv::THRESH_TOZERO, cv::THRESH_TOZERO_INV)\r
+#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))\r
\r
-GPU_PERF_TEST(Resize, cv::gpu::DeviceInfo, cv::Size, perf::MatType, Interpolation, double)\r
+GPU_PERF_TEST(Threshold, cv::gpu::DeviceInfo, cv::Size, MatDepth, ThreshOp)\r
{\r
cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
- int interpolation = GET_PARAM(3);\r
- double f = GET_PARAM(4);\r
-\r
- cv::Mat src(size, type);\r
+ int depth = GET_PARAM(2);\r
+ int threshOp = GET_PARAM(3);\r
\r
- declare.in(src, WARMUP_RNG);\r
+ cv::Mat src(size, depth);\r
+ fill(src, 0, 255);\r
\r
cv::Mat dst;\r
\r
- declare.time(1.0);\r
+ cv::threshold(src, dst, 100.0, 255.0, threshOp);\r
\r
TEST_CYCLE()\r
{\r
- cv::resize(src, dst, cv::Size(), f, f, interpolation);\r
+ cv::threshold(src, dst, 100.0, 255.0, threshOp);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(ImgProc, Resize, testing::Combine(\r
- ALL_DEVICES,\r
- testing::Values(perf::szSXGA, perf::sz1080p),\r
- testing::Values(CV_8UC1, CV_8UC4, CV_16UC1, CV_32FC1),\r
- testing::Values((int) cv::INTER_NEAREST, (int) cv::INTER_LINEAR, (int) cv::INTER_CUBIC),\r
- testing::Values(0.5, 2.0)));\r
+INSTANTIATE_TEST_CASE_P(ImgProc, Threshold, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_32F), MatDepth(CV_64F)),\r
+ ALL_THRESH_OPS));\r
\r
//////////////////////////////////////////////////////////////////////\r
-// WarpAffine\r
+// Integral\r
\r
-GPU_PERF_TEST(WarpAffine, cv::gpu::DeviceInfo, cv::Size, perf::MatType, Interpolation)\r
+GPU_PERF_TEST(Integral, cv::gpu::DeviceInfo, cv::Size)\r
{\r
cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
- int interpolation = GET_PARAM(3);\r
\r
- cv::Mat src(size, type);\r
-\r
- declare.in(src, WARMUP_RNG);\r
+ cv::Mat src(size, CV_8UC1);\r
+ fill(src, 0, 255);\r
\r
cv::Mat dst;\r
\r
- const double aplha = CV_PI / 4;\r
- double mat[2][3] = { {std::cos(aplha), -std::sin(aplha), src.cols / 2},\r
- {std::sin(aplha), std::cos(aplha), 0}};\r
- cv::Mat M(2, 3, CV_64F, (void*) mat);\r
+ cv::integral(src, dst);\r
\r
TEST_CYCLE()\r
{\r
- cv::warpAffine(src, dst, M, size, interpolation, cv::BORDER_CONSTANT, cv::Scalar());\r
+ cv::integral(src, dst);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(ImgProc, WarpAffine, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_16UC1, CV_16UC3, CV_16UC4, CV_32FC1, CV_32FC3, CV_32FC4),\r
- testing::Values((int) cv::INTER_NEAREST, (int) cv::INTER_LINEAR, (int) cv::INTER_CUBIC)));\r
+INSTANTIATE_TEST_CASE_P(ImgProc, Integral, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES));\r
\r
//////////////////////////////////////////////////////////////////////\r
-// WarpPerspective\r
+// HistEven_OneChannel\r
\r
-GPU_PERF_TEST(WarpPerspective, cv::gpu::DeviceInfo, cv::Size, perf::MatType, Interpolation)\r
+GPU_PERF_TEST(HistEven_OneChannel, cv::gpu::DeviceInfo, cv::Size, MatDepth)\r
{\r
cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
- int interpolation = GET_PARAM(3);\r
+ int depth = GET_PARAM(2);\r
\r
- cv::Mat src(size, type);\r
+ cv::Mat src(size, depth);\r
+ fill(src, 0, 255);\r
\r
- declare.in(src, WARMUP_RNG);\r
+ int hbins = 30;\r
+ float hranges[] = {0.0f, 180.0f};\r
+ cv::Mat hist;\r
+ int histSize[] = {hbins};\r
+ const float* ranges[] = {hranges};\r
+ int channels[] = {0};\r
\r
- cv::Mat dst;\r
-\r
- const double aplha = CV_PI / 4;\r
- double mat[3][3] = { {std::cos(aplha), -std::sin(aplha), src.cols / 2},\r
- {std::sin(aplha), std::cos(aplha), 0},\r
- {0.0, 0.0, 1.0}};\r
- cv::Mat M(3, 3, CV_64F, (void*) mat);\r
+ cv::calcHist(&src, 1, channels, cv::Mat(), hist, 1, histSize, ranges);\r
\r
TEST_CYCLE()\r
{\r
- cv::warpPerspective(src, dst, M, size, interpolation, cv::BORDER_CONSTANT, cv::Scalar());\r
+ cv::calcHist(&src, 1, channels, cv::Mat(), hist, 1, histSize, ranges);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(ImgProc, WarpPerspective, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_16UC1, CV_16UC3, CV_16UC4, CV_32FC1, CV_32FC3, CV_32FC4),\r
- testing::Values((int) cv::INTER_NEAREST, (int) cv::INTER_LINEAR, (int) cv::INTER_CUBIC)));\r
+INSTANTIATE_TEST_CASE_P(ImgProc, HistEven_OneChannel, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_16S))));\r
\r
//////////////////////////////////////////////////////////////////////\r
-// CopyMakeBorder\r
+// EqualizeHist\r
\r
-GPU_PERF_TEST(CopyMakeBorder, cv::gpu::DeviceInfo, cv::Size, perf::MatType, BorderMode)\r
+GPU_PERF_TEST(EqualizeHist, cv::gpu::DeviceInfo, cv::Size)\r
{\r
cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
- int borderType = GET_PARAM(3);\r
\r
- cv::Mat src(size, type);\r
-\r
- declare.in(src, WARMUP_RNG);\r
+ cv::Mat src(size, CV_8UC1);\r
+ fill(src, 0, 255);\r
\r
cv::Mat dst;\r
\r
+ cv::equalizeHist(src, dst);\r
+\r
TEST_CYCLE()\r
{\r
- cv::copyMakeBorder(src, dst, 5, 5, 5, 5, borderType);\r
+ cv::equalizeHist(src, dst);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(ImgProc, CopyMakeBorder, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(CV_8UC1, CV_8UC4, CV_32FC1),\r
- testing::Values((int) cv::BORDER_REPLICATE, (int) cv::BORDER_REFLECT, (int) cv::BORDER_WRAP, (int) cv::BORDER_CONSTANT)));\r
+INSTANTIATE_TEST_CASE_P(ImgProc, EqualizeHist, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES));\r
\r
//////////////////////////////////////////////////////////////////////\r
-// Integral\r
+// Canny\r
\r
-GPU_PERF_TEST(Integral, cv::gpu::DeviceInfo, cv::Size)\r
-{\r
- cv::Size size = GET_PARAM(1);\r
+IMPLEMENT_PARAM_CLASS(AppertureSize, int)\r
+IMPLEMENT_PARAM_CLASS(L2gradient, bool)\r
\r
- cv::Mat src(size, CV_8UC1);\r
+GPU_PERF_TEST(Canny, cv::gpu::DeviceInfo, AppertureSize, L2gradient)\r
+{\r
+ int apperture_size = GET_PARAM(1);\r
+ bool useL2gradient = GET_PARAM(2);\r
\r
- declare.in(src, WARMUP_RNG);\r
+ cv::Mat image = readImage("perf/1280x1024.jpg", cv::IMREAD_GRAYSCALE);\r
+ ASSERT_FALSE(image.empty());\r
\r
cv::Mat dst;\r
\r
+ cv::Canny(image, dst, 50.0, 100.0, apperture_size, useL2gradient);\r
+\r
TEST_CYCLE()\r
{\r
- cv::integral(src, dst);\r
+ cv::Canny(image, dst, 50.0, 100.0, apperture_size, useL2gradient);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(ImgProc, Integral, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES));\r
+INSTANTIATE_TEST_CASE_P(ImgProc, Canny, testing::Combine(\r
+ ALL_DEVICES,\r
+ testing::Values(AppertureSize(3), AppertureSize(5)),\r
+ testing::Values(L2gradient(false), L2gradient(true))));\r
\r
//////////////////////////////////////////////////////////////////////\r
-// CornerHarris\r
+// MeanShiftFiltering\r
\r
-GPU_PERF_TEST(CornerHarris, cv::gpu::DeviceInfo, perf::MatType)\r
+GPU_PERF_TEST_1(MeanShiftFiltering, cv::gpu::DeviceInfo)\r
{\r
- int type = GET_PARAM(1);\r
-\r
- cv::Mat img = readImage("gpu/stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE);\r
+ cv::Mat img = readImage("gpu/meanshift/cones.png");\r
ASSERT_FALSE(img.empty());\r
\r
- img.convertTo(img, type, type == CV_32F ? 1.0 / 255.0 : 1.0);\r
-\r
cv::Mat dst;\r
\r
- int blockSize = 3;\r
- int ksize = 7;\r
- double k = 0.5;\r
+ cv::pyrMeanShiftFiltering(img, dst, 50, 50);\r
+\r
+ declare.time(15.0);\r
\r
TEST_CYCLE()\r
{\r
- cv::cornerHarris(img, dst, blockSize, ksize, k);\r
+ cv::pyrMeanShiftFiltering(img, dst, 50, 50);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(ImgProc, CornerHarris, testing::Combine(\r
- ALL_DEVICES,\r
- testing::Values(CV_8UC1, CV_32FC1)));\r
+INSTANTIATE_TEST_CASE_P(ImgProc, MeanShiftFiltering, ALL_DEVICES);\r
\r
//////////////////////////////////////////////////////////////////////\r
-// CornerMinEigenVal\r
+// Convolve\r
+\r
+IMPLEMENT_PARAM_CLASS(KSize, int)\r
+IMPLEMENT_PARAM_CLASS(Ccorr, bool)\r
\r
-GPU_PERF_TEST(CornerMinEigenVal, cv::gpu::DeviceInfo, perf::MatType)\r
+GPU_PERF_TEST(Convolve, cv::gpu::DeviceInfo, cv::Size, KSize, Ccorr)\r
{\r
- int type = GET_PARAM(1);\r
+ cv::Size size = GET_PARAM(1);\r
+ int templ_size = GET_PARAM(2);\r
+ bool ccorr = GET_PARAM(3);\r
\r
- cv::Mat img = readImage("gpu/stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE);\r
- ASSERT_FALSE(img.empty());\r
+ ASSERT_FALSE(ccorr);\r
\r
- img.convertTo(img, type, type == CV_32F ? 1.0 / 255.0 : 1.0);\r
+ cv::Mat image(size, CV_32FC1);\r
+ image.setTo(1.0);\r
+\r
+ cv::Mat templ(templ_size, templ_size, CV_32FC1);\r
+ templ.setTo(1.0);\r
\r
cv::Mat dst;\r
\r
- int blockSize = 3;\r
- int ksize = 7;\r
+ cv::filter2D(image, dst, image.depth(), templ);\r
+\r
+ declare.time(10.0);\r
\r
TEST_CYCLE()\r
{\r
- cv::cornerMinEigenVal(img, dst, blockSize, ksize);\r
+ cv::filter2D(image, dst, image.depth(), templ);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(ImgProc, CornerMinEigenVal, testing::Combine(\r
- ALL_DEVICES,\r
- testing::Values(CV_8UC1, CV_32FC1)));\r
+INSTANTIATE_TEST_CASE_P(ImgProc, Convolve, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values(KSize(3), KSize(9), KSize(17), KSize(27), KSize(32), KSize(64)),\r
+ testing::Values(Ccorr(false), Ccorr(true))));\r
\r
-//////////////////////////////////////////////////////////////////////\r
-// MulSpectrums\r
+////////////////////////////////////////////////////////////////////////////////\r
+// MatchTemplate_8U\r
+\r
+CV_ENUM(TemplateMethod, cv::TM_SQDIFF, cv::TM_SQDIFF_NORMED, cv::TM_CCORR, cv::TM_CCORR_NORMED, cv::TM_CCOEFF, cv::TM_CCOEFF_NORMED)\r
+#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))\r
+\r
+IMPLEMENT_PARAM_CLASS(TemplateSize, cv::Size)\r
\r
-GPU_PERF_TEST(MulSpectrums, cv::gpu::DeviceInfo, cv::Size)\r
+GPU_PERF_TEST(MatchTemplate_8U, cv::gpu::DeviceInfo, cv::Size, TemplateSize, Channels, TemplateMethod)\r
{\r
cv::Size size = GET_PARAM(1);\r
+ cv::Size templ_size = GET_PARAM(2);\r
+ int cn = GET_PARAM(3);\r
+ int method = GET_PARAM(4);\r
\r
- cv::Mat a(size, CV_32FC2);\r
- cv::Mat b(size, CV_32FC2);\r
+ cv::Mat image(size, CV_MAKE_TYPE(CV_8U, cn));\r
+ fill(image, 0, 255);\r
\r
- declare.in(a, b, WARMUP_RNG);\r
+ cv::Mat templ(templ_size, CV_MAKE_TYPE(CV_8U, cn));\r
+ fill(templ, 0, 255);\r
\r
cv::Mat dst;\r
\r
+ cv::matchTemplate(image, templ, dst, method);\r
+\r
TEST_CYCLE()\r
{\r
- cv::mulSpectrums(a, b, dst, 0);\r
+ cv::matchTemplate(image, templ, dst, method);\r
}\r
-}\r
+};\r
\r
-INSTANTIATE_TEST_CASE_P(ImgProc, MulSpectrums, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES));\r
+INSTANTIATE_TEST_CASE_P(ImgProc, MatchTemplate_8U, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values(TemplateSize(cv::Size(5, 5)), TemplateSize(cv::Size(16, 16)), TemplateSize(cv::Size(30, 30))),\r
+ testing::Values(Channels(1), Channels(3), Channels(4)),\r
+ ALL_TEMPLATE_METHODS));\r
\r
-//////////////////////////////////////////////////////////////////////\r
-// Dft\r
+////////////////////////////////////////////////////////////////////////////////\r
+// MatchTemplate_32F\r
\r
-GPU_PERF_TEST(Dft, cv::gpu::DeviceInfo, cv::Size)\r
+GPU_PERF_TEST(MatchTemplate_32F, cv::gpu::DeviceInfo, cv::Size, TemplateSize, Channels, TemplateMethod)\r
{\r
cv::Size size = GET_PARAM(1);\r
+ cv::Size templ_size = GET_PARAM(2);\r
+ int cn = GET_PARAM(3);\r
+ int method = GET_PARAM(4);\r
\r
- cv::Mat src(size, CV_32FC2);\r
+ cv::Mat image(size, CV_MAKE_TYPE(CV_32F, cn));\r
+ fill(image, 0, 255);\r
\r
- declare.in(src, WARMUP_RNG);\r
+ cv::Mat templ(templ_size, CV_MAKE_TYPE(CV_32F, cn));\r
+ fill(templ, 0, 255);\r
\r
cv::Mat dst;\r
\r
- declare.time(2.0);\r
+ cv::matchTemplate(image, templ, dst, method);\r
\r
TEST_CYCLE()\r
{\r
- cv::dft(src, dst);\r
+ cv::matchTemplate(image, templ, dst, method);\r
}\r
-}\r
+};\r
\r
-INSTANTIATE_TEST_CASE_P(ImgProc, Dft, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES));\r
+INSTANTIATE_TEST_CASE_P(ImgProc, MatchTemplate_32F, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values(TemplateSize(cv::Size(5, 5)), TemplateSize(cv::Size(16, 16)), TemplateSize(cv::Size(30, 30))),\r
+ testing::Values(Channels(1), Channels(3), Channels(4)),\r
+ testing::Values(TemplateMethod(cv::TM_SQDIFF), TemplateMethod(cv::TM_CCORR))));\r
\r
//////////////////////////////////////////////////////////////////////\r
-// Convolve\r
+// MulSpectrums\r
\r
-GPU_PERF_TEST(Convolve, cv::gpu::DeviceInfo, cv::Size, int, bool)\r
+CV_FLAGS(DftFlags, 0, cv::DFT_INVERSE, cv::DFT_SCALE, cv::DFT_ROWS, cv::DFT_COMPLEX_OUTPUT, cv::DFT_REAL_OUTPUT)\r
+\r
+GPU_PERF_TEST(MulSpectrums, cv::gpu::DeviceInfo, cv::Size, DftFlags)\r
{\r
cv::Size size = GET_PARAM(1);\r
- int templ_size = GET_PARAM(2);\r
+ int flag = GET_PARAM(2);\r
\r
- cv::Mat image(size, CV_32FC1);\r
- cv::Mat templ(templ_size, templ_size, CV_32FC1);\r
+ cv::Mat a(size, CV_32FC2);\r
+ fill(a, 0, 100);\r
\r
- image.setTo(cv::Scalar(1.0));\r
- templ.setTo(cv::Scalar(1.0));\r
+ cv::Mat b(size, CV_32FC2);\r
+ fill(b, 0, 100);\r
\r
cv::Mat dst;\r
\r
- declare.time(2.0);\r
+ cv::mulSpectrums(a, b, dst, flag);\r
\r
TEST_CYCLE()\r
{\r
- cv::filter2D(image, dst, image.depth(), templ);\r
+ cv::mulSpectrums(a, b, dst, flag);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(ImgProc, Convolve, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(3, 9, 27, 32, 64),\r
- testing::Bool()));\r
+INSTANTIATE_TEST_CASE_P(ImgProc, MulSpectrums, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values(DftFlags(0), DftFlags(cv::DFT_ROWS))));\r
\r
//////////////////////////////////////////////////////////////////////\r
-// PyrDown\r
+// Dft\r
\r
-GPU_PERF_TEST(PyrDown, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
+GPU_PERF_TEST(Dft, cv::gpu::DeviceInfo, cv::Size, DftFlags)\r
{\r
cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
+ int flag = GET_PARAM(2);\r
\r
- cv::Mat src(size, type);\r
-\r
- declare.in(src, WARMUP_RNG);\r
+ cv::Mat src(size, CV_32FC2);\r
+ fill(src, 0, 100);\r
\r
cv::Mat dst;\r
\r
+ cv::dft(src, dst, flag);\r
+\r
+ declare.time(10.0);\r
+\r
TEST_CYCLE()\r
{\r
- cv::pyrDown(src, dst);\r
+ cv::dft(src, dst, flag);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(ImgProc, PyrDown, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(CV_8UC1, CV_8UC4, CV_16SC3, CV_32FC1)));\r
+INSTANTIATE_TEST_CASE_P(ImgProc, Dft, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values(DftFlags(0), DftFlags(cv::DFT_ROWS), DftFlags(cv::DFT_INVERSE))));\r
\r
//////////////////////////////////////////////////////////////////////\r
-// PyrUp\r
+// CornerHarris\r
\r
-GPU_PERF_TEST(PyrUp, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
+IMPLEMENT_PARAM_CLASS(BlockSize, int)\r
+IMPLEMENT_PARAM_CLASS(ApertureSize, int)\r
+\r
+GPU_PERF_TEST(CornerHarris, cv::gpu::DeviceInfo, MatType, BorderMode, BlockSize, ApertureSize)\r
{\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
+ int type = GET_PARAM(1);\r
+ int borderType = GET_PARAM(2);\r
+ int blockSize = GET_PARAM(3);\r
+ int apertureSize = GET_PARAM(4);\r
\r
- cv::Mat src(size, type);\r
+ cv::Mat img = readImage("gpu/stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE);\r
+ ASSERT_FALSE(img.empty());\r
\r
- declare.in(src, WARMUP_RNG);\r
+ img.convertTo(img, type, type == CV_32F ? 1.0 / 255.0 : 1.0);\r
\r
cv::Mat dst;\r
\r
+ double k = 0.5;\r
+\r
+ cv::cornerHarris(img, dst, blockSize, apertureSize, k, borderType);\r
+\r
TEST_CYCLE()\r
{\r
- cv::pyrUp(src, dst);\r
+ cv::cornerHarris(img, dst, blockSize, apertureSize, k, borderType);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(ImgProc, PyrUp, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(CV_8UC1, CV_8UC4, CV_16SC3, CV_32FC1)));\r
+INSTANTIATE_TEST_CASE_P(ImgProc, CornerHarris, testing::Combine(\r
+ ALL_DEVICES,\r
+ testing::Values(MatType(CV_8UC1), MatType(CV_32FC1)),\r
+ testing::Values(BorderMode(cv::BORDER_REFLECT101), BorderMode(cv::BORDER_REPLICATE), BorderMode(cv::BORDER_REFLECT)),\r
+ testing::Values(BlockSize(3), BlockSize(5), BlockSize(7)),\r
+ testing::Values(ApertureSize(0), ApertureSize(3), ApertureSize(5), ApertureSize(7))));\r
\r
//////////////////////////////////////////////////////////////////////\r
-// Canny\r
+// CornerMinEigenVal\r
\r
-GPU_PERF_TEST_1(Canny, cv::gpu::DeviceInfo)\r
+GPU_PERF_TEST(CornerMinEigenVal, cv::gpu::DeviceInfo, MatType, BorderMode, BlockSize, ApertureSize)\r
{\r
- cv::Mat image = readImage("perf/1280x1024.jpg", cv::IMREAD_GRAYSCALE);\r
- ASSERT_FALSE(image.empty());\r
+ int type = GET_PARAM(1);\r
+ int borderType = GET_PARAM(2);\r
+ int blockSize = GET_PARAM(3);\r
+ int apertureSize = GET_PARAM(4);\r
+\r
+ cv::Mat img = readImage("gpu/stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE);\r
+ ASSERT_FALSE(img.empty());\r
+\r
+ img.convertTo(img, type, type == CV_32F ? 1.0 / 255.0 : 1.0);\r
\r
cv::Mat dst;\r
\r
+ cv::cornerMinEigenVal(img, dst, blockSize, apertureSize, borderType);\r
+\r
TEST_CYCLE()\r
{\r
- cv::Canny(image, dst, 50.0, 100.0);\r
+ cv::cornerMinEigenVal(img, dst, blockSize, apertureSize, borderType);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(ImgProc, Canny, ALL_DEVICES);\r
+INSTANTIATE_TEST_CASE_P(ImgProc, CornerMinEigenVal, testing::Combine(\r
+ ALL_DEVICES,\r
+ testing::Values(MatType(CV_8UC1), MatType(CV_32FC1)),\r
+ testing::Values(BorderMode(cv::BORDER_REFLECT101), BorderMode(cv::BORDER_REPLICATE), BorderMode(cv::BORDER_REFLECT)),\r
+ testing::Values(BlockSize(3), BlockSize(5), BlockSize(7)),\r
+ testing::Values(ApertureSize(0), ApertureSize(3), ApertureSize(5), ApertureSize(7))));\r
\r
//////////////////////////////////////////////////////////////////////\r
-// CalcHist\r
+// PyrDown\r
\r
-GPU_PERF_TEST(CalcHist, cv::gpu::DeviceInfo, cv::Size)\r
+GPU_PERF_TEST(PyrDown, cv::gpu::DeviceInfo, cv::Size, MatType)\r
{\r
cv::Size size = GET_PARAM(1);\r
+ int type = GET_PARAM(2);\r
\r
- cv::Mat src(size, CV_8UC1);\r
-\r
- declare.in(src, WARMUP_RNG);\r
+ cv::Mat src(size, type);\r
+ fill(src, 0, 255);\r
\r
- cv::Mat hist;\r
+ cv::Mat dst;\r
\r
- int histSize = 256;\r
- float range[] = { 0, 256 } ;\r
- const float* histRange = { range };\r
+ cv::pyrDown(src, dst);\r
\r
TEST_CYCLE()\r
{\r
- cv::calcHist(&src, 1, 0, cv::noArray(), hist, 1, &histSize, &histRange);\r
+ cv::pyrDown(src, dst);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(ImgProc, CalcHist, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES));\r
+INSTANTIATE_TEST_CASE_P(ImgProc, PyrDown, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),\r
+ MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),\r
+ MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4))));\r
\r
//////////////////////////////////////////////////////////////////////\r
-// EqualizeHist\r
+// PyrUp\r
\r
-GPU_PERF_TEST(EqualizeHist, cv::gpu::DeviceInfo, cv::Size)\r
+GPU_PERF_TEST(PyrUp, cv::gpu::DeviceInfo, cv::Size, MatType)\r
{\r
cv::Size size = GET_PARAM(1);\r
+ int type = GET_PARAM(2);\r
\r
- cv::Mat src(size, CV_8UC1);\r
-\r
- declare.in(src, WARMUP_RNG);\r
+ cv::Mat src(size, type);\r
+ fill(src, 0, 255);\r
\r
cv::Mat dst;\r
\r
+ cv::pyrUp(src, dst);\r
+\r
TEST_CYCLE()\r
{\r
- cv::equalizeHist(src, dst);\r
+ cv::pyrUp(src, dst);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(ImgProc, EqualizeHist, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES));\r
-\r
+INSTANTIATE_TEST_CASE_P(ImgProc, PyrUp, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),\r
+ MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),\r
+ MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4))));\r
\r
//////////////////////////////////////////////////////////////////////\r
-// MulAndScaleSpectrums\r
-\r
+// CvtColor\r
\r
-GPU_PERF_TEST(MulAndScaleSpectrums, cv::gpu::DeviceInfo, cv::Size)\r
+GPU_PERF_TEST(CvtColor, cv::gpu::DeviceInfo, cv::Size, MatDepth, CvtColorInfo)\r
{\r
- cv::Size size = GET_PARAM(1); \r
+ cv::Size size = GET_PARAM(1);\r
+ int depth = GET_PARAM(2);\r
+ CvtColorInfo info = GET_PARAM(3);\r
\r
- int type = CV_32FC2;\r
+ cv::Mat src(size, CV_MAKETYPE(depth, info.scn));\r
+ fill(src, 0, 255);\r
+\r
+ cv::Mat dst;\r
+\r
+ cv::cvtColor(src, dst, info.code, info.dcn);\r
\r
- cv::Mat src1(size, type);\r
- cv::Mat src2(size, type);\r
- cv::Mat dst(size, type);\r
- declare.in(src1, src2, WARMUP_RNG); \r
- \r
TEST_CYCLE()\r
- { \r
- cv::mulSpectrums(src1, src2, dst, cv::DFT_ROWS, false);\r
+ {\r
+ cv::cvtColor(src, dst, info.code, info.dcn);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(ImgProc, MulAndScaleSpectrums, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES));\r
-\r
+INSTANTIATE_TEST_CASE_P(ImgProc, CvtColor, testing::Combine(\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_32F)),\r
+ testing::Values(CvtColorInfo(4, 4, cv::COLOR_RGBA2BGRA),\r
+ CvtColorInfo(4, 1, cv::COLOR_BGRA2GRAY),\r
+ CvtColorInfo(1, 4, cv::COLOR_GRAY2BGRA),\r
+ CvtColorInfo(3, 3, cv::COLOR_BGR2XYZ),\r
+ CvtColorInfo(3, 3, cv::COLOR_XYZ2BGR),\r
+ CvtColorInfo(3, 3, cv::COLOR_BGR2YCrCb),\r
+ CvtColorInfo(3, 3, cv::COLOR_YCrCb2BGR),\r
+ CvtColorInfo(3, 3, cv::COLOR_BGR2YUV),\r
+ CvtColorInfo(3, 3, cv::COLOR_YUV2BGR),\r
+ CvtColorInfo(3, 3, cv::COLOR_BGR2HSV),\r
+ CvtColorInfo(3, 3, cv::COLOR_HSV2BGR),\r
+ CvtColorInfo(3, 3, cv::COLOR_BGR2HLS),\r
+ CvtColorInfo(3, 3, cv::COLOR_HLS2BGR))));\r
\r
#endif\r
#ifdef HAVE_CUDA\r
\r
//////////////////////////////////////////////////////////////////////\r
-// Merge\r
-\r
-GPU_PERF_TEST(Merge, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- const int num_channels = 4;\r
-\r
- std::vector<cv::Mat> src(num_channels);\r
- for (int i = 0; i < num_channels; ++i)\r
- src[i] = cv::Mat(size, type, cv::Scalar::all(i));\r
-\r
- cv::Mat dst;\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::merge(src, dst);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(MatOp, Merge, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(CV_8UC1, CV_16UC1, CV_32FC1)));\r
-\r
-//////////////////////////////////////////////////////////////////////\r
-// Split\r
-\r
-GPU_PERF_TEST(Split, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
-{\r
- cv::Size size = GET_PARAM(1);\r
- int type = GET_PARAM(2);\r
-\r
- const int num_channels = 4;\r
-\r
- cv::Mat src(size, CV_MAKETYPE(type, num_channels), cv::Scalar(1, 2, 3, 4));\r
-\r
- std::vector<cv::Mat> dst(num_channels);\r
- for (int i = 0; i < num_channels; ++i)\r
- dst[i] = cv::Mat(size, type);\r
-\r
- TEST_CYCLE()\r
- {\r
- cv::split(src, dst);\r
- }\r
-}\r
-\r
-INSTANTIATE_TEST_CASE_P(MatOp, Split, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(CV_8UC1, CV_16UC1, CV_32FC1)));\r
-\r
-//////////////////////////////////////////////////////////////////////\r
// SetTo\r
\r
-GPU_PERF_TEST(SetTo, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
+GPU_PERF_TEST(SetTo, cv::gpu::DeviceInfo, cv::Size, MatType)\r
{\r
cv::Size size = GET_PARAM(1);\r
int type = GET_PARAM(2);\r
cv::Mat src(size, type);\r
cv::Scalar val(1, 2, 3, 4);\r
\r
+ src.setTo(val);\r
+\r
TEST_CYCLE()\r
{\r
src.setTo(val);\r
}\r
\r
INSTANTIATE_TEST_CASE_P(MatOp, SetTo, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_16UC1, CV_16UC3, CV_16UC4, CV_32FC1, CV_32FC3, CV_32FC4)));\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),\r
+ MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),\r
+ MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4),\r
+ MatType(CV_64FC1), MatType(CV_64FC3), MatType(CV_64FC4))));\r
\r
//////////////////////////////////////////////////////////////////////\r
// SetToMasked\r
\r
-GPU_PERF_TEST(SetToMasked, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
+GPU_PERF_TEST(SetToMasked, cv::gpu::DeviceInfo, cv::Size, MatType)\r
{\r
cv::Size size = GET_PARAM(1);\r
int type = GET_PARAM(2);\r
\r
cv::Mat src(size, type);\r
- cv::Mat mask(size, CV_8UC1);\r
+ fill(src, 0, 255);\r
\r
- declare.in(src, WARMUP_RNG);\r
+ cv::Mat mask(size, CV_8UC1);\r
fill(mask, 0, 2);\r
\r
cv::Scalar val(1, 2, 3, 4);\r
\r
+ src.setTo(val, mask);\r
+\r
TEST_CYCLE()\r
{\r
src.setTo(val, mask);\r
}\r
\r
INSTANTIATE_TEST_CASE_P(MatOp, SetToMasked, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_16UC1, CV_16UC3, CV_16UC4, CV_32FC1, CV_32FC3, CV_32FC4)));\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),\r
+ MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),\r
+ MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4),\r
+ MatType(CV_64FC1), MatType(CV_64FC3), MatType(CV_64FC4))));\r
\r
//////////////////////////////////////////////////////////////////////\r
// CopyToMasked\r
\r
-GPU_PERF_TEST(CopyToMasked, cv::gpu::DeviceInfo, cv::Size, perf::MatType)\r
+GPU_PERF_TEST(CopyToMasked, cv::gpu::DeviceInfo, cv::Size, MatType)\r
{\r
cv::Size size = GET_PARAM(1);\r
int type = GET_PARAM(2);\r
\r
cv::Mat src(size, type);\r
- cv::Mat mask(size, CV_8UC1);\r
+ fill(src, 0, 255);\r
\r
- declare.in(src, WARMUP_RNG);\r
+ cv::Mat mask(size, CV_8UC1);\r
fill(mask, 0, 2);\r
\r
cv::Mat dst;\r
\r
+ src.copyTo(dst, mask);\r
+\r
TEST_CYCLE()\r
{\r
src.copyTo(dst, mask);\r
}\r
\r
INSTANTIATE_TEST_CASE_P(MatOp, CopyToMasked, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_16UC1, CV_16UC3, CV_16UC4, CV_32FC1, CV_32FC3, CV_32FC4)));\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4),\r
+ MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4),\r
+ MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4),\r
+ MatType(CV_64FC1), MatType(CV_64FC3), MatType(CV_64FC4))));\r
\r
//////////////////////////////////////////////////////////////////////\r
// ConvertTo\r
\r
-GPU_PERF_TEST(ConvertTo, cv::gpu::DeviceInfo, cv::Size, perf::MatType, perf::MatType)\r
+GPU_PERF_TEST(ConvertTo, cv::gpu::DeviceInfo, cv::Size, MatDepth, MatDepth)\r
{\r
cv::Size size = GET_PARAM(1);\r
- int type1 = GET_PARAM(2);\r
- int type2 = GET_PARAM(3);\r
+ int depth1 = GET_PARAM(2);\r
+ int depth2 = GET_PARAM(3);\r
\r
- cv::Mat src(size, type1);\r
-\r
- declare.in(src, WARMUP_RNG);\r
+ cv::Mat src(size, depth1);\r
+ fill(src, 0, 255);\r
\r
cv::Mat dst;\r
\r
+ src.convertTo(dst, depth2, 0.5, 1.0);\r
+\r
TEST_CYCLE()\r
{\r
- src.convertTo(dst, type2, 0.5, 1.0);\r
+ src.convertTo(dst, depth2, 0.5, 1.0);\r
}\r
}\r
\r
INSTANTIATE_TEST_CASE_P(MatOp, ConvertTo, testing::Combine(\r
- ALL_DEVICES,\r
- GPU_TYPICAL_MAT_SIZES,\r
- testing::Values(CV_8UC1, CV_16UC1, CV_32FC1),\r
- testing::Values(CV_8UC1, CV_16UC1, CV_32FC1)));\r
+ ALL_DEVICES,\r
+ GPU_TYPICAL_MAT_SIZES,\r
+ testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_32F), MatDepth(CV_64F)),\r
+ testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_32F), MatDepth(CV_64F))));\r
\r
#endif\r
\r
#ifdef HAVE_CUDA\r
\r
+///////////////////////////////////////////////////////////////\r
+// HOG\r
+\r
GPU_PERF_TEST_1(HOG, cv::gpu::DeviceInfo)\r
{\r
cv::Mat img = readImage("gpu/hog/road.png", cv::IMREAD_GRAYSCALE);\r
+ ASSERT_FALSE(img.empty());\r
\r
std::vector<cv::Rect> found_locations;\r
\r
cv::HOGDescriptor hog;\r
hog.setSVMDetector(cv::gpu::HOGDescriptor::getDefaultPeopleDetector());\r
\r
+ hog.detectMultiScale(img, found_locations);\r
+\r
TEST_CYCLE()\r
{\r
hog.detectMultiScale(img, found_locations);\r
\r
INSTANTIATE_TEST_CASE_P(ObjDetect, HOG, ALL_DEVICES);\r
\r
+///////////////////////////////////////////////////////////////\r
+// HaarClassifier\r
+\r
GPU_PERF_TEST_1(HaarClassifier, cv::gpu::DeviceInfo)\r
-{ \r
+{\r
cv::Mat img = readImage("gpu/haarcascade/group_1_640x480_VGA.pgm", cv::IMREAD_GRAYSCALE);\r
- \r
+ ASSERT_FALSE(img.empty());\r
+\r
cv::CascadeClassifier cascade;\r
\r
- if (!cascade.load("haarcascade_frontalface_alt.xml"))\r
- CV_Error(0, "Can't load cascade");\r
- \r
- \r
+ ASSERT_TRUE(cascade.load(perf::TestBase::getDataPath("gpu/perf/haarcascade_frontalface_alt.xml")));\r
+\r
std::vector<cv::Rect> rects;\r
- rects.reserve(1000);\r
+\r
+ cascade.detectMultiScale(img, rects);\r
\r
TEST_CYCLE()\r
{\r
- cascade.detectMultiScale(img, rects); \r
+ cascade.detectMultiScale(img, rects);\r
}\r
}\r
\r
INSTANTIATE_TEST_CASE_P(ObjDetect, HaarClassifier, ALL_DEVICES);\r
\r
-\r
-\r
#endif\r
return imread(perf::TestBase::getDataPath(fileName), flags);\r
}\r
\r
-bool supportFeature(const DeviceInfo& info, FeatureSet feature)\r
-{\r
- return TargetArchs::builtWith(feature) && info.supports(feature);\r
-}\r
-\r
const vector<DeviceInfo>& devices()\r
{\r
static vector<DeviceInfo> devs;\r
\r
return devs;\r
}\r
-\r
-vector<DeviceInfo> devices(FeatureSet feature)\r
-{\r
- const vector<DeviceInfo>& d = devices();\r
-\r
- vector<DeviceInfo> devs_filtered;\r
-\r
- if (TargetArchs::builtWith(feature))\r
- {\r
- devs_filtered.reserve(d.size());\r
-\r
- for (size_t i = 0, size = d.size(); i < size; ++i)\r
- {\r
- const DeviceInfo& info = d[i];\r
-\r
- if (info.supports(feature))\r
- devs_filtered.push_back(info);\r
- }\r
- }\r
-\r
- return devs_filtered;\r
-}\r
-\r
-\r
\r
void fill(cv::Mat& m, double a, double b);\r
\r
-enum {HORIZONTAL_AXIS = 0, VERTICAL_AXIS = 1, BOTH_AXIS = -1};\r
-\r
using perf::MatType;\r
using perf::MatDepth;\r
\r
CV_ENUM(BorderMode, cv::BORDER_REFLECT101, cv::BORDER_REPLICATE, cv::BORDER_CONSTANT, cv::BORDER_REFLECT, cv::BORDER_WRAP)\r
-CV_ENUM(FlipCode, HORIZONTAL_AXIS, VERTICAL_AXIS, BOTH_AXIS)\r
CV_ENUM(Interpolation, cv::INTER_NEAREST, cv::INTER_LINEAR, cv::INTER_CUBIC)\r
-CV_ENUM(MatchMethod, cv::TM_SQDIFF, cv::TM_SQDIFF_NORMED, cv::TM_CCORR, cv::TM_CCORR_NORMED, cv::TM_CCOEFF, cv::TM_CCOEFF_NORMED)\r
CV_ENUM(NormType, cv::NORM_INF, cv::NORM_L1, cv::NORM_L2)\r
-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)\r
+\r
+struct CvtColorInfo\r
+{\r
+ int scn;\r
+ int dcn;\r
+ int code;\r
+\r
+ explicit CvtColorInfo(int scn_=0, int dcn_=0, int code_=0) : scn(scn_), dcn(dcn_), code(code_) {}\r
+};\r
+\r
+void PrintTo(const CvtColorInfo& info, std::ostream* os);\r
\r
#define IMPLEMENT_PARAM_CLASS(name, type) \\r
class name \\r
*os << #name << "(" << testing::PrintToString(static_cast< type >(param)) << ")"; \\r
}\r
\r
-struct CvtColorInfo\r
-{\r
- int scn;\r
- int dcn;\r
- int code;\r
-\r
- explicit CvtColorInfo(int scn_=0, int dcn_=0, int code_=0) : scn(scn_), dcn(dcn_), code(code_) {}\r
-};\r
-\r
-void PrintTo(const CvtColorInfo& info, std::ostream* os);\r
+IMPLEMENT_PARAM_CLASS(Channels, int)\r
\r
namespace cv { namespace gpu\r
{\r
\r
cv::Mat readImage(const std::string& fileName, int flags = cv::IMREAD_COLOR);\r
\r
-bool supportFeature(const cv::gpu::DeviceInfo& info, cv::gpu::FeatureSet feature);\r
-\r
const std::vector<cv::gpu::DeviceInfo>& devices();\r
\r
-std::vector<cv::gpu::DeviceInfo> devices(cv::gpu::FeatureSet feature);\r
-\r
#define ALL_DEVICES testing::ValuesIn(devices())\r
-#define DEVICES(feature) testing::ValuesIn(devices(feature))\r
\r
#define GET_PARAM(k) std::tr1::get< k >(GetParam())\r
\r
//////////////////////////////////////////////////////\r
// GoodFeaturesToTrack\r
\r
-GPU_PERF_TEST(GoodFeaturesToTrack, cv::gpu::DeviceInfo, double)\r
+IMPLEMENT_PARAM_CLASS(MinDistance, double)\r
+\r
+GPU_PERF_TEST(GoodFeaturesToTrack, cv::gpu::DeviceInfo, MinDistance)\r
{\r
double minDistance = GET_PARAM(1);\r
\r
cv::Mat image = readImage("gpu/perf/aloe.jpg", cv::IMREAD_GRAYSCALE);\r
-\r
ASSERT_FALSE(image.empty());\r
\r
cv::Mat corners;\r
\r
+ cv::goodFeaturesToTrack(image, corners, 8000, 0.01, minDistance);\r
+\r
TEST_CYCLE()\r
{\r
cv::goodFeaturesToTrack(image, corners, 8000, 0.01, minDistance);\r
}\r
}\r
\r
-INSTANTIATE_TEST_CASE_P(Video, GoodFeaturesToTrack, testing::Combine(ALL_DEVICES, testing::Values(0.0, 3.0)));\r
+INSTANTIATE_TEST_CASE_P(Video, GoodFeaturesToTrack, testing::Combine(\r
+ ALL_DEVICES,\r
+ testing::Values(MinDistance(0.0), MinDistance(3.0))));\r
\r
//////////////////////////////////////////////////////\r
// PyrLKOpticalFlowSparse\r
\r
-GPU_PERF_TEST(PyrLKOpticalFlowSparse, cv::gpu::DeviceInfo, bool, int, int)\r
+IMPLEMENT_PARAM_CLASS(GraySource, bool)\r
+IMPLEMENT_PARAM_CLASS(Points, int)\r
+IMPLEMENT_PARAM_CLASS(WinSize, int)\r
+\r
+GPU_PERF_TEST(PyrLKOpticalFlowSparse, cv::gpu::DeviceInfo, GraySource, Points, WinSize)\r
{\r
bool useGray = GET_PARAM(1);\r
int points = GET_PARAM(2);\r
int win_size = GET_PARAM(3);\r
\r
cv::Mat frame0 = readImage("gpu/opticalflow/frame0.png", useGray ? cv::IMREAD_GRAYSCALE : cv::IMREAD_COLOR);\r
- cv::Mat frame1 = readImage("gpu/opticalflow/frame1.png", useGray ? cv::IMREAD_GRAYSCALE : cv::IMREAD_COLOR);\r
-\r
ASSERT_FALSE(frame0.empty());\r
+\r
+ cv::Mat frame1 = readImage("gpu/opticalflow/frame1.png", useGray ? cv::IMREAD_GRAYSCALE : cv::IMREAD_COLOR);\r
ASSERT_FALSE(frame1.empty());\r
\r
cv::Mat gray_frame;\r
cv::Mat nextPts;\r
cv::Mat status;\r
\r
+ cv::calcOpticalFlowPyrLK(frame0, frame1, pts, nextPts, status, cv::noArray(), cv::Size(win_size, win_size));\r
+\r
TEST_CYCLE()\r
{\r
cv::calcOpticalFlowPyrLK(frame0, frame1, pts, nextPts, status, cv::noArray(), cv::Size(win_size, win_size));\r
}\r
\r
INSTANTIATE_TEST_CASE_P(Video, PyrLKOpticalFlowSparse, testing::Combine(\r
- ALL_DEVICES,\r
- testing::Bool(),\r
- testing::Values(1000, 2000, 4000, 8000),\r
- testing::Values(17, 21)));\r
+ ALL_DEVICES,\r
+ testing::Values(GraySource(true), GraySource(false)),\r
+ testing::Values(Points(1000), Points(2000), Points(4000), Points(8000)),\r
+ testing::Values(WinSize(17), WinSize(21))));\r
\r
//////////////////////////////////////////////////////\r
// FarnebackOpticalFlowTest\r
GPU_PERF_TEST_1(FarnebackOpticalFlowTest, cv::gpu::DeviceInfo)\r
{\r
cv::Mat frame0 = readImage("gpu/opticalflow/frame0.png", cv::IMREAD_GRAYSCALE);\r
- cv::Mat frame1 = readImage("gpu/opticalflow/frame1.png", cv::IMREAD_GRAYSCALE);\r
-\r
ASSERT_FALSE(frame0.empty());\r
+\r
+ cv::Mat frame1 = readImage("gpu/opticalflow/frame1.png", cv::IMREAD_GRAYSCALE);\r
ASSERT_FALSE(frame1.empty());\r
\r
cv::Mat flow;\r
\r
- declare.time(10);\r
-\r
int numLevels = 5;\r
double pyrScale = 0.5;\r
int winSize = 13;\r
double polySigma = 1.1;\r
int flags = 0;\r
\r
+ cv::calcOpticalFlowFarneback(frame0, frame1, flow, pyrScale, numLevels, winSize, numIters, polyN, polySigma, flags);\r
+\r
+ declare.time(10);\r
+\r
TEST_CYCLE()\r
{\r
- cv::calcOpticalFlowFarneback(frame0, frame1, flow, pyrScale, numLevels, winSize, numIters, polyN, polySigma, flags);\r
}\r
}\r
\r
cv::Scalar_<int> val = randomScalar(0.0, 8.0);\r
\r
cv::gpu::GpuMat dst = createMat(size, type, useRoi);\r
- cv::gpu::rshift(loadMat(src, useRoi), val, dst);\r
+ cv::gpu::lshift(loadMat(src, useRoi), val, dst);\r
\r
cv::Mat dst_gold;\r
- rhiftGold(src, val, dst_gold);\r
+ lhiftGold(src, val, dst_gold);\r
\r
EXPECT_MAT_NEAR(dst_gold, dst, 0.0);\r
}\r
projects / platform / upstream / opencv.git / commitdiff