← 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/cudalegacy/test/TestHaarCascadeApplication.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/cudalegacy/test/TestHaarCascadeApplication.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) 2000-2008, Intel Corporation, all rights reserved.
 
14
// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
 
15
// Third party copyrights are property of their respective owners.
 
16
//
 
17
// Redistribution and use in source and binary forms, with or without modification,
 
18
// are permitted provided that the following conditions are met:
 
19
//
 
20
//   * Redistribution's of source code must retain the above copyright notice,
 
21
//     this list of conditions and the following disclaimer.
 
22
//
 
23
//   * Redistribution's in binary form must reproduce the above copyright notice,
 
24
//     this list of conditions and the following disclaimer in the documentation
 
25
//     and/or other materials provided with the distribution.
 
26
//
 
27
//   * The name of the copyright holders may not be used to endorse or promote products
 
28
//     derived from this software without specific prior written permission.
 
29
//
 
30
// This software is provided by the copyright holders and contributors "as is" and
 
31
// any express or implied warranties, including, but not limited to, the implied
 
32
// warranties of merchantability and fitness for a particular purpose are disclaimed.
 
33
// In no event shall the Intel Corporation or contributors be liable for any direct,
 
34
// indirect, incidental, special, exemplary, or consequential damages
 
35
// (including, but not limited to, procurement of substitute goods or services;
 
36
// loss of use, data, or profits; or business interruption) however caused
 
37
// and on any theory of liability, whether in contract, strict liability,
 
38
// or tort (including negligence or otherwise) arising in any way out of
 
39
// the use of this software, even if advised of the possibility of such damage.
 
40
//
 
41
//M*/
 
42
 
 
43
#include "test_precomp.hpp"
 
44
 
 
45
namespace
 
46
{
 
47
    // http://www.christian-seiler.de/projekte/fpmath/
 
48
    class FpuControl
 
49
    {
 
50
    public:
 
51
        FpuControl();
 
52
        ~FpuControl();
 
53
 
 
54
    private:
 
55
    #if defined(__GNUC__) && !defined(__APPLE__) && !defined(__arm__) && !defined(__aarch64__)
 
56
        fpu_control_t fpu_oldcw, fpu_cw;
 
57
    #elif defined(_WIN32) && !defined(_WIN64)
 
58
        unsigned int fpu_oldcw, fpu_cw;
 
59
    #endif
 
60
    };
 
61
 
 
62
    FpuControl::FpuControl()
 
63
    {
 
64
    #if defined(__GNUC__) && !defined(__APPLE__) && !defined(__arm__) && !defined(__aarch64__)
 
65
        _FPU_GETCW(fpu_oldcw);
 
66
        fpu_cw = (fpu_oldcw & ~_FPU_EXTENDED & ~_FPU_DOUBLE & ~_FPU_SINGLE) | _FPU_SINGLE;
 
67
        _FPU_SETCW(fpu_cw);
 
68
    #elif defined(_WIN32) && !defined(_WIN64)
 
69
        _controlfp_s(&fpu_cw, 0, 0);
 
70
        fpu_oldcw = fpu_cw;
 
71
        _controlfp_s(&fpu_cw, _PC_24, _MCW_PC);
 
72
    #endif
 
73
    }
 
74
 
 
75
    FpuControl::~FpuControl()
 
76
    {
 
77
    #if defined(__GNUC__) && !defined(__APPLE__) && !defined(__arm__) && !defined(__aarch64__)
 
78
        _FPU_SETCW(fpu_oldcw);
 
79
    #elif defined(_WIN32) && !defined(_WIN64)
 
80
        _controlfp_s(&fpu_cw, fpu_oldcw, _MCW_PC);
 
81
    #endif
 
82
    }
 
83
}
 
84
 
 
85
TestHaarCascadeApplication::TestHaarCascadeApplication(std::string testName_, NCVTestSourceProvider<Ncv8u> &src_,
 
86
                                                       std::string cascadeName_, Ncv32u width_, Ncv32u height_)
 
