From: Orest Chura Date: Fri, 18 Sep 2020 13:44:47 +0000 (+0300) Subject: Merge pull request #18257 from OrestChura:oc/fluid_operator_bitwise_and_scalar X-Git-Tag: submit/tizen/20210224.033012~2^2~45 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=d1cdef596c7018540cf68e709a2ba36a07ce46e0;p=platform%2Fupstream%2Fopencv.git Merge pull request #18257 from OrestChura:oc/fluid_operator_bitwise_and_scalar [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 --- diff --git a/modules/gapi/perf/common/gapi_core_perf_tests.hpp b/modules/gapi/perf/common/gapi_core_perf_tests.hpp index ed954ad..5934a05 100644 --- a/modules/gapi/perf/common/gapi_core_perf_tests.hpp +++ b/modules/gapi/perf/common/gapi_core_perf_tests.hpp @@ -43,8 +43,8 @@ namespace opencv_test class Polar2CartPerfTest : public TestPerfParams> {}; class Cart2PolarPerfTest : public TestPerfParams> {}; class CmpPerfTest : public TestPerfParams> {}; - class CmpWithScalarPerfTest : public TestPerfParams> {}; - class BitwisePerfTest : public TestPerfParams> {}; + class CmpWithScalarPerfTest : public TestPerfParams> {}; + class BitwisePerfTest : public TestPerfParams> {}; class BitwiseNotPerfTest : public TestPerfParams> {}; class SelectPerfTest : public TestPerfParams> {}; class MinPerfTest : public TestPerfParams> {}; diff --git a/modules/gapi/perf/common/gapi_core_perf_tests_inl.hpp b/modules/gapi/perf/common/gapi_core_perf_tests_inl.hpp index 6b049c2..962b1b5 100644 --- a/modules/gapi/perf/common/gapi_core_perf_tests_inl.hpp +++ b/modules/gapi/perf/common/gapi_core_perf_tests_inl.hpp @@ -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) - { - 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: - 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)); - - TEST_CYCLE() - { - cc(gin(in_mat1, in_mat2), gout(out_mat_gapi)); + if( testWithScalar ) + { + 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: + c.apply(gin(in_mat1, sc), gout(out_mat_gapi), std::move(compile_args)); + + TEST_CYCLE() + { + c.apply(gin(in_mat1, sc), gout(out_mat_gapi)); + } + } + 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)); + + // 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 //////////////////////////////////////////////////////////// diff --git a/modules/gapi/perf/cpu/gapi_core_perf_tests_cpu.cpp b/modules/gapi/perf/cpu/gapi_core_perf_tests_cpu.cpp index 8369ed1..c46c5d2 100644 --- a/modules/gapi/perf/cpu/gapi_core_perf_tests_cpu.cpp +++ b/modules/gapi/perf/cpu/gapi_core_perf_tests_cpu.cpp @@ -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), diff --git a/modules/gapi/perf/cpu/gapi_core_perf_tests_fluid.cpp b/modules/gapi/perf/cpu/gapi_core_perf_tests_fluid.cpp index c0a76be..204e1f0 100644 --- a/modules/gapi/perf/cpu/gapi_core_perf_tests_fluid.cpp +++ b/modules/gapi/perf/cpu/gapi_core_perf_tests_fluid.cpp @@ -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)))); diff --git a/modules/gapi/perf/gpu/gapi_core_perf_tests_gpu.cpp b/modules/gapi/perf/gpu/gapi_core_perf_tests_gpu.cpp index d77bfb8..56f7be4 100644 --- a/modules/gapi/perf/gpu/gapi_core_perf_tests_gpu.cpp +++ b/modules/gapi/perf/gpu/gapi_core_perf_tests_gpu.cpp @@ -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)))); diff --git a/modules/gapi/src/backends/fluid/gfluidcore.cpp b/modules/gapi/src/backends/fluid/gfluidcore.cpp index af9d6ec..7c1b312 100644 --- a/modules/gapi/src/backends/fluid/gfluidcore.cpp +++ b/modules/gapi/src/backends/fluid/gfluidcore.cpp @@ -806,7 +806,7 @@ GAPI_FLUID_KERNEL(GFluidDivRC, cv::gapi::core::GDivRC, false) enum Bitwise { BW_AND, BW_OR, BW_XOR, BW_NOT }; template -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::value, "wrong types"); static_assert(std::is_same::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 -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::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 convertScalarForBitwise(const cv::Scalar &_scalar) +{ + std::array scalarI = { + static_cast(_scalar[0]), + static_cast(_scalar[1]), + static_cast(_scalar[2]), + static_cast(_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 +static inline DST bw_andS(DST x, int y) +{ + return x & saturate(y); +} + +template +static inline DST bw_orS(DST x, int y) +{ + return x | saturate(y); +} + +template +static inline DST bw_xorS(DST x, int y) +{ + return x ^ saturate(y); +} + +// manually unroll the inner cycle by channels +// (reuse arithmetic function above of the same purpose) +template +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 +static void run_bitwise_s(Buffer &dst, const View &src, const int scalar[4], Bitwise bitwise_op) +{ + static_assert(std::is_same::value, "wrong types"); + + const auto *in = src.InLine(0); + auto *out = dst.OutLine(); + + 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); + break; + case BW_OR: + run_bitwise_s(out, in, width, chan, scalar, bw_orS); + break; + case BW_XOR: + run_bitwise_s(out, in, width, chan, scalar, bw_xorS); + 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 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 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 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 diff --git a/modules/gapi/test/common/gapi_core_tests.hpp b/modules/gapi/test/common/gapi_core_tests.hpp index 52e184a..308f886 100644 --- a/modules/gapi/test/common/gapi_core_tests.hpp +++ b/modules/gapi/test/common/gapi_core_tests.hpp @@ -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) diff --git a/modules/gapi/test/common/gapi_core_tests_inl.hpp b/modules/gapi/test/common/gapi_core_tests_inl.hpp index 7226fa3..331ef70 100644 --- a/modules/gapi/test/common/gapi_core_tests_inl.hpp +++ b/modules/gapi/test/common/gapi_core_tests_inl.hpp @@ -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: - { - 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: + cv::GScalar sc1; + switch(opType) { - out = cv::gapi::bitwise_xor(in1, in2); - cv::bitwise_xor(in_mat1, in_mat2, out_mat_ocv); - break; + 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!"; } - default: + cv::GComputation c(GIn(in1, sc1), GOut(out)); + c.apply(gin(in_mat1, sc), gout(out_mat_gapi), getCompileArgs()); + } + else + { + switch(opType) { - FAIL() << "no such bitwise operation type!"; + 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()); } - cv::GComputation c(GIn(in1, in2), GOut(out)); - c.apply(gin(in_mat1, in_mat2), gout(out_mat_gapi), getCompileArgs()); + // Comparison ////////////////////////////////////////////////////////////// { diff --git a/modules/gapi/test/common/gapi_operators_tests.hpp b/modules/gapi/test/common/gapi_operators_tests.hpp index 70bf477..9a195e0 100644 --- a/modules/gapi/test/common/gapi_operators_tests.hpp +++ b/modules/gapi/test/common/gapi_operators_tests.hpp @@ -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; using ocv_function_t = std::function; - 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<; using ocv_function_t = std::function; - 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<"}, - [](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="}, - [](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="}, - [](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, 0) } // opencv_test diff --git a/modules/gapi/test/common/gapi_operators_tests_inl.hpp b/modules/gapi/test/common/gapi_operators_tests_inl.hpp index ad8b60f..ad57929 100644 --- a/modules/gapi/test/common/gapi_operators_tests_inl.hpp +++ b/modules/gapi/test/common/gapi_operators_tests_inl.hpp @@ -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 //////////////////////////////// diff --git a/modules/gapi/test/common/gapi_tests_common.hpp b/modules/gapi/test/common/gapi_tests_common.hpp index 144ca5f..113f3c7 100644 --- a/modules/gapi/test/common/gapi_tests_common.hpp +++ b/modules/gapi/test/common/gapi_tests_common.hpp @@ -10,6 +10,7 @@ #include #include #include +#include #include #include @@ -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)); diff --git a/modules/gapi/test/cpu/gapi_core_tests_cpu.cpp b/modules/gapi/test/cpu/gapi_core_tests_cpu.cpp index 121b939..ff98130 100644 --- a/modules/gapi/test/cpu/gapi_core_tests_cpu.cpp +++ b/modules/gapi/test/cpu/gapi_core_tests_cpu.cpp @@ -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), diff --git a/modules/gapi/test/cpu/gapi_core_tests_fluid.cpp b/modules/gapi/test/cpu/gapi_core_tests_fluid.cpp index da2b986..21eb1b9 100644 --- a/modules/gapi/test/cpu/gapi_core_tests_fluid.cpp +++ b/modules/gapi/test/cpu/gapi_core_tests_fluid.cpp @@ -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), diff --git a/modules/gapi/test/cpu/gapi_operators_tests_cpu.cpp b/modules/gapi/test/cpu/gapi_operators_tests_cpu.cpp index 0f7ab97..df74a04 100644 --- a/modules/gapi/test/cpu/gapi_operators_tests_cpu.cpp +++ b/modules/gapi/test/cpu/gapi_operators_tests_cpu.cpp @@ -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), diff --git a/modules/gapi/test/cpu/gapi_operators_tests_fluid.cpp b/modules/gapi/test/cpu/gapi_operators_tests_fluid.cpp index 0a40ef3..d076ecd 100644 --- a/modules/gapi/test/cpu/gapi_operators_tests_fluid.cpp +++ b/modules/gapi/test/cpu/gapi_operators_tests_fluid.cpp @@ -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), diff --git a/modules/gapi/test/gpu/gapi_core_tests_gpu.cpp b/modules/gapi/test/gpu/gapi_core_tests_gpu.cpp index f4c9240..5b38722 100644 --- a/modules/gapi/test/gpu/gapi_core_tests_gpu.cpp +++ b/modules/gapi/test/gpu/gapi_core_tests_gpu.cpp @@ -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), diff --git a/modules/gapi/test/gpu/gapi_operators_tests_gpu.cpp b/modules/gapi/test/gpu/gapi_operators_tests_gpu.cpp index 0fb83f4..46a2155 100644 --- a/modules/gapi/test/gpu/gapi_operators_tests_gpu.cpp +++ b/modules/gapi/test/gpu/gapi_operators_tests_gpu.cpp @@ -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),