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

Merge pull request #18257 from OrestChura:oc/fluid_operator_bitwise_and_scalar

Browse Source 
[G-API]: Add Fluid bitwise operations implementation for (GMat, GScalar)

* Added Fluid `bitwise` with `Scalar` + acc.tests
 - simple loop implementation for Fluid used (no `hal`);
   - `Scalar` is casted to `int` in the beginning
 - tests just modified to work with `Scalar`
 - expected output in operators' tests fixed (operators can't change Mat's depth)
 - `float` `Scalar` `RNG` added, `RNG` reworked (`time` is used now), initialization of test fixtures reworked
   - if input or output is `float` Scalar is initialized by `float`
 - some problems with Fluid/OCV floating-point comparison difference stashed by `AbsSimilarPoints()` usage, FIXME added
 - divide-by-zero is now fixed differently and everywhere

* - Added perf_tests for bitwise_Scalar operations
 - due to errors of Fluid floating-point comparison operations, added support of different validation in Cmp perf_tests; added FIXME

 - reworked integral initialization of Scalar

* Addressing comments
 - NULL -> nullptr
 - Scalar convertion moved to the function
 - avoid -> avoiding

* Addressing comments

* CV_assert -> GAPI_assert

* Addressed DM comments
 - refactored convertScalarForBitwise()
 - removed unnecessary braces for switch

* Changed the operators tests
 - switch via `enum` implemented
 - infrastructure for that refactored
This commit is contained in:
Orest Chura 2020-09-18 16:44:47 +03:00 committed by GitHub
parent 7163781639
commit d1cdef596c
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
17 changed files with 606 additions and 284 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
modules/gapi/perf/common/gapi_core_perf_tests.hpp
View File

@ -43,8 +43,8 @@ namespace opencv_test
class Polar2CartPerfTest : public TestPerfParams<tuple<compare_f, cv::Size, cv::GCompileArgs>> {};
class Cart2PolarPerfTest : public TestPerfParams<tuple<compare_f, cv::Size, cv::GCompileArgs>> {};
class CmpPerfTest : public TestPerfParams<tuple<CmpTypes, cv::Size, MatType, cv::GCompileArgs>> {};
class CmpWithScalarPerfTest : public TestPerfParams<tuple<CmpTypes, cv::Size, MatType, cv::GCompileArgs>> {};
class BitwisePerfTest : public TestPerfParams<tuple<bitwiseOp, cv::Size, MatType, cv::GCompileArgs>> {};
class CmpWithScalarPerfTest : public TestPerfParams<tuple<compare_f, CmpTypes, cv::Size, MatType, cv::GCompileArgs>> {};
class BitwisePerfTest : public TestPerfParams<tuple<bitwiseOp, bool, cv::Size, MatType, cv::GCompileArgs>> {};
class BitwiseNotPerfTest : public TestPerfParams<tuple<cv::Size, MatType, cv::GCompileArgs>> {};
class SelectPerfTest : public TestPerfParams<tuple<cv::Size, MatType, cv::GCompileArgs>> {};
class MinPerfTest : public TestPerfParams<tuple<cv::Size, MatType, cv::GCompileArgs>> {};

114
modules/gapi/perf/common/gapi_core_perf_tests_inl.hpp
View File

@ -402,10 +402,6 @@ PERF_TEST_P_(DivRCPerfTest, TestPerformance)
// FIXIT Unstable input data for divide
initMatsRandU(type, sz, dtype, false);
// FIXIT Unstable input data for divide, don't process zeros
sc += Scalar::all(1);
in_mat1 += 1;
// OpenCV code ///////////////////////////////////////////////////////////
cv::divide(sc, in_mat1, out_mat_ocv, 1.0, dtype);
@ -426,7 +422,7 @@ PERF_TEST_P_(DivRCPerfTest, TestPerformance)
}
// Comparison ////////////////////////////////////////////////////////////
EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
// FIXIT unrealiable check: EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
EXPECT_EQ(out_mat_gapi.size(), sz);
SANITY_CHECK_NOTHING();
@ -630,10 +626,12 @@ PERF_TEST_P_(CmpPerfTest, TestPerformance)
PERF_TEST_P_(CmpWithScalarPerfTest, TestPerformance)
{
CmpTypes opType = get<0>(GetParam());
cv::Size sz = get<1>(GetParam());
MatType type = get<2>(GetParam());
cv::GCompileArgs compile_args = get<3>(GetParam());
MatType type = -1;
CmpTypes opType = CMP_EQ;
cv::Size sz;
compare_f cmpF;
cv::GCompileArgs compile_args;
std::tie(cmpF, opType, sz, type, compile_args) = GetParam();
initMatsRandU(type, sz, CV_8U, false);
@ -666,8 +664,8 @@ PERF_TEST_P_(CmpWithScalarPerfTest, TestPerformance)
}
// Comparison ////////////////////////////////////////////////////////////
EXPECT_EQ(0, cvtest::norm(out_mat_gapi, out_mat_ocv, NORM_INF));
EXPECT_EQ(out_mat_gapi.size(), sz);
EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
SANITY_CHECK_NOTHING();
}
@ -676,50 +674,76 @@ PERF_TEST_P_(CmpWithScalarPerfTest, TestPerformance)
PERF_TEST_P_(BitwisePerfTest, TestPerformance)
{
bitwiseOp opType = get<0>(GetParam());
cv::Size sz = get<1>(GetParam());
MatType type = get<2>(GetParam());
cv::GCompileArgs compile_args = get<3>(GetParam());
MatType type = -1;
bitwiseOp opType = AND;
bool testWithScalar = false;
cv::Size sz;
cv::GCompileArgs compile_args;
std::tie(opType, testWithScalar, sz, type, compile_args) = GetParam();
initMatsRandU(type, sz, type, false);
// G-API code & corresponding OpenCV code ////////////////////////////////
cv::GMat in1, in2, out;
switch (opType)
if( testWithScalar )
{
case AND:
{
out = cv::gapi::bitwise_and(in1, in2);
cv::bitwise_and(in_mat1, in_mat2, out_mat_ocv);
break;
}
case OR:
{
out = cv::gapi::bitwise_or(in1, in2);
cv::bitwise_or(in_mat1, in_mat2, out_mat_ocv);
break;
}
case XOR:
{
out = cv::gapi::bitwise_xor(in1, in2);
cv::bitwise_xor(in_mat1, in_mat2, out_mat_ocv);
break;
}
default:
{
FAIL() << "no such bitwise operation type!";
}
}
cv::GComputation c(GIn(in1, in2), GOut(out));
cv::GScalar sc1;
switch (opType)
{
case AND:
out = cv::gapi::bitwise_and(in1, sc1);
cv::bitwise_and(in_mat1, sc, out_mat_ocv);
break;
case OR:
out = cv::gapi::bitwise_or(in1, sc1);
cv::bitwise_or(in_mat1, sc, out_mat_ocv);
break;
case XOR:
out = cv::gapi::bitwise_xor(in1, sc1);
cv::bitwise_xor(in_mat1, sc, out_mat_ocv);
break;
default:
FAIL() << "no such bitwise operation type!";
}
cv::GComputation c(GIn(in1, sc1), GOut(out));
// Warm-up graph engine:
auto cc = c.compile(descr_of(gin(in_mat1, in_mat2)),
std::move(compile_args));
cc(gin(in_mat1, in_mat2), gout(out_mat_gapi));
// Warm-up graph engine:
c.apply(gin(in_mat1, sc), gout(out_mat_gapi), std::move(compile_args));
TEST_CYCLE()
TEST_CYCLE()
{
c.apply(gin(in_mat1, sc), gout(out_mat_gapi));
}
}
else
{
cc(gin(in_mat1, in_mat2), gout(out_mat_gapi));
switch (opType)
{
case AND:
out = cv::gapi::bitwise_and(in1, in2);
cv::bitwise_and(in_mat1, in_mat2, out_mat_ocv);
break;
case OR:
out = cv::gapi::bitwise_or(in1, in2);
cv::bitwise_or(in_mat1, in_mat2, out_mat_ocv);
break;
case XOR:
out = cv::gapi::bitwise_xor(in1, in2);
cv::bitwise_xor(in_mat1, in_mat2, out_mat_ocv);
break;
default:
FAIL() << "no such bitwise operation type!";
}
cv::GComputation c(GIn(in1, in2), GOut(out));
// Warm-up graph engine:
c.apply(gin(in_mat1, in_mat2), gout(out_mat_gapi), std::move(compile_args));
TEST_CYCLE()
{
c.apply(gin(in_mat1, in_mat2), gout(out_mat_gapi));
}
}
// Comparison ////////////////////////////////////////////////////////////

