mirror/opencv
1
0
Fork 0
mirror of https://github.com/opencv/opencv.git synced 2025-06-10 19:24:07 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge pull request #14945 from andrey-golubev:delete_bool

Browse Source 
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
This commit is contained in:
Andrey Golubev 2019-07-16 19:04:18 +03:00 committed by Alexander Alekhin
parent c11423df1e
commit c9bd43c0f6
15 changed files with 424 additions and 597 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

122
modules/gapi/test/common/gapi_core_tests.hpp
View File

@ -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 <class TestParams>
std::string operator()(const ::testing::TestParamInfo<TestParams>& info) const
#define CASE(v) case bitwiseOp::v: os << #v; break
switch (op)
{
std::stringstream ss;
using AllParams = Params<mathOp,bool,double,bool>;
const AllParams::params_t& params = info.param;
cv::Size sz = AllParams::getCommon<1>(params); // size
ss<<MathOperations[AllParams::getSpecific<0>(params)] // mathOp
<<"_"<<AllParams::getSpecific<1>(params) // testWithScalar
<<"_"<<AllParams::getCommon<0>(params) // type
<<"_"<<(int)AllParams::getSpecific<2>(params) // scale
<<"_"<<sz.width
<<"x"<<sz.height
<<"_"<<(AllParams::getCommon<2>(params)+1) // dtype
<<"_"<<AllParams::getCommon<3>(params) // createOutputMatrices
<<"_"<<AllParams::getSpecific<3>(params); // doReverseOp
return ss.str();
}
};
struct PrintCmpCoreParams
{
template <class TestParams>
std::string operator()(const ::testing::TestParamInfo<TestParams>& info) const
{
std::stringstream ss;
using AllParams = Params<CmpTypes,bool>;
const AllParams::params_t& params = info.param;
cv::Size sz = AllParams::getCommon<1>(params); // size
ss<<CompareOperations[AllParams::getSpecific<0>(params)] // CmpType
<<"_"<<AllParams::getSpecific<1>(params) // testWithScalar
<<"_"<<AllParams::getCommon<0>(params) // type
<<"_"<<sz.width
<<"x"<<sz.height
<<"_"<<AllParams::getCommon<3>(params); // createOutputMatrices
return ss.str();
}
};
struct PrintBWCoreParams
{
template <class TestParams>
std::string operator()(const ::testing::TestParamInfo<TestParams>& info) const
{
std::stringstream ss;
using AllParams = Params<bitwiseOp>;
const AllParams::params_t& params = info.param;
cv::Size sz = AllParams::getCommon<1>(params); // size
ss<<BitwiseOperations[AllParams::getSpecific<0>(params)] // bitwiseOp
<<"_"<<AllParams::getCommon<0>(params) // type
<<"_"<<sz.width
<<"x"<<sz.height
<<"_"<<AllParams::getCommon<3>(params); // createOutputMatrices
return ss.str();
}
};
struct PrintNormCoreParams
{
template <class TestParams>
std::string operator()(const ::testing::TestParamInfo<TestParams>& info) const
{
std::stringstream ss;
using AllParams = Params<compare_scalar_f,NormTypes>;
const AllParams::params_t& params = info.param;
cv::Size sz = AllParams::getCommon<1>(params); // size
ss<<NormOperations[AllParams::getSpecific<1>(params)] // NormTypes
<<"_"<<AllParams::getCommon<0>(params) // type
<<"_"<<sz.width
<<"x"<<sz.height;
return ss.str();
}
};
CASE(AND);
CASE(OR);
CASE(XOR);
CASE(NOT);
default: GAPI_Assert(false && "unknown bitwiseOp value");
}
#undef CASE
return os;
}
GAPI_TEST_FIXTURE(MathOpTest, initMatsRandU, FIXTURE_API(mathOp,bool,double,bool), 4,
opType, testWithScalar, scale, doReverseOp)
@ -133,9 +79,9 @@ GAPI_TEST_FIXTURE(MinTest, initMatsRandU, <>, 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<>
{

9
modules/gapi/test/common/gapi_core_tests_inl.hpp
View File

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

60
modules/gapi/test/common/gapi_imgproc_tests.hpp
View File

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

4
modules/gapi/test/common/gapi_operators_tests.hpp
View File

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

162
modules/gapi/test/common/gapi_tests_common.hpp
View File

@ -132,15 +132,33 @@ using compare_f = std::function<bool(const cv::Mat &a, const cv::Mat &b)>;
using compare_scalar_f = std::function<bool(const cv::Scalar &a, const cv::Scalar &b)>;
// 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<typename ...SpecificParams>
struct Params
{
using gcomp_args_function_t = cv::GCompileArgs(*)();
// TODO: delete bool (createOutputMatrices) from common parameters
using common_params_t = std::tuple<int, cv::Size, int, bool, gcomp_args_function_t>;
using common_params_t = std::tuple<MatType2, cv::Size, MatType2, gcomp_args_function_t>;
using specific_params_t = std::tuple<SpecificParams...>;
using params_t = std::tuple<int, cv::Size, int, bool, gcomp_args_function_t, SpecificParams...>;
using params_t = std::tuple<MatType2, cv::Size, MatType2, gcomp_args_function_t, SpecificParams...>;
static constexpr const size_t common_params_size = std::tuple_size<common_params_t>::value;
static constexpr const size_t specific_params_size = std::tuple_size<specific_params_t>::value;
@ -170,15 +188,9 @@ struct TestWithParamBase : TestFunctional,
{
using AllParams = Params<SpecificParams...>;
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<size_t I>
@ -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 <int, bool>
#define FIXTURE_API(...) <__VA_ARGS__>
template<typename T1, typename T2>
struct CompareF
{
using callable_t = std::function<bool(const T1& a, const T2& b)>;
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<T1, T2>& obj)
{
return os << obj._name;
}
private:
callable_t _comparator;
std::string _name;
};
using CompareMats = CompareF<cv::Mat, cv::Mat>;
using CompareScalars = CompareF<cv::Scalar, cv::Scalar>;
template<typename T>
struct Wrappable
{
@ -238,6 +272,14 @@ struct Wrappable
return t(a, b);
};
}
CompareMats to_compare_obj()
{
T t = *static_cast<T*const>(this);
std::stringstream ss;
ss << t;
return CompareMats(to_compare_f(), ss.str());
}
};
template<typename T>
@ -251,6 +293,14 @@ struct WrappableScalar
return t(a, b);
};
}
CompareScalars to_compare_obj()
{
T t = *static_cast<T*const>(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<AbsTolerance>
@ -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

6
modules/gapi/test/common/gapi_tests_helpers.hpp
View File

@ -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<int>::max()
};
// Ensure correct __VA_ARGS__ expansion on Windows
#define __WRAP_VAARGS(x) x

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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