← Back to branch summary

~paparazzi-uav/paparazzi/v5.0-manual

« back to all changes in this revision

Viewing changes to sw/ext/opencv_bebop/opencv/modules/ts/src/ocl_test.cpp

  • Committer: Paparazzi buildbot
  • Date: 2016-05-18 15:00:29 UTC
  • Revision ID: felix.ruess+docbot@gmail.com-20160518150029-e8lgzi5kvb4p7un9
Manual import commit 4b8bbb730080dac23cf816b98908dacfabe2a8ec from v5.0 branch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
sw/ext/opencv_bebop/opencv/modules/ts/src/ocl_test.cpp
 
1
/*M///////////////////////////////////////////////////////////////////////////////////////
 
2
//
 
3
//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
 
4
//
 
5
//  By downloading, copying, installing or using the software you agree to this license.
 
6
//  If you do not agree to this license, do not download, install,
 
7
//  copy or use the software.
 
8
//
 
9
//
 
10
//                           License Agreement
 
11
//                For Open Source Computer Vision Library
 
12
//
 
13
// Copyright (C) 2010-2013, Advanced Micro Devices, Inc., all rights reserved.
 
14
// Third party copyrights are property of their respective owners.
 
15
//
 
16
// Redistribution and use in source and binary forms, with or without modification,
 
17
// are permitted provided that the following conditions are met:
 
18
//
 
19
//   * Redistribution's of source code must retain the above copyright notice,
 
20
//     this list of conditions and the following disclaimer.
 
21
//
 
22
//   * Redistribution's in binary form must reproduce the above copyright notice,
 
23
//     this list of conditions and the following disclaimer in the documentation
 
24
//     and/or other materials provided with the distribution.
 
25
//
 
26
//   * The name of the copyright holders may not be used to endorse or promote products
 
27
//     derived from this software without specific prior written permission.
 
28
//
 
29
// This software is provided by the copyright holders and contributors "as is" and
 
30
// any express or implied warranties, including, but not limited to, the implied
 
31
// warranties of merchantability and fitness for a particular purpose are disclaimed.
 
32
// In no event shall the OpenCV Foundation or contributors be liable for any direct,
 
33
// indirect, incidental, special, exemplary, or consequential damages
 
34
// (including, but not limited to, procurement of substitute goods or services;
 
35
// loss of use, data, or profits; or business interruption) however caused
 
36
// and on any theory of liability, whether in contract, strict liability,
 
37
// or tort (including negligence or otherwise) arising in any way out of
 
38
// the use of this software, even if advised of the possibility of such damage.
 
39
//
 
40
//M*/
 
41
 
 
42
#include "precomp.hpp"
 
43
 
 
44
#include "opencv2/ts/ocl_test.hpp"
 
