Skip to content

O
opencv
Commit c9bd43c0 authored by Andrey Golubev's avatar Andrey Golubev Committed by Alexander Alekhin
Browse files
Options

Merge pull request #14945 from andrey-golubev:delete_bool 

G-API: clean up accuracy tests (#14945)

* Delete createOutputMatrices flag

Update the way compile args function is created

Fix instantiation suffix print function

* Update comment (NB)

* Make printable comparison functions

* Use defines instead of objects for compile args

* Remove custom printers, use operator<< overload

* Remove SAME_TYPE and use -1 instead

* Delete createOutputMatrices flag in new tests

* Fix GetParam() printed values

* Update Resize tests: use CompareF object

* Address code review feedback

* Add default cases for operator<< overloads

* change throw to GAPI_Assert
parent c11423df
Hide whitespace changes
Inline Side-by-side
Showing with 420 additions and 593 deletions
modules/gapi/test/common/gapi_core_tests.hpp
View file @ c9bd43c0
......@@ -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"};
}
struct PrintMathOpCoreParams
{
template <class TestParams>
std::string operator()(const ::testing::TestParamInfo<TestParams>& info) const
{
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
#define CASE(v) case mathOp::v: os << #v; break
switch (op)
{
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();
}
};
CASE(ADD);
CASE(SUB);
CASE(MUL);
CASE(DIV);
default: GAPI_Assert(false && "unknown mathOp value");
}
#undef CASE
return os;
}
struct PrintNormCoreParams
// 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<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<>
{
......
modules/gapi/test/common/gapi_core_tests_inl.hpp
View file @ c9bd43c0
......@@ -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;
......
modules/gapi/test/common/gapi_imgproc_tests.hpp
View file @ c9bd43c0
......@@ -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
modules/gapi/test/common/gapi_operators_tests.hpp
View file @ c9bd43c0
......@@ -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
......
modules/gapi/test/common/gapi_tests_common.hpp
View file @ c9bd43c0
......@@ -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&)
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_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)
{
return os << "compare_f";
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;
}
namespace
inline std::ostream& operator<<(std::ostream& os, NormTypes op)
{
inline std::ostream& operator<<(std::ostream& os, const opencv_test::compare_scalar_f&)
#define CASE(v) case NormTypes::v: os << #v; break
switch (op)
{
return os << "compare_scalar_f";
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
modules/gapi/test/common/gapi_tests_helpers.hpp
View file @ c9bd43c0
......@@ -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
......
modules/gapi/test/cpu/gapi_core_tests_cpu.cpp
View file @ c9bd43c0
......@@ -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),
......
modules/gapi/test/cpu/gapi_core_tests_fluid.cpp
View file @ c9bd43c0
......@@ -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),
......
modules/gapi/test/cpu/gapi_imgproc_tests_cpu.cpp
View file @ c9bd43c0
......@@ -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
modules/gapi/test/cpu/gapi_imgproc_tests_fluid.cpp
View file @ c9bd43c0
......@@ -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)));
......
modules/gapi/test/cpu/gapi_operators_tests_cpu.cpp
View file @ c9bd43c0
......@@ -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)));
}
modules/gapi/test/cpu/gapi_operators_tests_fluid.cpp
View file @ c9bd43c0
......@@ -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)));
}
modules/gapi/test/gpu/gapi_core_tests_gpu.cpp
View file @ c9bd43c0
......@@ -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,
......
modules/gapi/test/gpu/gapi_imgproc_tests_gpu.cpp
View file @ c9bd43c0
......@@ -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
modules/gapi/test/gpu/gapi_operators_tests_gpu.cpp
View file @ c9bd43c0
......@@ -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)));
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment