diff --git a/modules/gpu/perf/perf_core.cpp b/modules/gpu/perf/perf_core.cpp index 21beedce73..87e22c4695 100644 --- a/modules/gpu/perf/perf_core.cpp +++ b/modules/gpu/perf/perf_core.cpp @@ -528,14 +528,17 @@ PERF_TEST_P(Sz_Depth, Core_AbsDiffScalar, ////////////////////////////////////////////////////////////////////// // Abs -PERF_TEST_P(Sz_Depth, Core_Abs, Combine( - GPU_TYPICAL_MAT_SIZES, #ifdef OPENCV_TINY_GPU_MODULE - Values(MatDepth(CV_32F)) -#else - Values(CV_16S, CV_32F) -#endif +PERF_TEST_P(Sz_Depth, Core_Abs, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(MatDepth(CV_32F)) )) +#else +PERF_TEST_P(Sz_Depth, Core_Abs, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(CV_16S, CV_32F) +)) +#endif { const cv::Size size = GET_PARAM(0); const int depth = GET_PARAM(1); @@ -561,14 +564,17 @@ PERF_TEST_P(Sz_Depth, Core_Abs, Combine( ////////////////////////////////////////////////////////////////////// // Sqr -PERF_TEST_P(Sz_Depth, Core_Sqr, Combine( - GPU_TYPICAL_MAT_SIZES, #ifdef OPENCV_TINY_GPU_MODULE - Values(MatDepth(CV_32F)) -#else - Values(CV_8U, CV_16S, CV_32F) -#endif +PERF_TEST_P(Sz_Depth, Core_Sqr, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(MatDepth(CV_32F)) )) +#else +PERF_TEST_P(Sz_Depth, Core_Sqr, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(CV_8U, CV_16S, CV_32F) +)) +#endif { const cv::Size size = GET_PARAM(0); const int depth = GET_PARAM(1); @@ -594,14 +600,17 @@ PERF_TEST_P(Sz_Depth, Core_Sqr, Combine( ////////////////////////////////////////////////////////////////////// // Sqrt -PERF_TEST_P(Sz_Depth, Core_Sqrt, Combine( - GPU_TYPICAL_MAT_SIZES, #ifdef OPENCV_TINY_GPU_MODULE - Values(MatDepth(CV_32F)) -#else - Values(CV_8U, CV_16S, CV_32F) -#endif +PERF_TEST_P(Sz_Depth, Core_Sqrt, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(MatDepth(CV_32F)) )) +#else +PERF_TEST_P(Sz_Depth, Core_Sqrt, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(CV_8U, CV_16S, CV_32F) +)) +#endif { const cv::Size size = GET_PARAM(0); const int depth = GET_PARAM(1); @@ -631,14 +640,17 @@ PERF_TEST_P(Sz_Depth, Core_Sqrt, Combine( ////////////////////////////////////////////////////////////////////// // Log -PERF_TEST_P(Sz_Depth, Core_Log, Combine( - GPU_TYPICAL_MAT_SIZES, #ifdef OPENCV_TINY_GPU_MODULE - Values(MatDepth(CV_32F)) -#else - Values(CV_8U, CV_16S, CV_32F) -#endif +PERF_TEST_P(Sz_Depth, Core_Log, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(MatDepth(CV_32F)) )) +#else +PERF_TEST_P(Sz_Depth, Core_Log, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(CV_8U, CV_16S, CV_32F) +)) +#endif { const cv::Size size = GET_PARAM(0); const int depth = GET_PARAM(1); @@ -668,14 +680,17 @@ PERF_TEST_P(Sz_Depth, Core_Log, Combine( ////////////////////////////////////////////////////////////////////// // Exp -PERF_TEST_P(Sz_Depth, Core_Exp, Combine( - GPU_TYPICAL_MAT_SIZES, #ifdef OPENCV_TINY_GPU_MODULE - Values(MatDepth(CV_32F)) -#else - Values(CV_8U, CV_16S, CV_32F) -#endif +PERF_TEST_P(Sz_Depth, Core_Exp, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(MatDepth(CV_32F)) )) +#else +PERF_TEST_P(Sz_Depth, Core_Exp, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(CV_8U, CV_16S, CV_32F) +)) +#endif { const cv::Size size = GET_PARAM(0); const int depth = GET_PARAM(1); @@ -707,15 +722,19 @@ PERF_TEST_P(Sz_Depth, Core_Exp, Combine( DEF_PARAM_TEST(Sz_Depth_Power, cv::Size, MatDepth, double); -PERF_TEST_P(Sz_Depth_Power, Core_Pow, Combine( - GPU_TYPICAL_MAT_SIZES, #ifdef OPENCV_TINY_GPU_MODULE - Values(MatDepth(CV_32F)), -#else - Values(CV_8U, CV_16S, CV_32F), -#endif - Values(0.3, 2.0, 2.4) +PERF_TEST_P(Sz_Depth_Power, Core_Pow, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(MatDepth(CV_32F)), + Values(0.3, 2.0, 2.4) )) +#else +PERF_TEST_P(Sz_Depth_Power, Core_Pow, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(CV_8U, CV_16S, CV_32F), + Values(0.3, 2.0, 2.4) +)) +#endif { const cv::Size size = GET_PARAM(0); const int depth = GET_PARAM(1); @@ -893,16 +912,19 @@ PERF_TEST_P(Sz_Depth, Core_BitwiseAndMat, ////////////////////////////////////////////////////////////////////// // BitwiseAndScalar -PERF_TEST_P(Sz_Depth_Cn, Core_BitwiseAndScalar, Combine( - GPU_TYPICAL_MAT_SIZES, #ifdef OPENCV_TINY_GPU_MODULE - Values(MatDepth(CV_8U)), - testing::Values(MatCn(Gray)) -#else - Values(CV_8U, CV_16U, CV_32S), - GPU_CHANNELS_1_3_4 -#endif +PERF_TEST_P(Sz_Depth_Cn, Core_BitwiseAndScalar, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(MatDepth(CV_8U)), + testing::Values(MatCn(Gray)) )) +#else +PERF_TEST_P(Sz_Depth_Cn, Core_BitwiseAndScalar, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(CV_8U, CV_16U, CV_32S), + GPU_CHANNELS_1_3_4 +)) +#endif { const cv::Size size = GET_PARAM(0); const int depth = GET_PARAM(1); @@ -975,16 +997,19 @@ PERF_TEST_P(Sz_Depth, Core_BitwiseOrMat, ////////////////////////////////////////////////////////////////////// // BitwiseOrScalar -PERF_TEST_P(Sz_Depth_Cn, Core_BitwiseOrScalar, Combine( - GPU_TYPICAL_MAT_SIZES, #ifdef OPENCV_TINY_GPU_MODULE - Values(MatDepth(CV_8U)), - testing::Values(MatCn(Gray)) -#else - Values(CV_8U, CV_16U, CV_32S), - GPU_CHANNELS_1_3_4 -#endif +PERF_TEST_P(Sz_Depth_Cn, Core_BitwiseOrScalar, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(MatDepth(CV_8U)), + testing::Values(MatCn(Gray)) )) +#else +PERF_TEST_P(Sz_Depth_Cn, Core_BitwiseOrScalar, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(CV_8U, CV_16U, CV_32S), + GPU_CHANNELS_1_3_4 +)) +#endif { const cv::Size size = GET_PARAM(0); const int depth = GET_PARAM(1); @@ -1057,16 +1082,19 @@ PERF_TEST_P(Sz_Depth, Core_BitwiseXorMat, ////////////////////////////////////////////////////////////////////// // BitwiseXorScalar -PERF_TEST_P(Sz_Depth_Cn, Core_BitwiseXorScalar, Combine( - GPU_TYPICAL_MAT_SIZES, #ifdef OPENCV_TINY_GPU_MODULE - Values(MatDepth(CV_8U)), - testing::Values(MatCn(Gray)) -#else - Values(CV_8U, CV_16U, CV_32S), - GPU_CHANNELS_1_3_4 -#endif +PERF_TEST_P(Sz_Depth_Cn, Core_BitwiseXorScalar, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(MatDepth(CV_8U)), + testing::Values(MatCn(Gray)) )) +#else +PERF_TEST_P(Sz_Depth_Cn, Core_BitwiseXorScalar, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(CV_8U, CV_16U, CV_32S), + GPU_CHANNELS_1_3_4 +)) +#endif { const cv::Size size = GET_PARAM(0); const int depth = GET_PARAM(1); @@ -1207,14 +1235,17 @@ PERF_TEST_P(Sz_Depth, Core_MinMat, ////////////////////////////////////////////////////////////////////// // MinScalar -PERF_TEST_P(Sz_Depth, Core_MinScalar, Combine( - GPU_TYPICAL_MAT_SIZES, #ifdef OPENCV_TINY_GPU_MODULE - Values(CV_8U, CV_32F) -#else - Values(CV_8U, CV_16U, CV_32F) -#endif +PERF_TEST_P(Sz_Depth, Core_MinScalar, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(CV_8U, CV_32F) )) +#else +PERF_TEST_P(Sz_Depth, Core_MinScalar, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(CV_8U, CV_16U, CV_32F) +)) +#endif { const cv::Size size = GET_PARAM(0); const int depth = GET_PARAM(1); @@ -1283,14 +1314,17 @@ PERF_TEST_P(Sz_Depth, Core_MaxMat, ////////////////////////////////////////////////////////////////////// // MaxScalar -PERF_TEST_P(Sz_Depth, Core_MaxScalar, Combine( - GPU_TYPICAL_MAT_SIZES, #ifdef OPENCV_TINY_GPU_MODULE - Values(CV_8U, CV_32F) -#else - Values(CV_8U, CV_16U, CV_32F) -#endif +PERF_TEST_P(Sz_Depth, Core_MaxScalar, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(CV_8U, CV_32F) )) +#else +PERF_TEST_P(Sz_Depth, Core_MaxScalar, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(CV_8U, CV_16U, CV_32F) +)) +#endif { const cv::Size size = GET_PARAM(0); const int depth = GET_PARAM(1); @@ -1325,18 +1359,21 @@ PERF_TEST_P(Sz_Depth, Core_MaxScalar, Combine( DEF_PARAM_TEST(Sz_3Depth, cv::Size, MatDepth, MatDepth, MatDepth); -PERF_TEST_P(Sz_3Depth, Core_AddWeighted, - Combine(GPU_TYPICAL_MAT_SIZES, #ifdef OPENCV_TINY_GPU_MODULE - Values(MatDepth(CV_32F)), - Values(MatDepth(CV_32F)), - Values(MatDepth(CV_32F)) -#else - Values(CV_8U, CV_16U, CV_32F, CV_64F), - Values(CV_8U, CV_16U, CV_32F, CV_64F), - Values(CV_8U, CV_16U, CV_32F, CV_64F) -#endif +PERF_TEST_P(Sz_3Depth, Core_AddWeighted, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(MatDepth(CV_32F)), + Values(MatDepth(CV_32F)), + Values(MatDepth(CV_32F)) )) +#else +PERF_TEST_P(Sz_3Depth, Core_AddWeighted, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(CV_8U, CV_16U, CV_32F, CV_64F), + Values(CV_8U, CV_16U, CV_32F, CV_64F), + Values(CV_8U, CV_16U, CV_32F, CV_64F) +)) +#endif { const cv::Size size = GET_PARAM(0); const int depth1 = GET_PARAM(1); @@ -1851,14 +1888,19 @@ PERF_TEST_P(Sz, Core_MeanStdDev, DEF_PARAM_TEST(Sz_Depth_Norm, cv::Size, MatDepth, NormType); -PERF_TEST_P(Sz_Depth_Norm, Core_Norm, - Combine(GPU_TYPICAL_MAT_SIZES, #ifdef OPENCV_TINY_GPU_MODULE - Values(CV_8U, CV_32F), +PERF_TEST_P(Sz_Depth_Norm, Core_Norm, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(CV_8U, CV_32F), + Values(NormType(cv::NORM_INF), NormType(cv::NORM_L1), NormType(cv::NORM_L2)) +)) #else - Values(CV_8U, CV_16U, CV_32S, CV_32F), +PERF_TEST_P(Sz_Depth_Norm, Core_Norm, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(CV_8U, CV_16U, CV_32S, CV_32F), + Values(NormType(cv::NORM_INF), NormType(cv::NORM_L1), NormType(cv::NORM_L2)) +)) #endif - Values(NormType(cv::NORM_INF), NormType(cv::NORM_L1), NormType(cv::NORM_L2)))) { const cv::Size size = GET_PARAM(0); const int depth = GET_PARAM(1); @@ -1932,16 +1974,19 @@ PERF_TEST_P(Sz_Norm, Core_NormDiff, ////////////////////////////////////////////////////////////////////// // Sum -PERF_TEST_P(Sz_Depth_Cn, Core_Sum, Combine( - GPU_TYPICAL_MAT_SIZES, #ifdef OPENCV_TINY_GPU_MODULE - Values(CV_8U, CV_32F), - testing::Values(MatCn(Gray)) -#else - Values(CV_8U, CV_16U, CV_32F), - GPU_CHANNELS_1_3_4 -#endif +PERF_TEST_P(Sz_Depth_Cn, Core_Sum, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(CV_8U, CV_32F), + testing::Values(MatCn(Gray)) )) +#else +PERF_TEST_P(Sz_Depth_Cn, Core_Sum, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(CV_8U, CV_16U, CV_32F), + GPU_CHANNELS_1_3_4 +)) +#endif { const cv::Size size = GET_PARAM(0); const int depth = GET_PARAM(1); @@ -1975,16 +2020,19 @@ PERF_TEST_P(Sz_Depth_Cn, Core_Sum, Combine( ////////////////////////////////////////////////////////////////////// // SumAbs -PERF_TEST_P(Sz_Depth_Cn, Core_SumAbs, Combine( - GPU_TYPICAL_MAT_SIZES, #ifdef OPENCV_TINY_GPU_MODULE - Values(CV_8U, CV_32F), - testing::Values(MatCn(Gray)) -#else - Values(CV_8U, CV_16U, CV_32F), - GPU_CHANNELS_1_3_4 -#endif +PERF_TEST_P(Sz_Depth_Cn, Core_SumAbs, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(CV_8U, CV_32F), + testing::Values(MatCn(Gray)) )) +#else +PERF_TEST_P(Sz_Depth_Cn, Core_SumAbs, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(CV_8U, CV_16U, CV_32F), + GPU_CHANNELS_1_3_4 +)) +#endif { const cv::Size size = GET_PARAM(0); const int depth = GET_PARAM(1); @@ -2014,16 +2062,19 @@ PERF_TEST_P(Sz_Depth_Cn, Core_SumAbs, Combine( ////////////////////////////////////////////////////////////////////// // SumSqr -PERF_TEST_P(Sz_Depth_Cn, Core_SumSqr, Combine( - GPU_TYPICAL_MAT_SIZES, #ifdef OPENCV_TINY_GPU_MODULE - Values(CV_8U, CV_32F), - testing::Values(MatCn(Gray)) -#else - Values(CV_8U, CV_16U, CV_32F), - GPU_CHANNELS_1_3_4 -#endif +PERF_TEST_P(Sz_Depth_Cn, Core_SumSqr, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(CV_8U, CV_32F), + testing::Values(MatCn(Gray)) )) +#else +PERF_TEST_P(Sz_Depth_Cn, Core_SumSqr, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(CV_8U, CV_16U, CV_32F), + GPU_CHANNELS_1_3_4 +)) +#endif { const cv::Size size = GET_PARAM(0); const int depth = GET_PARAM(1); @@ -2053,14 +2104,17 @@ PERF_TEST_P(Sz_Depth_Cn, Core_SumSqr, Combine( ////////////////////////////////////////////////////////////////////// // MinMax -PERF_TEST_P(Sz_Depth, Core_MinMax, Combine( - GPU_TYPICAL_MAT_SIZES, #ifdef OPENCV_TINY_GPU_MODULE - Values(CV_8U, CV_32F) -#else - Values(CV_8U, CV_16U, CV_32F, CV_64F) -#endif +PERF_TEST_P(Sz_Depth, Core_MinMax, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(CV_8U, CV_32F) )) +#else +PERF_TEST_P(Sz_Depth, Core_MinMax, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(CV_8U, CV_16U, CV_32F, CV_64F) +)) +#endif { const cv::Size size = GET_PARAM(0); const int depth = GET_PARAM(1); @@ -2096,14 +2150,17 @@ PERF_TEST_P(Sz_Depth, Core_MinMax, Combine( ////////////////////////////////////////////////////////////////////// // MinMaxLoc -PERF_TEST_P(Sz_Depth, Core_MinMaxLoc, Combine( - GPU_TYPICAL_MAT_SIZES, #ifdef OPENCV_TINY_GPU_MODULE - Values(CV_8U, CV_32F) -#else - Values(CV_8U, CV_16U, CV_32F, CV_64F) -#endif +PERF_TEST_P(Sz_Depth, Core_MinMaxLoc, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(CV_8U, CV_32F) )) +#else +PERF_TEST_P(Sz_Depth, Core_MinMaxLoc, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(CV_8U, CV_16U, CV_32F, CV_64F) +)) +#endif { const cv::Size size = GET_PARAM(0); const int depth = GET_PARAM(1); @@ -2141,14 +2198,17 @@ PERF_TEST_P(Sz_Depth, Core_MinMaxLoc, Combine( ////////////////////////////////////////////////////////////////////// // CountNonZero -PERF_TEST_P(Sz_Depth, Core_CountNonZero, Combine( - GPU_TYPICAL_MAT_SIZES, #ifdef OPENCV_TINY_GPU_MODULE - Values(CV_8U, CV_32F) -#else - Values(CV_8U, CV_16U, CV_32F, CV_64F) -#endif +PERF_TEST_P(Sz_Depth, Core_CountNonZero, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(CV_8U, CV_32F) )) +#else +PERF_TEST_P(Sz_Depth, Core_CountNonZero, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(CV_8U, CV_16U, CV_32F, CV_64F) +)) +#endif { const cv::Size size = GET_PARAM(0); const int depth = GET_PARAM(1); @@ -2185,17 +2245,23 @@ CV_ENUM(ReduceDim, Rows, Cols) DEF_PARAM_TEST(Sz_Depth_Cn_Code_Dim, cv::Size, MatDepth, MatCn, ReduceCode, ReduceDim); -PERF_TEST_P(Sz_Depth_Cn_Code_Dim, Core_Reduce, Combine( - GPU_TYPICAL_MAT_SIZES, #ifdef OPENCV_TINY_GPU_MODULE - Values(CV_8U, CV_32F), -#else - Values(CV_8U, CV_16U, CV_16S, CV_32F), -#endif - Values(1, 2, 3, 4), - ReduceCode::all(), - ReduceDim::all() +PERF_TEST_P(Sz_Depth_Cn_Code_Dim, Core_Reduce, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(CV_8U, CV_32F), + Values(1, 2, 3, 4), + ReduceCode::all(), + ReduceDim::all() )) +#else +PERF_TEST_P(Sz_Depth_Cn_Code_Dim, Core_Reduce, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(CV_8U, CV_16U, CV_16S, CV_32F), + Values(1, 2, 3, 4), + ReduceCode::all(), + ReduceDim::all() +)) +#endif { const cv::Size size = GET_PARAM(0); const int depth = GET_PARAM(1); @@ -2231,18 +2297,25 @@ PERF_TEST_P(Sz_Depth_Cn_Code_Dim, Core_Reduce, Combine( DEF_PARAM_TEST(Sz_Depth_NormType, cv::Size, MatDepth, NormType); -PERF_TEST_P(Sz_Depth_NormType, Core_Normalize, Combine( - GPU_TYPICAL_MAT_SIZES, #ifdef OPENCV_TINY_GPU_MODULE - Values(CV_8U, CV_32F), -#else - Values(CV_8U, CV_16U, CV_32F, CV_64F), -#endif - Values(NormType(cv::NORM_INF), - NormType(cv::NORM_L1), - NormType(cv::NORM_L2), - NormType(cv::NORM_MINMAX)) +PERF_TEST_P(Sz_Depth_NormType, Core_Normalize, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(CV_8U, CV_32F), + Values(NormType(cv::NORM_INF), + NormType(cv::NORM_L1), + NormType(cv::NORM_L2), + NormType(cv::NORM_MINMAX)) )) +#else +PERF_TEST_P(Sz_Depth_NormType, Core_Normalize, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(CV_8U, CV_16U, CV_32F, CV_64F), + Values(NormType(cv::NORM_INF), + NormType(cv::NORM_L1), + NormType(cv::NORM_L2), + NormType(cv::NORM_MINMAX)) +)) +#endif { const cv::Size size = GET_PARAM(0); const int type = GET_PARAM(1); diff --git a/modules/gpu/perf/perf_features2d.cpp b/modules/gpu/perf/perf_features2d.cpp index dc8ccd057a..5a21acdff6 100644 --- a/modules/gpu/perf/perf_features2d.cpp +++ b/modules/gpu/perf/perf_features2d.cpp @@ -145,14 +145,17 @@ PERF_TEST_P(Image_NFeatures, Features2D_ORB, DEF_PARAM_TEST(DescSize_Norm, int, NormType); -PERF_TEST_P(DescSize_Norm, Features2D_BFMatch, Combine( - Values(64, 128, 256), #ifdef OPENCV_TINY_GPU_MODULE - Values(NormType(cv::NORM_L2), NormType(cv::NORM_HAMMING)) -#else - Values(NormType(cv::NORM_L1), NormType(cv::NORM_L2), NormType(cv::NORM_HAMMING)) -#endif +PERF_TEST_P(DescSize_Norm, Features2D_BFMatch, Combine( + Values(64, 128, 256), + Values(NormType(cv::NORM_L2), NormType(cv::NORM_HAMMING)) )) +#else +PERF_TEST_P(DescSize_Norm, Features2D_BFMatch, Combine( + Values(64, 128, 256), + Values(NormType(cv::NORM_L1), NormType(cv::NORM_L2), NormType(cv::NORM_HAMMING)) +)) +#endif { declare.time(20.0); @@ -207,15 +210,19 @@ static void toOneRowMatches(const std::vector< std::vector >& src, s DEF_PARAM_TEST(DescSize_K_Norm, int, int, NormType); -PERF_TEST_P(DescSize_K_Norm, Features2D_BFKnnMatch, Combine( - Values(64, 128, 256), - Values(2, 3), #ifdef OPENCV_TINY_GPU_MODULE - Values(NormType(cv::NORM_L2)) -#else - Values(NormType(cv::NORM_L1), NormType(cv::NORM_L2)) -#endif +PERF_TEST_P(DescSize_K_Norm, Features2D_BFKnnMatch, Combine( + Values(64, 128, 256), + Values(2, 3), + Values(NormType(cv::NORM_L2)) )) +#else +PERF_TEST_P(DescSize_K_Norm, Features2D_BFKnnMatch, Combine( + Values(64, 128, 256), + Values(2, 3), + Values(NormType(cv::NORM_L1), NormType(cv::NORM_L2)) +)) +#endif { declare.time(30.0); @@ -267,14 +274,17 @@ PERF_TEST_P(DescSize_K_Norm, Features2D_BFKnnMatch, Combine( ////////////////////////////////////////////////////////////////////// // BFRadiusMatch -PERF_TEST_P(DescSize_Norm, Features2D_BFRadiusMatch, Combine( - Values(64, 128, 256), #ifdef OPENCV_TINY_GPU_MODULE - Values(NormType(cv::NORM_L2)) -#else - Values(NormType(cv::NORM_L1), NormType(cv::NORM_L2)) -#endif +PERF_TEST_P(DescSize_Norm, Features2D_BFRadiusMatch, Combine( + Values(64, 128, 256), + Values(NormType(cv::NORM_L2)) )) +#else +PERF_TEST_P(DescSize_Norm, Features2D_BFRadiusMatch, Combine( + Values(64, 128, 256), + Values(NormType(cv::NORM_L1), NormType(cv::NORM_L2)) +)) +#endif { declare.time(30.0); diff --git a/modules/gpu/perf/perf_filters.cpp b/modules/gpu/perf/perf_filters.cpp index c317a7bcec..f064dd395e 100644 --- a/modules/gpu/perf/perf_filters.cpp +++ b/modules/gpu/perf/perf_filters.cpp @@ -88,9 +88,17 @@ PERF_TEST_P(Sz_Type_KernelSz, Filters_Blur, // Sobel #ifdef OPENCV_TINY_GPU_MODULE -PERF_TEST_P(Sz_Type_KernelSz, Filters_Sobel, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8UC1, CV_8UC4, CV_32FC1), Values(3, 5, 7))) +PERF_TEST_P(Sz_Type_KernelSz, Filters_Sobel, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(CV_8UC1, CV_8UC4, CV_32FC1), + Values(3, 5, 7) +)) #else -PERF_TEST_P(Sz_Type_KernelSz, Filters_Sobel, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8UC1, CV_8UC4, CV_32FC1), Values(3, 5, 7, 9, 11, 13, 15))) +PERF_TEST_P(Sz_Type_KernelSz, Filters_Sobel, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(CV_8UC1, CV_8UC4, CV_32FC1), + Values(3, 5, 7, 9, 11, 13, 15) +)) #endif { declare.time(20.0); @@ -159,9 +167,17 @@ PERF_TEST_P(Sz_Type, Filters_Scharr, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U // GaussianBlur #ifdef OPENCV_TINY_GPU_MODULE -PERF_TEST_P(Sz_Type_KernelSz, Filters_GaussianBlur, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8UC1, CV_8UC4, CV_32FC1), Values(3, 5, 7))) +PERF_TEST_P(Sz_Type_KernelSz, Filters_GaussianBlur, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(CV_8UC1, CV_8UC4, CV_32FC1), + Values(3, 5, 7) +)) #else -PERF_TEST_P(Sz_Type_KernelSz, Filters_GaussianBlur, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8UC1, CV_8UC4, CV_32FC1), Values(3, 5, 7, 9, 11, 13, 15))) +PERF_TEST_P(Sz_Type_KernelSz, Filters_GaussianBlur, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(CV_8UC1, CV_8UC4, CV_32FC1), + Values(3, 5, 7, 9, 11, 13, 15) +)) #endif { declare.time(20.0); diff --git a/modules/gpu/perf/perf_imgproc.cpp b/modules/gpu/perf/perf_imgproc.cpp index 1181598ba0..f2762e07c0 100644 --- a/modules/gpu/perf/perf_imgproc.cpp +++ b/modules/gpu/perf/perf_imgproc.cpp @@ -91,21 +91,25 @@ void generateMap(cv::Mat& map_x, cv::Mat& map_y, int remapMode) DEF_PARAM_TEST(Sz_Depth_Cn_Inter_Border_Mode, cv::Size, MatDepth, MatCn, Interpolation, BorderMode, RemapMode); -PERF_TEST_P(Sz_Depth_Cn_Inter_Border_Mode, ImgProc_Remap, - Combine(GPU_TYPICAL_MAT_SIZES, #ifdef OPENCV_TINY_GPU_MODULE - Values(CV_8U, CV_32F), +PERF_TEST_P(Sz_Depth_Cn_Inter_Border_Mode, ImgProc_Remap, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(CV_8U, CV_32F), + GPU_CHANNELS_1_3_4, + Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR)), + ALL_BORDER_MODES, + RemapMode::all() +)) #else - Values(CV_8U, CV_16U, CV_32F), +PERF_TEST_P(Sz_Depth_Cn_Inter_Border_Mode, ImgProc_Remap, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(CV_8U, CV_16U, CV_32F), + GPU_CHANNELS_1_3_4, + Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)), + ALL_BORDER_MODES, + RemapMode::all() +)) #endif - GPU_CHANNELS_1_3_4, -#ifdef OPENCV_TINY_GPU_MODULE - Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR)), -#else - Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)), -#endif - ALL_BORDER_MODES, - RemapMode::all())) { declare.time(20.0); @@ -151,20 +155,23 @@ PERF_TEST_P(Sz_Depth_Cn_Inter_Border_Mode, ImgProc_Remap, DEF_PARAM_TEST(Sz_Depth_Cn_Inter_Scale, cv::Size, MatDepth, MatCn, Interpolation, double); -PERF_TEST_P(Sz_Depth_Cn_Inter_Scale, ImgProc_Resize, - Combine(GPU_TYPICAL_MAT_SIZES, #ifdef OPENCV_TINY_GPU_MODULE - Values(CV_8U, CV_32F), +PERF_TEST_P(Sz_Depth_Cn_Inter_Scale, ImgProc_Resize, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(CV_8U, CV_32F), + GPU_CHANNELS_1_3_4, + Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR)), + Values(0.5, 0.3, 2.0) +)) #else - Values(CV_8U, CV_16U, CV_32F), +PERF_TEST_P(Sz_Depth_Cn_Inter_Scale, ImgProc_Resize, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(CV_8U, CV_16U, CV_32F), + GPU_CHANNELS_1_3_4, + Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)), + Values(0.5, 0.3, 2.0) +)) #endif - GPU_CHANNELS_1_3_4, -#ifdef OPENCV_TINY_GPU_MODULE - Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR)), -#else - Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)), -#endif - Values(0.5, 0.3, 2.0))) { declare.time(20.0); @@ -203,15 +210,21 @@ PERF_TEST_P(Sz_Depth_Cn_Inter_Scale, ImgProc_Resize, DEF_PARAM_TEST(Sz_Depth_Cn_Scale, cv::Size, MatDepth, MatCn, double); -PERF_TEST_P(Sz_Depth_Cn_Scale, ImgProc_ResizeArea, - Combine(GPU_TYPICAL_MAT_SIZES, #ifdef OPENCV_TINY_GPU_MODULE - Values(CV_8U, CV_32F), +PERF_TEST_P(Sz_Depth_Cn_Scale, ImgProc_ResizeArea, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(CV_8U, CV_32F), + GPU_CHANNELS_1_3_4, + Values(0.2, 0.1, 0.05) +)) #else - Values(CV_8U, CV_16U, CV_32F), +PERF_TEST_P(Sz_Depth_Cn_Scale, ImgProc_ResizeArea, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(CV_8U, CV_16U, CV_32F), + GPU_CHANNELS_1_3_4, + Values(0.2, 0.1, 0.05) +)) #endif - GPU_CHANNELS_1_3_4, - Values(0.2, 0.1, 0.05))) { declare.time(1.0); @@ -250,20 +263,23 @@ PERF_TEST_P(Sz_Depth_Cn_Scale, ImgProc_ResizeArea, DEF_PARAM_TEST(Sz_Depth_Cn_Inter_Border, cv::Size, MatDepth, MatCn, Interpolation, BorderMode); -PERF_TEST_P(Sz_Depth_Cn_Inter_Border, ImgProc_WarpAffine, - Combine(GPU_TYPICAL_MAT_SIZES, #ifdef OPENCV_TINY_GPU_MODULE - Values(CV_8U, CV_32F), +PERF_TEST_P(Sz_Depth_Cn_Inter_Border, ImgProc_WarpAffine, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(CV_8U, CV_32F), + GPU_CHANNELS_1_3_4, + Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR)), + ALL_BORDER_MODES) +) #else - Values(CV_8U, CV_16U, CV_32F), +PERF_TEST_P(Sz_Depth_Cn_Inter_Border, ImgProc_WarpAffine, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(CV_8U, CV_16U, CV_32F), + GPU_CHANNELS_1_3_4, + Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)), + ALL_BORDER_MODES) +) #endif - GPU_CHANNELS_1_3_4, -#ifdef OPENCV_TINY_GPU_MODULE - Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR)), -#else - Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)), -#endif - ALL_BORDER_MODES)) { declare.time(20.0); @@ -308,20 +324,23 @@ PERF_TEST_P(Sz_Depth_Cn_Inter_Border, ImgProc_WarpAffine, ////////////////////////////////////////////////////////////////////// // WarpPerspective -PERF_TEST_P(Sz_Depth_Cn_Inter_Border, ImgProc_WarpPerspective, - Combine(GPU_TYPICAL_MAT_SIZES, #ifdef OPENCV_TINY_GPU_MODULE - Values(CV_8U, CV_32F), +PERF_TEST_P(Sz_Depth_Cn_Inter_Border, ImgProc_WarpPerspective, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(CV_8U, CV_32F), + GPU_CHANNELS_1_3_4, + Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR)), + ALL_BORDER_MODES) +) #else - Values(CV_8U, CV_16U, CV_32F), +PERF_TEST_P(Sz_Depth_Cn_Inter_Border, ImgProc_WarpPerspective, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(CV_8U, CV_16U, CV_32F), + GPU_CHANNELS_1_3_4, + Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)), + ALL_BORDER_MODES) +) #endif - GPU_CHANNELS_1_3_4, -#ifdef OPENCV_TINY_GPU_MODULE - Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR)), -#else - Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)), -#endif - ALL_BORDER_MODES)) { declare.time(20.0); @@ -366,15 +385,21 @@ PERF_TEST_P(Sz_Depth_Cn_Inter_Border, ImgProc_WarpPerspective, DEF_PARAM_TEST(Sz_Depth_Cn_Border, cv::Size, MatDepth, MatCn, BorderMode); -PERF_TEST_P(Sz_Depth_Cn_Border, ImgProc_CopyMakeBorder, - Combine(GPU_TYPICAL_MAT_SIZES, #ifdef OPENCV_TINY_GPU_MODULE - Values(CV_8U, CV_32F), +PERF_TEST_P(Sz_Depth_Cn_Border, ImgProc_CopyMakeBorder, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(CV_8U, CV_32F), + GPU_CHANNELS_1_3_4, + ALL_BORDER_MODES) +) #else - Values(CV_8U, CV_16U, CV_32F), +PERF_TEST_P(Sz_Depth_Cn_Border, ImgProc_CopyMakeBorder, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(CV_8U, CV_16U, CV_32F), + GPU_CHANNELS_1_3_4, + ALL_BORDER_MODES) +) #endif - GPU_CHANNELS_1_3_4, - ALL_BORDER_MODES)) { const cv::Size size = GET_PARAM(0); const int depth = GET_PARAM(1); @@ -412,14 +437,19 @@ CV_ENUM(ThreshOp, THRESH_BINARY, THRESH_BINARY_INV, THRESH_TRUNC, THRESH_TOZERO, DEF_PARAM_TEST(Sz_Depth_Op, cv::Size, MatDepth, ThreshOp); -PERF_TEST_P(Sz_Depth_Op, ImgProc_Threshold, - Combine(GPU_TYPICAL_MAT_SIZES, #ifdef OPENCV_TINY_GPU_MODULE - Values(CV_8U, CV_32F), +PERF_TEST_P(Sz_Depth_Op, ImgProc_Threshold, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(CV_8U, CV_32F), + ThreshOp::all() +)) #else - Values(CV_8U, CV_16U, CV_32F, CV_64F), +PERF_TEST_P(Sz_Depth_Op, ImgProc_Threshold, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(CV_8U, CV_16U, CV_32F, CV_64F), + ThreshOp::all() +)) #endif - ThreshOp::all())) { const cv::Size size = GET_PARAM(0); const int depth = GET_PARAM(1); @@ -716,14 +746,19 @@ PERF_TEST_P(Sz, ImgProc_ColumnSum, DEF_PARAM_TEST(Image_AppertureSz_L2gradient, string, int, bool); -PERF_TEST_P(Image_AppertureSz_L2gradient, ImgProc_Canny, - Combine(Values("perf/800x600.png", "perf/1280x1024.png", "perf/1680x1050.png"), #ifdef OPENCV_TINY_GPU_MODULE - Values(3), +PERF_TEST_P(Image_AppertureSz_L2gradient, ImgProc_Canny, Combine( + Values("perf/800x600.png", "perf/1280x1024.png", "perf/1680x1050.png"), + Values(3), + Bool() +)) #else - Values(3, 5), +PERF_TEST_P(Image_AppertureSz_L2gradient, ImgProc_Canny, Combine( + Values("perf/800x600.png", "perf/1280x1024.png", "perf/1680x1050.png"), + Values(3, 5), + Bool() +)) #endif - Bool())) { const string fileName = GET_PARAM(0); const int apperture_size = GET_PARAM(1); @@ -1348,14 +1383,19 @@ PERF_TEST_P(Sz_Depth_Cn_Inter, ImgProc_Rotate, ////////////////////////////////////////////////////////////////////// // PyrDown -PERF_TEST_P(Sz_Depth_Cn, ImgProc_PyrDown, - Combine(GPU_TYPICAL_MAT_SIZES, #ifdef OPENCV_TINY_GPU_MODULE - Values(CV_8U, CV_32F), +PERF_TEST_P(Sz_Depth_Cn, ImgProc_PyrDown, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(CV_8U, CV_32F), + GPU_CHANNELS_1_3_4) +) #else - Values(CV_8U, CV_16U, CV_32F), +PERF_TEST_P(Sz_Depth_Cn, ImgProc_PyrDown, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(CV_8U, CV_16U, CV_32F), + GPU_CHANNELS_1_3_4) +) #endif - GPU_CHANNELS_1_3_4)) { const cv::Size size = GET_PARAM(0); const int depth = GET_PARAM(1); @@ -1388,14 +1428,19 @@ PERF_TEST_P(Sz_Depth_Cn, ImgProc_PyrDown, ////////////////////////////////////////////////////////////////////// // PyrUp -PERF_TEST_P(Sz_Depth_Cn, ImgProc_PyrUp, - Combine(GPU_TYPICAL_MAT_SIZES, #ifdef OPENCV_TINY_GPU_MODULE - Values(CV_8U, CV_32F), +PERF_TEST_P(Sz_Depth_Cn, ImgProc_PyrUp, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(CV_8U, CV_32F), + GPU_CHANNELS_1_3_4) +) #else - Values(CV_8U, CV_16U, CV_32F), +PERF_TEST_P(Sz_Depth_Cn, ImgProc_PyrUp, Combine( + GPU_TYPICAL_MAT_SIZES, + Values(CV_8U, CV_16U, CV_32F), + GPU_CHANNELS_1_3_4) +) #endif - GPU_CHANNELS_1_3_4)) { const cv::Size size = GET_PARAM(0); const int depth = GET_PARAM(1); diff --git a/modules/gpu/test/test_color.cpp b/modules/gpu/test/test_color.cpp index 49a3274c99..6d4c8c5423 100644 --- a/modules/gpu/test/test_color.cpp +++ b/modules/gpu/test/test_color.cpp @@ -2285,15 +2285,19 @@ GPU_TEST_P(CvtColor, BayerGR2Gray) EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 2); } +#ifdef OPENCV_TINY_GPU_MODULE INSTANTIATE_TEST_CASE_P(GPU_ImgProc, CvtColor, testing::Combine( ALL_DEVICES, DIFFERENT_SIZES, -#ifdef OPENCV_TINY_GPU_MODULE testing::Values(MatDepth(CV_8U), MatDepth(CV_32F)), -#else - testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_32F)), -#endif WHOLE_SUBMAT)); +#else +INSTANTIATE_TEST_CASE_P(GPU_ImgProc, CvtColor, testing::Combine( + ALL_DEVICES, + DIFFERENT_SIZES, + testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_32F)), + WHOLE_SUBMAT)); +#endif /////////////////////////////////////////////////////////////////////////////////////////////////////// // Demosaicing diff --git a/modules/gpu/test/test_copy_make_border.cpp b/modules/gpu/test/test_copy_make_border.cpp index 8159ba72a9..b06f795411 100644 --- a/modules/gpu/test/test_copy_make_border.cpp +++ b/modules/gpu/test/test_copy_make_border.cpp @@ -87,17 +87,23 @@ GPU_TEST_P(CopyMakeBorder, Accuracy) EXPECT_MAT_NEAR(dst_gold, dst, 0.0); } +#ifdef OPENCV_TINY_GPU_MODULE INSTANTIATE_TEST_CASE_P(GPU_ImgProc, CopyMakeBorder, testing::Combine( ALL_DEVICES, DIFFERENT_SIZES, -#ifdef OPENCV_TINY_GPU_MODULE testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)), + testing::Values(Border(1), Border(10), Border(50)), + ALL_BORDER_TYPES, + WHOLE_SUBMAT)); #else +INSTANTIATE_TEST_CASE_P(GPU_ImgProc, CopyMakeBorder, testing::Combine( + ALL_DEVICES, + DIFFERENT_SIZES, testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), @@ -107,9 +113,9 @@ INSTANTIATE_TEST_CASE_P(GPU_ImgProc, CopyMakeBorder, testing::Combine( MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)), -#endif testing::Values(Border(1), Border(10), Border(50)), ALL_BORDER_TYPES, WHOLE_SUBMAT)); +#endif #endif // HAVE_CUDA diff --git a/modules/gpu/test/test_core.cpp b/modules/gpu/test/test_core.cpp index 6ad36c094c..dae80c72df 100644 --- a/modules/gpu/test/test_core.cpp +++ b/modules/gpu/test/test_core.cpp @@ -1341,15 +1341,19 @@ GPU_TEST_P(Abs, Accuracy) EXPECT_MAT_NEAR(dst_gold, dst, 0.0); } +#ifdef OPENCV_TINY_GPU_MODULE INSTANTIATE_TEST_CASE_P(GPU_Core, Abs, testing::Combine( ALL_DEVICES, DIFFERENT_SIZES, -#ifdef OPENCV_TINY_GPU_MODULE testing::Values(MatDepth(CV_32F)), -#else - testing::Values(MatDepth(CV_16S), MatDepth(CV_32F)), -#endif WHOLE_SUBMAT)); +#else +INSTANTIATE_TEST_CASE_P(GPU_Core, Abs, testing::Combine( + ALL_DEVICES, + DIFFERENT_SIZES, + testing::Values(MatDepth(CV_16S), MatDepth(CV_32F)), + WHOLE_SUBMAT)); +#endif //////////////////////////////////////////////////////////////////////////////// // Sqr @@ -1385,18 +1389,22 @@ GPU_TEST_P(Sqr, Accuracy) EXPECT_MAT_NEAR(dst_gold, dst, 0.0); } +#ifdef OPENCV_TINY_GPU_MODULE INSTANTIATE_TEST_CASE_P(GPU_Core, Sqr, testing::Combine( ALL_DEVICES, DIFFERENT_SIZES, -#ifdef OPENCV_TINY_GPU_MODULE testing::Values(MatDepth(CV_32F)), + WHOLE_SUBMAT)); #else +INSTANTIATE_TEST_CASE_P(GPU_Core, Sqr, testing::Combine( + ALL_DEVICES, + DIFFERENT_SIZES, testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_16S), MatDepth(CV_32F)), -#endif WHOLE_SUBMAT)); +#endif //////////////////////////////////////////////////////////////////////////////// // Sqrt @@ -1459,18 +1467,22 @@ GPU_TEST_P(Sqrt, Accuracy) EXPECT_MAT_NEAR(dst_gold, dst, depth < CV_32F ? 1.0 : 1e-5); } +#ifdef OPENCV_TINY_GPU_MODULE INSTANTIATE_TEST_CASE_P(GPU_Core, Sqrt, testing::Combine( ALL_DEVICES, DIFFERENT_SIZES, -#ifdef OPENCV_TINY_GPU_MODULE testing::Values(MatDepth(CV_32F)), + WHOLE_SUBMAT)); #else +INSTANTIATE_TEST_CASE_P(GPU_Core, Sqrt, testing::Combine( + ALL_DEVICES, + DIFFERENT_SIZES, testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_16S), MatDepth(CV_32F)), -#endif WHOLE_SUBMAT)); +#endif //////////////////////////////////////////////////////////////////////////////// // Log @@ -1533,18 +1545,22 @@ GPU_TEST_P(Log, Accuracy) EXPECT_MAT_NEAR(dst_gold, dst, depth < CV_32F ? 1.0 : 1e-6); } +#ifdef OPENCV_TINY_GPU_MODULE INSTANTIATE_TEST_CASE_P(GPU_Core, Log, testing::Combine( ALL_DEVICES, DIFFERENT_SIZES, -#ifdef OPENCV_TINY_GPU_MODULE testing::Values(MatDepth(CV_32F)), + WHOLE_SUBMAT)); #else +INSTANTIATE_TEST_CASE_P(GPU_Core, Log, testing::Combine( + ALL_DEVICES, + DIFFERENT_SIZES, testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_16S), MatDepth(CV_32F)), -#endif WHOLE_SUBMAT)); +#endif //////////////////////////////////////////////////////////////////////////////// // Exp @@ -1617,18 +1633,22 @@ GPU_TEST_P(Exp, Accuracy) EXPECT_MAT_NEAR(dst_gold, dst, depth < CV_32F ? 1.0 : 1e-2); } +#ifdef OPENCV_TINY_GPU_MODULE INSTANTIATE_TEST_CASE_P(GPU_Core, Exp, testing::Combine( ALL_DEVICES, DIFFERENT_SIZES, -#ifdef OPENCV_TINY_GPU_MODULE testing::Values(MatDepth(CV_32F)), + WHOLE_SUBMAT)); #else +INSTANTIATE_TEST_CASE_P(GPU_Core, Exp, testing::Combine( + ALL_DEVICES, + DIFFERENT_SIZES, testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_16S), MatDepth(CV_32F)), -#endif WHOLE_SUBMAT)); +#endif //////////////////////////////////////////////////////////////////////////////// // Compare_Array @@ -1795,16 +1815,21 @@ GPU_TEST_P(Compare_Scalar, Accuracy) } } +#ifdef OPENCV_TINY_GPU_MODULE INSTANTIATE_TEST_CASE_P(GPU_Core, Compare_Scalar, testing::Combine( ALL_DEVICES, DIFFERENT_SIZES, -#ifdef OPENCV_TINY_GPU_MODULE testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)), -#else - TYPES(CV_8U, CV_64F, 1, 4), -#endif CmpCode::all(), WHOLE_SUBMAT)); +#else +INSTANTIATE_TEST_CASE_P(GPU_Core, Compare_Scalar, testing::Combine( + ALL_DEVICES, + DIFFERENT_SIZES, + TYPES(CV_8U, CV_64F, 1, 4), + CmpCode::all(), + WHOLE_SUBMAT)); +#endif ////////////////////////////////////////////////////////////////////////////// // Bitwise_Array @@ -1960,17 +1985,19 @@ GPU_TEST_P(Bitwise_Scalar, Xor) EXPECT_MAT_NEAR(dst_gold, dst, 0.0); } +#ifdef OPENCV_TINY_GPU_MODULE INSTANTIATE_TEST_CASE_P(GPU_Core, Bitwise_Scalar, testing::Combine( ALL_DEVICES, DIFFERENT_SIZES, -#ifdef OPENCV_TINY_GPU_MODULE testing::Values(MatDepth(CV_8U)), - testing::Values(Channels(1)) + testing::Values(Channels(1)))); #else +INSTANTIATE_TEST_CASE_P(GPU_Core, Bitwise_Scalar, testing::Combine( + ALL_DEVICES, + DIFFERENT_SIZES, testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_32S)), - IMAGE_CHANNELS + IMAGE_CHANNELS)); #endif -)); ////////////////////////////////////////////////////////////////////////////// // RShift @@ -2347,15 +2374,19 @@ GPU_TEST_P(Pow, Accuracy) } } +#ifdef OPENCV_TINY_GPU_MODULE INSTANTIATE_TEST_CASE_P(GPU_Core, Pow, testing::Combine( ALL_DEVICES, DIFFERENT_SIZES, -#ifdef OPENCV_TINY_GPU_MODULE testing::Values(MatDepth(CV_32F)), -#else - ALL_DEPTH, -#endif WHOLE_SUBMAT)); +#else +INSTANTIATE_TEST_CASE_P(GPU_Core, Pow, testing::Combine( + ALL_DEVICES, + DIFFERENT_SIZES, + ALL_DEPTH, + WHOLE_SUBMAT)); +#endif ////////////////////////////////////////////////////////////////////////////// // AddWeighted @@ -3005,22 +3036,27 @@ GPU_TEST_P(Norm, Accuracy) EXPECT_NEAR(val_gold, val, depth < CV_32F ? 0.0 : 1.0); } +#ifdef OPENCV_TINY_GPU_MODULE INSTANTIATE_TEST_CASE_P(GPU_Core, Norm, testing::Combine( ALL_DEVICES, DIFFERENT_SIZES, -#ifdef OPENCV_TINY_GPU_MODULE testing::Values(MatDepth(CV_8U), MatDepth(CV_32F)), + testing::Values(NormCode(cv::NORM_L1), NormCode(cv::NORM_L2), NormCode(cv::NORM_INF)), + WHOLE_SUBMAT)); #else +INSTANTIATE_TEST_CASE_P(GPU_Core, Norm, testing::Combine( + ALL_DEVICES, + DIFFERENT_SIZES, testing::Values(MatDepth(CV_8U), MatDepth(CV_8S), MatDepth(CV_16U), MatDepth(CV_16S), MatDepth(CV_32S), MatDepth(CV_32F)), -#endif testing::Values(NormCode(cv::NORM_L1), NormCode(cv::NORM_L2), NormCode(cv::NORM_INF)), WHOLE_SUBMAT)); +#endif //////////////////////////////////////////////////////////////////////////////// // normDiff @@ -3193,15 +3229,19 @@ GPU_TEST_P(Sum, Sqr) EXPECT_SCALAR_NEAR(val_gold, val, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.5); } +#ifdef OPENCV_TINY_GPU_MODULE INSTANTIATE_TEST_CASE_P(GPU_Core, Sum, testing::Combine( ALL_DEVICES, DIFFERENT_SIZES, -#ifdef OPENCV_TINY_GPU_MODULE testing::Values(MatType(CV_8UC1), MatType(CV_32FC1)), -#else - TYPES(CV_8U, CV_64F, 1, 4), -#endif WHOLE_SUBMAT)); +#else +INSTANTIATE_TEST_CASE_P(GPU_Core, Sum, testing::Combine( + ALL_DEVICES, + DIFFERENT_SIZES, + TYPES(CV_8U, CV_64F, 1, 4), + WHOLE_SUBMAT)); +#endif //////////////////////////////////////////////////////////////////////////////// // MinMax @@ -3622,22 +3662,28 @@ GPU_TEST_P(Reduce, Cols) EXPECT_MAT_NEAR(dst_gold, dst, dst_depth < CV_32F ? 0.0 : 0.02); } +#ifdef OPENCV_TINY_GPU_MODULE INSTANTIATE_TEST_CASE_P(GPU_Core, Reduce, testing::Combine( ALL_DEVICES, DIFFERENT_SIZES, -#ifdef OPENCV_TINY_GPU_MODULE testing::Values(MatDepth(CV_8U), MatDepth(CV_32F)), + ALL_CHANNELS, + ALL_REDUCE_CODES, + WHOLE_SUBMAT)); #else +INSTANTIATE_TEST_CASE_P(GPU_Core, Reduce, testing::Combine( + ALL_DEVICES, + DIFFERENT_SIZES, testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_16S), MatDepth(CV_32F), MatDepth(CV_64F)), -#endif ALL_CHANNELS, ALL_REDUCE_CODES, WHOLE_SUBMAT)); +#endif ////////////////////////////////////////////////////////////////////////////// // Normalize diff --git a/modules/gpu/test/test_features2d.cpp b/modules/gpu/test/test_features2d.cpp index 41f71d9bdf..99d9b2e8f6 100644 --- a/modules/gpu/test/test_features2d.cpp +++ b/modules/gpu/test/test_features2d.cpp @@ -700,14 +700,18 @@ GPU_TEST_P(BruteForceMatcher, RadiusMatch_Collection) } #endif +#ifdef OPENCV_TINY_GPU_MODULE INSTANTIATE_TEST_CASE_P(GPU_Features2D, BruteForceMatcher, testing::Combine( ALL_DEVICES, -#ifdef OPENCV_TINY_GPU_MODULE testing::Values(NormCode(cv::NORM_L2)), -#else - testing::Values(NormCode(cv::NORM_L1), NormCode(cv::NORM_L2)), -#endif testing::Values(DescriptorSize(57), DescriptorSize(64), DescriptorSize(83), DescriptorSize(128), DescriptorSize(179), DescriptorSize(256), DescriptorSize(304)), testing::Values(UseMask(false), UseMask(true)))); +#else +INSTANTIATE_TEST_CASE_P(GPU_Features2D, BruteForceMatcher, testing::Combine( + ALL_DEVICES, + testing::Values(NormCode(cv::NORM_L1), NormCode(cv::NORM_L2)), + testing::Values(DescriptorSize(57), DescriptorSize(64), DescriptorSize(83), DescriptorSize(128), DescriptorSize(179), DescriptorSize(256), DescriptorSize(304)), + testing::Values(UseMask(false), UseMask(true)))); +#endif #endif // HAVE_CUDA diff --git a/modules/gpu/test/test_filters.cpp b/modules/gpu/test/test_filters.cpp index 12aa91b602..cac3c70d79 100644 --- a/modules/gpu/test/test_filters.cpp +++ b/modules/gpu/test/test_filters.cpp @@ -164,14 +164,11 @@ GPU_TEST_P(Sobel, Accuracy) EXPECT_MAT_NEAR(getInnerROI(dst_gold, ksize), getInnerROI(dst, ksize), CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.1); } +#ifdef OPENCV_TINY_GPU_MODULE INSTANTIATE_TEST_CASE_P(GPU_Filter, Sobel, testing::Combine( ALL_DEVICES, DIFFERENT_SIZES, -#ifdef OPENCV_TINY_GPU_MODULE testing::Values(MatDepth(CV_8U), MatDepth(CV_32F)), -#else - testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_16S), MatDepth(CV_32F)), -#endif IMAGE_CHANNELS, testing::Values(KSize(cv::Size(3, 3)), KSize(cv::Size(5, 5)), KSize(cv::Size(7, 7))), testing::Values(Deriv_X(0), Deriv_X(1), Deriv_X(2)), @@ -181,6 +178,21 @@ INSTANTIATE_TEST_CASE_P(GPU_Filter, Sobel, testing::Combine( BorderType(cv::BORDER_CONSTANT), BorderType(cv::BORDER_REFLECT)), WHOLE_SUBMAT)); +#else +INSTANTIATE_TEST_CASE_P(GPU_Filter, Sobel, testing::Combine( + ALL_DEVICES, + DIFFERENT_SIZES, + testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_16S), MatDepth(CV_32F)), + IMAGE_CHANNELS, + testing::Values(KSize(cv::Size(3, 3)), KSize(cv::Size(5, 5)), KSize(cv::Size(7, 7))), + testing::Values(Deriv_X(0), Deriv_X(1), Deriv_X(2)), + testing::Values(Deriv_Y(0), Deriv_Y(1), Deriv_Y(2)), + testing::Values(BorderType(cv::BORDER_REFLECT101), + BorderType(cv::BORDER_REPLICATE), + BorderType(cv::BORDER_CONSTANT), + BorderType(cv::BORDER_REFLECT)), + WHOLE_SUBMAT)); +#endif ///////////////////////////////////////////////////////////////////////////////////////////////// // Scharr @@ -231,14 +243,11 @@ GPU_TEST_P(Scharr, Accuracy) EXPECT_MAT_NEAR(getInnerROI(dst_gold, cv::Size(3, 3)), getInnerROI(dst, cv::Size(3, 3)), CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.1); } +#ifdef OPENCV_TINY_GPU_MODULE INSTANTIATE_TEST_CASE_P(GPU_Filter, Scharr, testing::Combine( ALL_DEVICES, DIFFERENT_SIZES, -#ifdef OPENCV_TINY_GPU_MODULE testing::Values(MatDepth(CV_8U), MatDepth(CV_32F)), -#else - testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_16S), MatDepth(CV_32F)), -#endif IMAGE_CHANNELS, testing::Values(Deriv_X(0), Deriv_X(1)), testing::Values(Deriv_Y(0), Deriv_Y(1)), @@ -247,6 +256,20 @@ INSTANTIATE_TEST_CASE_P(GPU_Filter, Scharr, testing::Combine( BorderType(cv::BORDER_CONSTANT), BorderType(cv::BORDER_REFLECT)), WHOLE_SUBMAT)); +#else +INSTANTIATE_TEST_CASE_P(GPU_Filter, Scharr, testing::Combine( + ALL_DEVICES, + DIFFERENT_SIZES, + testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_16S), MatDepth(CV_32F)), + IMAGE_CHANNELS, + testing::Values(Deriv_X(0), Deriv_X(1)), + testing::Values(Deriv_Y(0), Deriv_Y(1)), + testing::Values(BorderType(cv::BORDER_REFLECT101), + BorderType(cv::BORDER_REPLICATE), + BorderType(cv::BORDER_CONSTANT), + BorderType(cv::BORDER_REFLECT)), + WHOLE_SUBMAT)); +#endif ///////////////////////////////////////////////////////////////////////////////////////////////// // GaussianBlur @@ -309,20 +332,26 @@ GPU_TEST_P(GaussianBlur, Accuracy) } } +#ifdef OPENCV_TINY_GPU_MODULE INSTANTIATE_TEST_CASE_P(GPU_Filter, GaussianBlur, testing::Combine( ALL_DEVICES, DIFFERENT_SIZES, -#ifdef OPENCV_TINY_GPU_MODULE testing::Values(MatDepth(CV_8U), MatDepth(CV_32F)), -#else - testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_16S), MatDepth(CV_32F)), -#endif IMAGE_CHANNELS, -#ifdef OPENCV_TINY_GPU_MODULE testing::Values(KSize(cv::Size(3, 3)), KSize(cv::Size(5, 5)), KSize(cv::Size(7, 7))), + testing::Values(BorderType(cv::BORDER_REFLECT101), + BorderType(cv::BORDER_REPLICATE), + BorderType(cv::BORDER_CONSTANT), + BorderType(cv::BORDER_REFLECT)), + WHOLE_SUBMAT)); #else +INSTANTIATE_TEST_CASE_P(GPU_Filter, GaussianBlur, testing::Combine( + ALL_DEVICES, + DIFFERENT_SIZES, + testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_16S), MatDepth(CV_32F)), + IMAGE_CHANNELS, testing::Values(KSize(cv::Size(3, 3)), KSize(cv::Size(5, 5)), KSize(cv::Size(7, 7)), @@ -338,12 +367,12 @@ INSTANTIATE_TEST_CASE_P(GPU_Filter, GaussianBlur, testing::Combine( KSize(cv::Size(27, 27)), KSize(cv::Size(29, 29)), KSize(cv::Size(31, 31))), -#endif testing::Values(BorderType(cv::BORDER_REFLECT101), BorderType(cv::BORDER_REPLICATE), BorderType(cv::BORDER_CONSTANT), BorderType(cv::BORDER_REFLECT)), WHOLE_SUBMAT)); +#endif ///////////////////////////////////////////////////////////////////////////////////////////////// // Laplacian @@ -583,17 +612,24 @@ GPU_TEST_P(Filter2D, Accuracy) EXPECT_MAT_NEAR(dst_gold, dst, CV_MAT_DEPTH(type) == CV_32F ? 1e-1 : 1.0); } +#ifdef OPENCV_TINY_GPU_MODULE INSTANTIATE_TEST_CASE_P(GPU_Filter, Filter2D, testing::Combine( ALL_DEVICES, DIFFERENT_SIZES, -#ifdef OPENCV_TINY_GPU_MODULE testing::Values(MatType(CV_8UC1), MatType(CV_8UC4), MatType(CV_32FC1), MatType(CV_32FC4)), -#else - testing::Values(MatType(CV_8UC1), MatType(CV_8UC4), MatType(CV_16UC1), MatType(CV_16UC4), MatType(CV_32FC1), MatType(CV_32FC4)), -#endif testing::Values(KSize(cv::Size(3, 3)), KSize(cv::Size(5, 5)), KSize(cv::Size(7, 7)), KSize(cv::Size(11, 11)), KSize(cv::Size(13, 13)), KSize(cv::Size(15, 15))), testing::Values(Anchor(cv::Point(-1, -1)), Anchor(cv::Point(0, 0)), Anchor(cv::Point(2, 2))), testing::Values(BorderType(cv::BORDER_REFLECT101), BorderType(cv::BORDER_REPLICATE), BorderType(cv::BORDER_CONSTANT), BorderType(cv::BORDER_REFLECT)), WHOLE_SUBMAT)); +#else +INSTANTIATE_TEST_CASE_P(GPU_Filter, Filter2D, testing::Combine( + ALL_DEVICES, + DIFFERENT_SIZES, + testing::Values(MatType(CV_8UC1), MatType(CV_8UC4), MatType(CV_16UC1), MatType(CV_16UC4), MatType(CV_32FC1), MatType(CV_32FC4)), + testing::Values(KSize(cv::Size(3, 3)), KSize(cv::Size(5, 5)), KSize(cv::Size(7, 7)), KSize(cv::Size(11, 11)), KSize(cv::Size(13, 13)), KSize(cv::Size(15, 15))), + testing::Values(Anchor(cv::Point(-1, -1)), Anchor(cv::Point(0, 0)), Anchor(cv::Point(2, 2))), + testing::Values(BorderType(cv::BORDER_REFLECT101), BorderType(cv::BORDER_REPLICATE), BorderType(cv::BORDER_CONSTANT), BorderType(cv::BORDER_REFLECT)), + WHOLE_SUBMAT)); +#endif #endif // HAVE_CUDA diff --git a/modules/gpu/test/test_imgproc.cpp b/modules/gpu/test/test_imgproc.cpp index d834048cfe..c6c0bf1868 100644 --- a/modules/gpu/test/test_imgproc.cpp +++ b/modules/gpu/test/test_imgproc.cpp @@ -357,15 +357,19 @@ GPU_TEST_P(Canny, Accuracy) } } +#ifdef OPENCV_TINY_GPU_MODULE INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Canny, testing::Combine( ALL_DEVICES, -#ifdef OPENCV_TINY_GPU_MODULE testing::Values(AppertureSize(3)), -#else - testing::Values(AppertureSize(3), AppertureSize(5)), -#endif testing::Values(L2gradient(false), L2gradient(true)), WHOLE_SUBMAT)); +#else +INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Canny, testing::Combine( + ALL_DEVICES, + testing::Values(AppertureSize(3), AppertureSize(5)), + testing::Values(L2gradient(false), L2gradient(true)), + WHOLE_SUBMAT)); +#endif //////////////////////////////////////////////////////////////////////////////// // MeanShift diff --git a/modules/gpu/test/test_pyramids.cpp b/modules/gpu/test/test_pyramids.cpp index 64bcacc48e..5ddecf49ac 100644 --- a/modules/gpu/test/test_pyramids.cpp +++ b/modules/gpu/test/test_pyramids.cpp @@ -80,15 +80,19 @@ GPU_TEST_P(PyrDown, Accuracy) EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-4 : 1.0); } +#ifdef OPENCV_TINY_GPU_MODULE INSTANTIATE_TEST_CASE_P(GPU_ImgProc, PyrDown, testing::Combine( ALL_DEVICES, DIFFERENT_SIZES, -#ifdef OPENCV_TINY_GPU_MODULE testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)), -#else - testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)), -#endif WHOLE_SUBMAT)); +#else +INSTANTIATE_TEST_CASE_P(GPU_ImgProc, PyrDown, testing::Combine( + ALL_DEVICES, + DIFFERENT_SIZES, + testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)), + WHOLE_SUBMAT)); +#endif //////////////////////////////////////////////////////// // pyrUp @@ -124,14 +128,18 @@ GPU_TEST_P(PyrUp, Accuracy) EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-4 : 1.0); } +#ifdef OPENCV_TINY_GPU_MODULE INSTANTIATE_TEST_CASE_P(GPU_ImgProc, PyrUp, testing::Combine( ALL_DEVICES, DIFFERENT_SIZES, -#ifdef OPENCV_TINY_GPU_MODULE testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)), -#else - testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)), -#endif WHOLE_SUBMAT)); +#else +INSTANTIATE_TEST_CASE_P(GPU_ImgProc, PyrUp, testing::Combine( + ALL_DEVICES, + DIFFERENT_SIZES, + testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)), + WHOLE_SUBMAT)); +#endif #endif // HAVE_CUDA diff --git a/modules/gpu/test/test_remap.cpp b/modules/gpu/test/test_remap.cpp index 58635e4f3b..cd0520070b 100644 --- a/modules/gpu/test/test_remap.cpp +++ b/modules/gpu/test/test_remap.cpp @@ -169,17 +169,22 @@ GPU_TEST_P(Remap, Accuracy) EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-3 : 1.0); } +#ifdef OPENCV_TINY_GPU_MODULE INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Remap, testing::Combine( ALL_DEVICES, DIFFERENT_SIZES, testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)), -#ifdef OPENCV_TINY_GPU_MODULE testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR)), testing::Values(BorderType(cv::BORDER_REFLECT101), BorderType(cv::BORDER_REPLICATE), BorderType(cv::BORDER_CONSTANT), BorderType(cv::BORDER_REFLECT)), + WHOLE_SUBMAT)); #else +INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Remap, testing::Combine( + ALL_DEVICES, + DIFFERENT_SIZES, + testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)), testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)), testing::Values(BorderType(cv::BORDER_REFLECT101), BorderType(cv::BORDER_REPLICATE), BorderType(cv::BORDER_CONSTANT), BorderType(cv::BORDER_REFLECT), BorderType(cv::BORDER_WRAP)), -#endif WHOLE_SUBMAT)); +#endif #endif // HAVE_CUDA diff --git a/modules/gpu/test/test_resize.cpp b/modules/gpu/test/test_resize.cpp index 4adfd8d3ef..99cbfec3b4 100644 --- a/modules/gpu/test/test_resize.cpp +++ b/modules/gpu/test/test_resize.cpp @@ -174,21 +174,23 @@ GPU_TEST_P(Resize, Accuracy) EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-2 : 1.0); } +#ifdef OPENCV_TINY_GPU_MODULE INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Resize, testing::Combine( ALL_DEVICES, DIFFERENT_SIZES, -#ifdef OPENCV_TINY_GPU_MODULE testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)), -#else - testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)), -#endif testing::Values(0.3, 0.5, 1.5, 2.0), -#ifdef OPENCV_TINY_GPU_MODULE testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR)), -#else - testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)), -#endif WHOLE_SUBMAT)); +#else +INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Resize, testing::Combine( + ALL_DEVICES, + DIFFERENT_SIZES, + testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)), + testing::Values(0.3, 0.5, 1.5, 2.0), + testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)), + WHOLE_SUBMAT)); +#endif ///////////////// @@ -229,28 +231,40 @@ GPU_TEST_P(ResizeSameAsHost, Accuracy) EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-2 : src.depth() == CV_8U ? 4.0 : 1.0); } +#ifdef OPENCV_TINY_GPU_MODULE INSTANTIATE_TEST_CASE_P(GPU_ImgProc, ResizeSameAsHost, testing::Combine( ALL_DEVICES, DIFFERENT_SIZES, -#ifdef OPENCV_TINY_GPU_MODULE testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)), -#else - testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)), -#endif testing::Values(0.3, 0.5), testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_AREA)), WHOLE_SUBMAT)); +#else +INSTANTIATE_TEST_CASE_P(GPU_ImgProc, ResizeSameAsHost, testing::Combine( + ALL_DEVICES, + DIFFERENT_SIZES, + testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)), + testing::Values(0.3, 0.5), + testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_AREA)), + WHOLE_SUBMAT)); +#endif +#ifdef OPENCV_TINY_GPU_MODULE INSTANTIATE_TEST_CASE_P(GPU_ImgProc2, ResizeSameAsHost, testing::Combine( ALL_DEVICES, DIFFERENT_SIZES, -#ifdef OPENCV_TINY_GPU_MODULE testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)), -#else - testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)), -#endif testing::Values(0.3, 0.5, 1.5, 2.0), testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR)), WHOLE_SUBMAT)); +#else +INSTANTIATE_TEST_CASE_P(GPU_ImgProc2, ResizeSameAsHost, testing::Combine( + ALL_DEVICES, + DIFFERENT_SIZES, + testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)), + testing::Values(0.3, 0.5, 1.5, 2.0), + testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR)), + WHOLE_SUBMAT)); +#endif #endif // HAVE_CUDA diff --git a/modules/gpu/test/test_threshold.cpp b/modules/gpu/test/test_threshold.cpp index 3a410f7921..cd06c17dd9 100644 --- a/modules/gpu/test/test_threshold.cpp +++ b/modules/gpu/test/test_threshold.cpp @@ -83,15 +83,20 @@ GPU_TEST_P(Threshold, Accuracy) EXPECT_MAT_NEAR(dst_gold, dst, 0.0); } +#ifdef OPENCV_TINY_GPU_MODULE INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Threshold, testing::Combine( ALL_DEVICES, DIFFERENT_SIZES, -#ifdef OPENCV_TINY_GPU_MODULE testing::Values(MatType(CV_8UC1), MatType(CV_32FC1)), -#else - testing::Values(MatType(CV_8UC1), MatType(CV_16SC1), MatType(CV_32FC1)), -#endif ThreshOp::all(), WHOLE_SUBMAT)); +#else +INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Threshold, testing::Combine( + ALL_DEVICES, + DIFFERENT_SIZES, + testing::Values(MatType(CV_8UC1), MatType(CV_16SC1), MatType(CV_32FC1)), + ThreshOp::all(), + WHOLE_SUBMAT)); +#endif #endif // HAVE_CUDA diff --git a/modules/gpu/test/test_warp_affine.cpp b/modules/gpu/test/test_warp_affine.cpp index fdcacb0c58..a20bbbeb4d 100644 --- a/modules/gpu/test/test_warp_affine.cpp +++ b/modules/gpu/test/test_warp_affine.cpp @@ -222,23 +222,25 @@ GPU_TEST_P(WarpAffine, Accuracy) EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-1 : 1.0); } +#ifdef OPENCV_TINY_GPU_MODULE INSTANTIATE_TEST_CASE_P(GPU_ImgProc, WarpAffine, testing::Combine( ALL_DEVICES, DIFFERENT_SIZES, -#ifdef OPENCV_TINY_GPU_MODULE testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)), -#else - testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)), -#endif DIRECT_INVERSE, -#ifdef OPENCV_TINY_GPU_MODULE testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR)), testing::Values(BorderType(cv::BORDER_REFLECT101), BorderType(cv::BORDER_REPLICATE), BorderType(cv::BORDER_REFLECT)), + WHOLE_SUBMAT)); #else +INSTANTIATE_TEST_CASE_P(GPU_ImgProc, WarpAffine, testing::Combine( + ALL_DEVICES, + DIFFERENT_SIZES, + testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)), + DIRECT_INVERSE, testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)), testing::Values(BorderType(cv::BORDER_REFLECT101), BorderType(cv::BORDER_REPLICATE), BorderType(cv::BORDER_REFLECT), BorderType(cv::BORDER_WRAP)), -#endif WHOLE_SUBMAT)); +#endif /////////////////////////////////////////////////////////////////// // Test NPP @@ -280,15 +282,18 @@ GPU_TEST_P(WarpAffineNPP, Accuracy) EXPECT_MAT_SIMILAR(dst_gold, dst, 2e-2); } +#ifdef OPENCV_TINY_GPU_MODULE INSTANTIATE_TEST_CASE_P(GPU_ImgProc, WarpAffineNPP, testing::Combine( ALL_DEVICES, testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)), DIRECT_INVERSE, -#ifdef OPENCV_TINY_GPU_MODULE - testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR)) + testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR)))); #else - testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)) +INSTANTIATE_TEST_CASE_P(GPU_ImgProc, WarpAffineNPP, testing::Combine( + ALL_DEVICES, + testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)), + DIRECT_INVERSE, + testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)))); #endif -)); #endif // HAVE_CUDA diff --git a/modules/gpu/test/test_warp_perspective.cpp b/modules/gpu/test/test_warp_perspective.cpp index e707eb4f41..892704dd30 100644 --- a/modules/gpu/test/test_warp_perspective.cpp +++ b/modules/gpu/test/test_warp_perspective.cpp @@ -225,23 +225,25 @@ GPU_TEST_P(WarpPerspective, Accuracy) EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-1 : 1.0); } +#ifdef OPENCV_TINY_GPU_MODULE INSTANTIATE_TEST_CASE_P(GPU_ImgProc, WarpPerspective, testing::Combine( ALL_DEVICES, DIFFERENT_SIZES, -#ifdef OPENCV_TINY_GPU_MODULE testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)), -#else - testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)), -#endif DIRECT_INVERSE, -#ifdef OPENCV_TINY_GPU_MODULE testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR)), testing::Values(BorderType(cv::BORDER_REFLECT101), BorderType(cv::BORDER_REPLICATE), BorderType(cv::BORDER_REFLECT)), + WHOLE_SUBMAT)); #else +INSTANTIATE_TEST_CASE_P(GPU_ImgProc, WarpPerspective, testing::Combine( + ALL_DEVICES, + DIFFERENT_SIZES, + testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)), + DIRECT_INVERSE, testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)), testing::Values(BorderType(cv::BORDER_REFLECT101), BorderType(cv::BORDER_REPLICATE), BorderType(cv::BORDER_REFLECT), BorderType(cv::BORDER_WRAP)), -#endif WHOLE_SUBMAT)); +#endif /////////////////////////////////////////////////////////////////// // Test NPP @@ -283,15 +285,18 @@ GPU_TEST_P(WarpPerspectiveNPP, Accuracy) EXPECT_MAT_SIMILAR(dst_gold, dst, 2e-2); } +#ifdef OPENCV_TINY_GPU_MODULE INSTANTIATE_TEST_CASE_P(GPU_ImgProc, WarpPerspectiveNPP, testing::Combine( ALL_DEVICES, testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)), DIRECT_INVERSE, -#ifdef OPENCV_TINY_GPU_MODULE - testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR)) + testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR)))); #else - testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)) +INSTANTIATE_TEST_CASE_P(GPU_ImgProc, WarpPerspectiveNPP, testing::Combine( + ALL_DEVICES, + testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)), + DIRECT_INVERSE, + testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)))); #endif -)); #endif // HAVE_CUDA