16
modules/gapi/perf/cpu/gapi_core_perf_tests_cpu.cpp
View File

@ -110,16 +110,18 @@ INSTANTIATE_TEST_CASE_P(CmpPerfTestCPU, CmpPerfTest,
Values(cv::compile_args(CORE_CPU))));
INSTANTIATE_TEST_CASE_P(CmpWithScalarPerfTestCPU, CmpWithScalarPerfTest,
Combine(Values(CMP_EQ, CMP_GE, CMP_NE, CMP_GT, CMP_LT, CMP_LE),
Values(szSmall128, szVGA, sz720p, sz1080p),
Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
Values(cv::compile_args(CORE_CPU))));
Combine(Values(AbsExact().to_compare_f()),
Values(CMP_EQ, CMP_GE, CMP_NE, CMP_GT, CMP_LT, CMP_LE),
Values(szSmall128, szVGA, sz720p, sz1080p),
Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
Values(cv::compile_args(CORE_CPU))));
INSTANTIATE_TEST_CASE_P(BitwisePerfTestCPU, BitwisePerfTest,
Combine(Values(AND, OR, XOR),
Values(szSmall128, szVGA, sz720p, sz1080p),
Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1),
Values(cv::compile_args(CORE_CPU))));
testing::Bool(),
Values(szSmall128, szVGA, sz720p, sz1080p),
Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1),
Values(cv::compile_args(CORE_CPU))));
INSTANTIATE_TEST_CASE_P(BitwiseNotPerfTestCPU, BitwiseNotPerfTest,
Combine(Values(szSmall128, szVGA, sz720p, sz1080p),

10
modules/gapi/perf/cpu/gapi_core_perf_tests_fluid.cpp
View File

@ -107,13 +107,15 @@ INSTANTIATE_TEST_CASE_P(SubPerfTestFluid, SubPerfTest,
// Values(cv::compile_args(CORE_FLUID))));
INSTANTIATE_TEST_CASE_P(CmpWithScalarPerfTestFluid, CmpWithScalarPerfTest,
Combine(Values(CMP_EQ, CMP_GE, CMP_NE, CMP_GT, CMP_LT, CMP_LE),
Values(szSmall128, szVGA, sz720p, sz1080p),
Values(CV_8UC1, CV_8UC3, CV_16SC1, CV_32FC1),
Values(cv::compile_args(CORE_FLUID))));
Combine(Values(AbsSimilarPoints(1, 0.01).to_compare_f()),
Values(CMP_EQ, CMP_GE, CMP_NE, CMP_GT, CMP_LT, CMP_LE),
Values(szSmall128, szVGA, sz720p, sz1080p),
Values(CV_8UC1, CV_8UC3, CV_16SC1, CV_32FC1),
Values(cv::compile_args(CORE_FLUID))));
INSTANTIATE_TEST_CASE_P(BitwisePerfTestFluid, BitwisePerfTest,
Combine(Values(AND, OR, XOR),
testing::Bool(),
Values(szSmall128, szVGA, sz720p, sz1080p),
Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1),
Values(cv::compile_args(CORE_FLUID))));

4
modules/gapi/perf/gpu/gapi_core_perf_tests_gpu.cpp
View File

@ -108,13 +108,15 @@ INSTANTIATE_TEST_CASE_P(CmpPerfTestGPU, CmpPerfTest,
Values(cv::compile_args(CORE_GPU))));
INSTANTIATE_TEST_CASE_P(CmpWithScalarPerfTestGPU, CmpWithScalarPerfTest,
Combine(Values(CMP_EQ, CMP_GE, CMP_NE, CMP_GT, CMP_LT, CMP_LE),
Combine(Values(AbsExact().to_compare_f()),
Values(CMP_EQ, CMP_GE, CMP_NE, CMP_GT, CMP_LT, CMP_LE),
Values( szSmall128, szVGA, sz720p, sz1080p ),
Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
Values(cv::compile_args(CORE_GPU))));
INSTANTIATE_TEST_CASE_P(BitwisePerfTestGPU, BitwisePerfTest,
Combine(Values(AND, OR, XOR),
testing::Bool(),
Values( szSmall128, szVGA, sz720p, sz1080p ),
Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1),
Values(cv::compile_args(CORE_GPU))));

138
modules/gapi/src/backends/fluid/gfluidcore.cpp
View File

