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

fix accuracy tests in tiny mode

Browse Source
pull/3785/head
Vladislav Vinogradov 10 years ago
parent dd93d48be4
commit f1bec940b1
13 changed files with 198 additions and 3 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. 4
      modules/gpu/test/test_color.cpp
  2. 9
      modules/gpu/test/test_copy_make_border.cpp
  3. 76
      modules/gpu/test/test_core.cpp
  4. 10
      modules/gpu/test/test_features2d.cpp
  5. 22
      modules/gpu/test/test_filters.cpp
  6. 4
      modules/gpu/test/test_imgproc.cpp
  7. 8
      modules/gpu/test/test_pyramids.cpp
  8. 5
      modules/gpu/test/test_remap.cpp
  9. 16
      modules/gpu/test/test_resize.cpp
  10. 4
      modules/gpu/test/test_threshold.cpp
  11. 16
      modules/gpu/test/test_warp_affine.cpp
  12. 16
      modules/gpu/test/test_warp_perspective.cpp
  13. 11
      modules/ts/include/opencv2/ts/gpu_test.hpp

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

@ -2288,7 +2288,11 @@ GPU_TEST_P(CvtColor, BayerGR2Gray)
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, CvtColor, testing::Combine(
ALL_DEVICES,
DIFFERENT_SIZES,
#ifdef OPENCV_TINY_GPU_MODULE
testing::Values(MatDepth(CV_8U), MatDepth(CV_32F)),
#else
testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_32F)),
#endif
WHOLE_SUBMAT));
///////////////////////////////////////////////////////////////////////////////////////////////////////

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

@ -90,6 +90,14 @@ GPU_TEST_P(CopyMakeBorder, Accuracy)
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)),
#else
testing::Values(MatType(CV_8UC1),
MatType(CV_8UC3),
MatType(CV_8UC4),
@ -99,6 +107,7 @@ 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));

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

