Chiebot-Mirror
/
opencv
mirror of https://github.com/opencv/opencv.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge pull request #14922 from andrey-golubev:operators_tests_update_clean

Browse Source 
G-API: Align operators tests to new test model (#14922)

* Align operators tests to new test model

* Change init function in NotOperatorTest
pull/14932/head
Andrey Golubev 5 years ago committed by Alexander Alekhin
parent 8dd596b7ba
commit 1666195984
5 changed files with 99 additions and 109 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 10
      modules/gapi/test/common/gapi_operators_tests.hpp
  2. 30
      modules/gapi/test/common/gapi_operators_tests_inl.hpp
  3. 49
      modules/gapi/test/cpu/gapi_operators_tests_cpu.cpp
  4. 46
      modules/gapi/test/cpu/gapi_operators_tests_fluid.cpp
  5. 49
      modules/gapi/test/gpu/gapi_operators_tests_gpu.cpp

10
modules/gapi/test/common/gapi_operators_tests.hpp
Unescape View File

@ -61,7 +61,6 @@ struct g_api_ocv_pair_mat_mat {
namespace namespace
{ {
//declare test cases for matrix and scalar operators //declare test cases for matrix and scalar operators
g_api_ocv_pair_mat_scalar opPlus = {std::string{"operator+"}, g_api_ocv_pair_mat_scalar opPlus = {std::string{"operator+"},
[](cv::GMat in,cv::GScalar c){return in+c;}, [](cv::GMat in,cv::GScalar c){return in+c;},
@ -184,9 +183,12 @@ g_api_ocv_pair_mat_mat opXor = {std::string{"operator^"},
[](const cv::Mat& in1, const cv::Mat& in2, cv::Mat& out){cv::bitwise_xor(in1, in2, out);}}; [](const cv::Mat& in1, const cv::Mat& in2, cv::Mat& out){cv::bitwise_xor(in1, in2, out);}};
} // anonymous namespace } // anonymous namespace
struct MathOperatorMatScalarTest : public TestParams<std::tuple<compare_f, g_api_ocv_pair_mat_scalar,int,cv::Size,int,bool,cv::GCompileArgs>>{};
struct MathOperatorMatMatTest : public TestParams<std::tuple<compare_f, g_api_ocv_pair_mat_mat,int,cv::Size,int,bool,cv::GCompileArgs>>{}; GAPI_TEST_FIXTURE(MathOperatorMatScalarTest, initMatsRandU,
struct NotOperatorTest : public TestParams<std::tuple<int,cv::Size,bool,cv::GCompileArgs>> {}; FIXTURE_API(compare_f, g_api_ocv_pair_mat_scalar), 2, cmpF, op)
GAPI_TEST_FIXTURE(MathOperatorMatMatTest, initMatsRandU,
FIXTURE_API(compare_f, g_api_ocv_pair_mat_mat), 2, cmpF, op)
GAPI_TEST_FIXTURE(NotOperatorTest, initMatrixRandU, <>, 0)
} // opencv_test } // opencv_test
#endif // OPENCV_GAPI_OPERATOR_TESTS_COMMON_HPP #endif // OPENCV_GAPI_OPERATOR_TESTS_COMMON_HPP

30
modules/gapi/test/common/gapi_operators_tests_inl.hpp
Unescape View File

@ -14,15 +14,6 @@ namespace opencv_test
{ {
TEST_P(MathOperatorMatScalarTest, OperatorAccuracyTest ) TEST_P(MathOperatorMatScalarTest, OperatorAccuracyTest )
{ {
compare_f cmpF;
g_api_ocv_pair_mat_scalar op;
int type = 0, dtype = 0;
cv::Size sz;
bool initOutMatr = false;
cv::GCompileArgs compile_args;
std::tie(cmpF, op, type, sz, dtype, initOutMatr, compile_args) = GetParam();
initMatsRandU(type, sz, dtype, initOutMatr);
auto fun_gapi = op.g_api_function; auto fun_gapi = op.g_api_function;
auto fun_ocv = op.ocv_function ; auto fun_ocv = op.ocv_function ;
@ -33,7 +24,7 @@ TEST_P(MathOperatorMatScalarTest, OperatorAccuracyTest )
auto out = fun_gapi(in1, in2); auto out = fun_gapi(in1, in2);
cv::GComputation c(GIn(in1, in2), GOut(out)); cv::GComputation c(GIn(in1, in2), GOut(out));
c.apply(gin(in_mat1, sc), gout(out_mat_gapi), std::move(compile_args)); c.apply(gin(in_mat1, sc), gout(out_mat_gapi), getCompileArgs());
fun_ocv(in_mat1, sc, out_mat_ocv); fun_ocv(in_mat1, sc, out_mat_ocv);
@ -46,15 +37,6 @@ TEST_P(MathOperatorMatScalarTest, OperatorAccuracyTest )
TEST_P(MathOperatorMatMatTest, OperatorAccuracyTest ) TEST_P(MathOperatorMatMatTest, OperatorAccuracyTest )
{ {
compare_f cmpF;
g_api_ocv_pair_mat_mat op;
int type = 0, dtype = 0;
cv::Size sz;
bool initOutMatr = false;
cv::GCompileArgs compile_args;
std::tie(cmpF, op, type, sz, dtype, initOutMatr, compile_args) = GetParam();
initMatsRandU(type, sz, dtype, initOutMatr);
auto fun_gapi = op.g_api_function; auto fun_gapi = op.g_api_function;
auto fun_ocv = op.ocv_function ; auto fun_ocv = op.ocv_function ;
@ -65,7 +47,7 @@ TEST_P(MathOperatorMatMatTest, OperatorAccuracyTest )
auto out = fun_gapi(in1, in2); auto out = fun_gapi(in1, in2);
cv::GComputation c(GIn(in1, in2), GOut(out)); cv::GComputation c(GIn(in1, in2), GOut(out));
c.apply(gin(in_mat1, in_mat2), gout(out_mat_gapi), std::move(compile_args)); c.apply(gin(in_mat1, in_mat2), gout(out_mat_gapi), getCompileArgs());
fun_ocv(in_mat1, in_mat2, out_mat_ocv); fun_ocv(in_mat1, in_mat2, out_mat_ocv);
@ -78,16 +60,12 @@ TEST_P(MathOperatorMatMatTest, OperatorAccuracyTest )
TEST_P(NotOperatorTest, OperatorAccuracyTest) TEST_P(NotOperatorTest, OperatorAccuracyTest)
{ {
cv::Size sz_in = std::get<1>(GetParam());
initMatrixRandU(std::get<0>(GetParam()), sz_in, std::get<0>(GetParam()), std::get<2>(GetParam()));
cv::GCompileArgs compile_args;
// G-API code ////////////////////////////////////////////////////////////// // G-API code //////////////////////////////////////////////////////////////
cv::GMat in; cv::GMat in;
auto out = ~in; auto out = ~in;
cv::GComputation c(in, out); cv::GComputation c(in, out);
c.apply(in_mat1, out_mat_gapi, std::move(compile_args)); c.apply(in_mat1, out_mat_gapi, getCompileArgs());
// OpenCV code ///////////////////////////////////////////////////////////// // OpenCV code /////////////////////////////////////////////////////////////
{ {
@ -96,7 +74,7 @@ TEST_P(NotOperatorTest, OperatorAccuracyTest)
// Comparison ////////////////////////////////////////////////////////////// // Comparison //////////////////////////////////////////////////////////////
{ {
EXPECT_EQ(0, cv::countNonZero(out_mat_ocv != out_mat_gapi)); EXPECT_EQ(0, cv::countNonZero(out_mat_ocv != out_mat_gapi));
EXPECT_EQ(out_mat_gapi.size(), sz_in); EXPECT_EQ(out_mat_gapi.size(), sz);
} }
} }
} // opencv_test } // opencv_test

49
modules/gapi/test/cpu/gapi_operators_tests_cpu.cpp
Unescape View File

@ -9,65 +9,68 @@
#include "../common/gapi_operators_tests.hpp" #include "../common/gapi_operators_tests.hpp"
#include <opencv2/gapi/cpu/core.hpp> #include <opencv2/gapi/cpu/core.hpp>
#define CORE_CPU cv::gapi::core::cpu::kernels() namespace
{
#define CORE_CPU [] () { return cv::compile_args(cv::gapi::core::cpu::kernels()); }
} // anonymous namespace
namespace opencv_test namespace opencv_test
{ {
// FIXME: CPU test runs are disabled since Fluid is an exclusive plugin now! // FIXME: CPU test runs are disabled since Fluid is an exclusive plugin now!
INSTANTIATE_TEST_CASE_P(MathOperatorTestCPU, MathOperatorMatMatTest, INSTANTIATE_TEST_CASE_P(MathOperatorTestCPU, MathOperatorMatMatTest,
Combine(Values(AbsExact().to_compare_f()), Combine(Values(CV_8UC1, CV_16SC1, CV_32FC1),
Values( opPlusM, opMinusM, opDivM,
opGreater, opLess, opGreaterEq, opLessEq, opEq, opNotEq),
Values(CV_8UC1, CV_16SC1, CV_32FC1),
Values(cv::Size(1280, 720), Values(cv::Size(1280, 720),
cv::Size(640, 480), cv::Size(640, 480),
cv::Size(128, 128)), cv::Size(128, 128)),
Values(-1, CV_8U, CV_32F), Values(-1, CV_8U, CV_32F),
/*init output matrices or not*/ testing::Bool(), testing::Bool(),
Values(cv::compile_args(CORE_CPU)))); Values(CORE_CPU),
Values(AbsExact().to_compare_f()),
Values( opPlusM, opMinusM, opDivM,
opGreater, opLess, opGreaterEq, opLessEq, opEq, opNotEq)));
INSTANTIATE_TEST_CASE_P(MathOperatorTestCPU, MathOperatorMatScalarTest, INSTANTIATE_TEST_CASE_P(MathOperatorTestCPU, MathOperatorMatScalarTest,
Combine(Values(AbsExact().to_compare_f()), Combine(Values(CV_8UC1, CV_16SC1, CV_32FC1),
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(CV_8UC1, CV_16SC1, CV_32FC1),
Values(cv::Size(1280, 720), Values(cv::Size(1280, 720),
cv::Size(640, 480), cv::Size(640, 480),
cv::Size(128, 128)), cv::Size(128, 128)),
Values(-1, CV_8U, CV_32F), Values(-1, CV_8U, CV_32F),
/*init output matrices or not*/ testing::Bool(), /*init output matrices or not*/ testing::Bool(),
Values(cv::compile_args(CORE_CPU)))); Values(CORE_CPU),
Values(AbsExact().to_compare_f()),
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)));
INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestCPU, MathOperatorMatMatTest, INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestCPU, MathOperatorMatMatTest,
Combine(Values(AbsExact().to_compare_f()), Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
Values( opAnd, opOr, opXor ),
Values(CV_8UC1, CV_16UC1, CV_16SC1),
Values(cv::Size(1280, 720), Values(cv::Size(1280, 720),
cv::Size(640, 480), cv::Size(640, 480),
cv::Size(128, 128)), cv::Size(128, 128)),
Values(-1), Values(-1),
/*init output matrices or not*/ testing::Bool(), /*init output matrices or not*/ testing::Bool(),
Values(cv::compile_args(CORE_CPU)))); Values(CORE_CPU),
Values(AbsExact().to_compare_f()),
Values( opAnd, opOr, opXor )));
INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestCPU, MathOperatorMatScalarTest, INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestCPU, MathOperatorMatScalarTest,
Combine(Values(AbsExact().to_compare_f()), Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
Values( opAND, opOR, opXOR, opANDR, opORR, opXORR ),
Values(CV_8UC1, CV_16UC1, CV_16SC1),
Values(cv::Size(1280, 720), Values(cv::Size(1280, 720),
cv::Size(640, 480), cv::Size(640, 480),
cv::Size(128, 128)), cv::Size(128, 128)),
Values(-1), Values(-1),
/*init output matrices or not*/ testing::Bool(), /*init output matrices or not*/ testing::Bool(),
Values(cv::compile_args(CORE_CPU)))); Values(CORE_CPU),
Values(AbsExact().to_compare_f()),
Values( opAND, opOR, opXOR, opANDR, opORR, opXORR )));
INSTANTIATE_TEST_CASE_P(BitwiseNotOperatorTestCPU, NotOperatorTest, INSTANTIATE_TEST_CASE_P(BitwiseNotOperatorTestCPU, NotOperatorTest,
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1), Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
Values(cv::Size(1280, 720), Values(cv::Size(1280, 720),
cv::Size(640, 480), cv::Size(640, 480),
cv::Size(128, 128)), cv::Size(128, 128)),
Values(SAME_TYPE),
/*init output matrices or not*/ testing::Bool(), /*init output matrices or not*/ testing::Bool(),
Values(cv::compile_args(CORE_CPU)))); Values(CORE_CPU)));
} }