@ -806,7 +806,7 @@ GAPI_FLUID_KERNEL(GFluidDivRC, cv::gapi::core::GDivRC, false)
enum Bitwise { BW_AND, BW_OR, BW_XOR, BW_NOT };
template<typename DST, typename SRC1, typename SRC2>
static void run_bitwise2(Buffer &dst, const View &src1, const View &src2, Bitwise bitwise)
static void run_bitwise2(Buffer &dst, const View &src1, const View &src2, Bitwise bitwise_op)
{
static_assert(std::is_same<DST, SRC1>::value, "wrong types");
static_assert(std::is_same<DST, SRC2>::value, "wrong types");
@ -819,7 +819,7 @@ static void run_bitwise2(Buffer &dst, const View &src1, const View &src2, Bitwis
int chan = dst.meta().chan;
int length = width * chan;
switch (bitwise)
switch (bitwise_op)
{
case BW_AND:
for (int l=0; l < length; l++)
@ -838,7 +838,7 @@ static void run_bitwise2(Buffer &dst, const View &src1, const View &src2, Bitwis
}
template<typename DST, typename SRC>
static void run_bitwise1(Buffer &dst, const View &src, Bitwise bitwise)
static void run_bitwise1(Buffer &dst, const View &src, Bitwise bitwise_op)
{
static_assert(std::is_same<DST, SRC>::value, "wrong types");
@ -849,7 +849,7 @@ static void run_bitwise1(Buffer &dst, const View &src, Bitwise bitwise)
int chan = dst.meta().chan;
int length = width * chan;
switch (bitwise)
switch (bitwise_op)
{
case BW_NOT:
for (int l=0; l < length; l++)
@ -922,6 +922,133 @@ GAPI_FLUID_KERNEL(GFluidNot, cv::gapi::core::GNot, false)
}
};
//--------------------------------------
//
// Fluid math kernels: bitwise with Scalar
//
//--------------------------------------
static std::array<int,4> convertScalarForBitwise(const cv::Scalar &_scalar)
{
std::array<int,4> scalarI = {
static_cast<int>(_scalar[0]),
static_cast<int>(_scalar[1]),
static_cast<int>(_scalar[2]),
static_cast<int>(_scalar[3])
};
if (!((_scalar[0] == scalarI[0]) && (_scalar[1] == scalarI[1]) &&
(_scalar[2] == scalarI[2]) && (_scalar[3] == scalarI[3])))
{
CV_Error(cv::Error::StsBadArg, "Bitwise operations make sense with integral types only");
}
return scalarI;
}
template<typename DST>
static inline DST bw_andS(DST x, int y)
{
return x & saturate<DST>(y);
}
template<typename DST>
static inline DST bw_orS(DST x, int y)
{
return x | saturate<DST>(y);
}
template<typename DST>
static inline DST bw_xorS(DST x, int y)
{
return x ^ saturate<DST>(y);
}
// manually unroll the inner cycle by channels
// (reuse arithmetic function above of the same purpose)
template<typename DST, typename FUNC>
static inline void run_bitwise_s(DST out[], const DST in[], int width, int chan,
const int scalar[4], FUNC func)
{
run_arithm_s(out, in, width, chan, scalar, func);
}
template<typename DST, typename SRC>
static void run_bitwise_s(Buffer &dst, const View &src, const int scalar[4], Bitwise bitwise_op)
{
static_assert(std::is_same<DST, SRC>::value, "wrong types");
const auto *in = src.InLine<SRC>(0);
auto *out = dst.OutLine<DST>();
int width = dst.length();
int chan = dst.meta().chan;
switch (bitwise_op)
{
case BW_AND:
run_bitwise_s(out, in, width, chan, scalar, bw_andS<DST>);
break;
case BW_OR:
run_bitwise_s(out, in, width, chan, scalar, bw_orS<DST>);
break;
case BW_XOR:
run_bitwise_s(out, in, width, chan, scalar, bw_xorS<DST>);
break;
default: CV_Error(cv::Error::StsBadArg, "unsupported bitwise operation");
}
}
GAPI_FLUID_KERNEL(GFluidAndS, cv::gapi::core::GAndS, false)
{
static const int Window = 1;
static void run(const View &src, const cv::Scalar &_scalar, Buffer &dst)
{
std::array<int,4> scalar = convertScalarForBitwise(_scalar);
// DST SRC OP __VA_ARGS__
UNARY_(uchar , uchar , run_bitwise_s, dst, src, scalar.data(), BW_AND);
UNARY_(ushort, ushort, run_bitwise_s, dst, src, scalar.data(), BW_AND);
UNARY_( short, short, run_bitwise_s, dst, src, scalar.data(), BW_AND);
CV_Error(cv::Error::StsBadArg, "unsupported combination of types");
}
};
GAPI_FLUID_KERNEL(GFluidOrS, cv::gapi::core::GOrS, false)
{
static const int Window = 1;
static void run(const View &src, const cv::Scalar &_scalar, Buffer &dst)
{
std::array<int,4> scalar = convertScalarForBitwise(_scalar);
// DST SRC OP __VA_ARGS__
UNARY_(uchar , uchar , run_bitwise_s, dst, src, scalar.data(), BW_OR);
UNARY_(ushort, ushort, run_bitwise_s, dst, src, scalar.data(), BW_OR);
UNARY_( short, short, run_bitwise_s, dst, src, scalar.data(), BW_OR);
CV_Error(cv::Error::StsBadArg, "unsupported combination of types");
}
};
GAPI_FLUID_KERNEL(GFluidXorS, cv::gapi::core::GXorS, false)
{
static const int Window = 1;
static void run(const View &src, const cv::Scalar &_scalar, Buffer &dst)
{
std::array<int,4> scalar = convertScalarForBitwise(_scalar);
// DST SRC OP __VA_ARGS__
UNARY_(uchar , uchar , run_bitwise_s, dst, src, scalar.data(), BW_XOR);
UNARY_(ushort, ushort, run_bitwise_s, dst, src, scalar.data(), BW_XOR);
UNARY_( short, short, run_bitwise_s, dst, src, scalar.data(), BW_XOR);
CV_Error(cv::Error::StsBadArg, "unsupported combination of types");
}
};
//-------------------
//
// Fluid kernels: LUT
@ -2175,6 +2302,9 @@ cv::gapi::GKernelPackage cv::gapi::core::fluid::kernels()
,GFluidAnd
,GFluidOr
,GFluidXor
,GFluidAndS
,GFluidOrS
,GFluidXorS
,GFluidMin
,GFluidMax
,GFluidCmpGT

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

@ -88,8 +88,8 @@ GAPI_TEST_FIXTURE(MeanTest, initMatrixRandU, <>, 0)
GAPI_TEST_FIXTURE(MaskTest, initMatrixRandU, <>, 0)
GAPI_TEST_FIXTURE(Polar2CartTest, initMatsRandU, <>, 0)
GAPI_TEST_FIXTURE(Cart2PolarTest, initMatsRandU, <>, 0)
GAPI_TEST_FIXTURE(CmpTest, initMatsRandU, FIXTURE_API(CmpTypes,bool), 2, opType, testWithScalar)
GAPI_TEST_FIXTURE(BitwiseTest, initMatsRandU, FIXTURE_API(bitwiseOp), 1, opType)
GAPI_TEST_FIXTURE(CmpTest, initMatsRandU, FIXTURE_API(CmpTypes,bool,CompareMats), 3, opType, testWithScalar, cmpF)
GAPI_TEST_FIXTURE(BitwiseTest, initMatsRandU, FIXTURE_API(bitwiseOp,bool), 2, opType, testWithScalar)
GAPI_TEST_FIXTURE(NotTest, initMatrixRandU, <>, 0)
GAPI_TEST_FIXTURE(SelectTest, initMatsRandU, <>, 0)
GAPI_TEST_FIXTURE(MinTest, initMatsRandU, <>, 0)

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

@ -48,14 +48,14 @@ TEST_P(MathOpTest, MatricesAccuracyTest)
{
if( doReverseOp )
{
in_mat1.setTo(1, in_mat1 == 0); // avoid zeros in divide input data
in_mat1.setTo(1, in_mat1 == 0); // avoiding zeros in divide input data
out = cv::gapi::divRC(sc1, in1, scale, dtype);
cv::divide(sc, in_mat1, out_mat_ocv, scale, dtype);
break;
}
else
{
sc += Scalar(1, 1, 1, 1); // avoid zeros in divide input data
sc += Scalar(sc[0] == 0, sc[1] == 0, sc[2] == 0, sc[3] == 0); // avoiding zeros in divide input data
out = cv::gapi::divC(in1, sc1, scale, dtype);
cv::divide(in_mat1, sc, out_mat_ocv, scale, dtype);
break;
@ -94,7 +94,7 @@ TEST_P(MathOpTest, MatricesAccuracyTest)
}
case (DIV):
{
in_mat2.setTo(1, in_mat2 == 0); // avoid zeros in divide input data
in_mat2.setTo(1, in_mat2 == 0); // avoiding zeros in divide input data
out = cv::gapi::div(in1, in2, scale, dtype);
cv::divide(in_mat1, in_mat2, out_mat_ocv, scale, dtype);
break;
@ -406,7 +406,7 @@ TEST_P(CmpTest, AccuracyTest)
// Comparison //////////////////////////////////////////////////////////////
{
ASSERT_EQ(out_mat_gapi.size(), sz);
EXPECT_EQ(0, cvtest::norm(out_mat_gapi, out_mat_ocv, NORM_INF));
EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
}
}
@ -414,33 +414,52 @@ TEST_P(BitwiseTest, AccuracyTest)
{
// G-API code & corresponding OpenCV code ////////////////////////////////
cv::GMat in1, in2, out;
switch(opType)
if( testWithScalar )
{
case AND:
cv::GScalar sc1;
switch(opType)
{
out = cv::gapi::bitwise_and(in1, in2);
cv::bitwise_and(in_mat1, in_mat2, out_mat_ocv);
break;
}
case OR:
{
out = cv::gapi::bitwise_or(in1, in2);
cv::bitwise_or(in_mat1, in_mat2, out_mat_ocv);
break;
}
case XOR:
{
out = cv::gapi::bitwise_xor(in1, in2);
cv::bitwise_xor(in_mat1, in_mat2, out_mat_ocv);
break;
}
default:
{
FAIL() << "no such bitwise operation type!";
case AND:
out = cv::gapi::bitwise_and(in1, sc1);
cv::bitwise_and(in_mat1, sc, out_mat_ocv);
break;
case OR:
out = cv::gapi::bitwise_or(in1, sc1);
cv::bitwise_or(in_mat1, sc, out_mat_ocv);
break;
case XOR:
out = cv::gapi::bitwise_xor(in1, sc1);
cv::bitwise_xor(in_mat1, sc, out_mat_ocv);
break;
default:
FAIL() << "no such bitwise operation type!";
}
cv::GComputation c(GIn(in1, sc1), GOut(out));
c.apply(gin(in_mat1, sc), gout(out_mat_gapi), getCompileArgs());
}
cv::GComputation c(GIn(in1, in2), GOut(out));
c.apply(gin(in_mat1, in_mat2), gout(out_mat_gapi), getCompileArgs());
else
{
switch(opType)
{
case AND:
out = cv::gapi::bitwise_and(in1, in2);
cv::bitwise_and(in_mat1, in_mat2, out_mat_ocv);
break;
case OR:
out = cv::gapi::bitwise_or(in1, in2);
cv::bitwise_or(in_mat1, in_mat2, out_mat_ocv);
break;
case XOR:
out = cv::gapi::bitwise_xor(in1, in2);
cv::bitwise_xor(in_mat1, in_mat2, out_mat_ocv);
break;
default:
FAIL() << "no such bitwise operation type!";
}
cv::GComputation c(GIn(in1, in2), GOut(out));
c.apply(gin(in_mat1, in_mat2), gout(out_mat_gapi), getCompileArgs());
}
// Comparison //////////////////////////////////////////////////////////////
{

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

@ -12,178 +12,214 @@
namespace opencv_test
{
enum operation
{
ADD, SUB, MUL, DIV,
ADDR, SUBR, MULR, DIVR,
GT, LT, GE, LE, EQ, NE,
GTR, LTR, GER, LER, EQR, NER,
AND, OR, XOR,
ANDR, ORR, XORR
};
// Note: namespace must match the namespace of the type of the printed object
inline std::ostream& operator<<(std::ostream& os, operation op)
{
#define CASE(v) case operation::v: os << #v; break
switch (op)
{
CASE(ADD); CASE(SUB); CASE(MUL); CASE(DIV);
CASE(ADDR); CASE(SUBR); CASE(MULR); CASE(DIVR);
CASE(GT); CASE(LT); CASE(GE); CASE(LE); CASE(EQ); CASE(NE);
CASE(GTR); CASE(LTR); CASE(GER); CASE(LER); CASE(EQR); CASE(NER);
CASE(AND); CASE(OR); CASE(XOR);
CASE(ANDR); CASE(ORR); CASE(XORR);
default: GAPI_Assert(false && "unknown operation value");
}
#undef CASE
return os;
}
namespace
{
// declare test cases for matrix and scalar operators
auto opADD_gapi = [](cv::GMat in,cv::GScalar c){return in + c;};
auto opADD_ocv = [](const cv::Mat& in, cv::Scalar c, cv::Mat& out){cv::add(in, c, out);};
auto opADDR_gapi = [](cv::GMat in,cv::GScalar c){return c + in;};
auto opADDR_ocv = [](const cv::Mat& in, cv::Scalar c, cv::Mat& out){cv::add(c, in, out);};
auto opSUB_gapi = [](cv::GMat in,cv::GScalar c){return in - c;};
auto opSUB_ocv = [](const cv::Mat& in, cv::Scalar c, cv::Mat& out){cv::subtract(in, c, out);};
auto opSUBR_gapi = [](cv::GMat in,cv::GScalar c){return c - in;};
auto opSUBR_ocv = [](const cv::Mat& in, cv::Scalar c, cv::Mat& out){cv::subtract(c, in, out);};
auto opMUL_gapi = [](cv::GMat in,cv::GScalar c){return in * c;};
auto opMUL_ocv = [](const cv::Mat& in, cv::Scalar c, cv::Mat& out){cv::multiply(in, c, out);};
auto opMULR_gapi = [](cv::GMat in,cv::GScalar c){return c * in;};
auto opMULR_ocv = [](const cv::Mat& in, cv::Scalar c, cv::Mat& out){cv::multiply(c, in, out);};
auto opDIV_gapi = [](cv::GMat in,cv::GScalar c){return in / c;};
auto opDIV_ocv = [](const cv::Mat& in, cv::Scalar c, cv::Mat& out){cv::divide(in, c, out);};
auto opDIVR_gapi = [](cv::GMat in,cv::GScalar c){return c / in;};
auto opDIVR_ocv = [](const cv::Mat& in, cv::Scalar c, cv::Mat& out){cv::divide(c, in, out);};
auto opGT_gapi = [](cv::GMat in,cv::GScalar c){return in > c;};
auto opGT_ocv = [](const cv::Mat& in, cv::Scalar c, cv::Mat& out){cv::compare(in, c, out,cv::CMP_GT);};
auto opGTR_gapi = [](cv::GMat in,cv::GScalar c){return c > in;};
auto opGTR_ocv = [](const cv::Mat& in, cv::Scalar c, cv::Mat& out){cv::compare(c, in, out,cv::CMP_GT);};
auto opLT_gapi = [](cv::GMat in,cv::GScalar c){return in < c;};
auto opLT_ocv = [](const cv::Mat& in, cv::Scalar c, cv::Mat& out){cv::compare(in, c, out,cv::CMP_LT);};
auto opLTR_gapi = [](cv::GMat in,cv::GScalar c){return c < in;};
auto opLTR_ocv = [](const cv::Mat& in, cv::Scalar c, cv::Mat& out){cv::compare(c, in, out,cv::CMP_LT);};
auto opGE_gapi = [](cv::GMat in,cv::GScalar c){return in >= c;};
auto opGE_ocv = [](const cv::Mat& in, cv::Scalar c, cv::Mat& out){cv::compare(in, c, out,cv::CMP_GE);};
auto opGER_gapi = [](cv::GMat in,cv::GScalar c){return c >= in;};
auto opGER_ocv = [](const cv::Mat& in, cv::Scalar c, cv::Mat& out){cv::compare(c, in, out,cv::CMP_GE);};
auto opLE_gapi = [](cv::GMat in,cv::GScalar c){return in <= c;};
auto opLE_ocv = [](const cv::Mat& in, cv::Scalar c, cv::Mat& out){cv::compare(in, c, out,cv::CMP_LE);};
auto opLER_gapi = [](cv::GMat in,cv::GScalar c){return c <= in;};
auto opLER_ocv = [](const cv::Mat& in, cv::Scalar c, cv::Mat& out){cv::compare(c, in, out,cv::CMP_LE);};
auto opEQ_gapi = [](cv::GMat in,cv::GScalar c){return in == c;};
auto opEQ_ocv = [](const cv::Mat& in, cv::Scalar c, cv::Mat& out){cv::compare(in, c, out,cv::CMP_EQ);};
auto opEQR_gapi = [](cv::GMat in,cv::GScalar c){return c == in;};
auto opEQR_ocv = [](const cv::Mat& in, cv::Scalar c, cv::Mat& out){cv::compare(c, in, out,cv::CMP_EQ);};
auto opNE_gapi = [](cv::GMat in,cv::GScalar c){return in != c;};
auto opNE_ocv = [](const cv::Mat& in, cv::Scalar c, cv::Mat& out){cv::compare(in, c, out,cv::CMP_NE);};
auto opNER_gapi = [](cv::GMat in,cv::GScalar c){return c != in;};
auto opNER_ocv = [](const cv::Mat& in, cv::Scalar c, cv::Mat& out){cv::compare(c, in, out,cv::CMP_NE);};
auto opAND_gapi = [](cv::GMat in,cv::GScalar c){return in & c;};
auto opAND_ocv = [](const cv::Mat& in, const cv::Scalar& c, cv::Mat& out){cv::bitwise_and(in, c, out);};
auto opOR_gapi = [](cv::GMat in,cv::GScalar c){return in | c;};
auto opOR_ocv = [](const cv::Mat& in, const cv::Scalar& c, cv::Mat& out){cv::bitwise_or(in, c, out);};
auto opXOR_gapi = [](cv::GMat in,cv::GScalar c){return in ^ c;};
auto opXOR_ocv = [](const cv::Mat& in, const cv::Scalar& c, cv::Mat& out){cv::bitwise_xor(in, c, out);};
auto opANDR_gapi = [](cv::GMat in,cv::GScalar c){return c & in;};
auto opANDR_ocv = [](const cv::Mat& in, const cv::Scalar& c, cv::Mat& out){cv::bitwise_and(c, in, out);};
auto opORR_gapi = [](cv::GMat in,cv::GScalar c){return c | in;};
auto opORR_ocv = [](const cv::Mat& in, const cv::Scalar& c, cv::Mat& out){cv::bitwise_or(c, in, out);};
auto opXORR_gapi = [](cv::GMat in,cv::GScalar c){return c ^ in;};
auto opXORR_ocv = [](const cv::Mat& in, const cv::Scalar& c, cv::Mat& out){cv::bitwise_xor(c, in, out);};
// declare test cases for matrix and matrix operators
auto opADDM_gapi = [](cv::GMat in1,cv::GMat in2){return in1 + in2;};
auto opADDM_ocv = [](const cv::Mat& in1, const cv::Mat& in2, cv::Mat& out){cv::add(in1, in2, out);};
auto opSUBM_gapi = [](cv::GMat in1,cv::GMat in2){return in1 - in2;};
auto opSUBM_ocv = [](const cv::Mat& in1, const cv::Mat& in2, cv::Mat& out){cv::subtract(in1, in2, out);};
auto opDIVM_gapi = [](cv::GMat in1,cv::GMat in2){return in1 / in2;};
auto opDIVM_ocv = [](const cv::Mat& in1, const cv::Mat& in2, cv::Mat& out){cv::divide(in1, in2, out);};
auto opGTM_gapi = [](cv::GMat in1,cv::GMat in2){return in1 > in2;};
auto opGTM_ocv = [](const cv::Mat& in1, const cv::Mat& in2, cv::Mat& out){cv::compare(in1, in2, out, cv::CMP_GT);};
auto opGEM_gapi = [](cv::GMat in1,cv::GMat in2){return in1 >= in2;};
auto opGEM_ocv = [](const cv::Mat& in1, const cv::Mat& in2, cv::Mat& out){cv::compare(in1, in2, out, cv::CMP_GE);};
auto opLTM_gapi = [](cv::GMat in1,cv::GMat in2){return in1 < in2;};
auto opLTM_ocv = [](const cv::Mat& in1, const cv::Mat& in2, cv::Mat& out){cv::compare(in1, in2, out, cv::CMP_LT);};
auto opLEM_gapi = [](cv::GMat in1,cv::GMat in2){return in1 <= in2;};
auto opLEM_ocv = [](const cv::Mat& in1, const cv::Mat& in2, cv::Mat& out){cv::compare(in1, in2, out, cv::CMP_LE);};
auto opEQM_gapi = [](cv::GMat in1,cv::GMat in2){return in1 == in2;};
auto opEQM_ocv = [](const cv::Mat& in1, const cv::Mat& in2, cv::Mat& out){cv::compare(in1, in2, out, cv::CMP_EQ);};
auto opNEM_gapi = [](cv::GMat in1,cv::GMat in2){return in1 != in2;};
auto opNEM_ocv = [](const cv::Mat& in1, const cv::Mat& in2, cv::Mat& out){cv::compare(in1, in2, out, cv::CMP_NE);};
auto opANDM_gapi = [](cv::GMat in1,cv::GMat in2){return in1 & in2;};
auto opANDM_ocv = [](const cv::Mat& in1, const cv::Mat& in2, cv::Mat& out){cv::bitwise_and(in1, in2, out);};
auto opORM_gapi = [](cv::GMat in1,cv::GMat in2){return in1 | in2;};
auto opORM_ocv = [](const cv::Mat& in1, const cv::Mat& in2, cv::Mat& out){cv::bitwise_or(in1, in2, out);};
auto opXORM_gapi = [](cv::GMat in1,cv::GMat in2){return in1 ^ in2;};
auto opXORM_ocv = [](const cv::Mat& in1, const cv::Mat& in2, cv::Mat& out){cv::bitwise_xor(in1, in2, out);};
} // anonymous namespace
struct g_api_ocv_pair_mat_scalar {
using g_api_function_t = std::function<cv::GMat(cv::GMat,cv::GScalar)>;
using ocv_function_t = std::function<void(cv::Mat const&, cv::Scalar, cv::Mat&)>;
std::string name;
g_api_function_t g_api_function;
ocv_function_t ocv_function;
g_api_ocv_pair_mat_scalar(std::string const& n, g_api_function_t const& g, ocv_function_t const& o)
: name(n), g_api_function(g), ocv_function(o) {}
g_api_ocv_pair_mat_scalar() = default;
friend std::ostream& operator<<(std::ostream& o, const g_api_ocv_pair_mat_scalar& p)
#define CASE(v) case operation::v: \
g_api_function = op##v##_gapi; \
ocv_function = op##v##_ocv; \
break
g_api_ocv_pair_mat_scalar(operation op)
{
return o<<p.name;
switch (op)
{
CASE(ADD); CASE(SUB); CASE(MUL); CASE(DIV);
CASE(ADDR); CASE(SUBR); CASE(MULR); CASE(DIVR);
CASE(GT); CASE(LT); CASE(GE); CASE(LE); CASE(EQ); CASE(NE);
CASE(GTR); CASE(LTR); CASE(GER); CASE(LER); CASE(EQR); CASE(NER);
CASE(AND); CASE(OR); CASE(XOR);
CASE(ANDR); CASE(ORR); CASE(XORR);
default: GAPI_Assert(false && "unknown operation value");
}
}
#undef CASE
};
struct g_api_ocv_pair_mat_mat {
using g_api_function_t = std::function<cv::GMat(cv::GMat,cv::GMat)>;
using ocv_function_t = std::function<void(cv::Mat const&, cv::Mat const&, cv::Mat&)>;
std::string name;
g_api_function_t g_api_function;
ocv_function_t ocv_function;
g_api_ocv_pair_mat_mat(std::string const& n, g_api_function_t const& g, ocv_function_t const& o)
: name(n), g_api_function(g), ocv_function(o) {}
g_api_ocv_pair_mat_mat() = default;
friend std::ostream& operator<<(std::ostream& o, const g_api_ocv_pair_mat_mat& p)
#define CASE(v) case operation::v: \
g_api_function = op##v##M_gapi; \
ocv_function = op##v##M_ocv; \
break
g_api_ocv_pair_mat_mat(operation op)
{
return o<<p.name;
switch (op)
{
CASE(ADD); CASE(SUB); CASE(DIV);
CASE(GT); CASE(LT); CASE(GE); CASE(LE); CASE(EQ); CASE(NE);
CASE(AND); CASE(OR); CASE(XOR);
default: GAPI_Assert(false && "unknown operation value");
}
}
#undef CASE
};
////////////////////////////////////////////////////////////////////////////////
//
// FIXME: Please refactor this test to a template test (T,U) with enum (OP)
//
////////////////////////////////////////////////////////////////////////////////
namespace
{
//declare test cases for matrix and scalar operators
g_api_ocv_pair_mat_scalar opPlus = {std::string{"operator+"},
[](cv::GMat in,cv::GScalar c){return in+c;},
[](const cv::Mat& in, cv::Scalar c, cv::Mat& out){cv::add(in, c, out);}};
g_api_ocv_pair_mat_scalar opPlusR = {std::string{"rev_operator+"},
[](cv::GMat in,cv::GScalar c){return c+in;},
[](const cv::Mat& in, cv::Scalar c, cv::Mat& out){cv::add(c, in, out);}};
g_api_ocv_pair_mat_scalar opMinus = {std::string{"operator-"},
[](cv::GMat in,cv::GScalar c){return in-c;},
[](const cv::Mat& in, cv::Scalar c, cv::Mat& out){cv::subtract(in, c, out);}};
g_api_ocv_pair_mat_scalar opMinusR = {std::string{"rev_operator-"},
[](cv::GMat in,cv::GScalar c){return c-in;},
[](const cv::Mat& in, cv::Scalar c, cv::Mat& out){cv::subtract(c, in, out);}};
g_api_ocv_pair_mat_scalar opMul = {std::string{"operator*"},
[](cv::GMat in,cv::GScalar c){return in*c;},
[](const cv::Mat& in, cv::Scalar c, cv::Mat& out){cv::multiply(in, c, out);}};
g_api_ocv_pair_mat_scalar opMulR = {std::string{"rev_operator*"},
[](cv::GMat in,cv::GScalar c){return c*in;},
[](const cv::Mat& in, cv::Scalar c, cv::Mat& out){cv::multiply(c, in, out);}};
g_api_ocv_pair_mat_scalar opDiv = {std::string{"operator/"},
[](cv::GMat in,cv::GScalar c){return in/c;},
[](const cv::Mat& in, cv::Scalar c, cv::Mat& out){cv::divide(in, c, out);}};
g_api_ocv_pair_mat_scalar opDivR = {std::string{"rev_operator/"},
[](cv::GMat in,cv::GScalar c){return c/in;},
[](const cv::Mat& in, cv::Scalar c, cv::Mat& out){cv::divide(c, in, out);}};
g_api_ocv_pair_mat_scalar opGT = {std::string{"operator>"},
[](cv::GMat in,cv::GScalar c){return in>c;},
[](const cv::Mat& in, cv::Scalar c, cv::Mat& out){cv::compare(in, c, out,cv::CMP_GT);}};
g_api_ocv_pair_mat_scalar opLT = {std::string{"operator<"},
[](cv::GMat in,cv::GScalar c){return in<c;},
[](const cv::Mat& in, cv::Scalar c, cv::Mat& out){cv::compare(in, c, out,cv::CMP_LT);}};
g_api_ocv_pair_mat_scalar opGE = {std::string{"operator>="},
[](cv::GMat in,cv::GScalar c){return in>=c;},
[](const cv::Mat& in, cv::Scalar c, cv::Mat& out){cv::compare(in, c, out,cv::CMP_GE);}};
g_api_ocv_pair_mat_scalar opLE = {std::string{"operator<="},
[](cv::GMat in,cv::GScalar c){return in<=c;},
[](const cv::Mat& in, cv::Scalar c, cv::Mat& out){cv::compare(in, c, out,cv::CMP_LE);}};
g_api_ocv_pair_mat_scalar opEQ = {std::string{"operator=="},
[](cv::GMat in,cv::GScalar c){return in==c;},
[](const cv::Mat& in, cv::Scalar c, cv::Mat& out){cv::compare(in, c, out,cv::CMP_EQ);}};
g_api_ocv_pair_mat_scalar opNE = {std::string{"operator!="},
[](cv::GMat in,cv::GScalar c){return in!=c;},
[](const cv::Mat& in, cv::Scalar c, cv::Mat& out){cv::compare(in, c, out,cv::CMP_NE);}};
g_api_ocv_pair_mat_scalar opGTR = {std::string{"rev_operator>"},
[](cv::GMat in,cv::GScalar c){return c>in;},
[](const cv::Mat& in, cv::Scalar c, cv::Mat& out){cv::compare(c, in, out,cv::CMP_GT);}};
g_api_ocv_pair_mat_scalar opLTR = {std::string{"rev_operator<"},
[](cv::GMat in,cv::GScalar c){return c<in;},
[](const cv::Mat& in, cv::Scalar c, cv::Mat& out){cv::compare(c, in, out,cv::CMP_LT);}};
g_api_ocv_pair_mat_scalar opGER = {std::string{"rev_operator>="},
[](cv::GMat in,cv::GScalar c){return c>=in;},
[](const cv::Mat& in, cv::Scalar c, cv::Mat& out){cv::compare(c, in, out,cv::CMP_GE);}};
g_api_ocv_pair_mat_scalar opLER = {std::string{"rev_operator<="},
[](cv::GMat in,cv::GScalar c){return c<=in;},
[](const cv::Mat& in, cv::Scalar c, cv::Mat& out){cv::compare(c, in, out,cv::CMP_LE);}};
g_api_ocv_pair_mat_scalar opEQR = {std::string{"rev_operator=="},
[](cv::GMat in,cv::GScalar c){return c==in;},
[](const cv::Mat& in, cv::Scalar c, cv::Mat& out){cv::compare(c, in, out,cv::CMP_EQ);}};
g_api_ocv_pair_mat_scalar opNER = {std::string{"rev_operator!="},
[](cv::GMat in,cv::GScalar c){return c!=in;},
[](const cv::Mat& in, cv::Scalar c, cv::Mat& out){cv::compare(c, in, out,cv::CMP_NE);}};
g_api_ocv_pair_mat_scalar opAND = {std::string{"operator&"},
[](cv::GMat in1,cv::GScalar in2){return in1&in2;},
[](const cv::Mat& in1, const cv::Scalar& in2, cv::Mat& out){cv::bitwise_and(in1, in2, out);}};
g_api_ocv_pair_mat_scalar opOR = {std::string{"operator|"},
[](cv::GMat in1,cv::GScalar in2){return in1|in2;},
[](const cv::Mat& in1, const cv::Scalar& in2, cv::Mat& out){cv::bitwise_or(in1, in2, out);}};
g_api_ocv_pair_mat_scalar opXOR = {std::string{"operator^"},
[](cv::GMat in1,cv::GScalar in2){return in1^in2;},
[](const cv::Mat& in1, const cv::Scalar& in2, cv::Mat& out){cv::bitwise_xor(in1, in2, out);}};
g_api_ocv_pair_mat_scalar opANDR = {std::string{"rev_operator&"},
[](cv::GMat in1,cv::GScalar in2){return in2&in1;},
[](const cv::Mat& in1, const cv::Scalar& in2, cv::Mat& out){cv::bitwise_and(in2, in1, out);}};
g_api_ocv_pair_mat_scalar opORR = {std::string{"rev_operator|"},
[](cv::GMat in1,cv::GScalar in2){return in2|in1;},
[](const cv::Mat& in1, const cv::Scalar& in2, cv::Mat& out){cv::bitwise_or(in2, in1, out);}};
g_api_ocv_pair_mat_scalar opXORR = {std::string{"rev_operator^"},
[](cv::GMat in1,cv::GScalar in2){return in2^in1;},
[](const cv::Mat& in1, const cv::Scalar& in2, cv::Mat& out){cv::bitwise_xor(in2, in1, out);}};
// declare test cases for matrix and matrix operators
g_api_ocv_pair_mat_mat opPlusM = {std::string{"operator+"},
[](cv::GMat in1,cv::GMat in2){return in1+in2;},
[](const cv::Mat& in1, const cv::Mat& in2, cv::Mat& out){cv::add(in1, in2, out);}};
g_api_ocv_pair_mat_mat opMinusM = {std::string{"operator-"},
[](cv::GMat in,cv::GMat in2){return in-in2;},
[](const cv::Mat& in, const cv::Mat& in2, cv::Mat& out){cv::subtract(in, in2, out);}};
g_api_ocv_pair_mat_mat opDivM = {std::string{"operator/"},
[](cv::GMat in,cv::GMat in2){return in/in2;},
[](const cv::Mat& in, const cv::Mat& in2, cv::Mat& out){cv::divide(in, in2, out);}};
g_api_ocv_pair_mat_mat opGreater = {std::string{"operator>"},
[](cv::GMat in1,cv::GMat in2){return in1>in2;},
[](const cv::Mat& in1, const cv::Mat& in2, cv::Mat& out){cv::compare(in1, in2, out, cv::CMP_GT);}};
g_api_ocv_pair_mat_mat opGreaterEq = {std::string{"operator>="},
[](cv::GMat in1,cv::GMat in2){return in1>=in2;},
[](const cv::Mat& in1, const cv::Mat& in2, cv::Mat& out){cv::compare(in1, in2, out, cv::CMP_GE);}};
g_api_ocv_pair_mat_mat opLess = {std::string{"operator<"},
[](cv::GMat in1,cv::GMat in2){return in1<in2;},
[](const cv::Mat& in1, const cv::Mat& in2, cv::Mat& out){cv::compare(in1, in2, out, cv::CMP_LT);}};
g_api_ocv_pair_mat_mat opLessEq = {std::string{"operator<="},
[](cv::GMat in1,cv::GMat in2){return in1<=in2;},
[](const cv::Mat& in1, const cv::Mat& in2, cv::Mat& out){cv::compare(in1, in2, out, cv::CMP_LE);}};
g_api_ocv_pair_mat_mat opEq = {std::string{"operator=="},
[](cv::GMat in1,cv::GMat in2){return in1==in2;},
[](const cv::Mat& in1, const cv::Mat& in2, cv::Mat& out){cv::compare(in1, in2, out, cv::CMP_EQ);}};
g_api_ocv_pair_mat_mat opNotEq = {std::string{"operator!="},
[](cv::GMat in1,cv::GMat in2){return in1!=in2;},
[](const cv::Mat& in1, const cv::Mat& in2, cv::Mat& out){cv::compare(in1, in2, out, cv::CMP_NE);}};
g_api_ocv_pair_mat_mat opAnd = {std::string{"operator&"},
[](cv::GMat in1,cv::GMat in2){return in1&in2;},
[](const cv::Mat& in1, const cv::Mat& in2, cv::Mat& out){cv::bitwise_and(in1, in2, out);}};
g_api_ocv_pair_mat_mat opOr = {std::string{"operator|"},
[](cv::GMat in1,cv::GMat in2){return in1|in2;},
[](const cv::Mat& in1, const cv::Mat& in2, cv::Mat& out){cv::bitwise_or(in1, in2, out);}};
g_api_ocv_pair_mat_mat opXor = {std::string{"operator^"},
[](cv::GMat in1,cv::GMat in2){return in1^in2;},
[](const cv::Mat& in1, const cv::Mat& in2, cv::Mat& out){cv::bitwise_xor(in1, in2, out);}};
} // anonymous namespace
// Create new value-parameterized test fixture:
// MathOperatorMatScalarTest - fixture name
// initMatsRandU - function that is used to initialize input/output data
@ -200,9 +236,9 @@ g_api_ocv_pair_mat_mat opXor = {std::string{"operator^"},
// - available in test body
// Note: all parameter _values_ (e.g. type CV_8UC3) are set via INSTANTIATE_TEST_CASE_P macro
GAPI_TEST_FIXTURE(MathOperatorMatScalarTest, initMatsRandU,
FIXTURE_API(CompareMats, g_api_ocv_pair_mat_scalar), 2, cmpF, op)
FIXTURE_API(CompareMats, operation), 2, cmpF, op)
GAPI_TEST_FIXTURE(MathOperatorMatMatTest, initMatsRandU,
FIXTURE_API(CompareMats, g_api_ocv_pair_mat_mat), 2, cmpF, op)
FIXTURE_API(CompareMats, operation), 2, cmpF, op)
GAPI_TEST_FIXTURE(NotOperatorTest, initMatrixRandU, <>, 0)
} // opencv_test

18
modules/gapi/test/common/gapi_operators_tests_inl.hpp
View File

@ -14,8 +14,14 @@ namespace opencv_test
{
TEST_P(MathOperatorMatScalarTest, OperatorAccuracyTest )
{
auto fun_gapi = op.g_api_function;
auto fun_ocv = op.ocv_function ;
g_api_ocv_pair_mat_scalar funcs(op);
auto fun_gapi = funcs.g_api_function;
auto fun_ocv = funcs.ocv_function;
if (op == DIVR)
in_mat1.setTo(1, in_mat1 == 0); // avoiding zeros in divide input data
if (op == DIV)
sc += Scalar(sc[0] == 0, sc[1] == 0, sc[2] == 0, sc[3] == 0); // avoiding zeros in divide input data
// G-API code & corresponding OpenCV code ////////////////////////////////
@ -37,8 +43,12 @@ TEST_P(MathOperatorMatScalarTest, OperatorAccuracyTest )
TEST_P(MathOperatorMatMatTest, OperatorAccuracyTest )
{
auto fun_gapi = op.g_api_function;
auto fun_ocv = op.ocv_function ;
g_api_ocv_pair_mat_mat funcs(op);
auto fun_gapi = funcs.g_api_function;
auto fun_ocv = funcs.ocv_function;
if (op == DIV)
in_mat2.setTo(1, in_mat2 == 0); // avoiding zeros in divide input data
// G-API code & corresponding OpenCV code ////////////////////////////////

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

@ -10,6 +10,7 @@
#include <iostream>
#include <tuple>
#include <type_traits>
#include <time.h>
#include <opencv2/ts.hpp>
#include <opencv2/gapi.hpp>
@ -88,16 +89,28 @@ public:
cv::Scalar sc;
// integral Scalar initialization
cv::Scalar initScalarRandU(unsigned upper)
{
auto& rng = cv::theRNG();
double s1 = rng(upper); // FIXIT: RNG result is 'int', not double
cv::RNG rng(time(nullptr));
double s1 = rng(upper);
double s2 = rng(upper);
double s3 = rng(upper);
double s4 = rng(upper);
return cv::Scalar(s1, s2, s3, s4);
}
// floating-point Scalar initialization (cv::core)
cv::Scalar initScalarRandU()
{
cv::RNG rng(time(nullptr));
double s1 = exp(rng.uniform(-1, 6) * 3.0 * CV_LOG2) * (rng.uniform(0, 2) ? 1. : -1.);
double s2 = exp(rng.uniform(-1, 6) * 3.0 * CV_LOG2) * (rng.uniform(0, 2) ? 1. : -1.);
double s3 = exp(rng.uniform(-1, 6) * 3.0 * CV_LOG2) * (rng.uniform(0, 2) ? 1. : -1.);
double s4 = exp(rng.uniform(-1, 6) * 3.0 * CV_LOG2) * (rng.uniform(0, 2) ? 1. : -1.);
return cv::Scalar(s1, s2, s3, s4);
}
void initOutMats(cv::Size sz_in, int dtype)
{
if (dtype != -1)
@ -112,7 +125,32 @@ public:
in_mat1 = cv::Mat(sz_in, type);
in_mat2 = cv::Mat(sz_in, type);
sc = initScalarRandU(100);
int sdepth = CV_MAT_DEPTH(type);
int ddepth = (dtype >= 0) ? CV_MAT_DEPTH(dtype)
: sdepth; // dtype == -1 <=> dtype == SAME_TYPE
if ((sdepth >= CV_32F) || (ddepth >= CV_32F))
{
sc = initScalarRandU(); // initializing by floating-points
}
else
{
switch (sdepth)
{
case CV_8U:
sc = initScalarRandU(UCHAR_MAX + 1U);
break;
case CV_16U:
sc = initScalarRandU(USHRT_MAX + 1U);
break;
case CV_16S:
sc = initScalarRandU(SHRT_MAX + 1U);
break;
default:
sc = initScalarRandU(SCHAR_MAX + 1U);
break;
}
}
// Details: https://github.com/opencv/opencv/pull/16083
//if (CV_MAT_DEPTH(type) < CV_32F)
@ -142,7 +180,33 @@ public:
{
in_mat1 = cv::Mat(sz_in, type);
sc = initScalarRandU(100);
int sdepth = CV_MAT_DEPTH(type);
int ddepth = (dtype >= 0) ? CV_MAT_DEPTH(dtype)
: sdepth; // dtype == -1 <=> dtype == SAME_TYPE
if ((sdepth >= CV_32F) || (ddepth >= CV_32F))
{
sc = initScalarRandU();
}
else
{
switch (sdepth)
{
case CV_8U:
sc = initScalarRandU(UCHAR_MAX + 1U);
break;
case CV_16U:
sc = initScalarRandU(USHRT_MAX + 1U);
break;
case CV_16S:
sc = initScalarRandU(SHRT_MAX + 1U);
break;
default:
sc = initScalarRandU(SCHAR_MAX + 1U);
break;
}
}
if (CV_MAT_DEPTH(type) < CV_32F)
{
cv::randu(in_mat1, cv::Scalar::all(0), cv::Scalar::all(255));

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

@ -155,7 +155,8 @@ INSTANTIATE_TEST_CASE_P(CompareTestCPU, CmpTest,
Values(CV_8U),
Values(CORE_CPU),
Values(CMP_EQ, CMP_GE, CMP_NE, CMP_GT, CMP_LT, CMP_LE),
testing::Bool()));
testing::Bool(),
Values(AbsExact().to_compare_obj())));
INSTANTIATE_TEST_CASE_P(BitwiseTestCPU, BitwiseTest,
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1),
@ -164,7 +165,8 @@ INSTANTIATE_TEST_CASE_P(BitwiseTestCPU, BitwiseTest,
cv::Size(128, 128)),
Values(-1),
Values(CORE_CPU),
Values(AND, OR, XOR)));
Values(AND, OR, XOR),
testing::Bool()));
INSTANTIATE_TEST_CASE_P(BitwiseNotTestCPU, NotTest,
Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1),

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

@ -89,7 +89,8 @@ INSTANTIATE_TEST_CASE_P(BitwiseTestFluid, BitwiseTest,
cv::Size(128, 128)),
Values(-1),
Values(CORE_FLUID),
Values(AND, OR, XOR)));
Values(AND, OR, XOR),
testing::Bool()));
INSTANTIATE_TEST_CASE_P(BitwiseNotTestFluid, NotTest,
Combine(Values(CV_8UC3, CV_8UC1, CV_16UC1, CV_16SC1),
@ -136,7 +137,21 @@ INSTANTIATE_TEST_CASE_P(CompareTestFluid, CmpTest,
Values(CV_8U),
Values(CORE_FLUID),
Values(CMP_EQ, CMP_GE, CMP_NE, CMP_GT, CMP_LT, CMP_LE),
testing::Bool()));
Values(false),
Values(AbsExact().to_compare_obj())));
// FIXME: solve comparison error to unite with the test above
INSTANTIATE_TEST_CASE_P(CompareTestFluidScalar, CmpTest,
Combine(Values(CV_8UC3, CV_8UC1, CV_16SC1, CV_32FC1),
Values(cv::Size(1920, 1080),
cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
Values(CV_8U),
Values(CORE_FLUID),
Values(CMP_EQ, CMP_GE, CMP_NE, CMP_GT, CMP_LT, CMP_LE),
Values(true),
Values(AbsSimilarPoints(1, 0.01).to_compare_obj())));
INSTANTIATE_TEST_CASE_P(AddWeightedTestFluid, AddWeightedTest,
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),

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

@ -23,23 +23,24 @@ INSTANTIATE_TEST_CASE_P(MathOperatorTestCPU, MathOperatorMatMatTest,
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
Values(-1, CV_8U, CV_32F),
Values(-1),
Values(CORE_CPU),
Values(AbsExact().to_compare_obj()),
Values( opPlusM, opMinusM, opDivM,
opGreater, opLess, opGreaterEq, opLessEq, opEq, opNotEq)));
Values( ADD, SUB, DIV,
GT, LT, GE, LE, EQ, NE)));
INSTANTIATE_TEST_CASE_P(MathOperatorTestCPU, MathOperatorMatScalarTest,
Combine(Values(CV_8UC1, CV_16SC1, CV_32FC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
Values(-1, CV_8U, CV_32F),
Values(-1),
Values(CORE_CPU),
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)));
Values( ADD, SUB, MUL, DIV,
ADDR, SUBR, MULR, DIVR,
GT, LT, GE, LE, EQ, NE,
GTR, LTR, GER, LER, EQR, NER)));
INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestCPU, MathOperatorMatMatTest,
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
@ -49,7 +50,7 @@ INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestCPU, MathOperatorMatMatTest,
Values(-1),
Values(CORE_CPU),
Values(AbsExact().to_compare_obj()),
Values( opAnd, opOr, opXor )));
Values( AND, OR, XOR )));
INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestCPU, MathOperatorMatScalarTest,
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
@ -59,7 +60,8 @@ INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestCPU, MathOperatorMatScalarTest,
Values(-1),
Values(CORE_CPU),
Values(AbsExact().to_compare_obj()),
Values( opAND, opOR, opXOR, opANDR, opORR, opXORR )));
Values( AND, OR, XOR,
ANDR, ORR, XORR )));
INSTANTIATE_TEST_CASE_P(BitwiseNotOperatorTestCPU, NotOperatorTest,
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),

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

