mirror/opencv
1
0
Fork 0
mirror of https://github.com/opencv/opencv.git synced 2024-11-29 05:29:54 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

fix accuracy tests in tiny mode

Browse Source
This commit is contained in:
Vladislav Vinogradov 2015-03-06 13:59:08 +03:00
parent dd93d48be4
commit f1bec940b1
13 changed files with 198 additions and 3 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
modules/gpu/test/test_color.cpp
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
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
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
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
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
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
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
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
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
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
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
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
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)