@ -1344,7 +1344,11 @@ GPU_TEST_P(Abs, Accuracy)
INSTANTIATE_TEST_CASE_P(GPU_Core, Abs, testing::Combine(
ALL_DEVICES,
DIFFERENT_SIZES,
#ifdef OPENCV_TINY_GPU_MODULE
testing::Values(MatDepth(CV_32F)),
#else
testing::Values(MatDepth(CV_16S), MatDepth(CV_32F)),
#endif
WHOLE_SUBMAT));
////////////////////////////////////////////////////////////////////////////////
@ -1384,10 +1388,14 @@ GPU_TEST_P(Sqr, Accuracy)
INSTANTIATE_TEST_CASE_P(GPU_Core, Sqr, testing::Combine(
ALL_DEVICES,
DIFFERENT_SIZES,
#ifdef OPENCV_TINY_GPU_MODULE
testing::Values(MatDepth(CV_32F)),
#else
testing::Values(MatDepth(CV_8U),
MatDepth(CV_16U),
MatDepth(CV_16S),
MatDepth(CV_32F)),
#endif
WHOLE_SUBMAT));
////////////////////////////////////////////////////////////////////////////////
@ -1454,10 +1462,14 @@ GPU_TEST_P(Sqrt, Accuracy)
INSTANTIATE_TEST_CASE_P(GPU_Core, Sqrt, testing::Combine(
ALL_DEVICES,
DIFFERENT_SIZES,
#ifdef OPENCV_TINY_GPU_MODULE
testing::Values(MatDepth(CV_32F)),
#else
testing::Values(MatDepth(CV_8U),
MatDepth(CV_16U),
MatDepth(CV_16S),
MatDepth(CV_32F)),
#endif
WHOLE_SUBMAT));
////////////////////////////////////////////////////////////////////////////////
@ -1524,10 +1536,14 @@ GPU_TEST_P(Log, Accuracy)
INSTANTIATE_TEST_CASE_P(GPU_Core, Log, testing::Combine(
ALL_DEVICES,
DIFFERENT_SIZES,
#ifdef OPENCV_TINY_GPU_MODULE
testing::Values(MatDepth(CV_32F)),
#else
testing::Values(MatDepth(CV_8U),
MatDepth(CV_16U),
MatDepth(CV_16S),
MatDepth(CV_32F)),
#endif
WHOLE_SUBMAT));
////////////////////////////////////////////////////////////////////////////////
@ -1604,10 +1620,14 @@ GPU_TEST_P(Exp, Accuracy)
INSTANTIATE_TEST_CASE_P(GPU_Core, Exp, testing::Combine(
ALL_DEVICES,
DIFFERENT_SIZES,
#ifdef OPENCV_TINY_GPU_MODULE
testing::Values(MatDepth(CV_32F)),
#else
testing::Values(MatDepth(CV_8U),
MatDepth(CV_16U),
MatDepth(CV_16S),
MatDepth(CV_32F)),
#endif
WHOLE_SUBMAT));
////////////////////////////////////////////////////////////////////////////////
@ -1778,7 +1798,11 @@ GPU_TEST_P(Compare_Scalar, Accuracy)
INSTANTIATE_TEST_CASE_P(GPU_Core, Compare_Scalar, testing::Combine(
ALL_DEVICES,
DIFFERENT_SIZES,
#ifdef OPENCV_TINY_GPU_MODULE
testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),
#else
TYPES(CV_8U, CV_64F, 1, 4),
#endif
CmpCode::all(),
WHOLE_SUBMAT));
@ -1939,8 +1963,14 @@ GPU_TEST_P(Bitwise_Scalar, Xor)
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))
#else
testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_32S)),
IMAGE_CHANNELS));
IMAGE_CHANNELS
#endif
));
//////////////////////////////////////////////////////////////////////////////
// RShift
@ -2320,7 +2350,11 @@ GPU_TEST_P(Pow, Accuracy)
INSTANTIATE_TEST_CASE_P(GPU_Core, Pow, testing::Combine(
ALL_DEVICES,
DIFFERENT_SIZES,
#ifdef OPENCV_TINY_GPU_MODULE
testing::Values(MatDepth(CV_32F)),
#else
ALL_DEPTH,
#endif
WHOLE_SUBMAT));
//////////////////////////////////////////////////////////////////////////////
@ -2380,6 +2414,23 @@ GPU_TEST_P(AddWeighted, Accuracy)
}
}
#ifdef OPENCV_TINY_GPU_MODULE
INSTANTIATE_TEST_CASE_P(GPU_Core_1, AddWeighted, testing::Combine(
ALL_DEVICES,
DIFFERENT_SIZES,
testing::Values(MatDepth(CV_8U)),
testing::Values(MatDepth(CV_8U)),
testing::Values(MatDepth(CV_8U)),
WHOLE_SUBMAT));
INSTANTIATE_TEST_CASE_P(GPU_Core_2, AddWeighted, testing::Combine(
ALL_DEVICES,
DIFFERENT_SIZES,
testing::Values(MatDepth(CV_32F)),
testing::Values(MatDepth(CV_32F)),
testing::Values(MatDepth(CV_32F)),
WHOLE_SUBMAT));
#else
INSTANTIATE_TEST_CASE_P(GPU_Core, AddWeighted, testing::Combine(
ALL_DEVICES,
DIFFERENT_SIZES,
@ -2387,6 +2438,7 @@ INSTANTIATE_TEST_CASE_P(GPU_Core, AddWeighted, testing::Combine(
ALL_DEPTH,
ALL_DEPTH,
WHOLE_SUBMAT));
#endif
//////////////////////////////////////////////////////////////////////////////
// GEMM
@ -2956,12 +3008,17 @@ GPU_TEST_P(Norm, Accuracy)
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)),
#else
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));
@ -3139,7 +3196,11 @@ GPU_TEST_P(Sum, Sqr)
INSTANTIATE_TEST_CASE_P(GPU_Core, Sum, testing::Combine(
ALL_DEVICES,
DIFFERENT_SIZES,
#ifdef OPENCV_TINY_GPU_MODULE
testing::Values(MatType(CV_8UC1), MatType(CV_32FC1)),
#else
TYPES(CV_8U, CV_64F, 1, 4),
#endif
WHOLE_SUBMAT));
////////////////////////////////////////////////////////////////////////////////
@ -3513,11 +3574,19 @@ PARAM_TEST_CASE(Reduce, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, Reduc
type = CV_MAKE_TYPE(depth, channels);
if (reduceOp == CV_REDUCE_MAX || reduceOp == CV_REDUCE_MIN)
{
dst_depth = depth;
}
#ifndef OPENCV_TINY_GPU_MODULE
else if (reduceOp == CV_REDUCE_SUM)
{
dst_depth = depth == CV_8U ? CV_32S : depth < CV_64F ? CV_32F : depth;
}
#endif
else
{
dst_depth = depth < CV_32F ? CV_32F : depth;
}
dst_type = CV_MAKE_TYPE(dst_depth, channels);
}
@ -3556,11 +3625,16 @@ GPU_TEST_P(Reduce, Cols)
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)),
#else
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));

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

