Skip to content

O
opencv
Commit f10537cd authored by Vladislav Vinogradov's avatar Vladislav Vinogradov
Browse files
Options

fix tests compilation issue on Windows

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