Chiebot-Mirror
/
opencv
8
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

fix tests compilation issue on Windows

Browse Source
pull/3785/head
Vladislav Vinogradov 10 years ago
parent 9d294cbcf5
commit f10537cdd6
16 changed files with 594 additions and 308 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 331
      modules/gpu/perf/perf_core.cpp
  2. 42
      modules/gpu/perf/perf_features2d.cpp
  3. 24
      modules/gpu/perf/perf_filters.cpp
  4. 199
      modules/gpu/perf/perf_imgproc.cpp
  5. 8
      modules/gpu/test/test_color.cpp
  6. 10
      modules/gpu/test/test_copy_make_border.cpp
  7. 94
      modules/gpu/test/test_core.cpp
  8. 8
      modules/gpu/test/test_features2d.cpp
  9. 60
      modules/gpu/test/test_filters.cpp
  10. 8
      modules/gpu/test/test_imgproc.cpp
  11. 16
      modules/gpu/test/test_pyramids.cpp
  12. 9
      modules/gpu/test/test_remap.cpp
  13. 34
      modules/gpu/test/test_resize.cpp
  14. 9
      modules/gpu/test/test_threshold.cpp
  15. 25
      modules/gpu/test/test_warp_affine.cpp
  16. 25
      modules/gpu/test/test_warp_perspective.cpp

331
modules/gpu/perf/perf_core.cpp
Unescape View File

@ -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))
PERF_TEST_P(Sz_Depth, Core_Abs, Combine(
GPU_TYPICAL_MAT_SIZES,
Values(MatDepth(CV_32F))
))
#else
Values(CV_16S, CV_32F)
#endif
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))
PERF_TEST_P(Sz_Depth, Core_Sqr, Combine(
GPU_TYPICAL_MAT_SIZES,
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(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))
PERF_TEST_P(Sz_Depth, Core_Sqrt, Combine(
GPU_TYPICAL_MAT_SIZES,
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(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))
PERF_TEST_P(Sz_Depth, Core_Log, Combine(
GPU_TYPICAL_MAT_SIZES,
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(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))
PERF_TEST_P(Sz_Depth, Core_Exp, Combine(
GPU_TYPICAL_MAT_SIZES,
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(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)),
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
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(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))
PERF_TEST_P(Sz_Depth_Cn, Core_BitwiseAndScalar, Combine(
GPU_TYPICAL_MAT_SIZES,
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(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))
PERF_TEST_P(Sz_Depth_Cn, Core_BitwiseOrScalar, Combine(
GPU_TYPICAL_MAT_SIZES,
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(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))
PERF_TEST_P(Sz_Depth_Cn, Core_BitwiseXorScalar, Combine(
GPU_TYPICAL_MAT_SIZES,
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(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)
PERF_TEST_P(Sz_Depth, Core_MinScalar, Combine(
GPU_TYPICAL_MAT_SIZES,
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_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)
PERF_TEST_P(Sz_Depth, Core_MaxScalar, Combine(
GPU_TYPICAL_MAT_SIZES,
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_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))
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
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(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))
PERF_TEST_P(Sz_Depth_Cn, Core_Sum, Combine(
GPU_TYPICAL_MAT_SIZES,
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_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))
PERF_TEST_P(Sz_Depth_Cn, Core_SumAbs, Combine(
GPU_TYPICAL_MAT_SIZES,
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_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))
PERF_TEST_P(Sz_Depth_Cn, Core_SumSqr, Combine(
GPU_TYPICAL_MAT_SIZES,
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_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)
PERF_TEST_P(Sz_Depth, Core_MinMax, Combine(
GPU_TYPICAL_MAT_SIZES,
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_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)
PERF_TEST_P(Sz_Depth, Core_MinMaxLoc, Combine(
GPU_TYPICAL_MAT_SIZES,
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_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)
PERF_TEST_P(Sz_Depth, Core_CountNonZero, Combine(
GPU_TYPICAL_MAT_SIZES,
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_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),
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
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_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),
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
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_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);

42
modules/gpu/perf/perf_features2d.cpp
Unescape View File

@ -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))
PERF_TEST_P(DescSize_Norm, Features2D_BFMatch, Combine(
Values(64, 128, 256),
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_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<cv::DMatch> >& 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))
PERF_TEST_P(DescSize_K_Norm, Features2D_BFKnnMatch, Combine(
Values(64, 128, 256),
Values(2, 3),
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_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))
PERF_TEST_P(DescSize_Norm, Features2D_BFRadiusMatch, Combine(
Values(64, 128, 256),
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_L1), NormType(cv::NORM_L2))
))
#endif
{
declare.time(30.0);

24
modules/gpu/perf/perf_filters.cpp
Unescape View File

@ -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);

199
modules/gpu/perf/perf_imgproc.cpp
Unescape View File

@ -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),
#else
Values(CV_8U, CV_16U, CV_32F),
#endif
GPU_CHANNELS_1_3_4,
#ifdef OPENCV_TINY_GPU_MODULE
Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR)),
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(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)),
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
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),
#else
Values(CV_8U, CV_16U, CV_32F),
#endif
GPU_CHANNELS_1_3_4,
#ifdef OPENCV_TINY_GPU_MODULE
Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR)),
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(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)),
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
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),
#else
Values(CV_8U, CV_16U, CV_32F),
#endif
GPU_CHANNELS_1_3_4,
#ifdef OPENCV_TINY_GPU_MODULE
Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR)),
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(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)),
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
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);