87
    :
 
88
    NCVTestProvider(testName_),
 
89
    src(src_),
 
90
    cascadeName(cascadeName_),
 
91
    width(width_),
 
92
    height(height_)
 
93
{
 
94
}
 
95
 
 
96
 
 
97
bool TestHaarCascadeApplication::toString(std::ofstream &strOut)
 
98
{
 
99
    strOut << "cascadeName=" << cascadeName << std::endl;
 
100
    strOut << "width=" << width << std::endl;
 
101
    strOut << "height=" << height << std::endl;
 
102
    return true;
 
103
}
 
104
 
 
105
 
 
106
bool TestHaarCascadeApplication::init()
 
107
{
 
108
    return true;
 
109
}
 
110
 
 
111
bool TestHaarCascadeApplication::process()
 
112
{
 
113
    NCVStatus ncvStat;
 
114
    bool rcode = false;
 
115
 
 
116
    Ncv32u numStages, numNodes, numFeatures;
 
117
 
 
118
    ncvStat = ncvHaarGetClassifierSize(this->cascadeName, numStages, numNodes, numFeatures);
 
119
    ncvAssertReturn(ncvStat == NCV_SUCCESS, false);
 
120
 
 
121
    NCVVectorAlloc<HaarStage64> h_HaarStages(*this->allocatorCPU.get(), numStages);
 
122
    ncvAssertReturn(h_HaarStages.isMemAllocated(), false);
 
123
    NCVVectorAlloc<HaarClassifierNode128> h_HaarNodes(*this->allocatorCPU.get(), numNodes);
 
124
    ncvAssertReturn(h_HaarNodes.isMemAllocated(), false);
 
125
    NCVVectorAlloc<HaarFeature64> h_HaarFeatures(*this->allocatorCPU.get(), numFeatures);
 
126
    ncvAssertReturn(h_HaarFeatures.isMemAllocated(), false);
 
127
 
 
128
    NCVVectorAlloc<HaarStage64> d_HaarStages(*this->allocatorGPU.get(), numStages);
 
129
    ncvAssertReturn(d_HaarStages.isMemAllocated(), false);
 
130
    NCVVectorAlloc<HaarClassifierNode128> d_HaarNodes(*this->allocatorGPU.get(), numNodes);
 
131
    ncvAssertReturn(d_HaarNodes.isMemAllocated(), false);
 
132
    NCVVectorAlloc<HaarFeature64> d_HaarFeatures(*this->allocatorGPU.get(), numFeatures);
 
133
    ncvAssertReturn(d_HaarFeatures.isMemAllocated(), false);
 
134
 
 
135
    HaarClassifierCascadeDescriptor haar;
 
136
    haar.ClassifierSize.width = haar.ClassifierSize.height = 1;
 
137
    haar.bNeedsTiltedII = false;
 
138
    haar.NumClassifierRootNodes = numNodes;
 
139
    haar.NumClassifierTotalNodes = numNodes;
 
140
    haar.NumFeatures = numFeatures;
 
141
    haar.NumStages = numStages;
 
142
 
 
143
    NCV_SET_SKIP_COND(this->allocatorGPU.get()->isCounting());
 
144
    NCV_SKIP_COND_BEGIN
 
145
 
 
146
    ncvStat = ncvHaarLoadFromFile_host(this->cascadeName, haar, h_HaarStages, h_HaarNodes, h_HaarFeatures);
 
147
    ncvAssertReturn(ncvStat == NCV_SUCCESS, false);
 
148
 
 
149
    ncvAssertReturn(NCV_SUCCESS == h_HaarStages.copySolid(d_HaarStages, 0), false);
 
150
    ncvAssertReturn(NCV_SUCCESS == h_HaarNodes.copySolid(d_HaarNodes, 0), false);
 
151
    ncvAssertReturn(NCV_SUCCESS == h_HaarFeatures.copySolid(d_HaarFeatures, 0), false);
 
152
    ncvAssertCUDAReturn(cudaStreamSynchronize(0), false);
 
153
 
 
154
    NCV_SKIP_COND_END
 
155
 
 
156
    NcvSize32s srcRoi, srcIIRoi, searchRoi;
 
157
    srcRoi.width = this->width;
 
158
    srcRoi.height = this->height;
 
159
    srcIIRoi.width = srcRoi.width + 1;
 
160
    srcIIRoi.height = srcRoi.height + 1;
 
161
    searchRoi.width = srcIIRoi.width - haar.ClassifierSize.width;
 
162
    searchRoi.height = srcIIRoi.height - haar.ClassifierSize.height;
 
163
    if (searchRoi.width <= 0 || searchRoi.height <= 0)
 
164
    {
 
165
        return false;
 
166
    }
 
167
    NcvSize32u searchRoiU(searchRoi.width, searchRoi.height);
 
168
 
 
169
    NCVMatrixAlloc<Ncv8u> d_img(*this->allocatorGPU.get(), this->width, this->height);
 
170
    ncvAssertReturn(d_img.isMemAllocated(), false);
 
171
    NCVMatrixAlloc<Ncv8u> h_img(*this->allocatorCPU.get(), this->width, this->height);
 
172
    ncvAssertReturn(h_img.isMemAllocated(), false);
 
173
 
 
174
    Ncv32u integralWidth = this->width + 1;
 
175
    Ncv32u integralHeight = this->height + 1;
 
176
 
 
177
    NCVMatrixAlloc<Ncv32u> d_integralImage(*this->allocatorGPU.get(), integralWidth, integralHeight);
 
178
    ncvAssertReturn(d_integralImage.isMemAllocated(), false);
 
179
    NCVMatrixAlloc<Ncv64u> d_sqIntegralImage(*this->allocatorGPU.get(), integralWidth, integralHeight);
 
180
    ncvAssertReturn(d_sqIntegralImage.isMemAllocated(), false);
 
181
    NCVMatrixAlloc<Ncv32u> h_integralImage(*this->allocatorCPU.get(), integralWidth, integralHeight);
 
182
    ncvAssertReturn(h_integralImage.isMemAllocated(), false);
 
183
    NCVMatrixAlloc<Ncv64u> h_sqIntegralImage(*this->allocatorCPU.get(), integralWidth, integralHeight);
 
184
    ncvAssertReturn(h_sqIntegralImage.isMemAllocated(), false);
 
185
 
 
186
    NCVMatrixAlloc<Ncv32f> d_rectStdDev(*this->allocatorGPU.get(), this->width, this->height);
 
187
    ncvAssertReturn(d_rectStdDev.isMemAllocated(), false);
 
188
    NCVMatrixAlloc<Ncv32u> d_pixelMask(*this->allocatorGPU.get(), this->width, this->height);
 
189
    ncvAssertReturn(d_pixelMask.isMemAllocated(), false);
 
190
    NCVMatrixAlloc<Ncv32f> h_rectStdDev(*this->allocatorCPU.get(), this->width, this->height);
 
191
    ncvAssertReturn(h_rectStdDev.isMemAllocated(), false);
 
192
    NCVMatrixAlloc<Ncv32u> h_pixelMask(*this->allocatorCPU.get(), this->width, this->height);
 
193
    ncvAssertReturn(h_pixelMask.isMemAllocated(), false);
 
194
 
 
195
    NCVVectorAlloc<NcvRect32u> d_hypotheses(*this->allocatorGPU.get(), this->width * this->height);
 
196
    ncvAssertReturn(d_hypotheses.isMemAllocated(), false);
 
197
    NCVVectorAlloc<NcvRect32u> h_hypotheses(*this->allocatorCPU.get(), this->width * this->height);
 
198
    ncvAssertReturn(h_hypotheses.isMemAllocated(), false);
 
199
 
 
200
    NCVStatus nppStat;
 
201
    Ncv32u szTmpBufIntegral, szTmpBufSqIntegral;
 
202
    nppStat = nppiStIntegralGetSize_8u32u(NcvSize32u(this->width, this->height), &szTmpBufIntegral, this->devProp);
 
203
    ncvAssertReturn(nppStat == NPPST_SUCCESS, false);
 
204
    nppStat = nppiStSqrIntegralGetSize_8u64u(NcvSize32u(this->width, this->height), &szTmpBufSqIntegral, this->devProp);
 
205
    ncvAssertReturn(nppStat == NPPST_SUCCESS, false);
 
206
    NCVVectorAlloc<Ncv8u> d_tmpIIbuf(*this->allocatorGPU.get(), std::max(szTmpBufIntegral, szTmpBufSqIntegral));
 
207
    ncvAssertReturn(d_tmpIIbuf.isMemAllocated(), false);
 
208
 
 
209
    Ncv32u detectionsOnThisScale_d = 0;
 
210
    Ncv32u detectionsOnThisScale_h = 0;
 
211
 
 
212
    NCV_SKIP_COND_BEGIN
 
213
 
 
214
    ncvAssertReturn(this->src.fill(h_img), false);
 
215
    ncvStat = h_img.copySolid(d_img, 0);
 
216
    ncvAssertReturn(ncvStat == NCV_SUCCESS, false);
 
217
    ncvAssertCUDAReturn(cudaStreamSynchronize(0), false);
 
218
 
 
219
    nppStat = nppiStIntegral_8u32u_C1R(d_img.ptr(), d_img.pitch(),
 
220
                                       d_integralImage.ptr(), d_integralImage.pitch(),
 
221
                                       NcvSize32u(d_img.width(), d_img.height()),
 
222
                                       d_tmpIIbuf.ptr(), szTmpBufIntegral, this->devProp);
 
223
    ncvAssertReturn(nppStat == NPPST_SUCCESS, false);
 
224
 
 
225
    nppStat = nppiStSqrIntegral_8u64u_C1R(d_img.ptr(), d_img.pitch(),
 
226
                                          d_sqIntegralImage.ptr(), d_sqIntegralImage.pitch(),
 
227
                                          NcvSize32u(d_img.width(), d_img.height()),
 
228
                                          d_tmpIIbuf.ptr(), szTmpBufSqIntegral, this->devProp);
 
229
    ncvAssertReturn(nppStat == NPPST_SUCCESS, false);
 
230
 
 
231
    const NcvRect32u rect(
 
232
        HAAR_STDDEV_BORDER,
 
233
        HAAR_STDDEV_BORDER,
 
234
        haar.ClassifierSize.width - 2*HAAR_STDDEV_BORDER,
 
235
        haar.ClassifierSize.height - 2*HAAR_STDDEV_BORDER);
 
236
    nppStat = nppiStRectStdDev_32f_C1R(
 
237
        d_integralImage.ptr(), d_integralImage.pitch(),
 
238
        d_sqIntegralImage.ptr(), d_sqIntegralImage.pitch(),
 
239
        d_rectStdDev.ptr(), d_rectStdDev.pitch(),
 
240
        NcvSize32u(searchRoi.width, searchRoi.height), rect,
 
241
        1.0f, true);
 
242
    ncvAssertReturn(nppStat == NPPST_SUCCESS, false);
 
243
 
 
244
    ncvStat = d_integralImage.copySolid(h_integralImage, 0);
 
245
    ncvAssertReturn(ncvStat == NCV_SUCCESS, false);
 
246
    ncvStat = d_rectStdDev.copySolid(h_rectStdDev, 0);
 
247
    ncvAssertReturn(ncvStat == NCV_SUCCESS, false);
 
248
 
 
249
    for (Ncv32u i=0; i<searchRoiU.height; i++)
 
250
    {
 
251
        for (Ncv32u j=0; j<h_pixelMask.stride(); j++)
 
252
        {
 
253
            if (j<searchRoiU.width)
 
254
            {
 
255
                h_pixelMask.ptr()[i*h_pixelMask.stride()+j] = (i << 16) | j;
 
256
            }
 
257
            else
 
258
            {
 
259
                h_pixelMask.ptr()[i*h_pixelMask.stride()+j] = OBJDET_MASK_ELEMENT_INVALID_32U;
 
260
            }
 
261
        }
 
262
    }
 
263
    ncvAssertReturn(cudaSuccess == cudaStreamSynchronize(0), false);
 
264
 
 
265
    {
 
266
        // calculations here
 
267
        FpuControl fpu;
 
268
        (void) fpu;
 
269
 
 
270
        ncvStat = ncvApplyHaarClassifierCascade_host(
 
271
            h_integralImage, h_rectStdDev, h_pixelMask,
 
272
            detectionsOnThisScale_h,
 
273
            haar, h_HaarStages, h_HaarNodes, h_HaarFeatures, false,
 
274
            searchRoiU, 1, 1.0f);
 
275
        ncvAssertReturn(ncvStat == NCV_SUCCESS, false);
 
276
    }
 
277
 
 
278
    NCV_SKIP_COND_END
 
279
 
 
280
    int devId;
 
281
    ncvAssertCUDAReturn(cudaGetDevice(&devId), false);
 
282
    cudaDeviceProp _devProp;
 
283
    ncvAssertCUDAReturn(cudaGetDeviceProperties(&_devProp, devId), false);
 
284
 
 
285
    ncvStat = ncvApplyHaarClassifierCascade_device(
 
286
        d_integralImage, d_rectStdDev, d_pixelMask,
 
287
        detectionsOnThisScale_d,
 
288
        haar, h_HaarStages, d_HaarStages, d_HaarNodes, d_HaarFeatures, false,
 
289
        searchRoiU, 1, 1.0f,
 
290
        *this->allocatorGPU.get(), *this->allocatorCPU.get(),
 
291
        _devProp, 0);
 
292
    ncvAssertReturn(ncvStat == NCV_SUCCESS, false);
 
293
 
 
294
    NCVMatrixAlloc<Ncv32u> h_pixelMask_d(*this->allocatorCPU.get(), this->width, this->height);
 
295
    ncvAssertReturn(h_pixelMask_d.isMemAllocated(), false);
 
296
 
 
297
    //bit-to-bit check
 
298
    bool bLoopVirgin = true;
 
299
 
 
300
    NCV_SKIP_COND_BEGIN
 
301
 
 
302
    ncvStat = d_pixelMask.copySolid(h_pixelMask_d, 0);
 
303
    ncvAssertReturn(ncvStat == NCV_SUCCESS, false);
 
304
 
 
305
    if (detectionsOnThisScale_d != detectionsOnThisScale_h)
 
306
    {
 
307
        bLoopVirgin = false;
 
308
    }
 
309
    else
 
310
    {
 
311
        std::sort(h_pixelMask_d.ptr(), h_pixelMask_d.ptr() + detectionsOnThisScale_d);
 
312
        for (Ncv32u i=0; i<detectionsOnThisScale_d && bLoopVirgin; i++)
 
313
        {
 
314
            if (h_pixelMask.ptr()[i] != h_pixelMask_d.ptr()[i])
 
315
            {
 
316
                bLoopVirgin = false;
 
317
            }
 
318
        }
 
319
    }
 
320
 
 
321
    NCV_SKIP_COND_END
 
322
 
 
323
    if (bLoopVirgin)
 
324
    {
 
325
        rcode = true;
 
326
    }
 
327
 
 
328
    return rcode;
 
329
}
 
330
 
 
331
 
 
332
bool TestHaarCascadeApplication::deinit()
 
333
{
 
334
    return true;
 
335
}