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// Intel License Agreement 11// For Open Source Computer Vision Library 12// 13// Copyright (C) 2000, Intel Corporation, all rights reserved. 14// Third party copyrights are property of their respective owners. 15// 16// Redistribution and use in source and binary forms, with or without modification, 17// are permitted provided that the following conditions are met: 18// 19// * Redistribution's of source code must retain the above copyright notice, 20// this list of conditions and the following disclaimer. 21// 22// * Redistribution's in binary form must reproduce the above copyright notice, 23// this list of conditions and the following disclaimer in the documentation 24// and/or other materials provided with the distribution. 25// 26// * The name of Intel Corporation may not be used to endorse or promote products 27// derived from this software without specific prior written permission. 28// 29// This software is provided by the copyright holders and contributors "as is" and 30// any express or implied warranties, including, but not limited to, the implied 31// warranties of merchantability and fitness for a particular purpose are disclaimed. 32// In no event shall the Intel Corporation or contributors be liable for any direct, 33// indirect, incidental, special, exemplary, or consequential damages 34// (including, but not limited to, procurement of substitute goods or services; 35// loss of use, data, or profits; or business interruption) however caused 36// and on any theory of liability, whether in contract, strict liability, 37// or tort (including negligence or otherwise) arising in any way out of 38// the use of this software, even if advised of the possibility of such damage. 39// 40//M*/ 41 42/* Haar features calculation */ 43 44#include "_cv.h" 45#include <stdio.h> 46 47/* these settings affect the quality of detection: change with care */ 48#define CV_ADJUST_FEATURES 1 49#define CV_ADJUST_WEIGHTS 0 50 51typedef int sumtype; 52typedef double sqsumtype; 53 54typedef struct CvHidHaarFeature 55{ 56 struct 57 { 58 sumtype *p0, *p1, *p2, *p3; 59 float weight; 60 } 61 rect[CV_HAAR_FEATURE_MAX]; 62} 63CvHidHaarFeature; 64 65 66typedef struct CvHidHaarTreeNode 67{ 68 CvHidHaarFeature feature; 69 float threshold; 70 int left; 71 int right; 72} 73CvHidHaarTreeNode; 74 75 76typedef struct CvHidHaarClassifier 77{ 78 int count; 79 //CvHaarFeature* orig_feature; 80 CvHidHaarTreeNode* node; 81 float* alpha; 82} 83CvHidHaarClassifier; 84 85 86typedef struct CvHidHaarStageClassifier 87{ 88 int count; 89 float threshold; 90 CvHidHaarClassifier* classifier; 91 int two_rects; 92 93 struct CvHidHaarStageClassifier* next; 94 struct CvHidHaarStageClassifier* child; 95 struct CvHidHaarStageClassifier* parent; 96} 97CvHidHaarStageClassifier; 98 99 100struct CvHidHaarClassifierCascade 101{ 102 int count; 103 int is_stump_based; 104 int has_tilted_features; 105 int is_tree; 106 double inv_window_area; 107 CvMat sum, sqsum, tilted; 108 CvHidHaarStageClassifier* stage_classifier; 109 sqsumtype *pq0, *pq1, *pq2, *pq3; 110 sumtype *p0, *p1, *p2, *p3; 111 112 void** ipp_stages; 113}; 114 115 116/* IPP functions for object detection */ 117icvHaarClassifierInitAlloc_32f_t icvHaarClassifierInitAlloc_32f_p = 0; 118icvHaarClassifierFree_32f_t icvHaarClassifierFree_32f_p = 0; 119icvApplyHaarClassifier_32f_C1R_t icvApplyHaarClassifier_32f_C1R_p = 0; 120icvRectStdDev_32f_C1R_t icvRectStdDev_32f_C1R_p = 0; 121 122const int icv_object_win_border = 1; 123const float icv_stage_threshold_bias = 0.0001f; 124 125static CvHaarClassifierCascade* 126icvCreateHaarClassifierCascade( int stage_count ) 127{ 128 CvHaarClassifierCascade* cascade = 0; 129 130 CV_FUNCNAME( "icvCreateHaarClassifierCascade" ); 131 132 __BEGIN__; 133 134 int block_size = sizeof(*cascade) + stage_count*sizeof(*cascade->stage_classifier); 135 136 if( stage_count <= 0 ) 137 CV_ERROR( CV_StsOutOfRange, "Number of stages should be positive" ); 138 139 CV_CALL( cascade = (CvHaarClassifierCascade*)cvAlloc( block_size )); 140 memset( cascade, 0, block_size ); 141 142 cascade->stage_classifier = (CvHaarStageClassifier*)(cascade + 1); 143 cascade->flags = CV_HAAR_MAGIC_VAL; 144 cascade->count = stage_count; 145 146 __END__; 147 148 return cascade; 149} 150 151static void 152icvReleaseHidHaarClassifierCascade( CvHidHaarClassifierCascade** _cascade ) 153{ 154 if( _cascade && *_cascade ) 155 { 156 CvHidHaarClassifierCascade* cascade = *_cascade; 157 if( cascade->ipp_stages && icvHaarClassifierFree_32f_p ) 158 { 159 int i; 160 for( i = 0; i < cascade->count; i++ ) 161 { 162 if( cascade->ipp_stages[i] ) 163 icvHaarClassifierFree_32f_p( cascade->ipp_stages[i] ); 164 } 165 } 166 cvFree( &cascade->ipp_stages ); 167 cvFree( _cascade ); 168 } 169} 170 171/* create more efficient internal representation of haar classifier cascade */ 172static CvHidHaarClassifierCascade* 173icvCreateHidHaarClassifierCascade( CvHaarClassifierCascade* cascade ) 174{ 175 CvRect* ipp_features = 0; 176 float *ipp_weights = 0, *ipp_thresholds = 0, *ipp_val1 = 0, *ipp_val2 = 0; 177 int* ipp_counts = 0; 178 179 CvHidHaarClassifierCascade* out = 0; 180 181 CV_FUNCNAME( "icvCreateHidHaarClassifierCascade" ); 182 183 __BEGIN__; 184 185 int i, j, k, l; 186 int datasize; 187 int total_classifiers = 0; 188 int total_nodes = 0; 189 char errorstr[100]; 190 CvHidHaarClassifier* haar_classifier_ptr; 191 CvHidHaarTreeNode* haar_node_ptr; 192 CvSize orig_window_size; 193 int has_tilted_features = 0; 194 int max_count = 0; 195 196 if( !CV_IS_HAAR_CLASSIFIER(cascade) ) 197 CV_ERROR( !cascade ? CV_StsNullPtr : CV_StsBadArg, "Invalid classifier pointer" ); 198 199 if( cascade->hid_cascade ) 200 CV_ERROR( CV_StsError, "hid_cascade has been already created" ); 201 202 if( !cascade->stage_classifier ) 203 CV_ERROR( CV_StsNullPtr, "" ); 204 205 if( cascade->count <= 0 ) 206 CV_ERROR( CV_StsOutOfRange, "Negative number of cascade stages" ); 207 208 orig_window_size = cascade->orig_window_size; 209 210 /* check input structure correctness and calculate total memory size needed for 211 internal representation of the classifier cascade */ 212 for( i = 0; i < cascade->count; i++ ) 213 { 214 CvHaarStageClassifier* stage_classifier = cascade->stage_classifier + i; 215 216 if( !stage_classifier->classifier || 217 stage_classifier->count <= 0 ) 218 { 219 sprintf( errorstr, "header of the stage classifier #%d is invalid " 220 "(has null pointers or non-positive classfier count)", i ); 221 CV_ERROR( CV_StsError, errorstr ); 222 } 223 224 max_count = MAX( max_count, stage_classifier->count ); 225 total_classifiers += stage_classifier->count; 226 227 for( j = 0; j < stage_classifier->count; j++ ) 228 { 229 CvHaarClassifier* classifier = stage_classifier->classifier + j; 230 231 total_nodes += classifier->count; 232 for( l = 0; l < classifier->count; l++ ) 233 { 234 for( k = 0; k < CV_HAAR_FEATURE_MAX; k++ ) 235 { 236 if( classifier->haar_feature[l].rect[k].r.width ) 237 { 238 CvRect r = classifier->haar_feature[l].rect[k].r; 239 int tilted = classifier->haar_feature[l].tilted; 240 has_tilted_features |= tilted != 0; 241 if( r.width < 0 || r.height < 0 || r.y < 0 || 242 r.x + r.width > orig_window_size.width 243 || 244 (!tilted && 245 (r.x < 0 || r.y + r.height > orig_window_size.height)) 246 || 247 (tilted && (r.x - r.height < 0 || 248 r.y + r.width + r.height > orig_window_size.height))) 249 { 250 sprintf( errorstr, "rectangle #%d of the classifier #%d of " 251 "the stage classifier #%d is not inside " 252 "the reference (original) cascade window", k, j, i ); 253 CV_ERROR( CV_StsNullPtr, errorstr ); 254 } 255 } 256 } 257 } 258 } 259 } 260 261 // this is an upper boundary for the whole hidden cascade size 262 datasize = sizeof(CvHidHaarClassifierCascade) + 263 sizeof(CvHidHaarStageClassifier)*cascade->count + 264 sizeof(CvHidHaarClassifier) * total_classifiers + 265 sizeof(CvHidHaarTreeNode) * total_nodes + 266 sizeof(void*)*(total_nodes + total_classifiers); 267 268 CV_CALL( out = (CvHidHaarClassifierCascade*)cvAlloc( datasize )); 269 memset( out, 0, sizeof(*out) ); 270 271 /* init header */ 272 out->count = cascade->count; 273 out->stage_classifier = (CvHidHaarStageClassifier*)(out + 1); 274 haar_classifier_ptr = (CvHidHaarClassifier*)(out->stage_classifier + cascade->count); 275 haar_node_ptr = (CvHidHaarTreeNode*)(haar_classifier_ptr + total_classifiers); 276 277 out->is_stump_based = 1; 278 out->has_tilted_features = has_tilted_features; 279 out->is_tree = 0; 280 281 /* initialize internal representation */ 282 for( i = 0; i < cascade->count; i++ ) 283 { 284 CvHaarStageClassifier* stage_classifier = cascade->stage_classifier + i; 285 CvHidHaarStageClassifier* hid_stage_classifier = out->stage_classifier + i; 286 287 hid_stage_classifier->count = stage_classifier->count; 288 hid_stage_classifier->threshold = stage_classifier->threshold - icv_stage_threshold_bias; 289 hid_stage_classifier->classifier = haar_classifier_ptr; 290 hid_stage_classifier->two_rects = 1; 291 haar_classifier_ptr += stage_classifier->count; 292 293 hid_stage_classifier->parent = (stage_classifier->parent == -1) 294 ? NULL : out->stage_classifier + stage_classifier->parent; 295 hid_stage_classifier->next = (stage_classifier->next == -1) 296 ? NULL : out->stage_classifier + stage_classifier->next; 297 hid_stage_classifier->child = (stage_classifier->child == -1) 298 ? NULL : out->stage_classifier + stage_classifier->child; 299 300 out->is_tree |= hid_stage_classifier->next != NULL; 301 302 for( j = 0; j < stage_classifier->count; j++ ) 303 { 304 CvHaarClassifier* classifier = stage_classifier->classifier + j; 305 CvHidHaarClassifier* hid_classifier = hid_stage_classifier->classifier + j; 306 int node_count = classifier->count; 307 float* alpha_ptr = (float*)(haar_node_ptr + node_count); 308 309 hid_classifier->count = node_count; 310 hid_classifier->node = haar_node_ptr; 311 hid_classifier->alpha = alpha_ptr; 312 313 for( l = 0; l < node_count; l++ ) 314 { 315 CvHidHaarTreeNode* node = hid_classifier->node + l; 316 CvHaarFeature* feature = classifier->haar_feature + l; 317 memset( node, -1, sizeof(*node) ); 318 node->threshold = classifier->threshold[l]; 319 node->left = classifier->left[l]; 320 node->right = classifier->right[l]; 321 322 if( fabs(feature->rect[2].weight) < DBL_EPSILON || 323 feature->rect[2].r.width == 0 || 324 feature->rect[2].r.height == 0 ) 325 memset( &(node->feature.rect[2]), 0, sizeof(node->feature.rect[2]) ); 326 else 327 hid_stage_classifier->two_rects = 0; 328 } 329 330 memcpy( alpha_ptr, classifier->alpha, (node_count+1)*sizeof(alpha_ptr[0])); 331 haar_node_ptr = 332 (CvHidHaarTreeNode*)cvAlignPtr(alpha_ptr+node_count+1, sizeof(void*)); 333 334 out->is_stump_based &= node_count == 1; 335 } 336 } 337 338 { 339 int can_use_ipp = icvHaarClassifierInitAlloc_32f_p != 0 && 340 icvHaarClassifierFree_32f_p != 0 && 341 icvApplyHaarClassifier_32f_C1R_p != 0 && 342 icvRectStdDev_32f_C1R_p != 0 && 343 !out->has_tilted_features && !out->is_tree && out->is_stump_based; 344 345 if( can_use_ipp ) 346 { 347 int ipp_datasize = cascade->count*sizeof(out->ipp_stages[0]); 348 float ipp_weight_scale=(float)(1./((orig_window_size.width-icv_object_win_border*2)* 349 (orig_window_size.height-icv_object_win_border*2))); 350 351 CV_CALL( out->ipp_stages = (void**)cvAlloc( ipp_datasize )); 352 memset( out->ipp_stages, 0, ipp_datasize ); 353 354 CV_CALL( ipp_features = (CvRect*)cvAlloc( max_count*3*sizeof(ipp_features[0]) )); 355 CV_CALL( ipp_weights = (float*)cvAlloc( max_count*3*sizeof(ipp_weights[0]) )); 356 CV_CALL( ipp_thresholds = (float*)cvAlloc( max_count*sizeof(ipp_thresholds[0]) )); 357 CV_CALL( ipp_val1 = (float*)cvAlloc( max_count*sizeof(ipp_val1[0]) )); 358 CV_CALL( ipp_val2 = (float*)cvAlloc( max_count*sizeof(ipp_val2[0]) )); 359 CV_CALL( ipp_counts = (int*)cvAlloc( max_count*sizeof(ipp_counts[0]) )); 360 361 for( i = 0; i < cascade->count; i++ ) 362 { 363 CvHaarStageClassifier* stage_classifier = cascade->stage_classifier + i; 364 for( j = 0, k = 0; j < stage_classifier->count; j++ ) 365 { 366 CvHaarClassifier* classifier = stage_classifier->classifier + j; 367 int rect_count = 2 + (classifier->haar_feature->rect[2].r.width != 0); 368 369 ipp_thresholds[j] = classifier->threshold[0]; 370 ipp_val1[j] = classifier->alpha[0]; 371 ipp_val2[j] = classifier->alpha[1]; 372 ipp_counts[j] = rect_count; 373 374 for( l = 0; l < rect_count; l++, k++ ) 375 { 376 ipp_features[k] = classifier->haar_feature->rect[l].r; 377 //ipp_features[k].y = orig_window_size.height - ipp_features[k].y - ipp_features[k].height; 378 ipp_weights[k] = classifier->haar_feature->rect[l].weight*ipp_weight_scale; 379 } 380 } 381 382 if( icvHaarClassifierInitAlloc_32f_p( &out->ipp_stages[i], 383 ipp_features, ipp_weights, ipp_thresholds, 384 ipp_val1, ipp_val2, ipp_counts, stage_classifier->count ) < 0 ) 385 break; 386 } 387 388 if( i < cascade->count ) 389 { 390 for( j = 0; j < i; j++ ) 391 if( icvHaarClassifierFree_32f_p && out->ipp_stages[i] ) 392 icvHaarClassifierFree_32f_p( out->ipp_stages[i] ); 393 cvFree( &out->ipp_stages ); 394 } 395 } 396 } 397 398 cascade->hid_cascade = out; 399 assert( (char*)haar_node_ptr - (char*)out <= datasize ); 400 401 __END__; 402 403 if( cvGetErrStatus() < 0 ) 404 icvReleaseHidHaarClassifierCascade( &out ); 405 406 cvFree( &ipp_features ); 407 cvFree( &ipp_weights ); 408 cvFree( &ipp_thresholds ); 409 cvFree( &ipp_val1 ); 410 cvFree( &ipp_val2 ); 411 cvFree( &ipp_counts ); 412 413 return out; 414} 415 416 417#define sum_elem_ptr(sum,row,col) \ 418 ((sumtype*)CV_MAT_ELEM_PTR_FAST((sum),(row),(col),sizeof(sumtype))) 419 420#define sqsum_elem_ptr(sqsum,row,col) \ 421 ((sqsumtype*)CV_MAT_ELEM_PTR_FAST((sqsum),(row),(col),sizeof(sqsumtype))) 422 423#define calc_sum(rect,offset) \ 424 ((rect).p0[offset] - (rect).p1[offset] - (rect).p2[offset] + (rect).p3[offset]) 425 426 427CV_IMPL void 428cvSetImagesForHaarClassifierCascade( CvHaarClassifierCascade* _cascade, 429 const CvArr* _sum, 430 const CvArr* _sqsum, 431 const CvArr* _tilted_sum, 432 double scale ) 433{ 434 CV_FUNCNAME("cvSetImagesForHaarClassifierCascade"); 435 436 __BEGIN__; 437 438 CvMat sum_stub, *sum = (CvMat*)_sum; 439 CvMat sqsum_stub, *sqsum = (CvMat*)_sqsum; 440 CvMat tilted_stub, *tilted = (CvMat*)_tilted_sum; 441 CvHidHaarClassifierCascade* cascade; 442 int coi0 = 0, coi1 = 0; 443 int i; 444 CvRect equ_rect; 445 double weight_scale; 446 447 if( !CV_IS_HAAR_CLASSIFIER(_cascade) ) 448 CV_ERROR( !_cascade ? CV_StsNullPtr : CV_StsBadArg, "Invalid classifier pointer" ); 449 450 if( scale <= 0 ) 451 CV_ERROR( CV_StsOutOfRange, "Scale must be positive" ); 452 453 CV_CALL( sum = cvGetMat( sum, &sum_stub, &coi0 )); 454 CV_CALL( sqsum = cvGetMat( sqsum, &sqsum_stub, &coi1 )); 455 456 if( coi0 || coi1 ) 457 CV_ERROR( CV_BadCOI, "COI is not supported" ); 458 459 if( !CV_ARE_SIZES_EQ( sum, sqsum )) 460 CV_ERROR( CV_StsUnmatchedSizes, "All integral images must have the same size" ); 461 462 if( CV_MAT_TYPE(sqsum->type) != CV_64FC1 || 463 CV_MAT_TYPE(sum->type) != CV_32SC1 ) 464 CV_ERROR( CV_StsUnsupportedFormat, 465 "Only (32s, 64f, 32s) combination of (sum,sqsum,tilted_sum) formats is allowed" ); 466 467 if( !_cascade->hid_cascade ) 468 CV_CALL( icvCreateHidHaarClassifierCascade(_cascade) ); 469 470 cascade = _cascade->hid_cascade; 471 472 if( cascade->has_tilted_features ) 473 { 474 CV_CALL( tilted = cvGetMat( tilted, &tilted_stub, &coi1 )); 475 476 if( CV_MAT_TYPE(tilted->type) != CV_32SC1 ) 477 CV_ERROR( CV_StsUnsupportedFormat, 478 "Only (32s, 64f, 32s) combination of (sum,sqsum,tilted_sum) formats is allowed" ); 479 480 if( sum->step != tilted->step ) 481 CV_ERROR( CV_StsUnmatchedSizes, 482 "Sum and tilted_sum must have the same stride (step, widthStep)" ); 483 484 if( !CV_ARE_SIZES_EQ( sum, tilted )) 485 CV_ERROR( CV_StsUnmatchedSizes, "All integral images must have the same size" ); 486 cascade->tilted = *tilted; 487 } 488 489 _cascade->scale = scale; 490 _cascade->real_window_size.width = cvRound( _cascade->orig_window_size.width * scale ); 491 _cascade->real_window_size.height = cvRound( _cascade->orig_window_size.height * scale ); 492 493 cascade->sum = *sum; 494 cascade->sqsum = *sqsum; 495 496 equ_rect.x = equ_rect.y = cvRound(scale); 497 equ_rect.width = cvRound((_cascade->orig_window_size.width-2)*scale); 498 equ_rect.height = cvRound((_cascade->orig_window_size.height-2)*scale); 499 weight_scale = 1./(equ_rect.width*equ_rect.height); 500 cascade->inv_window_area = weight_scale; 501 502 cascade->p0 = sum_elem_ptr(*sum, equ_rect.y, equ_rect.x); 503 cascade->p1 = sum_elem_ptr(*sum, equ_rect.y, equ_rect.x + equ_rect.width ); 504 cascade->p2 = sum_elem_ptr(*sum, equ_rect.y + equ_rect.height, equ_rect.x ); 505 cascade->p3 = sum_elem_ptr(*sum, equ_rect.y + equ_rect.height, 506 equ_rect.x + equ_rect.width ); 507 508 cascade->pq0 = sqsum_elem_ptr(*sqsum, equ_rect.y, equ_rect.x); 509 cascade->pq1 = sqsum_elem_ptr(*sqsum, equ_rect.y, equ_rect.x + equ_rect.width ); 510 cascade->pq2 = sqsum_elem_ptr(*sqsum, equ_rect.y + equ_rect.height, equ_rect.x ); 511 cascade->pq3 = sqsum_elem_ptr(*sqsum, equ_rect.y + equ_rect.height, 512 equ_rect.x + equ_rect.width ); 513 514 /* init pointers in haar features according to real window size and 515 given image pointers */ 516 { 517#ifdef _OPENMP 518 int max_threads = cvGetNumThreads(); 519 #pragma omp parallel for num_threads(max_threads) schedule(dynamic) 520#endif // _OPENMP 521 for( i = 0; i < _cascade->count; i++ ) 522 { 523 int j, k, l; 524 for( j = 0; j < cascade->stage_classifier[i].count; j++ ) 525 { 526 for( l = 0; l < cascade->stage_classifier[i].classifier[j].count; l++ ) 527 { 528 CvHaarFeature* feature = 529 &_cascade->stage_classifier[i].classifier[j].haar_feature[l]; 530 /* CvHidHaarClassifier* classifier = 531 cascade->stage_classifier[i].classifier + j; */ 532 CvHidHaarFeature* hidfeature = 533 &cascade->stage_classifier[i].classifier[j].node[l].feature; 534 double sum0 = 0, area0 = 0; 535 CvRect r[3]; 536#if CV_ADJUST_FEATURES 537 int base_w = -1, base_h = -1; 538 int new_base_w = 0, new_base_h = 0; 539 int kx, ky; 540 int flagx = 0, flagy = 0; 541 int x0 = 0, y0 = 0; 542#endif 543 int nr; 544 545 /* align blocks */ 546 for( k = 0; k < CV_HAAR_FEATURE_MAX; k++ ) 547 { 548 if( !hidfeature->rect[k].p0 ) 549 break; 550#if CV_ADJUST_FEATURES 551 r[k] = feature->rect[k].r; 552 base_w = (int)CV_IMIN( (unsigned)base_w, (unsigned)(r[k].width-1) ); 553 base_w = (int)CV_IMIN( (unsigned)base_w, (unsigned)(r[k].x - r[0].x-1) ); 554 base_h = (int)CV_IMIN( (unsigned)base_h, (unsigned)(r[k].height-1) ); 555 base_h = (int)CV_IMIN( (unsigned)base_h, (unsigned)(r[k].y - r[0].y-1) ); 556#endif 557 } 558 559 nr = k; 560 561#if CV_ADJUST_FEATURES 562 base_w += 1; 563 base_h += 1; 564 kx = r[0].width / base_w; 565 ky = r[0].height / base_h; 566 567 if( kx <= 0 ) 568 { 569 flagx = 1; 570 new_base_w = cvRound( r[0].width * scale ) / kx; 571 x0 = cvRound( r[0].x * scale ); 572 } 573 574 if( ky <= 0 ) 575 { 576 flagy = 1; 577 new_base_h = cvRound( r[0].height * scale ) / ky; 578 y0 = cvRound( r[0].y * scale ); 579 } 580#endif 581 582 for( k = 0; k < nr; k++ ) 583 { 584 CvRect tr; 585 double correction_ratio; 586 587#if CV_ADJUST_FEATURES 588 if( flagx ) 589 { 590 tr.x = (r[k].x - r[0].x) * new_base_w / base_w + x0; 591 tr.width = r[k].width * new_base_w / base_w; 592 } 593 else 594#endif 595 { 596 tr.x = cvRound( r[k].x * scale ); 597 tr.width = cvRound( r[k].width * scale ); 598 } 599 600#if CV_ADJUST_FEATURES 601 if( flagy ) 602 { 603 tr.y = (r[k].y - r[0].y) * new_base_h / base_h + y0; 604 tr.height = r[k].height * new_base_h / base_h; 605 } 606 else 607#endif 608 { 609 tr.y = cvRound( r[k].y * scale ); 610 tr.height = cvRound( r[k].height * scale ); 611 } 612 613#if CV_ADJUST_WEIGHTS 614 { 615 // RAINER START 616 const float orig_feature_size = (float)(feature->rect[k].r.width)*feature->rect[k].r.height; 617 const float orig_norm_size = (float)(_cascade->orig_window_size.width)*(_cascade->orig_window_size.height); 618 const float feature_size = float(tr.width*tr.height); 619 //const float normSize = float(equ_rect.width*equ_rect.height); 620 float target_ratio = orig_feature_size / orig_norm_size; 621 //float isRatio = featureSize / normSize; 622 //correctionRatio = targetRatio / isRatio / normSize; 623 correction_ratio = target_ratio / feature_size; 624 // RAINER END 625 } 626#else 627 correction_ratio = weight_scale * (!feature->tilted ? 1 : 0.5); 628#endif 629 630 if( !feature->tilted ) 631 { 632 hidfeature->rect[k].p0 = sum_elem_ptr(*sum, tr.y, tr.x); 633 hidfeature->rect[k].p1 = sum_elem_ptr(*sum, tr.y, tr.x + tr.width); 634 hidfeature->rect[k].p2 = sum_elem_ptr(*sum, tr.y + tr.height, tr.x); 635 hidfeature->rect[k].p3 = sum_elem_ptr(*sum, tr.y + tr.height, tr.x + tr.width); 636 } 637 else 638 { 639 hidfeature->rect[k].p2 = sum_elem_ptr(*tilted, tr.y + tr.width, tr.x + tr.width); 640 hidfeature->rect[k].p3 = sum_elem_ptr(*tilted, tr.y + tr.width + tr.height, 641 tr.x + tr.width - tr.height); 642 hidfeature->rect[k].p0 = sum_elem_ptr(*tilted, tr.y, tr.x); 643 hidfeature->rect[k].p1 = sum_elem_ptr(*tilted, tr.y + tr.height, tr.x - tr.height); 644 } 645 646 hidfeature->rect[k].weight = (float)(feature->rect[k].weight * correction_ratio); 647 648 if( k == 0 ) 649 area0 = tr.width * tr.height; 650 else 651 sum0 += hidfeature->rect[k].weight * tr.width * tr.height; 652 } 653 654 hidfeature->rect[0].weight = (float)(-sum0/area0); 655 } /* l */ 656 } /* j */ 657 } 658 } 659 660 __END__; 661} 662 663 664CV_INLINE 665double icvEvalHidHaarClassifier( CvHidHaarClassifier* classifier, 666 double variance_norm_factor, 667 size_t p_offset ) 668{ 669 int idx = 0; 670 do 671 { 672 CvHidHaarTreeNode* node = classifier->node + idx; 673 double t = node->threshold * variance_norm_factor; 674 675 double sum = calc_sum(node->feature.rect[0],p_offset) * node->feature.rect[0].weight; 676 sum += calc_sum(node->feature.rect[1],p_offset) * node->feature.rect[1].weight; 677 678 if( node->feature.rect[2].p0 ) 679 sum += calc_sum(node->feature.rect[2],p_offset) * node->feature.rect[2].weight; 680 681 idx = sum < t ? node->left : node->right; 682 } 683 while( idx > 0 ); 684 return classifier->alpha[-idx]; 685} 686 687 688CV_IMPL int 689cvRunHaarClassifierCascade( CvHaarClassifierCascade* _cascade, 690 CvPoint pt, int start_stage ) 691{ 692 int result = -1; 693 CV_FUNCNAME("cvRunHaarClassifierCascade"); 694 695 __BEGIN__; 696 697 int p_offset, pq_offset; 698 int i, j; 699 double mean, variance_norm_factor; 700 CvHidHaarClassifierCascade* cascade; 701 702 if( !CV_IS_HAAR_CLASSIFIER(_cascade) ) 703 CV_ERROR( !_cascade ? CV_StsNullPtr : CV_StsBadArg, "Invalid cascade pointer" ); 704 705 cascade = _cascade->hid_cascade; 706 if( !cascade ) 707 CV_ERROR( CV_StsNullPtr, "Hidden cascade has not been created.\n" 708 "Use cvSetImagesForHaarClassifierCascade" ); 709 710 if( pt.x < 0 || pt.y < 0 || 711 pt.x + _cascade->real_window_size.width >= cascade->sum.width-2 || 712 pt.y + _cascade->real_window_size.height >= cascade->sum.height-2 ) 713 EXIT; 714 715 p_offset = pt.y * (cascade->sum.step/sizeof(sumtype)) + pt.x; 716 pq_offset = pt.y * (cascade->sqsum.step/sizeof(sqsumtype)) + pt.x; 717 mean = calc_sum(*cascade,p_offset)*cascade->inv_window_area; 718 variance_norm_factor = cascade->pq0[pq_offset] - cascade->pq1[pq_offset] - 719 cascade->pq2[pq_offset] + cascade->pq3[pq_offset]; 720 variance_norm_factor = variance_norm_factor*cascade->inv_window_area - mean*mean; 721 if( variance_norm_factor >= 0. ) 722 variance_norm_factor = sqrt(variance_norm_factor); 723 else 724 variance_norm_factor = 1.; 725 726 if( cascade->is_tree ) 727 { 728 CvHidHaarStageClassifier* ptr; 729 assert( start_stage == 0 ); 730 731 result = 1; 732 ptr = cascade->stage_classifier; 733 734 while( ptr ) 735 { 736 double stage_sum = 0; 737 738 for( j = 0; j < ptr->count; j++ ) 739 { 740 stage_sum += icvEvalHidHaarClassifier( ptr->classifier + j, 741 variance_norm_factor, p_offset ); 742 } 743 744 if( stage_sum >= ptr->threshold ) 745 { 746 ptr = ptr->child; 747 } 748 else 749 { 750 while( ptr && ptr->next == NULL ) ptr = ptr->parent; 751 if( ptr == NULL ) 752 { 753 result = 0; 754 EXIT; 755 } 756 ptr = ptr->next; 757 } 758 } 759 } 760 else if( cascade->is_stump_based ) 761 { 762 for( i = start_stage; i < cascade->count; i++ ) 763 { 764 double stage_sum = 0; 765 766 if( cascade->stage_classifier[i].two_rects ) 767 { 768 for( j = 0; j < cascade->stage_classifier[i].count; j++ ) 769 { 770 CvHidHaarClassifier* classifier = cascade->stage_classifier[i].classifier + j; 771 CvHidHaarTreeNode* node = classifier->node; 772 double sum, t = node->threshold*variance_norm_factor, a, b; 773 774 sum = calc_sum(node->feature.rect[0],p_offset) * node->feature.rect[0].weight; 775 sum += calc_sum(node->feature.rect[1],p_offset) * node->feature.rect[1].weight; 776 777 a = classifier->alpha[0]; 778 b = classifier->alpha[1]; 779 stage_sum += sum < t ? a : b; 780 } 781 } 782 else 783 { 784 for( j = 0; j < cascade->stage_classifier[i].count; j++ ) 785 { 786 CvHidHaarClassifier* classifier = cascade->stage_classifier[i].classifier + j; 787 CvHidHaarTreeNode* node = classifier->node; 788 double sum, t = node->threshold*variance_norm_factor, a, b; 789 790 sum = calc_sum(node->feature.rect[0],p_offset) * node->feature.rect[0].weight; 791 sum += calc_sum(node->feature.rect[1],p_offset) * node->feature.rect[1].weight; 792 793 if( node->feature.rect[2].p0 ) 794 sum += calc_sum(node->feature.rect[2],p_offset) * node->feature.rect[2].weight; 795 796 a = classifier->alpha[0]; 797 b = classifier->alpha[1]; 798 stage_sum += sum < t ? a : b; 799 } 800 } 801 802 if( stage_sum < cascade->stage_classifier[i].threshold ) 803 { 804 result = -i; 805 EXIT; 806 } 807 } 808 } 809 else 810 { 811 for( i = start_stage; i < cascade->count; i++ ) 812 { 813 double stage_sum = 0; 814 815 for( j = 0; j < cascade->stage_classifier[i].count; j++ ) 816 { 817 stage_sum += icvEvalHidHaarClassifier( 818 cascade->stage_classifier[i].classifier + j, 819 variance_norm_factor, p_offset ); 820 } 821 822 if( stage_sum < cascade->stage_classifier[i].threshold ) 823 { 824 result = -i; 825 EXIT; 826 } 827 } 828 } 829 830 result = 1; 831 832 __END__; 833 834 return result; 835} 836 837 838static int is_equal( const void* _r1, const void* _r2, void* ) 839{ 840 const CvRect* r1 = (const CvRect*)_r1; 841 const CvRect* r2 = (const CvRect*)_r2; 842 int distance = cvRound(r1->width*0.2); 843 844 return r2->x <= r1->x + distance && 845 r2->x >= r1->x - distance && 846 r2->y <= r1->y + distance && 847 r2->y >= r1->y - distance && 848 r2->width <= cvRound( r1->width * 1.2 ) && 849 cvRound( r2->width * 1.2 ) >= r1->width; 850} 851 852 853#define VERY_ROUGH_SEARCH 0 854 855CV_IMPL CvSeq* 856cvHaarDetectObjects( const CvArr* _img, 857 CvHaarClassifierCascade* cascade, 858 CvMemStorage* storage, double scale_factor, 859 int min_neighbors, int flags, CvSize min_size ) 860{ 861 int split_stage = 2; 862 863 CvMat stub, *img = (CvMat*)_img; 864 CvMat *temp = 0, *sum = 0, *tilted = 0, *sqsum = 0, *norm_img = 0, *sumcanny = 0, *img_small = 0; 865 CvSeq* result_seq = 0; 866 CvMemStorage* temp_storage = 0; 867 CvAvgComp* comps = 0; 868 CvSeq* seq_thread[CV_MAX_THREADS] = {0}; 869 int i, max_threads = 0; 870 871 CV_FUNCNAME( "cvHaarDetectObjects" ); 872 873 __BEGIN__; 874 875 CvSeq *seq = 0, *seq2 = 0, *idx_seq = 0, *big_seq = 0; 876 CvAvgComp result_comp = {{0,0,0,0},0}; 877 double factor; 878 int npass = 2, coi; 879 bool do_canny_pruning = (flags & CV_HAAR_DO_CANNY_PRUNING) != 0; 880 bool find_biggest_object = (flags & CV_HAAR_FIND_BIGGEST_OBJECT) != 0; 881 bool rough_search = (flags & CV_HAAR_DO_ROUGH_SEARCH) != 0; 882 883 if( !CV_IS_HAAR_CLASSIFIER(cascade) ) 884 CV_ERROR( !cascade ? CV_StsNullPtr : CV_StsBadArg, "Invalid classifier cascade" ); 885 886 if( !storage ) 887 CV_ERROR( CV_StsNullPtr, "Null storage pointer" ); 888 889 CV_CALL( img = cvGetMat( img, &stub, &coi )); 890 if( coi ) 891 CV_ERROR( CV_BadCOI, "COI is not supported" ); 892 893 if( CV_MAT_DEPTH(img->type) != CV_8U ) 894 CV_ERROR( CV_StsUnsupportedFormat, "Only 8-bit images are supported" ); 895 896 if( find_biggest_object ) 897 flags &= ~CV_HAAR_SCALE_IMAGE; 898 899 CV_CALL( temp = cvCreateMat( img->rows, img->cols, CV_8UC1 )); 900 CV_CALL( sum = cvCreateMat( img->rows + 1, img->cols + 1, CV_32SC1 )); 901 CV_CALL( sqsum = cvCreateMat( img->rows + 1, img->cols + 1, CV_64FC1 )); 902 CV_CALL( temp_storage = cvCreateChildMemStorage( storage )); 903 904 if( !cascade->hid_cascade ) 905 CV_CALL( icvCreateHidHaarClassifierCascade(cascade) ); 906 907 if( cascade->hid_cascade->has_tilted_features ) 908 tilted = cvCreateMat( img->rows + 1, img->cols + 1, CV_32SC1 ); 909 910 seq = cvCreateSeq( 0, sizeof(CvSeq), sizeof(CvRect), temp_storage ); 911 seq2 = cvCreateSeq( 0, sizeof(CvSeq), sizeof(CvAvgComp), temp_storage ); 912 result_seq = cvCreateSeq( 0, sizeof(CvSeq), sizeof(CvAvgComp), storage ); 913 914 max_threads = cvGetNumThreads(); 915 if( max_threads > 1 ) 916 for( i = 0; i < max_threads; i++ ) 917 { 918 CvMemStorage* temp_storage_thread; 919 CV_CALL( temp_storage_thread = cvCreateMemStorage(0)); 920 CV_CALL( seq_thread[i] = cvCreateSeq( 0, sizeof(CvSeq), 921 sizeof(CvRect), temp_storage_thread )); 922 } 923 else 924 seq_thread[0] = seq; 925 926 if( CV_MAT_CN(img->type) > 1 ) 927 { 928 cvCvtColor( img, temp, CV_BGR2GRAY ); 929 img = temp; 930 } 931 932 if( flags & CV_HAAR_FIND_BIGGEST_OBJECT ) 933 flags &= ~(CV_HAAR_SCALE_IMAGE|CV_HAAR_DO_CANNY_PRUNING); 934 935 if( flags & CV_HAAR_SCALE_IMAGE ) 936 { 937 CvSize win_size0 = cascade->orig_window_size; 938 int use_ipp = cascade->hid_cascade->ipp_stages != 0 && 939 icvApplyHaarClassifier_32f_C1R_p != 0; 940 941 if( use_ipp ) 942 CV_CALL( norm_img = cvCreateMat( img->rows, img->cols, CV_32FC1 )); 943 CV_CALL( img_small = cvCreateMat( img->rows + 1, img->cols + 1, CV_8UC1 )); 944 945 for( factor = 1; ; factor *= scale_factor ) 946 { 947 int strip_count, strip_size; 948 int ystep = factor > 2. ? 1 : 2; 949 CvSize win_size = { cvRound(win_size0.width*factor), 950 cvRound(win_size0.height*factor) }; 951 CvSize sz = { cvRound( img->cols/factor ), cvRound( img->rows/factor ) }; 952 CvSize sz1 = { sz.width - win_size0.width, sz.height - win_size0.height }; 953 CvRect equ_rect = { icv_object_win_border, icv_object_win_border, 954 win_size0.width - icv_object_win_border*2, 955 win_size0.height - icv_object_win_border*2 }; 956 CvMat img1, sum1, sqsum1, norm1, tilted1, mask1; 957 CvMat* _tilted = 0; 958 959 if( sz1.width <= 0 || sz1.height <= 0 ) 960 break; 961 if( win_size.width < min_size.width || win_size.height < min_size.height ) 962 continue; 963 964 img1 = cvMat( sz.height, sz.width, CV_8UC1, img_small->data.ptr ); 965 sum1 = cvMat( sz.height+1, sz.width+1, CV_32SC1, sum->data.ptr ); 966 sqsum1 = cvMat( sz.height+1, sz.width+1, CV_64FC1, sqsum->data.ptr ); 967 if( tilted ) 968 { 969 tilted1 = cvMat( sz.height+1, sz.width+1, CV_32SC1, tilted->data.ptr ); 970 _tilted = &tilted1; 971 } 972 norm1 = cvMat( sz1.height, sz1.width, CV_32FC1, norm_img ? norm_img->data.ptr : 0 ); 973 mask1 = cvMat( sz1.height, sz1.width, CV_8UC1, temp->data.ptr ); 974 975 cvResize( img, &img1, CV_INTER_LINEAR ); 976 cvIntegral( &img1, &sum1, &sqsum1, _tilted ); 977 978 if( max_threads > 1 ) 979 { 980 strip_count = MAX(MIN(sz1.height/ystep, max_threads*3), 1); 981 strip_size = (sz1.height + strip_count - 1)/strip_count; 982 strip_size = (strip_size / ystep)*ystep; 983 } 984 else 985 { 986 strip_count = 1; 987 strip_size = sz1.height; 988 } 989 990 if( !use_ipp ) 991 cvSetImagesForHaarClassifierCascade( cascade, &sum1, &sqsum1, 0, 1. ); 992 else 993 { 994 for( i = 0; i <= sz.height; i++ ) 995 { 996 const int* isum = (int*)(sum1.data.ptr + sum1.step*i); 997 float* fsum = (float*)isum; 998 const int FLT_DELTA = -(1 << 24); 999 int j; 1000 for( j = 0; j <= sz.width; j++ ) 1001 fsum[j] = (float)(isum[j] + FLT_DELTA); 1002 } 1003 } 1004 1005 #ifdef _OPENMP 1006 #pragma omp parallel for num_threads(max_threads) schedule(dynamic) 1007 #endif 1008 for( i = 0; i < strip_count; i++ ) 1009 { 1010 int thread_id = cvGetThreadNum(); 1011 int positive = 0; 1012 int y1 = i*strip_size, y2 = (i+1)*strip_size/* - ystep + 1*/; 1013 CvSize ssz; 1014 int x, y, j; 1015 if( i == strip_count - 1 || y2 > sz1.height ) 1016 y2 = sz1.height; 1017 ssz = cvSize(sz1.width, y2 - y1); 1018 1019 if( use_ipp ) 1020 { 1021 icvRectStdDev_32f_C1R_p( 1022 (float*)(sum1.data.ptr + y1*sum1.step), sum1.step, 1023 (double*)(sqsum1.data.ptr + y1*sqsum1.step), sqsum1.step, 1024 (float*)(norm1.data.ptr + y1*norm1.step), norm1.step, ssz, equ_rect ); 1025 1026 positive = (ssz.width/ystep)*((ssz.height + ystep-1)/ystep); 1027 memset( mask1.data.ptr + y1*mask1.step, ystep == 1, mask1.height*mask1.step); 1028 1029 if( ystep > 1 ) 1030 { 1031 for( y = y1, positive = 0; y < y2; y += ystep ) 1032 for( x = 0; x < ssz.width; x += ystep ) 1033 mask1.data.ptr[mask1.step*y + x] = (uchar)1; 1034 } 1035 1036 for( j = 0; j < cascade->count; j++ ) 1037 { 1038 if( icvApplyHaarClassifier_32f_C1R_p( 1039 (float*)(sum1.data.ptr + y1*sum1.step), sum1.step, 1040 (float*)(norm1.data.ptr + y1*norm1.step), norm1.step, 1041 mask1.data.ptr + y1*mask1.step, mask1.step, ssz, &positive, 1042 cascade->hid_cascade->stage_classifier[j].threshold, 1043 cascade->hid_cascade->ipp_stages[j]) < 0 ) 1044 { 1045 positive = 0; 1046 break; 1047 } 1048 if( positive <= 0 ) 1049 break; 1050 } 1051 } 1052 else 1053 { 1054 for( y = y1, positive = 0; y < y2; y += ystep ) 1055 for( x = 0; x < ssz.width; x += ystep ) 1056 { 1057 mask1.data.ptr[mask1.step*y + x] = 1058 cvRunHaarClassifierCascade( cascade, cvPoint(x,y), 0 ) > 0; 1059 positive += mask1.data.ptr[mask1.step*y + x]; 1060 } 1061 } 1062 1063 if( positive > 0 ) 1064 { 1065 for( y = y1; y < y2; y += ystep ) 1066 for( x = 0; x < ssz.width; x += ystep ) 1067 if( mask1.data.ptr[mask1.step*y + x] != 0 ) 1068 { 1069 CvRect obj_rect = { cvRound(x*factor), cvRound(y*factor), 1070 win_size.width, win_size.height }; 1071 cvSeqPush( seq_thread[thread_id], &obj_rect ); 1072 } 1073 } 1074 } 1075 1076 // gather the results 1077 if( max_threads > 1 ) 1078 for( i = 0; i < max_threads; i++ ) 1079 { 1080 CvSeq* s = seq_thread[i]; 1081 int j, total = s->total; 1082 CvSeqBlock* b = s->first; 1083 for( j = 0; j < total; j += b->count, b = b->next ) 1084 cvSeqPushMulti( seq, b->data, b->count ); 1085 } 1086 } 1087 } 1088 else 1089 { 1090 int n_factors = 0; 1091 CvRect scan_roi_rect = {0,0,0,0}; 1092 bool is_found = false, scan_roi = false; 1093 1094 cvIntegral( img, sum, sqsum, tilted ); 1095 1096 if( do_canny_pruning ) 1097 { 1098 sumcanny = cvCreateMat( img->rows + 1, img->cols + 1, CV_32SC1 ); 1099 cvCanny( img, temp, 0, 50, 3 ); 1100 cvIntegral( temp, sumcanny ); 1101 } 1102 1103 if( (unsigned)split_stage >= (unsigned)cascade->count || 1104 cascade->hid_cascade->is_tree ) 1105 { 1106 split_stage = cascade->count; 1107 npass = 1; 1108 } 1109 1110 for( n_factors = 0, factor = 1; 1111 factor*cascade->orig_window_size.width < img->cols - 10 && 1112 factor*cascade->orig_window_size.height < img->rows - 10; 1113 n_factors++, factor *= scale_factor ) 1114 ; 1115 1116 if( find_biggest_object ) 1117 { 1118 scale_factor = 1./scale_factor; 1119 factor *= scale_factor; 1120 big_seq = cvCreateSeq( 0, sizeof(CvSeq), sizeof(CvRect), temp_storage ); 1121 } 1122 else 1123 factor = 1; 1124 1125 for( ; n_factors-- > 0 && !is_found; factor *= scale_factor ) 1126 { 1127 const double ystep = MAX( 2, factor ); 1128 CvSize win_size = { cvRound( cascade->orig_window_size.width * factor ), 1129 cvRound( cascade->orig_window_size.height * factor )}; 1130 CvRect equ_rect = { 0, 0, 0, 0 }; 1131 int *p0 = 0, *p1 = 0, *p2 = 0, *p3 = 0; 1132 int *pq0 = 0, *pq1 = 0, *pq2 = 0, *pq3 = 0; 1133 int pass, stage_offset = 0; 1134 int start_x = 0, start_y = 0; 1135 int end_x = cvRound((img->cols - win_size.width) / ystep); 1136 int end_y = cvRound((img->rows - win_size.height) / ystep); 1137 1138 if( win_size.width < min_size.width || win_size.height < min_size.height ) 1139 { 1140 if( find_biggest_object ) 1141 break; 1142 continue; 1143 } 1144 1145 cvSetImagesForHaarClassifierCascade( cascade, sum, sqsum, tilted, factor ); 1146 cvZero( temp ); 1147 1148 if( do_canny_pruning ) 1149 { 1150 equ_rect.x = cvRound(win_size.width*0.15); 1151 equ_rect.y = cvRound(win_size.height*0.15); 1152 equ_rect.width = cvRound(win_size.width*0.7); 1153 equ_rect.height = cvRound(win_size.height*0.7); 1154 1155 p0 = (int*)(sumcanny->data.ptr + equ_rect.y*sumcanny->step) + equ_rect.x; 1156 p1 = (int*)(sumcanny->data.ptr + equ_rect.y*sumcanny->step) 1157 + equ_rect.x + equ_rect.width; 1158 p2 = (int*)(sumcanny->data.ptr + (equ_rect.y + equ_rect.height)*sumcanny->step) + equ_rect.x; 1159 p3 = (int*)(sumcanny->data.ptr + (equ_rect.y + equ_rect.height)*sumcanny->step) 1160 + equ_rect.x + equ_rect.width; 1161 1162 pq0 = (int*)(sum->data.ptr + equ_rect.y*sum->step) + equ_rect.x; 1163 pq1 = (int*)(sum->data.ptr + equ_rect.y*sum->step) 1164 + equ_rect.x + equ_rect.width; 1165 pq2 = (int*)(sum->data.ptr + (equ_rect.y + equ_rect.height)*sum->step) + equ_rect.x; 1166 pq3 = (int*)(sum->data.ptr + (equ_rect.y + equ_rect.height)*sum->step) 1167 + equ_rect.x + equ_rect.width; 1168 } 1169 1170 if( scan_roi ) 1171 { 1172 //adjust start_height and stop_height 1173 start_y = cvRound(scan_roi_rect.y / ystep); 1174 end_y = cvRound((scan_roi_rect.y + scan_roi_rect.height - win_size.height) / ystep); 1175 1176 start_x = cvRound(scan_roi_rect.x / ystep); 1177 end_x = cvRound((scan_roi_rect.x + scan_roi_rect.width - win_size.width) / ystep); 1178 } 1179 1180 cascade->hid_cascade->count = split_stage; 1181 1182 for( pass = 0; pass < npass; pass++ ) 1183 { 1184 #ifdef _OPENMP 1185 #pragma omp parallel for num_threads(max_threads) schedule(dynamic) 1186 #endif 1187 for( int _iy = start_y; _iy < end_y; _iy++ ) 1188 { 1189 int thread_id = cvGetThreadNum(); 1190 int iy = cvRound(_iy*ystep); 1191 int _ix, _xstep = 1; 1192 uchar* mask_row = temp->data.ptr + temp->step * iy; 1193 1194 for( _ix = start_x; _ix < end_x; _ix += _xstep ) 1195 { 1196 int ix = cvRound(_ix*ystep); // it really should be ystep 1197 1198 if( pass == 0 ) 1199 { 1200 int result; 1201 _xstep = 2; 1202 1203 if( do_canny_pruning ) 1204 { 1205 int offset; 1206 int s, sq; 1207 1208 offset = iy*(sum->step/sizeof(p0[0])) + ix; 1209 s = p0[offset] - p1[offset] - p2[offset] + p3[offset]; 1210 sq = pq0[offset] - pq1[offset] - pq2[offset] + pq3[offset]; 1211 if( s < 100 || sq < 20 ) 1212 continue; 1213 } 1214 1215 result = cvRunHaarClassifierCascade( cascade, cvPoint(ix,iy), 0 ); 1216 if( result > 0 ) 1217 { 1218 if( pass < npass - 1 ) 1219 mask_row[ix] = 1; 1220 else 1221 { 1222 CvRect rect = cvRect(ix,iy,win_size.width,win_size.height); 1223 cvSeqPush( seq_thread[thread_id], &rect ); 1224 } 1225 } 1226 if( result < 0 ) 1227 _xstep = 1; 1228 } 1229 else if( mask_row[ix] ) 1230 { 1231 int result = cvRunHaarClassifierCascade( cascade, cvPoint(ix,iy), 1232 stage_offset ); 1233 if( result > 0 ) 1234 { 1235 if( pass == npass - 1 ) 1236 { 1237 CvRect rect = cvRect(ix,iy,win_size.width,win_size.height); 1238 cvSeqPush( seq_thread[thread_id], &rect ); 1239 } 1240 } 1241 else 1242 mask_row[ix] = 0; 1243 } 1244 } 1245 } 1246 stage_offset = cascade->hid_cascade->count; 1247 cascade->hid_cascade->count = cascade->count; 1248 } 1249 1250 // gather the results 1251 if( max_threads > 1 ) 1252 for( i = 0; i < max_threads; i++ ) 1253 { 1254 CvSeq* s = seq_thread[i]; 1255 int j, total = s->total; 1256 CvSeqBlock* b = s->first; 1257 for( j = 0; j < total; j += b->count, b = b->next ) 1258 cvSeqPushMulti( seq, b->data, b->count ); 1259 } 1260 1261 if( find_biggest_object ) 1262 { 1263 CvSeq* bseq = min_neighbors > 0 ? big_seq : seq; 1264 1265 if( min_neighbors > 0 && !scan_roi ) 1266 { 1267 // group retrieved rectangles in order to filter out noise 1268 int ncomp = cvSeqPartition( seq, 0, &idx_seq, is_equal, 0 ); 1269 CV_CALL( comps = (CvAvgComp*)cvAlloc( (ncomp+1)*sizeof(comps[0]))); 1270 memset( comps, 0, (ncomp+1)*sizeof(comps[0])); 1271 1272 #if VERY_ROUGH_SEARCH 1273 if( rough_search ) 1274 { 1275 for( i = 0; i < seq->total; i++ ) 1276 { 1277 CvRect r1 = *(CvRect*)cvGetSeqElem( seq, i ); 1278 int idx = *(int*)cvGetSeqElem( idx_seq, i ); 1279 assert( (unsigned)idx < (unsigned)ncomp ); 1280 1281 comps[idx].neighbors++; 1282 comps[idx].rect.x += r1.x; 1283 comps[idx].rect.y += r1.y; 1284 comps[idx].rect.width += r1.width; 1285 comps[idx].rect.height += r1.height; 1286 } 1287 1288 // calculate average bounding box 1289 for( i = 0; i < ncomp; i++ ) 1290 { 1291 int n = comps[i].neighbors; 1292 if( n >= min_neighbors ) 1293 { 1294 CvAvgComp comp; 1295 comp.rect.x = (comps[i].rect.x*2 + n)/(2*n); 1296 comp.rect.y = (comps[i].rect.y*2 + n)/(2*n); 1297 comp.rect.width = (comps[i].rect.width*2 + n)/(2*n); 1298 comp.rect.height = (comps[i].rect.height*2 + n)/(2*n); 1299 comp.neighbors = n; 1300 cvSeqPush( bseq, &comp ); 1301 } 1302 } 1303 } 1304 else 1305 #endif 1306 { 1307 for( i = 0 ; i <= ncomp; i++ ) 1308 comps[i].rect.x = comps[i].rect.y = INT_MAX; 1309 1310 // count number of neighbors 1311 for( i = 0; i < seq->total; i++ ) 1312 { 1313 CvRect r1 = *(CvRect*)cvGetSeqElem( seq, i ); 1314 int idx = *(int*)cvGetSeqElem( idx_seq, i ); 1315 assert( (unsigned)idx < (unsigned)ncomp ); 1316 1317 comps[idx].neighbors++; 1318 1319 // rect.width and rect.height will store coordinate of right-bottom corner 1320 comps[idx].rect.x = MIN(comps[idx].rect.x, r1.x); 1321 comps[idx].rect.y = MIN(comps[idx].rect.y, r1.y); 1322 comps[idx].rect.width = MAX(comps[idx].rect.width, r1.x+r1.width-1); 1323 comps[idx].rect.height = MAX(comps[idx].rect.height, r1.y+r1.height-1); 1324 } 1325 1326 // calculate enclosing box 1327 for( i = 0; i < ncomp; i++ ) 1328 { 1329 int n = comps[i].neighbors; 1330 if( n >= min_neighbors ) 1331 { 1332 CvAvgComp comp; 1333 int t; 1334 double min_scale = rough_search ? 0.6 : 0.4; 1335 comp.rect.x = comps[i].rect.x; 1336 comp.rect.y = comps[i].rect.y; 1337 comp.rect.width = comps[i].rect.width - comps[i].rect.x + 1; 1338 comp.rect.height = comps[i].rect.height - comps[i].rect.y + 1; 1339 1340 // update min_size 1341 t = cvRound( comp.rect.width*min_scale ); 1342 min_size.width = MAX( min_size.width, t ); 1343 1344 t = cvRound( comp.rect.height*min_scale ); 1345 min_size.height = MAX( min_size.height, t ); 1346 1347 //expand the box by 20% because we could miss some neighbours 1348 //see 'is_equal' function 1349 #if 1 1350 int offset = cvRound(comp.rect.width * 0.2); 1351 int right = MIN( img->cols-1, comp.rect.x+comp.rect.width-1 + offset ); 1352 int bottom = MIN( img->rows-1, comp.rect.y+comp.rect.height-1 + offset); 1353 comp.rect.x = MAX( comp.rect.x - offset, 0 ); 1354 comp.rect.y = MAX( comp.rect.y - offset, 0 ); 1355 comp.rect.width = right - comp.rect.x + 1; 1356 comp.rect.height = bottom - comp.rect.y + 1; 1357 #endif 1358 1359 comp.neighbors = n; 1360 cvSeqPush( bseq, &comp ); 1361 } 1362 } 1363 } 1364 1365 cvFree( &comps ); 1366 } 1367 1368 // extract the biggest rect 1369 if( bseq->total > 0 ) 1370 { 1371 int max_area = 0; 1372 for( i = 0; i < bseq->total; i++ ) 1373 { 1374 CvAvgComp* comp = (CvAvgComp*)cvGetSeqElem( bseq, i ); 1375 int area = comp->rect.width * comp->rect.height; 1376 if( max_area < area ) 1377 { 1378 max_area = area; 1379 result_comp.rect = comp->rect; 1380 result_comp.neighbors = bseq == seq ? 1 : comp->neighbors; 1381 } 1382 } 1383 1384 //Prepare information for further scanning inside the biggest rectangle 1385 1386 #if VERY_ROUGH_SEARCH 1387 // change scan ranges to roi in case of required 1388 if( !rough_search && !scan_roi ) 1389 { 1390 scan_roi = true; 1391 scan_roi_rect = result_comp.rect; 1392 cvClearSeq(bseq); 1393 } 1394 else if( rough_search ) 1395 is_found = true; 1396 #else 1397 if( !scan_roi ) 1398 { 1399 scan_roi = true; 1400 scan_roi_rect = result_comp.rect; 1401 cvClearSeq(bseq); 1402 } 1403 #endif 1404 } 1405 } 1406 } 1407 } 1408 1409 if( min_neighbors == 0 && !find_biggest_object ) 1410 { 1411 for( i = 0; i < seq->total; i++ ) 1412 { 1413 CvRect* rect = (CvRect*)cvGetSeqElem( seq, i ); 1414 CvAvgComp comp; 1415 comp.rect = *rect; 1416 comp.neighbors = 1; 1417 cvSeqPush( result_seq, &comp ); 1418 } 1419 } 1420 1421 if( min_neighbors != 0 1422#if VERY_ROUGH_SEARCH 1423 && (!find_biggest_object || !rough_search) 1424#endif 1425 ) 1426 { 1427 // group retrieved rectangles in order to filter out noise 1428 int ncomp = cvSeqPartition( seq, 0, &idx_seq, is_equal, 0 ); 1429 CV_CALL( comps = (CvAvgComp*)cvAlloc( (ncomp+1)*sizeof(comps[0]))); 1430 memset( comps, 0, (ncomp+1)*sizeof(comps[0])); 1431 1432 // count number of neighbors 1433 for( i = 0; i < seq->total; i++ ) 1434 { 1435 CvRect r1 = *(CvRect*)cvGetSeqElem( seq, i ); 1436 int idx = *(int*)cvGetSeqElem( idx_seq, i ); 1437 assert( (unsigned)idx < (unsigned)ncomp ); 1438 1439 comps[idx].neighbors++; 1440 1441 comps[idx].rect.x += r1.x; 1442 comps[idx].rect.y += r1.y; 1443 comps[idx].rect.width += r1.width; 1444 comps[idx].rect.height += r1.height; 1445 } 1446 1447 // calculate average bounding box 1448 for( i = 0; i < ncomp; i++ ) 1449 { 1450 int n = comps[i].neighbors; 1451 if( n >= min_neighbors ) 1452 { 1453 CvAvgComp comp; 1454 comp.rect.x = (comps[i].rect.x*2 + n)/(2*n); 1455 comp.rect.y = (comps[i].rect.y*2 + n)/(2*n); 1456 comp.rect.width = (comps[i].rect.width*2 + n)/(2*n); 1457 comp.rect.height = (comps[i].rect.height*2 + n)/(2*n); 1458 comp.neighbors = comps[i].neighbors; 1459 1460 cvSeqPush( seq2, &comp ); 1461 } 1462 } 1463 1464 if( !find_biggest_object ) 1465 { 1466 // filter out small face rectangles inside large face rectangles 1467 for( i = 0; i < seq2->total; i++ ) 1468 { 1469 CvAvgComp r1 = *(CvAvgComp*)cvGetSeqElem( seq2, i ); 1470 int j, flag = 1; 1471 1472 for( j = 0; j < seq2->total; j++ ) 1473 { 1474 CvAvgComp r2 = *(CvAvgComp*)cvGetSeqElem( seq2, j ); 1475 int distance = cvRound( r2.rect.width * 0.2 ); 1476 1477 if( i != j && 1478 r1.rect.x >= r2.rect.x - distance && 1479 r1.rect.y >= r2.rect.y - distance && 1480 r1.rect.x + r1.rect.width <= r2.rect.x + r2.rect.width + distance && 1481 r1.rect.y + r1.rect.height <= r2.rect.y + r2.rect.height + distance && 1482 (r2.neighbors > MAX( 3, r1.neighbors ) || r1.neighbors < 3) ) 1483 { 1484 flag = 0; 1485 break; 1486 } 1487 } 1488 1489 if( flag ) 1490 cvSeqPush( result_seq, &r1 ); 1491 } 1492 } 1493 else 1494 { 1495 int max_area = 0; 1496 for( i = 0; i < seq2->total; i++ ) 1497 { 1498 CvAvgComp* comp = (CvAvgComp*)cvGetSeqElem( seq2, i ); 1499 int area = comp->rect.width * comp->rect.height; 1500 if( max_area < area ) 1501 { 1502 max_area = area; 1503 result_comp = *comp; 1504 } 1505 } 1506 } 1507 } 1508 1509 if( find_biggest_object && result_comp.rect.width > 0 ) 1510 cvSeqPush( result_seq, &result_comp ); 1511 1512 __END__; 1513 1514 if( max_threads > 1 ) 1515 for( i = 0; i < max_threads; i++ ) 1516 { 1517 if( seq_thread[i] ) 1518 cvReleaseMemStorage( &seq_thread[i]->storage ); 1519 } 1520 1521 cvReleaseMemStorage( &temp_storage ); 1522 cvReleaseMat( &sum ); 1523 cvReleaseMat( &sqsum ); 1524 cvReleaseMat( &tilted ); 1525 cvReleaseMat( &temp ); 1526 cvReleaseMat( &sumcanny ); 1527 cvReleaseMat( &norm_img ); 1528 cvReleaseMat( &img_small ); 1529 cvFree( &comps ); 1530 1531 return result_seq; 1532} 1533 1534 1535static CvHaarClassifierCascade* 1536icvLoadCascadeCART( const char** input_cascade, int n, CvSize orig_window_size ) 1537{ 1538 int i; 1539 CvHaarClassifierCascade* cascade = icvCreateHaarClassifierCascade(n); 1540 cascade->orig_window_size = orig_window_size; 1541 1542 for( i = 0; i < n; i++ ) 1543 { 1544 int j, count, l; 1545 float threshold = 0; 1546 const char* stage = input_cascade[i]; 1547 int dl = 0; 1548 1549 /* tree links */ 1550 int parent = -1; 1551 int next = -1; 1552 1553 sscanf( stage, "%d%n", &count, &dl ); 1554 stage += dl; 1555 1556 assert( count > 0 ); 1557 cascade->stage_classifier[i].count = count; 1558 cascade->stage_classifier[i].classifier = 1559 (CvHaarClassifier*)cvAlloc( count*sizeof(cascade->stage_classifier[i].classifier[0])); 1560 1561 for( j = 0; j < count; j++ ) 1562 { 1563 CvHaarClassifier* classifier = cascade->stage_classifier[i].classifier + j; 1564 int k, rects = 0; 1565 char str[100]; 1566 1567 sscanf( stage, "%d%n", &classifier->count, &dl ); 1568 stage += dl; 1569 1570 classifier->haar_feature = (CvHaarFeature*) cvAlloc( 1571 classifier->count * ( sizeof( *classifier->haar_feature ) + 1572 sizeof( *classifier->threshold ) + 1573 sizeof( *classifier->left ) + 1574 sizeof( *classifier->right ) ) + 1575 (classifier->count + 1) * sizeof( *classifier->alpha ) ); 1576 classifier->threshold = (float*) (classifier->haar_feature+classifier->count); 1577 classifier->left = (int*) (classifier->threshold + classifier->count); 1578 classifier->right = (int*) (classifier->left + classifier->count); 1579 classifier->alpha = (float*) (classifier->right + classifier->count); 1580 1581 for( l = 0; l < classifier->count; l++ ) 1582 { 1583 sscanf( stage, "%d%n", &rects, &dl ); 1584 stage += dl; 1585 1586 assert( rects >= 2 && rects <= CV_HAAR_FEATURE_MAX ); 1587 1588 for( k = 0; k < rects; k++ ) 1589 { 1590 CvRect r; 1591 int band = 0; 1592 sscanf( stage, "%d%d%d%d%d%f%n", 1593 &r.x, &r.y, &r.width, &r.height, &band, 1594 &(classifier->haar_feature[l].rect[k].weight), &dl ); 1595 stage += dl; 1596 classifier->haar_feature[l].rect[k].r = r; 1597 } 1598 sscanf( stage, "%s%n", str, &dl ); 1599 stage += dl; 1600 1601 classifier->haar_feature[l].tilted = strncmp( str, "tilted", 6 ) == 0; 1602 1603 for( k = rects; k < CV_HAAR_FEATURE_MAX; k++ ) 1604 { 1605 memset( classifier->haar_feature[l].rect + k, 0, 1606 sizeof(classifier->haar_feature[l].rect[k]) ); 1607 } 1608 1609 sscanf( stage, "%f%d%d%n", &(classifier->threshold[l]), 1610 &(classifier->left[l]), 1611 &(classifier->right[l]), &dl ); 1612 stage += dl; 1613 } 1614 for( l = 0; l <= classifier->count; l++ ) 1615 { 1616 sscanf( stage, "%f%n", &(classifier->alpha[l]), &dl ); 1617 stage += dl; 1618 } 1619 } 1620 1621 sscanf( stage, "%f%n", &threshold, &dl ); 1622 stage += dl; 1623 1624 cascade->stage_classifier[i].threshold = threshold; 1625 1626 /* load tree links */ 1627 if( sscanf( stage, "%d%d%n", &parent, &next, &dl ) != 2 ) 1628 { 1629 parent = i - 1; 1630 next = -1; 1631 } 1632 stage += dl; 1633 1634 cascade->stage_classifier[i].parent = parent; 1635 cascade->stage_classifier[i].next = next; 1636 cascade->stage_classifier[i].child = -1; 1637 1638 if( parent != -1 && cascade->stage_classifier[parent].child == -1 ) 1639 { 1640 cascade->stage_classifier[parent].child = i; 1641 } 1642 } 1643 1644 return cascade; 1645} 1646 1647#ifndef _MAX_PATH 1648#define _MAX_PATH 1024 1649#endif 1650 1651CV_IMPL CvHaarClassifierCascade* 1652cvLoadHaarClassifierCascade( const char* directory, CvSize orig_window_size ) 1653{ 1654 const char** input_cascade = 0; 1655 CvHaarClassifierCascade *cascade = 0; 1656 1657 CV_FUNCNAME( "cvLoadHaarClassifierCascade" ); 1658 1659 __BEGIN__; 1660 1661 int i, n; 1662 const char* slash; 1663 char name[_MAX_PATH]; 1664 int size = 0; 1665 char* ptr = 0; 1666 1667 if( !directory ) 1668 CV_ERROR( CV_StsNullPtr, "Null path is passed" ); 1669 1670 n = (int)strlen(directory)-1; 1671 slash = directory[n] == '\\' || directory[n] == '/' ? "" : "/"; 1672 1673 /* try to read the classifier from directory */ 1674 for( n = 0; ; n++ ) 1675 { 1676 sprintf( name, "%s%s%d/AdaBoostCARTHaarClassifier.txt", directory, slash, n ); 1677 FILE* f = fopen( name, "rb" ); 1678 if( !f ) 1679 break; 1680 fseek( f, 0, SEEK_END ); 1681 size += ftell( f ) + 1; 1682 fclose(f); 1683 } 1684 1685 if( n == 0 && slash[0] ) 1686 { 1687 CV_CALL( cascade = (CvHaarClassifierCascade*)cvLoad( directory )); 1688 EXIT; 1689 } 1690 else if( n == 0 ) 1691 CV_ERROR( CV_StsBadArg, "Invalid path" ); 1692 1693 size += (n+1)*sizeof(char*); 1694 CV_CALL( input_cascade = (const char**)cvAlloc( size )); 1695 ptr = (char*)(input_cascade + n + 1); 1696 1697 for( i = 0; i < n; i++ ) 1698 { 1699 sprintf( name, "%s/%d/AdaBoostCARTHaarClassifier.txt", directory, i ); 1700 FILE* f = fopen( name, "rb" ); 1701 if( !f ) 1702 CV_ERROR( CV_StsError, "" ); 1703 fseek( f, 0, SEEK_END ); 1704 size = ftell( f ); 1705 fseek( f, 0, SEEK_SET ); 1706 fread( ptr, 1, size, f ); 1707 fclose(f); 1708 input_cascade[i] = ptr; 1709 ptr += size; 1710 *ptr++ = '\0'; 1711 } 1712 1713 input_cascade[n] = 0; 1714 cascade = icvLoadCascadeCART( input_cascade, n, orig_window_size ); 1715 1716 __END__; 1717 1718 if( input_cascade ) 1719 cvFree( &input_cascade ); 1720 1721 if( cvGetErrStatus() < 0 ) 1722 cvReleaseHaarClassifierCascade( &cascade ); 1723 1724 return cascade; 1725} 1726 1727 1728CV_IMPL void 1729cvReleaseHaarClassifierCascade( CvHaarClassifierCascade** _cascade ) 1730{ 1731 if( _cascade && *_cascade ) 1732 { 1733 int i, j; 1734 CvHaarClassifierCascade* cascade = *_cascade; 1735 1736 for( i = 0; i < cascade->count; i++ ) 1737 { 1738 for( j = 0; j < cascade->stage_classifier[i].count; j++ ) 1739 cvFree( &cascade->stage_classifier[i].classifier[j].haar_feature ); 1740 cvFree( &cascade->stage_classifier[i].classifier ); 1741 } 1742 icvReleaseHidHaarClassifierCascade( &cascade->hid_cascade ); 1743 cvFree( _cascade ); 1744 } 1745} 1746 1747 1748/****************************************************************************************\ 1749* Persistence functions * 1750\****************************************************************************************/ 1751 1752/* field names */ 1753 1754#define ICV_HAAR_SIZE_NAME "size" 1755#define ICV_HAAR_STAGES_NAME "stages" 1756#define ICV_HAAR_TREES_NAME "trees" 1757#define ICV_HAAR_FEATURE_NAME "feature" 1758#define ICV_HAAR_RECTS_NAME "rects" 1759#define ICV_HAAR_TILTED_NAME "tilted" 1760#define ICV_HAAR_THRESHOLD_NAME "threshold" 1761#define ICV_HAAR_LEFT_NODE_NAME "left_node" 1762#define ICV_HAAR_LEFT_VAL_NAME "left_val" 1763#define ICV_HAAR_RIGHT_NODE_NAME "right_node" 1764#define ICV_HAAR_RIGHT_VAL_NAME "right_val" 1765#define ICV_HAAR_STAGE_THRESHOLD_NAME "stage_threshold" 1766#define ICV_HAAR_PARENT_NAME "parent" 1767#define ICV_HAAR_NEXT_NAME "next" 1768 1769static int 1770icvIsHaarClassifier( const void* struct_ptr ) 1771{ 1772 return CV_IS_HAAR_CLASSIFIER( struct_ptr ); 1773} 1774 1775static void* 1776icvReadHaarClassifier( CvFileStorage* fs, CvFileNode* node ) 1777{ 1778 CvHaarClassifierCascade* cascade = NULL; 1779 1780 CV_FUNCNAME( "cvReadHaarClassifier" ); 1781 1782 __BEGIN__; 1783 1784 char buf[256]; 1785 CvFileNode* seq_fn = NULL; /* sequence */ 1786 CvFileNode* fn = NULL; 1787 CvFileNode* stages_fn = NULL; 1788 CvSeqReader stages_reader; 1789 int n; 1790 int i, j, k, l; 1791 int parent, next; 1792 1793 CV_CALL( stages_fn = cvGetFileNodeByName( fs, node, ICV_HAAR_STAGES_NAME ) ); 1794 if( !stages_fn || !CV_NODE_IS_SEQ( stages_fn->tag) ) 1795 CV_ERROR( CV_StsError, "Invalid stages node" ); 1796 1797 n = stages_fn->data.seq->total; 1798 CV_CALL( cascade = icvCreateHaarClassifierCascade(n) ); 1799 1800 /* read size */ 1801 CV_CALL( seq_fn = cvGetFileNodeByName( fs, node, ICV_HAAR_SIZE_NAME ) ); 1802 if( !seq_fn || !CV_NODE_IS_SEQ( seq_fn->tag ) || seq_fn->data.seq->total != 2 ) 1803 CV_ERROR( CV_StsError, "size node is not a valid sequence." ); 1804 CV_CALL( fn = (CvFileNode*) cvGetSeqElem( seq_fn->data.seq, 0 ) ); 1805 if( !CV_NODE_IS_INT( fn->tag ) || fn->data.i <= 0 ) 1806 CV_ERROR( CV_StsError, "Invalid size node: width must be positive integer" ); 1807 cascade->orig_window_size.width = fn->data.i; 1808 CV_CALL( fn = (CvFileNode*) cvGetSeqElem( seq_fn->data.seq, 1 ) ); 1809 if( !CV_NODE_IS_INT( fn->tag ) || fn->data.i <= 0 ) 1810 CV_ERROR( CV_StsError, "Invalid size node: height must be positive integer" ); 1811 cascade->orig_window_size.height = fn->data.i; 1812 1813 CV_CALL( cvStartReadSeq( stages_fn->data.seq, &stages_reader ) ); 1814 for( i = 0; i < n; ++i ) 1815 { 1816 CvFileNode* stage_fn; 1817 CvFileNode* trees_fn; 1818 CvSeqReader trees_reader; 1819 1820 stage_fn = (CvFileNode*) stages_reader.ptr; 1821 if( !CV_NODE_IS_MAP( stage_fn->tag ) ) 1822 { 1823 sprintf( buf, "Invalid stage %d", i ); 1824 CV_ERROR( CV_StsError, buf ); 1825 } 1826 1827 CV_CALL( trees_fn = cvGetFileNodeByName( fs, stage_fn, ICV_HAAR_TREES_NAME ) ); 1828 if( !trees_fn || !CV_NODE_IS_SEQ( trees_fn->tag ) 1829 || trees_fn->data.seq->total <= 0 ) 1830 { 1831 sprintf( buf, "Trees node is not a valid sequence. (stage %d)", i ); 1832 CV_ERROR( CV_StsError, buf ); 1833 } 1834 1835 CV_CALL( cascade->stage_classifier[i].classifier = 1836 (CvHaarClassifier*) cvAlloc( trees_fn->data.seq->total 1837 * sizeof( cascade->stage_classifier[i].classifier[0] ) ) ); 1838 for( j = 0; j < trees_fn->data.seq->total; ++j ) 1839 { 1840 cascade->stage_classifier[i].classifier[j].haar_feature = NULL; 1841 } 1842 cascade->stage_classifier[i].count = trees_fn->data.seq->total; 1843 1844 CV_CALL( cvStartReadSeq( trees_fn->data.seq, &trees_reader ) ); 1845 for( j = 0; j < trees_fn->data.seq->total; ++j ) 1846 { 1847 CvFileNode* tree_fn; 1848 CvSeqReader tree_reader; 1849 CvHaarClassifier* classifier; 1850 int last_idx; 1851 1852 classifier = &cascade->stage_classifier[i].classifier[j]; 1853 tree_fn = (CvFileNode*) trees_reader.ptr; 1854 if( !CV_NODE_IS_SEQ( tree_fn->tag ) || tree_fn->data.seq->total <= 0 ) 1855 { 1856 sprintf( buf, "Tree node is not a valid sequence." 1857 " (stage %d, tree %d)", i, j ); 1858 CV_ERROR( CV_StsError, buf ); 1859 } 1860 1861 classifier->count = tree_fn->data.seq->total; 1862 CV_CALL( classifier->haar_feature = (CvHaarFeature*) cvAlloc( 1863 classifier->count * ( sizeof( *classifier->haar_feature ) + 1864 sizeof( *classifier->threshold ) + 1865 sizeof( *classifier->left ) + 1866 sizeof( *classifier->right ) ) + 1867 (classifier->count + 1) * sizeof( *classifier->alpha ) ) ); 1868 classifier->threshold = (float*) (classifier->haar_feature+classifier->count); 1869 classifier->left = (int*) (classifier->threshold + classifier->count); 1870 classifier->right = (int*) (classifier->left + classifier->count); 1871 classifier->alpha = (float*) (classifier->right + classifier->count); 1872 1873 CV_CALL( cvStartReadSeq( tree_fn->data.seq, &tree_reader ) ); 1874 for( k = 0, last_idx = 0; k < tree_fn->data.seq->total; ++k ) 1875 { 1876 CvFileNode* node_fn; 1877 CvFileNode* feature_fn; 1878 CvFileNode* rects_fn; 1879 CvSeqReader rects_reader; 1880 1881 node_fn = (CvFileNode*) tree_reader.ptr; 1882 if( !CV_NODE_IS_MAP( node_fn->tag ) ) 1883 { 1884 sprintf( buf, "Tree node %d is not a valid map. (stage %d, tree %d)", 1885 k, i, j ); 1886 CV_ERROR( CV_StsError, buf ); 1887 } 1888 CV_CALL( feature_fn = cvGetFileNodeByName( fs, node_fn, 1889 ICV_HAAR_FEATURE_NAME ) ); 1890 if( !feature_fn || !CV_NODE_IS_MAP( feature_fn->tag ) ) 1891 { 1892 sprintf( buf, "Feature node is not a valid map. " 1893 "(stage %d, tree %d, node %d)", i, j, k ); 1894 CV_ERROR( CV_StsError, buf ); 1895 } 1896 CV_CALL( rects_fn = cvGetFileNodeByName( fs, feature_fn, 1897 ICV_HAAR_RECTS_NAME ) ); 1898 if( !rects_fn || !CV_NODE_IS_SEQ( rects_fn->tag ) 1899 || rects_fn->data.seq->total < 1 1900 || rects_fn->data.seq->total > CV_HAAR_FEATURE_MAX ) 1901 { 1902 sprintf( buf, "Rects node is not a valid sequence. " 1903 "(stage %d, tree %d, node %d)", i, j, k ); 1904 CV_ERROR( CV_StsError, buf ); 1905 } 1906 CV_CALL( cvStartReadSeq( rects_fn->data.seq, &rects_reader ) ); 1907 for( l = 0; l < rects_fn->data.seq->total; ++l ) 1908 { 1909 CvFileNode* rect_fn; 1910 CvRect r; 1911 1912 rect_fn = (CvFileNode*) rects_reader.ptr; 1913 if( !CV_NODE_IS_SEQ( rect_fn->tag ) || rect_fn->data.seq->total != 5 ) 1914 { 1915 sprintf( buf, "Rect %d is not a valid sequence. " 1916 "(stage %d, tree %d, node %d)", l, i, j, k ); 1917 CV_ERROR( CV_StsError, buf ); 1918 } 1919 1920 fn = CV_SEQ_ELEM( rect_fn->data.seq, CvFileNode, 0 ); 1921 if( !CV_NODE_IS_INT( fn->tag ) || fn->data.i < 0 ) 1922 { 1923 sprintf( buf, "x coordinate must be non-negative integer. " 1924 "(stage %d, tree %d, node %d, rect %d)", i, j, k, l ); 1925 CV_ERROR( CV_StsError, buf ); 1926 } 1927 r.x = fn->data.i; 1928 fn = CV_SEQ_ELEM( rect_fn->data.seq, CvFileNode, 1 ); 1929 if( !CV_NODE_IS_INT( fn->tag ) || fn->data.i < 0 ) 1930 { 1931 sprintf( buf, "y coordinate must be non-negative integer. " 1932 "(stage %d, tree %d, node %d, rect %d)", i, j, k, l ); 1933 CV_ERROR( CV_StsError, buf ); 1934 } 1935 r.y = fn->data.i; 1936 fn = CV_SEQ_ELEM( rect_fn->data.seq, CvFileNode, 2 ); 1937 if( !CV_NODE_IS_INT( fn->tag ) || fn->data.i <= 0 1938 || r.x + fn->data.i > cascade->orig_window_size.width ) 1939 { 1940 sprintf( buf, "width must be positive integer and " 1941 "(x + width) must not exceed window width. " 1942 "(stage %d, tree %d, node %d, rect %d)", i, j, k, l ); 1943 CV_ERROR( CV_StsError, buf ); 1944 } 1945 r.width = fn->data.i; 1946 fn = CV_SEQ_ELEM( rect_fn->data.seq, CvFileNode, 3 ); 1947 if( !CV_NODE_IS_INT( fn->tag ) || fn->data.i <= 0 1948 || r.y + fn->data.i > cascade->orig_window_size.height ) 1949 { 1950 sprintf( buf, "height must be positive integer and " 1951 "(y + height) must not exceed window height. " 1952 "(stage %d, tree %d, node %d, rect %d)", i, j, k, l ); 1953 CV_ERROR( CV_StsError, buf ); 1954 } 1955 r.height = fn->data.i; 1956 fn = CV_SEQ_ELEM( rect_fn->data.seq, CvFileNode, 4 ); 1957 if( !CV_NODE_IS_REAL( fn->tag ) ) 1958 { 1959 sprintf( buf, "weight must be real number. " 1960 "(stage %d, tree %d, node %d, rect %d)", i, j, k, l ); 1961 CV_ERROR( CV_StsError, buf ); 1962 } 1963 1964 classifier->haar_feature[k].rect[l].weight = (float) fn->data.f; 1965 classifier->haar_feature[k].rect[l].r = r; 1966 1967 CV_NEXT_SEQ_ELEM( sizeof( *rect_fn ), rects_reader ); 1968 } /* for each rect */ 1969 for( l = rects_fn->data.seq->total; l < CV_HAAR_FEATURE_MAX; ++l ) 1970 { 1971 classifier->haar_feature[k].rect[l].weight = 0; 1972 classifier->haar_feature[k].rect[l].r = cvRect( 0, 0, 0, 0 ); 1973 } 1974 1975 CV_CALL( fn = cvGetFileNodeByName( fs, feature_fn, ICV_HAAR_TILTED_NAME)); 1976 if( !fn || !CV_NODE_IS_INT( fn->tag ) ) 1977 { 1978 sprintf( buf, "tilted must be 0 or 1. " 1979 "(stage %d, tree %d, node %d)", i, j, k ); 1980 CV_ERROR( CV_StsError, buf ); 1981 } 1982 classifier->haar_feature[k].tilted = ( fn->data.i != 0 ); 1983 CV_CALL( fn = cvGetFileNodeByName( fs, node_fn, ICV_HAAR_THRESHOLD_NAME)); 1984 if( !fn || !CV_NODE_IS_REAL( fn->tag ) ) 1985 { 1986 sprintf( buf, "threshold must be real number. " 1987 "(stage %d, tree %d, node %d)", i, j, k ); 1988 CV_ERROR( CV_StsError, buf ); 1989 } 1990 classifier->threshold[k] = (float) fn->data.f; 1991 CV_CALL( fn = cvGetFileNodeByName( fs, node_fn, ICV_HAAR_LEFT_NODE_NAME)); 1992 if( fn ) 1993 { 1994 if( !CV_NODE_IS_INT( fn->tag ) || fn->data.i <= k 1995 || fn->data.i >= tree_fn->data.seq->total ) 1996 { 1997 sprintf( buf, "left node must be valid node number. " 1998 "(stage %d, tree %d, node %d)", i, j, k ); 1999 CV_ERROR( CV_StsError, buf ); 2000 } 2001 /* left node */ 2002 classifier->left[k] = fn->data.i; 2003 } 2004 else 2005 { 2006 CV_CALL( fn = cvGetFileNodeByName( fs, node_fn, 2007 ICV_HAAR_LEFT_VAL_NAME ) ); 2008 if( !fn ) 2009 { 2010 sprintf( buf, "left node or left value must be specified. " 2011 "(stage %d, tree %d, node %d)", i, j, k ); 2012 CV_ERROR( CV_StsError, buf ); 2013 } 2014 if( !CV_NODE_IS_REAL( fn->tag ) ) 2015 { 2016 sprintf( buf, "left value must be real number. " 2017 "(stage %d, tree %d, node %d)", i, j, k ); 2018 CV_ERROR( CV_StsError, buf ); 2019 } 2020 /* left value */ 2021 if( last_idx >= classifier->count + 1 ) 2022 { 2023 sprintf( buf, "Tree structure is broken: too many values. " 2024 "(stage %d, tree %d, node %d)", i, j, k ); 2025 CV_ERROR( CV_StsError, buf ); 2026 } 2027 classifier->left[k] = -last_idx; 2028 classifier->alpha[last_idx++] = (float) fn->data.f; 2029 } 2030 CV_CALL( fn = cvGetFileNodeByName( fs, node_fn,ICV_HAAR_RIGHT_NODE_NAME)); 2031 if( fn ) 2032 { 2033 if( !CV_NODE_IS_INT( fn->tag ) || fn->data.i <= k 2034 || fn->data.i >= tree_fn->data.seq->total ) 2035 { 2036 sprintf( buf, "right node must be valid node number. " 2037 "(stage %d, tree %d, node %d)", i, j, k ); 2038 CV_ERROR( CV_StsError, buf ); 2039 } 2040 /* right node */ 2041 classifier->right[k] = fn->data.i; 2042 } 2043 else 2044 { 2045 CV_CALL( fn = cvGetFileNodeByName( fs, node_fn, 2046 ICV_HAAR_RIGHT_VAL_NAME ) ); 2047 if( !fn ) 2048 { 2049 sprintf( buf, "right node or right value must be specified. " 2050 "(stage %d, tree %d, node %d)", i, j, k ); 2051 CV_ERROR( CV_StsError, buf ); 2052 } 2053 if( !CV_NODE_IS_REAL( fn->tag ) ) 2054 { 2055 sprintf( buf, "right value must be real number. " 2056 "(stage %d, tree %d, node %d)", i, j, k ); 2057 CV_ERROR( CV_StsError, buf ); 2058 } 2059 /* right value */ 2060 if( last_idx >= classifier->count + 1 ) 2061 { 2062 sprintf( buf, "Tree structure is broken: too many values. " 2063 "(stage %d, tree %d, node %d)", i, j, k ); 2064 CV_ERROR( CV_StsError, buf ); 2065 } 2066 classifier->right[k] = -last_idx; 2067 classifier->alpha[last_idx++] = (float) fn->data.f; 2068 } 2069 2070 CV_NEXT_SEQ_ELEM( sizeof( *node_fn ), tree_reader ); 2071 } /* for each node */ 2072 if( last_idx != classifier->count + 1 ) 2073 { 2074 sprintf( buf, "Tree structure is broken: too few values. " 2075 "(stage %d, tree %d)", i, j ); 2076 CV_ERROR( CV_StsError, buf ); 2077 } 2078 2079 CV_NEXT_SEQ_ELEM( sizeof( *tree_fn ), trees_reader ); 2080 } /* for each tree */ 2081 2082 CV_CALL( fn = cvGetFileNodeByName( fs, stage_fn, ICV_HAAR_STAGE_THRESHOLD_NAME)); 2083 if( !fn || !CV_NODE_IS_REAL( fn->tag ) ) 2084 { 2085 sprintf( buf, "stage threshold must be real number. (stage %d)", i ); 2086 CV_ERROR( CV_StsError, buf ); 2087 } 2088 cascade->stage_classifier[i].threshold = (float) fn->data.f; 2089 2090 parent = i - 1; 2091 next = -1; 2092 2093 CV_CALL( fn = cvGetFileNodeByName( fs, stage_fn, ICV_HAAR_PARENT_NAME ) ); 2094 if( !fn || !CV_NODE_IS_INT( fn->tag ) 2095 || fn->data.i < -1 || fn->data.i >= cascade->count ) 2096 { 2097 sprintf( buf, "parent must be integer number. (stage %d)", i ); 2098 CV_ERROR( CV_StsError, buf ); 2099 } 2100 parent = fn->data.i; 2101 CV_CALL( fn = cvGetFileNodeByName( fs, stage_fn, ICV_HAAR_NEXT_NAME ) ); 2102 if( !fn || !CV_NODE_IS_INT( fn->tag ) 2103 || fn->data.i < -1 || fn->data.i >= cascade->count ) 2104 { 2105 sprintf( buf, "next must be integer number. (stage %d)", i ); 2106 CV_ERROR( CV_StsError, buf ); 2107 } 2108 next = fn->data.i; 2109 2110 cascade->stage_classifier[i].parent = parent; 2111 cascade->stage_classifier[i].next = next; 2112 cascade->stage_classifier[i].child = -1; 2113 2114 if( parent != -1 && cascade->stage_classifier[parent].child == -1 ) 2115 { 2116 cascade->stage_classifier[parent].child = i; 2117 } 2118 2119 CV_NEXT_SEQ_ELEM( sizeof( *stage_fn ), stages_reader ); 2120 } /* for each stage */ 2121 2122 __END__; 2123 2124 if( cvGetErrStatus() < 0 ) 2125 { 2126 cvReleaseHaarClassifierCascade( &cascade ); 2127 cascade = NULL; 2128 } 2129 2130 return cascade; 2131} 2132 2133static void 2134icvWriteHaarClassifier( CvFileStorage* fs, const char* name, const void* struct_ptr, 2135 CvAttrList attributes ) 2136{ 2137 CV_FUNCNAME( "cvWriteHaarClassifier" ); 2138 2139 __BEGIN__; 2140 2141 int i, j, k, l; 2142 char buf[256]; 2143 const CvHaarClassifierCascade* cascade = (const CvHaarClassifierCascade*) struct_ptr; 2144 2145 /* TODO: parameters check */ 2146 2147 CV_CALL( cvStartWriteStruct( fs, name, CV_NODE_MAP, CV_TYPE_NAME_HAAR, attributes ) ); 2148 2149 CV_CALL( cvStartWriteStruct( fs, ICV_HAAR_SIZE_NAME, CV_NODE_SEQ | CV_NODE_FLOW ) ); 2150 CV_CALL( cvWriteInt( fs, NULL, cascade->orig_window_size.width ) ); 2151 CV_CALL( cvWriteInt( fs, NULL, cascade->orig_window_size.height ) ); 2152 CV_CALL( cvEndWriteStruct( fs ) ); /* size */ 2153 2154 CV_CALL( cvStartWriteStruct( fs, ICV_HAAR_STAGES_NAME, CV_NODE_SEQ ) ); 2155 for( i = 0; i < cascade->count; ++i ) 2156 { 2157 CV_CALL( cvStartWriteStruct( fs, NULL, CV_NODE_MAP ) ); 2158 sprintf( buf, "stage %d", i ); 2159 CV_CALL( cvWriteComment( fs, buf, 1 ) ); 2160 2161 CV_CALL( cvStartWriteStruct( fs, ICV_HAAR_TREES_NAME, CV_NODE_SEQ ) ); 2162 2163 for( j = 0; j < cascade->stage_classifier[i].count; ++j ) 2164 { 2165 CvHaarClassifier* tree = &cascade->stage_classifier[i].classifier[j]; 2166 2167 CV_CALL( cvStartWriteStruct( fs, NULL, CV_NODE_SEQ ) ); 2168 sprintf( buf, "tree %d", j ); 2169 CV_CALL( cvWriteComment( fs, buf, 1 ) ); 2170 2171 for( k = 0; k < tree->count; ++k ) 2172 { 2173 CvHaarFeature* feature = &tree->haar_feature[k]; 2174 2175 CV_CALL( cvStartWriteStruct( fs, NULL, CV_NODE_MAP ) ); 2176 if( k ) 2177 { 2178 sprintf( buf, "node %d", k ); 2179 } 2180 else 2181 { 2182 sprintf( buf, "root node" ); 2183 } 2184 CV_CALL( cvWriteComment( fs, buf, 1 ) ); 2185 2186 CV_CALL( cvStartWriteStruct( fs, ICV_HAAR_FEATURE_NAME, CV_NODE_MAP ) ); 2187 2188 CV_CALL( cvStartWriteStruct( fs, ICV_HAAR_RECTS_NAME, CV_NODE_SEQ ) ); 2189 for( l = 0; l < CV_HAAR_FEATURE_MAX && feature->rect[l].r.width != 0; ++l ) 2190 { 2191 CV_CALL( cvStartWriteStruct( fs, NULL, CV_NODE_SEQ | CV_NODE_FLOW ) ); 2192 CV_CALL( cvWriteInt( fs, NULL, feature->rect[l].r.x ) ); 2193 CV_CALL( cvWriteInt( fs, NULL, feature->rect[l].r.y ) ); 2194 CV_CALL( cvWriteInt( fs, NULL, feature->rect[l].r.width ) ); 2195 CV_CALL( cvWriteInt( fs, NULL, feature->rect[l].r.height ) ); 2196 CV_CALL( cvWriteReal( fs, NULL, feature->rect[l].weight ) ); 2197 CV_CALL( cvEndWriteStruct( fs ) ); /* rect */ 2198 } 2199 CV_CALL( cvEndWriteStruct( fs ) ); /* rects */ 2200 CV_CALL( cvWriteInt( fs, ICV_HAAR_TILTED_NAME, feature->tilted ) ); 2201 CV_CALL( cvEndWriteStruct( fs ) ); /* feature */ 2202 2203 CV_CALL( cvWriteReal( fs, ICV_HAAR_THRESHOLD_NAME, tree->threshold[k]) ); 2204 2205 if( tree->left[k] > 0 ) 2206 { 2207 CV_CALL( cvWriteInt( fs, ICV_HAAR_LEFT_NODE_NAME, tree->left[k] ) ); 2208 } 2209 else 2210 { 2211 CV_CALL( cvWriteReal( fs, ICV_HAAR_LEFT_VAL_NAME, 2212 tree->alpha[-tree->left[k]] ) ); 2213 } 2214 2215 if( tree->right[k] > 0 ) 2216 { 2217 CV_CALL( cvWriteInt( fs, ICV_HAAR_RIGHT_NODE_NAME, tree->right[k] ) ); 2218 } 2219 else 2220 { 2221 CV_CALL( cvWriteReal( fs, ICV_HAAR_RIGHT_VAL_NAME, 2222 tree->alpha[-tree->right[k]] ) ); 2223 } 2224 2225 CV_CALL( cvEndWriteStruct( fs ) ); /* split */ 2226 } 2227 2228 CV_CALL( cvEndWriteStruct( fs ) ); /* tree */ 2229 } 2230 2231 CV_CALL( cvEndWriteStruct( fs ) ); /* trees */ 2232 2233 CV_CALL( cvWriteReal( fs, ICV_HAAR_STAGE_THRESHOLD_NAME, 2234 cascade->stage_classifier[i].threshold) ); 2235 2236 CV_CALL( cvWriteInt( fs, ICV_HAAR_PARENT_NAME, 2237 cascade->stage_classifier[i].parent ) ); 2238 CV_CALL( cvWriteInt( fs, ICV_HAAR_NEXT_NAME, 2239 cascade->stage_classifier[i].next ) ); 2240 2241 CV_CALL( cvEndWriteStruct( fs ) ); /* stage */ 2242 } /* for each stage */ 2243 2244 CV_CALL( cvEndWriteStruct( fs ) ); /* stages */ 2245 CV_CALL( cvEndWriteStruct( fs ) ); /* root */ 2246 2247 __END__; 2248} 2249 2250static void* 2251icvCloneHaarClassifier( const void* struct_ptr ) 2252{ 2253 CvHaarClassifierCascade* cascade = NULL; 2254 2255 CV_FUNCNAME( "cvCloneHaarClassifier" ); 2256 2257 __BEGIN__; 2258 2259 int i, j, k, n; 2260 const CvHaarClassifierCascade* cascade_src = 2261 (const CvHaarClassifierCascade*) struct_ptr; 2262 2263 n = cascade_src->count; 2264 CV_CALL( cascade = icvCreateHaarClassifierCascade(n) ); 2265 cascade->orig_window_size = cascade_src->orig_window_size; 2266 2267 for( i = 0; i < n; ++i ) 2268 { 2269 cascade->stage_classifier[i].parent = cascade_src->stage_classifier[i].parent; 2270 cascade->stage_classifier[i].next = cascade_src->stage_classifier[i].next; 2271 cascade->stage_classifier[i].child = cascade_src->stage_classifier[i].child; 2272 cascade->stage_classifier[i].threshold = cascade_src->stage_classifier[i].threshold; 2273 2274 cascade->stage_classifier[i].count = 0; 2275 CV_CALL( cascade->stage_classifier[i].classifier = 2276 (CvHaarClassifier*) cvAlloc( cascade_src->stage_classifier[i].count 2277 * sizeof( cascade->stage_classifier[i].classifier[0] ) ) ); 2278 2279 cascade->stage_classifier[i].count = cascade_src->stage_classifier[i].count; 2280 2281 for( j = 0; j < cascade->stage_classifier[i].count; ++j ) 2282 { 2283 cascade->stage_classifier[i].classifier[j].haar_feature = NULL; 2284 } 2285 2286 for( j = 0; j < cascade->stage_classifier[i].count; ++j ) 2287 { 2288 const CvHaarClassifier* classifier_src = 2289 &cascade_src->stage_classifier[i].classifier[j]; 2290 CvHaarClassifier* classifier = 2291 &cascade->stage_classifier[i].classifier[j]; 2292 2293 classifier->count = classifier_src->count; 2294 CV_CALL( classifier->haar_feature = (CvHaarFeature*) cvAlloc( 2295 classifier->count * ( sizeof( *classifier->haar_feature ) + 2296 sizeof( *classifier->threshold ) + 2297 sizeof( *classifier->left ) + 2298 sizeof( *classifier->right ) ) + 2299 (classifier->count + 1) * sizeof( *classifier->alpha ) ) ); 2300 classifier->threshold = (float*) (classifier->haar_feature+classifier->count); 2301 classifier->left = (int*) (classifier->threshold + classifier->count); 2302 classifier->right = (int*) (classifier->left + classifier->count); 2303 classifier->alpha = (float*) (classifier->right + classifier->count); 2304 for( k = 0; k < classifier->count; ++k ) 2305 { 2306 classifier->haar_feature[k] = classifier_src->haar_feature[k]; 2307 classifier->threshold[k] = classifier_src->threshold[k]; 2308 classifier->left[k] = classifier_src->left[k]; 2309 classifier->right[k] = classifier_src->right[k]; 2310 classifier->alpha[k] = classifier_src->alpha[k]; 2311 } 2312 classifier->alpha[classifier->count] = 2313 classifier_src->alpha[classifier->count]; 2314 } 2315 } 2316 2317 __END__; 2318 2319 return cascade; 2320} 2321 2322 2323CvType haar_type( CV_TYPE_NAME_HAAR, icvIsHaarClassifier, 2324 (CvReleaseFunc)cvReleaseHaarClassifierCascade, 2325 icvReadHaarClassifier, icvWriteHaarClassifier, 2326 icvCloneHaarClassifier ); 2327 2328/* End of file. */ 2329