1 /*M///////////////////////////////////////////////////////////////////////////////////////
3 // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
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.
11 // For Open Source Computer Vision Library
13 // Copyright (C) 2010-2012, Institute Of Software Chinese Academy Of Science, all rights reserved.
14 // Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
15 // Third party copyrights are property of their respective owners.
18 // Niko Li, newlife20080214@gmail.com
19 // Wang Weiyan, wangweiyanster@gmail.com
20 // Jia Haipeng, jiahaipeng95@gmail.com
21 // Wu Xinglong, wxl370@126.com
22 // Wang Yao, bitwangyaoyao@gmail.com
23 // Sen Liu, swjtuls1987@126.com
25 // Redistribution and use in source and binary forms, with or without modification,
26 // are permitted provided that the following conditions are met:
28 // * Redistribution's of source code must retain the above copyright notice,
29 // this list of conditions and the following disclaimer.
31 // * Redistribution's in binary form must reproduce the above copyright notice,
32 // this list of conditions and the following disclaimer in the documentation
33 // and/or other oclMaterials provided with the distribution.
35 // * The name of the copyright holders may not be used to endorse or promote products
36 // derived from this software without specific prior written permission.
38 // This software is provided by the copyright holders and contributors "as is" and
39 // any express or implied warranties, including, but not limited to, the implied
40 // warranties of merchantability and fitness for a particular purpose are disclaimed.
41 // In no event shall the Intel Corporation or contributors be liable for any direct,
42 // indirect, incidental, special, exemplary, or consequential damages
43 // (including, but not limited to, procurement of substitute goods or services;
44 // loss of use, data, or profits; or business interruption) however caused
45 // and on any theory of liability, whether in contract, strict liability,
46 // or tort (including negligence or otherwise) arising in any way out of
47 // the use of this software, even if advised of the possibility of such damage.
51 #include "precomp.hpp"
56 using namespace cv::ocl;
64 ///////////////////////////OpenCL kernel strings///////////////////////////
65 extern const char *haarobjectdetect;
66 extern const char *haarobjectdetectbackup;
67 extern const char *haarobjectdetect_scaled2;
71 /* these settings affect the quality of detection: change with care */
72 #define CV_ADJUST_FEATURES 1
73 #define CV_ADJUST_WEIGHTS 0
76 typedef double sqsumtype;
78 typedef struct CvHidHaarFeature
82 sumtype *p0, *p1, *p2, *p3;
85 rect[CV_HAAR_FEATURE_MAX];
90 typedef struct CvHidHaarTreeNode
92 CvHidHaarFeature feature;
100 typedef struct CvHidHaarClassifier
103 //CvHaarFeature* orig_feature;
104 CvHidHaarTreeNode *node;
110 typedef struct CvHidHaarStageClassifier
114 CvHidHaarClassifier *classifier;
117 struct CvHidHaarStageClassifier *next;
118 struct CvHidHaarStageClassifier *child;
119 struct CvHidHaarStageClassifier *parent;
121 CvHidHaarStageClassifier;
124 struct CvHidHaarClassifierCascade
128 int has_tilted_features;
130 double inv_window_area;
131 CvMat sum, sqsum, tilted;
132 CvHidHaarStageClassifier *stage_classifier;
133 sqsumtype *pq0, *pq1, *pq2, *pq3;
134 sumtype *p0, *p1, *p2, *p3;
141 int grpnumperline_totalgrp;
144 } detect_piramid_info;
146 #define _ALIGNED_ON(_ALIGNMENT) __declspec(align(_ALIGNMENT))
148 typedef _ALIGNED_ON(128) struct GpuHidHaarTreeNode
150 _ALIGNED_ON(64) int p[CV_HAAR_FEATURE_MAX][4];
151 float weight[CV_HAAR_FEATURE_MAX] ;
153 _ALIGNED_ON(16) float alpha[3] ;
154 _ALIGNED_ON(4) int left ;
155 _ALIGNED_ON(4) int right ;
160 typedef _ALIGNED_ON(32) struct GpuHidHaarClassifier
162 _ALIGNED_ON(4) int count;
163 _ALIGNED_ON(8) GpuHidHaarTreeNode *node ;
164 _ALIGNED_ON(8) float *alpha ;
166 GpuHidHaarClassifier;
169 typedef _ALIGNED_ON(64) struct GpuHidHaarStageClassifier
171 _ALIGNED_ON(4) int count ;
172 _ALIGNED_ON(4) float threshold ;
173 _ALIGNED_ON(4) int two_rects ;
174 _ALIGNED_ON(8) GpuHidHaarClassifier *classifier ;
175 _ALIGNED_ON(8) struct GpuHidHaarStageClassifier *next;
176 _ALIGNED_ON(8) struct GpuHidHaarStageClassifier *child ;
177 _ALIGNED_ON(8) struct GpuHidHaarStageClassifier *parent ;
179 GpuHidHaarStageClassifier;
182 typedef _ALIGNED_ON(64) struct GpuHidHaarClassifierCascade
184 _ALIGNED_ON(4) int count ;
185 _ALIGNED_ON(4) int is_stump_based ;
186 _ALIGNED_ON(4) int has_tilted_features ;
187 _ALIGNED_ON(4) int is_tree ;
188 _ALIGNED_ON(4) int pq0 ;
189 _ALIGNED_ON(4) int pq1 ;
190 _ALIGNED_ON(4) int pq2 ;
191 _ALIGNED_ON(4) int pq3 ;
192 _ALIGNED_ON(4) int p0 ;
193 _ALIGNED_ON(4) int p1 ;
194 _ALIGNED_ON(4) int p2 ;
195 _ALIGNED_ON(4) int p3 ;
196 _ALIGNED_ON(4) float inv_window_area ;
197 } GpuHidHaarClassifierCascade;
199 #define _ALIGNED_ON(_ALIGNMENT) __attribute__((aligned(_ALIGNMENT) ))
201 typedef struct _ALIGNED_ON(128) GpuHidHaarTreeNode
203 int p[CV_HAAR_FEATURE_MAX][4] _ALIGNED_ON(64);
204 float weight[CV_HAAR_FEATURE_MAX];// _ALIGNED_ON(16);
205 float threshold;// _ALIGNED_ON(4);
206 float alpha[3] _ALIGNED_ON(16);
207 int left _ALIGNED_ON(4);
208 int right _ALIGNED_ON(4);
212 typedef struct _ALIGNED_ON(32) GpuHidHaarClassifier
214 int count _ALIGNED_ON(4);
215 GpuHidHaarTreeNode *node _ALIGNED_ON(8);
216 float *alpha _ALIGNED_ON(8);
218 GpuHidHaarClassifier;
221 typedef struct _ALIGNED_ON(64) GpuHidHaarStageClassifier
223 int count _ALIGNED_ON(4);
224 float threshold _ALIGNED_ON(4);
225 int two_rects _ALIGNED_ON(4);
226 GpuHidHaarClassifier *classifier _ALIGNED_ON(8);
227 struct GpuHidHaarStageClassifier *next _ALIGNED_ON(8);
228 struct GpuHidHaarStageClassifier *child _ALIGNED_ON(8);
229 struct GpuHidHaarStageClassifier *parent _ALIGNED_ON(8);
231 GpuHidHaarStageClassifier;
234 typedef struct _ALIGNED_ON(64) GpuHidHaarClassifierCascade
236 int count _ALIGNED_ON(4);
237 int is_stump_based _ALIGNED_ON(4);
238 int has_tilted_features _ALIGNED_ON(4);
239 int is_tree _ALIGNED_ON(4);
240 int pq0 _ALIGNED_ON(4);
241 int pq1 _ALIGNED_ON(4);
242 int pq2 _ALIGNED_ON(4);
243 int pq3 _ALIGNED_ON(4);
244 int p0 _ALIGNED_ON(4);
245 int p1 _ALIGNED_ON(4);
246 int p2 _ALIGNED_ON(4);
247 int p3 _ALIGNED_ON(4);
248 float inv_window_area _ALIGNED_ON(4);
249 } GpuHidHaarClassifierCascade;
252 const int icv_object_win_border = 1;
253 const float icv_stage_threshold_bias = 0.0001f;
254 double globaltime = 0;
256 /* create more efficient internal representation of haar classifier cascade */
257 static GpuHidHaarClassifierCascade * gpuCreateHidHaarClassifierCascade( CvHaarClassifierCascade *cascade, int *size, int *totalclassifier)
259 GpuHidHaarClassifierCascade *out = 0;
263 int total_classifiers = 0;
267 GpuHidHaarStageClassifier *stage_classifier_ptr;
268 GpuHidHaarClassifier *haar_classifier_ptr;
269 GpuHidHaarTreeNode *haar_node_ptr;
271 CvSize orig_window_size;
272 int has_tilted_features = 0;
274 if( !CV_IS_HAAR_CLASSIFIER(cascade) )
275 CV_Error( !cascade ? CV_StsNullPtr : CV_StsBadArg, "Invalid classifier pointer" );
277 if( cascade->hid_cascade )
278 CV_Error( CV_StsError, "hid_cascade has been already created" );
280 if( !cascade->stage_classifier )
281 CV_Error( CV_StsNullPtr, "" );
283 if( cascade->count <= 0 )
284 CV_Error( CV_StsOutOfRange, "Negative number of cascade stages" );
286 orig_window_size = cascade->orig_window_size;
288 /* check input structure correctness and calculate total memory size needed for
289 internal representation of the classifier cascade */
290 for( i = 0; i < cascade->count; i++ )
292 CvHaarStageClassifier *stage_classifier = cascade->stage_classifier + i;
294 if( !stage_classifier->classifier ||
295 stage_classifier->count <= 0 )
297 sprintf( errorstr, "header of the stage classifier #%d is invalid "
298 "(has null pointers or non-positive classfier count)", i );
299 CV_Error( CV_StsError, errorstr );
302 total_classifiers += stage_classifier->count;
304 for( j = 0; j < stage_classifier->count; j++ )
306 CvHaarClassifier *classifier = stage_classifier->classifier + j;
308 total_nodes += classifier->count;
309 for( l = 0; l < classifier->count; l++ )
311 for( k = 0; k < CV_HAAR_FEATURE_MAX; k++ )
313 if( classifier->haar_feature[l].rect[k].r.width )
315 CvRect r = classifier->haar_feature[l].rect[k].r;
316 int tilted = classifier->haar_feature[l].tilted;
317 has_tilted_features |= tilted != 0;
318 if( r.width < 0 || r.height < 0 || r.y < 0 ||
319 r.x + r.width > orig_window_size.width
322 (r.x < 0 || r.y + r.height > orig_window_size.height))
324 (tilted && (r.x - r.height < 0 ||
325 r.y + r.width + r.height > orig_window_size.height)))
327 sprintf( errorstr, "rectangle #%d of the classifier #%d of "
328 "the stage classifier #%d is not inside "
329 "the reference (original) cascade window", k, j, i );
330 CV_Error( CV_StsNullPtr, errorstr );
338 // this is an upper boundary for the whole hidden cascade size
339 datasize = sizeof(GpuHidHaarClassifierCascade) +
340 sizeof(GpuHidHaarStageClassifier) * cascade->count +
341 sizeof(GpuHidHaarClassifier) * total_classifiers +
342 sizeof(GpuHidHaarTreeNode) * total_nodes;
344 *totalclassifier = total_classifiers;
346 out = (GpuHidHaarClassifierCascade *)cvAlloc( datasize );
347 memset( out, 0, sizeof(*out) );
350 out->count = cascade->count;
351 stage_classifier_ptr = (GpuHidHaarStageClassifier *)(out + 1);
352 haar_classifier_ptr = (GpuHidHaarClassifier *)(stage_classifier_ptr + cascade->count);
353 haar_node_ptr = (GpuHidHaarTreeNode *)(haar_classifier_ptr + total_classifiers);
355 out->is_stump_based = 1;
356 out->has_tilted_features = has_tilted_features;
359 /* initialize internal representation */
360 for( i = 0; i < cascade->count; i++ )
362 CvHaarStageClassifier *stage_classifier = cascade->stage_classifier + i;
363 GpuHidHaarStageClassifier *hid_stage_classifier = stage_classifier_ptr + i;
365 hid_stage_classifier->count = stage_classifier->count;
366 hid_stage_classifier->threshold = stage_classifier->threshold - icv_stage_threshold_bias;
367 hid_stage_classifier->classifier = haar_classifier_ptr;
368 hid_stage_classifier->two_rects = 1;
369 haar_classifier_ptr += stage_classifier->count;
371 for( j = 0; j < stage_classifier->count; j++ )
373 CvHaarClassifier *classifier = stage_classifier->classifier + j;
374 GpuHidHaarClassifier *hid_classifier = hid_stage_classifier->classifier + j;
375 int node_count = classifier->count;
377 float *alpha_ptr = &haar_node_ptr->alpha[0];
379 hid_classifier->count = node_count;
380 hid_classifier->node = haar_node_ptr;
381 hid_classifier->alpha = alpha_ptr;
383 for( l = 0; l < node_count; l++ )
385 GpuHidHaarTreeNode *node = hid_classifier->node + l;
386 CvHaarFeature *feature = classifier->haar_feature + l;
388 memset( node, -1, sizeof(*node) );
389 node->threshold = classifier->threshold[l];
390 node->left = classifier->left[l];
391 node->right = classifier->right[l];
393 if( fabs(feature->rect[2].weight) < DBL_EPSILON ||
394 feature->rect[2].r.width == 0 ||
395 feature->rect[2].r.height == 0 )
404 hid_stage_classifier->two_rects = 0;
406 memcpy( node->alpha, classifier->alpha, (node_count + 1)*sizeof(alpha_ptr[0]));
407 haar_node_ptr = haar_node_ptr + 1;
409 out->is_stump_based &= node_count == 1;
413 cascade->hid_cascade = (CvHidHaarClassifierCascade *)out;
414 assert( (char *)haar_node_ptr - (char *)out <= datasize );
420 #define sum_elem_ptr(sum,row,col) \
421 ((sumtype*)CV_MAT_ELEM_PTR_FAST((sum),(row),(col),sizeof(sumtype)))
423 #define sqsum_elem_ptr(sqsum,row,col) \
424 ((sqsumtype*)CV_MAT_ELEM_PTR_FAST((sqsum),(row),(col),sizeof(sqsumtype)))
426 #define calc_sum(rect,offset) \
427 ((rect).p0[offset] - (rect).p1[offset] - (rect).p2[offset] + (rect).p3[offset])
430 static void gpuSetImagesForHaarClassifierCascade( CvHaarClassifierCascade *_cascade,
434 GpuHidHaarClassifierCascade *cascade;
435 int coi0 = 0, coi1 = 0;
441 GpuHidHaarStageClassifier *stage_classifier;
443 if( !CV_IS_HAAR_CLASSIFIER(_cascade) )
444 CV_Error( !_cascade ? CV_StsNullPtr : CV_StsBadArg, "Invalid classifier pointer" );
447 CV_Error( CV_StsOutOfRange, "Scale must be positive" );
450 CV_Error( CV_BadCOI, "COI is not supported" );
452 if( !_cascade->hid_cascade )
453 gpuCreateHidHaarClassifierCascade(_cascade, &datasize, &total);
455 cascade = (GpuHidHaarClassifierCascade *) _cascade->hid_cascade;
456 stage_classifier = (GpuHidHaarStageClassifier *) (cascade + 1);
458 _cascade->scale = scale;
459 _cascade->real_window_size.width = cvRound( _cascade->orig_window_size.width * scale );
460 _cascade->real_window_size.height = cvRound( _cascade->orig_window_size.height * scale );
462 equRect.x = equRect.y = cvRound(scale);
463 equRect.width = cvRound((_cascade->orig_window_size.width - 2) * scale);
464 equRect.height = cvRound((_cascade->orig_window_size.height - 2) * scale);
465 weight_scale = 1. / (equRect.width * equRect.height);
466 cascade->inv_window_area = weight_scale;
468 cascade->pq0 = equRect.x;
469 cascade->pq1 = equRect.y;
470 cascade->pq2 = equRect.x + equRect.width;
471 cascade->pq3 = equRect.y + equRect.height;
473 cascade->p0 = equRect.x;
474 cascade->p1 = equRect.y;
475 cascade->p2 = equRect.x + equRect.width;
476 cascade->p3 = equRect.y + equRect.height;
479 /* init pointers in haar features according to real window size and
480 given image pointers */
481 for( i = 0; i < _cascade->count; i++ )
484 for( j = 0; j < stage_classifier[i].count; j++ )
486 for( l = 0; l < stage_classifier[i].classifier[j].count; l++ )
488 CvHaarFeature *feature =
489 &_cascade->stage_classifier[i].classifier[j].haar_feature[l];
490 GpuHidHaarTreeNode *hidnode = &stage_classifier[i].classifier[j].node[l];
491 double sum0 = 0, area0 = 0;
494 int base_w = -1, base_h = -1;
495 int new_base_w = 0, new_base_h = 0;
497 int flagx = 0, flagy = 0;
502 for( k = 0; k < CV_HAAR_FEATURE_MAX; k++ )
504 if(!hidnode->p[k][0])
506 r[k] = feature->rect[k].r;
507 base_w = (int)CV_IMIN( (unsigned)base_w, (unsigned)(r[k].width - 1) );
508 base_w = (int)CV_IMIN( (unsigned)base_w, (unsigned)(r[k].x - r[0].x - 1) );
509 base_h = (int)CV_IMIN( (unsigned)base_h, (unsigned)(r[k].height - 1) );
510 base_h = (int)CV_IMIN( (unsigned)base_h, (unsigned)(r[k].y - r[0].y - 1) );
518 kx = r[0].width / base_w;
521 ky = r[0].height / base_h;
526 new_base_w = cvRound( r[0].width * scale ) / kx;
527 x0 = cvRound( r[0].x * scale );
533 new_base_h = cvRound( r[0].height * scale ) / ky;
534 y0 = cvRound( r[0].y * scale );
537 for( k = 0; k < nr; k++ )
540 double correction_ratio;
544 tr.x = (r[k].x - r[0].x) * new_base_w / base_w + x0;
545 tr.width = r[k].width * new_base_w / base_w;
549 tr.x = cvRound( r[k].x * scale );
550 tr.width = cvRound( r[k].width * scale );
555 tr.y = (r[k].y - r[0].y) * new_base_h / base_h + y0;
556 tr.height = r[k].height * new_base_h / base_h;
560 tr.y = cvRound( r[k].y * scale );
561 tr.height = cvRound( r[k].height * scale );
564 #if CV_ADJUST_WEIGHTS
567 const float orig_feature_size = (float)(feature->rect[k].r.width) * feature->rect[k].r.height;
568 const float orig_norm_size = (float)(_cascade->orig_window_size.width) * (_cascade->orig_window_size.height);
569 const float feature_size = float(tr.width * tr.height);
570 //const float normSize = float(equRect.width*equRect.height);
571 float target_ratio = orig_feature_size / orig_norm_size;
572 //float isRatio = featureSize / normSize;
573 //correctionRatio = targetRatio / isRatio / normSize;
574 correction_ratio = target_ratio / feature_size;
578 correction_ratio = weight_scale * (!feature->tilted ? 1 : 0.5);
581 if( !feature->tilted )
583 hidnode->p[k][0] = tr.x;
584 hidnode->p[k][1] = tr.y;
585 hidnode->p[k][2] = tr.x + tr.width;
586 hidnode->p[k][3] = tr.y + tr.height;
590 hidnode->p[k][2] = (tr.y + tr.width) * step + tr.x + tr.width;
591 hidnode->p[k][3] = (tr.y + tr.width + tr.height) * step + tr.x + tr.width - tr.height;
592 hidnode->p[k][0] = tr.y * step + tr.x;
593 hidnode->p[k][1] = (tr.y + tr.height) * step + tr.x - tr.height;
595 hidnode->weight[k] = (float)(feature->rect[k].weight * correction_ratio);
597 area0 = tr.width * tr.height;
599 sum0 += hidnode->weight[k] * tr.width * tr.height;
601 hidnode->weight[0] = (float)(-sum0 / area0);
607 static void gpuSetHaarClassifierCascade( CvHaarClassifierCascade *_cascade)
609 GpuHidHaarClassifierCascade *cascade;
615 GpuHidHaarStageClassifier *stage_classifier;
617 if( !CV_IS_HAAR_CLASSIFIER(_cascade) )
618 CV_Error( !_cascade ? CV_StsNullPtr : CV_StsBadArg, "Invalid classifier pointer" );
620 if( !_cascade->hid_cascade )
621 gpuCreateHidHaarClassifierCascade(_cascade, &datasize, &total);
623 cascade = (GpuHidHaarClassifierCascade *) _cascade->hid_cascade;
624 stage_classifier = (GpuHidHaarStageClassifier *) cascade + 1;
626 _cascade->scale = 1.0;
627 _cascade->real_window_size.width = _cascade->orig_window_size.width ;
628 _cascade->real_window_size.height = _cascade->orig_window_size.height;
630 equRect.x = equRect.y = 1;
631 equRect.width = _cascade->orig_window_size.width - 2;
632 equRect.height = _cascade->orig_window_size.height - 2;
634 cascade->inv_window_area = weight_scale;
636 cascade->p0 = equRect.x;
637 cascade->p1 = equRect.y;
638 cascade->p2 = equRect.height;
639 cascade->p3 = equRect.width ;
640 for( i = 0; i < _cascade->count; i++ )
643 for( j = 0; j < stage_classifier[i].count; j++ )
645 for( l = 0; l < stage_classifier[i].classifier[j].count; l++ )
647 CvHaarFeature *feature =
648 &_cascade->stage_classifier[i].classifier[j].haar_feature[l];
649 GpuHidHaarTreeNode *hidnode = &stage_classifier[i].classifier[j].node[l];
656 for( k = 0; k < CV_HAAR_FEATURE_MAX; k++ )
658 if(!hidnode->p[k][0])
660 r[k] = feature->rect[k].r;
664 for( k = 0; k < nr; k++ )
667 double correction_ratio;
669 tr.width = r[k].width;
671 tr.height = r[k].height;
672 correction_ratio = weight_scale * (!feature->tilted ? 1 : 0.5);
673 hidnode->p[k][0] = tr.x;
674 hidnode->p[k][1] = tr.y;
675 hidnode->p[k][2] = tr.width;
676 hidnode->p[k][3] = tr.height;
677 hidnode->weight[k] = (float)(feature->rect[k].weight * correction_ratio);
684 CvSeq *cv::ocl::OclCascadeClassifier::oclHaarDetectObjects( oclMat &gimg, CvMemStorage *storage, double scaleFactor,
685 int minNeighbors, int flags, CvSize minSize, CvSize maxSize)
687 CvHaarClassifierCascade *cascade = oldCascade;
689 const double GROUP_EPS = 0.2;
690 CvSeq *result_seq = 0;
692 cv::ConcurrentRectVector allCandidates;
693 std::vector<cv::Rect> rectList;
694 std::vector<int> rweights;
697 int totalclassifier=0;
699 GpuHidHaarClassifierCascade *gcascade;
700 GpuHidHaarStageClassifier *stage;
701 GpuHidHaarClassifier *classifier;
702 GpuHidHaarTreeNode *node;
707 bool findBiggestObject = (flags & CV_HAAR_FIND_BIGGEST_OBJECT) != 0;
709 if( maxSize.height == 0 || maxSize.width == 0 )
711 maxSize.height = gimg.rows;
712 maxSize.width = gimg.cols;
715 if( !CV_IS_HAAR_CLASSIFIER(cascade) )
716 CV_Error( !cascade ? CV_StsNullPtr : CV_StsBadArg, "Invalid classifier cascade" );
719 CV_Error( CV_StsNullPtr, "Null storage pointer" );
721 if( CV_MAT_DEPTH(gimg.type()) != CV_8U )
722 CV_Error( CV_StsUnsupportedFormat, "Only 8-bit images are supported" );
724 if( scaleFactor <= 1 )
725 CV_Error( CV_StsOutOfRange, "scale factor must be > 1" );
727 if( findBiggestObject )
728 flags &= ~CV_HAAR_SCALE_IMAGE;
730 if( !cascade->hid_cascade )
731 gpuCreateHidHaarClassifierCascade(cascade, &datasize, &totalclassifier);
733 result_seq = cvCreateSeq( 0, sizeof(CvSeq), sizeof(CvAvgComp), storage );
735 if( CV_MAT_CN(gimg.type()) > 1 )
738 cvtColor( gimg, gtemp, CV_BGR2GRAY );
742 if( findBiggestObject )
743 flags &= ~(CV_HAAR_SCALE_IMAGE | CV_HAAR_DO_CANNY_PRUNING);
745 if( gimg.cols < minSize.width || gimg.rows < minSize.height )
746 CV_Error(CV_StsError, "Image too small");
748 cl_command_queue qu = reinterpret_cast<cl_command_queue>(Context::getContext()->oclCommandQueue());
749 if( (flags & CV_HAAR_SCALE_IMAGE) )
751 CvSize winSize0 = cascade->orig_window_size;
755 vector<CvSize> sizev;
756 vector<float> scalev;
757 for(factor = 1.f;; factor *= scaleFactor)
759 CvSize winSize = { cvRound(winSize0.width * factor), cvRound(winSize0.height * factor) };
760 sz.width = cvRound( gimg.cols / factor ) + 1;
761 sz.height = cvRound( gimg.rows / factor ) + 1;
762 CvSize sz1 = { sz.width - winSize0.width - 1, sz.height - winSize0.height - 1 };
764 if( sz1.width <= 0 || sz1.height <= 0 )
766 if( winSize.width > maxSize.width || winSize.height > maxSize.height )
768 if( winSize.width < minSize.width || winSize.height < minSize.height )
771 totalheight += sz.height;
773 scalev.push_back(factor);
776 oclMat gimg1(gimg.rows, gimg.cols, CV_8UC1);
777 oclMat gsum(totalheight + 4, gimg.cols + 1, CV_32SC1);
778 oclMat gsqsum(totalheight + 4, gimg.cols + 1, CV_32FC1);
782 cl_mem candidatebuffer;
783 cl_mem scaleinfobuffer;
785 cv::Mat imgroi, imgroisq;
786 cv::ocl::oclMat resizeroi, gimgroi, gimgroisq;
789 size_t blocksize = 8;
790 size_t localThreads[3] = { blocksize, blocksize , 1 };
791 size_t globalThreads[3] = { grp_per_CU *(gsum.clCxt->computeUnits()) *localThreads[0],
794 int outputsz = 256 * globalThreads[0] / localThreads[0];
795 int loopcount = sizev.size();
796 detect_piramid_info *scaleinfo = (detect_piramid_info *)malloc(sizeof(detect_piramid_info) * loopcount);
798 for( int i = 0; i < loopcount; i++ )
802 roi = Rect(0, indexy, sz.width, sz.height);
803 roi2 = Rect(0, 0, sz.width - 1, sz.height - 1);
804 resizeroi = gimg1(roi2);
806 gimgroisq = gsqsum(roi);
807 int width = gimgroi.cols - 1 - cascade->orig_window_size.width;
808 int height = gimgroi.rows - 1 - cascade->orig_window_size.height;
809 scaleinfo[i].width_height = (width << 16) | height;
812 int grpnumperline = (width + localThreads[0] - 1) / localThreads[0];
813 int totalgrp = ((height + localThreads[1] - 1) / localThreads[1]) * grpnumperline;
815 scaleinfo[i].grpnumperline_totalgrp = (grpnumperline << 16) | totalgrp;
816 scaleinfo[i].imgoff = gimgroi.offset >> 2;
817 scaleinfo[i].factor = factor;
818 cv::ocl::resize(gimg, resizeroi, Size(sz.width - 1, sz.height - 1), 0, 0, INTER_LINEAR);
819 cv::ocl::integral(resizeroi, gimgroi, gimgroisq);
823 gcascade = (GpuHidHaarClassifierCascade *)cascade->hid_cascade;
824 stage = (GpuHidHaarStageClassifier *)(gcascade + 1);
825 classifier = (GpuHidHaarClassifier *)(stage + gcascade->count);
826 node = (GpuHidHaarTreeNode *)(classifier->node);
828 int nodenum = (datasize - sizeof(GpuHidHaarClassifierCascade) -
829 sizeof(GpuHidHaarStageClassifier) * gcascade->count - sizeof(GpuHidHaarClassifier) * totalclassifier) / sizeof(GpuHidHaarTreeNode);
831 candidate = (int *)malloc(4 * sizeof(int) * outputsz);
833 gpuSetImagesForHaarClassifierCascade( cascade, 1., gsum.step / 4 );
835 stagebuffer = openCLCreateBuffer(gsum.clCxt, CL_MEM_READ_ONLY, sizeof(GpuHidHaarStageClassifier) * gcascade->count);
836 openCLSafeCall(clEnqueueWriteBuffer(qu, stagebuffer, 1, 0, sizeof(GpuHidHaarStageClassifier)*gcascade->count, stage, 0, NULL, NULL));
838 nodebuffer = openCLCreateBuffer(gsum.clCxt, CL_MEM_READ_ONLY, nodenum * sizeof(GpuHidHaarTreeNode));
840 openCLSafeCall(clEnqueueWriteBuffer(qu, nodebuffer, 1, 0, nodenum * sizeof(GpuHidHaarTreeNode),
841 node, 0, NULL, NULL));
842 candidatebuffer = openCLCreateBuffer(gsum.clCxt, CL_MEM_WRITE_ONLY, 4 * sizeof(int) * outputsz);
844 scaleinfobuffer = openCLCreateBuffer(gsum.clCxt, CL_MEM_READ_ONLY, sizeof(detect_piramid_info) * loopcount);
845 openCLSafeCall(clEnqueueWriteBuffer(qu, scaleinfobuffer, 1, 0, sizeof(detect_piramid_info)*loopcount, scaleinfo, 0, NULL, NULL));
848 int endstage = gcascade->count;
850 int pixelstep = gsum.step / 4;
852 int splitnode = stage[0].count + stage[1].count + stage[2].count;
854 p.s[0] = gcascade->p0;
855 p.s[1] = gcascade->p1;
856 p.s[2] = gcascade->p2;
857 p.s[3] = gcascade->p3;
858 pq.s[0] = gcascade->pq0;
859 pq.s[1] = gcascade->pq1;
860 pq.s[2] = gcascade->pq2;
861 pq.s[3] = gcascade->pq3;
862 float correction = gcascade->inv_window_area;
864 vector<pair<size_t, const void *> > args;
865 args.push_back ( make_pair(sizeof(cl_mem) , (void *)&stagebuffer ));
866 args.push_back ( make_pair(sizeof(cl_mem) , (void *)&scaleinfobuffer ));
867 args.push_back ( make_pair(sizeof(cl_mem) , (void *)&nodebuffer ));
868 args.push_back ( make_pair(sizeof(cl_mem) , (void *)&gsum.data ));
869 args.push_back ( make_pair(sizeof(cl_mem) , (void *)&gsqsum.data ));
870 args.push_back ( make_pair(sizeof(cl_mem) , (void *)&candidatebuffer ));
871 args.push_back ( make_pair(sizeof(cl_int) , (void *)&pixelstep ));
872 args.push_back ( make_pair(sizeof(cl_int) , (void *)&loopcount ));
873 args.push_back ( make_pair(sizeof(cl_int) , (void *)&startstage ));
874 args.push_back ( make_pair(sizeof(cl_int) , (void *)&splitstage ));
875 args.push_back ( make_pair(sizeof(cl_int) , (void *)&endstage ));
876 args.push_back ( make_pair(sizeof(cl_int) , (void *)&startnode ));
877 args.push_back ( make_pair(sizeof(cl_int) , (void *)&splitnode ));
878 args.push_back ( make_pair(sizeof(cl_int4) , (void *)&p ));
879 args.push_back ( make_pair(sizeof(cl_int4) , (void *)&pq ));
880 args.push_back ( make_pair(sizeof(cl_float) , (void *)&correction ));
882 const char * build_options = gcascade->is_stump_based ? "-D STUMP_BASED=1" : "-D STUMP_BASED=0";
884 openCLExecuteKernel(gsum.clCxt, &haarobjectdetect, "gpuRunHaarClassifierCascade", globalThreads, localThreads, args, -1, -1, build_options);
886 openCLReadBuffer( gsum.clCxt, candidatebuffer, candidate, 4 * sizeof(int)*outputsz );
888 for(int i = 0; i < outputsz; i++)
889 if(candidate[4 * i + 2] != 0)
890 allCandidates.push_back(Rect(candidate[4 * i], candidate[4 * i + 1],
891 candidate[4 * i + 2], candidate[4 * i + 3]));
895 openCLSafeCall(clReleaseMemObject(stagebuffer));
896 openCLSafeCall(clReleaseMemObject(scaleinfobuffer));
897 openCLSafeCall(clReleaseMemObject(nodebuffer));
898 openCLSafeCall(clReleaseMemObject(candidatebuffer));
903 CvSize winsize0 = cascade->orig_window_size;
907 cv::ocl::integral(gimg, gsum, gsqsum);
909 vector<CvSize> sizev;
910 vector<float> scalev;
911 gpuSetHaarClassifierCascade(cascade);
912 gcascade = (GpuHidHaarClassifierCascade *)cascade->hid_cascade;
913 stage = (GpuHidHaarStageClassifier *)(gcascade + 1);
914 classifier = (GpuHidHaarClassifier *)(stage + gcascade->count);
915 node = (GpuHidHaarTreeNode *)(classifier->node);
918 cl_mem candidatebuffer;
919 cl_mem scaleinfobuffer;
921 cl_mem correctionbuffer;
922 for( n_factors = 0, factor = 1;
923 cvRound(factor * winsize0.width) < gimg.cols - 10 &&
924 cvRound(factor * winsize0.height) < gimg.rows - 10;
925 n_factors++, factor *= scaleFactor )
927 CvSize winSize = { cvRound( winsize0.width * factor ),
928 cvRound( winsize0.height * factor )
930 if( winSize.width < minSize.width || winSize.height < minSize.height )
934 sizev.push_back(winSize);
935 scalev.push_back(factor);
937 int loopcount = scalev.size();
942 sizev.push_back(minSize);
943 scalev.push_back( min(cvRound(minSize.width / winsize0.width), cvRound(minSize.height / winsize0.height)) );
946 detect_piramid_info *scaleinfo = (detect_piramid_info *)malloc(sizeof(detect_piramid_info) * loopcount);
947 cl_int4 *p = (cl_int4 *)malloc(sizeof(cl_int4) * loopcount);
948 float *correction = (float *)malloc(sizeof(float) * loopcount);
950 size_t blocksize = 8;
951 size_t localThreads[3] = { blocksize, blocksize , 1 };
952 size_t globalThreads[3] = { grp_per_CU *gsum.clCxt->computeUnits() *localThreads[0],
953 localThreads[1], 1 };
954 int outputsz = 256 * globalThreads[0] / localThreads[0];
955 int nodenum = (datasize - sizeof(GpuHidHaarClassifierCascade) -
956 sizeof(GpuHidHaarStageClassifier) * gcascade->count - sizeof(GpuHidHaarClassifier) * totalclassifier) / sizeof(GpuHidHaarTreeNode);
957 nodebuffer = openCLCreateBuffer(gsum.clCxt, CL_MEM_READ_ONLY,
958 nodenum * sizeof(GpuHidHaarTreeNode));
959 openCLSafeCall(clEnqueueWriteBuffer(qu, nodebuffer, 1, 0,
960 nodenum * sizeof(GpuHidHaarTreeNode),
961 node, 0, NULL, NULL));
962 cl_mem newnodebuffer = openCLCreateBuffer(gsum.clCxt, CL_MEM_READ_WRITE,
963 loopcount * nodenum * sizeof(GpuHidHaarTreeNode));
965 int endstage = gcascade->count;
966 for(int i = 0; i < loopcount; i++)
970 int ystep = cvRound(std::max(2., factor));
971 int equRect_x = (int)(factor * gcascade->p0 + 0.5);
972 int equRect_y = (int)(factor * gcascade->p1 + 0.5);
973 int equRect_w = (int)(factor * gcascade->p3 + 0.5);
974 int equRect_h = (int)(factor * gcascade->p2 + 0.5);
975 p[i].s[0] = equRect_x;
976 p[i].s[1] = equRect_y;
977 p[i].s[2] = equRect_x + equRect_w;
978 p[i].s[3] = equRect_y + equRect_h;
979 correction[i] = 1. / (equRect_w * equRect_h);
980 int width = (gsum.cols - 1 - sz.width + ystep - 1) / ystep;
981 int height = (gsum.rows - 1 - sz.height + ystep - 1) / ystep;
982 int grpnumperline = (width + localThreads[0] - 1) / localThreads[0];
983 int totalgrp = ((height + localThreads[1] - 1) / localThreads[1]) * grpnumperline;
985 scaleinfo[i].width_height = (width << 16) | height;
986 scaleinfo[i].grpnumperline_totalgrp = (grpnumperline << 16) | totalgrp;
987 scaleinfo[i].imgoff = 0;
988 scaleinfo[i].factor = factor;
989 int startnodenum = nodenum * i;
990 float factor2 = (float)factor;
992 vector<pair<size_t, const void *> > args1;
993 args1.push_back ( make_pair(sizeof(cl_mem) , (void *)&nodebuffer ));
994 args1.push_back ( make_pair(sizeof(cl_mem) , (void *)&newnodebuffer ));
995 args1.push_back ( make_pair(sizeof(cl_float) , (void *)&factor2 ));
996 args1.push_back ( make_pair(sizeof(cl_float) , (void *)&correction[i] ));
997 args1.push_back ( make_pair(sizeof(cl_int) , (void *)&startnodenum ));
999 size_t globalThreads2[3] = {nodenum, 1, 1};
1000 openCLExecuteKernel(gsum.clCxt, &haarobjectdetect_scaled2, "gpuscaleclassifier", globalThreads2, NULL/*localThreads2*/, args1, -1, -1);
1003 int step = gsum.step / 4;
1006 stagebuffer = openCLCreateBuffer(gsum.clCxt, CL_MEM_READ_ONLY, sizeof(GpuHidHaarStageClassifier) * gcascade->count);
1007 openCLSafeCall(clEnqueueWriteBuffer(qu, stagebuffer, 1, 0, sizeof(GpuHidHaarStageClassifier)*gcascade->count, stage, 0, NULL, NULL));
1008 candidatebuffer = openCLCreateBuffer(gsum.clCxt, CL_MEM_WRITE_ONLY | CL_MEM_ALLOC_HOST_PTR, 4 * sizeof(int) * outputsz);
1009 scaleinfobuffer = openCLCreateBuffer(gsum.clCxt, CL_MEM_READ_ONLY, sizeof(detect_piramid_info) * loopcount);
1010 openCLSafeCall(clEnqueueWriteBuffer(qu, scaleinfobuffer, 1, 0, sizeof(detect_piramid_info)*loopcount, scaleinfo, 0, NULL, NULL));
1011 pbuffer = openCLCreateBuffer(gsum.clCxt, CL_MEM_READ_ONLY, sizeof(cl_int4) * loopcount);
1012 openCLSafeCall(clEnqueueWriteBuffer(qu, pbuffer, 1, 0, sizeof(cl_int4)*loopcount, p, 0, NULL, NULL));
1013 correctionbuffer = openCLCreateBuffer(gsum.clCxt, CL_MEM_READ_ONLY, sizeof(cl_float) * loopcount);
1014 openCLSafeCall(clEnqueueWriteBuffer(qu, correctionbuffer, 1, 0, sizeof(cl_float)*loopcount, correction, 0, NULL, NULL));
1016 vector<pair<size_t, const void *> > args;
1017 args.push_back ( make_pair(sizeof(cl_mem) , (void *)&stagebuffer ));
1018 args.push_back ( make_pair(sizeof(cl_mem) , (void *)&scaleinfobuffer ));
1019 args.push_back ( make_pair(sizeof(cl_mem) , (void *)&newnodebuffer ));
1020 args.push_back ( make_pair(sizeof(cl_mem) , (void *)&gsum.data ));
1021 args.push_back ( make_pair(sizeof(cl_mem) , (void *)&gsqsum.data ));
1022 args.push_back ( make_pair(sizeof(cl_mem) , (void *)&candidatebuffer ));
1023 args.push_back ( make_pair(sizeof(cl_int) , (void *)&gsum.rows ));
1024 args.push_back ( make_pair(sizeof(cl_int) , (void *)&gsum.cols ));
1025 args.push_back ( make_pair(sizeof(cl_int) , (void *)&step ));
1026 args.push_back ( make_pair(sizeof(cl_int) , (void *)&loopcount ));
1027 args.push_back ( make_pair(sizeof(cl_int) , (void *)&startstage ));
1028 args.push_back ( make_pair(sizeof(cl_int) , (void *)&splitstage ));
1029 args.push_back ( make_pair(sizeof(cl_int) , (void *)&endstage ));
1030 args.push_back ( make_pair(sizeof(cl_int) , (void *)&startnode ));
1031 args.push_back ( make_pair(sizeof(cl_mem) , (void *)&pbuffer ));
1032 args.push_back ( make_pair(sizeof(cl_mem) , (void *)&correctionbuffer ));
1033 args.push_back ( make_pair(sizeof(cl_int) , (void *)&nodenum ));
1034 const char * build_options = gcascade->is_stump_based ? "-D STUMP_BASED=1" : "-D STUMP_BASED=0";
1035 openCLExecuteKernel(gsum.clCxt, &haarobjectdetect_scaled2, "gpuRunHaarClassifierCascade_scaled2", globalThreads, localThreads, args, -1, -1, build_options);
1037 candidate = (int *)clEnqueueMapBuffer(qu, candidatebuffer, 1, CL_MAP_READ, 0, 4 * sizeof(int) * outputsz, 0, 0, 0, &status);
1039 for(int i = 0; i < outputsz; i++)
1041 if(candidate[4 * i + 2] != 0)
1042 allCandidates.push_back(Rect(candidate[4 * i], candidate[4 * i + 1], candidate[4 * i + 2], candidate[4 * i + 3]));
1048 clEnqueueUnmapMemObject(qu, candidatebuffer, candidate, 0, 0, 0);
1049 openCLSafeCall(clReleaseMemObject(stagebuffer));
1050 openCLSafeCall(clReleaseMemObject(scaleinfobuffer));
1051 openCLSafeCall(clReleaseMemObject(nodebuffer));
1052 openCLSafeCall(clReleaseMemObject(newnodebuffer));
1053 openCLSafeCall(clReleaseMemObject(candidatebuffer));
1054 openCLSafeCall(clReleaseMemObject(pbuffer));
1055 openCLSafeCall(clReleaseMemObject(correctionbuffer));
1058 cvFree(&cascade->hid_cascade);
1059 rectList.resize(allCandidates.size());
1060 if(!allCandidates.empty())
1061 std::copy(allCandidates.begin(), allCandidates.end(), rectList.begin());
1063 if( minNeighbors != 0 || findBiggestObject )
1064 groupRectangles(rectList, rweights, std::max(minNeighbors, 1), GROUP_EPS);
1066 rweights.resize(rectList.size(), 0);
1068 if( findBiggestObject && rectList.size() )
1070 CvAvgComp result_comp = {{0, 0, 0, 0}, 0};
1072 for( size_t i = 0; i < rectList.size(); i++ )
1074 cv::Rect r = rectList[i];
1075 if( r.area() > cv::Rect(result_comp.rect).area() )
1077 result_comp.rect = r;
1078 result_comp.neighbors = rweights[i];
1081 cvSeqPush( result_seq, &result_comp );
1085 for( size_t i = 0; i < rectList.size(); i++ )
1088 c.rect = rectList[i];
1089 c.neighbors = rweights[i];
1090 cvSeqPush( result_seq, &c );
1101 cl_mem candidatebuffer;
1102 cl_mem scaleinfobuffer;
1104 cl_mem correctionbuffer;
1105 cl_mem newnodebuffer;
1110 Rect operator()(const CvAvgComp &e) const
1116 void cv::ocl::OclCascadeClassifierBuf::detectMultiScale(oclMat &gimg, CV_OUT std::vector<cv::Rect>& faces,
1117 double scaleFactor, int minNeighbors, int flags,
1118 Size minSize, Size maxSize)
1121 int grp_per_CU = 12;
1122 size_t localThreads[3] = { blocksize, blocksize, 1 };
1123 size_t globalThreads[3] = { grp_per_CU * cv::ocl::Context::getContext()->computeUnits() *localThreads[0],
1126 int outputsz = 256 * globalThreads[0] / localThreads[0];
1128 Init(gimg.rows, gimg.cols, scaleFactor, flags, outputsz, localThreads, minSize, maxSize);
1130 const double GROUP_EPS = 0.2;
1132 cv::ConcurrentRectVector allCandidates;
1133 std::vector<cv::Rect> rectList;
1134 std::vector<int> rweights;
1136 CvHaarClassifierCascade *cascade = oldCascade;
1137 GpuHidHaarClassifierCascade *gcascade;
1138 GpuHidHaarStageClassifier *stage;
1140 if( CV_MAT_DEPTH(gimg.type()) != CV_8U )
1141 CV_Error( CV_StsUnsupportedFormat, "Only 8-bit images are supported" );
1143 if( CV_MAT_CN(gimg.type()) > 1 )
1146 cvtColor( gimg, gtemp, CV_BGR2GRAY );
1151 cl_command_queue qu = reinterpret_cast<cl_command_queue>(Context::getContext()->oclCommandQueue());
1152 if( (flags & CV_HAAR_SCALE_IMAGE) )
1158 cv::Mat imgroi, imgroisq;
1159 cv::ocl::oclMat resizeroi, gimgroi, gimgroisq;
1161 for( int i = 0; i < m_loopcount; i++ )
1164 roi = Rect(0, indexy, sz.width, sz.height);
1165 roi2 = Rect(0, 0, sz.width - 1, sz.height - 1);
1166 resizeroi = gimg1(roi2);
1167 gimgroi = gsum(roi);
1168 gimgroisq = gsqsum(roi);
1170 cv::ocl::resize(gimg, resizeroi, Size(sz.width - 1, sz.height - 1), 0, 0, INTER_LINEAR);
1171 cv::ocl::integral(resizeroi, gimgroi, gimgroisq);
1172 indexy += sz.height;
1175 gcascade = (GpuHidHaarClassifierCascade *)(cascade->hid_cascade);
1176 stage = (GpuHidHaarStageClassifier *)(gcascade + 1);
1179 int endstage = gcascade->count;
1181 int pixelstep = gsum.step / 4;
1183 int splitnode = stage[0].count + stage[1].count + stage[2].count;
1185 p.s[0] = gcascade->p0;
1186 p.s[1] = gcascade->p1;
1187 p.s[2] = gcascade->p2;
1188 p.s[3] = gcascade->p3;
1189 pq.s[0] = gcascade->pq0;
1190 pq.s[1] = gcascade->pq1;
1191 pq.s[2] = gcascade->pq2;
1192 pq.s[3] = gcascade->pq3;
1193 float correction = gcascade->inv_window_area;
1195 vector<pair<size_t, const void *> > args;
1196 args.push_back ( make_pair(sizeof(cl_mem) , (void *)&((OclBuffers *)buffers)->stagebuffer ));
1197 args.push_back ( make_pair(sizeof(cl_mem) , (void *)&((OclBuffers *)buffers)->scaleinfobuffer ));
1198 args.push_back ( make_pair(sizeof(cl_mem) , (void *)&((OclBuffers *)buffers)->nodebuffer ));
1199 args.push_back ( make_pair(sizeof(cl_mem) , (void *)&gsum.data ));
1200 args.push_back ( make_pair(sizeof(cl_mem) , (void *)&gsqsum.data ));
1201 args.push_back ( make_pair(sizeof(cl_mem) , (void *)&((OclBuffers *)buffers)->candidatebuffer ));
1202 args.push_back ( make_pair(sizeof(cl_int) , (void *)&pixelstep ));
1203 args.push_back ( make_pair(sizeof(cl_int) , (void *)&m_loopcount ));
1204 args.push_back ( make_pair(sizeof(cl_int) , (void *)&startstage ));
1205 args.push_back ( make_pair(sizeof(cl_int) , (void *)&splitstage ));
1206 args.push_back ( make_pair(sizeof(cl_int) , (void *)&endstage ));
1207 args.push_back ( make_pair(sizeof(cl_int) , (void *)&startnode ));
1208 args.push_back ( make_pair(sizeof(cl_int) , (void *)&splitnode ));
1209 args.push_back ( make_pair(sizeof(cl_int4) , (void *)&p ));
1210 args.push_back ( make_pair(sizeof(cl_int4) , (void *)&pq ));
1211 args.push_back ( make_pair(sizeof(cl_float) , (void *)&correction ));
1213 const char * build_options = gcascade->is_stump_based ? "-D STUMP_BASED=1" : "-D STUMP_BASED=0";
1215 openCLExecuteKernel(gsum.clCxt, &haarobjectdetect, "gpuRunHaarClassifierCascade", globalThreads, localThreads, args, -1, -1, build_options);
1217 candidate = (int *)malloc(4 * sizeof(int) * outputsz);
1218 memset(candidate, 0, 4 * sizeof(int) * outputsz);
1220 openCLReadBuffer( gsum.clCxt, ((OclBuffers *)buffers)->candidatebuffer, candidate, 4 * sizeof(int)*outputsz );
1222 for(int i = 0; i < outputsz; i++)
1224 if(candidate[4 * i + 2] != 0)
1226 allCandidates.push_back(Rect(candidate[4 * i], candidate[4 * i + 1],
1227 candidate[4 * i + 2], candidate[4 * i + 3]));
1230 free((void *)candidate);
1235 cv::ocl::integral(gimg, gsum, gsqsum);
1237 gcascade = (GpuHidHaarClassifierCascade *)cascade->hid_cascade;
1239 int step = gsum.step / 4;
1244 int endstage = gcascade->count;
1246 vector<pair<size_t, const void *> > args;
1247 args.push_back ( make_pair(sizeof(cl_mem) , (void *)&((OclBuffers *)buffers)->stagebuffer ));
1248 args.push_back ( make_pair(sizeof(cl_mem) , (void *)&((OclBuffers *)buffers)->scaleinfobuffer ));
1249 args.push_back ( make_pair(sizeof(cl_mem) , (void *)&((OclBuffers *)buffers)->newnodebuffer ));
1250 args.push_back ( make_pair(sizeof(cl_mem) , (void *)&gsum.data ));
1251 args.push_back ( make_pair(sizeof(cl_mem) , (void *)&gsqsum.data ));
1252 args.push_back ( make_pair(sizeof(cl_mem) , (void *)&((OclBuffers *)buffers)->candidatebuffer ));
1253 args.push_back ( make_pair(sizeof(cl_int) , (void *)&gsum.rows ));
1254 args.push_back ( make_pair(sizeof(cl_int) , (void *)&gsum.cols ));
1255 args.push_back ( make_pair(sizeof(cl_int) , (void *)&step ));
1256 args.push_back ( make_pair(sizeof(cl_int) , (void *)&m_loopcount ));
1257 args.push_back ( make_pair(sizeof(cl_int) , (void *)&startstage ));
1258 args.push_back ( make_pair(sizeof(cl_int) , (void *)&splitstage ));
1259 args.push_back ( make_pair(sizeof(cl_int) , (void *)&endstage ));
1260 args.push_back ( make_pair(sizeof(cl_int) , (void *)&startnode ));
1261 args.push_back ( make_pair(sizeof(cl_mem) , (void *)&((OclBuffers *)buffers)->pbuffer ));
1262 args.push_back ( make_pair(sizeof(cl_mem) , (void *)&((OclBuffers *)buffers)->correctionbuffer ));
1263 args.push_back ( make_pair(sizeof(cl_int) , (void *)&m_nodenum ));
1265 const char * build_options = gcascade->is_stump_based ? "-D STUMP_BASED=1" : "-D STUMP_BASED=0";
1266 openCLExecuteKernel(gsum.clCxt, &haarobjectdetect_scaled2, "gpuRunHaarClassifierCascade_scaled2", globalThreads, localThreads, args, -1, -1, build_options);
1268 candidate = (int *)clEnqueueMapBuffer(qu, ((OclBuffers *)buffers)->candidatebuffer, 1, CL_MAP_READ, 0, 4 * sizeof(int) * outputsz, 0, 0, 0, NULL);
1270 for(int i = 0; i < outputsz; i++)
1272 if(candidate[4 * i + 2] != 0)
1273 allCandidates.push_back(Rect(candidate[4 * i], candidate[4 * i + 1],
1274 candidate[4 * i + 2], candidate[4 * i + 3]));
1276 clEnqueueUnmapMemObject(qu, ((OclBuffers *)buffers)->candidatebuffer, candidate, 0, 0, 0);
1278 rectList.resize(allCandidates.size());
1279 if(!allCandidates.empty())
1280 std::copy(allCandidates.begin(), allCandidates.end(), rectList.begin());
1282 if( minNeighbors != 0 || findBiggestObject )
1283 groupRectangles(rectList, rweights, std::max(minNeighbors, 1), GROUP_EPS);
1285 rweights.resize(rectList.size(), 0);
1287 GenResult(faces, rectList, rweights);
1290 void cv::ocl::OclCascadeClassifierBuf::Init(const int rows, const int cols,
1291 double scaleFactor, int flags,
1292 const int outputsz, const size_t localThreads[],
1293 CvSize minSize, CvSize maxSize)
1297 return; // we only allow one time initialization
1299 CvHaarClassifierCascade *cascade = oldCascade;
1301 if( !CV_IS_HAAR_CLASSIFIER(cascade) )
1302 CV_Error( !cascade ? CV_StsNullPtr : CV_StsBadArg, "Invalid classifier cascade" );
1304 if( scaleFactor <= 1 )
1305 CV_Error( CV_StsOutOfRange, "scale factor must be > 1" );
1307 if( cols < minSize.width || rows < minSize.height )
1308 CV_Error(CV_StsError, "Image too small");
1311 int totalclassifier=0;
1313 if( !cascade->hid_cascade )
1315 gpuCreateHidHaarClassifierCascade(cascade, &datasize, &totalclassifier);
1318 if( maxSize.height == 0 || maxSize.width == 0 )
1320 maxSize.height = rows;
1321 maxSize.width = cols;
1324 findBiggestObject = (flags & CV_HAAR_FIND_BIGGEST_OBJECT) != 0;
1325 if( findBiggestObject )
1326 flags &= ~(CV_HAAR_SCALE_IMAGE | CV_HAAR_DO_CANNY_PRUNING);
1328 CreateBaseBufs(datasize, totalclassifier, flags, outputsz);
1329 CreateFactorRelatedBufs(rows, cols, flags, scaleFactor, localThreads, minSize, maxSize);
1331 m_scaleFactor = scaleFactor;
1335 m_minSize = minSize;
1336 m_maxSize = maxSize;
1339 GpuHidHaarClassifierCascade *gcascade;
1340 GpuHidHaarStageClassifier *stage;
1341 GpuHidHaarClassifier *classifier;
1342 GpuHidHaarTreeNode *node;
1343 cl_command_queue qu = reinterpret_cast<cl_command_queue>(Context::getContext()->oclCommandQueue());
1344 if( (flags & CV_HAAR_SCALE_IMAGE) )
1346 gcascade = (GpuHidHaarClassifierCascade *)(cascade->hid_cascade);
1347 stage = (GpuHidHaarStageClassifier *)(gcascade + 1);
1348 classifier = (GpuHidHaarClassifier *)(stage + gcascade->count);
1349 node = (GpuHidHaarTreeNode *)(classifier->node);
1351 gpuSetImagesForHaarClassifierCascade( cascade, 1., gsum.step / 4 );
1353 openCLSafeCall(clEnqueueWriteBuffer(qu, ((OclBuffers *)buffers)->stagebuffer, 1, 0,
1354 sizeof(GpuHidHaarStageClassifier) * gcascade->count,
1355 stage, 0, NULL, NULL));
1357 openCLSafeCall(clEnqueueWriteBuffer(qu, ((OclBuffers *)buffers)->nodebuffer, 1, 0,
1358 m_nodenum * sizeof(GpuHidHaarTreeNode),
1359 node, 0, NULL, NULL));
1363 gpuSetHaarClassifierCascade(cascade);
1365 gcascade = (GpuHidHaarClassifierCascade *)cascade->hid_cascade;
1366 stage = (GpuHidHaarStageClassifier *)(gcascade + 1);
1367 classifier = (GpuHidHaarClassifier *)(stage + gcascade->count);
1368 node = (GpuHidHaarTreeNode *)(classifier->node);
1370 openCLSafeCall(clEnqueueWriteBuffer(qu, ((OclBuffers *)buffers)->nodebuffer, 1, 0,
1371 m_nodenum * sizeof(GpuHidHaarTreeNode),
1372 node, 0, NULL, NULL));
1374 cl_int4 *p = (cl_int4 *)malloc(sizeof(cl_int4) * m_loopcount);
1375 float *correction = (float *)malloc(sizeof(float) * m_loopcount);
1377 for(int i = 0; i < m_loopcount; i++)
1380 int equRect_x = (int)(factor * gcascade->p0 + 0.5);
1381 int equRect_y = (int)(factor * gcascade->p1 + 0.5);
1382 int equRect_w = (int)(factor * gcascade->p3 + 0.5);
1383 int equRect_h = (int)(factor * gcascade->p2 + 0.5);
1384 p[i].s[0] = equRect_x;
1385 p[i].s[1] = equRect_y;
1386 p[i].s[2] = equRect_x + equRect_w;
1387 p[i].s[3] = equRect_y + equRect_h;
1388 correction[i] = 1. / (equRect_w * equRect_h);
1389 int startnodenum = m_nodenum * i;
1390 float factor2 = (float)factor;
1392 vector<pair<size_t, const void *> > args1;
1393 args1.push_back ( make_pair(sizeof(cl_mem) , (void *)&((OclBuffers *)buffers)->nodebuffer ));
1394 args1.push_back ( make_pair(sizeof(cl_mem) , (void *)&((OclBuffers *)buffers)->newnodebuffer ));
1395 args1.push_back ( make_pair(sizeof(cl_float) , (void *)&factor2 ));
1396 args1.push_back ( make_pair(sizeof(cl_float) , (void *)&correction[i] ));
1397 args1.push_back ( make_pair(sizeof(cl_int) , (void *)&startnodenum ));
1399 size_t globalThreads2[3] = {m_nodenum, 1, 1};
1401 openCLExecuteKernel(Context::getContext(), &haarobjectdetect_scaled2, "gpuscaleclassifier", globalThreads2, NULL/*localThreads2*/, args1, -1, -1);
1403 openCLSafeCall(clEnqueueWriteBuffer(qu, ((OclBuffers *)buffers)->stagebuffer, 1, 0, sizeof(GpuHidHaarStageClassifier)*gcascade->count, stage, 0, NULL, NULL));
1404 openCLSafeCall(clEnqueueWriteBuffer(qu, ((OclBuffers *)buffers)->pbuffer, 1, 0, sizeof(cl_int4)*m_loopcount, p, 0, NULL, NULL));
1405 openCLSafeCall(clEnqueueWriteBuffer(qu, ((OclBuffers *)buffers)->correctionbuffer, 1, 0, sizeof(cl_float)*m_loopcount, correction, 0, NULL, NULL));
1413 void cv::ocl::OclCascadeClassifierBuf::CreateBaseBufs(const int datasize, const int totalclassifier,
1414 const int flags, const int outputsz)
1418 buffers = malloc(sizeof(OclBuffers));
1421 sizeof(GpuHidHaarStageClassifier) * ((GpuHidHaarClassifierCascade *)oldCascade->hid_cascade)->count;
1422 m_nodenum = (datasize - sizeof(GpuHidHaarClassifierCascade) - tempSize - sizeof(GpuHidHaarClassifier) * totalclassifier)
1423 / sizeof(GpuHidHaarTreeNode);
1425 ((OclBuffers *)buffers)->stagebuffer = openCLCreateBuffer(cv::ocl::Context::getContext(), CL_MEM_READ_ONLY, tempSize);
1426 ((OclBuffers *)buffers)->nodebuffer = openCLCreateBuffer(cv::ocl::Context::getContext(), CL_MEM_READ_ONLY, m_nodenum * sizeof(GpuHidHaarTreeNode));
1430 && ((m_flags & CV_HAAR_SCALE_IMAGE) ^ (flags & CV_HAAR_SCALE_IMAGE)))
1432 openCLSafeCall(clReleaseMemObject(((OclBuffers *)buffers)->candidatebuffer));
1435 if (flags & CV_HAAR_SCALE_IMAGE)
1437 ((OclBuffers *)buffers)->candidatebuffer = openCLCreateBuffer(cv::ocl::Context::getContext(),
1439 4 * sizeof(int) * outputsz);
1443 ((OclBuffers *)buffers)->candidatebuffer = openCLCreateBuffer(cv::ocl::Context::getContext(),
1444 CL_MEM_WRITE_ONLY | CL_MEM_ALLOC_HOST_PTR,
1445 4 * sizeof(int) * outputsz);
1449 void cv::ocl::OclCascadeClassifierBuf::CreateFactorRelatedBufs(
1450 const int rows, const int cols, const int flags,
1451 const double scaleFactor, const size_t localThreads[],
1452 CvSize minSize, CvSize maxSize)
1456 if ((m_flags & CV_HAAR_SCALE_IMAGE) && !(flags & CV_HAAR_SCALE_IMAGE))
1462 else if (!(m_flags & CV_HAAR_SCALE_IMAGE) && (flags & CV_HAAR_SCALE_IMAGE))
1464 openCLSafeCall(clReleaseMemObject(((OclBuffers *)buffers)->newnodebuffer));
1465 openCLSafeCall(clReleaseMemObject(((OclBuffers *)buffers)->correctionbuffer));
1466 openCLSafeCall(clReleaseMemObject(((OclBuffers *)buffers)->pbuffer));
1468 else if ((m_flags & CV_HAAR_SCALE_IMAGE) && (flags & CV_HAAR_SCALE_IMAGE))
1470 if (fabs(m_scaleFactor - scaleFactor) < 1e-6
1471 && (rows == m_rows && cols == m_cols)
1472 && (minSize.width == m_minSize.width)
1473 && (minSize.height == m_minSize.height)
1474 && (maxSize.width == m_maxSize.width)
1475 && (maxSize.height == m_maxSize.height))
1482 if (fabs(m_scaleFactor - scaleFactor) < 1e-6
1483 && (rows == m_rows && cols == m_cols)
1484 && (minSize.width == m_minSize.width)
1485 && (minSize.height == m_minSize.height)
1486 && (maxSize.width == m_maxSize.width)
1487 && (maxSize.height == m_maxSize.height))
1493 openCLSafeCall(clReleaseMemObject(((OclBuffers *)buffers)->newnodebuffer));
1494 openCLSafeCall(clReleaseMemObject(((OclBuffers *)buffers)->correctionbuffer));
1495 openCLSafeCall(clReleaseMemObject(((OclBuffers *)buffers)->pbuffer));
1502 int totalheight = 0;
1506 CvSize winSize0 = oldCascade->orig_window_size;
1507 detect_piramid_info *scaleinfo;
1508 cl_command_queue qu = reinterpret_cast<cl_command_queue>(Context::getContext()->oclCommandQueue());
1509 if (flags & CV_HAAR_SCALE_IMAGE)
1511 for(factor = 1.f;; factor *= scaleFactor)
1513 CvSize winSize = { cvRound(winSize0.width * factor), cvRound(winSize0.height * factor) };
1514 sz.width = cvRound( cols / factor ) + 1;
1515 sz.height = cvRound( rows / factor ) + 1;
1516 CvSize sz1 = { sz.width - winSize0.width - 1, sz.height - winSize0.height - 1 };
1518 if( sz1.width <= 0 || sz1.height <= 0 )
1520 if( winSize.width > maxSize.width || winSize.height > maxSize.height )
1522 if( winSize.width < minSize.width || winSize.height < minSize.height )
1525 totalheight += sz.height;
1526 sizev.push_back(sz);
1527 scalev.push_back(static_cast<float>(factor));
1530 loopcount = sizev.size();
1531 gimg1.create(rows, cols, CV_8UC1);
1532 gsum.create(totalheight + 4, cols + 1, CV_32SC1);
1533 gsqsum.create(totalheight + 4, cols + 1, CV_32FC1);
1535 scaleinfo = (detect_piramid_info *)malloc(sizeof(detect_piramid_info) * loopcount);
1536 for( int i = 0; i < loopcount; i++ )
1539 roi = Rect(0, indexy, sz.width, sz.height);
1540 int width = sz.width - 1 - oldCascade->orig_window_size.width;
1541 int height = sz.height - 1 - oldCascade->orig_window_size.height;
1542 int grpnumperline = (width + localThreads[0] - 1) / localThreads[0];
1543 int totalgrp = ((height + localThreads[1] - 1) / localThreads[1]) * grpnumperline;
1545 ((detect_piramid_info *)scaleinfo)[i].width_height = (width << 16) | height;
1546 ((detect_piramid_info *)scaleinfo)[i].grpnumperline_totalgrp = (grpnumperline << 16) | totalgrp;
1547 ((detect_piramid_info *)scaleinfo)[i].imgoff = gsum(roi).offset >> 2;
1548 ((detect_piramid_info *)scaleinfo)[i].factor = scalev[i];
1550 indexy += sz.height;
1556 cvRound(factor * winSize0.width) < cols - 10 && cvRound(factor * winSize0.height) < rows - 10;
1557 factor *= scaleFactor)
1559 CvSize winSize = { cvRound( winSize0.width * factor ), cvRound( winSize0.height * factor ) };
1560 if( winSize.width < minSize.width || winSize.height < minSize.height )
1564 sizev.push_back(winSize);
1565 scalev.push_back(factor);
1568 loopcount = scalev.size();
1572 sizev.push_back(minSize);
1573 scalev.push_back( min(cvRound(minSize.width / winSize0.width), cvRound(minSize.height / winSize0.height)) );
1576 ((OclBuffers *)buffers)->pbuffer = openCLCreateBuffer(cv::ocl::Context::getContext(), CL_MEM_READ_ONLY,
1577 sizeof(cl_int4) * loopcount);
1578 ((OclBuffers *)buffers)->correctionbuffer = openCLCreateBuffer(cv::ocl::Context::getContext(), CL_MEM_READ_ONLY,
1579 sizeof(cl_float) * loopcount);
1580 ((OclBuffers *)buffers)->newnodebuffer = openCLCreateBuffer(cv::ocl::Context::getContext(), CL_MEM_READ_WRITE,
1581 loopcount * m_nodenum * sizeof(GpuHidHaarTreeNode));
1583 scaleinfo = (detect_piramid_info *)malloc(sizeof(detect_piramid_info) * loopcount);
1584 for( int i = 0; i < loopcount; i++ )
1588 int ystep = cvRound(std::max(2., factor));
1589 int width = (cols - 1 - sz.width + ystep - 1) / ystep;
1590 int height = (rows - 1 - sz.height + ystep - 1) / ystep;
1591 int grpnumperline = (width + localThreads[0] - 1) / localThreads[0];
1592 int totalgrp = ((height + localThreads[1] - 1) / localThreads[1]) * grpnumperline;
1594 ((detect_piramid_info *)scaleinfo)[i].width_height = (width << 16) | height;
1595 ((detect_piramid_info *)scaleinfo)[i].grpnumperline_totalgrp = (grpnumperline << 16) | totalgrp;
1596 ((detect_piramid_info *)scaleinfo)[i].imgoff = 0;
1597 ((detect_piramid_info *)scaleinfo)[i].factor = factor;
1601 if (loopcount != m_loopcount)
1605 openCLSafeCall(clReleaseMemObject(((OclBuffers *)buffers)->scaleinfobuffer));
1607 ((OclBuffers *)buffers)->scaleinfobuffer = openCLCreateBuffer(cv::ocl::Context::getContext(), CL_MEM_READ_ONLY, sizeof(detect_piramid_info) * loopcount);
1610 openCLSafeCall(clEnqueueWriteBuffer(qu, ((OclBuffers *)buffers)->scaleinfobuffer, 1, 0,
1611 sizeof(detect_piramid_info)*loopcount,
1612 scaleinfo, 0, NULL, NULL));
1615 m_loopcount = loopcount;
1618 void cv::ocl::OclCascadeClassifierBuf::GenResult(CV_OUT std::vector<cv::Rect>& faces,
1619 const std::vector<cv::Rect> &rectList,
1620 const std::vector<int> &rweights)
1622 MemStorage tempStorage(cvCreateMemStorage(0));
1623 CvSeq *result_seq = cvCreateSeq( 0, sizeof(CvSeq), sizeof(CvAvgComp), tempStorage );
1625 if( findBiggestObject && rectList.size() )
1627 CvAvgComp result_comp = {{0, 0, 0, 0}, 0};
1629 for( size_t i = 0; i < rectList.size(); i++ )
1631 cv::Rect r = rectList[i];
1632 if( r.area() > cv::Rect(result_comp.rect).area() )
1634 result_comp.rect = r;
1635 result_comp.neighbors = rweights[i];
1638 cvSeqPush( result_seq, &result_comp );
1642 for( size_t i = 0; i < rectList.size(); i++ )
1645 c.rect = rectList[i];
1646 c.neighbors = rweights[i];
1647 cvSeqPush( result_seq, &c );
1651 vector<CvAvgComp> vecAvgComp;
1652 Seq<CvAvgComp>(result_seq).copyTo(vecAvgComp);
1653 faces.resize(vecAvgComp.size());
1654 std::transform(vecAvgComp.begin(), vecAvgComp.end(), faces.begin(), getRect());
1657 void cv::ocl::OclCascadeClassifierBuf::release()
1661 openCLSafeCall(clReleaseMemObject(((OclBuffers *)buffers)->stagebuffer));
1662 openCLSafeCall(clReleaseMemObject(((OclBuffers *)buffers)->scaleinfobuffer));
1663 openCLSafeCall(clReleaseMemObject(((OclBuffers *)buffers)->nodebuffer));
1664 openCLSafeCall(clReleaseMemObject(((OclBuffers *)buffers)->candidatebuffer));
1666 if( (m_flags & CV_HAAR_SCALE_IMAGE) )
1668 cvFree(&oldCascade->hid_cascade);
1672 openCLSafeCall(clReleaseMemObject(((OclBuffers *)buffers)->newnodebuffer));
1673 openCLSafeCall(clReleaseMemObject(((OclBuffers *)buffers)->correctionbuffer));
1674 openCLSafeCall(clReleaseMemObject(((OclBuffers *)buffers)->pbuffer));
1679 initialized = false;
1684 #define _MAX_PATH 1024