From c9bd43c0f670dc2ad781cd2bc6caafe5ed8e3716 Mon Sep 17 00:00:00 2001 From: Andrey Golubev Date: Tue, 16 Jul 2019 19:04:18 +0300 Subject: [PATCH] Merge pull request #14945 from andrey-golubev:delete_bool G-API: clean up accuracy tests (#14945) * Delete createOutputMatrices flag Update the way compile args function is created Fix instantiation suffix print function * Update comment (NB) * Make printable comparison functions * Use defines instead of objects for compile args * Remove custom printers, use operator<< overload * Remove SAME_TYPE and use -1 instead * Delete createOutputMatrices flag in new tests * Fix GetParam() printed values * Update Resize tests: use CompareF object * Address code review feedback * Add default cases for operator<< overloads * change throw to GAPI_Assert --- modules/gapi/test/common/gapi_core_tests.hpp | 122 ++++--------- .../gapi/test/common/gapi_core_tests_inl.hpp | 9 +- .../gapi/test/common/gapi_imgproc_tests.hpp | 60 +++---- .../gapi/test/common/gapi_operators_tests.hpp | 4 +- .../gapi/test/common/gapi_tests_common.hpp | 162 +++++++++++++++--- .../gapi/test/common/gapi_tests_helpers.hpp | 6 - modules/gapi/test/cpu/gapi_core_tests_cpu.cpp | 134 +++++---------- .../gapi/test/cpu/gapi_core_tests_fluid.cpp | 82 +++------ .../gapi/test/cpu/gapi_imgproc_tests_cpu.cpp | 115 +++++-------- .../test/cpu/gapi_imgproc_tests_fluid.cpp | 75 +++----- .../test/cpu/gapi_operators_tests_cpu.cpp | 17 +- .../test/cpu/gapi_operators_tests_fluid.cpp | 17 +- modules/gapi/test/gpu/gapi_core_tests_gpu.cpp | 111 ++++-------- .../gapi/test/gpu/gapi_imgproc_tests_gpu.cpp | 90 ++++------ .../test/gpu/gapi_operators_tests_gpu.cpp | 17 +- 15 files changed, 424 insertions(+), 597 deletions(-) diff --git a/modules/gapi/test/common/gapi_core_tests.hpp b/modules/gapi/test/common/gapi_core_tests.hpp index e01d3276e7..b249a4c944 100644 --- a/modules/gapi/test/common/gapi_core_tests.hpp +++ b/modules/gapi/test/common/gapi_core_tests.hpp @@ -30,91 +30,37 @@ enum bitwiseOp NOT = 3 }; -namespace +// Note: namespace must match the namespace of the type of the printed object +inline std::ostream& operator<<(std::ostream& os, mathOp op) { -const char *MathOperations[] = {"ADD", "SUB", "MUL", "DIV"}; -const char *BitwiseOperations[] = {"And", "Or", "Xor"}; -const char *CompareOperations[] = {"CMP_EQ", "CMP_GT", "CMP_GE", "CMP_LT", "CMP_LE", "CMP_NE"}; -//corresponds to OpenCV -const char *NormOperations[] = {"", "NORM_INF", "NORM_L1", "","NORM_L2"}; +#define CASE(v) case mathOp::v: os << #v; break + switch (op) + { + CASE(ADD); + CASE(SUB); + CASE(MUL); + CASE(DIV); + default: GAPI_Assert(false && "unknown mathOp value"); + } +#undef CASE + return os; } - -struct PrintMathOpCoreParams +// Note: namespace must match the namespace of the type of the printed object +inline std::ostream& operator<<(std::ostream& os, bitwiseOp op) { - template - std::string operator()(const ::testing::TestParamInfo& info) const +#define CASE(v) case bitwiseOp::v: os << #v; break + switch (op) { - std::stringstream ss; - using AllParams = Params; - const AllParams::params_t& params = info.param; - cv::Size sz = AllParams::getCommon<1>(params); // size - ss<(params)] // mathOp - <<"_"<(params) // testWithScalar - <<"_"<(params) // type - <<"_"<<(int)AllParams::getSpecific<2>(params) // scale - <<"_"<(params)+1) // dtype - <<"_"<(params) // createOutputMatrices - <<"_"<(params); // doReverseOp - return ss.str(); - } -}; - -struct PrintCmpCoreParams -{ - template - std::string operator()(const ::testing::TestParamInfo& info) const - { - std::stringstream ss; - using AllParams = Params; - const AllParams::params_t& params = info.param; - cv::Size sz = AllParams::getCommon<1>(params); // size - ss<(params)] // CmpType - <<"_"<(params) // testWithScalar - <<"_"<(params) // type - <<"_"<(params); // createOutputMatrices - return ss.str(); - } -}; - -struct PrintBWCoreParams -{ - template - std::string operator()(const ::testing::TestParamInfo& info) const - { - std::stringstream ss; - using AllParams = Params; - const AllParams::params_t& params = info.param; - cv::Size sz = AllParams::getCommon<1>(params); // size - ss<(params)] // bitwiseOp - <<"_"<(params) // type - <<"_"<(params); // createOutputMatrices - return ss.str(); - } -}; - -struct PrintNormCoreParams -{ - template - std::string operator()(const ::testing::TestParamInfo& info) const - { - std::stringstream ss; - using AllParams = Params; - const AllParams::params_t& params = info.param; - cv::Size sz = AllParams::getCommon<1>(params); // size - ss<(params)] // NormTypes - <<"_"<(params) // type - <<"_"<, 0) GAPI_TEST_FIXTURE(MaxTest, initMatsRandU, <>, 0) GAPI_TEST_FIXTURE(AbsDiffTest, initMatsRandU, <>, 0) GAPI_TEST_FIXTURE(AbsDiffCTest, initMatsRandU, <>, 0) -GAPI_TEST_FIXTURE(SumTest, initMatrixRandU, FIXTURE_API(compare_scalar_f), 1, cmpF) -GAPI_TEST_FIXTURE(AddWeightedTest, initMatsRandU, FIXTURE_API(compare_f), 1, cmpF) -GAPI_TEST_FIXTURE(NormTest, initMatrixRandU, FIXTURE_API(compare_scalar_f,NormTypes), 2, +GAPI_TEST_FIXTURE(SumTest, initMatrixRandU, FIXTURE_API(CompareScalars), 1, cmpF) +GAPI_TEST_FIXTURE(AddWeightedTest, initMatsRandU, FIXTURE_API(CompareMats), 1, cmpF) +GAPI_TEST_FIXTURE(NormTest, initMatrixRandU, FIXTURE_API(CompareScalars,NormTypes), 2, cmpF, opType) GAPI_TEST_FIXTURE(IntegralTest, initNothing, <>, 0) GAPI_TEST_FIXTURE(ThresholdTest, initMatrixRandU, FIXTURE_API(int), 1, tt) @@ -143,11 +89,11 @@ GAPI_TEST_FIXTURE(ThresholdOTTest, initMatrixRandU, FIXTURE_API(int), 1, tt) GAPI_TEST_FIXTURE(InRangeTest, initMatrixRandU, <>, 0) GAPI_TEST_FIXTURE(Split3Test, initMatrixRandU, <>, 0) GAPI_TEST_FIXTURE(Split4Test, initMatrixRandU, <>, 0) -GAPI_TEST_FIXTURE(ResizeTest, initNothing, FIXTURE_API(compare_f,int,cv::Size), 3, +GAPI_TEST_FIXTURE(ResizeTest, initNothing, FIXTURE_API(CompareMats,int,cv::Size), 3, cmpF, interp, sz_out) -GAPI_TEST_FIXTURE(ResizePTest, initNothing, FIXTURE_API(compare_f,int,cv::Size), 3, +GAPI_TEST_FIXTURE(ResizePTest, initNothing, FIXTURE_API(CompareMats,int,cv::Size), 3, cmpF, interp, sz_out) -GAPI_TEST_FIXTURE(ResizeTestFxFy, initNothing, FIXTURE_API(compare_f,int,double,double), 4, +GAPI_TEST_FIXTURE(ResizeTestFxFy, initNothing, FIXTURE_API(CompareMats,int,double,double), 4, cmpF, interp, fx, fy) GAPI_TEST_FIXTURE(Merge3Test, initMatsRandU, <>, 0) GAPI_TEST_FIXTURE(Merge4Test, initMatsRandU, <>, 0) @@ -159,11 +105,11 @@ GAPI_TEST_FIXTURE(ConcatVertTest, initNothing, <>, 0) GAPI_TEST_FIXTURE(ConcatVertVecTest, initNothing, <>, 0) GAPI_TEST_FIXTURE(ConcatHorVecTest, initNothing, <>, 0) GAPI_TEST_FIXTURE(LUTTest, initNothing, <>, 0) -GAPI_TEST_FIXTURE(ConvertToTest, initNothing, FIXTURE_API(compare_f, double, double), 3, +GAPI_TEST_FIXTURE(ConvertToTest, initNothing, FIXTURE_API(CompareMats, double, double), 3, cmpF, alpha, beta) GAPI_TEST_FIXTURE(PhaseTest, initMatsRandU, FIXTURE_API(bool), 1, angle_in_degrees) GAPI_TEST_FIXTURE(SqrtTest, initMatrixRandU, <>, 0) -GAPI_TEST_FIXTURE(NormalizeTest, initNothing, FIXTURE_API(compare_f,double,double,int,MatType), 5, +GAPI_TEST_FIXTURE(NormalizeTest, initNothing, FIXTURE_API(CompareMats,double,double,int,MatType2), 5, cmpF, a, b, norm_type, ddepth) struct BackendOutputAllocationTest : TestWithParamBase<> { diff --git a/modules/gapi/test/common/gapi_core_tests_inl.hpp b/modules/gapi/test/common/gapi_core_tests_inl.hpp index c5aef0fe19..e0408ddf77 100644 --- a/modules/gapi/test/common/gapi_core_tests_inl.hpp +++ b/modules/gapi/test/common/gapi_core_tests_inl.hpp @@ -269,7 +269,7 @@ TEST_P(Polar2CartTest, AccuracyTest) { cv::Mat out_mat2; cv::Mat out_mat_ocv2; - if(createOutputMatrices) + if (dtype != -1) { out_mat2 = cv::Mat(sz, dtype); out_mat_ocv2 = cv::Mat(sz, dtype); @@ -808,7 +808,8 @@ TEST_P(Split4Test, AccuracyTest) } } -static void ResizeAccuracyTest(compare_f cmpF, int type, int interp, cv::Size sz_in, cv::Size sz_out, double fx, double fy, cv::GCompileArgs&& compile_args) +static void ResizeAccuracyTest(const CompareMats& cmpF, int type, int interp, cv::Size sz_in, + cv::Size sz_out, double fx, double fy, cv::GCompileArgs&& compile_args) { cv::Mat in_mat1 (sz_in, type ); cv::Scalar mean = cv::Scalar::all(127); @@ -978,7 +979,7 @@ TEST_P(FlipTest, AccuracyTest) TEST_P(CropTest, AccuracyTest) { cv::Size sz_out = cv::Size(rect_to.width, rect_to.height); - if(createOutputMatrices) + if (dtype != -1) { out_mat_gapi = cv::Mat(sz_out, dtype); out_mat_ocv = cv::Mat(sz_out, dtype); @@ -1247,7 +1248,7 @@ TEST_P(SqrtTest, AccuracyTest) TEST_P(NormalizeTest, Test) { - initMatrixRandN(type, sz, CV_MAKETYPE(ddepth, CV_MAT_CN(type)), createOutputMatrices); + initMatrixRandN(type, sz, CV_MAKETYPE(ddepth, CV_MAT_CN(type))); // G-API code ////////////////////////////////////////////////////////////// cv::GMat in; diff --git a/modules/gapi/test/common/gapi_imgproc_tests.hpp b/modules/gapi/test/common/gapi_imgproc_tests.hpp index cf3e97aebc..bb75f820e6 100644 --- a/modules/gapi/test/common/gapi_imgproc_tests.hpp +++ b/modules/gapi/test/common/gapi_imgproc_tests.hpp @@ -14,45 +14,45 @@ namespace opencv_test { -GAPI_TEST_FIXTURE(Filter2DTest, initMatrixRandN, FIXTURE_API(compare_f,int,int), 3, +GAPI_TEST_FIXTURE(Filter2DTest, initMatrixRandN, FIXTURE_API(CompareMats,int,int), 3, cmpF, kernSize, borderType) -GAPI_TEST_FIXTURE(BoxFilterTest, initMatrixRandN, FIXTURE_API(compare_f,int,int), 3, +GAPI_TEST_FIXTURE(BoxFilterTest, initMatrixRandN, FIXTURE_API(CompareMats,int,int), 3, cmpF, filterSize, borderType) -GAPI_TEST_FIXTURE(SepFilterTest, initMatrixRandN, FIXTURE_API(compare_f,int), 2, cmpF, kernSize) -GAPI_TEST_FIXTURE(BlurTest, initMatrixRandN, FIXTURE_API(compare_f,int,int), 3, +GAPI_TEST_FIXTURE(SepFilterTest, initMatrixRandN, FIXTURE_API(CompareMats,int), 2, cmpF, kernSize) +GAPI_TEST_FIXTURE(BlurTest, initMatrixRandN, FIXTURE_API(CompareMats,int,int), 3, cmpF, filterSize, borderType) -GAPI_TEST_FIXTURE(GaussianBlurTest, initMatrixRandN, FIXTURE_API(compare_f,int), 2, cmpF, kernSize) -GAPI_TEST_FIXTURE(MedianBlurTest, initMatrixRandN, FIXTURE_API(compare_f,int), 2, cmpF, kernSize) -GAPI_TEST_FIXTURE(ErodeTest, initMatrixRandN, FIXTURE_API(compare_f,int,int), 3, +GAPI_TEST_FIXTURE(GaussianBlurTest, initMatrixRandN, FIXTURE_API(CompareMats,int), 2, cmpF, kernSize) +GAPI_TEST_FIXTURE(MedianBlurTest, initMatrixRandN, FIXTURE_API(CompareMats,int), 2, cmpF, kernSize) +GAPI_TEST_FIXTURE(ErodeTest, initMatrixRandN, FIXTURE_API(CompareMats,int,int), 3, cmpF, kernSize, kernType) -GAPI_TEST_FIXTURE(Erode3x3Test, initMatrixRandN, FIXTURE_API(compare_f,int), 2, +GAPI_TEST_FIXTURE(Erode3x3Test, initMatrixRandN, FIXTURE_API(CompareMats,int), 2, cmpF, numIters) -GAPI_TEST_FIXTURE(DilateTest, initMatrixRandN, FIXTURE_API(compare_f,int,int), 3, +GAPI_TEST_FIXTURE(DilateTest, initMatrixRandN, FIXTURE_API(CompareMats,int,int), 3, cmpF, kernSize, kernType) -GAPI_TEST_FIXTURE(Dilate3x3Test, initMatrixRandN, FIXTURE_API(compare_f,int), 2, cmpF, numIters) -GAPI_TEST_FIXTURE(SobelTest, initMatrixRandN, FIXTURE_API(compare_f,int,int,int), 4, +GAPI_TEST_FIXTURE(Dilate3x3Test, initMatrixRandN, FIXTURE_API(CompareMats,int), 2, cmpF, numIters) +GAPI_TEST_FIXTURE(SobelTest, initMatrixRandN, FIXTURE_API(CompareMats,int,int,int), 4, cmpF, kernSize, dx, dy) -GAPI_TEST_FIXTURE(SobelXYTest, initMatrixRandN, FIXTURE_API(compare_f,int,int,int,int), 5, +GAPI_TEST_FIXTURE(SobelXYTest, initMatrixRandN, FIXTURE_API(CompareMats,int,int,int,int), 5, cmpF, kernSize, order, border_type, border_val) -GAPI_TEST_FIXTURE(EqHistTest, initMatrixRandN, FIXTURE_API(compare_f), 1, cmpF) -GAPI_TEST_FIXTURE(CannyTest, initMatrixRandN, FIXTURE_API(compare_f,double,double,int,bool), 5, +GAPI_TEST_FIXTURE(EqHistTest, initMatrixRandN, FIXTURE_API(CompareMats), 1, cmpF) +GAPI_TEST_FIXTURE(CannyTest, initMatrixRandN, FIXTURE_API(CompareMats,double,double,int,bool), 5, cmpF, thrLow, thrUp, apSize, l2gr) -GAPI_TEST_FIXTURE(RGB2GrayTest, initMatrixRandN, FIXTURE_API(compare_f), 1, cmpF) -GAPI_TEST_FIXTURE(BGR2GrayTest, initMatrixRandN, FIXTURE_API(compare_f), 1, cmpF) -GAPI_TEST_FIXTURE(RGB2YUVTest, initMatrixRandN, FIXTURE_API(compare_f), 1, cmpF) -GAPI_TEST_FIXTURE(YUV2RGBTest, initMatrixRandN, FIXTURE_API(compare_f), 1, cmpF) -GAPI_TEST_FIXTURE(NV12toRGBTest, initMatrixRandN, FIXTURE_API(compare_f), 1, cmpF) -GAPI_TEST_FIXTURE(NV12toBGRpTest, initMatrixRandN, FIXTURE_API(compare_f), 1, cmpF) -GAPI_TEST_FIXTURE(NV12toRGBpTest, initMatrixRandN, FIXTURE_API(compare_f), 1, cmpF) -GAPI_TEST_FIXTURE(NV12toBGRTest, initMatrixRandN, FIXTURE_API(compare_f), 1, cmpF) -GAPI_TEST_FIXTURE(RGB2LabTest, initMatrixRandN, FIXTURE_API(compare_f), 1, cmpF) -GAPI_TEST_FIXTURE(BGR2LUVTest, initMatrixRandN, FIXTURE_API(compare_f), 1, cmpF) -GAPI_TEST_FIXTURE(LUV2BGRTest, initMatrixRandN, FIXTURE_API(compare_f), 1, cmpF) -GAPI_TEST_FIXTURE(BGR2YUVTest, initMatrixRandN, FIXTURE_API(compare_f), 1, cmpF) -GAPI_TEST_FIXTURE(YUV2BGRTest, initMatrixRandN, FIXTURE_API(compare_f), 1, cmpF) -GAPI_TEST_FIXTURE(RGB2HSVTest, initMatrixRandN, FIXTURE_API(compare_f), 1, cmpF) -GAPI_TEST_FIXTURE(BayerGR2RGBTest, initMatrixRandN, FIXTURE_API(compare_f), 1, cmpF) -GAPI_TEST_FIXTURE(RGB2YUV422Test, initMatrixRandN, FIXTURE_API(compare_f), 1, cmpF) +GAPI_TEST_FIXTURE(RGB2GrayTest, initMatrixRandN, FIXTURE_API(CompareMats), 1, cmpF) +GAPI_TEST_FIXTURE(BGR2GrayTest, initMatrixRandN, FIXTURE_API(CompareMats), 1, cmpF) +GAPI_TEST_FIXTURE(RGB2YUVTest, initMatrixRandN, FIXTURE_API(CompareMats), 1, cmpF) +GAPI_TEST_FIXTURE(YUV2RGBTest, initMatrixRandN, FIXTURE_API(CompareMats), 1, cmpF) +GAPI_TEST_FIXTURE(NV12toRGBTest, initMatrixRandN, FIXTURE_API(CompareMats), 1, cmpF) +GAPI_TEST_FIXTURE(NV12toBGRpTest, initMatrixRandN, FIXTURE_API(CompareMats), 1, cmpF) +GAPI_TEST_FIXTURE(NV12toRGBpTest, initMatrixRandN, FIXTURE_API(CompareMats), 1, cmpF) +GAPI_TEST_FIXTURE(NV12toBGRTest, initMatrixRandN, FIXTURE_API(CompareMats), 1, cmpF) +GAPI_TEST_FIXTURE(RGB2LabTest, initMatrixRandN, FIXTURE_API(CompareMats), 1, cmpF) +GAPI_TEST_FIXTURE(BGR2LUVTest, initMatrixRandN, FIXTURE_API(CompareMats), 1, cmpF) +GAPI_TEST_FIXTURE(LUV2BGRTest, initMatrixRandN, FIXTURE_API(CompareMats), 1, cmpF) +GAPI_TEST_FIXTURE(BGR2YUVTest, initMatrixRandN, FIXTURE_API(CompareMats), 1, cmpF) +GAPI_TEST_FIXTURE(YUV2BGRTest, initMatrixRandN, FIXTURE_API(CompareMats), 1, cmpF) +GAPI_TEST_FIXTURE(RGB2HSVTest, initMatrixRandN, FIXTURE_API(CompareMats), 1, cmpF) +GAPI_TEST_FIXTURE(BayerGR2RGBTest, initMatrixRandN, FIXTURE_API(CompareMats), 1, cmpF) +GAPI_TEST_FIXTURE(RGB2YUV422Test, initMatrixRandN, FIXTURE_API(CompareMats), 1, cmpF) } // opencv_test #endif //OPENCV_GAPI_IMGPROC_TESTS_HPP diff --git a/modules/gapi/test/common/gapi_operators_tests.hpp b/modules/gapi/test/common/gapi_operators_tests.hpp index f773709a8a..6cf4e5ed29 100644 --- a/modules/gapi/test/common/gapi_operators_tests.hpp +++ b/modules/gapi/test/common/gapi_operators_tests.hpp @@ -185,9 +185,9 @@ g_api_ocv_pair_mat_mat opXor = {std::string{"operator^"}, } // anonymous namespace GAPI_TEST_FIXTURE(MathOperatorMatScalarTest, initMatsRandU, - FIXTURE_API(compare_f, g_api_ocv_pair_mat_scalar), 2, cmpF, op) + FIXTURE_API(CompareMats, g_api_ocv_pair_mat_scalar), 2, cmpF, op) GAPI_TEST_FIXTURE(MathOperatorMatMatTest, initMatsRandU, - FIXTURE_API(compare_f, g_api_ocv_pair_mat_mat), 2, cmpF, op) + FIXTURE_API(CompareMats, g_api_ocv_pair_mat_mat), 2, cmpF, op) GAPI_TEST_FIXTURE(NotOperatorTest, initMatrixRandU, <>, 0) } // opencv_test diff --git a/modules/gapi/test/common/gapi_tests_common.hpp b/modules/gapi/test/common/gapi_tests_common.hpp index 9198a14536..3d3141feda 100644 --- a/modules/gapi/test/common/gapi_tests_common.hpp +++ b/modules/gapi/test/common/gapi_tests_common.hpp @@ -132,15 +132,33 @@ using compare_f = std::function; using compare_scalar_f = std::function; +// FIXME: re-use MatType. current problem: "special values" interpreted incorrectly (-1 is printed +// as 16FC512) +struct MatType2 +{ +public: + MatType2(int val = 0) : _value(val) {} + operator int() const { return _value; } + friend std::ostream& operator<<(std::ostream& os, const MatType2& t) + { + switch (t) + { + case -1: return os << "SAME_TYPE"; + default: PrintTo(MatType(t), &os); return os; + } + } +private: + int _value; +}; + // Universal parameter wrapper for common (pre-defined) and specific (user-defined) parameters template struct Params { using gcomp_args_function_t = cv::GCompileArgs(*)(); - // TODO: delete bool (createOutputMatrices) from common parameters - using common_params_t = std::tuple; + using common_params_t = std::tuple; using specific_params_t = std::tuple; - using params_t = std::tuple; + using params_t = std::tuple; static constexpr const size_t common_params_size = std::tuple_size::value; static constexpr const size_t specific_params_size = std::tuple_size::value; @@ -170,15 +188,9 @@ struct TestWithParamBase : TestFunctional, { using AllParams = Params; - MatType type = getCommonParam<0>(); + MatType2 type = getCommonParam<0>(); cv::Size sz = getCommonParam<1>(); - MatType dtype = getCommonParam<2>(); - bool createOutputMatrices = getCommonParam<3>(); - - TestWithParamBase() - { - if (dtype == SAME_TYPE) { dtype = type; } - } + MatType2 dtype = getCommonParam<2>(); // Get common (pre-defined) parameter value by index template @@ -199,7 +211,7 @@ struct TestWithParamBase : TestFunctional, // Return G-API compile arguments specified for test fixture inline cv::GCompileArgs getCompileArgs() const { - return getCommonParam<4>()(); + return getCommonParam<3>()(); } }; @@ -220,13 +232,35 @@ struct TestWithParamBase : TestFunctional, static_assert(Number == AllParams::specific_params_size, \ "Number of user-defined parameters doesn't match size of __VA_ARGS__"); \ __WRAP_VAARGS(DEFINE_SPECIFIC_PARAMS_##Number(__VA_ARGS__)) \ - Fixture() { InitF(type, sz, dtype, createOutputMatrices); } \ + Fixture() { InitF(type, sz, dtype); } \ }; // Wrapper for test fixture API. Use to specify multiple types. // Example: FIXTURE_API(int, bool) expands to #define FIXTURE_API(...) <__VA_ARGS__> +template +struct CompareF +{ + using callable_t = std::function; + CompareF(callable_t&& cmp, std::string&& cmp_name) : + _comparator(std::move(cmp)), _name(std::move(cmp_name)) {} + bool operator()(const T1& a, const T2& b) const + { + return _comparator(a, b); + } + friend std::ostream& operator<<(std::ostream& os, const CompareF& obj) + { + return os << obj._name; + } +private: + callable_t _comparator; + std::string _name; +}; + +using CompareMats = CompareF; +using CompareScalars = CompareF; + template struct Wrappable { @@ -238,6 +272,14 @@ struct Wrappable return t(a, b); }; } + + CompareMats to_compare_obj() + { + T t = *static_cast(this); + std::stringstream ss; + ss << t; + return CompareMats(to_compare_f(), ss.str()); + } }; template @@ -251,6 +293,14 @@ struct WrappableScalar return t(a, b); }; } + + CompareScalars to_compare_obj() + { + T t = *static_cast(this); + std::stringstream ss; + ss << t; + return CompareScalars(to_compare_f(), ss.str()); + } }; @@ -270,7 +320,10 @@ public: return true; } } -private: + friend std::ostream& operator<<(std::ostream& os, const AbsExact&) + { + return os << "AbsExact()"; + } }; class AbsTolerance : public Wrappable @@ -290,6 +343,10 @@ public: return true; } } + friend std::ostream& operator<<(std::ostream& os, const AbsTolerance& obj) + { + return os << "AbsTolerance(" << std::to_string(obj._tol) << ")"; + } private: double _tol; }; @@ -318,6 +375,10 @@ public: } } } + friend std::ostream& operator<<(std::ostream& os, const Tolerance_FloatRel_IntAbs& obj) + { + return os << "Tolerance_FloatRel_IntAbs(" << obj._tol << ", " << obj._tol8u << ")"; + } private: double _tol; double _tol8u; @@ -347,6 +408,10 @@ public: return true; } } + friend std::ostream& operator<<(std::ostream& os, const AbsSimilarPoints& obj) + { + return os << "AbsSimilarPoints(" << obj._tol << ", " << obj._percent << ")"; + } private: double _tol; double _percent; @@ -379,6 +444,11 @@ public: } return true; } + friend std::ostream& operator<<(std::ostream& os, const ToleranceFilter& obj) + { + return os << "ToleranceFilter(" << obj._tol << ", " << obj._tol8u << ", " + << obj._inf_tol << ")"; + } private: double _tol; double _tol8u; @@ -407,6 +477,10 @@ public: } return true; } + friend std::ostream& operator<<(std::ostream& os, const ToleranceColor& obj) + { + return os << "ToleranceColor(" << obj._tol << ", " << obj._inf_tol << ")"; + } private: double _tol; double _inf_tol; @@ -429,26 +503,66 @@ public: return true; } } + friend std::ostream& operator<<(std::ostream& os, const AbsToleranceScalar& obj) + { + return os << "AbsToleranceScalar(" << std::to_string(obj._tol) << ")"; + } private: double _tol; }; - } // namespace opencv_test namespace { - inline std::ostream& operator<<(std::ostream& os, const opencv_test::compare_f&) - { - return os << "compare_f"; - } +inline std::ostream& operator<<(std::ostream& os, const opencv_test::compare_f&) +{ + return os << "compare_f"; } -namespace +inline std::ostream& operator<<(std::ostream& os, const opencv_test::compare_scalar_f&) { - inline std::ostream& operator<<(std::ostream& os, const opencv_test::compare_scalar_f&) - { - return os << "compare_scalar_f"; - } + return os << "compare_scalar_f"; } +} // anonymous namespace + +// Note: namespace must match the namespace of the type of the printed object +namespace cv +{ +inline std::ostream& operator<<(std::ostream& os, CmpTypes op) +{ +#define CASE(v) case CmpTypes::v: os << #v; break + switch (op) + { + CASE(CMP_EQ); + CASE(CMP_GT); + CASE(CMP_GE); + CASE(CMP_LT); + CASE(CMP_LE); + CASE(CMP_NE); + default: GAPI_Assert(false && "unknown CmpTypes value"); + } +#undef CASE + return os; +} + +inline std::ostream& operator<<(std::ostream& os, NormTypes op) +{ +#define CASE(v) case NormTypes::v: os << #v; break + switch (op) + { + CASE(NORM_INF); + CASE(NORM_L1); + CASE(NORM_L2); + CASE(NORM_L2SQR); + CASE(NORM_HAMMING); + CASE(NORM_HAMMING2); + CASE(NORM_RELATIVE); + CASE(NORM_MINMAX); + default: GAPI_Assert(false && "unknown NormTypes value"); + } +#undef CASE + return os; +} +} // namespace cv #endif //OPENCV_GAPI_TESTS_COMMON_HPP diff --git a/modules/gapi/test/common/gapi_tests_helpers.hpp b/modules/gapi/test/common/gapi_tests_helpers.hpp index 0d849c2b34..db1083df0c 100644 --- a/modules/gapi/test/common/gapi_tests_helpers.hpp +++ b/modules/gapi/test/common/gapi_tests_helpers.hpp @@ -13,12 +13,6 @@ namespace opencv_test { -// out_type == in_type in matrices initialization if out_type is marked as SAME_TYPE -enum { - // TODO: why is it different from -1? - SAME_TYPE = std::numeric_limits::max() -}; - // Ensure correct __VA_ARGS__ expansion on Windows #define __WRAP_VAARGS(x) x diff --git a/modules/gapi/test/cpu/gapi_core_tests_cpu.cpp b/modules/gapi/test/cpu/gapi_core_tests_cpu.cpp index ce54ea759e..0aac763c4f 100644 --- a/modules/gapi/test/cpu/gapi_core_tests_cpu.cpp +++ b/modules/gapi/test/cpu/gapi_core_tests_cpu.cpp @@ -11,7 +11,7 @@ namespace { - #define CORE_CPU [] () { return cv::compile_args(cv::gapi::core::cpu::kernels()); } +#define CORE_CPU [] () { return cv::compile_args(cv::gapi::core::cpu::kernels()); } } // anonymous namespace namespace opencv_test @@ -24,13 +24,11 @@ INSTANTIATE_TEST_CASE_P(AddTestCPU, MathOpTest, cv::Size(640, 480), cv::Size(128, 128)), Values( -1, CV_8U, CV_16U, CV_32F ), -/*init output matrices or not*/ testing::Bool(), Values(CORE_CPU), Values(ADD, MUL), testing::Bool(), Values(1.0), - Values(false)), - opencv_test::PrintMathOpCoreParams()); + Values(false))); INSTANTIATE_TEST_CASE_P(MulTestCPU, MathOpTest, Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), @@ -38,13 +36,11 @@ INSTANTIATE_TEST_CASE_P(MulTestCPU, MathOpTest, cv::Size(640, 480), cv::Size(128, 128)), Values( -1, CV_8U, CV_16U, CV_32F ), -/*init output matrices or not*/ testing::Bool(), Values(CORE_CPU), Values(MUL), testing::Bool(), Values(1.0, 0.5, 2.0), - Values(false)), - opencv_test::PrintMathOpCoreParams()); + Values(false))); INSTANTIATE_TEST_CASE_P(SubTestCPU, MathOpTest, Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), @@ -52,13 +48,11 @@ INSTANTIATE_TEST_CASE_P(SubTestCPU, MathOpTest, cv::Size(640, 480), cv::Size(128, 128)), Values( -1, CV_8U, CV_16U, CV_32F ), -/*init output matrices or not*/ testing::Bool(), Values(CORE_CPU), Values(SUB), testing::Bool(), Values (1.0), - testing::Bool()), - opencv_test::PrintMathOpCoreParams()); + testing::Bool())); INSTANTIATE_TEST_CASE_P(DivTestCPU, MathOpTest, Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), @@ -66,13 +60,11 @@ INSTANTIATE_TEST_CASE_P(DivTestCPU, MathOpTest, cv::Size(640, 480), cv::Size(128, 128)), Values( -1, CV_8U, CV_16U, CV_32F ), -/*init output matrices or not*/ testing::Bool(), Values(CORE_CPU), Values(DIV), testing::Bool(), Values (1.0, 0.5, 2.0), - testing::Bool()), - opencv_test::PrintMathOpCoreParams()); + testing::Bool())); INSTANTIATE_TEST_CASE_P(MulTestCPU, MulDoubleTest, Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), @@ -80,7 +72,6 @@ INSTANTIATE_TEST_CASE_P(MulTestCPU, MulDoubleTest, cv::Size(640, 480), cv::Size(128, 128)), Values( -1, CV_8U, CV_16U, CV_32F ), -/*init output matrices or not*/ testing::Bool(), Values(CORE_CPU))); INSTANTIATE_TEST_CASE_P(DivTestCPU, DivTest, @@ -89,7 +80,6 @@ INSTANTIATE_TEST_CASE_P(DivTestCPU, DivTest, cv::Size(640, 480), cv::Size(128, 128)), Values( -1, CV_8U, CV_16U, CV_32F ), -/*init output matrices or not*/ testing::Bool(), Values(CORE_CPU))); INSTANTIATE_TEST_CASE_P(DivCTestCPU, DivCTest, @@ -98,7 +88,6 @@ INSTANTIATE_TEST_CASE_P(DivCTestCPU, DivCTest, cv::Size(640, 480), cv::Size(128, 128)), Values( -1, CV_8U, CV_16U, CV_32F ), -/*init output matrices or not*/ testing::Bool(), Values(CORE_CPU))); INSTANTIATE_TEST_CASE_P(MeanTestCPU, MeanTest, @@ -106,8 +95,7 @@ INSTANTIATE_TEST_CASE_P(MeanTestCPU, MeanTest, Values(cv::Size(1280, 720), cv::Size(640, 480), cv::Size(128, 128)), - Values(-1, SAME_TYPE), -/*init output matrices or not*/ testing::Bool(), + Values(-1), Values(CORE_CPU))); INSTANTIATE_TEST_CASE_P(MaskTestCPU, MaskTest, @@ -115,8 +103,7 @@ INSTANTIATE_TEST_CASE_P(MaskTestCPU, MaskTest, Values(cv::Size(1280, 720), cv::Size(640, 480), cv::Size(128, 128)), - Values(SAME_TYPE), -/*init output matrices or not*/ testing::Bool(), + Values(-1), Values(CORE_CPU))); INSTANTIATE_TEST_CASE_P(SelectTestCPU, SelectTest, @@ -124,8 +111,7 @@ INSTANTIATE_TEST_CASE_P(SelectTestCPU, SelectTest, Values(cv::Size(1280, 720), cv::Size(640, 480), cv::Size(128, 128)), - Values(SAME_TYPE), -/*init output matrices or not*/ testing::Bool(), + Values(-1), Values(CORE_CPU))); INSTANTIATE_TEST_CASE_P(Polar2CartCPU, Polar2CartTest, @@ -134,7 +120,6 @@ INSTANTIATE_TEST_CASE_P(Polar2CartCPU, Polar2CartTest, cv::Size(640, 480), cv::Size(128, 128)), Values(CV_32FC1), -/*init output matrices or not*/ testing::Bool(), Values(CORE_CPU))); INSTANTIATE_TEST_CASE_P(Cart2PolarCPU, Cart2PolarTest, @@ -143,7 +128,6 @@ INSTANTIATE_TEST_CASE_P(Cart2PolarCPU, Cart2PolarTest, cv::Size(640, 480), cv::Size(128, 128)), Values(CV_32FC1), -/*init output matrices or not*/ testing::Bool(), Values(CORE_CPU))); INSTANTIATE_TEST_CASE_P(PhaseCPU, PhaseTest, @@ -151,18 +135,16 @@ INSTANTIATE_TEST_CASE_P(PhaseCPU, PhaseTest, Values(cv::Size(1280, 720), cv::Size(640, 480), cv::Size(128, 128)), - Values(SAME_TYPE), - Values(true), + Values(-1), Values(CORE_CPU), - testing::Bool())); + /* 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)), - Values(SAME_TYPE), - Values(true), + Values(-1), Values(CORE_CPU))); INSTANTIATE_TEST_CASE_P(CompareTestCPU, CmpTest, @@ -171,30 +153,25 @@ INSTANTIATE_TEST_CASE_P(CompareTestCPU, CmpTest, cv::Size(640, 480), cv::Size(128, 128)), Values(CV_8U), -/*init output matrices or not*/ testing::Bool(), Values(CORE_CPU), Values(CMP_EQ, CMP_GE, CMP_NE, CMP_GT, CMP_LT, CMP_LE), - testing::Bool()), - opencv_test::PrintCmpCoreParams()); + testing::Bool())); 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)), - Values(SAME_TYPE), -/*init output matrices or not*/ testing::Bool(), + Values(-1), Values(CORE_CPU), - Values(AND, OR, XOR)), - opencv_test::PrintBWCoreParams()); + Values(AND, OR, XOR))); INSTANTIATE_TEST_CASE_P(BitwiseNotTestCPU, NotTest, 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)), - Values(SAME_TYPE), -/*init output matrices or not*/ testing::Bool(), + Values(-1), Values(CORE_CPU))); INSTANTIATE_TEST_CASE_P(MinTestCPU, MinTest, @@ -202,8 +179,7 @@ INSTANTIATE_TEST_CASE_P(MinTestCPU, MinTest, Values(cv::Size(1280, 720), cv::Size(640, 480), cv::Size(128, 128)), - Values(SAME_TYPE), -/*init output matrices or not*/ testing::Bool(), + Values(-1), Values(CORE_CPU))); INSTANTIATE_TEST_CASE_P(MaxTestCPU, MaxTest, @@ -211,8 +187,7 @@ INSTANTIATE_TEST_CASE_P(MaxTestCPU, MaxTest, Values(cv::Size(1280, 720), cv::Size(640, 480), cv::Size(128, 128)), - Values(SAME_TYPE), -/*init output matrices or not*/ testing::Bool(), + Values(-1), Values(CORE_CPU))); INSTANTIATE_TEST_CASE_P(SumTestCPU, SumTest, @@ -220,19 +195,17 @@ INSTANTIATE_TEST_CASE_P(SumTestCPU, SumTest, Values(cv::Size(1280, 720), cv::Size(640, 480), cv::Size(128, 128)), - Values(SAME_TYPE), -/*init output matrices or not*/ testing::Bool(), + Values(-1), //Values(1e-5), Values(CORE_CPU), - Values(AbsToleranceScalar(1e-5).to_compare_f()))); + 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)), - Values(SAME_TYPE), -/*init output matrices or not*/ testing::Bool(), + Values(-1), Values(CORE_CPU))); INSTANTIATE_TEST_CASE_P(AbsDiffCTestCPU, AbsDiffCTest, @@ -240,8 +213,7 @@ INSTANTIATE_TEST_CASE_P(AbsDiffCTestCPU, AbsDiffCTest, Values(cv::Size(1280, 720), cv::Size(640, 480), cv::Size(128, 128)), - Values(SAME_TYPE), -/*init output matrices or not*/ testing::Bool(), + Values(-1), Values(CORE_CPU))); INSTANTIATE_TEST_CASE_P(AddWeightedTestCPU, AddWeightedTest, @@ -250,22 +222,18 @@ INSTANTIATE_TEST_CASE_P(AddWeightedTestCPU, AddWeightedTest, cv::Size(640, 480), cv::Size(128, 128)), Values( -1, CV_8U, CV_16U, CV_32F ), -/*init output matrices or not*/ testing::Bool(), Values(CORE_CPU), - Values(Tolerance_FloatRel_IntAbs(1e-6, 1).to_compare_f()))); + 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)), - Values(SAME_TYPE), - Values(false), - //Values(1e-5), + Values(-1), Values(CORE_CPU), - Values(AbsToleranceScalar(1e-5).to_compare_f()), - Values(NORM_INF, NORM_L1, NORM_L2)), - opencv_test::PrintNormCoreParams()); + Values(AbsToleranceScalar(1e-5).to_compare_obj()), + Values(NORM_INF, NORM_L1, NORM_L2))); INSTANTIATE_TEST_CASE_P(IntegralTestCPU, IntegralTest, Combine(Values( CV_8UC1, CV_16UC1, CV_16SC1, CV_32FC1 ), @@ -273,7 +241,6 @@ INSTANTIATE_TEST_CASE_P(IntegralTestCPU, IntegralTest, cv::Size(640, 480), cv::Size(128, 128)), Values(-1), - Values(false), Values(CORE_CPU))); INSTANTIATE_TEST_CASE_P(ThresholdTestCPU, ThresholdTest, @@ -281,8 +248,7 @@ INSTANTIATE_TEST_CASE_P(ThresholdTestCPU, ThresholdTest, Values(cv::Size(1280, 720), cv::Size(640, 480), cv::Size(128, 128)), - Values(SAME_TYPE), -/*init output matrices or not*/ testing::Bool(), + Values(-1), Values(CORE_CPU), Values(cv::THRESH_BINARY, cv::THRESH_BINARY_INV, cv::THRESH_TRUNC, cv::THRESH_TOZERO, cv::THRESH_TOZERO_INV))); @@ -292,8 +258,7 @@ INSTANTIATE_TEST_CASE_P(ThresholdTestCPU, ThresholdOTTest, Values(cv::Size(1280, 720), cv::Size(640, 480), cv::Size(128, 128)), - Values(SAME_TYPE), -/*init output matrices or not*/ testing::Bool(), + Values(-1), Values(CORE_CPU), Values(cv::THRESH_OTSU, cv::THRESH_TRIANGLE))); @@ -303,8 +268,7 @@ INSTANTIATE_TEST_CASE_P(InRangeTestCPU, InRangeTest, Values(cv::Size(1280, 720), cv::Size(640, 480), cv::Size(128, 128)), - Values(SAME_TYPE), -/*init output matrices or not*/ testing::Bool(), + Values(-1), Values(CORE_CPU))); INSTANTIATE_TEST_CASE_P(Split3TestCPU, Split3Test, @@ -313,7 +277,6 @@ INSTANTIATE_TEST_CASE_P(Split3TestCPU, Split3Test, cv::Size(640, 480), cv::Size(128, 128)), Values(CV_8UC1), - Values(true), Values(CORE_CPU))); INSTANTIATE_TEST_CASE_P(Split4TestCPU, Split4Test, @@ -322,7 +285,6 @@ INSTANTIATE_TEST_CASE_P(Split4TestCPU, Split4Test, cv::Size(640, 480), cv::Size(128, 128)), Values(CV_8UC1), - Values(true), Values(CORE_CPU))); INSTANTIATE_TEST_CASE_P(ResizeTestCPU, ResizeTest, @@ -331,9 +293,8 @@ INSTANTIATE_TEST_CASE_P(ResizeTestCPU, ResizeTest, cv::Size(640, 480), cv::Size(128, 128)), Values(-1), - Values(false), Values(CORE_CPU), - Values(AbsSimilarPoints(2, 0.05).to_compare_f()), + Values(AbsSimilarPoints(2, 0.05).to_compare_obj()), Values(cv::INTER_NEAREST, cv::INTER_LINEAR, cv::INTER_AREA), Values(cv::Size(64,64), cv::Size(30,30)))); @@ -344,9 +305,8 @@ INSTANTIATE_TEST_CASE_P(ResizePTestCPU, ResizePTest, cv::Size(640, 480), cv::Size(128, 128)), Values(-1), - Values(false), Values(CORE_CPU), - Values(AbsSimilarPoints(2, 0.05).to_compare_f()), + Values(AbsSimilarPoints(2, 0.05).to_compare_obj()), Values(cv::INTER_LINEAR), Values(cv::Size(64,64), cv::Size(30,30)))); @@ -357,9 +317,8 @@ INSTANTIATE_TEST_CASE_P(ResizeTestCPU, ResizeTestFxFy, cv::Size(640, 480), cv::Size(128, 128)), Values(-1), - Values(false), Values(CORE_CPU), - Values(AbsSimilarPoints(2, 0.05).to_compare_f()), + Values(AbsSimilarPoints(2, 0.05).to_compare_obj()), Values(cv::INTER_NEAREST, cv::INTER_LINEAR, cv::INTER_AREA), Values(0.5, 0.1), Values(0.5, 0.1))); @@ -370,7 +329,6 @@ INSTANTIATE_TEST_CASE_P(Merge3TestCPU, Merge3Test, cv::Size(640, 480), cv::Size(128, 128)), Values(CV_8UC3), - Values(true), Values(CORE_CPU))); INSTANTIATE_TEST_CASE_P(Merge4TestCPU, Merge4Test, @@ -379,7 +337,6 @@ INSTANTIATE_TEST_CASE_P(Merge4TestCPU, Merge4Test, cv::Size(640, 480), cv::Size(128, 128)), Values(CV_8UC4), - Values(true), Values(CORE_CPU))); INSTANTIATE_TEST_CASE_P(RemapTestCPU, RemapTest, @@ -387,8 +344,7 @@ INSTANTIATE_TEST_CASE_P(RemapTestCPU, RemapTest, Values(cv::Size(1280, 720), cv::Size(640, 480), cv::Size(128, 128)), - Values(SAME_TYPE), -/*init output matrices or not*/ testing::Bool(), + Values(-1), Values(CORE_CPU))); INSTANTIATE_TEST_CASE_P(FlipTestCPU, FlipTest, @@ -396,8 +352,7 @@ INSTANTIATE_TEST_CASE_P(FlipTestCPU, FlipTest, Values(cv::Size(1280, 720), cv::Size(640, 480), cv::Size(128, 128)), - Values(SAME_TYPE), -/*init output matrices or not*/ Values(false), + Values(-1), Values(CORE_CPU), Values(0,1,-1))); @@ -406,8 +361,7 @@ INSTANTIATE_TEST_CASE_P(CropTestCPU, CropTest, Values(cv::Size(1280, 720), cv::Size(640, 480), cv::Size(128, 128)), - Values(SAME_TYPE), -/*init output matrices or not*/ Values(false), + Values(-1), Values(CORE_CPU), Values(cv::Rect(10, 8, 20, 35), cv::Rect(4, 10, 37, 50)))); @@ -417,7 +371,6 @@ INSTANTIATE_TEST_CASE_P(LUTTestCPU, LUTTest, cv::Size(640, 480), cv::Size(128, 128)), Values(CV_8UC1), -/*init output matrices or not*/ Values(true), Values(CORE_CPU))); INSTANTIATE_TEST_CASE_P(LUTTestCustomCPU, LUTTest, @@ -426,7 +379,6 @@ INSTANTIATE_TEST_CASE_P(LUTTestCustomCPU, LUTTest, cv::Size(640, 480), cv::Size(128, 128)), Values(CV_8UC3), -/*init output matrices or not*/ Values(true), Values(CORE_CPU))); INSTANTIATE_TEST_CASE_P(ConvertToCPU, ConvertToTest, @@ -435,9 +387,8 @@ INSTANTIATE_TEST_CASE_P(ConvertToCPU, ConvertToTest, cv::Size(640, 480), cv::Size(128, 128)), Values(CV_8U, CV_16U, CV_16S, CV_32F), - Values(false), Values(CORE_CPU), - Values(AbsExact().to_compare_f()), + Values(AbsExact().to_compare_obj()), Values(2.5, 1.0, -1.0), Values(250.0, 0.0, -128.0))); @@ -446,8 +397,7 @@ INSTANTIATE_TEST_CASE_P(ConcatHorTestCPU, ConcatHorTest, Values(cv::Size(1280, 720), cv::Size(640, 480), cv::Size(128, 128)), - Values(SAME_TYPE), - Values(false), + Values(-1), Values(CORE_CPU))); INSTANTIATE_TEST_CASE_P(ConcatVertTestCPU, ConcatVertTest, @@ -455,8 +405,7 @@ INSTANTIATE_TEST_CASE_P(ConcatVertTestCPU, ConcatVertTest, Values(cv::Size(1280, 720), cv::Size(640, 480), cv::Size(128, 128)), - Values(SAME_TYPE), - Values(false), + Values(-1), Values(CORE_CPU))); INSTANTIATE_TEST_CASE_P(ConcatVertVecTestCPU, ConcatVertVecTest, @@ -464,8 +413,7 @@ INSTANTIATE_TEST_CASE_P(ConcatVertVecTestCPU, ConcatVertVecTest, Values(cv::Size(1280, 720), cv::Size(640, 480), cv::Size(128, 128)), - Values(SAME_TYPE), - Values(false), + Values(-1), Values(CORE_CPU))); INSTANTIATE_TEST_CASE_P(ConcatHorVecTestCPU, ConcatHorVecTest, @@ -473,8 +421,7 @@ INSTANTIATE_TEST_CASE_P(ConcatHorVecTestCPU, ConcatHorVecTest, Values(cv::Size(1280, 720), cv::Size(640, 480), cv::Size(128, 128)), - Values(SAME_TYPE), - Values(false), + Values(-1), Values(CORE_CPU))); INSTANTIATE_TEST_CASE_P(NormalizeTestCPU, NormalizeTest, @@ -482,9 +429,8 @@ INSTANTIATE_TEST_CASE_P(NormalizeTestCPU, NormalizeTest, Values(cv::Size(1280, 720), cv::Size(640, 480)), Values(-1), -/*init output matrices or not*/ testing::Bool(), Values(CORE_CPU), - Values(AbsExact().to_compare_f()), + Values(AbsExact().to_compare_obj()), Values(0.0, 15.0), Values(1.0, 120.0, 255.0), Values(NORM_MINMAX, NORM_INF, NORM_L1, NORM_L2), diff --git a/modules/gapi/test/cpu/gapi_core_tests_fluid.cpp b/modules/gapi/test/cpu/gapi_core_tests_fluid.cpp index 818eddccf1..d989f31734 100644 --- a/modules/gapi/test/cpu/gapi_core_tests_fluid.cpp +++ b/modules/gapi/test/cpu/gapi_core_tests_fluid.cpp @@ -10,7 +10,7 @@ namespace { - #define CORE_FLUID [] () { return cv::compile_args(cv::gapi::core::fluid::kernels()); } +#define CORE_FLUID [] () { return cv::compile_args(cv::gapi::core::fluid::kernels()); } } // anonymous namespace namespace opencv_test @@ -24,13 +24,11 @@ INSTANTIATE_TEST_CASE_P(MathOpTestFluid, MathOpTest, cv::Size(640, 480), cv::Size(128, 128)), Values(-1, CV_8U, CV_32F), - testing::Bool(), Values(CORE_FLUID), Values(ADD, SUB, DIV, MUL), testing::Bool(), Values(1.0), - testing::Bool()), - opencv_test::PrintMathOpCoreParams()); + testing::Bool())); INSTANTIATE_TEST_CASE_P(MulSTestFluid, MulDoubleTest, Combine(Values(CV_8UC1, CV_16SC1, CV_32FC1), @@ -38,7 +36,6 @@ INSTANTIATE_TEST_CASE_P(MulSTestFluid, MulDoubleTest, cv::Size(640, 480), cv::Size(128, 128)), Values(-1), // FIXME: extend with more types - testing::Bool(), Values(CORE_FLUID))); INSTANTIATE_TEST_CASE_P(DivCTestFluid, DivCTest, @@ -47,7 +44,6 @@ INSTANTIATE_TEST_CASE_P(DivCTestFluid, DivCTest, cv::Size(640, 480), cv::Size(128, 128)), Values(CV_8U, CV_32F), - testing::Bool(), Values(CORE_FLUID))); INSTANTIATE_TEST_CASE_P(AbsDiffTestFluid, AbsDiffTest, @@ -55,8 +51,7 @@ INSTANTIATE_TEST_CASE_P(AbsDiffTestFluid, AbsDiffTest, Values(cv::Size(1280, 720), cv::Size(640, 480), cv::Size(128, 128)), - Values(SAME_TYPE), - testing::Bool(), + Values(-1), Values(CORE_FLUID))); INSTANTIATE_TEST_CASE_P(AbsDiffCTestFluid, AbsDiffCTest, @@ -64,8 +59,7 @@ INSTANTIATE_TEST_CASE_P(AbsDiffCTestFluid, AbsDiffCTest, Values(cv::Size(1280, 720), cv::Size(640, 480), cv::Size(128, 128)), - Values(SAME_TYPE), - testing::Bool(), + Values(-1), Values(CORE_FLUID))); INSTANTIATE_TEST_CASE_P(BitwiseTestFluid, BitwiseTest, @@ -74,11 +68,9 @@ INSTANTIATE_TEST_CASE_P(BitwiseTestFluid, BitwiseTest, cv::Size(1280, 720), cv::Size(640, 480), cv::Size(128, 128)), - Values(SAME_TYPE), - testing::Bool(), + Values(-1), Values(CORE_FLUID), - Values(AND, OR, XOR)), - opencv_test::PrintBWCoreParams()); + Values(AND, OR, XOR))); INSTANTIATE_TEST_CASE_P(BitwiseNotTestFluid, NotTest, Combine(Values(CV_8UC3, CV_8UC1, CV_16UC1, CV_16SC1), @@ -86,8 +78,7 @@ INSTANTIATE_TEST_CASE_P(BitwiseNotTestFluid, NotTest, cv::Size(1280, 720), cv::Size(640, 480), cv::Size(128, 128)), - Values(SAME_TYPE), - testing::Bool(), + Values(-1), Values(CORE_FLUID))); INSTANTIATE_TEST_CASE_P(MinTestFluid, MinTest, @@ -96,8 +87,7 @@ INSTANTIATE_TEST_CASE_P(MinTestFluid, MinTest, cv::Size(1280, 720), cv::Size(640, 480), cv::Size(128, 128)), - Values(SAME_TYPE), - testing::Bool(), + Values(-1), Values(CORE_FLUID))); INSTANTIATE_TEST_CASE_P(MaxTestFluid, MaxTest, @@ -106,8 +96,7 @@ INSTANTIATE_TEST_CASE_P(MaxTestFluid, MaxTest, cv::Size(1280, 720), cv::Size(640, 480), cv::Size(128, 128)), - Values(SAME_TYPE), - testing::Bool(), + Values(-1), Values(CORE_FLUID))); INSTANTIATE_TEST_CASE_P(CompareTestFluid, CmpTest, @@ -117,11 +106,9 @@ INSTANTIATE_TEST_CASE_P(CompareTestFluid, CmpTest, cv::Size(640, 480), cv::Size(128, 128)), Values(CV_8U), - testing::Bool(), Values(CORE_FLUID), Values(CMP_EQ, CMP_GE, CMP_NE, CMP_GT, CMP_LT, CMP_LE), - testing::Bool()), - opencv_test::PrintCmpCoreParams()); + testing::Bool())); INSTANTIATE_TEST_CASE_P(AddWeightedTestFluid, AddWeightedTest, Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1), @@ -129,10 +116,8 @@ INSTANTIATE_TEST_CASE_P(AddWeightedTestFluid, AddWeightedTest, cv::Size(640, 480), cv::Size(128, 128)), Values(-1, CV_8U, CV_32F), - testing::Bool(), - //Values(0.5000005), Values(CORE_FLUID), - Values(Tolerance_FloatRel_IntAbs(1e-5, 2).to_compare_f()))); + Values(Tolerance_FloatRel_IntAbs(1e-5, 2).to_compare_obj()))); INSTANTIATE_TEST_CASE_P(LUTTestFluid, LUTTest, Combine(Values(CV_8UC1, CV_8UC3), @@ -141,7 +126,6 @@ INSTANTIATE_TEST_CASE_P(LUTTestFluid, LUTTest, cv::Size(640, 480), cv::Size(128, 128)), Values(CV_8UC1), -/*init output matrices or not*/ Values(true), Values(CORE_FLUID))); INSTANTIATE_TEST_CASE_P(ConvertToFluid, ConvertToTest, @@ -151,9 +135,8 @@ INSTANTIATE_TEST_CASE_P(ConvertToFluid, ConvertToTest, cv::Size(640, 480), cv::Size(128, 128)), Values(CV_8U, CV_16U, CV_32F), - Values(true), Values(CORE_FLUID), - Values(Tolerance_FloatRel_IntAbs(1e-5, 2).to_compare_f()), + Values(Tolerance_FloatRel_IntAbs(1e-5, 2).to_compare_obj()), Values(2.5, 1.0, -1.0), Values(250.0, 0.0, -128.0))); @@ -163,7 +146,6 @@ INSTANTIATE_TEST_CASE_P(Split3TestFluid, Split3Test, cv::Size(640, 480), cv::Size(128, 128)), Values(CV_8UC1), - Values(true), Values(CORE_FLUID))); INSTANTIATE_TEST_CASE_P(Split4TestFluid, Split4Test, @@ -172,7 +154,6 @@ INSTANTIATE_TEST_CASE_P(Split4TestFluid, Split4Test, cv::Size(640, 480), cv::Size(128, 128)), Values(CV_8UC1), - Values(true), Values(CORE_FLUID))); INSTANTIATE_TEST_CASE_P(Merge3TestFluid, Merge3Test, @@ -182,7 +163,6 @@ INSTANTIATE_TEST_CASE_P(Merge3TestFluid, Merge3Test, cv::Size(640, 480), cv::Size(128, 128)), Values(CV_8UC3), - Values(true), Values(CORE_FLUID))); INSTANTIATE_TEST_CASE_P(Merge4TestFluid, Merge4Test, @@ -192,7 +172,6 @@ INSTANTIATE_TEST_CASE_P(Merge4TestFluid, Merge4Test, cv::Size(640, 480), cv::Size(128, 128)), Values(CV_8UC4), - Values(true), Values(CORE_FLUID))); INSTANTIATE_TEST_CASE_P(SelectTestFluid, SelectTest, @@ -201,8 +180,7 @@ INSTANTIATE_TEST_CASE_P(SelectTestFluid, SelectTest, cv::Size(1280, 720), cv::Size(640, 480), cv::Size(128, 128)), - Values(SAME_TYPE), - testing::Bool(), + Values(-1), Values(CORE_FLUID))); INSTANTIATE_TEST_CASE_P(Polar2CartFluid, Polar2CartTest, @@ -211,7 +189,6 @@ INSTANTIATE_TEST_CASE_P(Polar2CartFluid, Polar2CartTest, cv::Size(640, 480), cv::Size(128, 128)), Values(CV_32FC1), - testing::Bool(), Values(CORE_FLUID))); INSTANTIATE_TEST_CASE_P(Cart2PolarFluid, Cart2PolarTest, @@ -220,7 +197,6 @@ INSTANTIATE_TEST_CASE_P(Cart2PolarFluid, Cart2PolarTest, cv::Size(640, 480), cv::Size(128, 128)), Values(CV_32FC1), - testing::Bool(), Values(CORE_FLUID))); INSTANTIATE_TEST_CASE_P(PhaseFluid, PhaseTest, @@ -228,18 +204,16 @@ INSTANTIATE_TEST_CASE_P(PhaseFluid, PhaseTest, Values(cv::Size(1280, 720), cv::Size(640, 480), cv::Size(128, 128)), - Values(SAME_TYPE), - Values(true), + Values(-1), Values(CORE_FLUID), - testing::Bool())); + /* 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)), - Values(SAME_TYPE), - Values(true), + Values(-1), Values(CORE_FLUID))); INSTANTIATE_TEST_CASE_P(ThresholdTestFluid, ThresholdTest, @@ -248,8 +222,7 @@ INSTANTIATE_TEST_CASE_P(ThresholdTestFluid, ThresholdTest, cv::Size(1280, 720), cv::Size(640, 480), cv::Size(128, 128)), - Values(SAME_TYPE), - testing::Bool(), + Values(-1), Values(CORE_FLUID), Values(cv::THRESH_BINARY, cv::THRESH_BINARY_INV, cv::THRESH_TRUNC, @@ -261,8 +234,7 @@ INSTANTIATE_TEST_CASE_P(InRangeTestFluid, InRangeTest, cv::Size(1280, 720), cv::Size(640, 480), cv::Size(128, 128)), - Values(SAME_TYPE), - testing::Bool(), + Values(-1), Values(CORE_FLUID))); INSTANTIATE_TEST_CASE_P(ResizeTestFluid, ResizeTest, @@ -273,9 +245,8 @@ INSTANTIATE_TEST_CASE_P(ResizeTestFluid, ResizeTest, cv::Size(64, 64), cv::Size(30, 30)), Values(-1), - Values(false), Values(CORE_FLUID), - Values(AbsExact().to_compare_f()), + Values(AbsExact().to_compare_obj()), Values(/*cv::INTER_NEAREST,*/ cv::INTER_LINEAR/*, cv::INTER_AREA*/), Values(cv::Size(1280, 720), cv::Size(640, 480), @@ -310,8 +281,7 @@ INSTANTIATE_TEST_CASE_P(MathOpTestCPU, MathOpTest, cv::Size(128, 128)), Values(-1, CV_8U, CV_32F), /*init output matrices or not*/ testing::Bool(), - Values(false)), - opencv_test::PrintMathOpCoreParams()); + Values(false))); INSTANTIATE_TEST_CASE_P(SubTestCPU, MathOpTest, Combine(Values(SUB), @@ -322,8 +292,7 @@ INSTANTIATE_TEST_CASE_P(SubTestCPU, MathOpTest, cv::Size(128, 128)), Values(-1, CV_8U, CV_32F), /*init output matrices or not*/ testing::Bool(), - testing::Bool()), - opencv_test::PrintMathOpCoreParams()); + testing::Bool())); INSTANTIATE_TEST_CASE_P(MulSTestCPU, MulSTest, Combine(Values(CV_8UC1, CV_16SC1, CV_32FC1), @@ -373,8 +342,7 @@ INSTANTIATE_TEST_CASE_P(CompareTestCPU, CmpTest, Values(cv::Size(1280, 720), cv::Size(640, 480), cv::Size(128, 128)), -/*init output matrices or not*/ testing::Bool()), - opencv_test::PrintCmpCoreParams()); +/*init output matrices or not*/ testing::Bool())); INSTANTIATE_TEST_CASE_P(BitwiseTestCPU, BitwiseTest, Combine(Values(AND, OR, XOR), @@ -382,8 +350,7 @@ INSTANTIATE_TEST_CASE_P(BitwiseTestCPU, BitwiseTest, Values(cv::Size(1280, 720), cv::Size(640, 480), cv::Size(128, 128)), -/*init output matrices or not*/ testing::Bool()), - opencv_test::PrintBWCoreParams()); +/*init output matrices or not*/ testing::Bool())); INSTANTIATE_TEST_CASE_P(BitwiseNotTestCPU, NotTest, Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1), @@ -443,8 +410,7 @@ INSTANTIATE_TEST_CASE_P(NormTestCPU, NormTest, Values(cv::Size(1280, 720), cv::Size(640, 480), cv::Size(128, 128))), - Values(0.0), - opencv_test::PrintNormCoreParams()); + Values(0.0)); INSTANTIATE_TEST_CASE_P(IntegralTestCPU, IntegralTest, Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1), diff --git a/modules/gapi/test/cpu/gapi_imgproc_tests_cpu.cpp b/modules/gapi/test/cpu/gapi_imgproc_tests_cpu.cpp index 0c95bd1dc7..77622b87ce 100644 --- a/modules/gapi/test/cpu/gapi_imgproc_tests_cpu.cpp +++ b/modules/gapi/test/cpu/gapi_imgproc_tests_cpu.cpp @@ -12,7 +12,7 @@ namespace { - #define IMGPROC_CPU [] () { return cv::compile_args(cv::gapi::imgproc::cpu::kernels()); } +#define IMGPROC_CPU [] () { return cv::compile_args(cv::gapi::imgproc::cpu::kernels()); } } // anonymous namespace namespace opencv_test @@ -24,9 +24,8 @@ INSTANTIATE_TEST_CASE_P(Filter2DTestCPU, Filter2DTest, cv::Size(640, 480), cv::Size(128, 128)), Values(-1, CV_32F), - testing::Bool(), Values(IMGPROC_CPU), - Values(AbsExact().to_compare_f()), + Values(AbsExact().to_compare_obj()), Values(3, 4, 5, 7), Values(cv::BORDER_DEFAULT))); @@ -35,9 +34,8 @@ INSTANTIATE_TEST_CASE_P(BoxFilterTestCPU, BoxFilterTest, Values(cv::Size(1280, 720), cv::Size(640, 480)), Values(-1, CV_32F), - testing::Bool(), Values(IMGPROC_CPU), - Values(AbsTolerance(0).to_compare_f()), + Values(AbsTolerance(0).to_compare_obj()), Values(3,5), Values(cv::BORDER_DEFAULT))); @@ -46,9 +44,8 @@ INSTANTIATE_TEST_CASE_P(SepFilterTestCPU_8U, SepFilterTest, Values(cv::Size(1280, 720), cv::Size(640, 480)), Values(-1, CV_16S, CV_32F), - testing::Bool(), Values(IMGPROC_CPU), - Values(AbsExact().to_compare_f()), + Values(AbsExact().to_compare_obj()), Values(3))); INSTANTIATE_TEST_CASE_P(SepFilterTestCPU_other, SepFilterTest, @@ -56,19 +53,17 @@ INSTANTIATE_TEST_CASE_P(SepFilterTestCPU_other, SepFilterTest, Values(cv::Size(1280, 720), cv::Size(640, 480)), Values(-1, CV_32F), - testing::Bool(), Values(IMGPROC_CPU), - Values(AbsExact().to_compare_f()), + Values(AbsExact().to_compare_obj()), Values(3))); 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(SAME_TYPE), -/*init output matrices or not*/ testing::Bool(), + Values(-1), Values(IMGPROC_CPU), - Values(AbsTolerance(0.0).to_compare_f()), + Values(AbsTolerance(0.0).to_compare_obj()), Values(3,5), Values(cv::BORDER_DEFAULT))); @@ -76,30 +71,27 @@ 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(SAME_TYPE), -/*init output matrices or not*/ testing::Bool(), + Values(-1), Values(IMGPROC_CPU), - Values(AbsExact().to_compare_f()), + Values(AbsExact().to_compare_obj()), Values(3, 5))); 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(SAME_TYPE), -/*init output matrices or not*/ testing::Bool(), + Values(-1), Values(IMGPROC_CPU), - Values(AbsExact().to_compare_f()), + Values(AbsExact().to_compare_obj()), Values(3, 5))); 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(SAME_TYPE), -/*init output matrices or not*/ testing::Bool(), + Values(-1), Values(IMGPROC_CPU), - Values(AbsExact().to_compare_f()), + Values(AbsExact().to_compare_obj()), Values(3, 5), Values(cv::MorphShapes::MORPH_RECT, cv::MorphShapes::MORPH_CROSS, @@ -109,20 +101,18 @@ 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(SAME_TYPE), -/*init output matrices or not*/ testing::Bool(), + Values(-1), Values(IMGPROC_CPU), - Values(AbsExact().to_compare_f()), + Values(AbsExact().to_compare_obj()), Values(1,2,4))); 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(SAME_TYPE), -/*init output matrices or not*/ testing::Bool(), + Values(-1), Values(IMGPROC_CPU), - Values(AbsExact().to_compare_f()), + Values(AbsExact().to_compare_obj()), Values(3, 5), Values(cv::MorphShapes::MORPH_RECT, cv::MorphShapes::MORPH_CROSS, @@ -132,10 +122,9 @@ 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(SAME_TYPE), -/*init output matrices or not*/ testing::Bool(), + Values(-1), Values(IMGPROC_CPU), - Values(AbsExact().to_compare_f()), + Values(AbsExact().to_compare_obj()), Values(1,2,4))); INSTANTIATE_TEST_CASE_P(SobelTestCPU, SobelTest, @@ -143,9 +132,8 @@ INSTANTIATE_TEST_CASE_P(SobelTestCPU, SobelTest, Values(cv::Size(1280, 720), cv::Size(640, 480)), Values(-1, CV_16S, CV_32F), -/*init output matrices or not*/ testing::Bool(), Values(IMGPROC_CPU), - Values(AbsExact().to_compare_f()), + Values(AbsExact().to_compare_obj()), Values(3, 5), Values(0, 1), Values(1, 2))); @@ -155,9 +143,8 @@ INSTANTIATE_TEST_CASE_P(SobelTestCPU32F, SobelTest, Values(cv::Size(1280, 720), cv::Size(640, 480)), Values(CV_32F), -/*init output matrices or not*/ testing::Bool(), Values(IMGPROC_CPU), - Values(AbsExact().to_compare_f()), + Values(AbsExact().to_compare_obj()), Values(3, 5), Values(0, 1), Values(1, 2))); @@ -167,9 +154,8 @@ INSTANTIATE_TEST_CASE_P(SobelXYTestCPU, SobelXYTest, Values(cv::Size(1280, 720), cv::Size(640, 480)), Values(-1, CV_16S, CV_32F), - Values(true), Values(IMGPROC_CPU), - Values(AbsExact().to_compare_f()), + Values(AbsExact().to_compare_obj()), Values(3, 5), Values(1, 2), Values(BORDER_CONSTANT, BORDER_REPLICATE, BORDER_REFLECT), @@ -180,9 +166,8 @@ INSTANTIATE_TEST_CASE_P(SobelXYTestCPU32F, SobelXYTest, Values(cv::Size(1280, 720), cv::Size(640, 480)), Values(CV_32F), - Values(true), Values(IMGPROC_CPU), - Values(AbsExact().to_compare_f()), + Values(AbsExact().to_compare_obj()), Values(3, 5), Values(1, 2), Values(BORDER_CONSTANT, BORDER_REPLICATE, BORDER_REFLECT), @@ -193,18 +178,16 @@ INSTANTIATE_TEST_CASE_P(EqHistTestCPU, EqHistTest, Values(cv::Size(1280, 720), cv::Size(640, 480)), Values(CV_8UC1), -/*init output matrices or not*/ testing::Bool(), Values(IMGPROC_CPU), - Values(AbsExact().to_compare_f()))); + 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_8UC1), -/*init output matrices or not*/ testing::Bool(), Values(IMGPROC_CPU), - Values(AbsSimilarPoints(0, 0.05).to_compare_f()), + Values(AbsSimilarPoints(0, 0.05).to_compare_obj()), Values(3.0, 120.0), Values(125.0, 240.0), Values(3, 5), @@ -215,142 +198,126 @@ INSTANTIATE_TEST_CASE_P(RGB2GrayTestCPU, RGB2GrayTest, Values(cv::Size(1280, 720), cv::Size(640, 480)), Values(CV_8UC1), -/*init output matrices or not*/ testing::Bool(), Values(IMGPROC_CPU), - Values(AbsExact().to_compare_f()))); + 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_8UC1), -/*init output matrices or not*/ testing::Bool(), Values(IMGPROC_CPU), - Values(AbsExact().to_compare_f()))); + 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_8UC3), -/*init output matrices or not*/ testing::Bool(), Values(IMGPROC_CPU), - Values(AbsExact().to_compare_f()))); + 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_8UC3), -/*init output matrices or not*/ testing::Bool(), Values(IMGPROC_CPU), - Values(AbsExact().to_compare_f()))); + 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_8UC3), - Values(true), Values(IMGPROC_CPU), - Values(AbsExact().to_compare_f()))); + 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_8UC3), - Values(true), Values(IMGPROC_CPU), - Values(AbsExact().to_compare_f()))); + 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_8UC3), - Values(true), Values(IMGPROC_CPU), - Values(AbsExact().to_compare_f()))); + 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_8UC3), - Values(true), Values(IMGPROC_CPU), - Values(AbsExact().to_compare_f()))); + 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_8UC3), -/*init output matrices or not*/ testing::Bool(), Values(IMGPROC_CPU), - Values(AbsExact().to_compare_f()))); + 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_8UC3), -/*init output matrices or not*/ testing::Bool(), Values(IMGPROC_CPU), - Values(AbsExact().to_compare_f()))); + 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_8UC3), -/*init output matrices or not*/ testing::Bool(), Values(IMGPROC_CPU), - Values(AbsExact().to_compare_f()))); + 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_8UC3), -/*init output matrices or not*/ testing::Bool(), Values(IMGPROC_CPU), - Values(AbsExact().to_compare_f()))); + 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_8UC3), -/*init output matrices or not*/ testing::Bool(), Values(IMGPROC_CPU), - Values(AbsExact().to_compare_f()))); + 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_8UC3), -/*init output matrices or not*/ testing::Bool(), Values(IMGPROC_CPU), - Values(AbsExact().to_compare_f()))); + 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_8UC3), -/*init output matrices or not*/ testing::Bool(), Values(IMGPROC_CPU), - Values(AbsExact().to_compare_f()))); + 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_8UC2), -/*init output matrices or not*/ testing::Bool(), Values(IMGPROC_CPU), - Values(AbsTolerance(1).to_compare_f()))); + Values(AbsTolerance(1).to_compare_obj()))); } // opencv_test diff --git a/modules/gapi/test/cpu/gapi_imgproc_tests_fluid.cpp b/modules/gapi/test/cpu/gapi_imgproc_tests_fluid.cpp index 71f8ee74d0..99c36c4661 100644 --- a/modules/gapi/test/cpu/gapi_imgproc_tests_fluid.cpp +++ b/modules/gapi/test/cpu/gapi_imgproc_tests_fluid.cpp @@ -10,7 +10,7 @@ namespace { - #define IMGPROC_FLUID [] () { return cv::compile_args(cv::gapi::imgproc::fluid::kernels()); } +#define IMGPROC_FLUID [] () { return cv::compile_args(cv::gapi::imgproc::fluid::kernels()); } } // anonymous namespace namespace opencv_test @@ -21,45 +21,40 @@ INSTANTIATE_TEST_CASE_P(RGB2GrayTestFluid, RGB2GrayTest, Values(cv::Size(1280, 720), cv::Size(640, 480)), Values(CV_8UC1), - Values(true, false), Values(IMGPROC_FLUID), - Values(ToleranceColor(1e-3).to_compare_f()))); + 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_8UC1), - Values(true, false), Values(IMGPROC_FLUID), - Values(ToleranceColor(1e-3).to_compare_f()))); + 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_8UC3), - Values(true, false), Values(IMGPROC_FLUID), - Values(ToleranceColor(1e-3).to_compare_f()))); + 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_8UC3), - Values(true, false), Values(IMGPROC_FLUID), - Values(ToleranceColor(1e-3).to_compare_f()))); + 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_8UC3), - Values(true, false), Values(IMGPROC_FLUID), - Values(AbsSimilarPoints(1, 0.05).to_compare_f()))); + Values(AbsSimilarPoints(1, 0.05).to_compare_obj()))); // FIXME: Not supported by Fluid yet (no kernel implemented) INSTANTIATE_TEST_CASE_P(BGR2LUVTestFluid, BGR2LUVTest, @@ -67,45 +62,40 @@ INSTANTIATE_TEST_CASE_P(BGR2LUVTestFluid, BGR2LUVTest, Values(cv::Size(1280, 720), cv::Size(640, 480)), Values(CV_8UC3), - Values(true, false), Values(IMGPROC_FLUID), - Values(ToleranceColor(5e-3, 6).to_compare_f()))); + 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_8UC3), - Values(true, false), Values(IMGPROC_FLUID), - Values(ToleranceColor(1e-3).to_compare_f()))); + 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_8UC3), - Values(true, false), Values(IMGPROC_FLUID), - Values(ToleranceColor(1e-3).to_compare_f()))); + 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_8UC2), - Values(true, false), Values(IMGPROC_FLUID), - Values(AbsTolerance(1).to_compare_f()))); + 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(SAME_TYPE), - Values(true, false), + Values(-1), Values(IMGPROC_FLUID), - Values(ToleranceFilter(1e-4f, 0.01).to_compare_f()), + Values(ToleranceFilter(1e-4f, 0.01).to_compare_obj()), Values(3), // add kernel size=5 when implementation is ready Values(cv::BORDER_DEFAULT))); @@ -113,30 +103,27 @@ INSTANTIATE_TEST_CASE_P(gaussBlurTestFluid, GaussianBlurTest, Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1), Values(cv::Size(1280, 720), cv::Size(640, 480)), - Values(SAME_TYPE), - Values(true, false), + Values(-1), Values(IMGPROC_FLUID), - Values(ToleranceFilter(1e-3f, 0.01).to_compare_f()), + Values(ToleranceFilter(1e-3f, 0.01).to_compare_obj()), Values(3))); // add kernel size=5 when implementation is ready INSTANTIATE_TEST_CASE_P(medianBlurTestFluid, MedianBlurTest, Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1), Values(cv::Size(1280, 720), cv::Size(640, 480)), - Values(SAME_TYPE), - Values(true, false), + Values(-1), Values(IMGPROC_FLUID), - Values(AbsExact().to_compare_f()), + Values(AbsExact().to_compare_obj()), Values(3))); // add kernel size=5 when implementation is ready INSTANTIATE_TEST_CASE_P(erodeTestFluid, ErodeTest, Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1), Values(cv::Size(1280, 720), cv::Size(640, 480)), - Values(SAME_TYPE), - Values(true, false), + Values(-1), Values(IMGPROC_FLUID), - Values(AbsExact().to_compare_f()), + Values(AbsExact().to_compare_obj()), Values(3), // add kernel size=5 when implementation is ready Values(cv::MorphShapes::MORPH_RECT, cv::MorphShapes::MORPH_CROSS, @@ -146,10 +133,9 @@ INSTANTIATE_TEST_CASE_P(dilateTestFluid, DilateTest, Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1), Values(cv::Size(1280, 720), cv::Size(640, 480)), - Values(SAME_TYPE), - Values(true, false), + Values(-1), Values(IMGPROC_FLUID), - Values(AbsExact().to_compare_f()), + Values(AbsExact().to_compare_obj()), Values(3), // add kernel size=5 when implementation is ready Values(cv::MorphShapes::MORPH_RECT, cv::MorphShapes::MORPH_CROSS, @@ -160,9 +146,8 @@ INSTANTIATE_TEST_CASE_P(SobelTestFluid, SobelTest, Values(cv::Size(1280, 720), cv::Size(640, 480)), Values(-1, CV_16S, CV_32F), - Values(true, false), Values(IMGPROC_FLUID), - Values(AbsExact().to_compare_f()), + Values(AbsExact().to_compare_obj()), Values(3), // add kernel size=5 when implementation is ready Values(0, 1), Values(1, 2))); @@ -172,9 +157,8 @@ INSTANTIATE_TEST_CASE_P(SobelTestFluid32F, SobelTest, Values(cv::Size(1280, 720), cv::Size(640, 480)), Values(CV_32F), - Values(true, false), Values(IMGPROC_FLUID), - Values(ToleranceFilter(1e-4f, 0.01).to_compare_f()), + Values(ToleranceFilter(1e-4f, 0.01).to_compare_obj()), Values(3), // add kernel size=5 when implementation is ready Values(0, 1), Values(1, 2))); @@ -184,9 +168,8 @@ INSTANTIATE_TEST_CASE_P(SobelXYTestFluid, SobelXYTest, Values(cv::Size(1280, 720), cv::Size(640, 480)), Values(-1, CV_16S, CV_32F), - Values(true), Values(IMGPROC_FLUID), - Values(AbsExact().to_compare_f()), + Values(AbsExact().to_compare_obj()), Values(3), Values(1, 2), Values(BORDER_CONSTANT, BORDER_REPLICATE, BORDER_REFLECT_101), @@ -197,9 +180,8 @@ INSTANTIATE_TEST_CASE_P(SobelXYTestFluid32F, SobelXYTest, Values(cv::Size(1280, 720), cv::Size(640, 480)), Values(CV_32F), - Values(true), Values(IMGPROC_FLUID), - Values(ToleranceFilter(1e-4f, 0.01).to_compare_f()), + Values(ToleranceFilter(1e-4f, 0.01).to_compare_obj()), Values(3), Values(1, 2), Values(BORDER_CONSTANT, BORDER_REPLICATE, BORDER_REFLECT_101), @@ -210,9 +192,8 @@ INSTANTIATE_TEST_CASE_P(boxFilterTestFluid32, BoxFilterTest, Values(cv::Size(1280, 720), cv::Size(640, 480)), Values(-1, CV_32F), - Values(true, false), Values(IMGPROC_FLUID), - Values(ToleranceFilter(1e-4f, 0.01).to_compare_f()), + Values(ToleranceFilter(1e-4f, 0.01).to_compare_obj()), Values(3), // add kernel size=5 when implementation is ready Values(cv::BORDER_DEFAULT))); @@ -221,9 +202,8 @@ INSTANTIATE_TEST_CASE_P(sepFilterTestFluid, SepFilterTest, Values(cv::Size(1280, 720), cv::Size(640, 480)), Values(-1, CV_32F), - testing::Bool(), Values(IMGPROC_FLUID), - Values(ToleranceFilter(1e-4f, 0.01).to_compare_f()), + Values(ToleranceFilter(1e-4f, 0.01).to_compare_obj()), Values(3))); // add kernel size=5 when implementation is ready INSTANTIATE_TEST_CASE_P(filter2DTestFluid, Filter2DTest, @@ -232,9 +212,8 @@ INSTANTIATE_TEST_CASE_P(filter2DTestFluid, Filter2DTest, cv::Size(640, 480), cv::Size(128, 128)), Values(-1, CV_32F), - testing::Bool(), Values(IMGPROC_FLUID), - Values(ToleranceFilter(1e-4f, 0.01).to_compare_f()), + Values(ToleranceFilter(1e-4f, 0.01).to_compare_obj()), Values(3), // add kernel size=4,5,7 when implementation ready Values(cv::BORDER_DEFAULT))); diff --git a/modules/gapi/test/cpu/gapi_operators_tests_cpu.cpp b/modules/gapi/test/cpu/gapi_operators_tests_cpu.cpp index 71d4af8275..14817557b4 100644 --- a/modules/gapi/test/cpu/gapi_operators_tests_cpu.cpp +++ b/modules/gapi/test/cpu/gapi_operators_tests_cpu.cpp @@ -11,7 +11,7 @@ namespace { - #define CORE_CPU [] () { return cv::compile_args(cv::gapi::core::cpu::kernels()); } +#define CORE_CPU [] () { return cv::compile_args(cv::gapi::core::cpu::kernels()); } } // anonymous namespace namespace opencv_test @@ -24,9 +24,8 @@ INSTANTIATE_TEST_CASE_P(MathOperatorTestCPU, MathOperatorMatMatTest, cv::Size(640, 480), cv::Size(128, 128)), Values(-1, CV_8U, CV_32F), - testing::Bool(), Values(CORE_CPU), - Values(AbsExact().to_compare_f()), + Values(AbsExact().to_compare_obj()), Values( opPlusM, opMinusM, opDivM, opGreater, opLess, opGreaterEq, opLessEq, opEq, opNotEq))); @@ -36,9 +35,8 @@ INSTANTIATE_TEST_CASE_P(MathOperatorTestCPU, MathOperatorMatScalarTest, cv::Size(640, 480), cv::Size(128, 128)), Values(-1, CV_8U, CV_32F), -/*init output matrices or not*/ testing::Bool(), Values(CORE_CPU), - Values(AbsExact().to_compare_f()), + Values(AbsExact().to_compare_obj()), Values( opPlus, opPlusR, opMinus, opMinusR, opMul, opMulR, // FIXIT avoid division by values near zero: opDiv, opDivR, opGT, opLT, opGE, opLE, opEQ, opNE, opGTR, opLTR, opGER, opLER, opEQR, opNER))); @@ -49,9 +47,8 @@ INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestCPU, MathOperatorMatMatTest, cv::Size(640, 480), cv::Size(128, 128)), Values(-1), -/*init output matrices or not*/ testing::Bool(), Values(CORE_CPU), - Values(AbsExact().to_compare_f()), + Values(AbsExact().to_compare_obj()), Values( opAnd, opOr, opXor ))); INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestCPU, MathOperatorMatScalarTest, @@ -60,9 +57,8 @@ INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestCPU, MathOperatorMatScalarTest, cv::Size(640, 480), cv::Size(128, 128)), Values(-1), -/*init output matrices or not*/ testing::Bool(), Values(CORE_CPU), - Values(AbsExact().to_compare_f()), + Values(AbsExact().to_compare_obj()), Values( opAND, opOR, opXOR, opANDR, opORR, opXORR ))); INSTANTIATE_TEST_CASE_P(BitwiseNotOperatorTestCPU, NotOperatorTest, @@ -70,7 +66,6 @@ INSTANTIATE_TEST_CASE_P(BitwiseNotOperatorTestCPU, NotOperatorTest, Values(cv::Size(1280, 720), cv::Size(640, 480), cv::Size(128, 128)), - Values(SAME_TYPE), -/*init output matrices or not*/ testing::Bool(), + Values(-1), Values(CORE_CPU))); } diff --git a/modules/gapi/test/cpu/gapi_operators_tests_fluid.cpp b/modules/gapi/test/cpu/gapi_operators_tests_fluid.cpp index bc55154f1c..45c8e18890 100644 --- a/modules/gapi/test/cpu/gapi_operators_tests_fluid.cpp +++ b/modules/gapi/test/cpu/gapi_operators_tests_fluid.cpp @@ -10,7 +10,7 @@ namespace { - #define CORE_FLUID [] () { return cv::compile_args(cv::gapi::core::fluid::kernels()); } +#define CORE_FLUID [] () { return cv::compile_args(cv::gapi::core::fluid::kernels()); } } // anonymous namespace namespace opencv_test @@ -22,9 +22,8 @@ INSTANTIATE_TEST_CASE_P(MathOperatorTestFluid, MathOperatorMatMatTest, cv::Size(640, 480), cv::Size(128, 128)), Values(-1, CV_8U, CV_32F), -/*init output matrices or not*/ testing::Bool(), Values(CORE_FLUID), - Values(AbsExact().to_compare_f()), + Values(AbsExact().to_compare_obj()), Values( opPlusM, opMinusM, opDivM, opGreater, opLess, opGreaterEq, opLessEq, opEq, opNotEq))); @@ -35,9 +34,8 @@ INSTANTIATE_TEST_CASE_P(DISABLED_MathOperatorTestFluid, MathOperatorMatScalarTes cv::Size(640, 480), cv::Size(128, 128)), Values(-1, CV_8U, CV_32F), -/*init output matrices or not*/ testing::Bool(), Values(CORE_FLUID), - Values(AbsExact().to_compare_f()), + Values(AbsExact().to_compare_obj()), Values( opPlus, opPlusR, opMinus, opMinusR, opMul, opMulR, // FIXIT avoid division by values near zero: opDiv, opDivR, opGT, opLT, opGE, opLE, opEQ, opNE, opGTR, opLTR, opGER, opLER, opEQR, opNER))); @@ -48,9 +46,8 @@ INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestFluid, MathOperatorMatMatTest, cv::Size(640, 480), cv::Size(128, 128)), Values(-1), -/*init output matrices or not*/ testing::Bool(), Values(CORE_FLUID), - Values(AbsExact().to_compare_f()), + Values(AbsExact().to_compare_obj()), Values( opAnd, opOr, opXor ))); //FIXME: Some Mat/Scalar Fluid kernels are not there yet! @@ -60,9 +57,8 @@ INSTANTIATE_TEST_CASE_P(DISABLED_BitwiseOperatorTestFluid, MathOperatorMatScalar cv::Size(640, 480), cv::Size(128, 128)), Values(-1), -/*init output matrices or not*/ testing::Bool(), Values(CORE_FLUID), - Values(AbsExact().to_compare_f()), + Values(AbsExact().to_compare_obj()), Values( opAND, opOR, opXOR, opANDR, opORR, opXORR ))); INSTANTIATE_TEST_CASE_P(BitwiseNotOperatorTestFluid, NotOperatorTest, @@ -70,7 +66,6 @@ INSTANTIATE_TEST_CASE_P(BitwiseNotOperatorTestFluid, NotOperatorTest, Values(cv::Size(1280, 720), cv::Size(640, 480), cv::Size(128, 128)), - Values(SAME_TYPE), -/*init output matrices or not*/ testing::Bool(), + Values(-1), Values(CORE_FLUID))); } diff --git a/modules/gapi/test/gpu/gapi_core_tests_gpu.cpp b/modules/gapi/test/gpu/gapi_core_tests_gpu.cpp index e1b69c0403..878839c03f 100644 --- a/modules/gapi/test/gpu/gapi_core_tests_gpu.cpp +++ b/modules/gapi/test/gpu/gapi_core_tests_gpu.cpp @@ -10,7 +10,7 @@ namespace { - #define CORE_GPU [] () { return cv::compile_args(cv::gapi::core::gpu::kernels()); } +#define CORE_GPU [] () { return cv::compile_args(cv::gapi::core::gpu::kernels()); } } // anonymous namespace namespace opencv_test @@ -23,13 +23,11 @@ INSTANTIATE_TEST_CASE_P(AddTestGPU, MathOpTest, cv::Size(640, 480), cv::Size(128, 128)), Values( -1, CV_8U, CV_16U, CV_32F ), -/*init output matrices or not*/ testing::Bool(), Values(CORE_GPU), Values(ADD, MUL), testing::Bool(), Values(1.0), - Values(false)), - opencv_test::PrintMathOpCoreParams()); + Values(false))); INSTANTIATE_TEST_CASE_P(MulTestGPU, MathOpTest, Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), @@ -37,13 +35,11 @@ INSTANTIATE_TEST_CASE_P(MulTestGPU, MathOpTest, cv::Size(640, 480), cv::Size(128, 128)), Values( -1, CV_8U, CV_16U, CV_32F ), -/*init output matrices or not*/ testing::Bool(), Values(CORE_GPU), Values(MUL), testing::Bool(), Values(1.0, 0.5, 2.0), - Values(false)), - opencv_test::PrintMathOpCoreParams()); + Values(false))); INSTANTIATE_TEST_CASE_P(SubTestGPU, MathOpTest, Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), @@ -51,13 +47,11 @@ INSTANTIATE_TEST_CASE_P(SubTestGPU, MathOpTest, cv::Size(640, 480), cv::Size(128, 128)), Values( -1, CV_8U, CV_16U, CV_32F ), -/*init output matrices or not*/ testing::Bool(), Values(CORE_GPU), Values(SUB), testing::Bool(), Values (1.0), - testing::Bool()), - opencv_test::PrintMathOpCoreParams()); + testing::Bool())); INSTANTIATE_TEST_CASE_P(DivTestGPU, MathOpTest, Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), @@ -65,13 +59,11 @@ INSTANTIATE_TEST_CASE_P(DivTestGPU, MathOpTest, cv::Size(640, 480), cv::Size(128, 128)), Values( -1, CV_8U, CV_16U, CV_32F ), -/*init output matrices or not*/ testing::Bool(), Values(CORE_GPU), Values(DIV), testing::Bool(), Values (1.0, 0.5, 2.0), - testing::Bool()), - opencv_test::PrintMathOpCoreParams()); + testing::Bool())); INSTANTIATE_TEST_CASE_P(MulTestGPU, MulDoubleTest, Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ), @@ -79,7 +71,6 @@ INSTANTIATE_TEST_CASE_P(MulTestGPU, MulDoubleTest, cv::Size(640, 480), cv::Size(128, 128)), Values( -1, CV_8U, CV_16U, CV_32F ), -/*init output matrices or not*/ testing::Bool(), Values(CORE_GPU))); INSTANTIATE_TEST_CASE_P(DivTestGPU, DivTest, @@ -88,7 +79,6 @@ INSTANTIATE_TEST_CASE_P(DivTestGPU, DivTest, cv::Size(640, 480), cv::Size(128, 128)), Values( -1, CV_8U, CV_16U, CV_32F ), -/*init output matrices or not*/ testing::Bool(), Values(CORE_GPU))); INSTANTIATE_TEST_CASE_P(DivCTestGPU, DivCTest, @@ -97,7 +87,6 @@ INSTANTIATE_TEST_CASE_P(DivCTestGPU, DivCTest, cv::Size(640, 480), cv::Size(128, 128)), Values( -1, CV_8U, CV_16U, CV_32F ), -/*init output matrices or not*/ testing::Bool(), Values(CORE_GPU))); INSTANTIATE_TEST_CASE_P(MeanTestGPU, MeanTest, @@ -105,8 +94,7 @@ INSTANTIATE_TEST_CASE_P(MeanTestGPU, MeanTest, Values(cv::Size(1280, 720), cv::Size(640, 480), cv::Size(128, 128)), - Values(SAME_TYPE), -/*init output matrices or not*/ testing::Bool(), + Values(-1), Values(CORE_GPU))); //TODO: mask test doesn't work @@ -116,7 +104,6 @@ INSTANTIATE_TEST_CASE_P(MaskTestGPU, MaskTest, Values(cv::Size(1280, 720), cv::Size(640, 480), cv::Size(128, 128)), -/*init output matrices or not*/ testing::Bool(), Values(CORE_GPU))); #endif @@ -125,8 +112,7 @@ INSTANTIATE_TEST_CASE_P(SelectTestGPU, SelectTest, Values(cv::Size(1280, 720), cv::Size(640, 480), cv::Size(128, 128)), - Values(SAME_TYPE), -/*init output matrices or not*/ testing::Bool(), + Values(-1), Values(CORE_GPU))); INSTANTIATE_TEST_CASE_P(Polar2CartGPU, Polar2CartTest, @@ -135,7 +121,6 @@ INSTANTIATE_TEST_CASE_P(Polar2CartGPU, Polar2CartTest, cv::Size(640, 480), cv::Size(128, 128)), Values(CV_32FC1), -/*init output matrices or not*/ testing::Bool(), Values(CORE_GPU))); INSTANTIATE_TEST_CASE_P(Cart2PolarGPU, Cart2PolarTest, @@ -144,7 +129,6 @@ INSTANTIATE_TEST_CASE_P(Cart2PolarGPU, Cart2PolarTest, cv::Size(640, 480), cv::Size(128, 128)), Values(CV_32FC1), -/*init output matrices or not*/ testing::Bool(), Values(CORE_GPU))); INSTANTIATE_TEST_CASE_P(CompareTestGPU, CmpTest, @@ -153,30 +137,25 @@ INSTANTIATE_TEST_CASE_P(CompareTestGPU, CmpTest, cv::Size(640, 480), cv::Size(128, 128)), Values(CV_8U), -/*init output matrices or not*/ testing::Bool(), Values(CORE_GPU), Values(CMP_EQ, CMP_GE, CMP_NE, CMP_GT, CMP_LT, CMP_LE), - testing::Bool()), - opencv_test::PrintCmpCoreParams()); + testing::Bool())); 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)), - Values(SAME_TYPE), -/*init output matrices or not*/ testing::Bool(), + Values(-1), Values(CORE_GPU), - Values(AND, OR, XOR)), - opencv_test::PrintBWCoreParams()); + Values(AND, OR, XOR))); INSTANTIATE_TEST_CASE_P(BitwiseNotTestGPU, NotTest, 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)), - Values(SAME_TYPE), -/*init output matrices or not*/ testing::Bool(), + Values(-1), Values(CORE_GPU))); INSTANTIATE_TEST_CASE_P(MinTestGPU, MinTest, @@ -184,8 +163,7 @@ INSTANTIATE_TEST_CASE_P(MinTestGPU, MinTest, Values(cv::Size(1280, 720), cv::Size(640, 480), cv::Size(128, 128)), - Values(SAME_TYPE), -/*init output matrices or not*/ testing::Bool(), + Values(-1), Values(CORE_GPU))); INSTANTIATE_TEST_CASE_P(MaxTestGPU, MaxTest, @@ -193,8 +171,7 @@ INSTANTIATE_TEST_CASE_P(MaxTestGPU, MaxTest, Values(cv::Size(1280, 720), cv::Size(640, 480), cv::Size(128, 128)), - Values(SAME_TYPE), -/*init output matrices or not*/ testing::Bool(), + Values(-1), Values(CORE_GPU))); INSTANTIATE_TEST_CASE_P(SumTestGPU, SumTest, @@ -202,18 +179,16 @@ INSTANTIATE_TEST_CASE_P(SumTestGPU, SumTest, Values(cv::Size(1280, 720), cv::Size(640, 480), cv::Size(128, 128)), - Values(SAME_TYPE), -/*init output matrices or not*/ testing::Bool(), + Values(-1), Values(CORE_GPU), - Values(AbsToleranceScalar(1e-3).to_compare_f())));//TODO: too relaxed? + Values(AbsToleranceScalar(1e-3).to_compare_obj())));//TODO: too relaxed? 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)), - Values(SAME_TYPE), -/*init output matrices or not*/ testing::Bool(), + Values(-1), Values(CORE_GPU))); INSTANTIATE_TEST_CASE_P(AbsDiffCTestGPU, AbsDiffCTest, @@ -221,8 +196,7 @@ INSTANTIATE_TEST_CASE_P(AbsDiffCTestGPU, AbsDiffCTest, Values(cv::Size(1280, 720), cv::Size(640, 480), cv::Size(128, 128)), - Values(SAME_TYPE), -/*init output matrices or not*/ testing::Bool(), + Values(-1), Values(CORE_GPU))); INSTANTIATE_TEST_CASE_P(AddWeightedTestGPU, AddWeightedTest, @@ -231,21 +205,18 @@ INSTANTIATE_TEST_CASE_P(AddWeightedTestGPU, AddWeightedTest, cv::Size(640, 480), cv::Size(128, 128)), Values( -1, CV_8U, CV_16U, CV_32F ), -/*init output matrices or not*/ testing::Bool(), Values(CORE_GPU), - Values(Tolerance_FloatRel_IntAbs(1e-6, 1).to_compare_f()))); + 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)), - Values(SAME_TYPE), - Values(false), + Values(-1), Values(CORE_GPU), - Values(AbsToleranceScalar(1e-3).to_compare_f()), //TODO: too relaxed? - Values(NORM_INF, NORM_L1, NORM_L2)), - opencv_test::PrintNormCoreParams()); + Values(AbsToleranceScalar(1e-3).to_compare_obj()), //TODO: too relaxed? + Values(NORM_INF, NORM_L1, NORM_L2))); INSTANTIATE_TEST_CASE_P(IntegralTestGPU, IntegralTest, Combine(Values( CV_8UC1, CV_16UC1, CV_16SC1, CV_32FC1 ), @@ -253,7 +224,6 @@ INSTANTIATE_TEST_CASE_P(IntegralTestGPU, IntegralTest, cv::Size(640, 480), cv::Size(128, 128)), Values(-1), - Values(false), Values(CORE_GPU))); INSTANTIATE_TEST_CASE_P(ThresholdTestGPU, ThresholdTest, @@ -261,8 +231,7 @@ INSTANTIATE_TEST_CASE_P(ThresholdTestGPU, ThresholdTest, Values(cv::Size(1280, 720), cv::Size(640, 480), cv::Size(128, 128)), - Values(SAME_TYPE), -/*init output matrices or not*/ testing::Bool(), + Values(-1), Values(CORE_GPU), Values(cv::THRESH_BINARY, cv::THRESH_BINARY_INV, cv::THRESH_TRUNC, cv::THRESH_TOZERO, cv::THRESH_TOZERO_INV))); @@ -272,8 +241,7 @@ INSTANTIATE_TEST_CASE_P(ThresholdTestGPU, ThresholdOTTest, Values(cv::Size(1280, 720), cv::Size(640, 480), cv::Size(128, 128)), - Values(SAME_TYPE), -/*init output matrices or not*/ testing::Bool(), + Values(-1), Values(CORE_GPU), Values(cv::THRESH_OTSU, cv::THRESH_TRIANGLE))); @@ -283,8 +251,7 @@ INSTANTIATE_TEST_CASE_P(InRangeTestGPU, InRangeTest, Values(cv::Size(1280, 720), cv::Size(640, 480), cv::Size(128, 128)), - Values(SAME_TYPE), -/*init output matrices or not*/ testing::Bool(), + Values(-1), Values(CORE_GPU))); INSTANTIATE_TEST_CASE_P(Split3TestGPU, Split3Test, @@ -293,7 +260,6 @@ INSTANTIATE_TEST_CASE_P(Split3TestGPU, Split3Test, cv::Size(640, 480), cv::Size(128, 128)), Values(CV_8UC1), - Values(true), Values(CORE_GPU))); INSTANTIATE_TEST_CASE_P(Split4TestGPU, Split4Test, @@ -302,7 +268,6 @@ INSTANTIATE_TEST_CASE_P(Split4TestGPU, Split4Test, cv::Size(640, 480), cv::Size(128, 128)), Values(CV_8UC1), - Values(true), Values(CORE_GPU))); INSTANTIATE_TEST_CASE_P(ResizeTestGPU, ResizeTest, @@ -311,9 +276,8 @@ INSTANTIATE_TEST_CASE_P(ResizeTestGPU, ResizeTest, cv::Size(640, 480), cv::Size(128, 128)), Values(-1), - Values(false), Values(CORE_GPU), - Values(AbsSimilarPoints(2, 0.05).to_compare_f()), + Values(AbsSimilarPoints(2, 0.05).to_compare_obj()), Values(cv::INTER_NEAREST, cv::INTER_LINEAR, cv::INTER_AREA), Values(cv::Size(64,64), cv::Size(30,30)))); @@ -324,9 +288,8 @@ INSTANTIATE_TEST_CASE_P(ResizeTestGPU, ResizeTestFxFy, cv::Size(640, 480), cv::Size(128, 128)), Values(-1), - Values(false), Values(CORE_GPU), - Values(AbsSimilarPoints(2, 0.05).to_compare_f()), + Values(AbsSimilarPoints(2, 0.05).to_compare_obj()), Values(cv::INTER_NEAREST, cv::INTER_LINEAR, cv::INTER_AREA), Values(0.5, 0.1), Values(0.5, 0.1))); @@ -337,7 +300,6 @@ INSTANTIATE_TEST_CASE_P(Merge3TestGPU, Merge3Test, cv::Size(640, 480), cv::Size(128, 128)), Values(CV_8UC3), - Values(true), Values(CORE_GPU))); INSTANTIATE_TEST_CASE_P(Merge4TestGPU, Merge4Test, @@ -346,7 +308,6 @@ INSTANTIATE_TEST_CASE_P(Merge4TestGPU, Merge4Test, cv::Size(640, 480), cv::Size(128, 128)), Values(CV_8UC4), - Values(true), Values(CORE_GPU))); INSTANTIATE_TEST_CASE_P(RemapTestGPU, RemapTest, @@ -354,8 +315,7 @@ INSTANTIATE_TEST_CASE_P(RemapTestGPU, RemapTest, Values(cv::Size(1280, 720), cv::Size(640, 480), cv::Size(128, 128)), - Values(SAME_TYPE), -/*init output matrices or not*/ testing::Bool(), + Values(-1), Values(CORE_GPU))); INSTANTIATE_TEST_CASE_P(FlipTestGPU, FlipTest, @@ -363,8 +323,7 @@ INSTANTIATE_TEST_CASE_P(FlipTestGPU, FlipTest, Values(cv::Size(1280, 720), cv::Size(640, 480), cv::Size(128, 128)), - Values(SAME_TYPE), -/*init output matrices or not*/ Values(false), + Values(-1), Values(CORE_GPU), Values(0,1,-1))); @@ -373,8 +332,7 @@ INSTANTIATE_TEST_CASE_P(CropTestGPU, CropTest, Values(cv::Size(1280, 720), cv::Size(640, 480), cv::Size(128, 128)), - Values(SAME_TYPE), -/*init output matrices or not*/ Values(false), + Values(-1), Values(CORE_GPU), Values(cv::Rect(10, 8, 20, 35), cv::Rect(4, 10, 37, 50)))); @@ -384,7 +342,6 @@ INSTANTIATE_TEST_CASE_P(LUTTestGPU, LUTTest, cv::Size(640, 480), cv::Size(128, 128)), Values(CV_8UC1), -/*init output matrices or not*/ Values(true), Values(CORE_GPU))); INSTANTIATE_TEST_CASE_P(LUTTestCustomGPU, LUTTest, @@ -393,7 +350,6 @@ INSTANTIATE_TEST_CASE_P(LUTTestCustomGPU, LUTTest, cv::Size(640, 480), cv::Size(128, 128)), Values(CV_8UC3), -/*init output matrices or not*/ Values(true), Values(CORE_GPU))); INSTANTIATE_TEST_CASE_P(ConvertToGPU, ConvertToTest, @@ -402,9 +358,8 @@ INSTANTIATE_TEST_CASE_P(ConvertToGPU, ConvertToTest, cv::Size(640, 480), cv::Size(128, 128)), Values(CV_8U, CV_16U, CV_16S, CV_32F), - Values(false), Values(CORE_GPU), - Values(AbsExact().to_compare_f()), + Values(AbsExact().to_compare_obj()), Values(2.5, 1.0, -1.0), Values(250.0, 0.0, -128.0))); @@ -413,8 +368,7 @@ INSTANTIATE_TEST_CASE_P(ConcatHorTestGPU, ConcatHorTest, Values(cv::Size(1280, 720), cv::Size(640, 480), cv::Size(128, 128)), - Values(SAME_TYPE), - Values(false), + Values(-1), Values(CORE_GPU))); INSTANTIATE_TEST_CASE_P(ConcatVertTestGPU, ConcatVertTest, @@ -422,8 +376,7 @@ INSTANTIATE_TEST_CASE_P(ConcatVertTestGPU, ConcatVertTest, Values(cv::Size(1280, 720), cv::Size(640, 480), cv::Size(128, 128)), - Values(SAME_TYPE), - Values(false), + Values(-1), Values(CORE_GPU))); INSTANTIATE_TEST_CASE_P(BackendOutputAllocationTestGPU, BackendOutputAllocationTest, diff --git a/modules/gapi/test/gpu/gapi_imgproc_tests_gpu.cpp b/modules/gapi/test/gpu/gapi_imgproc_tests_gpu.cpp index b01ae6d95b..e745bbeed2 100644 --- a/modules/gapi/test/gpu/gapi_imgproc_tests_gpu.cpp +++ b/modules/gapi/test/gpu/gapi_imgproc_tests_gpu.cpp @@ -11,7 +11,7 @@ namespace { - #define IMGPROC_GPU [] () { return cv::compile_args(cv::gapi::imgproc::gpu::kernels()); } +#define IMGPROC_GPU [] () { return cv::compile_args(cv::gapi::imgproc::gpu::kernels()); } } // anonymous namespace namespace opencv_test @@ -23,9 +23,8 @@ INSTANTIATE_TEST_CASE_P(Filter2DTestGPU, Filter2DTest, cv::Size(640, 480), cv::Size(128, 128)), Values(-1, CV_32F), - testing::Bool(), Values(IMGPROC_GPU), - Values(Tolerance_FloatRel_IntAbs(1e-5, 2).to_compare_f()), + Values(Tolerance_FloatRel_IntAbs(1e-5, 2).to_compare_obj()), Values(3, 4, 5, 7), Values(cv::BORDER_DEFAULT))); @@ -34,9 +33,8 @@ INSTANTIATE_TEST_CASE_P(BoxFilterTestCPU, BoxFilterTest, Values(cv::Size(1280, 720), cv::Size(640, 480)), Values(-1, CV_32F), - testing::Bool(), Values(IMGPROC_GPU), - Values(Tolerance_FloatRel_IntAbs(1e-5, 2).to_compare_f()), + Values(Tolerance_FloatRel_IntAbs(1e-5, 2).to_compare_obj()), Values(3,5), Values(cv::BORDER_DEFAULT))); //TODO: 8UC1 doesn't work @@ -46,9 +44,8 @@ INSTANTIATE_TEST_CASE_P(SepFilterTestGPU_8U, SepFilterTest, Values(cv::Size(1280, 720), cv::Size(640, 480)), Values(-1, CV_16S, CV_32F), - testing::Bool(), Values(IMGPROC_GPU), - Values(ToleranceFilter(1e-4f, 0.01).to_compare_f()), + Values(ToleranceFilter(1e-4f, 0.01).to_compare_obj()), Values(3))); INSTANTIATE_TEST_CASE_P(SepFilterTestGPU_other, SepFilterTest, @@ -56,19 +53,17 @@ INSTANTIATE_TEST_CASE_P(SepFilterTestGPU_other, SepFilterTest, Values(cv::Size(1280, 720), cv::Size(640, 480)), Values(-1, CV_32F), - testing::Bool(), Values(IMGPROC_GPU), - Values(ToleranceFilter(1e-4f, 0.01).to_compare_f()), + Values(ToleranceFilter(1e-4f, 0.01).to_compare_obj()), Values(3))); 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(SAME_TYPE), -/*init output matrices or not*/ testing::Bool(), + Values(-1), Values(IMGPROC_GPU), - Values(Tolerance_FloatRel_IntAbs(1e-4, 2).to_compare_f()), + Values(Tolerance_FloatRel_IntAbs(1e-4, 2).to_compare_obj()), Values(3,5), Values(cv::BORDER_DEFAULT))); @@ -76,30 +71,27 @@ 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(SAME_TYPE), -/*init output matrices or not*/ testing::Bool(), + Values(-1), Values(IMGPROC_GPU), - Values(ToleranceFilter(1e-5f, 0.01).to_compare_f()), + Values(ToleranceFilter(1e-5f, 0.01).to_compare_obj()), Values(3))); // FIXIT 5 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(SAME_TYPE), -/*init output matrices or not*/ testing::Bool(), + Values(-1), Values(IMGPROC_GPU), - Values(AbsExact().to_compare_f()), + Values(AbsExact().to_compare_obj()), Values(3, 5))); 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(SAME_TYPE), -/*init output matrices or not*/ testing::Bool(), + Values(-1), Values(IMGPROC_GPU), - Values(AbsExact().to_compare_f()), + Values(AbsExact().to_compare_obj()), Values(3, 5), Values(cv::MorphShapes::MORPH_RECT, cv::MorphShapes::MORPH_CROSS, @@ -109,20 +101,18 @@ 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(SAME_TYPE), -/*init output matrices or not*/ testing::Bool(), + Values(-1), Values(IMGPROC_GPU), - Values(AbsExact().to_compare_f()), + Values(AbsExact().to_compare_obj()), Values(1,2,4))); 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(SAME_TYPE), -/*init output matrices or not*/ testing::Bool(), + Values(-1), Values(IMGPROC_GPU), - Values(AbsExact().to_compare_f()), + Values(AbsExact().to_compare_obj()), Values(3, 5), Values(cv::MorphShapes::MORPH_RECT, cv::MorphShapes::MORPH_CROSS, @@ -132,10 +122,9 @@ 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(SAME_TYPE), -/*init output matrices or not*/ testing::Bool(), + Values(-1), Values(IMGPROC_GPU), - Values(AbsExact().to_compare_f()), + Values(AbsExact().to_compare_obj()), Values(1,2,4))); INSTANTIATE_TEST_CASE_P(SobelTestGPU, SobelTest, @@ -143,9 +132,8 @@ INSTANTIATE_TEST_CASE_P(SobelTestGPU, SobelTest, Values(cv::Size(1280, 720), cv::Size(640, 480)), Values(-1, CV_16S, CV_32F), -/*init output matrices or not*/ testing::Bool(), Values(IMGPROC_GPU), - Values(Tolerance_FloatRel_IntAbs(1e-4, 2).to_compare_f()), + Values(Tolerance_FloatRel_IntAbs(1e-4, 2).to_compare_obj()), Values(3, 5), Values(0, 1), Values(1, 2))); @@ -155,9 +143,8 @@ INSTANTIATE_TEST_CASE_P(SobelTestGPU32F, SobelTest, Values(cv::Size(1280, 720), cv::Size(640, 480)), Values(CV_32F), -/*init output matrices or not*/ testing::Bool(), Values(IMGPROC_GPU), - Values(Tolerance_FloatRel_IntAbs(1e-4, 2).to_compare_f()), + Values(Tolerance_FloatRel_IntAbs(1e-4, 2).to_compare_obj()), Values(3, 5), Values(0, 1), Values(1, 2))); @@ -166,19 +153,17 @@ INSTANTIATE_TEST_CASE_P(EqHistTestGPU, EqHistTest, Combine(Values(CV_8UC1), Values(cv::Size(1280, 720), cv::Size(640, 480)), - Values(SAME_TYPE), -/*init output matrices or not*/ testing::Bool(), + Values(-1), Values(IMGPROC_GPU), - Values(AbsExact().to_compare_f()))); // FIXIT Non reliable check + 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_8UC1), -/*init output matrices or not*/ testing::Bool(), Values(IMGPROC_GPU), - Values(AbsSimilarPoints(0, 0.05).to_compare_f()), + Values(AbsSimilarPoints(0, 0.05).to_compare_obj()), Values(3.0, 120.0), Values(125.0, 240.0), Values(3, 5), @@ -189,80 +174,71 @@ INSTANTIATE_TEST_CASE_P(RGB2GrayTestGPU, RGB2GrayTest, Values(cv::Size(1280, 720), cv::Size(640, 480)), Values(CV_8UC1), -/*init output matrices or not*/ testing::Bool(), Values(IMGPROC_GPU), - Values(ToleranceColor(1e-3).to_compare_f()))); + 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_8UC1), -/*init output matrices or not*/ testing::Bool(), Values(IMGPROC_GPU), - Values(ToleranceColor(1e-3).to_compare_f()))); + 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_8UC3), -/*init output matrices or not*/ testing::Bool(), Values(IMGPROC_GPU), - Values(ToleranceColor(1e-3).to_compare_f()))); + 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_8UC3), -/*init output matrices or not*/ testing::Bool(), Values(IMGPROC_GPU), - Values(ToleranceColor(1e-3).to_compare_f()))); + 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_8UC3), -/*init output matrices or not*/ testing::Bool(), Values(IMGPROC_GPU), - Values(AbsSimilarPoints(1, 0.05).to_compare_f()))); + 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_8UC3), -/*init output matrices or not*/ testing::Bool(), Values(IMGPROC_GPU), - Values(ToleranceColor(5e-3, 6).to_compare_f()))); + 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_8UC3), -/*init output matrices or not*/ testing::Bool(), Values(IMGPROC_GPU), - Values(ToleranceColor(1e-3).to_compare_f()))); + 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_8UC3), -/*init output matrices or not*/ testing::Bool(), Values(IMGPROC_GPU), - Values(ToleranceColor(1e-3).to_compare_f()))); + 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_8UC3), -/*init output matrices or not*/ testing::Bool(), Values(IMGPROC_GPU), - Values(ToleranceColor(1e-3).to_compare_f()))); + Values(ToleranceColor(1e-3).to_compare_obj()))); } // opencv_test diff --git a/modules/gapi/test/gpu/gapi_operators_tests_gpu.cpp b/modules/gapi/test/gpu/gapi_operators_tests_gpu.cpp index 0e21019b06..a939d3208c 100644 --- a/modules/gapi/test/gpu/gapi_operators_tests_gpu.cpp +++ b/modules/gapi/test/gpu/gapi_operators_tests_gpu.cpp @@ -10,7 +10,7 @@ namespace { - #define CORE_GPU [] () { return cv::compile_args(cv::gapi::core::gpu::kernels()); } +#define CORE_GPU [] () { return cv::compile_args(cv::gapi::core::gpu::kernels()); } } // anonymous namespace namespace opencv_test @@ -22,9 +22,8 @@ INSTANTIATE_TEST_CASE_P(MathOperatorTestGPU, MathOperatorMatMatTest, cv::Size(640, 480), cv::Size(128, 128)), Values(-1, CV_8U, CV_32F), - testing::Bool(), Values(CORE_GPU), - Values(Tolerance_FloatRel_IntAbs(1e-5, 2).to_compare_f()), + Values(Tolerance_FloatRel_IntAbs(1e-5, 2).to_compare_obj()), Values( opPlusM, opMinusM, opDivM, opGreater, opLess, opGreaterEq, opLessEq, opEq, opNotEq))); @@ -34,9 +33,8 @@ INSTANTIATE_TEST_CASE_P(MathOperatorTestGPU, MathOperatorMatScalarTest, cv::Size(640, 480), cv::Size(128, 128)), Values(-1, CV_8U, CV_32F), -/*init output matrices or not*/ testing::Bool(), Values(CORE_GPU), - Values(Tolerance_FloatRel_IntAbs(1e-4, 2).to_compare_f()), + Values(Tolerance_FloatRel_IntAbs(1e-4, 2).to_compare_obj()), Values( opPlus, opPlusR, opMinus, opMinusR, opMul, opMulR, // FIXIT avoid division by values near zero: opDiv, opDivR, opGT, opLT, opGE, opLE, opEQ, opNE, opGTR, opLTR, opGER, opLER, opEQR, opNER))); @@ -47,9 +45,8 @@ INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestGPU, MathOperatorMatMatTest, cv::Size(640, 480), cv::Size(128, 128)), Values(-1), -/*init output matrices or not*/ testing::Bool(), Values(CORE_GPU), - Values(AbsExact().to_compare_f()), + Values(AbsExact().to_compare_obj()), Values( opAnd, opOr, opXor ))); INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestGPU, MathOperatorMatScalarTest, @@ -58,9 +55,8 @@ INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestGPU, MathOperatorMatScalarTest, cv::Size(640, 480), cv::Size(128, 128)), Values(-1), -/*init output matrices or not*/ testing::Bool(), Values(CORE_GPU), - Values(AbsExact().to_compare_f()), + Values(AbsExact().to_compare_obj()), Values( opAND, opOR, opXOR, opANDR, opORR, opXORR ))); INSTANTIATE_TEST_CASE_P(BitwiseNotOperatorTestGPU, NotOperatorTest, @@ -68,7 +64,6 @@ INSTANTIATE_TEST_CASE_P(BitwiseNotOperatorTestGPU, NotOperatorTest, Values(cv::Size(1280, 720), cv::Size(640, 480), cv::Size(128, 128)), - Values(SAME_TYPE), -/*init output matrices or not*/ testing::Bool(), + Values(-1), Values(CORE_GPU))); }