inference-engine/thirdparty/fluid/modules/gapi/test/common/gapi_operators_tests.hpp

   1 // This file is part of OpenCV project.
   2 // It is subject to the license terms in the LICENSE file found in the top-level directory
   3 // of this distribution and at http://opencv.org/license.html.
   4 //
   5 // Copyright (C) 2018-2019 Intel Corporation
   6
   7
   8 #ifndef OPENCV_GAPI_OPERATOR_TESTS_COMMON_HPP
   9 #define OPENCV_GAPI_OPERATOR_TESTS_COMMON_HPP
  10
  11 #include "gapi_tests_common.hpp"
  12
  13 namespace opencv_test
  14 {
  15
  16 struct g_api_ocv_pair_mat_scalar {
  17     using g_api_function_t = std::function<cv::GMat(cv::GMat,cv::GScalar)>;
  18     using ocv_function_t   = std::function<void(cv::Mat const&, cv::Scalar, cv::Mat&)>;
  19
  20     std::string      name;
  21     g_api_function_t g_api_function;
  22     ocv_function_t   ocv_function;
  23
  24
  25     g_api_ocv_pair_mat_scalar(std::string const& n, g_api_function_t const& g, ocv_function_t const& o)
  26     : name(n), g_api_function(g), ocv_function(o) {}
  27
  28     g_api_ocv_pair_mat_scalar() = default;
  29
  30     friend std::ostream& operator<<(std::ostream& o, const g_api_ocv_pair_mat_scalar& p)
  31     {
  32         return o<<p.name;
  33     }
  34 };
  35
  36 struct g_api_ocv_pair_mat_mat {
  37     using g_api_function_t = std::function<cv::GMat(cv::GMat,cv::GMat)>;
  38     using ocv_function_t   = std::function<void(cv::Mat const&, cv::Mat const&, cv::Mat&)>;
  39
  40     std::string      name;
  41     g_api_function_t g_api_function;
  42     ocv_function_t   ocv_function;
  43
  44
  45     g_api_ocv_pair_mat_mat(std::string const& n, g_api_function_t const& g, ocv_function_t const& o)
  46     : name(n), g_api_function(g), ocv_function(o) {}
  47
  48     g_api_ocv_pair_mat_mat() = default;
  49
  50     friend std::ostream& operator<<(std::ostream& o, const g_api_ocv_pair_mat_mat& p)
  51     {
  52         return o<<p.name;
  53     }
  54 };
  55
  56 ////////////////////////////////////////////////////////////////////////////////
  57 //
  58 // FIXME: Please refactor this test to a template test (T,U) with enum (OP)
  59 //
  60 ////////////////////////////////////////////////////////////////////////////////
  61 namespace
  62 {
  63
  64
  65 //declare test cases for matrix and scalar operators
  66 g_api_ocv_pair_mat_scalar opPlus =  {std::string{"operator+"},
  67                                     [](cv::GMat in,cv::GScalar c){return in+c;},
  68                                     [](const cv::Mat& in, cv::Scalar c, cv::Mat& out){cv::add(in, c, out);}};
  69 g_api_ocv_pair_mat_scalar opPlusR = {std::string{"rev_operator+"},
  70                                     [](cv::GMat in,cv::GScalar c){return c+in;},
  71                                     [](const cv::Mat& in, cv::Scalar c, cv::Mat& out){cv::add(c, in, out);}};
  72 g_api_ocv_pair_mat_scalar opMinus = {std::string{"operator-"},
  73                                     [](cv::GMat in,cv::GScalar c){return in-c;},
  74                                     [](const cv::Mat& in, cv::Scalar c, cv::Mat& out){cv::subtract(in, c, out);}};
  75 g_api_ocv_pair_mat_scalar opMinusR = {std::string{"rev_operator-"},
  76                                     [](cv::GMat in,cv::GScalar c){return c-in;},
  77                                     [](const cv::Mat& in, cv::Scalar c, cv::Mat& out){cv::subtract(c, in, out);}};
  78 g_api_ocv_pair_mat_scalar opMul =   {std::string{"operator*"},
  79                                     [](cv::GMat in,cv::GScalar c){return in*c;},
  80                                     [](const cv::Mat& in, cv::Scalar c, cv::Mat& out){cv::multiply(in, c, out);}};
  81 g_api_ocv_pair_mat_scalar opMulR =  {std::string{"rev_operator*"},
  82                                     [](cv::GMat in,cv::GScalar c){return c*in;},
  83                                     [](const cv::Mat& in, cv::Scalar c, cv::Mat& out){cv::multiply(c, in, out);}};
  84 g_api_ocv_pair_mat_scalar opDiv =   {std::string{"operator/"},
  85                                     [](cv::GMat in,cv::GScalar c){return in/c;},
  86                                     [](const cv::Mat& in, cv::Scalar c, cv::Mat& out){cv::divide(in, c, out);}};
  87 g_api_ocv_pair_mat_scalar opDivR =  {std::string{"rev_operator/"},
  88                                     [](cv::GMat in,cv::GScalar c){return c/in;},
  89                                     [](const cv::Mat& in, cv::Scalar c, cv::Mat& out){cv::divide(c, in, out);}};
  90
  91 g_api_ocv_pair_mat_scalar opGT = {std::string{"operator>"},
  92                                             [](cv::GMat in,cv::GScalar c){return in>c;},
  93                                             [](const cv::Mat& in, cv::Scalar c, cv::Mat& out){cv::compare(in, c, out,cv::CMP_GT);}};
  94 g_api_ocv_pair_mat_scalar opLT = {std::string{"operator<"},
  95                                             [](cv::GMat in,cv::GScalar c){return in<c;},
  96                                             [](const cv::Mat& in, cv::Scalar c, cv::Mat& out){cv::compare(in, c, out,cv::CMP_LT);}};
  97 g_api_ocv_pair_mat_scalar opGE = {std::string{"operator>="},
  98                                             [](cv::GMat in,cv::GScalar c){return in>=c;},
  99                                             [](const cv::Mat& in, cv::Scalar c, cv::Mat& out){cv::compare(in, c, out,cv::CMP_GE);}};
 100 g_api_ocv_pair_mat_scalar opLE = {std::string{"operator<="},
 101                                             [](cv::GMat in,cv::GScalar c){return in<=c;},
 102                                             [](const cv::Mat& in, cv::Scalar c, cv::Mat& out){cv::compare(in, c, out,cv::CMP_LE);}};
 103 g_api_ocv_pair_mat_scalar opEQ = {std::string{"operator=="},
 104                                             [](cv::GMat in,cv::GScalar c){return in==c;},
 105                                             [](const cv::Mat& in, cv::Scalar c, cv::Mat& out){cv::compare(in, c, out,cv::CMP_EQ);}};
 106 g_api_ocv_pair_mat_scalar opNE = {std::string{"operator!="},
 107                                             [](cv::GMat in,cv::GScalar c){return in!=c;},
 108                                             [](const cv::Mat& in, cv::Scalar c, cv::Mat& out){cv::compare(in, c, out,cv::CMP_NE);}};
 109 g_api_ocv_pair_mat_scalar opGTR = {std::string{"rev_operator>"},
 110                                             [](cv::GMat in,cv::GScalar c){return c>in;},
 111                                             [](const cv::Mat& in, cv::Scalar c, cv::Mat& out){cv::compare(c, in, out,cv::CMP_GT);}};
 112 g_api_ocv_pair_mat_scalar opLTR = {std::string{"rev_operator<"},
 113                                             [](cv::GMat in,cv::GScalar c){return c<in;},
 114                                             [](const cv::Mat& in, cv::Scalar c, cv::Mat& out){cv::compare(c, in, out,cv::CMP_LT);}};
 115 g_api_ocv_pair_mat_scalar opGER = {std::string{"rev_operator>="},
 116                                             [](cv::GMat in,cv::GScalar c){return c>=in;},
 117                                             [](const cv::Mat& in, cv::Scalar c, cv::Mat& out){cv::compare(c, in, out,cv::CMP_GE);}};
 118 g_api_ocv_pair_mat_scalar opLER = {std::string{"rev_operator<="},
 119                                             [](cv::GMat in,cv::GScalar c){return c<=in;},
 120                                             [](const cv::Mat& in, cv::Scalar c, cv::Mat& out){cv::compare(c, in, out,cv::CMP_LE);}};
 121 g_api_ocv_pair_mat_scalar opEQR = {std::string{"rev_operator=="},
 122                                             [](cv::GMat in,cv::GScalar c){return c==in;},
 123                                             [](const cv::Mat& in, cv::Scalar c, cv::Mat& out){cv::compare(c, in, out,cv::CMP_EQ);}};
 124 g_api_ocv_pair_mat_scalar opNER = {std::string{"rev_operator!="},
 125                                             [](cv::GMat in,cv::GScalar c){return c!=in;},
 126                                             [](const cv::Mat& in, cv::Scalar c, cv::Mat& out){cv::compare(c, in, out,cv::CMP_NE);}};
 127
 128 g_api_ocv_pair_mat_scalar opAND = {std::string{"operator&"},
 129                                         [](cv::GMat in1,cv::GScalar in2){return in1&in2;},
 130                                         [](const cv::Mat& in1, const cv::Scalar& in2, cv::Mat& out){cv::bitwise_and(in1, in2, out);}};
 131 g_api_ocv_pair_mat_scalar opOR = {std::string{"operator|"},
 132                                         [](cv::GMat in1,cv::GScalar in2){return in1|in2;},
 133                                         [](const cv::Mat& in1, const cv::Scalar& in2, cv::Mat& out){cv::bitwise_or(in1, in2, out);}};
 134 g_api_ocv_pair_mat_scalar opXOR = {std::string{"operator^"},
 135                                         [](cv::GMat in1,cv::GScalar in2){return in1^in2;},
 136                                         [](const cv::Mat& in1, const cv::Scalar& in2, cv::Mat& out){cv::bitwise_xor(in1, in2, out);}};
 137 g_api_ocv_pair_mat_scalar opANDR = {std::string{"rev_operator&"},
 138                                         [](cv::GMat in1,cv::GScalar in2){return in2&in1;},
 139                                         [](const cv::Mat& in1, const cv::Scalar& in2, cv::Mat& out){cv::bitwise_and(in2, in1, out);}};
 140 g_api_ocv_pair_mat_scalar opORR = {std::string{"rev_operator|"},
 141                                         [](cv::GMat in1,cv::GScalar in2){return in2|in1;},
 142                                         [](const cv::Mat& in1, const cv::Scalar& in2, cv::Mat& out){cv::bitwise_or(in2, in1, out);}};
 143 g_api_ocv_pair_mat_scalar opXORR = {std::string{"rev_operator^"},
 144                                         [](cv::GMat in1,cv::GScalar in2){return in2^in1;},
 145                                         [](const cv::Mat& in1, const cv::Scalar& in2, cv::Mat& out){cv::bitwise_xor(in2, in1, out);}};
 146
 147 // declare test cases for matrix and matrix operators
 148 g_api_ocv_pair_mat_mat opPlusM =  {std::string{"operator+"},
 149                                             [](cv::GMat in1,cv::GMat in2){return in1+in2;},
 150                                             [](const cv::Mat& in1, const cv::Mat& in2, cv::Mat& out){cv::add(in1, in2, out);}};
 151 g_api_ocv_pair_mat_mat opMinusM = {std::string{"operator-"},
 152                                             [](cv::GMat in,cv::GMat in2){return in-in2;},
 153                                             [](const cv::Mat& in, const cv::Mat& in2, cv::Mat& out){cv::subtract(in, in2, out);}};
 154 g_api_ocv_pair_mat_mat opDivM = {std::string{"operator/"},
 155                                             [](cv::GMat in,cv::GMat in2){return in/in2;},
 156                                             [](const cv::Mat& in, const cv::Mat& in2, cv::Mat& out){cv::divide(in, in2, out);}};
 157 g_api_ocv_pair_mat_mat opGreater =  {std::string{"operator>"},
 158                                             [](cv::GMat in1,cv::GMat in2){return in1>in2;},
 159                                             [](const cv::Mat& in1, const cv::Mat& in2, cv::Mat& out){cv::compare(in1, in2, out, cv::CMP_GT);}};
 160 g_api_ocv_pair_mat_mat opGreaterEq = {std::string{"operator>="},
 161                                             [](cv::GMat in1,cv::GMat in2){return in1>=in2;},
 162                                             [](const cv::Mat& in1, const cv::Mat& in2, cv::Mat& out){cv::compare(in1, in2, out, cv::CMP_GE);}};
 163 g_api_ocv_pair_mat_mat opLess = {std::string{"operator<"},
 164                                             [](cv::GMat in1,cv::GMat in2){return in1<in2;},
 165                                             [](const cv::Mat& in1, const cv::Mat& in2, cv::Mat& out){cv::compare(in1, in2, out, cv::CMP_LT);}};
 166 g_api_ocv_pair_mat_mat opLessEq = {std::string{"operator<="},
 167                                             [](cv::GMat in1,cv::GMat in2){return in1<=in2;},
 168                                             [](const cv::Mat& in1, const cv::Mat& in2, cv::Mat& out){cv::compare(in1, in2, out, cv::CMP_LE);}};
 169 g_api_ocv_pair_mat_mat opEq = {std::string{"operator=="},
 170                                             [](cv::GMat in1,cv::GMat in2){return in1==in2;},
 171                                             [](const cv::Mat& in1, const cv::Mat& in2, cv::Mat& out){cv::compare(in1, in2, out, cv::CMP_EQ);}};
 172 g_api_ocv_pair_mat_mat opNotEq = {std::string{"operator!="},
 173                                             [](cv::GMat in1,cv::GMat in2){return in1!=in2;},
 174                                             [](const cv::Mat& in1, const cv::Mat& in2, cv::Mat& out){cv::compare(in1, in2, out, cv::CMP_NE);}};
 175
 176 g_api_ocv_pair_mat_mat opAnd = {std::string{"operator&"},
 177                                         [](cv::GMat in1,cv::GMat in2){return in1&in2;},
 178                                         [](const cv::Mat& in1, const cv::Mat& in2, cv::Mat& out){cv::bitwise_and(in1, in2, out);}};
 179 g_api_ocv_pair_mat_mat opOr = {std::string{"operator|"},
 180                                         [](cv::GMat in1,cv::GMat in2){return in1|in2;},
 181                                         [](const cv::Mat& in1, const cv::Mat& in2, cv::Mat& out){cv::bitwise_or(in1, in2, out);}};
 182 g_api_ocv_pair_mat_mat opXor = {std::string{"operator^"},
 183                                         [](cv::GMat in1,cv::GMat in2){return in1^in2;},
 184                                         [](const cv::Mat& in1, const cv::Mat& in2, cv::Mat& out){cv::bitwise_xor(in1, in2, out);}};
 185
 186 } // anonymous namespace
 187 struct MathOperatorMatScalarTest : public TestParams<std::tuple<compare_f, g_api_ocv_pair_mat_scalar,int,cv::Size,int,bool,cv::GCompileArgs>>{};
 188 struct MathOperatorMatMatTest : public TestParams<std::tuple<compare_f, g_api_ocv_pair_mat_mat,int,cv::Size,int,bool,cv::GCompileArgs>>{};
 189 struct NotOperatorTest : public TestParams<std::tuple<int,cv::Size,bool,cv::GCompileArgs>> {};
 190 } // opencv_test
 191
 192 #endif // OPENCV_GAPI_OPERATOR_TESTS_COMMON_HPP