mirror/opencv
1
0
Fork 0
mirror of https://github.com/opencv/opencv.git synced 2025-06-11 20:09:23 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge pull request #21909 from dbudnikov:dbudnikov/reduce_gapi_tests_number

Browse Source 
Reduce G-API tests number

* reduce number of G-API tests

* reduce number of G-API tests

* Address more comments from Dmitry.
This commit is contained in:
dbudnikov 2022-05-15 13:07:01 +03:00 committed by GitHub
parent ed567a2dd1
commit 3f4ffe7844
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
9 changed files with 257 additions and 663 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

190
modules/gapi/test/cpu/gapi_core_tests_cpu.cpp
View File

@ -12,6 +12,7 @@
namespace
{
#define CORE_CPU [] () { return cv::compile_args(cv::gapi::use_only{cv::gapi::core::cpu::kernels()}); }
const std::vector <cv::Size> in_sizes{ cv::Size(1280, 720), cv::Size(128, 128) };
} // anonymous namespace
namespace opencv_test
@ -20,9 +21,7 @@ namespace opencv_test
// FIXME: Wut? See MulTestCPU/MathOpTest below (duplicate?)
INSTANTIATE_TEST_CASE_P(AddTestCPU, MathOpTest,
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values( -1, CV_8U, CV_16U, CV_32F ),
Values(CORE_CPU),
Values(ADD, MUL),
@ -32,9 +31,7 @@ INSTANTIATE_TEST_CASE_P(AddTestCPU, MathOpTest,
INSTANTIATE_TEST_CASE_P(MulTestCPU, MathOpTest,
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values( -1, CV_8U, CV_16U, CV_32F ),
Values(CORE_CPU),
Values(MUL),
@ -44,9 +41,7 @@ INSTANTIATE_TEST_CASE_P(MulTestCPU, MathOpTest,
INSTANTIATE_TEST_CASE_P(SubTestCPU, MathOpTest,
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values( -1, CV_8U, CV_16U, CV_32F ),
Values(CORE_CPU),
Values(SUB),
@ -56,9 +51,7 @@ INSTANTIATE_TEST_CASE_P(SubTestCPU, MathOpTest,
INSTANTIATE_TEST_CASE_P(DivTestCPU, MathOpTest,
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values( -1, CV_8U, CV_16U, CV_32F ),
Values(CORE_CPU),
Values(DIV),
@ -68,90 +61,68 @@ INSTANTIATE_TEST_CASE_P(DivTestCPU, MathOpTest,
INSTANTIATE_TEST_CASE_P(MulTestCPU, MulDoubleTest,
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values( -1, CV_8U, CV_16U, CV_32F ),
Values(CORE_CPU)));
INSTANTIATE_TEST_CASE_P(DivTestCPU, DivTest,
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values( -1, CV_8U, CV_16U, CV_32F ),
Values(CORE_CPU)));
INSTANTIATE_TEST_CASE_P(DivCTestCPU, DivCTest,
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values( -1, CV_8U, CV_16U, CV_32F ),
Values(CORE_CPU)));
INSTANTIATE_TEST_CASE_P(MeanTestCPU, MeanTest,
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_CPU)));
INSTANTIATE_TEST_CASE_P(MaskTestCPU, MaskTest,
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_CPU)));
INSTANTIATE_TEST_CASE_P(SelectTestCPU, SelectTest,
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_CPU)));
INSTANTIATE_TEST_CASE_P(Polar2CartCPU, Polar2CartTest,
Combine(Values(CV_32FC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(CV_32FC1),
Values(CORE_CPU)));
INSTANTIATE_TEST_CASE_P(Cart2PolarCPU, Cart2PolarTest,
Combine(Values(CV_32FC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(CV_32FC1),
Values(CORE_CPU)));
INSTANTIATE_TEST_CASE_P(PhaseCPU, PhaseTest,
Combine(Values(CV_32F, CV_32FC3),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_CPU),
/* angle_in_degrees */ testing::Bool()));
INSTANTIATE_TEST_CASE_P(SqrtCPU, SqrtTest,
Combine(Values(CV_32F, CV_32FC3),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_CPU)));
INSTANTIATE_TEST_CASE_P(CompareTestCPU, CmpTest,
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(CV_8U),
Values(CORE_CPU),
Values(CMP_EQ, CMP_GE, CMP_NE, CMP_GT, CMP_LT, CMP_LE),
@ -160,9 +131,7 @@ INSTANTIATE_TEST_CASE_P(CompareTestCPU, CmpTest,
INSTANTIATE_TEST_CASE_P(BitwiseTestCPU, BitwiseTest,
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_CPU),
Values(AND, OR, XOR),
@ -170,33 +139,25 @@ INSTANTIATE_TEST_CASE_P(BitwiseTestCPU, BitwiseTest,
INSTANTIATE_TEST_CASE_P(BitwiseNotTestCPU, NotTest,
Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_CPU)));
INSTANTIATE_TEST_CASE_P(MinTestCPU, MinTest,
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_CPU)));
INSTANTIATE_TEST_CASE_P(MaxTestCPU, MaxTest,
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_CPU)));
INSTANTIATE_TEST_CASE_P(SumTestCPU, SumTest,
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
//Values(1e-5),
Values(CORE_CPU),
@ -204,43 +165,33 @@ INSTANTIATE_TEST_CASE_P(SumTestCPU, SumTest,
INSTANTIATE_TEST_CASE_P(CountNonZeroTestCPU, CountNonZeroTest,
Combine(Values( CV_8UC1, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_CPU),
Values(AbsToleranceScalar(1e-5).to_compare_obj())));
INSTANTIATE_TEST_CASE_P(AbsDiffTestCPU, AbsDiffTest,
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_CPU)));
INSTANTIATE_TEST_CASE_P(AbsDiffCTestCPU, AbsDiffCTest,
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_CPU)));
INSTANTIATE_TEST_CASE_P(AddWeightedTestCPU, AddWeightedTest,
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values( -1, CV_8U, CV_16U, CV_32F ),
Values(CORE_CPU),
Values(Tolerance_FloatRel_IntAbs(1e-6, 1).to_compare_obj())));
INSTANTIATE_TEST_CASE_P(NormTestCPU, NormTest,
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_CPU),
Values(AbsToleranceScalar(1e-5).to_compare_obj()),
@ -248,17 +199,13 @@ INSTANTIATE_TEST_CASE_P(NormTestCPU, NormTest,
INSTANTIATE_TEST_CASE_P(IntegralTestCPU, IntegralTest,
Combine(Values( CV_8UC1, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_CPU)));
INSTANTIATE_TEST_CASE_P(ThresholdTestCPU, ThresholdTest,
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_CPU),
Values(cv::THRESH_BINARY, cv::THRESH_BINARY_INV, cv::THRESH_TRUNC,
@ -269,9 +216,7 @@ INSTANTIATE_TEST_CASE_P(ThresholdTestCPU, ThresholdTest,
INSTANTIATE_TEST_CASE_P(ThresholdTestCPU, ThresholdOTTest,
Combine(Values(CV_8UC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_CPU),
Values(cv::THRESH_OTSU, cv::THRESH_TRIANGLE)));
@ -279,99 +224,75 @@ INSTANTIATE_TEST_CASE_P(ThresholdTestCPU, ThresholdOTTest,
INSTANTIATE_TEST_CASE_P(InRangeTestCPU, InRangeTest,
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1, CV_32FC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_CPU)));
INSTANTIATE_TEST_CASE_P(Split3TestCPU, Split3Test,
Combine(Values(CV_8UC3),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(CV_8UC1),
Values(CORE_CPU)));
INSTANTIATE_TEST_CASE_P(Split4TestCPU, Split4Test,
Combine(Values(CV_8UC4),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(CV_8UC1),
Values(CORE_CPU)));
INSTANTIATE_TEST_CASE_P(Merge3TestCPU, Merge3Test,
Combine(Values(CV_8UC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(CV_8UC3),
Values(CORE_CPU)));
INSTANTIATE_TEST_CASE_P(Merge4TestCPU, Merge4Test,
Combine(Values(CV_8UC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(CV_8UC4),
Values(CORE_CPU)));
INSTANTIATE_TEST_CASE_P(RemapTestCPU, RemapTest,
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_CPU)));
INSTANTIATE_TEST_CASE_P(FlipTestCPU, FlipTest,
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_CPU),
Values(0,1,-1)));
INSTANTIATE_TEST_CASE_P(CropTestCPU, CropTest,
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_CPU),
Values(cv::Rect(10, 8, 20, 35), cv::Rect(4, 10, 37, 50))));
INSTANTIATE_TEST_CASE_P(CopyTestCPU, CopyTest,
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_CPU)));
INSTANTIATE_TEST_CASE_P(LUTTestCPU, LUTTest,
Combine(Values(CV_8UC1, CV_8UC3),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(CV_8UC1),
Values(CORE_CPU)));
INSTANTIATE_TEST_CASE_P(LUTTestCustomCPU, LUTTest,
Combine(Values(CV_8UC3),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(CV_8UC3),
Values(CORE_CPU)));
INSTANTIATE_TEST_CASE_P(ConvertToCPU, ConvertToTest,
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(CV_8U, CV_16U, CV_16S, CV_32F),
Values(CORE_CPU),
Values(AbsExact().to_compare_obj()),
@ -380,40 +301,31 @@ INSTANTIATE_TEST_CASE_P(ConvertToCPU, ConvertToTest,
INSTANTIATE_TEST_CASE_P(ConcatHorTestCPU, ConcatHorTest,
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_CPU)));
INSTANTIATE_TEST_CASE_P(ConcatVertTestCPU, ConcatVertTest,
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_CPU)));
INSTANTIATE_TEST_CASE_P(ConcatVertVecTestCPU, ConcatVertVecTest,
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_CPU)));
INSTANTIATE_TEST_CASE_P(ConcatHorVecTestCPU, ConcatHorVecTest,
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_CPU)));
INSTANTIATE_TEST_CASE_P(WarpPerspectiveTestCPU, WarpPerspectiveTest,
Combine(Values(CV_8UC1, CV_8UC3),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(-1),
Values(CORE_CPU),
Values(AbsExact().to_compare_obj()),
@ -425,8 +337,7 @@ INSTANTIATE_TEST_CASE_P(WarpPerspectiveTestCPU, WarpPerspectiveTest,
INSTANTIATE_TEST_CASE_P(WarpAffineTestCPU, WarpAffineTest,
Combine(Values(CV_8UC1, CV_8UC3),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(-1),
Values(CORE_CPU),
Values(AbsExact().to_compare_obj()),
@ -438,8 +349,7 @@ INSTANTIATE_TEST_CASE_P(WarpAffineTestCPU, WarpAffineTest,
INSTANTIATE_TEST_CASE_P(NormalizeTestCPU, NormalizeTest,
Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(-1),
Values(CORE_CPU),
Values(AbsExact().to_compare_obj()),
@ -519,9 +429,7 @@ INSTANTIATE_TEST_CASE_P(TransposeTestCPU, TransposeTest,
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1, CV_32FC1,
CV_8UC2, CV_16UC2, CV_16SC2, CV_32FC2,
CV_8UC3, CV_16UC3, CV_16SC3, CV_32FC3),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_CPU),
Values(AbsExact().to_compare_obj())));

167
modules/gapi/test/cpu/gapi_core_tests_fluid.cpp
View File

@ -11,6 +11,7 @@
namespace
{
#define CORE_FLUID [] () { return cv::compile_args(cv::gapi::use_only{cv::gapi::core::fluid::kernels()}); }
const std::vector <cv::Size> in_sizes{ cv::Size(1280, 720), cv::Size(128, 128) };
} // anonymous namespace
namespace opencv_test
@ -18,10 +19,7 @@ namespace opencv_test
// FIXME: Windows accuracy problems after recent update!
INSTANTIATE_TEST_CASE_P(MathOpTestFluid, MathOpTest,
Combine(Values(CV_8UC3, CV_8UC1, CV_16SC1, CV_32FC1),
Values(cv::Size(1920, 1080),
cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1, CV_8U, CV_32F),
Values(CORE_FLUID),
Values(DIV, MUL),
@ -37,10 +35,7 @@ INSTANTIATE_TEST_CASE_P(MathOpTestFluid, MathOpTest,
// Github ticket: https://github.com/opencv/opencv/issues/18373.
INSTANTIATE_TEST_CASE_P(DISABLED_MathOpTestFluid, MathOpTest,
Combine(Values(CV_8UC3, CV_8UC1, CV_16SC1, CV_32FC1),
Values(cv::Size(1920, 1080),
cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1, CV_8U, CV_32F),
Values(CORE_FLUID),
Values(ADD, SUB),
@ -54,9 +49,7 @@ INSTANTIATE_TEST_CASE_P(DISABLED_MathOpTestFluid, MathOpTest,
// Github ticket: https://github.com/opencv/opencv/issues/18373.
INSTANTIATE_TEST_CASE_P(DISABLED_SubTestFluid, MathOpTest,
Combine(Values(CV_8UC1, CV_16SC1 , CV_32FC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1, CV_8U, CV_32F),
Values(CORE_FLUID),
Values(SUB),
@ -66,41 +59,31 @@ INSTANTIATE_TEST_CASE_P(DISABLED_SubTestFluid, MathOpTest,
INSTANTIATE_TEST_CASE_P(MulSTestFluid, MulDoubleTest,
Combine(Values(CV_8UC1, CV_16SC1, CV_32FC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1), // FIXME: extend with more types
Values(CORE_FLUID)));
INSTANTIATE_TEST_CASE_P(DivCTestFluid, DivCTest,
Combine(Values(CV_8UC1, CV_16SC1, CV_32FC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(CV_8U, CV_32F),
Values(CORE_FLUID)));
INSTANTIATE_TEST_CASE_P(DISABLED_MeanTestFluid, MeanTest,
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_FLUID)));
INSTANTIATE_TEST_CASE_P(MaskTestFluid, MaskTest,
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_FLUID)));
INSTANTIATE_TEST_CASE_P(AbsDiffTestFluid, AbsDiffTest,
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_FLUID)));
@ -108,18 +91,13 @@ INSTANTIATE_TEST_CASE_P(AbsDiffCTestFluid, AbsDiffCTest,
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1, CV_8UC2,
CV_16UC2, CV_16SC2, CV_8UC3, CV_16UC3,
CV_16SC3, CV_8UC4, CV_16UC4, CV_16SC4),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_FLUID)));
INSTANTIATE_TEST_CASE_P(BitwiseTestFluid, BitwiseTest,
Combine(Values(CV_8UC3, CV_8UC1, CV_16UC1, CV_16SC1),
Values(cv::Size(1920, 1080),
cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_FLUID),
Values(AND, OR, XOR),
@ -127,46 +105,32 @@ INSTANTIATE_TEST_CASE_P(BitwiseTestFluid, BitwiseTest,
INSTANTIATE_TEST_CASE_P(BitwiseNotTestFluid, NotTest,
Combine(Values(CV_8UC3, CV_8UC1, CV_16UC1, CV_16SC1),
Values(cv::Size(1920, 1080),
cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_FLUID)));
INSTANTIATE_TEST_CASE_P(MinTestFluid, MinTest,
Combine(Values(CV_8UC3, CV_8UC1, CV_16UC1, CV_16SC1, CV_32FC1),
Values(cv::Size(1920, 1080),
cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_FLUID)));
INSTANTIATE_TEST_CASE_P(MaxTestFluid, MaxTest,
Combine(Values(CV_8UC3, CV_8UC1, CV_16UC1, CV_16SC1, CV_32FC1),
Values(cv::Size(1920, 1080),
cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_FLUID)));
INSTANTIATE_TEST_CASE_P(DISABLED_SumTestFluid, SumTest,
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_FLUID),
Values(AbsToleranceScalar(1e-5).to_compare_obj())));
INSTANTIATE_TEST_CASE_P(CompareTestFluid, CmpTest,
Combine(Values(CV_8UC3, CV_8UC1, CV_16SC1, CV_32FC1),
Values(cv::Size(1920, 1080),
cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(CV_8U),
Values(CORE_FLUID),
Values(CMP_EQ, CMP_GE, CMP_NE, CMP_GT, CMP_LT, CMP_LE),
@ -176,10 +140,7 @@ INSTANTIATE_TEST_CASE_P(CompareTestFluid, CmpTest,
// FIXME: solve comparison error to unite with the test above
INSTANTIATE_TEST_CASE_P(CompareTestFluidScalar, CmpTest,
Combine(Values(CV_8UC3, CV_8UC1, CV_16SC1, CV_32FC1),
Values(cv::Size(1920, 1080),
cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(CV_8U),
Values(CORE_FLUID),
Values(CMP_EQ, CMP_GE, CMP_NE, CMP_GT, CMP_LT, CMP_LE),
@ -188,18 +149,14 @@ INSTANTIATE_TEST_CASE_P(CompareTestFluidScalar, CmpTest,
INSTANTIATE_TEST_CASE_P(AddWeightedTestFluid, AddWeightedTest,
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1, CV_8U, CV_32F),
Values(CORE_FLUID),
Values(Tolerance_FloatRel_IntAbs(1e-5, 2).to_compare_obj())));
INSTANTIATE_TEST_CASE_P(DISABLED_NormTestFluid, NormTest,
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_FLUID),
Values(AbsToleranceScalar(1e-5).to_compare_obj()),
@ -207,26 +164,19 @@ INSTANTIATE_TEST_CASE_P(DISABLED_NormTestFluid, NormTest,
INSTANTIATE_TEST_CASE_P(DISABLED_IntegralTestFluid, IntegralTest,
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_FLUID)));
INSTANTIATE_TEST_CASE_P(LUTTestFluid, LUTTest,
Combine(Values(CV_8UC1, CV_8UC3),
Values(cv::Size(1920, 1080),
cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(CV_8UC1),
Values(CORE_FLUID)));
INSTANTIATE_TEST_CASE_P(ConvertToFluid, ConvertToTest,
Combine(Values(CV_8UC3, CV_8UC1, CV_16UC1, CV_16SC1, CV_32FC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(CV_8U, CV_16U, CV_16S, CV_32F),
Values(CORE_FLUID),
Values(Tolerance_FloatRel_IntAbs(1e-5, 2).to_compare_obj()),
@ -235,128 +185,94 @@ INSTANTIATE_TEST_CASE_P(ConvertToFluid, ConvertToTest,
INSTANTIATE_TEST_CASE_P(DISABLED_ConcatHorTestFluid, ConcatHorTest,
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_FLUID)));
INSTANTIATE_TEST_CASE_P(DISABLED_ConcatVertTestFluid, ConcatVertTest,
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_FLUID)));
INSTANTIATE_TEST_CASE_P(Split3TestFluid, Split3Test,
Combine(Values(CV_8UC3),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(CV_8UC1),
Values(CORE_FLUID)));
INSTANTIATE_TEST_CASE_P(Split4TestFluid, Split4Test,
Combine(Values(CV_8UC4),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(CV_8UC1),
Values(CORE_FLUID)));
INSTANTIATE_TEST_CASE_P(Merge3TestFluid, Merge3Test,
Combine(Values(CV_8UC1),
Values(cv::Size(1920, 1080),
cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(CV_8UC3),
Values(CORE_FLUID)));
INSTANTIATE_TEST_CASE_P(Merge4TestFluid, Merge4Test,
Combine(Values(CV_8UC1),
Values(cv::Size(1920, 1080),
cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(CV_8UC4),
Values(CORE_FLUID)));
INSTANTIATE_TEST_CASE_P(DISABLED_RemapTestFluid, RemapTest,
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_FLUID)));
INSTANTIATE_TEST_CASE_P(DISABLED_FlipTestFluid, FlipTest,
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_FLUID),
Values(0,1,-1)));
INSTANTIATE_TEST_CASE_P(DISABLED_CropTestFluid, CropTest,
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_FLUID),
Values(cv::Rect(10, 8, 20, 35), cv::Rect(4, 10, 37, 50))));
INSTANTIATE_TEST_CASE_P(SelectTestFluid, SelectTest,
Combine(Values(CV_8UC3, CV_8UC1, CV_16UC1, CV_16SC1),
Values(cv::Size(1920, 1080),
cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_FLUID)));
INSTANTIATE_TEST_CASE_P(Polar2CartFluid, Polar2CartTest,
Combine(Values(CV_32FC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(CV_32FC1),
Values(CORE_FLUID)));
INSTANTIATE_TEST_CASE_P(Cart2PolarFluid, Cart2PolarTest,
Combine(Values(CV_32FC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(CV_32FC1),
Values(CORE_FLUID)));
INSTANTIATE_TEST_CASE_P(PhaseFluid, PhaseTest,
Combine(Values(CV_32F, CV_32FC3),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_FLUID),
/* angle_in_degrees */ testing::Bool()));
INSTANTIATE_TEST_CASE_P(SqrtFluid, SqrtTest,
Combine(Values(CV_32F, CV_32FC3),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_FLUID)));
INSTANTIATE_TEST_CASE_P(ThresholdTestFluid, ThresholdTest,
Combine(Values(CV_8UC3, CV_8UC1, CV_16UC1, CV_16SC1),
Values(cv::Size(1920, 1080),
cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_FLUID),
Values(cv::THRESH_BINARY, cv::THRESH_BINARY_INV,
@ -368,19 +284,14 @@ INSTANTIATE_TEST_CASE_P(ThresholdTestFluid, ThresholdTest,
INSTANTIATE_TEST_CASE_P(DISABLED_ThresholdTestFluid, ThresholdOTTest,
Combine(Values(CV_8UC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_FLUID),
Values(cv::THRESH_OTSU, cv::THRESH_TRIANGLE)));
INSTANTIATE_TEST_CASE_P(InRangeTestFluid, InRangeTest,
Combine(Values(CV_8UC3, CV_8UC1, CV_16UC1, CV_16SC1, CV_32FC1),
Values(cv::Size(1920, 1080),
cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_FLUID)));

153
modules/gapi/test/cpu/gapi_imgproc_tests_cpu.cpp
View File

@ -13,6 +13,7 @@
namespace
{
#define IMGPROC_CPU [] () { return cv::compile_args(cv::gapi::use_only{cv::gapi::imgproc::cpu::kernels()}); }
const std::vector <cv::Size> in_sizes{ cv::Size(1280, 720), cv::Size(128, 128) };
} // anonymous namespace
namespace opencv_test
@ -20,9 +21,7 @@ namespace opencv_test
INSTANTIATE_TEST_CASE_P(ResizeTestCPU, ResizeTest,
Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(IMGPROC_CPU),
Values(AbsSimilarPoints(2, 0.05).to_compare_obj()),
@ -32,9 +31,7 @@ INSTANTIATE_TEST_CASE_P(ResizeTestCPU, ResizeTest,
INSTANTIATE_TEST_CASE_P(ResizePTestCPU, ResizePTest,
Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(IMGPROC_CPU),
Values(AbsSimilarPoints(2, 0.05).to_compare_obj()),
@ -44,9 +41,7 @@ INSTANTIATE_TEST_CASE_P(ResizePTestCPU, ResizePTest,
INSTANTIATE_TEST_CASE_P(ResizeTestCPU, ResizeTestFxFy,
Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(IMGPROC_CPU),
Values(AbsSimilarPoints(2, 0.05).to_compare_obj()),
@ -56,9 +51,7 @@ INSTANTIATE_TEST_CASE_P(ResizeTestCPU, ResizeTestFxFy,
INSTANTIATE_TEST_CASE_P(Filter2DTestCPU, Filter2DTest,
Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1, CV_32F),
Values(IMGPROC_CPU),
Values(AbsExact().to_compare_obj()),
@ -70,8 +63,7 @@ INSTANTIATE_TEST_CASE_P(Filter2DTestCPU, Filter2DTest,
INSTANTIATE_TEST_CASE_P(BoxFilterTestCPU, BoxFilterTest,
Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(-1, CV_32F),
Values(IMGPROC_CPU),
Values(AbsTolerance(0).to_compare_obj()),
@ -80,8 +72,7 @@ INSTANTIATE_TEST_CASE_P(BoxFilterTestCPU, BoxFilterTest,
INSTANTIATE_TEST_CASE_P(SepFilterTestCPU_8U, SepFilterTest,
Combine(Values(CV_8UC1, CV_8UC3),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(-1, CV_16S, CV_32F),
Values(IMGPROC_CPU),
Values(AbsExact().to_compare_obj()),
@ -89,8 +80,7 @@ INSTANTIATE_TEST_CASE_P(SepFilterTestCPU_8U, SepFilterTest,
INSTANTIATE_TEST_CASE_P(SepFilterTestCPU_other, SepFilterTest,
Combine(Values(CV_16UC1, CV_16SC1, CV_32FC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(-1, CV_32F),
Values(IMGPROC_CPU),
Values(AbsExact().to_compare_obj()),
@ -98,8 +88,7 @@ INSTANTIATE_TEST_CASE_P(SepFilterTestCPU_other, SepFilterTest,
INSTANTIATE_TEST_CASE_P(BlurTestCPU, BlurTest,
Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(-1),
Values(IMGPROC_CPU),
Values(AbsTolerance(0.0).to_compare_obj()),
@ -108,8 +97,7 @@ INSTANTIATE_TEST_CASE_P(BlurTestCPU, BlurTest,
INSTANTIATE_TEST_CASE_P(gaussBlurTestCPU, GaussianBlurTest,
Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(-1),
Values(IMGPROC_CPU),
Values(AbsExact().to_compare_obj()),
@ -117,8 +105,7 @@ INSTANTIATE_TEST_CASE_P(gaussBlurTestCPU, GaussianBlurTest,
INSTANTIATE_TEST_CASE_P(MedianBlurTestCPU, MedianBlurTest,
Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(-1),
Values(IMGPROC_CPU),
Values(AbsExact().to_compare_obj()),
@ -126,8 +113,7 @@ INSTANTIATE_TEST_CASE_P(MedianBlurTestCPU, MedianBlurTest,
INSTANTIATE_TEST_CASE_P(ErodeTestCPU, ErodeTest,
Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(-1),
Values(IMGPROC_CPU),
Values(AbsExact().to_compare_obj()),
@ -138,8 +124,7 @@ INSTANTIATE_TEST_CASE_P(ErodeTestCPU, ErodeTest,
INSTANTIATE_TEST_CASE_P(Erode3x3TestCPU, Erode3x3Test,
Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(-1),
Values(IMGPROC_CPU),
Values(AbsExact().to_compare_obj()),
@ -147,8 +132,7 @@ INSTANTIATE_TEST_CASE_P(Erode3x3TestCPU, Erode3x3Test,
INSTANTIATE_TEST_CASE_P(DilateTestCPU, DilateTest,
Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(-1),
Values(IMGPROC_CPU),
Values(AbsExact().to_compare_obj()),
@ -159,8 +143,7 @@ INSTANTIATE_TEST_CASE_P(DilateTestCPU, DilateTest,
INSTANTIATE_TEST_CASE_P(Dilate3x3TestCPU, Dilate3x3Test,
Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(-1),
Values(IMGPROC_CPU),
Values(AbsExact().to_compare_obj()),
@ -168,8 +151,7 @@ INSTANTIATE_TEST_CASE_P(Dilate3x3TestCPU, Dilate3x3Test,
INSTANTIATE_TEST_CASE_P(MorphologyExTestCPU, MorphologyExTest,
Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(-1),
Values(IMGPROC_CPU),
Values(AbsExact().to_compare_obj()),
@ -183,8 +165,7 @@ INSTANTIATE_TEST_CASE_P(MorphologyExTestCPU, MorphologyExTest,
INSTANTIATE_TEST_CASE_P(MorphologyExHitMissTestCPU, MorphologyExTest,
Combine(Values(CV_8UC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(-1),
Values(IMGPROC_CPU),
Values(AbsExact().to_compare_obj()),
@ -192,8 +173,7 @@ INSTANTIATE_TEST_CASE_P(MorphologyExHitMissTestCPU, MorphologyExTest,
INSTANTIATE_TEST_CASE_P(SobelTestCPU, SobelTest,
Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(-1, CV_16S, CV_32F),
Values(IMGPROC_CPU),
Values(AbsExact().to_compare_obj()),
@ -203,8 +183,7 @@ INSTANTIATE_TEST_CASE_P(SobelTestCPU, SobelTest,
INSTANTIATE_TEST_CASE_P(SobelTestCPU32F, SobelTest,
Combine(Values(CV_32FC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(CV_32F),
Values(IMGPROC_CPU),
Values(AbsExact().to_compare_obj()),
@ -214,8 +193,7 @@ INSTANTIATE_TEST_CASE_P(SobelTestCPU32F, SobelTest,
INSTANTIATE_TEST_CASE_P(SobelXYTestCPU, SobelXYTest,
Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(-1, CV_16S, CV_32F),
Values(IMGPROC_CPU),
Values(AbsExact().to_compare_obj()),
@ -226,8 +204,7 @@ INSTANTIATE_TEST_CASE_P(SobelXYTestCPU, SobelXYTest,
INSTANTIATE_TEST_CASE_P(SobelXYTestCPU32F, SobelXYTest,
Combine(Values(CV_32FC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(CV_32F),
Values(IMGPROC_CPU),
Values(AbsExact().to_compare_obj()),
@ -238,8 +215,7 @@ INSTANTIATE_TEST_CASE_P(SobelXYTestCPU32F, SobelXYTest,
INSTANTIATE_TEST_CASE_P(LaplacianTestCPU, LaplacianTest,
Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(-1),
Values(IMGPROC_CPU),
Values(AbsExact().to_compare_obj()),
@ -249,8 +225,7 @@ INSTANTIATE_TEST_CASE_P(LaplacianTestCPU, LaplacianTest,
INSTANTIATE_TEST_CASE_P(BilateralFilterTestCPU, BilateralFilterTest,
Combine(Values(CV_32FC1, CV_32FC3, CV_8UC1, CV_8UC3),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(-1),
Values(IMGPROC_CPU),
Values(AbsExact().to_compare_obj()),
@ -261,16 +236,14 @@ INSTANTIATE_TEST_CASE_P(BilateralFilterTestCPU, BilateralFilterTest,
INSTANTIATE_TEST_CASE_P(EqHistTestCPU, EqHistTest,
Combine(Values(CV_8UC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(CV_8UC1),
Values(IMGPROC_CPU),
Values(AbsExact().to_compare_obj())));
INSTANTIATE_TEST_CASE_P(CannyTestCPU, CannyTest,
Combine(Values(CV_8UC1, CV_8UC3),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(CV_8UC1),
Values(IMGPROC_CPU),
Values(AbsSimilarPoints(0, 0.05).to_compare_obj()),
@ -314,8 +287,7 @@ INSTANTIATE_TEST_CASE_P(FindContoursOffsetTestCPU, FindContoursOffsetTest,
INSTANTIATE_TEST_CASE_P(FindContoursHNoOffsetTestCPU, FindContoursHNoOffsetTest,
Combine(Values(IMGPROC_CPU),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(CV_8UC1),
Values(RETR_EXTERNAL, RETR_LIST, RETR_CCOMP, RETR_TREE),
Values(CHAIN_APPROX_NONE, CHAIN_APPROX_SIMPLE,
@ -324,8 +296,7 @@ INSTANTIATE_TEST_CASE_P(FindContoursHNoOffsetTestCPU, FindContoursHNoOffsetTest,
INSTANTIATE_TEST_CASE_P(FindContoursHNoOffset32STestCPU, FindContoursHNoOffsetTest,
Combine(Values(IMGPROC_CPU),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(CV_32SC1),
Values(RETR_CCOMP, RETR_FLOODFILL),
Values(CHAIN_APPROX_NONE, CHAIN_APPROX_SIMPLE,
@ -337,9 +308,7 @@ INSTANTIATE_TEST_CASE_P(FindContoursHOffsetTestCPU, FindContoursHOffsetTest,
INSTANTIATE_TEST_CASE_P(BoundingRectMatTestCPU, BoundingRectMatTest,
Combine(Values( CV_8UC1 ),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(IMGPROC_CPU),
Values(IoUToleranceRect(0).to_compare_obj()),
@ -440,176 +409,154 @@ INSTANTIATE_TEST_CASE_P(FitLine3DVector64FTestCPU, FitLine3DVector64FTest,
INSTANTIATE_TEST_CASE_P(BGR2RGBTestCPU, BGR2RGBTest,
Combine(Values(CV_8UC3),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(CV_8UC3),
Values(IMGPROC_CPU),
Values(AbsExact().to_compare_obj())));
INSTANTIATE_TEST_CASE_P(RGB2GrayTestCPU, RGB2GrayTest,
Combine(Values(CV_8UC3),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(CV_8UC1),
Values(IMGPROC_CPU),
Values(AbsExact().to_compare_obj())));
INSTANTIATE_TEST_CASE_P(BGR2GrayTestCPU, BGR2GrayTest,
Combine(Values(CV_8UC3),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(CV_8UC1),
Values(IMGPROC_CPU),
Values(AbsExact().to_compare_obj())));
INSTANTIATE_TEST_CASE_P(RGB2YUVTestCPU, RGB2YUVTest,
Combine(Values(CV_8UC3),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(CV_8UC3),
Values(IMGPROC_CPU),
Values(AbsExact().to_compare_obj())));
INSTANTIATE_TEST_CASE_P(YUV2RGBTestCPU, YUV2RGBTest,
Combine(Values(CV_8UC3),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(CV_8UC3),
Values(IMGPROC_CPU),
Values(AbsExact().to_compare_obj())));
INSTANTIATE_TEST_CASE_P(BGR2I420TestCPU, BGR2I420Test,
Combine(Values(CV_8UC3),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(CV_8UC1),
Values(IMGPROC_CPU),
Values(AbsExact().to_compare_obj())));
INSTANTIATE_TEST_CASE_P(RGB2I420TestCPU, RGB2I420Test,
Combine(Values(CV_8UC3),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(CV_8UC1),
Values(IMGPROC_CPU),
Values(AbsExact().to_compare_obj())));
INSTANTIATE_TEST_CASE_P(I4202BGRTestCPU, I4202BGRTest,
Combine(Values(CV_8UC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(CV_8UC3),
Values(IMGPROC_CPU),
Values(AbsExact().to_compare_obj())));
INSTANTIATE_TEST_CASE_P(I4202RGBTestCPU, I4202RGBTest,
Combine(Values(CV_8UC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(CV_8UC3),
Values(IMGPROC_CPU),
Values(AbsExact().to_compare_obj())));
INSTANTIATE_TEST_CASE_P(NV12toRGBTestCPU, NV12toRGBTest,
Combine(Values(CV_8UC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(CV_8UC3),
Values(IMGPROC_CPU),
Values(AbsExact().to_compare_obj())));
INSTANTIATE_TEST_CASE_P(NV12toBGRTestCPU, NV12toBGRTest,
Combine(Values(CV_8UC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(CV_8UC3),
Values(IMGPROC_CPU),
Values(AbsExact().to_compare_obj())));
INSTANTIATE_TEST_CASE_P(NV12toGrayTestCPU, NV12toGrayTest,
Combine(Values(CV_8UC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(CV_8UC1),
Values(IMGPROC_CPU),
Values(AbsExact().to_compare_obj())));
INSTANTIATE_TEST_CASE_P(NV12toRGBpTestCPU, NV12toRGBpTest,
Combine(Values(CV_8UC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(CV_8UC1),
Values(IMGPROC_CPU),
Values(AbsExact().to_compare_obj())));
INSTANTIATE_TEST_CASE_P(NV12toBGRpTestCPU, NV12toBGRpTest,
Combine(Values(CV_8UC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(CV_8UC3),
Values(IMGPROC_CPU),
Values(AbsExact().to_compare_obj())));
INSTANTIATE_TEST_CASE_P(RGB2LabTestCPU, RGB2LabTest,
Combine(Values(CV_8UC3),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(CV_8UC3),
Values(IMGPROC_CPU),
Values(AbsExact().to_compare_obj())));
INSTANTIATE_TEST_CASE_P(BGR2LUVTestCPU, BGR2LUVTest,
Combine(Values(CV_8UC3),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(CV_8UC3),
Values(IMGPROC_CPU),
Values(AbsExact().to_compare_obj())));
INSTANTIATE_TEST_CASE_P(LUV2BGRTestCPU, LUV2BGRTest,
Combine(Values(CV_8UC3),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(CV_8UC3),
Values(IMGPROC_CPU),
Values(AbsExact().to_compare_obj())));
INSTANTIATE_TEST_CASE_P(BGR2YUVTestCPU, BGR2YUVTest,
Combine(Values(CV_8UC3),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(CV_8UC3),
Values(IMGPROC_CPU),
Values(AbsExact().to_compare_obj())));
INSTANTIATE_TEST_CASE_P(YUV2BGRTestCPU, YUV2BGRTest,
Combine(Values(CV_8UC3),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(CV_8UC3),
Values(IMGPROC_CPU),
Values(AbsExact().to_compare_obj())));
INSTANTIATE_TEST_CASE_P(RGB2HSVTestCPU, RGB2HSVTest,
Combine(Values(CV_8UC3),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(CV_8UC3),
Values(IMGPROC_CPU),
Values(AbsExact().to_compare_obj())));
INSTANTIATE_TEST_CASE_P(BayerGR2RGBTestCPU, BayerGR2RGBTest,
Combine(Values(CV_8UC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(CV_8UC3),
Values(IMGPROC_CPU),
Values(AbsExact().to_compare_obj())));
INSTANTIATE_TEST_CASE_P(RGB2YUV422TestCPU, RGB2YUV422Test,
Combine(Values(CV_8UC3),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(CV_8UC2),
Values(IMGPROC_CPU),
Values(AbsTolerance(1).to_compare_obj())));

70
modules/gapi/test/cpu/gapi_imgproc_tests_fluid.cpp
View File

@ -19,26 +19,17 @@ namespace opencv_test
INSTANTIATE_TEST_CASE_P(ResizeTestFluid, ResizeTest,
Combine(Values(CV_8UC3/*CV_8UC1, CV_16UC1, CV_16SC1*/),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128),
cv::Size(64, 64),
cv::Size(30, 30)),
Values(-1),
Values(IMGPROC_FLUID),
Values(Tolerance_FloatRel_IntAbs(1e-5, 1).to_compare_obj()),
Values(/*cv::INTER_NEAREST,*/ cv::INTER_LINEAR/*, cv::INTER_AREA*/),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128),
cv::Size(64, 64),
cv::Size(30, 30))));
INSTANTIATE_TEST_CASE_P(ResizeTestFxFyFluid, ResizeTestFxFy,
Combine(Values(CV_8UC3/*CV_8UC1, CV_16UC1, CV_16SC1*/),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128),
cv::Size(64, 64),
cv::Size(30, 30)),
Values(-1),
Values(IMGPROC_FLUID),
@ -49,40 +40,35 @@ INSTANTIATE_TEST_CASE_P(ResizeTestFxFyFluid, ResizeTestFxFy,
INSTANTIATE_TEST_CASE_P(RGB2GrayTestFluid, RGB2GrayTest,
Combine(Values(CV_8UC3),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(CV_8UC1),
Values(IMGPROC_FLUID),
Values(ToleranceColor(1e-3).to_compare_obj())));
INSTANTIATE_TEST_CASE_P(BGR2GrayTestFluid, BGR2GrayTest,
Combine(Values(CV_8UC3),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(CV_8UC1),
Values(IMGPROC_FLUID),
Values(ToleranceColor(1e-3).to_compare_obj())));
INSTANTIATE_TEST_CASE_P(RGB2YUVTestFluid, RGB2YUVTest,
Combine(Values(CV_8UC3),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(CV_8UC3),
Values(IMGPROC_FLUID),
Values(ToleranceColor(1e-3).to_compare_obj())));
INSTANTIATE_TEST_CASE_P(YUV2RGBTestFluid, YUV2RGBTest,
Combine(Values(CV_8UC3),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(CV_8UC3),
Values(IMGPROC_FLUID),
Values(ToleranceColor(1e-3).to_compare_obj())));
INSTANTIATE_TEST_CASE_P(RGB2LabTestFluid, RGB2LabTest,
Combine(Values(CV_8UC3),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(CV_8UC3),
Values(IMGPROC_FLUID),
Values(AbsSimilarPoints(1, 0.05).to_compare_obj())));
@ -90,40 +76,35 @@ INSTANTIATE_TEST_CASE_P(RGB2LabTestFluid, RGB2LabTest,
// FIXME: Not supported by Fluid yet (no kernel implemented)
INSTANTIATE_TEST_CASE_P(BGR2LUVTestFluid, BGR2LUVTest,
Combine(Values(CV_8UC3),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(CV_8UC3),
Values(IMGPROC_FLUID),
Values(ToleranceColor(5e-3, 6).to_compare_obj())));
INSTANTIATE_TEST_CASE_P(RGB2HSVTestFluid, RGB2HSVTest,
Combine(Values(CV_8UC3),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(CV_8UC3),
Values(IMGPROC_FLUID),
Values(ToleranceColor(1e-3).to_compare_obj())));
INSTANTIATE_TEST_CASE_P(BayerGR2RGBTestFluid, BayerGR2RGBTest,
Combine(Values(CV_8UC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(CV_8UC3),
Values(IMGPROC_FLUID),
Values(ToleranceColor(1e-3).to_compare_obj())));
INSTANTIATE_TEST_CASE_P(RGB2YUV422TestFluid, RGB2YUV422Test,
Combine(Values(CV_8UC3),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(CV_8UC2),
Values(IMGPROC_FLUID),
Values(AbsTolerance(1).to_compare_obj())));
INSTANTIATE_TEST_CASE_P(blurTestFluid, BlurTest,
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(-1),
Values(IMGPROC_FLUID),
Values(ToleranceFilter(1e-4f, 0.01).to_compare_obj()),
@ -132,8 +113,7 @@ INSTANTIATE_TEST_CASE_P(blurTestFluid, BlurTest,
INSTANTIATE_TEST_CASE_P(gaussBlurTestFluid, GaussianBlurTest,
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(-1),
Values(IMGPROC_FLUID),
Values(ToleranceFilter(1e-3f, 0.01).to_compare_obj()),
@ -141,8 +121,7 @@ INSTANTIATE_TEST_CASE_P(gaussBlurTestFluid, GaussianBlurTest,
INSTANTIATE_TEST_CASE_P(medianBlurTestFluid, MedianBlurTest,
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(-1),
Values(IMGPROC_FLUID),
Values(AbsExact().to_compare_obj()),
@ -150,8 +129,7 @@ INSTANTIATE_TEST_CASE_P(medianBlurTestFluid, MedianBlurTest,
INSTANTIATE_TEST_CASE_P(erodeTestFluid, ErodeTest,
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(-1),
Values(IMGPROC_FLUID),
Values(AbsExact().to_compare_obj()),
@ -162,8 +140,7 @@ INSTANTIATE_TEST_CASE_P(erodeTestFluid, ErodeTest,
INSTANTIATE_TEST_CASE_P(dilateTestFluid, DilateTest,
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(-1),
Values(IMGPROC_FLUID),
Values(AbsExact().to_compare_obj()),
@ -174,8 +151,7 @@ INSTANTIATE_TEST_CASE_P(dilateTestFluid, DilateTest,
INSTANTIATE_TEST_CASE_P(SobelTestFluid, SobelTest,
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(-1, CV_16S, CV_32F),
Values(IMGPROC_FLUID),
Values(AbsExact().to_compare_obj()),
@ -185,8 +161,7 @@ INSTANTIATE_TEST_CASE_P(SobelTestFluid, SobelTest,
INSTANTIATE_TEST_CASE_P(SobelTestFluid32F, SobelTest,
Combine(Values(CV_32FC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(CV_32F),
Values(IMGPROC_FLUID),
Values(ToleranceFilter(1e-4f, 0.01).to_compare_obj()),
@ -196,8 +171,7 @@ INSTANTIATE_TEST_CASE_P(SobelTestFluid32F, SobelTest,
INSTANTIATE_TEST_CASE_P(SobelXYTestFluid, SobelXYTest,
Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(-1, CV_16S, CV_32F),
Values(IMGPROC_FLUID),
Values(AbsExact().to_compare_obj()),
@ -208,8 +182,7 @@ INSTANTIATE_TEST_CASE_P(SobelXYTestFluid, SobelXYTest,
INSTANTIATE_TEST_CASE_P(SobelXYTestFluid32F, SobelXYTest,
Combine(Values(CV_32FC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(CV_32F),
Values(IMGPROC_FLUID),
Values(ToleranceFilter(1e-4f, 0.01).to_compare_obj()),
@ -220,8 +193,7 @@ INSTANTIATE_TEST_CASE_P(SobelXYTestFluid32F, SobelXYTest,
INSTANTIATE_TEST_CASE_P(boxFilterTestFluid32, BoxFilterTest,
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(-1, CV_32F),
Values(IMGPROC_FLUID),
Values(ToleranceFilter(1e-4f, 0.01).to_compare_obj()),
@ -230,8 +202,7 @@ INSTANTIATE_TEST_CASE_P(boxFilterTestFluid32, BoxFilterTest,
INSTANTIATE_TEST_CASE_P(sepFilterTestFluid, SepFilterTest,
Combine(Values(CV_32FC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(-1, CV_32F),
Values(IMGPROC_FLUID),
Values(ToleranceFilter(1e-4f, 0.01).to_compare_obj()),
@ -240,7 +211,6 @@ INSTANTIATE_TEST_CASE_P(sepFilterTestFluid, SepFilterTest,
INSTANTIATE_TEST_CASE_P(filter2DTestFluid, Filter2DTest,
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
Values(-1, CV_32F),
Values(IMGPROC_FLUID),

31
modules/gapi/test/cpu/gapi_operators_tests_cpu.cpp
View File

@ -12,6 +12,7 @@
namespace
{
#define CORE_CPU [] () { return cv::compile_args(cv::gapi::use_only{cv::gapi::core::cpu::kernels()}); }
const std::vector <cv::Size> in_sizes{ cv::Size(1280, 720), cv::Size(128, 128) };
} // anonymous namespace
namespace opencv_test
@ -19,21 +20,17 @@ namespace opencv_test
// FIXME: CPU test runs are disabled since Fluid is an exclusive plugin now!
INSTANTIATE_TEST_CASE_P(MathOperatorTestCPU, MathOperatorMatMatTest,
Combine(Values(CV_8UC1, CV_16SC1, CV_32FC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
Values(-1),
Values(CORE_CPU),
Values(AbsExact().to_compare_obj()),
Values( ADD, SUB, DIV,
Combine(Values(CV_8UC1, CV_16SC1, CV_32FC1),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_CPU),
Values(AbsExact().to_compare_obj()),
Values( ADD, SUB, DIV,
GT, LT, GE, LE, EQ, NE)));
INSTANTIATE_TEST_CASE_P(MathOperatorTestCPU, MathOperatorMatScalarTest,
Combine(Values(CV_8UC1, CV_16SC1, CV_32FC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_CPU),
Values(AbsExact().to_compare_obj()),
@ -44,9 +41,7 @@ INSTANTIATE_TEST_CASE_P(MathOperatorTestCPU, MathOperatorMatScalarTest,
INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestCPU, MathOperatorMatMatTest,
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_CPU),
Values(AbsExact().to_compare_obj()),
@ -54,9 +49,7 @@ INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestCPU, MathOperatorMatMatTest,
INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestCPU, MathOperatorMatScalarTest,
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_CPU),
Values(AbsExact().to_compare_obj()),
@ -65,9 +58,7 @@ INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestCPU, MathOperatorMatScalarTest,
INSTANTIATE_TEST_CASE_P(BitwiseNotOperatorTestCPU, NotOperatorTest,
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_CPU)));
}

31
modules/gapi/test/cpu/gapi_operators_tests_fluid.cpp
View File

@ -11,6 +11,7 @@
namespace
{
#define CORE_FLUID [] () { return cv::compile_args(cv::gapi::use_only{cv::gapi::core::fluid::kernels()}); }
const std::vector <cv::Size> in_sizes{ cv::Size(1280, 720), cv::Size(128, 128) };
} // anonymous namespace
namespace opencv_test
@ -18,9 +19,7 @@ namespace opencv_test
INSTANTIATE_TEST_CASE_P(MathOperatorTestFluid, MathOperatorMatMatTest,
Combine(Values(CV_8UC1, CV_16SC1, CV_32FC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_FLUID),
Values(AbsExact().to_compare_obj()),
@ -29,9 +28,7 @@ INSTANTIATE_TEST_CASE_P(MathOperatorTestFluid, MathOperatorMatMatTest,
INSTANTIATE_TEST_CASE_P(MathOperatorArithmeticTestFluid, MathOperatorMatScalarTest,
Combine(Values(CV_8UC1, CV_16SC1, CV_32FC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_FLUID),
Values(AbsExact().to_compare_obj()),
@ -41,9 +38,7 @@ INSTANTIATE_TEST_CASE_P(MathOperatorArithmeticTestFluid, MathOperatorMatScalarTe
// FIXME: solve comparison error
INSTANTIATE_TEST_CASE_P(MathOperatorCompareTestFluid, MathOperatorMatScalarTest,
Combine(Values(CV_8UC1, CV_16SC1, CV_32FC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_FLUID),
Values(AbsSimilarPoints(1, 0.01).to_compare_obj()),
@ -52,9 +47,7 @@ INSTANTIATE_TEST_CASE_P(MathOperatorCompareTestFluid, MathOperatorMatScalarTest,
INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestFluid, MathOperatorMatMatTest,
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_FLUID),
Values(AbsExact().to_compare_obj()),
@ -62,9 +55,7 @@ INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestFluid, MathOperatorMatMatTest,
INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestFluid, MathOperatorMatScalarTest,
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_FLUID),
Values(AbsExact().to_compare_obj()),
@ -72,10 +63,8 @@ INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestFluid, MathOperatorMatScalarTest,
ANDR, ORR, XORR )));
INSTANTIATE_TEST_CASE_P(BitwiseNotOperatorTestFluid, NotOperatorTest,
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
Values(-1),
Values(CORE_FLUID)));
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_FLUID)));
}

169
modules/gapi/test/gpu/gapi_core_tests_gpu.cpp
View File

@ -11,6 +11,7 @@
namespace
{
#define CORE_GPU [] () { return cv::compile_args(cv::gapi::use_only{cv::gapi::core::gpu::kernels()}); }
const std::vector <cv::Size> in_sizes{ cv::Size(1280, 720), cv::Size(128, 128) };
} // anonymous namespace
namespace opencv_test
@ -19,9 +20,7 @@ namespace opencv_test
// FIXME: Wut? See MulTestGPU/MathOpTest below (duplicate?)
INSTANTIATE_TEST_CASE_P(AddTestGPU, MathOpTest,
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values( -1, CV_8U, CV_16U, CV_32F ),
Values(CORE_GPU),
Values(ADD, MUL),
@ -31,9 +30,7 @@ INSTANTIATE_TEST_CASE_P(AddTestGPU, MathOpTest,
INSTANTIATE_TEST_CASE_P(MulTestGPU, MathOpTest,
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values( -1, CV_8U, CV_16U, CV_32F ),
Values(CORE_GPU),
Values(MUL),
@ -43,9 +40,7 @@ INSTANTIATE_TEST_CASE_P(MulTestGPU, MathOpTest,
INSTANTIATE_TEST_CASE_P(SubTestGPU, MathOpTest,
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values( -1, CV_8U, CV_16U, CV_32F ),
Values(CORE_GPU),
Values(SUB),
@ -65,9 +60,7 @@ INSTANTIATE_TEST_CASE_P(SubTestGPU, MathOpTest,
// Github ticket: https://github.com/opencv/opencv/issues/18373.
INSTANTIATE_TEST_CASE_P(DISABLED_DivTestGPU, MathOpTest,
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values( -1, CV_8U, CV_16U, CV_32F ),
Values(CORE_GPU),
Values(DIV),
@ -77,74 +70,56 @@ INSTANTIATE_TEST_CASE_P(DISABLED_DivTestGPU, MathOpTest,
INSTANTIATE_TEST_CASE_P(MulTestGPU, MulDoubleTest,
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values( -1, CV_8U, CV_16U, CV_32F ),
Values(CORE_GPU)));
INSTANTIATE_TEST_CASE_P(DivTestGPU, DivTest,
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values( -1, CV_8U, CV_16U, CV_32F ),
Values(CORE_GPU)));
INSTANTIATE_TEST_CASE_P(DivCTestGPU, DivCTest,
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values( -1, CV_8U, CV_16U, CV_32F ),
Values(CORE_GPU)));
INSTANTIATE_TEST_CASE_P(MeanTestGPU, MeanTest,
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_GPU)));
//TODO: mask test doesn't work
INSTANTIATE_TEST_CASE_P(DISABLED_MaskTestGPU, MaskTest,
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_GPU)));
INSTANTIATE_TEST_CASE_P(SelectTestGPU, SelectTest,
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_GPU)));
INSTANTIATE_TEST_CASE_P(Polar2CartGPU, Polar2CartTest,
Combine(Values(CV_32FC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(CV_32FC1),
Values(CORE_GPU)));
INSTANTIATE_TEST_CASE_P(Cart2PolarGPU, Cart2PolarTest,
Combine(Values(CV_32FC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(CV_32FC1),
Values(CORE_GPU)));
INSTANTIATE_TEST_CASE_P(CompareTestGPU, CmpTest,
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(CV_8U),
Values(CORE_GPU),
Values(CMP_EQ, CMP_GE, CMP_NE, CMP_GT, CMP_LT, CMP_LE),
@ -153,9 +128,7 @@ INSTANTIATE_TEST_CASE_P(CompareTestGPU, CmpTest,
INSTANTIATE_TEST_CASE_P(BitwiseTestGPU, BitwiseTest,
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_GPU),
Values(AND, OR, XOR),
@ -163,76 +136,58 @@ INSTANTIATE_TEST_CASE_P(BitwiseTestGPU, BitwiseTest,
INSTANTIATE_TEST_CASE_P(BitwiseNotTestGPU, NotTest,
Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_GPU)));
INSTANTIATE_TEST_CASE_P(DISABLED_MinTestGPU, MinTest,
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_GPU)));
INSTANTIATE_TEST_CASE_P(DISABLED_MaxTestGPU, MaxTest,
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_GPU)));
INSTANTIATE_TEST_CASE_P(SumTestGPU, SumTest,
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_GPU),
Values(AbsToleranceScalar(1e-5).to_compare_obj())));
INSTANTIATE_TEST_CASE_P(CountNonZeroTestGPU, CountNonZeroTest,
Combine(Values( CV_8UC1, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_GPU),
Values(AbsToleranceScalar(1e-5).to_compare_obj())));
INSTANTIATE_TEST_CASE_P(AbsDiffTestGPU, AbsDiffTest,
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_GPU)));
INSTANTIATE_TEST_CASE_P(AbsDiffCTestGPU, AbsDiffCTest,
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_GPU)));
INSTANTIATE_TEST_CASE_P(AddWeightedTestGPU, AddWeightedTest,
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values( -1, CV_8U, CV_16U, CV_32F ),
Values(CORE_GPU),
Values(Tolerance_FloatRel_IntAbs(1e-6, 1).to_compare_obj())));
INSTANTIATE_TEST_CASE_P(NormTestGPU, NormTest,
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_GPU),
Values(AbsToleranceScalar(1e-3).to_compare_obj()), //TODO: too relaxed?
@ -240,17 +195,13 @@ INSTANTIATE_TEST_CASE_P(NormTestGPU, NormTest,
INSTANTIATE_TEST_CASE_P(IntegralTestGPU, IntegralTest,
Combine(Values( CV_8UC1, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_GPU)));
INSTANTIATE_TEST_CASE_P(ThresholdTestGPU, ThresholdTest,
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_GPU),
Values(cv::THRESH_BINARY, cv::THRESH_BINARY_INV, cv::THRESH_TRUNC,
@ -261,9 +212,7 @@ INSTANTIATE_TEST_CASE_P(ThresholdTestGPU, ThresholdTest,
INSTANTIATE_TEST_CASE_P(ThresholdTestGPU, ThresholdOTTest,
Combine(Values(CV_8UC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_GPU),
Values(cv::THRESH_OTSU, cv::THRESH_TRIANGLE)));
@ -271,91 +220,69 @@ INSTANTIATE_TEST_CASE_P(ThresholdTestGPU, ThresholdOTTest,
INSTANTIATE_TEST_CASE_P(InRangeTestGPU, InRangeTest,
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_GPU)));
INSTANTIATE_TEST_CASE_P(Split3TestGPU, Split3Test,
Combine(Values(CV_8UC3),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(CV_8UC1),
Values(CORE_GPU)));
INSTANTIATE_TEST_CASE_P(Split4TestGPU, Split4Test,
Combine(Values(CV_8UC4),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(CV_8UC1),
Values(CORE_GPU)));
INSTANTIATE_TEST_CASE_P(Merge3TestGPU, Merge3Test,
Combine(Values(CV_8UC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(CV_8UC3),
Values(CORE_GPU)));
INSTANTIATE_TEST_CASE_P(Merge4TestGPU, Merge4Test,
Combine(Values(CV_8UC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(CV_8UC4),
Values(CORE_GPU)));
INSTANTIATE_TEST_CASE_P(RemapTestGPU, RemapTest,
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_GPU)));
INSTANTIATE_TEST_CASE_P(FlipTestGPU, FlipTest,
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_GPU),
Values(0,1,-1)));
INSTANTIATE_TEST_CASE_P(CropTestGPU, CropTest,
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_GPU),
Values(cv::Rect(10, 8, 20, 35), cv::Rect(4, 10, 37, 50))));
INSTANTIATE_TEST_CASE_P(LUTTestGPU, LUTTest,
Combine(Values(CV_8UC1, CV_8UC3),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(CV_8UC1),
Values(CORE_GPU)));
INSTANTIATE_TEST_CASE_P(LUTTestCustomGPU, LUTTest,
Combine(Values(CV_8UC3),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(CV_8UC3),
Values(CORE_GPU)));
INSTANTIATE_TEST_CASE_P(ConvertToGPU, ConvertToTest,
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(CV_8U, CV_16U, CV_16S, CV_32F),
Values(CORE_GPU),
Values(AbsExact().to_compare_obj()),
@ -364,17 +291,13 @@ INSTANTIATE_TEST_CASE_P(ConvertToGPU, ConvertToTest,
INSTANTIATE_TEST_CASE_P(ConcatHorTestGPU, ConcatHorTest,
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_GPU)));
INSTANTIATE_TEST_CASE_P(ConcatVertTestGPU, ConcatVertTest,
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_GPU)));
@ -382,9 +305,7 @@ INSTANTIATE_TEST_CASE_P(TransposeTestGPU, TransposeTest,
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1, CV_32FC1,
CV_8UC2, CV_16UC2, CV_16SC2, CV_32FC2,
CV_8UC3, CV_16UC3, CV_16SC3, CV_32FC3),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_GPU),
Values(AbsExact().to_compare_obj())));
@ -415,17 +336,13 @@ INSTANTIATE_TEST_CASE_P(ReInitOutTestGPU, ReInitOutTest,
//TODO: fix this backend to allow ConcatVertVec ConcatHorVec
INSTANTIATE_TEST_CASE_P(DISABLED_ConcatVertVecTestGPU, ConcatVertVecTest,
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_GPU)));
INSTANTIATE_TEST_CASE_P(DISABLED_ConcatHorVecTestGPU, ConcatHorVecTest,
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_GPU)));
}

88
modules/gapi/test/gpu/gapi_imgproc_tests_gpu.cpp
View File

@ -12,6 +12,7 @@
namespace
{
#define IMGPROC_GPU [] () { return cv::compile_args(cv::gapi::use_only{cv::gapi::imgproc::gpu::kernels()}); }
const std::vector <cv::Size> in_sizes{ cv::Size(1280, 720), cv::Size(128, 128) };
} // anonymous namespace
namespace opencv_test
@ -19,9 +20,7 @@ namespace opencv_test
INSTANTIATE_TEST_CASE_P(ResizeTestGPU, ResizeTest,
Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(IMGPROC_GPU),
Values(AbsSimilarPoints(2, 0.05).to_compare_obj()),
@ -31,9 +30,7 @@ INSTANTIATE_TEST_CASE_P(ResizeTestGPU, ResizeTest,
INSTANTIATE_TEST_CASE_P(ResizeTestGPU, ResizeTestFxFy,
Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(IMGPROC_GPU),
Values(AbsSimilarPoints(2, 0.05).to_compare_obj()),
@ -43,9 +40,7 @@ INSTANTIATE_TEST_CASE_P(ResizeTestGPU, ResizeTestFxFy,
INSTANTIATE_TEST_CASE_P(Filter2DTestGPU, Filter2DTest,
Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1, CV_32F),
Values(IMGPROC_GPU),
Values(Tolerance_FloatRel_IntAbs(1e-5, 2).to_compare_obj()),
@ -57,8 +52,7 @@ INSTANTIATE_TEST_CASE_P(Filter2DTestGPU, Filter2DTest,
INSTANTIATE_TEST_CASE_P(BoxFilterTestGPU, BoxFilterTest,
Combine(Values(/*CV_8UC1,*/ CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(-1, CV_32F),
Values(IMGPROC_GPU),
Values(Tolerance_FloatRel_IntAbs(1e-5, 2).to_compare_obj()),
@ -68,8 +62,7 @@ INSTANTIATE_TEST_CASE_P(BoxFilterTestGPU, BoxFilterTest,
INSTANTIATE_TEST_CASE_P(SepFilterTestGPU_8U, SepFilterTest,
Combine(Values(CV_8UC1, CV_8UC3),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(-1, CV_16S, CV_32F),
Values(IMGPROC_GPU),
Values(ToleranceFilter(1e-4f, 0.01).to_compare_obj()),
@ -77,8 +70,7 @@ INSTANTIATE_TEST_CASE_P(SepFilterTestGPU_8U, SepFilterTest,
INSTANTIATE_TEST_CASE_P(SepFilterTestGPU_other, SepFilterTest,
Combine(Values(CV_16UC1, CV_16SC1, CV_32FC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(-1, CV_32F),
Values(IMGPROC_GPU),
Values(ToleranceFilter(1e-4f, 0.01).to_compare_obj()),
@ -86,8 +78,7 @@ INSTANTIATE_TEST_CASE_P(SepFilterTestGPU_other, SepFilterTest,
INSTANTIATE_TEST_CASE_P(BlurTestGPU, BlurTest,
Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(-1),
Values(IMGPROC_GPU),
Values(Tolerance_FloatRel_IntAbs(1e-4, 2).to_compare_obj()),
@ -96,8 +87,7 @@ INSTANTIATE_TEST_CASE_P(BlurTestGPU, BlurTest,
INSTANTIATE_TEST_CASE_P(gaussBlurTestGPU, GaussianBlurTest,
Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(-1),
Values(IMGPROC_GPU),
Values(ToleranceFilter(1e-5f, 0.01).to_compare_obj()),
@ -105,8 +95,7 @@ INSTANTIATE_TEST_CASE_P(gaussBlurTestGPU, GaussianBlurTest,
INSTANTIATE_TEST_CASE_P(MedianBlurTestGPU, MedianBlurTest,
Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(-1),
Values(IMGPROC_GPU),
Values(AbsExact().to_compare_obj()),
@ -114,8 +103,7 @@ INSTANTIATE_TEST_CASE_P(MedianBlurTestGPU, MedianBlurTest,
INSTANTIATE_TEST_CASE_P(ErodeTestGPU, ErodeTest,
Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(-1),
Values(IMGPROC_GPU),
Values(AbsExact().to_compare_obj()),
@ -126,8 +114,7 @@ INSTANTIATE_TEST_CASE_P(ErodeTestGPU, ErodeTest,
INSTANTIATE_TEST_CASE_P(Erode3x3TestGPU, Erode3x3Test,
Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(-1),
Values(IMGPROC_GPU),
Values(AbsExact().to_compare_obj()),
@ -135,8 +122,7 @@ INSTANTIATE_TEST_CASE_P(Erode3x3TestGPU, Erode3x3Test,
INSTANTIATE_TEST_CASE_P(DilateTestGPU, DilateTest,
Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(-1),
Values(IMGPROC_GPU),
Values(AbsExact().to_compare_obj()),
@ -147,8 +133,7 @@ INSTANTIATE_TEST_CASE_P(DilateTestGPU, DilateTest,
INSTANTIATE_TEST_CASE_P(Dilate3x3TestGPU, Dilate3x3Test,
Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(-1),
Values(IMGPROC_GPU),
Values(AbsExact().to_compare_obj()),
@ -156,8 +141,7 @@ INSTANTIATE_TEST_CASE_P(Dilate3x3TestGPU, Dilate3x3Test,
INSTANTIATE_TEST_CASE_P(SobelTestGPU, SobelTest,
Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(-1, CV_16S, CV_32F),
Values(IMGPROC_GPU),
Values(Tolerance_FloatRel_IntAbs(1e-4, 2).to_compare_obj()),
@ -167,8 +151,7 @@ INSTANTIATE_TEST_CASE_P(SobelTestGPU, SobelTest,
INSTANTIATE_TEST_CASE_P(SobelTestGPU32F, SobelTest,
Combine(Values(CV_32FC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(CV_32F),
Values(IMGPROC_GPU),
Values(Tolerance_FloatRel_IntAbs(1e-4, 2).to_compare_obj()),
@ -178,8 +161,7 @@ INSTANTIATE_TEST_CASE_P(SobelTestGPU32F, SobelTest,
INSTANTIATE_TEST_CASE_P(LaplacianTestGPU, LaplacianTest,
Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(-1),
Values(IMGPROC_GPU),
Values(Tolerance_FloatRel_IntAbs(1e-4, 2).to_compare_obj()),
@ -189,8 +171,7 @@ INSTANTIATE_TEST_CASE_P(LaplacianTestGPU, LaplacianTest,
INSTANTIATE_TEST_CASE_P(BilateralFilterTestGPU, BilateralFilterTest,
Combine(Values(CV_32FC1, CV_32FC3, CV_8UC1, CV_8UC3),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(-1),
Values(IMGPROC_GPU),
Values(Tolerance_FloatRel_IntAbs(1e-4, 2).to_compare_obj()),
@ -201,16 +182,14 @@ INSTANTIATE_TEST_CASE_P(BilateralFilterTestGPU, BilateralFilterTest,
INSTANTIATE_TEST_CASE_P(EqHistTestGPU, EqHistTest,
Combine(Values(CV_8UC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(-1),
Values(IMGPROC_GPU),
Values(AbsExact().to_compare_obj()))); // FIXIT Non reliable check
INSTANTIATE_TEST_CASE_P(CannyTestGPU, CannyTest,
Combine(Values(CV_8UC1, CV_8UC3),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(CV_8UC1),
Values(IMGPROC_GPU),
Values(AbsSimilarPoints(0, 0.05).to_compare_obj()),
@ -221,72 +200,63 @@ INSTANTIATE_TEST_CASE_P(CannyTestGPU, CannyTest,
INSTANTIATE_TEST_CASE_P(RGB2GrayTestGPU, RGB2GrayTest,
Combine(Values(CV_8UC3),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(CV_8UC1),
Values(IMGPROC_GPU),
Values(ToleranceColor(1e-3).to_compare_obj())));
INSTANTIATE_TEST_CASE_P(BGR2GrayTestGPU, BGR2GrayTest,
Combine(Values(CV_8UC3),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(CV_8UC1),
Values(IMGPROC_GPU),
Values(ToleranceColor(1e-3).to_compare_obj())));
INSTANTIATE_TEST_CASE_P(RGB2YUVTestGPU, RGB2YUVTest,
Combine(Values(CV_8UC3),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(CV_8UC3),
Values(IMGPROC_GPU),
Values(ToleranceColor(1e-3).to_compare_obj())));
INSTANTIATE_TEST_CASE_P(YUV2RGBTestGPU, YUV2RGBTest,
Combine(Values(CV_8UC3),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(CV_8UC3),
Values(IMGPROC_GPU),
Values(ToleranceColor(1e-3).to_compare_obj())));
INSTANTIATE_TEST_CASE_P(RGB2LabTestGPU, RGB2LabTest,
Combine(Values(CV_8UC3),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(CV_8UC3),
Values(IMGPROC_GPU),
Values(AbsSimilarPoints(1, 0.05).to_compare_obj())));
INSTANTIATE_TEST_CASE_P(BGR2LUVTestGPU, BGR2LUVTest,
Combine(Values(CV_8UC3),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(CV_8UC3),
Values(IMGPROC_GPU),
Values(ToleranceColor(5e-3, 6).to_compare_obj())));
INSTANTIATE_TEST_CASE_P(LUV2BGRTestGPU, LUV2BGRTest,
Combine(Values(CV_8UC3),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(CV_8UC3),
Values(IMGPROC_GPU),
Values(ToleranceColor(1e-3).to_compare_obj())));
INSTANTIATE_TEST_CASE_P(BGR2YUVTestGPU, BGR2YUVTest,
Combine(Values(CV_8UC3),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(CV_8UC3),
Values(IMGPROC_GPU),
Values(ToleranceColor(1e-3).to_compare_obj())));
INSTANTIATE_TEST_CASE_P(YUV2BGRTestGPU, YUV2BGRTest,
Combine(Values(CV_8UC3),
Values(cv::Size(1280, 720),
cv::Size(640, 480)),
Values(cv::Size(1280, 720)),
Values(CV_8UC3),
Values(IMGPROC_GPU),
Values(ToleranceColor(1e-3).to_compare_obj())));

21
modules/gapi/test/gpu/gapi_operators_tests_gpu.cpp
View File

@ -11,6 +11,7 @@
namespace
{
#define CORE_GPU [] () { return cv::compile_args(cv::gapi::use_only{cv::gapi::core::gpu::kernels()}); }
const std::vector <cv::Size> in_sizes{ cv::Size(1280, 720), cv::Size(128, 128) };
} // anonymous namespace
namespace opencv_test
@ -18,9 +19,7 @@ namespace opencv_test
INSTANTIATE_TEST_CASE_P(MathOperatorTestGPU, MathOperatorMatMatTest,
Combine(Values(CV_8UC1, CV_16SC1, CV_32FC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_GPU),
Values(Tolerance_FloatRel_IntAbs(1e-5, 2).to_compare_obj()),
@ -29,9 +28,7 @@ INSTANTIATE_TEST_CASE_P(MathOperatorTestGPU, MathOperatorMatMatTest,
INSTANTIATE_TEST_CASE_P(MathOperatorTestGPU, MathOperatorMatScalarTest,
Combine(Values(CV_8UC1, CV_16SC1, CV_32FC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_GPU),
Values(Tolerance_FloatRel_IntAbs(1e-4, 2).to_compare_obj()),
@ -42,9 +39,7 @@ INSTANTIATE_TEST_CASE_P(MathOperatorTestGPU, MathOperatorMatScalarTest,
INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestGPU, MathOperatorMatMatTest,
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_GPU),
Values(AbsExact().to_compare_obj()),
@ -52,9 +47,7 @@ INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestGPU, MathOperatorMatMatTest,
INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestGPU, MathOperatorMatScalarTest,
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_GPU),
Values(AbsExact().to_compare_obj()),
@ -63,9 +56,7 @@ INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestGPU, MathOperatorMatScalarTest,
INSTANTIATE_TEST_CASE_P(BitwiseNotOperatorTestGPU, NotOperatorTest,
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
ValuesIn(in_sizes),
Values(-1),
Values(CORE_GPU)));
}