@ -21,24 +21,34 @@ INSTANTIATE_TEST_CASE_P(MathOperatorTestFluid, MathOperatorMatMatTest,
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
Values(-1, CV_8U, CV_32F),
Values(-1),
Values(CORE_FLUID),
Values(AbsExact().to_compare_obj()),
Values( opPlusM, opMinusM, opDivM,
opGreater, opLess, opGreaterEq, opLessEq, opEq, opNotEq)));
Values( ADD, SUB, DIV,
GT, LT, GE, LE, EQ, NE)));
//FIXME: Some Mat/Scalar Fluid kernels are not there yet!
INSTANTIATE_TEST_CASE_P(DISABLED_MathOperatorTestFluid, MathOperatorMatScalarTest,
INSTANTIATE_TEST_CASE_P(MathOperatorArithmeticTestFluid, MathOperatorMatScalarTest,
Combine(Values(CV_8UC1, CV_16SC1, CV_32FC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
Values(-1, CV_8U, CV_32F),
Values(-1),
Values(CORE_FLUID),
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)));
Values( ADD, SUB, MUL, DIV,
ADDR, SUBR, MULR, DIVR)));
// FIXME: solve comparison error
INSTANTIATE_TEST_CASE_P(MathOperatorCompareTestFluid, MathOperatorMatScalarTest,
Combine(Values(CV_8UC1, CV_16SC1, CV_32FC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
Values(-1),
Values(CORE_FLUID),
Values(AbsSimilarPoints(1, 0.01).to_compare_obj()),
Values( GT, LT, GE, LE, EQ, NE,
GTR, LTR, GER, LER, EQR, NER)));
INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestFluid, MathOperatorMatMatTest,
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
@ -48,10 +58,9 @@ INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestFluid, MathOperatorMatMatTest,
Values(-1),
Values(CORE_FLUID),
Values(AbsExact().to_compare_obj()),
Values( opAnd, opOr, opXor )));
Values( AND, OR, XOR )));
//FIXME: Some Mat/Scalar Fluid kernels are not there yet!
INSTANTIATE_TEST_CASE_P(DISABLED_BitwiseOperatorTestFluid, MathOperatorMatScalarTest,
INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestFluid, MathOperatorMatScalarTest,
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
@ -59,7 +68,8 @@ INSTANTIATE_TEST_CASE_P(DISABLED_BitwiseOperatorTestFluid, MathOperatorMatScalar
Values(-1),
Values(CORE_FLUID),
Values(AbsExact().to_compare_obj()),
Values( opAND, opOR, opXOR, opANDR, opORR, opXORR )));
Values( AND, OR, XOR,
ANDR, ORR, XORR )));
INSTANTIATE_TEST_CASE_P(BitwiseNotOperatorTestFluid, NotOperatorTest,
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),

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

