potok/opencv
1
0
Fork 0
mirror of https://github.com/opencv/opencv.git synced 2026-07-30 07:43:03 +04:00
Code Packages 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
17 changed files with 606 additions and 284 deletions
Download Patch File Download Diff File Expand all files Collapse all files
modules/gapi/test/common/gapi_core_tests.hpp
+2 -2
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)
modules/gapi/test/common/gapi_core_tests_inl.hpp
+46 -27
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 //////////////////////////////////////////////////////////////
{
modules/gapi/test/common/gapi_operators_tests.hpp
+183 -147
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
modules/gapi/test/common/gapi_operators_tests_inl.hpp
+14 -4
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 ////////////////////////////////
modules/gapi/test/common/gapi_tests_common.hpp
+68 -4
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));
modules/gapi/test/cpu/gapi_core_tests_cpu.cpp
+4 -2
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),
modules/gapi/test/cpu/gapi_core_tests_fluid.cpp
+17 -2
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),
modules/gapi/test/cpu/gapi_operators_tests_cpu.cpp
+11 -9
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),
modules/gapi/test/cpu/gapi_operators_tests_fluid.cpp
+23 -13
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),
modules/gapi/test/gpu/gapi_core_tests_gpu.cpp
+4 -2
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),
modules/gapi/test/gpu/gapi_operators_tests_gpu.cpp
+11 -9
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),