@ -310,6 +310,7 @@ GPU_TEST_P(BruteForceMatcher, Match_Single)
ASSERT_EQ(0, badCount);
}
#ifndef OPENCV_TINY_GPU_MODULE
GPU_TEST_P(BruteForceMatcher, Match_Collection)
{
cv::gpu::BFMatcher_GPU matcher(normCode);
@ -363,6 +364,7 @@ GPU_TEST_P(BruteForceMatcher, Match_Collection)
ASSERT_EQ(0, badCount);
}
#endif
GPU_TEST_P(BruteForceMatcher, KnnMatch_2_Single)
{
@ -442,6 +444,7 @@ GPU_TEST_P(BruteForceMatcher, KnnMatch_3_Single)
ASSERT_EQ(0, badCount);
}
#ifndef OPENCV_TINY_GPU_MODULE
GPU_TEST_P(BruteForceMatcher, KnnMatch_2_Collection)
{
cv::gpu::BFMatcher_GPU matcher(normCode);
@ -565,6 +568,7 @@ GPU_TEST_P(BruteForceMatcher, KnnMatch_3_Collection)
ASSERT_EQ(0, badCount);
}
#endif
GPU_TEST_P(BruteForceMatcher, RadiusMatch_Single)
{
@ -615,6 +619,7 @@ GPU_TEST_P(BruteForceMatcher, RadiusMatch_Single)
}
}
#ifndef OPENCV_TINY_GPU_MODULE
GPU_TEST_P(BruteForceMatcher, RadiusMatch_Collection)
{
cv::gpu::BFMatcher_GPU matcher(normCode);
@ -693,10 +698,15 @@ GPU_TEST_P(BruteForceMatcher, RadiusMatch_Collection)
ASSERT_EQ(0, badCount);
}
}
#endif
INSTANTIATE_TEST_CASE_P(GPU_Features2D, BruteForceMatcher, testing::Combine(
ALL_DEVICES,
#ifdef OPENCV_TINY_GPU_MODULE
testing::Values(NormCode(cv::NORM_L2)),
#else
testing::Values(NormCode(cv::NORM_L1), NormCode(cv::NORM_L2)),
#endif
testing::Values(DescriptorSize(57), DescriptorSize(64), DescriptorSize(83), DescriptorSize(128), DescriptorSize(179), DescriptorSize(256), DescriptorSize(304)),
testing::Values(UseMask(false), UseMask(true))));

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