45
 
 
46
namespace cvtest {
 
47
namespace ocl {
 
48
 
 
49
using namespace cv;
 
50
 
 
51
int test_loop_times = 1; // TODO Read from command line / environment
 
52
 
 
53
#ifdef HAVE_OPENCL
 
54
 
 
55
#define DUMP_PROPERTY_XML(propertyName, propertyValue) \
 
56
    do { \
 
57
        std::stringstream ssName, ssValue;\
 
58
        ssName << propertyName;\
 
59
        ssValue << (propertyValue); \
 
60
        ::testing::Test::RecordProperty(ssName.str(), ssValue.str()); \
 
61
    } while (false)
 
62
 
 
63
#define DUMP_MESSAGE_STDOUT(msg) \
 
64
    do { \
 
65
        std::cout << msg << std::endl; \
 
66
    } while (false)
 
67
 
 
68
static std::string bytesToStringRepr(size_t value)
 
69
{
 
70
    size_t b = value % 1024;
 
71
    value /= 1024;
 
72
 
 
73
    size_t kb = value % 1024;
 
74
    value /= 1024;
 
75
 
 
76
    size_t mb = value % 1024;
 
77
    value /= 1024;
 
78
 
 
79
    size_t gb = value;
 
80
 
 
81
    std::ostringstream stream;
 
82
 
 
83
    if (gb > 0)
 
84
        stream << gb << " GB ";
 
85
    if (mb > 0)
 
86
        stream << mb << " MB ";
 
87
    if (kb > 0)
 
88
        stream << kb << " kB ";
 
89
    if (b > 0)
 
90
        stream << b << " B";
 
91
 
 
92
    return stream.str();
 
93
}
 
94
 
 
95
void dumpOpenCLDevice()
 
96
{
 
97
    using namespace cv::ocl;
 
98
 
 
99
    try
 
100
    {
 
101
        if (!useOpenCL())
 
102
        {
 
103
            DUMP_MESSAGE_STDOUT("OpenCL is disabled");
 
104
            DUMP_PROPERTY_XML("cv_ocl", "disabled");
 
105
            return;
 
106
        }
 
107
 
 
108
        std::vector<PlatformInfo> platforms;
 
109
        cv::ocl::getPlatfomsInfo(platforms);
 
110
        if (platforms.size() > 0)
 
111
        {
 
112
            DUMP_MESSAGE_STDOUT("OpenCL Platforms: ");
 
113
            for (size_t i = 0; i < platforms.size(); i++)
 
114
            {
 
115
                const PlatformInfo* platform = &platforms[i];
 
116
                DUMP_MESSAGE_STDOUT("    " << platform->name().c_str());
 
117
                Device current_device;
 
118
                for (int j = 0; j < platform->deviceNumber(); j++)
 
119
                {
 
120
                    platform->getDevice(current_device, j);
 
121
                    const char* deviceTypeStr = current_device.type() == Device::TYPE_CPU
 
122
                        ? ("CPU") : (current_device.type() == Device::TYPE_GPU ? current_device.hostUnifiedMemory() ? "iGPU" : "dGPU" : "unknown");
 
123
                    DUMP_MESSAGE_STDOUT( "        " << deviceTypeStr << ": " << current_device.name().c_str() << " (" << current_device.version().c_str() << ")");
 
124
                    DUMP_PROPERTY_XML( cv::format("cv_ocl_platform_%d_device_%d", (int)i, (int)j ),
 
125
                        cv::format("(Platform=%s)(Type=%s)(Name=%s)(Version=%s)",
 
126
                        platform->name().c_str(), deviceTypeStr, current_device.name().c_str(), current_device.version().c_str()) );
 
127
                }
 
128
            }
 
129
        }
 
130
        else
 
131
        {
 
132
            DUMP_MESSAGE_STDOUT("OpenCL is not available");
 
133
            DUMP_PROPERTY_XML("cv_ocl", "not available");
 
134
            return;
 
135
        }
 
136
 
 
137
        const Device& device = Device::getDefault();
 
138
        if (!device.available())
 
139
            CV_ErrorNoReturn(CV_OpenCLInitError, "OpenCL device is not available");
 
140
 
 
141
        DUMP_MESSAGE_STDOUT("Current OpenCL device: ");
 
142
 
 
143
#if 0
 
144
        DUMP_MESSAGE_STDOUT("    Platform = "<< device.getPlatform().name());
 
145
        DUMP_PROPERTY_XML("cv_ocl_current_platformName", device.getPlatform().name());
 
146
#endif
 
147
 
 
148
        const char* deviceTypeStr = device.type() == Device::TYPE_CPU
 
149
            ? ("CPU") : (device.type() == Device::TYPE_GPU ? device.hostUnifiedMemory() ? "iGPU" : "dGPU" : "unknown");
 
150
        DUMP_MESSAGE_STDOUT("    Type = "<< deviceTypeStr);
 
151
        DUMP_PROPERTY_XML("cv_ocl_current_deviceType", deviceTypeStr);
 
152
 
 
153
        DUMP_MESSAGE_STDOUT("    Name = "<< device.name());
 
154
        DUMP_PROPERTY_XML("cv_ocl_current_deviceName", device.name());
 
155
 
 
156
        DUMP_MESSAGE_STDOUT("    Version = " << device.version());
 
157
        DUMP_PROPERTY_XML("cv_ocl_current_deviceVersion", device.version());
 
158
 
 
159
        DUMP_MESSAGE_STDOUT("    Compute units = "<< device.maxComputeUnits());
 
160
        DUMP_PROPERTY_XML("cv_ocl_current_maxComputeUnits", device.maxComputeUnits());
 
161
 
 
162
        DUMP_MESSAGE_STDOUT("    Max work group size = "<< device.maxWorkGroupSize());
 
163
        DUMP_PROPERTY_XML("cv_ocl_current_maxWorkGroupSize", device.maxWorkGroupSize());
 
164
 
 
165
        std::string localMemorySizeStr = bytesToStringRepr(device.localMemSize());
 
166
        DUMP_MESSAGE_STDOUT("    Local memory size = " << localMemorySizeStr);
 
167
        DUMP_PROPERTY_XML("cv_ocl_current_localMemSize", device.localMemSize());
 
168
 
 
169
        std::string maxMemAllocSizeStr = bytesToStringRepr(device.maxMemAllocSize());
 
170
        DUMP_MESSAGE_STDOUT("    Max memory allocation size = "<< maxMemAllocSizeStr);
 
171
        DUMP_PROPERTY_XML("cv_ocl_current_maxMemAllocSize", device.maxMemAllocSize());
 
172
 
 
173
        const char* doubleSupportStr = device.doubleFPConfig() > 0 ? "Yes" : "No";
 
174
        DUMP_MESSAGE_STDOUT("    Double support = "<< doubleSupportStr);
 
175
        DUMP_PROPERTY_XML("cv_ocl_current_haveDoubleSupport", device.doubleFPConfig() > 0);
 
176
 
 
177
        const char* isUnifiedMemoryStr = device.hostUnifiedMemory() ? "Yes" : "No";
 
178
        DUMP_MESSAGE_STDOUT("    Host unified memory = "<< isUnifiedMemoryStr);
 
179
        DUMP_PROPERTY_XML("cv_ocl_current_hostUnifiedMemory", device.hostUnifiedMemory());
 
180
 
 
181
        const char* haveAmdBlasStr = haveAmdBlas() ? "Yes" : "No";
 
182
        DUMP_MESSAGE_STDOUT("    Has AMD Blas = "<< haveAmdBlasStr);
 
183
        DUMP_PROPERTY_XML("cv_ocl_current_AmdBlas", haveAmdBlas());
 
184
 
 
185
        const char* haveAmdFftStr = haveAmdFft() ? "Yes" : "No";
 
186
        DUMP_MESSAGE_STDOUT("    Has AMD Fft = "<< haveAmdFftStr);
 
187
        DUMP_PROPERTY_XML("cv_ocl_current_AmdFft", haveAmdFft());
 
188
 
 
189
 
 
190
        DUMP_MESSAGE_STDOUT("    Preferred vector width char = "<< device.preferredVectorWidthChar());
 
191
        DUMP_PROPERTY_XML("cv_ocl_current_preferredVectorWidthChar", device.preferredVectorWidthChar());
 
192
 
 
193
        DUMP_MESSAGE_STDOUT("    Preferred vector width short = "<< device.preferredVectorWidthShort());
 
194
        DUMP_PROPERTY_XML("cv_ocl_current_preferredVectorWidthShort", device.preferredVectorWidthShort());
 
195
 
 
196
        DUMP_MESSAGE_STDOUT("    Preferred vector width int = "<< device.preferredVectorWidthInt());
 
197
        DUMP_PROPERTY_XML("cv_ocl_current_preferredVectorWidthInt", device.preferredVectorWidthInt());
 
198
 
 
199
        DUMP_MESSAGE_STDOUT("    Preferred vector width long = "<< device.preferredVectorWidthLong());
 
200
        DUMP_PROPERTY_XML("cv_ocl_current_preferredVectorWidthLong", device.preferredVectorWidthLong());
 
201
 
 
202
        DUMP_MESSAGE_STDOUT("    Preferred vector width float = "<< device.preferredVectorWidthFloat());
 
203
        DUMP_PROPERTY_XML("cv_ocl_current_preferredVectorWidthFloat", device.preferredVectorWidthFloat());
 
204
 
 
205
        DUMP_MESSAGE_STDOUT("    Preferred vector width double = "<< device.preferredVectorWidthDouble());
 
206
        DUMP_PROPERTY_XML("cv_ocl_current_preferredVectorWidthDouble", device.preferredVectorWidthDouble());
 
207
    }
 
208
    catch (...)
 
209
    {
 
210
        DUMP_MESSAGE_STDOUT("Exception. Can't dump OpenCL info");
 
211
        DUMP_MESSAGE_STDOUT("OpenCL device not available");
 
212
        DUMP_PROPERTY_XML("cv_ocl", "not available");
 
213
    }
 
214
}
 
215
#undef DUMP_MESSAGE_STDOUT
 
216
#undef DUMP_PROPERTY_XML
 
217
 
 
218
#endif
 
219
 
 
220
Mat TestUtils::readImage(const String &fileName, int flags)
 
221
{
 
222
    return cv::imread(cvtest::TS::ptr()->get_data_path() + fileName, flags);
 
223
}
 
224
 
 
225
Mat TestUtils::readImageType(const String &fname, int type)
 
226
{
 
227
    Mat src = readImage(fname, CV_MAT_CN(type) == 1 ? cv::IMREAD_GRAYSCALE : cv::IMREAD_COLOR);
 
228
    if (CV_MAT_CN(type) == 4)
 
229
    {
 
230
        Mat temp;
 
231
        cv::cvtColor(src, temp, cv::COLOR_BGR2BGRA);
 
232
        swap(src, temp);
 
233
    }
 
234
    src.convertTo(src, CV_MAT_DEPTH(type));
 
235
    return src;
 
236
}
 
237
 
 
238
double TestUtils::checkNorm1(InputArray m, InputArray mask)
 
239
{
 
240
    return cvtest::norm(m.getMat(), NORM_INF, mask.getMat());
 
241
}
 
242
 
 
243
double TestUtils::checkNorm2(InputArray m1, InputArray m2, InputArray mask)
 
244
{
 
245
    return cvtest::norm(m1.getMat(), m2.getMat(), NORM_INF, mask.getMat());
 
246
}
 
247
 
 
248
double TestUtils::checkSimilarity(InputArray m1, InputArray m2)
 
249
{
 
250
    Mat diff;
 
251
    matchTemplate(m1.getMat(), m2.getMat(), diff, CV_TM_CCORR_NORMED);
 
252
    return std::abs(diff.at<float>(0, 0) - 1.f);
 
253
}
 
254
 
 
255
double TestUtils::checkRectSimilarity(const Size & sz, std::vector<Rect>& ob1, std::vector<Rect>& ob2)
 
256
{
 
257
    double final_test_result = 0.0;
 
258
    size_t sz1 = ob1.size();
 
259
    size_t sz2 = ob2.size();
 
260
 
 
261
    if (sz1 != sz2)
 
262
        return sz1 > sz2 ? (double)(sz1 - sz2) : (double)(sz2 - sz1);
 
263
    else
 
264
    {
 
265
        if (sz1 == 0 && sz2 == 0)
 
266
            return 0;
 
267
        cv::Mat cpu_result(sz, CV_8UC1);
 
268
        cpu_result.setTo(0);
 
269
 
 
270
        for (vector<Rect>::const_iterator r = ob1.begin(); r != ob1.end(); r++)
 
271
        {
 
272
            cv::Mat cpu_result_roi(cpu_result, *r);
 
273
            cpu_result_roi.setTo(1);
 
274
            cpu_result.copyTo(cpu_result);
 
275
        }
 
276
        int cpu_area = cv::countNonZero(cpu_result > 0);
 
277
 
 
278
        cv::Mat gpu_result(sz, CV_8UC1);
 
279
        gpu_result.setTo(0);
 
280
        for(vector<Rect>::const_iterator r2 = ob2.begin(); r2 != ob2.end(); r2++)
 
281
        {
 
282
            cv::Mat gpu_result_roi(gpu_result, *r2);
 
283
            gpu_result_roi.setTo(1);
 
284
            gpu_result.copyTo(gpu_result);
 
285
        }
 
286
 
 
287
        cv::Mat result_;
 
288
        multiply(cpu_result, gpu_result, result_);
 
289
        int result = cv::countNonZero(result_ > 0);
 
290
        if (cpu_area!=0 && result!=0)
 
291
            final_test_result = 1.0 - (double)result/(double)cpu_area;
 
292
        else if(cpu_area==0 && result!=0)
 
293
            final_test_result = -1;
 
294
    }
 
295
    return final_test_result;
 
296
}
 
297
 
 
298
void TestUtils::showDiff(InputArray _src, InputArray _gold, InputArray _actual, double eps, bool alwaysShow)
 
299
{
 
300
    Mat src = _src.getMat(), actual = _actual.getMat(), gold = _gold.getMat();
 
301
 
 
302
    Mat diff, diff_thresh;
 
303
    absdiff(gold, actual, diff);
 
304
    diff.convertTo(diff, CV_32F);
 
305
    threshold(diff, diff_thresh, eps, 255.0, cv::THRESH_BINARY);
 
306
 
 
307
    if (alwaysShow || cv::countNonZero(diff_thresh.reshape(1)) > 0)
 
308
    {
 
309
#if 0
 
310
        std::cout << "Source: " << std::endl << src << std::endl;
 
311
        std::cout << "Expected: " << std::endl << gold << std::endl;
 
312
        std::cout << "Actual: " << std::endl << actual << std::endl;
 
313
#endif
 
314
 
 
315
        namedWindow("src", WINDOW_NORMAL);
 
316
        namedWindow("gold", WINDOW_NORMAL);
 
317
        namedWindow("actual", WINDOW_NORMAL);
 
318
        namedWindow("diff", WINDOW_NORMAL);
 
319
 
 
320
        imshow("src", src);
 
321
        imshow("gold", gold);
 
322
        imshow("actual", actual);
 
323
        imshow("diff", diff);
 
324
 
 
325
        cv::waitKey();
 
326
    }
 
327
}
 
328
 
 
329
} } // namespace cvtest::ocl