46
modules/gapi/test/cpu/gapi_operators_tests_fluid.cpp
Unescape View File

@ -8,65 +8,69 @@
#include "../test_precomp.hpp" #include "../test_precomp.hpp"
#include "../common/gapi_operators_tests.hpp" #include "../common/gapi_operators_tests.hpp"
#define CORE_FLUID cv::gapi::core::fluid::kernels() namespace
{
#define CORE_FLUID [] () { return cv::compile_args(cv::gapi::core::fluid::kernels()); }
} // anonymous namespace
namespace opencv_test namespace opencv_test
{ {
INSTANTIATE_TEST_CASE_P(MathOperatorTestFluid, MathOperatorMatMatTest, INSTANTIATE_TEST_CASE_P(MathOperatorTestFluid, MathOperatorMatMatTest,
Combine(Values(AbsExact().to_compare_f()), Combine(Values(CV_8UC1, CV_16SC1, CV_32FC1),
Values( opPlusM, opMinusM, opDivM,
opGreater, opLess, opGreaterEq, opLessEq, opEq, opNotEq),
Values(CV_8UC1, CV_16SC1, CV_32FC1),
Values(cv::Size(1280, 720), Values(cv::Size(1280, 720),
cv::Size(640, 480), cv::Size(640, 480),
cv::Size(128, 128)), cv::Size(128, 128)),
Values(-1, CV_8U, CV_32F), Values(-1, CV_8U, CV_32F),
/*init output matrices or not*/ testing::Bool(), /*init output matrices or not*/ testing::Bool(),
Values(cv::compile_args(CORE_FLUID)))); Values(CORE_FLUID),
Values(AbsExact().to_compare_f()),
Values( opPlusM, opMinusM, opDivM,
opGreater, opLess, opGreaterEq, opLessEq, opEq, opNotEq)));
//FIXME: Some Mat/Scalar Fluid kernels are not there yet! //FIXME: Some Mat/Scalar Fluid kernels are not there yet!
INSTANTIATE_TEST_CASE_P(DISABLED_MathOperatorTestFluid, MathOperatorMatScalarTest, INSTANTIATE_TEST_CASE_P(DISABLED_MathOperatorTestFluid, MathOperatorMatScalarTest,
Combine(Values(AbsExact().to_compare_f()), Combine(Values(CV_8UC1, CV_16SC1, CV_32FC1),
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(CV_8UC1, CV_16SC1, CV_32FC1),
Values(cv::Size(1280, 720), Values(cv::Size(1280, 720),
cv::Size(640, 480), cv::Size(640, 480),
cv::Size(128, 128)), cv::Size(128, 128)),
Values(-1, CV_8U, CV_32F), Values(-1, CV_8U, CV_32F),
/*init output matrices or not*/ testing::Bool(), /*init output matrices or not*/ testing::Bool(),
Values(cv::compile_args(CORE_FLUID)))); Values(CORE_FLUID),
Values(AbsExact().to_compare_f()),
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)));
INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestFluid, MathOperatorMatMatTest, INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestFluid, MathOperatorMatMatTest,
Combine(Values(AbsExact().to_compare_f()), Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
Values( opAnd, opOr, opXor ),
Values(CV_8UC1, CV_16UC1, CV_16SC1),
Values(cv::Size(1280, 720), Values(cv::Size(1280, 720),
cv::Size(640, 480), cv::Size(640, 480),
cv::Size(128, 128)), cv::Size(128, 128)),
Values(-1), Values(-1),
/*init output matrices or not*/ testing::Bool(), /*init output matrices or not*/ testing::Bool(),
Values(cv::compile_args(CORE_FLUID)))); Values(CORE_FLUID),
Values(AbsExact().to_compare_f()),
Values( opAnd, opOr, opXor )));
//FIXME: Some Mat/Scalar Fluid kernels are not there yet! //FIXME: Some Mat/Scalar Fluid kernels are not there yet!
INSTANTIATE_TEST_CASE_P(DISABLED_BitwiseOperatorTestFluid, MathOperatorMatScalarTest, INSTANTIATE_TEST_CASE_P(DISABLED_BitwiseOperatorTestFluid, MathOperatorMatScalarTest,
Combine(Values(AbsExact().to_compare_f()), Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
Values( opAND, opOR, opXOR, opANDR, opORR, opXORR ),
Values(CV_8UC1, CV_16UC1, CV_16SC1),
Values(cv::Size(1280, 720), Values(cv::Size(1280, 720),
cv::Size(640, 480), cv::Size(640, 480),
cv::Size(128, 128)), cv::Size(128, 128)),
Values(-1), Values(-1),
/*init output matrices or not*/ testing::Bool(), /*init output matrices or not*/ testing::Bool(),
Values(cv::compile_args(CORE_FLUID)))); Values(CORE_FLUID),
Values(AbsExact().to_compare_f()),
Values( opAND, opOR, opXOR, opANDR, opORR, opXORR )));
INSTANTIATE_TEST_CASE_P(BitwiseNotOperatorTestFluid, NotOperatorTest, INSTANTIATE_TEST_CASE_P(BitwiseNotOperatorTestFluid, NotOperatorTest,
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1), Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
Values(cv::Size(1280, 720), Values(cv::Size(1280, 720),
cv::Size(640, 480), cv::Size(640, 480),
cv::Size(128, 128)), cv::Size(128, 128)),
Values(SAME_TYPE),
/*init output matrices or not*/ testing::Bool(), /*init output matrices or not*/ testing::Bool(),
Values(cv::compile_args(CORE_FLUID)))); Values(CORE_FLUID)));
} }