@ -138,7 +138,8 @@ INSTANTIATE_TEST_CASE_P(CompareTestGPU, CmpTest,
Values(CV_8U),
Values(CORE_GPU),
Values(CMP_EQ, CMP_GE, CMP_NE, CMP_GT, CMP_LT, CMP_LE),
testing::Bool()));
testing::Bool(),
Values(AbsExact().to_compare_obj())));
INSTANTIATE_TEST_CASE_P(BitwiseTestGPU, BitwiseTest,
Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1),
@ -147,7 +148,8 @@ INSTANTIATE_TEST_CASE_P(BitwiseTestGPU, BitwiseTest,
cv::Size(128, 128)),
Values(-1),
Values(CORE_GPU),
Values(AND, OR, XOR)));
Values(AND, OR, XOR),
testing::Bool()));
INSTANTIATE_TEST_CASE_P(BitwiseNotTestGPU, NotTest,
Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1),

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

@ -21,23 +21,24 @@ INSTANTIATE_TEST_CASE_P(MathOperatorTestGPU, MathOperatorMatMatTest,
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
Values(-1, CV_8U, CV_32F),
Values(-1),
Values(CORE_GPU),
Values(Tolerance_FloatRel_IntAbs(1e-5, 2).to_compare_obj()),
Values( opPlusM, opMinusM, opDivM,
opGreater, opLess, opGreaterEq, opLessEq, opEq, opNotEq)));
Values( ADD, SUB, DIV,
GT, LT, GE, LE, EQ, NE)));
INSTANTIATE_TEST_CASE_P(MathOperatorTestGPU, MathOperatorMatScalarTest,
Combine(Values(CV_8UC1, CV_16SC1, CV_32FC1),
Values(cv::Size(1280, 720),
cv::Size(640, 480),
cv::Size(128, 128)),
Values(-1, CV_8U, CV_32F),
Values(-1),
Values(CORE_GPU),
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)));
Values( ADD, SUB, MUL, DIV,
ADDR, SUBR, MULR, DIVR,
GT, LT, GE, LE, EQ, NE,
GTR, LTR, GER, LER, EQR, NER)));
INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestGPU, MathOperatorMatMatTest,
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
@ -47,7 +48,7 @@ INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestGPU, MathOperatorMatMatTest,
Values(-1),
Values(CORE_GPU),
Values(AbsExact().to_compare_obj()),
Values( opAnd, opOr, opXor )));
Values( AND, OR, XOR )));
INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestGPU, MathOperatorMatScalarTest,
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
@ -57,7 +58,8 @@ INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestGPU, MathOperatorMatScalarTest,
Values(-1),
Values(CORE_GPU),
Values(AbsExact().to_compare_obj()),
Values( opAND, opOR, opXOR, opANDR, opORR, opXORR )));
Values( AND, OR, XOR,
ANDR, ORR, XORR )));
INSTANTIATE_TEST_CASE_P(BitwiseNotOperatorTestGPU, NotOperatorTest,
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),