@ -167,7 +167,11 @@ GPU_TEST_P(Sobel, Accuracy)
INSTANTIATE_TEST_CASE_P(GPU_Filter, Sobel, testing::Combine(
ALL_DEVICES,
DIFFERENT_SIZES,
#ifdef OPENCV_TINY_GPU_MODULE
testing::Values(MatDepth(CV_8U), MatDepth(CV_32F)),
#else
testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_16S), MatDepth(CV_32F)),
#endif
IMAGE_CHANNELS,
testing::Values(KSize(cv::Size(3, 3)), KSize(cv::Size(5, 5)), KSize(cv::Size(7, 7))),
testing::Values(Deriv_X(0), Deriv_X(1), Deriv_X(2)),
@ -230,7 +234,11 @@ GPU_TEST_P(Scharr, Accuracy)
INSTANTIATE_TEST_CASE_P(GPU_Filter, Scharr, testing::Combine(
ALL_DEVICES,
DIFFERENT_SIZES,
#ifdef OPENCV_TINY_GPU_MODULE
testing::Values(MatDepth(CV_8U), MatDepth(CV_32F)),
#else
testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_16S), MatDepth(CV_32F)),
#endif
IMAGE_CHANNELS,
testing::Values(Deriv_X(0), Deriv_X(1)),
testing::Values(Deriv_Y(0), Deriv_Y(1)),
@ -304,8 +312,17 @@ GPU_TEST_P(GaussianBlur, Accuracy)
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))),
#else
testing::Values(KSize(cv::Size(3, 3)),
KSize(cv::Size(5, 5)),
KSize(cv::Size(7, 7)),
@ -321,6 +338,7 @@ 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),
@ -568,7 +586,11 @@ GPU_TEST_P(Filter2D, Accuracy)
INSTANTIATE_TEST_CASE_P(GPU_Filter, Filter2D, testing::Combine(
ALL_DEVICES,
DIFFERENT_SIZES,
#ifdef OPENCV_TINY_GPU_MODULE
testing::Values(MatType(CV_8UC1), MatType(CV_8UC4), MatType(CV_32FC1), MatType(CV_32FC4)),
#else
testing::Values(MatType(CV_8UC1), MatType(CV_8UC4), MatType(CV_16UC1), MatType(CV_16UC4), MatType(CV_32FC1), MatType(CV_32FC4)),
#endif
testing::Values(KSize(cv::Size(3, 3)), KSize(cv::Size(5, 5)), KSize(cv::Size(7, 7)), KSize(cv::Size(11, 11)), KSize(cv::Size(13, 13)), KSize(cv::Size(15, 15))),
testing::Values(Anchor(cv::Point(-1, -1)), Anchor(cv::Point(0, 0)), Anchor(cv::Point(2, 2))),
testing::Values(BorderType(cv::BORDER_REFLECT101), BorderType(cv::BORDER_REPLICATE), BorderType(cv::BORDER_CONSTANT), BorderType(cv::BORDER_REFLECT)),

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

@ -359,7 +359,11 @@ GPU_TEST_P(Canny, Accuracy)
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Canny, testing::Combine(
ALL_DEVICES,
#ifdef OPENCV_TINY_GPU_MODULE
testing::Values(AppertureSize(3)),
#else
testing::Values(AppertureSize(3), AppertureSize(5)),
#endif
testing::Values(L2gradient(false), L2gradient(true)),
WHOLE_SUBMAT));

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

@ -83,7 +83,11 @@ GPU_TEST_P(PyrDown, Accuracy)
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, PyrDown, testing::Combine(
ALL_DEVICES,
DIFFERENT_SIZES,
#ifdef OPENCV_TINY_GPU_MODULE
testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),
#else
testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),
#endif
WHOLE_SUBMAT));
////////////////////////////////////////////////////////
@ -123,7 +127,11 @@ GPU_TEST_P(PyrUp, Accuracy)
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, PyrUp, testing::Combine(
ALL_DEVICES,
DIFFERENT_SIZES,
#ifdef OPENCV_TINY_GPU_MODULE
testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),
#else
testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),
#endif
WHOLE_SUBMAT));
#endif // HAVE_CUDA

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

@ -173,8 +173,13 @@ 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)),
#else
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 // HAVE_CUDA

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

@ -177,9 +177,17 @@ GPU_TEST_P(Resize, Accuracy)
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Resize, testing::Combine(
ALL_DEVICES,
DIFFERENT_SIZES,
#ifdef OPENCV_TINY_GPU_MODULE
testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),
#else
testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),
#endif
testing::Values(0.3, 0.5, 1.5, 2.0),
#ifdef OPENCV_TINY_GPU_MODULE
testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR)),
#else
testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)),
#endif
WHOLE_SUBMAT));
/////////////////
@ -224,7 +232,11 @@ GPU_TEST_P(ResizeSameAsHost, Accuracy)
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, ResizeSameAsHost, testing::Combine(
ALL_DEVICES,
DIFFERENT_SIZES,
#ifdef OPENCV_TINY_GPU_MODULE
testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),
#else
testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),
#endif
testing::Values(0.3, 0.5),
testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_AREA)),
WHOLE_SUBMAT));
@ -232,7 +244,11 @@ INSTANTIATE_TEST_CASE_P(GPU_ImgProc, ResizeSameAsHost, testing::Combine(
INSTANTIATE_TEST_CASE_P(GPU_ImgProc2, ResizeSameAsHost, testing::Combine(
ALL_DEVICES,
DIFFERENT_SIZES,
#ifdef OPENCV_TINY_GPU_MODULE
testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),
#else
testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), MatType(CV_16UC1), MatType(CV_16UC3), MatType(CV_16UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),
#endif
testing::Values(0.3, 0.5, 1.5, 2.0),
testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR)),
WHOLE_SUBMAT));

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