8
modules/gpu/test/test_color.cpp
Unescape View File

@ -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)),
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)),
#endif
WHOLE_SUBMAT));
#endif
///////////////////////////////////////////////////////////////////////////////////////////////////////
// Demosaicing

10
modules/gpu/test/test_copy_make_border.cpp
Unescape View File

@ -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

94
modules/gpu/test/test_core.cpp
Unescape View File

@ -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)),
WHOLE_SUBMAT));
#else
INSTANTIATE_TEST_CASE_P(GPU_Core, Abs, testing::Combine(
ALL_DEVICES,
DIFFERENT_SIZES,
testing::Values(MatDepth(CV_16S), MatDepth(CV_32F)),
#endif
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)),
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),
#endif
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)),
WHOLE_SUBMAT));
#else
INSTANTIATE_TEST_CASE_P(GPU_Core, Pow, testing::Combine(
ALL_DEVICES,
DIFFERENT_SIZES,
ALL_DEPTH,
#endif
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)),
WHOLE_SUBMAT));
#else
INSTANTIATE_TEST_CASE_P(GPU_Core, Sum, testing::Combine(
ALL_DEVICES,
DIFFERENT_SIZES,
TYPES(CV_8U, CV_64F, 1, 4),
#endif
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

8
modules/gpu/test/test_features2d.cpp
Unescape View File

@ -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)),
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)),
#endif
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

60
modules/gpu/test/test_filters.cpp
Unescape View File

@ -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);
}
#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)),
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
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)),
#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 +192,7 @@ INSTANTIATE_TEST_CASE_P(GPU_Filter, Sobel, testing::Combine(
BorderType(cv::BORDER_CONSTANT),
BorderType(cv::BORDER_REFLECT)),
WHOLE_SUBMAT));
#endif
/////////////////////////////////////////////////////////////////////////////////////////////////
// Scharr
@ -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);
}
#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)),
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
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)),
#endif
IMAGE_CHANNELS,
testing::Values(Deriv_X(0), Deriv_X(1)),
testing::Values(Deriv_Y(0), Deriv_Y(1)),
@ -247,6 +269,7 @@ INSTANTIATE_TEST_CASE_P(GPU_Filter, Scharr, testing::Combine(
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)),
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)),
#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));
#endif
#endif // HAVE_CUDA

8
modules/gpu/test/test_imgproc.cpp
Unescape View File

@ -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)),
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)),
#endif
testing::Values(L2gradient(false), L2gradient(true)),
WHOLE_SUBMAT));
#endif
////////////////////////////////////////////////////////////////////////////////
// MeanShift

16
modules/gpu/test/test_pyramids.cpp
Unescape View File

@ -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)),
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)),
#endif
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)),
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)),
#endif
WHOLE_SUBMAT));
#endif
#endif // HAVE_CUDA

9
modules/gpu/test/test_remap.cpp
Unescape View File

@ -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

34
modules/gpu/test/test_resize.cpp
Unescape View File

@ -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)),
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)),
#endif
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)),
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)),
#endif
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)),
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)),
#endif
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

9
modules/gpu/test/test_threshold.cpp
Unescape View File

@ -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)),
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)),
#endif
ThreshOp::all(),
WHOLE_SUBMAT));
#endif
#endif // HAVE_CUDA

25
modules/gpu/test/test_warp_affine.cpp
Unescape View File

@ -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

25
modules/gpu/test/test_warp_perspective.cpp
Unescape View File

@ -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

Write Preview
Loading…
Cancel
Save