modules/ocl/src/haar.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-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.
  16 //
  17 // @Authors
  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
  24 //
  25 // Redistribution and use in source and binary forms, with or without modification,
  26 // are permitted provided that the following conditions are met:
  27 //
  28 //   * Redistribution's of source code must retain the above copyright notice,
  29 //     this list of conditions and the following disclaimer.
  30 //
  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.
  34 //
  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.
  37 //
  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.
  48 //
  49 //M*/
  50
  51 #include "precomp.hpp"
  52 #include <stdio.h>
  53 #include <string>
  54
  55 using namespace cv;
  56 using namespace cv::ocl;
  57 using namespace std;
  58
  59
  60 namespace cv
  61 {
  62 namespace ocl
  63 {
  64 ///////////////////////////OpenCL kernel strings///////////////////////////
  65 extern const char *haarobjectdetect;
  66 extern const char *haarobjectdetectbackup;
  67 extern const char *haarobjectdetect_scaled2;
  68 }
  69 }
  70
  71 /* these settings affect the quality of detection: change with care */
  72 #define CV_ADJUST_FEATURES 1
  73 #define CV_ADJUST_WEIGHTS  0
  74
  75 typedef int sumtype;
  76 typedef double sqsumtype;
  77
  78 typedef struct CvHidHaarFeature
  79 {
  80     struct
  81     {
  82         sumtype *p0, *p1, *p2, *p3;
  83         float weight;
  84     }
  85     rect[CV_HAAR_FEATURE_MAX];
  86 }
  87 CvHidHaarFeature;
  88
  89
  90 typedef struct CvHidHaarTreeNode
  91 {
  92     CvHidHaarFeature feature;
  93     float threshold;
  94     int left;
  95     int right;
  96 }
  97 CvHidHaarTreeNode;
  98
  99
 100 typedef struct CvHidHaarClassifier
 101 {
 102     int count;
 103     //CvHaarFeature* orig_feature;
 104     CvHidHaarTreeNode *node;
 105     float *alpha;
 106 }
 107 CvHidHaarClassifier;
 108
 109
 110 typedef struct CvHidHaarStageClassifier
 111 {
 112     int  count;
 113     float threshold;
 114     CvHidHaarClassifier *classifier;
 115     int two_rects;
 116
 117     struct CvHidHaarStageClassifier *next;
 118     struct CvHidHaarStageClassifier *child;
 119     struct CvHidHaarStageClassifier *parent;
 120 }
 121 CvHidHaarStageClassifier;
 122
 123
 124 struct CvHidHaarClassifierCascade
 125 {
 126     int  count;
 127     int  is_stump_based;
 128     int  has_tilted_features;
 129     int  is_tree;
 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;
 135
 136     void **ipp_stages;
 137 };
 138 typedef struct
 139 {
 140     int width_height;
 141     int grpnumperline_totalgrp;
 142     int imgoff;
 143     float factor;
 144 } detect_piramid_info;
 145 #ifdef WIN32
 146 #define _ALIGNED_ON(_ALIGNMENT) __declspec(align(_ALIGNMENT))
 147
 148 typedef _ALIGNED_ON(128) struct  GpuHidHaarTreeNode
 149 {
 150     _ALIGNED_ON(64) int p[CV_HAAR_FEATURE_MAX][4];
 151     float weight[CV_HAAR_FEATURE_MAX] ;
 152     float threshold ;
 153     _ALIGNED_ON(16) float alpha[3] ;
 154     _ALIGNED_ON(4) int left ;
 155     _ALIGNED_ON(4) int right ;
 156 }
 157 GpuHidHaarTreeNode;
 158
 159
 160 typedef  _ALIGNED_ON(32) struct  GpuHidHaarClassifier
 161 {
 162     _ALIGNED_ON(4) int count;
 163     _ALIGNED_ON(8) GpuHidHaarTreeNode *node ;
 164     _ALIGNED_ON(8) float *alpha ;
 165 }
 166 GpuHidHaarClassifier;
 167
 168
 169 typedef _ALIGNED_ON(64) struct   GpuHidHaarStageClassifier
 170 {
 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 ;
 178 }
 179 GpuHidHaarStageClassifier;
 180
 181
 182 typedef _ALIGNED_ON(64) struct  GpuHidHaarClassifierCascade
 183 {
 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;
 198 #else
 199 #define _ALIGNED_ON(_ALIGNMENT) __attribute__((aligned(_ALIGNMENT) ))
 200
 201 typedef struct _ALIGNED_ON(128) GpuHidHaarTreeNode
 202 {
 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);
 209 }
 210 GpuHidHaarTreeNode;
 211
 212 typedef struct _ALIGNED_ON(32) GpuHidHaarClassifier
 213 {
 214     int count _ALIGNED_ON(4);
 215     GpuHidHaarTreeNode *node _ALIGNED_ON(8);
 216     float *alpha _ALIGNED_ON(8);
 217 }
 218 GpuHidHaarClassifier;
 219
 220
 221 typedef struct _ALIGNED_ON(64) GpuHidHaarStageClassifier
 222 {
 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);
 230 }
 231 GpuHidHaarStageClassifier;
 232
 233
 234 typedef struct _ALIGNED_ON(64) GpuHidHaarClassifierCascade
 235 {
 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;
 250 #endif
 251
 252 const int icv_object_win_border = 1;
 253 const float icv_stage_threshold_bias = 0.0001f;
 254 double globaltime = 0;
 255
 256 /* create more efficient internal representation of haar classifier cascade */
 257 static GpuHidHaarClassifierCascade * gpuCreateHidHaarClassifierCascade( CvHaarClassifierCascade *cascade, int *size, int *totalclassifier)
 258 {
 259     GpuHidHaarClassifierCascade *out = 0;
 260
 261     int i, j, k, l;
 262     int datasize;
 263     int total_classifiers = 0;
 264     int total_nodes = 0;
 265     char errorstr[100];
 266
 267     GpuHidHaarStageClassifier *stage_classifier_ptr;
 268     GpuHidHaarClassifier *haar_classifier_ptr;
 269     GpuHidHaarTreeNode *haar_node_ptr;
 270
 271     CvSize orig_window_size;
 272     int has_tilted_features = 0;
 273
 274     if( !CV_IS_HAAR_CLASSIFIER(cascade) )
 275         CV_Error( !cascade ? CV_StsNullPtr : CV_StsBadArg, "Invalid classifier pointer" );
 276
 277     if( cascade->hid_cascade )
 278         CV_Error( CV_StsError, "hid_cascade has been already created" );
 279
 280     if( !cascade->stage_classifier )
 281         CV_Error( CV_StsNullPtr, "" );
 282
 283     if( cascade->count <= 0 )
 284         CV_Error( CV_StsOutOfRange, "Negative number of cascade stages" );
 285
 286     orig_window_size = cascade->orig_window_size;
 287
 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++ )
 291     {
 292         CvHaarStageClassifier *stage_classifier = cascade->stage_classifier + i;
 293
 294         if( !stage_classifier->classifier ||
 295                 stage_classifier->count <= 0 )
 296         {
 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 );
 300         }
 301
 302         total_classifiers += stage_classifier->count;
 303
 304         for( j = 0; j < stage_classifier->count; j++ )
 305         {
 306             CvHaarClassifier *classifier = stage_classifier->classifier + j;
 307
 308             total_nodes += classifier->count;
 309             for( l = 0; l < classifier->count; l++ )
 310             {
 311                 for( k = 0; k < CV_HAAR_FEATURE_MAX; k++ )
 312                 {
 313                     if( classifier->haar_feature[l].rect[k].r.width )
 314                     {
 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
 320                                 ||
 321                                 (!tilted &&
 322                                  (r.x < 0 || r.y + r.height > orig_window_size.height))
 323                                 ||
 324                                 (tilted && (r.x - r.height < 0 ||
 325                                             r.y + r.width + r.height > orig_window_size.height)))
 326                         {
 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 );
 331                         }
 332                     }
 333                 }
 334             }
 335         }
 336     }
 337
 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;
 343
 344     *totalclassifier = total_classifiers;
 345     *size = datasize;
 346     out = (GpuHidHaarClassifierCascade *)cvAlloc( datasize );
 347     memset( out, 0, sizeof(*out) );
 348
 349     /* init header */
 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);
 354
 355     out->is_stump_based = 1;
 356     out->has_tilted_features = has_tilted_features;
 357     out->is_tree = 0;
 358
 359     /* initialize internal representation */
 360     for( i = 0; i < cascade->count; i++ )
 361     {
 362         CvHaarStageClassifier *stage_classifier = cascade->stage_classifier + i;
 363         GpuHidHaarStageClassifier *hid_stage_classifier = stage_classifier_ptr + i;
 364
 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;
 370
 371         for( j = 0; j < stage_classifier->count; j++ )
 372         {
 373             CvHaarClassifier *classifier         = stage_classifier->classifier + j;
 374             GpuHidHaarClassifier *hid_classifier = hid_stage_classifier->classifier + j;
 375             int node_count = classifier->count;
 376
 377             float *alpha_ptr = &haar_node_ptr->alpha[0];
 378
 379             hid_classifier->count = node_count;
 380             hid_classifier->node = haar_node_ptr;
 381             hid_classifier->alpha = alpha_ptr;
 382
 383             for( l = 0; l < node_count; l++ )
 384             {
 385                 GpuHidHaarTreeNode *node     = hid_classifier->node + l;
 386                 CvHaarFeature      *feature = classifier->haar_feature + l;
 387
 388                 memset( node, -1, sizeof(*node) );
 389                 node->threshold = classifier->threshold[l];
 390                 node->left      = classifier->left[l];
 391                 node->right     = classifier->right[l];
 392
 393                 if( fabs(feature->rect[2].weight) < DBL_EPSILON ||
 394                         feature->rect[2].r.width == 0 ||
 395                         feature->rect[2].r.height == 0 )
 396                 {
 397                     node->p[2][0] = 0;
 398                     node->p[2][1] = 0;
 399                     node->p[2][2] = 0;
 400                     node->p[2][3] = 0;
 401                     node->weight[2] = 0;
 402                 }
 403                 else
 404                     hid_stage_classifier->two_rects = 0;
 405
 406                 memcpy( node->alpha, classifier->alpha, (node_count + 1)*sizeof(alpha_ptr[0]));
 407                 haar_node_ptr = haar_node_ptr + 1;
 408             }
 409             out->is_stump_based &= node_count == 1;
 410         }
 411     }
 412
 413     cascade->hid_cascade = (CvHidHaarClassifierCascade *)out;
 414     assert( (char *)haar_node_ptr - (char *)out <= datasize );
 415
 416     return out;
 417 }
 418
 419
 420 #define sum_elem_ptr(sum,row,col)  \
 421     ((sumtype*)CV_MAT_ELEM_PTR_FAST((sum),(row),(col),sizeof(sumtype)))
 422
 423 #define sqsum_elem_ptr(sqsum,row,col)  \
 424     ((sqsumtype*)CV_MAT_ELEM_PTR_FAST((sqsum),(row),(col),sizeof(sqsumtype)))
 425
 426 #define calc_sum(rect,offset) \
 427     ((rect).p0[offset] - (rect).p1[offset] - (rect).p2[offset] + (rect).p3[offset])
 428
 429
 430 static void gpuSetImagesForHaarClassifierCascade( CvHaarClassifierCascade *_cascade,
 431                                       double scale,
 432                                       int step)
 433 {
 434     GpuHidHaarClassifierCascade *cascade;
 435     int coi0 = 0, coi1 = 0;
 436     int i;
 437     int datasize;
 438     int total;
 439     CvRect equRect;
 440     double weight_scale;
 441     GpuHidHaarStageClassifier *stage_classifier;
 442
 443     if( !CV_IS_HAAR_CLASSIFIER(_cascade) )
 444         CV_Error( !_cascade ? CV_StsNullPtr : CV_StsBadArg, "Invalid classifier pointer" );
 445
 446     if( scale <= 0 )
 447         CV_Error( CV_StsOutOfRange, "Scale must be positive" );
 448
 449     if( coi0 || coi1 )
 450         CV_Error( CV_BadCOI, "COI is not supported" );
 451
 452     if( !_cascade->hid_cascade )
 453         gpuCreateHidHaarClassifierCascade(_cascade, &datasize, &total);
 454
 455     cascade = (GpuHidHaarClassifierCascade *) _cascade->hid_cascade;
 456     stage_classifier = (GpuHidHaarStageClassifier *) (cascade + 1);
 457
 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 );
 461
 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;
 467
 468     cascade->pq0 = equRect.x;
 469     cascade->pq1 = equRect.y;
 470     cascade->pq2 = equRect.x + equRect.width;
 471     cascade->pq3 = equRect.y + equRect.height;
 472
 473     cascade->p0 = equRect.x;
 474     cascade->p1 = equRect.y;
 475     cascade->p2 = equRect.x + equRect.width;
 476     cascade->p3 = equRect.y + equRect.height;
 477
 478
 479     /* init pointers in haar features according to real window size and
 480     given image pointers */
 481     for( i = 0; i < _cascade->count; i++ )
 482     {
 483         int j, k, l;
 484         for( j = 0; j < stage_classifier[i].count; j++ )
 485         {
 486             for( l = 0; l < stage_classifier[i].classifier[j].count; l++ )
 487             {
 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;
 492                 CvRect r[3];
 493
 494                 int base_w = -1, base_h = -1;
 495                 int new_base_w = 0, new_base_h = 0;
 496                 int kx, ky;
 497                 int flagx = 0, flagy = 0;
 498                 int x0 = 0, y0 = 0;
 499                 int nr;
 500
 501                 /* align blocks */
 502                 for( k = 0; k < CV_HAAR_FEATURE_MAX; k++ )
 503                 {
 504                     if(!hidnode->p[k][0])
 505                         break;
 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) );
 511                 }
 512
 513                 nr = k;
 514                 base_w += 1;
 515                 base_h += 1;
 516                 if(base_w == 0)
 517                     base_w = 1;
 518                 kx = r[0].width / base_w;
 519                 if(base_h == 0)
 520                     base_h = 1;
 521                 ky = r[0].height / base_h;
 522
 523                 if( kx <= 0 )
 524                 {
 525                     flagx = 1;
 526                     new_base_w = cvRound( r[0].width * scale ) / kx;
 527                     x0 = cvRound( r[0].x * scale );
 528                 }
 529
 530                 if( ky <= 0 )
 531                 {
 532                     flagy = 1;
 533                     new_base_h = cvRound( r[0].height * scale ) / ky;
 534                     y0 = cvRound( r[0].y * scale );
 535                 }
 536
 537                 for( k = 0; k < nr; k++ )
 538                 {
 539                     CvRect tr;
 540                     double correction_ratio;
 541
 542                     if( flagx )
 543                     {
 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;
 546                     }
 547                     else
 548                     {
 549                         tr.x = cvRound( r[k].x * scale );
 550                         tr.width = cvRound( r[k].width * scale );
 551                     }
 552
 553                     if( flagy )
 554                     {
 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;
 557                     }
 558                     else
 559                     {
 560                         tr.y = cvRound( r[k].y * scale );
 561                         tr.height = cvRound( r[k].height * scale );
 562                     }
 563
 564 #if CV_ADJUST_WEIGHTS
 565                     {
 566                         // RAINER START
 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;
 575                         // RAINER END
 576                     }
 577 #else
 578                     correction_ratio = weight_scale * (!feature->tilted ? 1 : 0.5);
 579 #endif
 580
 581                     if( !feature->tilted )
 582                     {
 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;
 587                     }
 588                     else
 589                     {
 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;
 594                     }
 595                     hidnode->weight[k] = (float)(feature->rect[k].weight * correction_ratio);
 596                     if( k == 0 )
 597                         area0 = tr.width * tr.height;
 598                     else
 599                         sum0 += hidnode->weight[k] * tr.width * tr.height;
 600                 }
 601                 hidnode->weight[0] = (float)(-sum0 / area0);
 602             } /* l */
 603         } /* j */
 604     }
 605 }
 606
 607 static void gpuSetHaarClassifierCascade( CvHaarClassifierCascade *_cascade)
 608 {
 609     GpuHidHaarClassifierCascade *cascade;
 610     int i;
 611     int datasize;
 612     int total;
 613     CvRect equRect;
 614     double weight_scale;
 615     GpuHidHaarStageClassifier *stage_classifier;
 616
 617     if( !CV_IS_HAAR_CLASSIFIER(_cascade) )
 618         CV_Error( !_cascade ? CV_StsNullPtr : CV_StsBadArg, "Invalid classifier pointer" );
 619
 620     if( !_cascade->hid_cascade )
 621         gpuCreateHidHaarClassifierCascade(_cascade, &datasize, &total);
 622
 623     cascade = (GpuHidHaarClassifierCascade *) _cascade->hid_cascade;
 624     stage_classifier = (GpuHidHaarStageClassifier *) cascade + 1;
 625
 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;
 629
 630     equRect.x = equRect.y = 1;
 631     equRect.width = _cascade->orig_window_size.width - 2;
 632     equRect.height = _cascade->orig_window_size.height - 2;
 633     weight_scale = 1;
 634     cascade->inv_window_area = weight_scale;
 635
 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++ )
 641     {
 642         int j, k, l;
 643         for( j = 0; j < stage_classifier[i].count; j++ )
 644         {
 645             for( l = 0; l < stage_classifier[i].classifier[j].count; l++ )
 646             {
 647                 CvHaarFeature *feature =
 648                     &_cascade->stage_classifier[i].classifier[j].haar_feature[l];
 649                 GpuHidHaarTreeNode *hidnode = &stage_classifier[i].classifier[j].node[l];
 650                 CvRect r[3];
 651
 652
 653                 int nr;
 654
 655                 /* align blocks */
 656                 for( k = 0; k < CV_HAAR_FEATURE_MAX; k++ )
 657                 {
 658                     if(!hidnode->p[k][0])
 659                         break;
 660                     r[k] = feature->rect[k].r;
 661                }
 662
 663                 nr = k;
 664                 for( k = 0; k < nr; k++ )
 665                 {
 666                     CvRect tr;
 667                     double correction_ratio;
 668                     tr.x = r[k].x;
 669                     tr.width = r[k].width;
 670                     tr.y = r[k].y ;
 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);
 678                 }
 679             } /* l */
 680         } /* j */
 681     }
 682 }
 683
 684 CvSeq *cv::ocl::OclCascadeClassifier::oclHaarDetectObjects( oclMat &gimg, CvMemStorage *storage, double scaleFactor,
 685         int minNeighbors, int flags, CvSize minSize, CvSize maxSize)
 686 {
 687     CvHaarClassifierCascade *cascade = oldCascade;
 688
 689     const double GROUP_EPS = 0.2;
 690     CvSeq *result_seq = 0;
 691
 692     cv::ConcurrentRectVector allCandidates;
 693     std::vector<cv::Rect> rectList;
 694     std::vector<int> rweights;
 695     double factor;
 696     int datasize=0;
 697     int totalclassifier=0;
 698
 699     GpuHidHaarClassifierCascade *gcascade;
 700     GpuHidHaarStageClassifier    *stage;
 701     GpuHidHaarClassifier         *classifier;
 702     GpuHidHaarTreeNode           *node;
 703
 704     int *candidate;
 705     cl_int status;
 706
 707     bool findBiggestObject = (flags & CV_HAAR_FIND_BIGGEST_OBJECT) != 0;
 708
 709     if( maxSize.height == 0 || maxSize.width == 0 )
 710     {
 711         maxSize.height = gimg.rows;
 712         maxSize.width = gimg.cols;
 713     }
 714
 715     if( !CV_IS_HAAR_CLASSIFIER(cascade) )
 716         CV_Error( !cascade ? CV_StsNullPtr : CV_StsBadArg, "Invalid classifier cascade" );
 717
 718     if( !storage )
 719         CV_Error( CV_StsNullPtr, "Null storage pointer" );
 720
 721     if( CV_MAT_DEPTH(gimg.type()) != CV_8U )
 722         CV_Error( CV_StsUnsupportedFormat, "Only 8-bit images are supported" );
 723
 724     if( scaleFactor <= 1 )
 725         CV_Error( CV_StsOutOfRange, "scale factor must be > 1" );
 726
 727     if( findBiggestObject )
 728         flags &= ~CV_HAAR_SCALE_IMAGE;
 729
 730     if( !cascade->hid_cascade )
 731         gpuCreateHidHaarClassifierCascade(cascade, &datasize, &totalclassifier);
 732
 733     result_seq = cvCreateSeq( 0, sizeof(CvSeq), sizeof(CvAvgComp), storage );
 734
 735     if( CV_MAT_CN(gimg.type()) > 1 )
 736     {
 737         oclMat gtemp;
 738         cvtColor( gimg, gtemp, CV_BGR2GRAY );
 739         gimg = gtemp;
 740     }
 741
 742     if( findBiggestObject )
 743         flags &= ~(CV_HAAR_SCALE_IMAGE | CV_HAAR_DO_CANNY_PRUNING);
 744
 745     if( gimg.cols < minSize.width || gimg.rows < minSize.height )
 746         CV_Error(CV_StsError, "Image too small");
 747
 748     cl_command_queue qu = reinterpret_cast<cl_command_queue>(Context::getContext()->oclCommandQueue());
 749     if( (flags & CV_HAAR_SCALE_IMAGE) )
 750     {
 751         CvSize winSize0 = cascade->orig_window_size;
 752         int totalheight = 0;
 753         int indexy = 0;
 754         CvSize sz;
 755         vector<CvSize> sizev;
 756         vector<float> scalev;
 757         for(factor = 1.f;; factor *= scaleFactor)
 758         {
 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 };
 763
 764             if( sz1.width <= 0 || sz1.height <= 0 )
 765                 break;
 766             if( winSize.width > maxSize.width || winSize.height > maxSize.height )
 767                 break;
 768             if( winSize.width < minSize.width || winSize.height < minSize.height )
 769                 continue;
 770
 771             totalheight += sz.height;
 772             sizev.push_back(sz);
 773             scalev.push_back(factor);
 774         }
 775
 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);
 779
 780         cl_mem stagebuffer;
 781         cl_mem nodebuffer;
 782         cl_mem candidatebuffer;
 783         cl_mem scaleinfobuffer;
 784         cv::Rect roi, roi2;
 785         cv::Mat imgroi, imgroisq;
 786         cv::ocl::oclMat resizeroi, gimgroi, gimgroisq;
 787         int grp_per_CU = 12;
 788
 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],
 792                                     localThreads[1], 1
 793                                   };
 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);
 797
 798         for( int i = 0; i < loopcount; i++ )
 799         {
 800             sz = sizev[i];
 801             factor = scalev[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);
 805             gimgroi = gsum(roi);
 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;
 810
 811
 812             int grpnumperline = (width + localThreads[0] - 1) / localThreads[0];
 813             int totalgrp = ((height + localThreads[1] - 1) / localThreads[1]) * grpnumperline;
 814
 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);
 820             indexy += sz.height;
 821         }
 822
 823         gcascade   = (GpuHidHaarClassifierCascade *)cascade->hid_cascade;
 824         stage      = (GpuHidHaarStageClassifier *)(gcascade + 1);
 825         classifier = (GpuHidHaarClassifier *)(stage + gcascade->count);
 826         node       = (GpuHidHaarTreeNode *)(classifier->node);
 827
 828         int nodenum = (datasize - sizeof(GpuHidHaarClassifierCascade) -
 829                        sizeof(GpuHidHaarStageClassifier) * gcascade->count - sizeof(GpuHidHaarClassifier) * totalclassifier) / sizeof(GpuHidHaarTreeNode);
 830
 831         candidate = (int *)malloc(4 * sizeof(int) * outputsz);
 832
 833         gpuSetImagesForHaarClassifierCascade( cascade, 1., gsum.step / 4 );
 834
 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));
 837
 838         nodebuffer = openCLCreateBuffer(gsum.clCxt, CL_MEM_READ_ONLY, nodenum * sizeof(GpuHidHaarTreeNode));
 839
 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);
 843
 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));
 846
 847         int startstage = 0;
 848         int endstage = gcascade->count;
 849         int startnode = 0;
 850         int pixelstep = gsum.step / 4;
 851         int splitstage = 3;
 852         int splitnode = stage[0].count + stage[1].count + stage[2].count;
 853         cl_int4 p, pq;
 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;
 863
 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 ));
 881
 882         const char * build_options = gcascade->is_stump_based ? "-D STUMP_BASED=1" : "-D STUMP_BASED=0";
 883
 884         openCLExecuteKernel(gsum.clCxt, &haarobjectdetect, "gpuRunHaarClassifierCascade", globalThreads, localThreads, args, -1, -1, build_options);
 885
 886         openCLReadBuffer( gsum.clCxt, candidatebuffer, candidate, 4 * sizeof(int)*outputsz );
 887
 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]));
 892
 893         free(scaleinfo);
 894         free(candidate);
 895         openCLSafeCall(clReleaseMemObject(stagebuffer));
 896         openCLSafeCall(clReleaseMemObject(scaleinfobuffer));
 897         openCLSafeCall(clReleaseMemObject(nodebuffer));
 898         openCLSafeCall(clReleaseMemObject(candidatebuffer));
 899
 900     }
 901     else
 902     {
 903         CvSize winsize0 = cascade->orig_window_size;
 904         int n_factors = 0;
 905         oclMat gsum;
 906         oclMat gsqsum;
 907         cv::ocl::integral(gimg, gsum, gsqsum);
 908         CvSize sz;
 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);
 916         cl_mem stagebuffer;
 917         cl_mem nodebuffer;
 918         cl_mem candidatebuffer;
 919         cl_mem scaleinfobuffer;
 920         cl_mem pbuffer;
 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 )
 926         {
 927             CvSize winSize = { cvRound( winsize0.width * factor ),
 928                                cvRound( winsize0.height * factor )
 929                              };
 930             if( winSize.width < minSize.width || winSize.height < minSize.height )
 931             {
 932                 continue;
 933             }
 934             sizev.push_back(winSize);
 935             scalev.push_back(factor);
 936         }
 937         int loopcount = scalev.size();
 938         if(loopcount == 0)
 939         {
 940             loopcount = 1;
 941             n_factors = 1;
 942             sizev.push_back(minSize);
 943             scalev.push_back( min(cvRound(minSize.width / winsize0.width), cvRound(minSize.height / winsize0.height)) );
 944
 945         }
 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);
 949         int grp_per_CU = 12;
 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));
 964         int startstage = 0;
 965         int endstage = gcascade->count;
 966         for(int i = 0; i < loopcount; i++)
 967         {
 968             sz = sizev[i];
 969             factor = scalev[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;
 984
 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;
 991
 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 ));
 998
 999             size_t globalThreads2[3] = {nodenum, 1, 1};
