CoCalc -- gapi_imgproc_tests

GitHub Repository: Tetragramm/opencv
Path: blob/master/modules/gapi/test/cpu/gapi_imgproc_tests_fluid.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
#include "../common/gapi_imgproc_tests.hpp"
10
#include "backends/fluid/gfluidimgproc.hpp"
11

12
#define IMGPROC_FLUID cv::gapi::imgproc::fluid::kernels()
13

14
namespace opencv_test
15
{
16

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

25

26
class AbsToleranceFluid : public Wrappable<AbsToleranceFluid>
27
{
28
public:
29
    AbsToleranceFluid(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
class AbsTolerance32FFluid : public Wrappable<AbsTolerance32FFluid>
40
{
41
public:
42
    AbsTolerance32FFluid(double tol) : _tol(tol) {}
43
    bool operator() (const cv::Mat& in1, const cv::Mat& in2) const
44
    {
45
        if (CV_MAT_DEPTH(in1.type()) == CV_32F)
46
            return ((cv::countNonZero(cv::abs(in1 - in2) > (_tol)*cv::abs(in2))) ? false : true);
47
        else
48
            return ((cv::countNonZero(in1 != in2) <= (_tol * 100) * in2.total()) ? true : false);
49
    }
50
private:
51
    double _tol;
52
};
53

54
class AbsToleranceSepFilterFluid : public Wrappable<AbsToleranceSepFilterFluid>
55
{
56
public:
57
    AbsToleranceSepFilterFluid(double tol) : _tol(tol) {}
58
    bool operator() (const cv::Mat& in1, const cv::Mat& in2) const
59
    {
60
        return ((cv::countNonZero(cv::abs(in1 - in2) > (_tol)* cv::abs(in2)) <= 0.01 * in2.total()) ? true : false);
61
    }
62
private:
63
    double _tol;
64
};
65

66
class AbsToleranceGaussianBlurFluid : public Wrappable<AbsToleranceGaussianBlurFluid>
67
{
68
public:
69
    AbsToleranceGaussianBlurFluid(double tol) : _tol(tol) {}
70
    bool operator() (const cv::Mat& in1, const cv::Mat& in2) const
71
    {
72
        if (CV_MAT_DEPTH(in1.type()) == CV_32F || CV_MAT_DEPTH(in1.type()) == CV_64F)
73
        {
74
            return ((cv::countNonZero(cv::abs(in1 - in2) > (_tol)*cv::abs(in2))) ? false : true);
75
        }
76
        else
77
        {
78
            if (CV_MAT_DEPTH(in1.type()) == CV_8U)
79
            {
80
                bool a = (cv::countNonZero(cv::abs(in1 - in2) > 1) <= _tol * in2.total());
81
                return ((a == 1 ? 0 : 1) && ((cv::countNonZero(cv::abs(in1 - in2) > 2) <= 0) == 1 ? 0 : 1)) == 1 ? false : true;
82
            }
83
            else return cv::countNonZero(in1 != in2)==0;
84
        }
85
    }
86
private:
87
    double _tol;
88
};
89

90
class AbsToleranceRGBBGRFluid : public Wrappable<AbsToleranceRGBBGRFluid>
91
{
92
public:
93
    AbsToleranceRGBBGRFluid(double tol) : _tol(tol) {}
94
    bool operator() (const cv::Mat& in1, const cv::Mat& in2) const
95
    {
96
        bool a = (cv::countNonZero((in1 - in2) > 0) <= _tol * in2.total());
97
        return ((a == 1 ? 0 : 1) && ((cv::countNonZero((in1 - in2) > 1) <= 0) == 1 ? 0 : 1)) == 1 ? false : true;
98
    }
99
private:
100
    double _tol;
101
};
102

103
class ToleranceTripleFluid : public Wrappable<ToleranceTripleFluid>
104
{
105
public:
106
    ToleranceTripleFluid(double tol1, double tol2, double tol3) : _tol1(tol1), _tol2(tol2), _tol3(tol3) {}
107
    bool operator() (const cv::Mat& in1, const cv::Mat& in2) const
108
    {
109
        bool a = (cv::countNonZero((in1 - in2) > 0) <= _tol1 * in2.total());
110
        return (((a == 1 ? 0 : 1) &&
111
            ((cv::countNonZero((in1 - in2) > 1) <= _tol2 * in2.total()) == 1 ? 0 : 1) &&
112
            ((cv::countNonZero((in1 - in2) > 2) <= _tol3 * in2.total()) == 1 ? 0 : 1))) == 1 ? false : true;
113
    }
114
private:
115
    double _tol1, _tol2, _tol3;
116
};
117

118
INSTANTIATE_TEST_CASE_P(RGB2GrayTestFluid, RGB2GrayTest,
119
                        Combine(Values(AbsToleranceRGBBGRFluid(0.001).to_compare_f()),
120
                                Values(cv::Size(1280, 720),
121
                                cv::Size(640, 480)),
122
                                Values(true, false),
123
                                Values(cv::compile_args(IMGPROC_FLUID))));
124

125
INSTANTIATE_TEST_CASE_P(BGR2GrayTestFluid, BGR2GrayTest,
126
                        Combine(Values(AbsToleranceRGBBGRFluid(0.001).to_compare_f()),
127
                                Values(cv::Size(1280, 720),
128
                                       cv::Size(640, 480)),
129
                                Values(true, false),
130
                                Values(cv::compile_args(IMGPROC_FLUID))));
131

132
INSTANTIATE_TEST_CASE_P(RGB2YUVTestFluid, RGB2YUVTest,
133
                        Combine(Values(AbsToleranceRGBBGRFluid(0.15*3).to_compare_f()),
134
                                Values(cv::Size(1280, 720),
135
                                       cv::Size(640, 480)),
136
                                Values(true, false),
137
                                Values(cv::compile_args(IMGPROC_FLUID))));
138

139
INSTANTIATE_TEST_CASE_P(YUV2RGBTestFluid, YUV2RGBTest,
140
                        Combine(Values(ToleranceTripleFluid(0.25 * 3, 0.01 * 3, 1e-5 * 3).to_compare_f()),
141
                                Values(cv::Size(1280, 720),
142
                                       cv::Size(640, 480)),
143
                                Values(true, false),
144
                                Values(cv::compile_args(IMGPROC_FLUID))));
145

146
INSTANTIATE_TEST_CASE_P(RGB2LabTestFluid, RGB2LabTest,
147
                        Combine(Values(ToleranceTripleFluid(0.25 * 3, 0.0, 1e-5 * 3).to_compare_f()),
148
                                Values(cv::Size(1280, 720),
149
                                       cv::Size(640, 480)),
150
                                Values(true, false),
151
                                Values(cv::compile_args(IMGPROC_FLUID))));
152

153
// FIXME: Not supported by Fluid yet (no kernel implemented)
154
INSTANTIATE_TEST_CASE_P(BGR2LUVTestFluid, BGR2LUVTest,
155
                        Combine(Values(ToleranceTripleFluid(0.25 * 3, 0.01 * 3, 0.0001 * 3).to_compare_f()),
156
                                Values(cv::Size(1280, 720),
157
                                       cv::Size(640, 480)),
158
                                Values(true, false),
159
                                Values(cv::compile_args(IMGPROC_FLUID))));
160

161
INSTANTIATE_TEST_CASE_P(blurTestFluid, BlurTest,
162
                        Combine(Values(AbsToleranceFluid(0.0).to_compare_f()),
163
                                Values(CV_8UC1, CV_16UC1, CV_16SC1),
164
                                Values(3), // add kernel size=5 when implementation is ready
165
                                Values(cv::Size(1280, 720),
166
                                       cv::Size(640, 480)),
167
                                Values(cv::BORDER_DEFAULT),
168
                                Values(true, false),
169
                                Values(cv::compile_args(IMGPROC_FLUID))));
170

171
INSTANTIATE_TEST_CASE_P(gaussBlurTestFluid, GaussianBlurTest,
172
                        Combine(Values(AbsToleranceGaussianBlurFluid(1e-6).to_compare_f()),
173
                                Values(CV_8UC1, CV_16UC1, CV_16SC1),
174
                                Values(3), // add kernel size=5 when implementation is ready
175
                                Values(cv::Size(1280, 720),
176
                                       cv::Size(640, 480)),
177
                                Values(true, false),
178
                                Values(cv::compile_args(IMGPROC_FLUID))));
179

180
INSTANTIATE_TEST_CASE_P(medianBlurTestFluid, MedianBlurTest,
181
                        Combine(Values(AbsExactFluid().to_compare_f()),
182
                                Values(CV_8UC1, CV_16UC1, CV_16SC1),
183
                                Values(3), // add kernel size=5 when implementation is ready
184
                                Values(cv::Size(1280, 720),
185
                                       cv::Size(640, 480)),
186
                                Values(true, false),
187
                                Values(cv::compile_args(IMGPROC_FLUID))));
188

189
INSTANTIATE_TEST_CASE_P(erodeTestFluid, ErodeTest,
190
                        Combine(Values(AbsExactFluid().to_compare_f()),
191
                                Values(CV_8UC1, CV_16UC1, CV_16SC1),
192
                                Values(3), // add kernel size=5 when implementation is ready
193
                                Values(cv::Size(1280, 720),
194
                                       cv::Size(640, 480)),
195
                                Values(cv::MorphShapes::MORPH_RECT,
196
                                       cv::MorphShapes::MORPH_CROSS,
197
                                       cv::MorphShapes::MORPH_ELLIPSE),
198
                                Values(true, false),
199
                                Values(cv::compile_args(IMGPROC_FLUID))));
200

201
INSTANTIATE_TEST_CASE_P(dilateTestFluid, DilateTest,
202
                        Combine(Values(AbsExactFluid().to_compare_f()),
203
                                Values(CV_8UC1, CV_16UC1, CV_16SC1),
204
                                Values(3), // add kernel size=5 when implementation is ready
205
                                Values(cv::Size(1280, 720),
206
                                       cv::Size(640, 480)),
207
                                Values(cv::MorphShapes::MORPH_RECT,
208
                                       cv::MorphShapes::MORPH_CROSS,
209
                                       cv::MorphShapes::MORPH_ELLIPSE),
210
                                Values(true, false),
211
                                Values(cv::compile_args(IMGPROC_FLUID))));
212

213
INSTANTIATE_TEST_CASE_P(SobelTestFluid, SobelTest,
214
                        Combine(Values(AbsExactFluid().to_compare_f()),
215
                                Values(CV_8UC1, CV_16UC1, CV_16SC1),
216
                                Values(3), // add kernel size=5 when implementation is ready
217
                                Values(cv::Size(1280, 720),
218
                                       cv::Size(640, 480)),
219
                                Values(-1, CV_32F),
220
                                Values(0, 1),
221
                                Values(1, 2),
222
                                Values(true, false),
223
                                Values(cv::compile_args(IMGPROC_FLUID))));
224

225
INSTANTIATE_TEST_CASE_P(boxFilterTestFluid32, BoxFilterTest,
226
                        Combine(Values(AbsTolerance32FFluid(1e-6).to_compare_f()),
227
                                Values(CV_8UC1, CV_16UC1, CV_16SC1),
228
                                Values(3), // add kernel size=5 when implementation is ready
229
                                Values(cv::Size(1280, 720),
230
                                       cv::Size(640, 480)),
231
                                Values(cv::BORDER_DEFAULT),
232
                                Values(-1, CV_32F),
233
                                Values(true, false),
234
                                Values(cv::compile_args(IMGPROC_FLUID))));
235

236
INSTANTIATE_TEST_CASE_P(sepFilterTestFluid, SepFilterTest,
237
                        Combine(Values(AbsToleranceSepFilterFluid(1e-5f).to_compare_f()),
238
                                Values(CV_32FC1),
239
                                Values(3), // add kernel size=5 when implementation is ready
240
                                Values(cv::Size(1280, 720),
241
                                       cv::Size(640, 480)),
242
                                Values(-1, CV_32F),
243
                                Values(true, false),
244
                                Values(cv::compile_args(IMGPROC_FLUID))));
245

246
INSTANTIATE_TEST_CASE_P(filter2DTestFluid, Filter2DTest,
247
                        Combine(Values(AbsTolerance32FFluid(1e-6).to_compare_f()),
248
                                Values(CV_8UC1, CV_16UC1, CV_16SC1),
249
                                Values(3), // add kernel size=4,5,7 when implementation ready
250
                                Values(cv::Size(1280, 720),
251
                                       cv::Size(640, 480),
252
                                       cv::Size(128, 128)),
253
                                Values(cv::BORDER_DEFAULT),
254
                                Values(-1, CV_32F),
255
                                Values(true, false),
256
                                Values(cv::compile_args(IMGPROC_FLUID))));
257

258
} // opencv_test
259

260
Product

Resources

Company