49
modules/gapi/test/gpu/gapi_operators_tests_gpu.cpp
Unescape View File

@ -8,64 +8,67 @@
#include "../test_precomp.hpp" #include "../test_precomp.hpp"
#include "../common/gapi_operators_tests.hpp" #include "../common/gapi_operators_tests.hpp"
#define CORE_GPU cv::gapi::core::gpu::kernels() namespace
{
#define CORE_GPU [] () { return cv::compile_args(cv::gapi::core::gpu::kernels()); }
} // anonymous namespace
namespace opencv_test namespace opencv_test
{ {
INSTANTIATE_TEST_CASE_P(MathOperatorTestGPU, MathOperatorMatMatTest, INSTANTIATE_TEST_CASE_P(MathOperatorTestGPU, MathOperatorMatMatTest,
Combine(Values(Tolerance_FloatRel_IntAbs(1e-5, 2).to_compare_f()), Combine(Values(CV_8UC1, CV_16SC1, CV_32FC1),
Values( opPlusM, opMinusM, opDivM,
opGreater, opLess, opGreaterEq, opLessEq, opEq, opNotEq),
Values(CV_8UC1, CV_16SC1, CV_32FC1),
Values(cv::Size(1280, 720), Values(cv::Size(1280, 720),
cv::Size(640, 480), cv::Size(640, 480),
cv::Size(128, 128)), cv::Size(128, 128)),
Values(-1, CV_8U, CV_32F), Values(-1, CV_8U, CV_32F),
/*init output matrices or not*/ testing::Bool(), testing::Bool(),
Values(cv::compile_args(CORE_GPU)))); Values(CORE_GPU),
Values(Tolerance_FloatRel_IntAbs(1e-5, 2).to_compare_f()),
Values( opPlusM, opMinusM, opDivM,
opGreater, opLess, opGreaterEq, opLessEq, opEq, opNotEq)));
INSTANTIATE_TEST_CASE_P(MathOperatorTestGPU, MathOperatorMatScalarTest, INSTANTIATE_TEST_CASE_P(MathOperatorTestGPU, MathOperatorMatScalarTest,
Combine(Values(Tolerance_FloatRel_IntAbs(1e-4, 2).to_compare_f()), Combine(Values(CV_8UC1, CV_16SC1, CV_32FC1),
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(CV_8UC1, CV_16SC1, CV_32FC1),
Values(cv::Size(1280, 720), Values(cv::Size(1280, 720),
cv::Size(640, 480), cv::Size(640, 480),
cv::Size(128, 128)), cv::Size(128, 128)),
Values(-1, CV_8U, CV_32F), Values(-1, CV_8U, CV_32F),
/*init output matrices or not*/ testing::Bool(), /*init output matrices or not*/ testing::Bool(),
Values(cv::compile_args(CORE_GPU)))); Values(CORE_GPU),
Values(Tolerance_FloatRel_IntAbs(1e-4, 2).to_compare_f()),
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)));
INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestGPU, MathOperatorMatMatTest, INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestGPU, MathOperatorMatMatTest,
Combine(Values(AbsExact().to_compare_f()), Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
Values( opAnd, opOr, opXor ),
Values(CV_8UC1, CV_16UC1, CV_16SC1),
Values(cv::Size(1280, 720), Values(cv::Size(1280, 720),
cv::Size(640, 480), cv::Size(640, 480),
cv::Size(128, 128)), cv::Size(128, 128)),
Values(-1), Values(-1),
/*init output matrices or not*/ testing::Bool(), /*init output matrices or not*/ testing::Bool(),
Values(cv::compile_args(CORE_GPU)))); Values(CORE_GPU),
Values(AbsExact().to_compare_f()),
Values( opAnd, opOr, opXor )));
INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestGPU, MathOperatorMatScalarTest, INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestGPU, MathOperatorMatScalarTest,
Combine(Values(AbsExact().to_compare_f()), Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
Values( opAND, opOR, opXOR, opANDR, opORR, opXORR ),
Values(CV_8UC1, CV_16UC1, CV_16SC1),
Values(cv::Size(1280, 720), Values(cv::Size(1280, 720),
cv::Size(640, 480), cv::Size(640, 480),
cv::Size(128, 128)), cv::Size(128, 128)),
Values(-1), Values(-1),
/*init output matrices or not*/ testing::Bool(), /*init output matrices or not*/ testing::Bool(),
Values(cv::compile_args(CORE_GPU)))); Values(CORE_GPU),
Values(AbsExact().to_compare_f()),
Values( opAND, opOR, opXOR, opANDR, opORR, opXORR )));
INSTANTIATE_TEST_CASE_P(BitwiseNotOperatorTestGPU, NotOperatorTest, INSTANTIATE_TEST_CASE_P(BitwiseNotOperatorTestGPU, NotOperatorTest,
Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1), Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
Values(cv::Size(1280, 720), Values(cv::Size(1280, 720),
cv::Size(640, 480), cv::Size(640, 480),
cv::Size(128, 128)), cv::Size(128, 128)),
Values(SAME_TYPE),
/*init output matrices or not*/ testing::Bool(), /*init output matrices or not*/ testing::Bool(),
Values(cv::compile_args(CORE_GPU)))); Values(CORE_GPU)));
} }

Write Preview
Loading…
Cancel
Save