1000             openCLExecuteKernel(gsum.clCxt, &haarobjectdetect_scaled2, "gpuscaleclassifier", globalThreads2, NULL/*localThreads2*/, args1, -1, -1);
1001         }
1002
1003         int step = gsum.step / 4;
1004         int startnode = 0;
1005         int splitstage = 3;
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));
1015
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);
1036
1037         candidate = (int *)clEnqueueMapBuffer(qu, candidatebuffer, 1, CL_MAP_READ, 0, 4 * sizeof(int) * outputsz, 0, 0, 0, &status);
1038
1039         for(int i = 0; i < outputsz; i++)
1040         {
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]));
1043         }
1044
1045         free(scaleinfo);
1046         free(p);
1047         free(correction);
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));
1056     }
1057
1058     cvFree(&cascade->hid_cascade);
1059     rectList.resize(allCandidates.size());
1060     if(!allCandidates.empty())
1061         std::copy(allCandidates.begin(), allCandidates.end(), rectList.begin());
1062
1063     if( minNeighbors != 0 || findBiggestObject )
1064         groupRectangles(rectList, rweights, std::max(minNeighbors, 1), GROUP_EPS);
1065     else
1066         rweights.resize(rectList.size(), 0);
1067
1068     if( findBiggestObject && rectList.size() )
1069     {
1070         CvAvgComp result_comp = {{0, 0, 0, 0}, 0};
1071
1072         for( size_t i = 0; i < rectList.size(); i++ )
1073         {
1074             cv::Rect r = rectList[i];
1075             if( r.area() > cv::Rect(result_comp.rect).area() )
1076             {
1077                 result_comp.rect = r;
1078                 result_comp.neighbors = rweights[i];
1079             }
1080         }
1081         cvSeqPush( result_seq, &result_comp );
1082     }
1083     else
1084     {
1085         for( size_t i = 0; i < rectList.size(); i++ )
1086         {
1087             CvAvgComp c;
1088             c.rect = rectList[i];
1089             c.neighbors = rweights[i];
1090             cvSeqPush( result_seq, &c );
1091         }
1092     }
1093
1094     return result_seq;
1095 }
1096
1097 struct OclBuffers
1098 {
1099     cl_mem stagebuffer;
1100     cl_mem nodebuffer;
1101     cl_mem candidatebuffer;
1102     cl_mem scaleinfobuffer;
1103     cl_mem pbuffer;
1104     cl_mem correctionbuffer;
1105     cl_mem newnodebuffer;
1106 };
1107
1108 struct getRect
1109 {
1110     Rect operator()(const CvAvgComp &e) const
1111     {
1112         return e.rect;
1113     }
1114 };
1115
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)
1119 {
1120     int blocksize = 8;
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],
1124         localThreads[1],
1125         1 };
1126     int outputsz = 256 * globalThreads[0] / localThreads[0];
1127
1128     Init(gimg.rows, gimg.cols, scaleFactor, flags, outputsz, localThreads, minSize, maxSize);
1129
1130     const double GROUP_EPS = 0.2;
1131
1132     cv::ConcurrentRectVector allCandidates;
1133     std::vector<cv::Rect> rectList;
1134     std::vector<int> rweights;
1135
1136     CvHaarClassifierCascade      *cascade = oldCascade;
1137     GpuHidHaarClassifierCascade  *gcascade;
1138     GpuHidHaarStageClassifier    *stage;
1139
1140     if( CV_MAT_DEPTH(gimg.type()) != CV_8U )
1141         CV_Error( CV_StsUnsupportedFormat, "Only 8-bit images are supported" );
1142
1143     if( CV_MAT_CN(gimg.type()) > 1 )
1144     {
1145         oclMat gtemp;
1146         cvtColor( gimg, gtemp, CV_BGR2GRAY );
1147         gimg = gtemp;
1148     }
1149
1150     int *candidate;
1151     cl_command_queue qu = reinterpret_cast<cl_command_queue>(Context::getContext()->oclCommandQueue());
1152     if( (flags & CV_HAAR_SCALE_IMAGE) )
1153     {
1154         int indexy = 0;
1155         CvSize sz;
1156
1157         cv::Rect roi, roi2;
1158         cv::Mat imgroi, imgroisq;
1159         cv::ocl::oclMat resizeroi, gimgroi, gimgroisq;
1160
1161         for( int i = 0; i < m_loopcount; i++ )
1162         {
1163             sz = sizev[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);
1169
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;
1173         }
1174
1175         gcascade   = (GpuHidHaarClassifierCascade *)(cascade->hid_cascade);
1176         stage      = (GpuHidHaarStageClassifier *)(gcascade + 1);
1177
1178         int startstage = 0;
1179         int endstage = gcascade->count;
1180         int startnode = 0;
1181         int pixelstep = gsum.step / 4;
1182         int splitstage = 3;
1183         int splitnode = stage[0].count + stage[1].count + stage[2].count;
1184         cl_int4 p, pq;
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;
1194
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 ));
1212
1213         const char * build_options = gcascade->is_stump_based ? "-D STUMP_BASED=1" : "-D STUMP_BASED=0";
1214
1215         openCLExecuteKernel(gsum.clCxt, &haarobjectdetect, "gpuRunHaarClassifierCascade", globalThreads, localThreads, args, -1, -1, build_options);
1216
1217         candidate = (int *)malloc(4 * sizeof(int) * outputsz);
1218         memset(candidate, 0, 4 * sizeof(int) * outputsz);
1219
1220         openCLReadBuffer( gsum.clCxt, ((OclBuffers *)buffers)->candidatebuffer, candidate, 4 * sizeof(int)*outputsz );
1221
1222         for(int i = 0; i < outputsz; i++)
1223         {
1224             if(candidate[4 * i + 2] != 0)
1225             {
1226                 allCandidates.push_back(Rect(candidate[4 * i], candidate[4 * i + 1],
1227                 candidate[4 * i + 2], candidate[4 * i + 3]));
1228             }
1229         }
1230         free((void *)candidate);
1231         candidate = NULL;
1232     }
1233     else
1234     {
1235         cv::ocl::integral(gimg, gsum, gsqsum);
1236
1237         gcascade   = (GpuHidHaarClassifierCascade *)cascade->hid_cascade;
1238
1239         int step = gsum.step / 4;
1240         int startnode = 0;
1241         int splitstage = 3;
1242
1243         int startstage = 0;
1244         int endstage = gcascade->count;
1245
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 ));
1264
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);
1267
1268         candidate = (int *)clEnqueueMapBuffer(qu, ((OclBuffers *)buffers)->candidatebuffer, 1, CL_MAP_READ, 0, 4 * sizeof(int) * outputsz, 0, 0, 0, NULL);
1269
1270         for(int i = 0; i < outputsz; i++)
1271         {
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]));
1275         }
1276         clEnqueueUnmapMemObject(qu, ((OclBuffers *)buffers)->candidatebuffer, candidate, 0, 0, 0);
1277     }
1278     rectList.resize(allCandidates.size());
1279     if(!allCandidates.empty())
1280         std::copy(allCandidates.begin(), allCandidates.end(), rectList.begin());
1281
1282     if( minNeighbors != 0 || findBiggestObject )
1283         groupRectangles(rectList, rweights, std::max(minNeighbors, 1), GROUP_EPS);
1284     else
1285         rweights.resize(rectList.size(), 0);
1286
1287     GenResult(faces, rectList, rweights);
1288 }
1289
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)
1294 {
1295     if(initialized)
1296     {
1297         return; // we only allow one time initialization
1298     }
1299     CvHaarClassifierCascade      *cascade = oldCascade;
1300
1301     if( !CV_IS_HAAR_CLASSIFIER(cascade) )
1302         CV_Error( !cascade ? CV_StsNullPtr : CV_StsBadArg, "Invalid classifier cascade" );
1303
1304     if( scaleFactor <= 1 )
1305         CV_Error( CV_StsOutOfRange, "scale factor must be > 1" );
1306
1307     if( cols < minSize.width || rows < minSize.height )
1308         CV_Error(CV_StsError, "Image too small");
1309
1310     int datasize=0;
1311     int totalclassifier=0;
1312
1313     if( !cascade->hid_cascade )
1314     {
1315         gpuCreateHidHaarClassifierCascade(cascade, &datasize, &totalclassifier);
1316     }
1317
1318     if( maxSize.height == 0 || maxSize.width == 0 )
1319     {
1320         maxSize.height = rows;
1321         maxSize.width = cols;
1322     }
1323
1324     findBiggestObject = (flags & CV_HAAR_FIND_BIGGEST_OBJECT) != 0;
1325     if( findBiggestObject )
1326         flags &= ~(CV_HAAR_SCALE_IMAGE | CV_HAAR_DO_CANNY_PRUNING);
1327
1328     CreateBaseBufs(datasize, totalclassifier, flags, outputsz);
1329     CreateFactorRelatedBufs(rows, cols, flags, scaleFactor, localThreads, minSize, maxSize);
1330
1331     m_scaleFactor = scaleFactor;
1332     m_rows = rows;
1333     m_cols = cols;
1334     m_flags = flags;
1335     m_minSize = minSize;
1336     m_maxSize = maxSize;
1337
1338     // initialize nodes
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) )
1345     {
1346         gcascade   = (GpuHidHaarClassifierCascade *)(cascade->hid_cascade);
1347         stage      = (GpuHidHaarStageClassifier *)(gcascade + 1);
1348         classifier = (GpuHidHaarClassifier *)(stage + gcascade->count);
1349         node       = (GpuHidHaarTreeNode *)(classifier->node);
1350
1351         gpuSetImagesForHaarClassifierCascade( cascade, 1., gsum.step / 4 );
1352
1353         openCLSafeCall(clEnqueueWriteBuffer(qu, ((OclBuffers *)buffers)->stagebuffer, 1, 0,
1354             sizeof(GpuHidHaarStageClassifier) * gcascade->count,
1355             stage, 0, NULL, NULL));
1356
1357         openCLSafeCall(clEnqueueWriteBuffer(qu, ((OclBuffers *)buffers)->nodebuffer, 1, 0,
1358                                             m_nodenum * sizeof(GpuHidHaarTreeNode),
1359                                             node, 0, NULL, NULL));
1360     }
1361     else
1362     {
1363         gpuSetHaarClassifierCascade(cascade);
1364
1365         gcascade   = (GpuHidHaarClassifierCascade *)cascade->hid_cascade;
1366         stage      = (GpuHidHaarStageClassifier *)(gcascade + 1);
1367         classifier = (GpuHidHaarClassifier *)(stage + gcascade->count);
1368         node       = (GpuHidHaarTreeNode *)(classifier->node);
1369
1370         openCLSafeCall(clEnqueueWriteBuffer(qu, ((OclBuffers *)buffers)->nodebuffer, 1, 0,
1371             m_nodenum * sizeof(GpuHidHaarTreeNode),
1372             node, 0, NULL, NULL));
1373
1374         cl_int4 *p = (cl_int4 *)malloc(sizeof(cl_int4) * m_loopcount);
1375         float *correction = (float *)malloc(sizeof(float) * m_loopcount);
1376         double factor;
1377         for(int i = 0; i < m_loopcount; i++)
1378         {
1379             factor = scalev[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;
1391
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 ));
1398
1399             size_t globalThreads2[3] = {m_nodenum, 1, 1};
1400
1401             openCLExecuteKernel(Context::getContext(), &haarobjectdetect_scaled2, "gpuscaleclassifier", globalThreads2, NULL/*localThreads2*/, args1, -1, -1);
1402         }
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));
1406
1407         free(p);
1408         free(correction);
1409     }
1410     initialized = true;
1411 }
1412
1413 void cv::ocl::OclCascadeClassifierBuf::CreateBaseBufs(const int datasize, const int totalclassifier,
1414                                                       const int flags, const int outputsz)
1415 {
1416     if (!initialized)
1417     {
1418         buffers = malloc(sizeof(OclBuffers));
1419
1420         size_t tempSize =
1421             sizeof(GpuHidHaarStageClassifier) * ((GpuHidHaarClassifierCascade *)oldCascade->hid_cascade)->count;
1422         m_nodenum = (datasize - sizeof(GpuHidHaarClassifierCascade) - tempSize - sizeof(GpuHidHaarClassifier) * totalclassifier)
1423             / sizeof(GpuHidHaarTreeNode);
1424
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));
1427     }
1428
1429     if (initialized
1430         && ((m_flags & CV_HAAR_SCALE_IMAGE) ^ (flags & CV_HAAR_SCALE_IMAGE)))
1431     {
1432         openCLSafeCall(clReleaseMemObject(((OclBuffers *)buffers)->candidatebuffer));
1433     }
1434
1435     if (flags & CV_HAAR_SCALE_IMAGE)
1436     {
1437         ((OclBuffers *)buffers)->candidatebuffer = openCLCreateBuffer(cv::ocl::Context::getContext(),
1438                                                         CL_MEM_WRITE_ONLY,
1439                                                         4 * sizeof(int) * outputsz);
1440     }
1441     else
1442     {
1443         ((OclBuffers *)buffers)->candidatebuffer = openCLCreateBuffer(cv::ocl::Context::getContext(),
1444                                                         CL_MEM_WRITE_ONLY | CL_MEM_ALLOC_HOST_PTR,
1445                                                         4 * sizeof(int) * outputsz);
1446     }
1447 }
1448
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)
1453 {
1454     if (initialized)
1455     {
1456         if ((m_flags & CV_HAAR_SCALE_IMAGE) && !(flags & CV_HAAR_SCALE_IMAGE))
1457         {
1458             gimg1.release();
1459             gsum.release();
1460             gsqsum.release();
1461         }
1462         else if (!(m_flags & CV_HAAR_SCALE_IMAGE) && (flags & CV_HAAR_SCALE_IMAGE))
1463         {
1464             openCLSafeCall(clReleaseMemObject(((OclBuffers *)buffers)->newnodebuffer));
1465             openCLSafeCall(clReleaseMemObject(((OclBuffers *)buffers)->correctionbuffer));
1466             openCLSafeCall(clReleaseMemObject(((OclBuffers *)buffers)->pbuffer));
1467         }
1468         else if ((m_flags & CV_HAAR_SCALE_IMAGE) && (flags & CV_HAAR_SCALE_IMAGE))
1469         {
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))
1476             {
1477                 return;
1478             }
1479         }
1480         else
1481         {
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))
1488             {
1489                 return;
1490             }
1491             else
1492             {
1493                 openCLSafeCall(clReleaseMemObject(((OclBuffers *)buffers)->newnodebuffer));
1494                 openCLSafeCall(clReleaseMemObject(((OclBuffers *)buffers)->correctionbuffer));
1495                 openCLSafeCall(clReleaseMemObject(((OclBuffers *)buffers)->pbuffer));
1496             }
1497         }
1498     }
1499
1500     int loopcount;
1501     int indexy = 0;
1502     int totalheight = 0;
1503     double factor;
1504     Rect roi;
1505     CvSize sz;
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)
1510     {
1511         for(factor = 1.f;; factor *= scaleFactor)
1512         {
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 };
1517
1518             if( sz1.width <= 0 || sz1.height <= 0 )
1519                 break;
1520             if( winSize.width > maxSize.width || winSize.height > maxSize.height )
1521                 break;
1522             if( winSize.width < minSize.width || winSize.height < minSize.height )
1523                 continue;
1524
1525             totalheight += sz.height;
1526             sizev.push_back(sz);
1527             scalev.push_back(static_cast<float>(factor));
1528         }
1529
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);
1534
1535         scaleinfo = (detect_piramid_info *)malloc(sizeof(detect_piramid_info) * loopcount);
1536         for( int i = 0; i < loopcount; i++ )
1537         {
1538             sz = sizev[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;
1544
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];
1549
1550             indexy += sz.height;
1551         }
1552     }
1553     else
1554     {
1555         for(factor = 1;
1556             cvRound(factor * winSize0.width) < cols - 10 && cvRound(factor * winSize0.height) < rows - 10;
1557             factor *= scaleFactor)
1558         {
1559             CvSize winSize = { cvRound( winSize0.width * factor ), cvRound( winSize0.height * factor ) };
1560             if( winSize.width < minSize.width || winSize.height < minSize.height )
1561             {
1562                 continue;
1563             }
1564             sizev.push_back(winSize);
1565             scalev.push_back(factor);
1566         }
1567
1568         loopcount = scalev.size();
1569         if(loopcount == 0)
1570         {
1571             loopcount = 1;
1572             sizev.push_back(minSize);
1573             scalev.push_back( min(cvRound(minSize.width / winSize0.width), cvRound(minSize.height / winSize0.height)) );
1574         }
1575
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));
1582
1583         scaleinfo = (detect_piramid_info *)malloc(sizeof(detect_piramid_info) * loopcount);
1584         for( int i = 0; i < loopcount; i++ )
1585         {
1586             sz = sizev[i];
1587             factor = scalev[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;
1593
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;
1598         }
1599     }
1600
1601     if (loopcount != m_loopcount)
1602     {
1603         if (initialized)
1604         {
1605             openCLSafeCall(clReleaseMemObject(((OclBuffers *)buffers)->scaleinfobuffer));
1606         }
1607         ((OclBuffers *)buffers)->scaleinfobuffer = openCLCreateBuffer(cv::ocl::Context::getContext(), CL_MEM_READ_ONLY, sizeof(detect_piramid_info) * loopcount);
1608     }
1609
1610     openCLSafeCall(clEnqueueWriteBuffer(qu, ((OclBuffers *)buffers)->scaleinfobuffer, 1, 0,
1611         sizeof(detect_piramid_info)*loopcount,
1612         scaleinfo, 0, NULL, NULL));
1613     free(scaleinfo);
1614
1615     m_loopcount = loopcount;
1616 }
1617
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)
1621 {
1622     MemStorage tempStorage(cvCreateMemStorage(0));
1623     CvSeq *result_seq = cvCreateSeq( 0, sizeof(CvSeq), sizeof(CvAvgComp), tempStorage );
1624
1625     if( findBiggestObject && rectList.size() )
1626     {
1627         CvAvgComp result_comp = {{0, 0, 0, 0}, 0};
1628
1629         for( size_t i = 0; i < rectList.size(); i++ )
1630         {
1631             cv::Rect r = rectList[i];
1632             if( r.area() > cv::Rect(result_comp.rect).area() )
1633             {
1634                 result_comp.rect = r;
1635                 result_comp.neighbors = rweights[i];
1636             }
1637         }
1638         cvSeqPush( result_seq, &result_comp );
1639     }
1640     else
1641     {
1642         for( size_t i = 0; i < rectList.size(); i++ )
1643         {
1644             CvAvgComp c;
1645             c.rect = rectList[i];
1646             c.neighbors = rweights[i];
1647             cvSeqPush( result_seq, &c );
1648         }
1649     }
1650
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());
1655 }
1656
1657 void cv::ocl::OclCascadeClassifierBuf::release()
1658 {
1659     if(initialized)
1660     {
1661         openCLSafeCall(clReleaseMemObject(((OclBuffers *)buffers)->stagebuffer));
1662         openCLSafeCall(clReleaseMemObject(((OclBuffers *)buffers)->scaleinfobuffer));
1663         openCLSafeCall(clReleaseMemObject(((OclBuffers *)buffers)->nodebuffer));
1664         openCLSafeCall(clReleaseMemObject(((OclBuffers *)buffers)->candidatebuffer));
1665
1666         if( (m_flags & CV_HAAR_SCALE_IMAGE) )
1667         {
1668             cvFree(&oldCascade->hid_cascade);
1669         }
1670         else
1671         {
1672             openCLSafeCall(clReleaseMemObject(((OclBuffers *)buffers)->newnodebuffer));
1673             openCLSafeCall(clReleaseMemObject(((OclBuffers *)buffers)->correctionbuffer));
1674             openCLSafeCall(clReleaseMemObject(((OclBuffers *)buffers)->pbuffer));
1675         }
1676
1677         free(buffers);
1678         buffers = NULL;
1679         initialized = false;
1680     }
1681 }
1682
1683 #ifndef _MAX_PATH
1684 #define _MAX_PATH 1024
1685 #endif