CoCalc -- gapi_operators

GitHub Repository: Tetragramm/opencv
Path: blob/master/modules/gapi/test/common/gapi_operators_tests.hpp
¹⁶³³⁹ views
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 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 c){return in-c;},
153
                                            [](const cv::Mat& in, const cv::Mat& c, cv::Mat& out){cv::subtract(in, c, out);}};
154
g_api_ocv_pair_mat_mat opDivM = {std::string{"operator/"},
155
                                            [](cv::GMat in,cv::GMat c){return in/c;},
156
                                            [](const cv::Mat& in, const cv::Mat& c, cv::Mat& out){cv::divide(in, c, 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<g_api_ocv_pair_mat_scalar,int,cv::Size,int,bool,cv::GCompileArgs>>{};
188
struct MathOperatorMatMatTest : public TestParams<std::tuple<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
193

194
Product

Resources

Company