@ -86,7 +86,11 @@ GPU_TEST_P(Threshold, Accuracy)
INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Threshold, testing::Combine(
ALL_DEVICES,
DIFFERENT_SIZES,
#ifdef OPENCV_TINY_GPU_MODULE
testing::Values(MatType(CV_8UC1), MatType(CV_32FC1)),
#else
testing::Values(MatType(CV_8UC1), MatType(CV_16SC1), MatType(CV_32FC1)),
#endif
ThreshOp::all(),
WHOLE_SUBMAT));

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

@ -225,10 +225,19 @@ GPU_TEST_P(WarpAffine, Accuracy)
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)),
#else
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));
///////////////////////////////////////////////////////////////////
@ -275,6 +284,11 @@ 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))));
#ifdef OPENCV_TINY_GPU_MODULE
testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR))
#else
testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC))
#endif
));
#endif // HAVE_CUDA

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

@ -228,10 +228,19 @@ GPU_TEST_P(WarpPerspective, Accuracy)
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)),
#else
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));
///////////////////////////////////////////////////////////////////
@ -278,6 +287,11 @@ 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))));
#ifdef OPENCV_TINY_GPU_MODULE
testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR))
#else
testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC))
#endif
));
#endif // HAVE_CUDA

11
modules/ts/include/opencv2/ts/gpu_test.hpp
Unescape View File

@ -215,6 +215,12 @@ namespace cvtest
using perf::MatDepth;
#ifdef OPENCV_TINY_GPU_MODULE
#define ALL_DEPTH testing::Values(MatDepth(CV_8U), MatDepth(CV_32F))
#define DEPTH_PAIRS testing::Values(std::make_pair(MatDepth(CV_8U), MatDepth(CV_8U)), \
std::make_pair(MatDepth(CV_32F), MatDepth(CV_32F)))
#else
#define ALL_DEPTH testing::Values(MatDepth(CV_8U), MatDepth(CV_8S), MatDepth(CV_16U), MatDepth(CV_16S), MatDepth(CV_32S), MatDepth(CV_32F), MatDepth(CV_64F))
#define DEPTH_PAIRS testing::Values(std::make_pair(MatDepth(CV_8U), MatDepth(CV_8U)), \
@ -242,6 +248,7 @@ namespace cvtest
std::make_pair(MatDepth(CV_32F), MatDepth(CV_64F)), \
\
std::make_pair(MatDepth(CV_64F), MatDepth(CV_64F)))
#endif
// Type
@ -318,7 +325,11 @@ namespace cvtest
CV_ENUM(Interpolation, INTER_NEAREST, INTER_LINEAR, INTER_CUBIC, INTER_AREA)
CV_ENUM(BorderType, BORDER_REFLECT101, BORDER_REPLICATE, BORDER_CONSTANT, BORDER_REFLECT, BORDER_WRAP)
#ifdef OPENCV_TINY_GPU_MODULE
#define ALL_BORDER_TYPES testing::Values(BorderType(cv::BORDER_REFLECT101), BorderType(cv::BORDER_REPLICATE), BorderType(cv::BORDER_CONSTANT), BorderType(cv::BORDER_REFLECT))
#else
#define ALL_BORDER_TYPES testing::Values(BorderType(cv::BORDER_REFLECT101), BorderType(cv::BORDER_REPLICATE), BorderType(cv::BORDER_CONSTANT), BorderType(cv::BORDER_REFLECT), BorderType(cv::BORDER_WRAP))
#endif
CV_FLAGS(WarpFlags, INTER_NEAREST, INTER_LINEAR, INTER_CUBIC, WARP_INVERSE_MAP)

Write Preview
Loading…
Cancel
Save