CoCalc -- gapi_imgproc_tests

GitHub Repository: Tetragramm/opencv
Path: blob/master/modules/gapi/test/cpu/gapi_imgproc_tests_cpu.cpp
¹⁶³³⁷ 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
#include "../test_precomp.hpp"
9

10
#include "../common/gapi_imgproc_tests.hpp"
11
#include "opencv2/gapi/cpu/imgproc.hpp"
12

13
#define IMGPROC_CPU cv::gapi::imgproc::cpu::kernels()
14

15
namespace opencv_test
16
{
17

18
class AbsExact : public Wrappable<AbsExact>
19
{
20
public:
21
    AbsExact() {}
22
    bool operator() (const cv::Mat& in1, const cv::Mat& in2) const { return cv::countNonZero(in1 != in2)==0; }
23
private:
24
};
25

26
class AbsTolerance : public Wrappable<AbsTolerance>
27
{
28
public:
29
    AbsTolerance(double tol) : _tol(tol) {}
30
    bool operator() (const cv::Mat& in1, const cv::Mat& in2) const
31
    {
32
        cv::Mat absDiff; cv::absdiff(in1, in2, absDiff);
33
        return cv::countNonZero(absDiff > _tol) == 0;
34
    }
35
private:
36
    double _tol;
37
};
38

39
INSTANTIATE_TEST_CASE_P(Filter2DTestCPU, Filter2DTest,
40
                        Combine(Values(AbsExact().to_compare_f()),
41
                                Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
42
                                Values(3, 4, 5, 7),
43
                                Values(cv::Size(1280, 720),
44
                                       cv::Size(640, 480),
45
                                       cv::Size(128, 128)),
46
                                Values(cv::BORDER_DEFAULT),
47
                                Values(-1, CV_32F),
48
/*init output matrices or not*/ testing::Bool(),
49
                                Values(cv::compile_args(IMGPROC_CPU))));
50

51
INSTANTIATE_TEST_CASE_P(BoxFilterTestCPU, BoxFilterTest,
52
                        Combine(Values(AbsTolerance(1e-6).to_compare_f()),
53
                                Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
54
                                Values(3,5),
55
                                Values(cv::Size(1280, 720),
56
                                       cv::Size(640, 480)),
57
                                Values(cv::BORDER_DEFAULT),
58
                                Values(-1, CV_32F),
59
/*init output matrices or not*/ testing::Bool(),
60
                                Values(cv::compile_args(IMGPROC_CPU))));
61

62
INSTANTIATE_TEST_CASE_P(SepFilterTestCPU_8U, SepFilterTest,
63
                        Combine(Values(AbsExact().to_compare_f()),
64
                                Values(CV_8UC1, CV_8UC3),
65
                                Values(3),
66
                                Values(cv::Size(1280, 720),
67
                                       cv::Size(640, 480)),
68
                                Values(-1, CV_16S, CV_32F),
69
/*init output matrices or not*/ testing::Bool(),
70
                                Values(cv::compile_args(IMGPROC_CPU))));
71

72
INSTANTIATE_TEST_CASE_P(SepFilterTestCPU_other, SepFilterTest,
73
                        Combine(Values(AbsExact().to_compare_f()),
74
                                Values(CV_16UC1, CV_16SC1, CV_32FC1),
75
                                Values(3),
76
                                Values(cv::Size(1280, 720),
77
                                       cv::Size(640, 480)),
78
                                Values(-1, CV_32F),
79
/*init output matrices or not*/ testing::Bool(),
80
                                Values(cv::compile_args(IMGPROC_CPU))));
81

82
INSTANTIATE_TEST_CASE_P(BlurTestCPU, BlurTest,
83
                        Combine(Values(AbsTolerance(0.0).to_compare_f()),
84
                                Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
85
                                Values(3,5),
86
                                Values(cv::Size(1280, 720),
87
                                       cv::Size(640, 480)),
88
                                Values(cv::BORDER_DEFAULT),
89
/*init output matrices or not*/ testing::Bool(),
90
                                Values(cv::compile_args(IMGPROC_CPU))));
91

92
INSTANTIATE_TEST_CASE_P(gaussBlurTestCPU, GaussianBlurTest,
93
                        Combine(Values(AbsExact().to_compare_f()),
94
                                Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
95
                                Values(3, 5),
96
                                Values(cv::Size(1280, 720),
97
                                       cv::Size(640, 480)),
98
/*init output matrices or not*/ testing::Bool(),
99
                                Values(cv::compile_args(IMGPROC_CPU))));
100

101
INSTANTIATE_TEST_CASE_P(MedianBlurTestCPU, MedianBlurTest,
102
                        Combine(Values(AbsExact().to_compare_f()),
103
                                Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
104
                                Values(3, 5),
105
                                Values(cv::Size(1280, 720),
106
                                       cv::Size(640, 480)),
107
/*init output matrices or not*/ testing::Bool(),
108
                                Values(cv::compile_args(IMGPROC_CPU))));
109

110
INSTANTIATE_TEST_CASE_P(ErodeTestCPU, ErodeTest,
111
                        Combine(Values(AbsExact().to_compare_f()),
112
                                Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
113
                                Values(3, 5),
114
                                Values(cv::Size(1280, 720),
115
                                       cv::Size(640, 480)),
116
                                Values(cv::MorphShapes::MORPH_RECT,
117
                                       cv::MorphShapes::MORPH_CROSS,
118
                                       cv::MorphShapes::MORPH_ELLIPSE),
119
/*init output matrices or not*/ testing::Bool(),
120
                                Values(cv::compile_args(IMGPROC_CPU))));
121

122
INSTANTIATE_TEST_CASE_P(Erode3x3TestCPU, Erode3x3Test,
123
                        Combine(Values(AbsExact().to_compare_f()),
124
                                Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
125
                                Values(cv::Size(1280, 720),
126
                                       cv::Size(640, 480)),
127
/*init output matrices or not*/ testing::Bool(),
128
                                Values(1,2,4),
129
                                Values(cv::compile_args(IMGPROC_CPU))));
130

131
INSTANTIATE_TEST_CASE_P(DilateTestCPU, DilateTest,
132
                        Combine(Values(AbsExact().to_compare_f()),
133
                                Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
134
                                Values(3, 5),
135
                                Values(cv::Size(1280, 720),
136
                                       cv::Size(640, 480)),
137
                                Values(cv::MorphShapes::MORPH_RECT,
138
                                       cv::MorphShapes::MORPH_CROSS,
139
                                       cv::MorphShapes::MORPH_ELLIPSE),
140
/*init output matrices or not*/ testing::Bool(),
141
                                Values(cv::compile_args(IMGPROC_CPU))));
142

143
INSTANTIATE_TEST_CASE_P(Dilate3x3TestCPU, Dilate3x3Test,
144
                        Combine(Values(AbsExact().to_compare_f()),
145
                                Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
146
                                Values(cv::Size(1280, 720),
147
                                       cv::Size(640, 480)),
148
/*init output matrices or not*/ testing::Bool(),
149
                                Values(1,2,4),
150
                                Values(cv::compile_args(IMGPROC_CPU))));
151

152
INSTANTIATE_TEST_CASE_P(SobelTestCPU, SobelTest,
153
                        Combine(Values(AbsExact().to_compare_f()),
154
                                Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
155
                                Values(3, 5),
156
                                Values(cv::Size(1280, 720),
157
                                       cv::Size(640, 480)),
158
                                Values(-1, CV_32F),
159
                                Values(0, 1),
160
                                Values(1, 2),
161
/*init output matrices or not*/ testing::Bool(),
162
                                Values(cv::compile_args(IMGPROC_CPU))));
163

164
INSTANTIATE_TEST_CASE_P(EqHistTestCPU, EqHistTest,
165
                        Combine(Values(AbsExact().to_compare_f()),
166
                                Values(cv::Size(1280, 720),
167
                                cv::Size(640, 480)),
168
/*init output matrices or not*/ testing::Bool(),
169
                                Values(cv::compile_args(IMGPROC_CPU))));
170

171
INSTANTIATE_TEST_CASE_P(CannyTestCPU, CannyTest,
172
                        Combine(Values(AbsExact().to_compare_f()),
173
                                Values(CV_8UC1, CV_8UC3),
174
                                Values(cv::Size(1280, 720),
175
                                       cv::Size(640, 480)),
176
                                Values(3.0, 120.0),
177
                                Values(125.0, 240.0),
178
                                Values(3, 5),
179
                                testing::Bool(),
180
/*init output matrices or not*/ testing::Bool(),
181
                                Values(cv::compile_args(IMGPROC_CPU))));
182

183
INSTANTIATE_TEST_CASE_P(RGB2GrayTestCPU, RGB2GrayTest,
184
                        Combine(Values(AbsExact().to_compare_f()),
185
                                Values(cv::Size(1280, 720),
186
                                cv::Size(640, 480)),
187
/*init output matrices or not*/ testing::Bool(),
188
                                Values(cv::compile_args(IMGPROC_CPU))));
189

190
INSTANTIATE_TEST_CASE_P(BGR2GrayTestCPU, BGR2GrayTest,
191
                        Combine(Values(AbsExact().to_compare_f()),
192
                                Values(cv::Size(1280, 720),
193
                                       cv::Size(640, 480)),
194
/*init output matrices or not*/ testing::Bool(),
195
                                Values(cv::compile_args(IMGPROC_CPU))));
196

197
INSTANTIATE_TEST_CASE_P(RGB2YUVTestCPU, RGB2YUVTest,
198
                        Combine(Values(AbsExact().to_compare_f()),
199
                                Values(cv::Size(1280, 720),
200
                                       cv::Size(640, 480)),
201
/*init output matrices or not*/ testing::Bool(),
202
                                Values(cv::compile_args(IMGPROC_CPU))));
203

204
INSTANTIATE_TEST_CASE_P(YUV2RGBTestCPU, YUV2RGBTest,
205
                        Combine(Values(AbsExact().to_compare_f()),
206
                                Values(cv::Size(1280, 720),
207
                                       cv::Size(640, 480)),
208
                            /*init output matrices or not*/ testing::Bool(),
209
                                Values(cv::compile_args(IMGPROC_CPU))));
210

211
INSTANTIATE_TEST_CASE_P(RGB2LabTestCPU, RGB2LabTest,
212
                        Combine(Values(AbsExact().to_compare_f()),
213
                                Values(cv::Size(1280, 720),
214
                                       cv::Size(640, 480)),
215
/*init output matrices or not*/ testing::Bool(),
216
                                Values(cv::compile_args(IMGPROC_CPU))));
217

218
INSTANTIATE_TEST_CASE_P(BGR2LUVTestCPU, BGR2LUVTest,
219
                        Combine(Values(AbsExact().to_compare_f()),
220
                                Values(cv::Size(1280, 720),
221
                                       cv::Size(640, 480)),
222
/*init output matrices or not*/ testing::Bool(),
223
                                Values(cv::compile_args(IMGPROC_CPU))));
224

225
INSTANTIATE_TEST_CASE_P(LUV2BGRTestCPU, LUV2BGRTest,
226
                        Combine(Values(AbsExact().to_compare_f()),
227
                                Values(cv::Size(1280, 720),
228
                                       cv::Size(640, 480)),
229
/*init output matrices or not*/ testing::Bool(),
230
                                Values(cv::compile_args(IMGPROC_CPU))));
231

232
INSTANTIATE_TEST_CASE_P(BGR2YUVTestCPU, BGR2YUVTest,
233
                        Combine(Values(AbsExact().to_compare_f()),
234
                                Values(cv::Size(1280, 720),
235
                                       cv::Size(640, 480)),
236
/*init output matrices or not*/ testing::Bool(),
237
                                Values(cv::compile_args(IMGPROC_CPU))));
238

239
INSTANTIATE_TEST_CASE_P(YUV2BGRTestCPU, YUV2BGRTest,
240
                        Combine(Values(AbsExact().to_compare_f()),
241
                                Values(cv::Size(1280, 720),
242
                                       cv::Size(640, 480)),
243
/*init output matrices or not*/ testing::Bool(),
244
                                Values(cv::compile_args(IMGPROC_CPU))));
245

246
} // opencv_test
247

248
Product

Resources

Company
