/*M/////////////////////////////////////////////////////////////////////////////////////// // // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. // // By downloading, copying, installing or using the software you agree to this license. // If you do not agree to this license, do not download, install, // copy or use the software. // // // Intel License Agreement // For Open Source Computer Vision Library // // Copyright (C) 2000, Intel Corporation, all rights reserved. // Third party copyrights are property of their respective owners. // // Redistribution and use in source and binary forms, with or without modification, // are permitted provided that the following conditions are met: // // * Redistribution's of source code must retain the above copyright notice, // this list of conditions and the following disclaimer. // // * Redistribution's in binary form must reproduce the above copyright notice, // this list of conditions and the following disclaimer in the documentation // and/or other materials provided with the distribution. // // * The name of Intel Corporation may not be used to endorse or promote products // derived from this software without specific prior written permission. // // This software is provided by the copyright holders and contributors "as is" and // any express or implied warranties, including, but not limited to, the implied // warranties of merchantability and fitness for a particular purpose are disclaimed. // In no event shall the Intel Corporation or contributors be liable for any direct, // indirect, incidental, special, exemplary, or consequential damages // (including, but not limited to, procurement of substitute goods or services; // loss of use, data, or profits; or business interruption) however caused // and on any theory of liability, whether in contract, strict liability, // or tort (including negligence or otherwise) arising in any way out of // the use of this software, even if advised of the possibility of such damage. // //M*/ /* Haar features calculation */ #include "_cv.h" #include /* these settings affect the quality of detection: change with care */ #define CV_ADJUST_FEATURES 1 #define CV_ADJUST_WEIGHTS 1 typedef int sumtype; typedef double sqsumtype; typedef struct MyCvHidHaarFeature { struct { sumtype *p0, *p1, *p2, *p3; int weight; } rect[CV_HAAR_FEATURE_MAX]; } MyCvHidHaarFeature; typedef struct MyCvHidHaarTreeNode { MyCvHidHaarFeature feature; int threshold; int left; int right; } MyCvHidHaarTreeNode; typedef struct MyCvHidHaarClassifier { int count; //CvHaarFeature* orig_feature; MyCvHidHaarTreeNode* node; float* alpha; } MyCvHidHaarClassifier; typedef struct MyCvHidHaarStageClassifier { int count; float threshold; MyCvHidHaarClassifier* classifier; int two_rects; struct MyCvHidHaarStageClassifier* next; struct MyCvHidHaarStageClassifier* child; struct MyCvHidHaarStageClassifier* parent; } MyCvHidHaarStageClassifier; struct MyCvHidHaarClassifierCascade { int count; int is_stump_based; int has_tilted_features; int is_tree; double inv_window_area; CvMat sum, sqsum, tilted; MyCvHidHaarStageClassifier* stage_classifier; sqsumtype *pq0, *pq1, *pq2, *pq3; sumtype *p0, *p1, *p2, *p3; void** ipp_stages; }; const int icv_object_win_border = 1; const float icv_stage_threshold_bias = 0.0001f; static int myis_equal( const void* _r1, const void* _r2, void* ) { const CvRect* r1 = (const CvRect*)_r1; const CvRect* r2 = (const CvRect*)_r2; int distance = cvRound(r1->width*0.2); return r2->x <= r1->x + distance && r2->x >= r1->x - distance && r2->y <= r1->y + distance && r2->y >= r1->y - distance && r2->width <= cvRound( r1->width * 1.2 ) && cvRound( r2->width * 1.2 ) >= r1->width; } static void myicvReleaseHidHaarClassifierCascade( MyCvHidHaarClassifierCascade** _cascade ) { if( _cascade && *_cascade ) { /*CvHidHaarClassifierCascade* cascade = *_cascade; if( cascade->ipp_stages && icvHaarClassifierFree_32f_p ) { int i; for( i = 0; i < cascade->count; i++ ) { if( cascade->ipp_stages[i] ) icvHaarClassifierFree_32f_p( cascade->ipp_stages[i] ); } } cvFree( &cascade->ipp_stages );*/ cvFree( _cascade ); } } /* create more efficient internal representation of haar classifier cascade */ static MyCvHidHaarClassifierCascade* myicvCreateHidHaarClassifierCascade( CvHaarClassifierCascade* cascade ) { CvRect* ipp_features = 0; float *ipp_weights = 0, *ipp_thresholds = 0, *ipp_val1 = 0, *ipp_val2 = 0; int* ipp_counts = 0; MyCvHidHaarClassifierCascade* out = 0; CV_FUNCNAME( "icvCreateHidHaarClassifierCascade" ); __BEGIN__; int i, j, k, l; int datasize; int total_classifiers = 0; int total_nodes = 0; char errorstr[100]; MyCvHidHaarClassifier* haar_classifier_ptr; MyCvHidHaarTreeNode* haar_node_ptr; CvSize orig_window_size; int has_tilted_features = 0; int max_count = 0; if( !CV_IS_HAAR_CLASSIFIER(cascade) ) CV_ERROR( !cascade ? CV_StsNullPtr : CV_StsBadArg, "Invalid classifier pointer" ); if( cascade->hid_cascade ) CV_ERROR( CV_StsError, "hid_cascade has been already created" ); if( !cascade->stage_classifier ) CV_ERROR( CV_StsNullPtr, "" ); if( cascade->count <= 0 ) CV_ERROR( CV_StsOutOfRange, "Negative number of cascade stages" ); orig_window_size = cascade->orig_window_size; /* check input structure correctness and calculate total memory size needed for internal representation of the classifier cascade */ for( i = 0; i < cascade->count; i++ ) { CvHaarStageClassifier* stage_classifier = cascade->stage_classifier + i; if( !stage_classifier->classifier || stage_classifier->count <= 0 ) { sprintf( errorstr, "header of the stage classifier #%d is invalid " "(has null pointers or non-positive classfier count)", i ); CV_ERROR( CV_StsError, errorstr ); } max_count = MAX( max_count, stage_classifier->count ); total_classifiers += stage_classifier->count; for( j = 0; j < stage_classifier->count; j++ ) { CvHaarClassifier* classifier = stage_classifier->classifier + j; total_nodes += classifier->count; for( l = 0; l < classifier->count; l++ ) { for( k = 0; k < CV_HAAR_FEATURE_MAX; k++ ) { if( classifier->haar_feature[l].rect[k].r.width ) { CvRect r = classifier->haar_feature[l].rect[k].r; int tilted = classifier->haar_feature[l].tilted; has_tilted_features |= tilted != 0; if( r.width < 0 || r.height < 0 || r.y < 0 || r.x + r.width > orig_window_size.width || (!tilted && (r.x < 0 || r.y + r.height > orig_window_size.height)) || (tilted && (r.x - r.height < 0 || r.y + r.width + r.height > orig_window_size.height))) { sprintf( errorstr, "rectangle #%d of the classifier #%d of " "the stage classifier #%d is not inside " "the reference (original) cascade window", k, j, i ); CV_ERROR( CV_StsNullPtr, errorstr ); } } } } } } // this is an upper boundary for the whole hidden cascade size datasize = sizeof(MyCvHidHaarClassifierCascade) + sizeof(MyCvHidHaarStageClassifier)*cascade->count + sizeof(MyCvHidHaarClassifier) * total_classifiers + sizeof(MyCvHidHaarTreeNode) * total_nodes + sizeof(void*)*(total_nodes + total_classifiers); CV_CALL( out = (MyCvHidHaarClassifierCascade*)cvAlloc( datasize )); memset( out, 0, sizeof(*out) ); /* init header */ out->count = cascade->count; out->stage_classifier = (MyCvHidHaarStageClassifier*)(out + 1); haar_classifier_ptr = (MyCvHidHaarClassifier*)(out->stage_classifier + cascade->count); haar_node_ptr = (MyCvHidHaarTreeNode*)(haar_classifier_ptr + total_classifiers); out->is_stump_based = 1; out->has_tilted_features = has_tilted_features; out->is_tree = 0; /* initialize internal representation */ for( i = 0; i < cascade->count; i++ ) { CvHaarStageClassifier* stage_classifier = cascade->stage_classifier + i; MyCvHidHaarStageClassifier* hid_stage_classifier = out->stage_classifier + i; hid_stage_classifier->count = stage_classifier->count; hid_stage_classifier->threshold = stage_classifier->threshold - icv_stage_threshold_bias; hid_stage_classifier->classifier = haar_classifier_ptr; hid_stage_classifier->two_rects = 1; haar_classifier_ptr += stage_classifier->count; hid_stage_classifier->parent = (stage_classifier->parent == -1) ? NULL : out->stage_classifier + stage_classifier->parent; hid_stage_classifier->next = (stage_classifier->next == -1) ? NULL : out->stage_classifier + stage_classifier->next; hid_stage_classifier->child = (stage_classifier->child == -1) ? NULL : out->stage_classifier + stage_classifier->child; out->is_tree |= hid_stage_classifier->next != NULL; for( j = 0; j < stage_classifier->count; j++ ) { CvHaarClassifier* classifier = stage_classifier->classifier + j; MyCvHidHaarClassifier* hid_classifier = hid_stage_classifier->classifier + j; int node_count = classifier->count; float* alpha_ptr = (float*)(haar_node_ptr + node_count); hid_classifier->count = node_count; hid_classifier->node = haar_node_ptr; hid_classifier->alpha = alpha_ptr; for( l = 0; l < node_count; l++ ) { MyCvHidHaarTreeNode* node = hid_classifier->node + l; CvHaarFeature* feature = classifier->haar_feature + l; memset( node, -1, sizeof(*node) ); node->threshold = (int)((classifier->threshold[l]) * 65536.0); node->left = classifier->left[l]; node->right = classifier->right[l]; if( fabs(feature->rect[2].weight) < DBL_EPSILON || feature->rect[2].r.width == 0 || feature->rect[2].r.height == 0 ) memset( &(node->feature.rect[2]), 0, sizeof(node->feature.rect[2]) ); else hid_stage_classifier->two_rects = 0; } memcpy( alpha_ptr, classifier->alpha, (node_count+1)*sizeof(alpha_ptr[0])); haar_node_ptr = (MyCvHidHaarTreeNode*)cvAlignPtr(alpha_ptr+node_count+1, sizeof(void*)); out->is_stump_based &= node_count == 1; } } /*{ int can_use_ipp = icvHaarClassifierInitAlloc_32f_p != 0 && icvHaarClassifierFree_32f_p != 0 && icvApplyHaarClassifier_32f_C1R_p != 0 && icvRectStdDev_32f_C1R_p != 0 && !out->has_tilted_features && !out->is_tree && out->is_stump_based; if( can_use_ipp ) { int ipp_datasize = cascade->count*sizeof(out->ipp_stages[0]); float ipp_weight_scale=(float)(1./((orig_window_size.width-icv_object_win_border*2)* (orig_window_size.height-icv_object_win_border*2))); CV_CALL( out->ipp_stages = (void**)cvAlloc( ipp_datasize )); memset( out->ipp_stages, 0, ipp_datasize ); CV_CALL( ipp_features = (CvRect*)cvAlloc( max_count*3*sizeof(ipp_features[0]) )); CV_CALL( ipp_weights = (float*)cvAlloc( max_count*3*sizeof(ipp_weights[0]) )); CV_CALL( ipp_thresholds = (float*)cvAlloc( max_count*sizeof(ipp_thresholds[0]) )); CV_CALL( ipp_val1 = (float*)cvAlloc( max_count*sizeof(ipp_val1[0]) )); CV_CALL( ipp_val2 = (float*)cvAlloc( max_count*sizeof(ipp_val2[0]) )); CV_CALL( ipp_counts = (int*)cvAlloc( max_count*sizeof(ipp_counts[0]) )); for( i = 0; i < cascade->count; i++ ) { CvHaarStageClassifier* stage_classifier = cascade->stage_classifier + i; for( j = 0, k = 0; j < stage_classifier->count; j++ ) { CvHaarClassifier* classifier = stage_classifier->classifier + j; int rect_count = 2 + (classifier->haar_feature->rect[2].r.width != 0); ipp_thresholds[j] = classifier->threshold[0]; ipp_val1[j] = classifier->alpha[0]; ipp_val2[j] = classifier->alpha[1]; ipp_counts[j] = rect_count; for( l = 0; l < rect_count; l++, k++ ) { ipp_features[k] = classifier->haar_feature->rect[l].r; //ipp_features[k].y = orig_window_size.height - ipp_features[k].y - ipp_features[k].height; ipp_weights[k] = classifier->haar_feature->rect[l].weight*ipp_weight_scale; } } if( icvHaarClassifierInitAlloc_32f_p( &out->ipp_stages[i], ipp_features, ipp_weights, ipp_thresholds, ipp_val1, ipp_val2, ipp_counts, stage_classifier->count ) < 0 ) break; } if( i < cascade->count ) { for( j = 0; j < i; j++ ) if( icvHaarClassifierFree_32f_p && out->ipp_stages[i] ) icvHaarClassifierFree_32f_p( out->ipp_stages[i] ); cvFree( &out->ipp_stages ); } } }*/ cascade->hid_cascade = (CvHidHaarClassifierCascade*)out; assert( (char*)haar_node_ptr - (char*)out <= datasize ); __END__; if( cvGetErrStatus() < 0 ) myicvReleaseHidHaarClassifierCascade( &out ); cvFree( &ipp_features ); cvFree( &ipp_weights ); cvFree( &ipp_thresholds ); cvFree( &ipp_val1 ); cvFree( &ipp_val2 ); cvFree( &ipp_counts ); return out; } #define calc_sum(rect,offset) \ ((rect).p0[offset] - (rect).p1[offset] - (rect).p2[offset] + (rect).p3[offset]) CV_INLINE double myicvEvalHidHaarClassifier( MyCvHidHaarClassifier* classifier, double variance_norm_factor, size_t p_offset ) { int idx = 0; do { MyCvHidHaarTreeNode* node = classifier->node + idx; double t = node->threshold * variance_norm_factor; double sum = calc_sum(node->feature.rect[0],p_offset) * node->feature.rect[0].weight; sum += calc_sum(node->feature.rect[1],p_offset) * node->feature.rect[1].weight; if( node->feature.rect[2].p0 ) sum += calc_sum(node->feature.rect[2],p_offset) * node->feature.rect[2].weight; idx = sum < t ? node->left : node->right; } while( idx > 0 ); return classifier->alpha[-idx]; } /*********************** Special integer sqrt **************************/ int isqrt(int x) { /* * Logically, these are unsigned. We need the sign bit to test * whether (op - res - one) underflowed. */ register int op, res, one; op = x; res = 0; /* "one" starts at the highest power of four <= than the argument. */ one = 1 << 30; /* second-to-top bit set */ while (one > op) one >>= 2; while (one != 0) { if (op >= res + one) { op = op - (res + one); res = res + 2 * one; } res /= 2; one /= 4; } return(res); } #define NEXT(n, i) (((n) + (i)/(n)) >> 1) unsigned int isqrt1(int number) { unsigned int n = 1; unsigned int n1 = NEXT(n, number); while(abs(n1 - n) > 1) { n = n1; n1 = NEXT(n, number); } while((n1*n1) > number) { n1 -= 1; } return n1; } /***********************************************************************/ CV_IMPL int mycvRunHaarClassifierCascade( CvHaarClassifierCascade* _cascade, CvPoint pt, int start_stage ) { int result = -1; CV_FUNCNAME("mycvRunHaarClassifierCascade"); __BEGIN__; int p_offset, pq_offset; int pq0, pq1, pq2, pq3; int i, j; double mean; int variance_norm_factor; MyCvHidHaarClassifierCascade* cascade; if( !CV_IS_HAAR_CLASSIFIER(_cascade) ) CV_ERROR( !_cascade ? CV_StsNullPtr : CV_StsBadArg, "Invalid cascade pointer" ); cascade = (MyCvHidHaarClassifierCascade*)_cascade->hid_cascade; if( !cascade ) CV_ERROR( CV_StsNullPtr, "Hidden cascade has not been created.\n" "Use cvSetImagesForHaarClassifierCascade" ); if( pt.x < 0 || pt.y < 0 || pt.x + _cascade->real_window_size.width >= cascade->sum.width-2 || pt.y + _cascade->real_window_size.height >= cascade->sum.height-2 ) EXIT; p_offset = pt.y * (cascade->sum.step/sizeof(sumtype)) + pt.x; pq_offset = pt.y * (cascade->sqsum.step/sizeof(sqsumtype)) + pt.x; mean = calc_sum(*cascade,p_offset) * cascade->inv_window_area; pq0 = cascade->pq0[pq_offset]; pq1 = cascade->pq1[pq_offset]; pq2 = cascade->pq2[pq_offset]; pq3 = cascade->pq3[pq_offset]; variance_norm_factor = pq0 - pq1 - pq2 + pq3; variance_norm_factor = variance_norm_factor * cascade->inv_window_area - mean * mean; if( variance_norm_factor >= 0. ) variance_norm_factor = sqrt(variance_norm_factor); else variance_norm_factor = 1.; // if( cascade->is_tree ) // { // MyCvHidHaarStageClassifier* ptr; // assert( start_stage == 0 ); // // result = 1; // ptr = cascade->stage_classifier; // // while( ptr ) // { // double stage_sum = 0; // // for( j = 0; j < ptr->count; j++ ) // { // stage_sum += myicvEvalHidHaarClassifier( ptr->classifier + j, // variance_norm_factor, p_offset ); // } // // if( stage_sum >= ptr->threshold ) // { // ptr = ptr->child; // } // else // { // while( ptr && ptr->next == NULL ) ptr = ptr->parent; // if( ptr == NULL ) // { // result = 0; // EXIT; // } // ptr = ptr->next; // } // } // } // else if( cascade->is_stump_based ) { for( i = start_stage; i < cascade->count; i++ ) { double stage_sum = 0; if( cascade->stage_classifier[i].two_rects ) { for( j = 0; j < cascade->stage_classifier[i].count; j++ ) { MyCvHidHaarClassifier* classifier = cascade->stage_classifier[i].classifier + j; MyCvHidHaarTreeNode* node = classifier->node; int t = node->threshold * variance_norm_factor; int sum = calc_sum(node->feature.rect[0],p_offset) * node->feature.rect[0].weight; sum += calc_sum(node->feature.rect[1],p_offset) * node->feature.rect[1].weight; stage_sum += classifier->alpha[sum >= t]; } } else { for( j = 0; j < cascade->stage_classifier[i].count; j++ ) { MyCvHidHaarClassifier* classifier = cascade->stage_classifier[i].classifier + j; MyCvHidHaarTreeNode* node = classifier->node; int t = node->threshold * variance_norm_factor; int sum = calc_sum(node->feature.rect[0],p_offset) * node->feature.rect[0].weight; sum += calc_sum(node->feature.rect[1],p_offset) * node->feature.rect[1].weight; if( node->feature.rect[2].p0 ) sum += calc_sum(node->feature.rect[2],p_offset) * node->feature.rect[2].weight; stage_sum += classifier->alpha[sum >= t]; } } if( stage_sum < cascade->stage_classifier[i].threshold ) { result = -i; EXIT; } } } // else // { // for( i = start_stage; i < cascade->count; i++ ) // { // double stage_sum = 0; // // for( j = 0; j < cascade->stage_classifier[i].count; j++ ) // { // stage_sum += myicvEvalHidHaarClassifier( // cascade->stage_classifier[i].classifier + j, // variance_norm_factor, p_offset ); // } // // if( stage_sum < cascade->stage_classifier[i].threshold ) // { // result = -i; // EXIT; // } // } // } result = 1; __END__; return result; } #define sum_elem_ptr(sum,row,col) \ ((sumtype*)CV_MAT_ELEM_PTR_FAST((sum),(row),(col),sizeof(sumtype))) #define sqsum_elem_ptr(sqsum,row,col) \ ((sqsumtype*)CV_MAT_ELEM_PTR_FAST((sqsum),(row),(col),sizeof(sqsumtype))) CV_IMPL void mycvSetImagesForHaarClassifierCascade( CvHaarClassifierCascade* _cascade, const CvArr* _sum, const CvArr* _sqsum, const CvArr* _tilted_sum, double scale ) { CV_FUNCNAME("cvSetImagesForHaarClassifierCascade"); __BEGIN__; CvMat sum_stub, *sum = (CvMat*)_sum; CvMat sqsum_stub, *sqsum = (CvMat*)_sqsum; CvMat tilted_stub, *tilted = (CvMat*)_tilted_sum; MyCvHidHaarClassifierCascade* cascade; int coi0 = 0, coi1 = 0; int i; CvRect equ_rect; double weight_scale; if( !CV_IS_HAAR_CLASSIFIER(_cascade) ) CV_ERROR( !_cascade ? CV_StsNullPtr : CV_StsBadArg, "Invalid classifier pointer" ); if( scale <= 0 ) CV_ERROR( CV_StsOutOfRange, "Scale must be positive" ); CV_CALL( sum = cvGetMat( sum, &sum_stub, &coi0 )); CV_CALL( sqsum = cvGetMat( sqsum, &sqsum_stub, &coi1 )); if( coi0 || coi1 ) CV_ERROR( CV_BadCOI, "COI is not supported" ); if( !CV_ARE_SIZES_EQ( sum, sqsum )) CV_ERROR( CV_StsUnmatchedSizes, "All integral images must have the same size" ); if( CV_MAT_TYPE(sqsum->type) != CV_64FC1 || CV_MAT_TYPE(sum->type) != CV_32SC1 ) CV_ERROR( CV_StsUnsupportedFormat, "Only (32s, 64f, 32s) combination of (sum,sqsum,tilted_sum) formats is allowed" ); if( !_cascade->hid_cascade ) CV_CALL( myicvCreateHidHaarClassifierCascade(_cascade) ); cascade = (MyCvHidHaarClassifierCascade*)_cascade->hid_cascade; if( cascade->has_tilted_features ) { CV_CALL( tilted = cvGetMat( tilted, &tilted_stub, &coi1 )); if( CV_MAT_TYPE(tilted->type) != CV_32SC1 ) CV_ERROR( CV_StsUnsupportedFormat, "Only (32s, 64f, 32s) combination of (sum,sqsum,tilted_sum) formats is allowed" ); if( sum->step != tilted->step ) CV_ERROR( CV_StsUnmatchedSizes, "Sum and tilted_sum must have the same stride (step, widthStep)" ); if( !CV_ARE_SIZES_EQ( sum, tilted )) CV_ERROR( CV_StsUnmatchedSizes, "All integral images must have the same size" ); cascade->tilted = *tilted; } _cascade->scale = scale; _cascade->real_window_size.width = cvRound( _cascade->orig_window_size.width * scale ); _cascade->real_window_size.height = cvRound( _cascade->orig_window_size.height * scale ); cascade->sum = *sum; cascade->sqsum = *sqsum; equ_rect.x = equ_rect.y = cvRound(scale); equ_rect.width = cvRound((_cascade->orig_window_size.width-2)*scale); equ_rect.height = cvRound((_cascade->orig_window_size.height-2)*scale); weight_scale = 1./(equ_rect.width*equ_rect.height); cascade->inv_window_area = weight_scale; cascade->p0 = sum_elem_ptr(*sum, equ_rect.y, equ_rect.x); cascade->p1 = sum_elem_ptr(*sum, equ_rect.y, equ_rect.x + equ_rect.width ); cascade->p2 = sum_elem_ptr(*sum, equ_rect.y + equ_rect.height, equ_rect.x ); cascade->p3 = sum_elem_ptr(*sum, equ_rect.y + equ_rect.height, equ_rect.x + equ_rect.width ); cascade->pq0 = sqsum_elem_ptr(*sqsum, equ_rect.y, equ_rect.x); cascade->pq1 = sqsum_elem_ptr(*sqsum, equ_rect.y, equ_rect.x + equ_rect.width ); cascade->pq2 = sqsum_elem_ptr(*sqsum, equ_rect.y + equ_rect.height, equ_rect.x ); cascade->pq3 = sqsum_elem_ptr(*sqsum, equ_rect.y + equ_rect.height, equ_rect.x + equ_rect.width ); /* init pointers in haar features according to real window size and given image pointers */ { #ifdef _OPENMP int max_threads = cvGetNumThreads(); #pragma omp parallel for num_threads(max_threads) schedule(dynamic) #endif // _OPENMP for( i = 0; i < _cascade->count; i++ ) { int j, k, l; for( j = 0; j < cascade->stage_classifier[i].count; j++ ) { for( l = 0; l < cascade->stage_classifier[i].classifier[j].count; l++ ) { CvHaarFeature* feature = &_cascade->stage_classifier[i].classifier[j].haar_feature[l]; /* CvHidHaarClassifier* classifier = cascade->stage_classifier[i].classifier + j; */ MyCvHidHaarFeature* hidfeature = &cascade->stage_classifier[i].classifier[j].node[l].feature; double sum0 = 0, area0 = 0; CvRect r[3]; #if CV_ADJUST_FEATURES int base_w = -1, base_h = -1; int new_base_w = 0, new_base_h = 0; int kx, ky; int flagx = 0, flagy = 0; int x0 = 0, y0 = 0; #endif int nr; /* align blocks */ for( k = 0; k < CV_HAAR_FEATURE_MAX; k++ ) { if( !hidfeature->rect[k].p0 ) break; #if CV_ADJUST_FEATURES r[k] = feature->rect[k].r; base_w = (int)CV_IMIN( (unsigned)base_w, (unsigned)(r[k].width-1) ); base_w = (int)CV_IMIN( (unsigned)base_w, (unsigned)(r[k].x - r[0].x-1) ); base_h = (int)CV_IMIN( (unsigned)base_h, (unsigned)(r[k].height-1) ); base_h = (int)CV_IMIN( (unsigned)base_h, (unsigned)(r[k].y - r[0].y-1) ); #endif } nr = k; #if CV_ADJUST_FEATURES base_w += 1; base_h += 1; kx = r[0].width / base_w; ky = r[0].height / base_h; if( kx <= 0 ) { flagx = 1; new_base_w = cvRound( r[0].width * scale ) / kx; x0 = cvRound( r[0].x * scale ); } if( ky <= 0 ) { flagy = 1; new_base_h = cvRound( r[0].height * scale ) / ky; y0 = cvRound( r[0].y * scale ); } #endif float tmpweight[3] = {0}; for( k = 0; k < nr; k++ ) { CvRect tr; double correction_ratio; #if CV_ADJUST_FEATURES if( flagx ) { tr.x = (r[k].x - r[0].x) * new_base_w / base_w + x0; tr.width = r[k].width * new_base_w / base_w; } else #endif { tr.x = cvRound( r[k].x * scale ); tr.width = cvRound( r[k].width * scale ); } #if CV_ADJUST_FEATURES if( flagy ) { tr.y = (r[k].y - r[0].y) * new_base_h / base_h + y0; tr.height = r[k].height * new_base_h / base_h; } else #endif { tr.y = cvRound( r[k].y * scale ); tr.height = cvRound( r[k].height * scale ); } #if CV_ADJUST_WEIGHTS { // RAINER START const float orig_feature_size = (float)(feature->rect[k].r.width)*feature->rect[k].r.height; const float orig_norm_size = (float)(_cascade->orig_window_size.width)*(_cascade->orig_window_size.height); const float feature_size = float(tr.width*tr.height); //const float normSize = float(equ_rect.width*equ_rect.height); float target_ratio = orig_feature_size / orig_norm_size; //float isRatio = featureSize / normSize; //correctionRatio = targetRatio / isRatio / normSize; correction_ratio = target_ratio / feature_size; // RAINER END } #else correction_ratio = weight_scale * (!feature->tilted ? 1 : 0.5); #endif if( !feature->tilted ) { hidfeature->rect[k].p0 = sum_elem_ptr(*sum, tr.y, tr.x); hidfeature->rect[k].p1 = sum_elem_ptr(*sum, tr.y, tr.x + tr.width); hidfeature->rect[k].p2 = sum_elem_ptr(*sum, tr.y + tr.height, tr.x); hidfeature->rect[k].p3 = sum_elem_ptr(*sum, tr.y + tr.height, tr.x + tr.width); } else { hidfeature->rect[k].p2 = sum_elem_ptr(*tilted, tr.y + tr.width, tr.x + tr.width); hidfeature->rect[k].p3 = sum_elem_ptr(*tilted, tr.y + tr.width + tr.height, tr.x + tr.width - tr.height); hidfeature->rect[k].p0 = sum_elem_ptr(*tilted, tr.y, tr.x); hidfeature->rect[k].p1 = sum_elem_ptr(*tilted, tr.y + tr.height, tr.x - tr.height); } // hidfeature->rect[k].weight = (float)(feature->rect[k].weight * correction_ratio); tmpweight[k] = (float)(feature->rect[k].weight * correction_ratio); if( k == 0 ) area0 = tr.width * tr.height; else // sum0 += hidfeature->rect[k].weight * tr.width * tr.height; sum0 += tmpweight[k] * tr.width * tr.height; } tmpweight[0] = (float)(-sum0/area0); for(int ii = 0; ii < nr; hidfeature->rect[ii].weight = (int)(tmpweight[ii] * 65536.0), ii++); } /* l */ } /* j */ } } __END__; } CvMat *temp = 0, *sum = 0, *sqsum = 0; double tickFreqTimes1000 = ((double)cvGetTickFrequency()*1000.); CV_IMPL CvSeq* mycvHaarDetectObjects( const CvArr* _img, CvHaarClassifierCascade* cascade, CvMemStorage* storage, double scale_factor, int min_neighbors, int flags, CvSize min_size ) { int split_stage = 2; CvMat stub, *img = (CvMat*)_img; CvMat *tilted = 0, *norm_img = 0, *sumcanny = 0, *img_small = 0; CvSeq* result_seq = 0; CvMemStorage* temp_storage = 0; CvAvgComp* comps = 0; CvSeq* seq_thread[CV_MAX_THREADS] = {0}; int i, max_threads = 0; double t1; CV_FUNCNAME( "cvHaarDetectObjects" ); __BEGIN__; double t = (double)cvGetTickCount(); CvSeq *seq = 0, *seq2 = 0, *idx_seq = 0, *big_seq = 0; CvAvgComp result_comp = {{0,0,0,0},0}; double factor; int npass = 2, coi; bool do_canny_pruning = (flags & CV_HAAR_DO_CANNY_PRUNING) != 0; bool find_biggest_object = (flags & CV_HAAR_FIND_BIGGEST_OBJECT) != 0; bool rough_search = (flags & CV_HAAR_DO_ROUGH_SEARCH) != 0; if( !CV_IS_HAAR_CLASSIFIER(cascade) ) CV_ERROR( !cascade ? CV_StsNullPtr : CV_StsBadArg, "Invalid classifier cascade" ); if( !storage ) CV_ERROR( CV_StsNullPtr, "Null storage pointer" ); CV_CALL( img = cvGetMat( img, &stub, &coi )); if( coi ) CV_ERROR( CV_BadCOI, "COI is not supported" ); if( CV_MAT_DEPTH(img->type) != CV_8U ) CV_ERROR( CV_StsUnsupportedFormat, "Only 8-bit images are supported" ); if( scale_factor <= 1 ) CV_ERROR( CV_StsOutOfRange, "scale factor must be > 1" ); if( find_biggest_object ) flags &= ~CV_HAAR_SCALE_IMAGE; if(!temp) { CV_CALL( temp = cvCreateMat( img->rows, img->cols, CV_8UC1 )); } if(!sum) { CV_CALL( sum = cvCreateMat( img->rows + 1, img->cols + 1, CV_32SC1 )); } if(!sqsum) { CV_CALL( sqsum = cvCreateMat( img->rows + 1, img->cols + 1, CV_64FC1 )); } CV_CALL( temp_storage = cvCreateChildMemStorage( storage )); if( !cascade->hid_cascade ) CV_CALL( myicvCreateHidHaarClassifierCascade(cascade) ); if( ((MyCvHidHaarClassifierCascade*)cascade->hid_cascade)->has_tilted_features ) tilted = cvCreateMat( img->rows + 1, img->cols + 1, CV_32SC1 ); seq = cvCreateSeq( 0, sizeof(CvSeq), sizeof(CvRect), temp_storage ); seq2 = cvCreateSeq( 0, sizeof(CvSeq), sizeof(CvAvgComp), temp_storage ); result_seq = cvCreateSeq( 0, sizeof(CvSeq), sizeof(CvAvgComp), storage ); max_threads = cvGetNumThreads(); if( max_threads > 1 ) for( i = 0; i < max_threads; i++ ) { CvMemStorage* temp_storage_thread; CV_CALL( temp_storage_thread = cvCreateMemStorage(0)); CV_CALL( seq_thread[i] = cvCreateSeq( 0, sizeof(CvSeq), sizeof(CvRect), temp_storage_thread )); } else seq_thread[0] = seq; if( CV_MAT_CN(img->type) > 1 ) { cvCvtColor( img, temp, CV_BGR2GRAY ); img = temp; } if( flags & CV_HAAR_FIND_BIGGEST_OBJECT ) flags &= ~(CV_HAAR_SCALE_IMAGE|CV_HAAR_DO_CANNY_PRUNING); // if( flags & CV_HAAR_SCALE_IMAGE ) // { // CvSize win_size0 = cascade->orig_window_size; // /*int use_ipp = cascade->hid_cascade->ipp_stages != 0 && // icvApplyHaarClassifier_32f_C1R_p != 0; // // if( use_ipp ) // CV_CALL( norm_img = cvCreateMat( img->rows, img->cols, CV_32FC1 ));*/ // CV_CALL( img_small = cvCreateMat( img->rows + 1, img->cols + 1, CV_8UC1 )); // // for( factor = 1; ; factor *= scale_factor ) // { // int strip_count, strip_size; // int ystep = factor > 2. ? 1 : 2; // CvSize win_size = { cvRound(win_size0.width*factor), // cvRound(win_size0.height*factor) }; // CvSize sz = { cvRound( img->cols/factor ), cvRound( img->rows/factor ) }; // CvSize sz1 = { sz.width - win_size0.width, sz.height - win_size0.height }; // /*CvRect equ_rect = { icv_object_win_border, icv_object_win_border, // win_size0.width - icv_object_win_border*2, // win_size0.height - icv_object_win_border*2 };*/ // CvMat img1, sum1, sqsum1, norm1, tilted1, mask1; // CvMat* _tilted = 0; // // if( sz1.width <= 0 || sz1.height <= 0 ) // break; // if( win_size.width < min_size.width || win_size.height < min_size.height ) // continue; // // img1 = cvMat( sz.height, sz.width, CV_8UC1, img_small->data.ptr ); // sum1 = cvMat( sz.height+1, sz.width+1, CV_32SC1, sum->data.ptr ); // sqsum1 = cvMat( sz.height+1, sz.width+1, CV_64FC1, sqsum->data.ptr ); // if( tilted ) // { // tilted1 = cvMat( sz.height+1, sz.width+1, CV_32SC1, tilted->data.ptr ); // _tilted = &tilted1; // } // norm1 = cvMat( sz1.height, sz1.width, CV_32FC1, norm_img ? norm_img->data.ptr : 0 ); // mask1 = cvMat( sz1.height, sz1.width, CV_8UC1, temp->data.ptr ); // // cvResize( img, &img1, CV_INTER_LINEAR ); // cvIntegral( &img1, &sum1, &sqsum1, _tilted ); // // if( max_threads > 1 ) // { // strip_count = MAX(MIN(sz1.height/ystep, max_threads*3), 1); // strip_size = (sz1.height + strip_count - 1)/strip_count; // strip_size = (strip_size / ystep)*ystep; // } // else // { // strip_count = 1; // strip_size = sz1.height; // } // // //if( !use_ipp ) // cvSetImagesForHaarClassifierCascade( cascade, &sum1, &sqsum1, 0, 1. ); // /*else // { // for( i = 0; i <= sz.height; i++ ) // { // const int* isum = (int*)(sum1.data.ptr + sum1.step*i); // float* fsum = (float*)isum; // const int FLT_DELTA = -(1 << 24); // int j; // for( j = 0; j <= sz.width; j++ ) // fsum[j] = (float)(isum[j] + FLT_DELTA); // } // }*/ // //#ifdef _OPENMP //#pragma omp parallel for num_threads(max_threads) schedule(dynamic) //#endif // for( i = 0; i < strip_count; i++ ) // { // int thread_id = cvGetThreadNum(); // int positive = 0; // int y1 = i*strip_size, y2 = (i+1)*strip_size/* - ystep + 1*/; // CvSize ssz; // int x, y; // if( i == strip_count - 1 || y2 > sz1.height ) // y2 = sz1.height; // ssz = cvSize(sz1.width, y2 - y1); // // /*if( use_ipp ) // { // icvRectStdDev_32f_C1R_p( // (float*)(sum1.data.ptr + y1*sum1.step), sum1.step, // (double*)(sqsum1.data.ptr + y1*sqsum1.step), sqsum1.step, // (float*)(norm1.data.ptr + y1*norm1.step), norm1.step, ssz, equ_rect ); // // positive = (ssz.width/ystep)*((ssz.height + ystep-1)/ystep); // memset( mask1.data.ptr + y1*mask1.step, ystep == 1, mask1.height*mask1.step); // // if( ystep > 1 ) // { // for( y = y1, positive = 0; y < y2; y += ystep ) // for( x = 0; x < ssz.width; x += ystep ) // mask1.data.ptr[mask1.step*y + x] = (uchar)1; // } // // for( int j = 0; j < cascade->count; j++ ) // { // if( icvApplyHaarClassifier_32f_C1R_p( // (float*)(sum1.data.ptr + y1*sum1.step), sum1.step, // (float*)(norm1.data.ptr + y1*norm1.step), norm1.step, // mask1.data.ptr + y1*mask1.step, mask1.step, ssz, &positive, // cascade->hid_cascade->stage_classifier[j].threshold, // cascade->hid_cascade->ipp_stages[j]) < 0 ) // { // positive = 0; // break; // } // if( positive <= 0 ) // break; // } // } // else*/ // { // for( y = y1, positive = 0; y < y2; y += ystep ) // for( x = 0; x < ssz.width; x += ystep ) // { // mask1.data.ptr[mask1.step*y + x] = // mycvRunHaarClassifierCascade( cascade, cvPoint(x,y), 0 ) > 0; // positive += mask1.data.ptr[mask1.step*y + x]; // } // } // // if( positive > 0 ) // { // for( y = y1; y < y2; y += ystep ) // for( x = 0; x < ssz.width; x += ystep ) // if( mask1.data.ptr[mask1.step*y + x] != 0 ) // { // CvRect obj_rect = { cvRound(x*factor), cvRound(y*factor), // win_size.width, win_size.height }; // cvSeqPush( seq_thread[thread_id], &obj_rect ); // } // } // } // // // gather the results // if( max_threads > 1 ) // for( i = 0; i < max_threads; i++ ) // { // CvSeq* s = seq_thread[i]; // int j, total = s->total; // CvSeqBlock* b = s->first; // for( j = 0; j < total; j += b->count, b = b->next ) // cvSeqPushMulti( seq, b->data, b->count ); // } // } // } // else t1 = (double)cvGetTickCount(); // printf( "init time = %gms\n", (t1 - t)/tickFreqTimes1000); t = t1; { int n_factors = 0; CvRect scan_roi_rect = {0,0,0,0}; bool is_found = false, scan_roi = false; cvIntegral( img, sum, sqsum, tilted ); // if( do_canny_pruning ) // { // sumcanny = cvCreateMat( img->rows + 1, img->cols + 1, CV_32SC1 ); // cvCanny( img, temp, 0, 50, 3 ); // cvIntegral( temp, sumcanny ); // } if( (unsigned)split_stage >= (unsigned)cascade->count || ((MyCvHidHaarClassifierCascade*)cascade->hid_cascade)->is_tree ) { split_stage = cascade->count; npass = 1; } for( n_factors = 0, factor = 1; factor*cascade->orig_window_size.width < img->cols - 10 && factor*cascade->orig_window_size.height < img->rows - 10; n_factors++, factor *= scale_factor ) ; if( find_biggest_object ) { scale_factor = 1./scale_factor; factor *= scale_factor; big_seq = cvCreateSeq( 0, sizeof(CvSeq), sizeof(CvRect), temp_storage ); } else factor = 1; for( ; n_factors-- > 0 && !is_found; factor *= scale_factor ) { const double ystep = MAX( 2, factor ); CvSize win_size = { cvRound( cascade->orig_window_size.width * factor ), cvRound( cascade->orig_window_size.height * factor )}; CvRect equ_rect = { 0, 0, 0, 0 }; int *p0 = 0, *p1 = 0, *p2 = 0, *p3 = 0; int *pq0 = 0, *pq1 = 0, *pq2 = 0, *pq3 = 0; int pass, stage_offset = 0; int start_x = 0, start_y = 0; int end_x = cvRound((img->cols - win_size.width) / ystep); int end_y = cvRound((img->rows - win_size.height) / ystep); if( win_size.width < min_size.width || win_size.height < min_size.height ) { if( find_biggest_object ) break; continue; } mycvSetImagesForHaarClassifierCascade( cascade, sum, sqsum, tilted, factor ); cvZero( temp ); // if( do_canny_pruning ) // { // equ_rect.x = cvRound(win_size.width*0.15); // equ_rect.y = cvRound(win_size.height*0.15); // equ_rect.width = cvRound(win_size.width*0.7); // equ_rect.height = cvRound(win_size.height*0.7); // // p0 = (int*)(sumcanny->data.ptr + equ_rect.y*sumcanny->step) + equ_rect.x; // p1 = (int*)(sumcanny->data.ptr + equ_rect.y*sumcanny->step) // + equ_rect.x + equ_rect.width; // p2 = (int*)(sumcanny->data.ptr + (equ_rect.y + equ_rect.height)*sumcanny->step) + equ_rect.x; // p3 = (int*)(sumcanny->data.ptr + (equ_rect.y + equ_rect.height)*sumcanny->step) // + equ_rect.x + equ_rect.width; // // pq0 = (int*)(sum->data.ptr + equ_rect.y*sum->step) + equ_rect.x; // pq1 = (int*)(sum->data.ptr + equ_rect.y*sum->step) // + equ_rect.x + equ_rect.width; // pq2 = (int*)(sum->data.ptr + (equ_rect.y + equ_rect.height)*sum->step) + equ_rect.x; // pq3 = (int*)(sum->data.ptr + (equ_rect.y + equ_rect.height)*sum->step) // + equ_rect.x + equ_rect.width; // } if( scan_roi ) { //adjust start_height and stop_height start_y = cvRound(scan_roi_rect.y / ystep); end_y = cvRound((scan_roi_rect.y + scan_roi_rect.height - win_size.height) / ystep); start_x = cvRound(scan_roi_rect.x / ystep); end_x = cvRound((scan_roi_rect.x + scan_roi_rect.width - win_size.width) / ystep); } ((MyCvHidHaarClassifierCascade*)cascade->hid_cascade)->count = split_stage; for( pass = 0; pass < npass; pass++ ) { #ifdef _OPENMP #pragma omp parallel for num_threads(max_threads) schedule(dynamic) #endif for( int _iy = start_y; _iy < end_y; _iy++ ) { int thread_id = cvGetThreadNum(); int iy = cvRound(_iy*ystep); int _ix, _xstep = 1; uchar* mask_row = temp->data.ptr + temp->step * iy; for( _ix = start_x; _ix < end_x; _ix += _xstep ) { int ix = cvRound(_ix*ystep); // it really should be ystep if( pass == 0 ) { int result; _xstep = 2; // if( do_canny_pruning ) // { // int offset; // int s, sq; // // offset = iy*(sum->step/sizeof(p0[0])) + ix; // s = p0[offset] - p1[offset] - p2[offset] + p3[offset]; // sq = pq0[offset] - pq1[offset] - pq2[offset] + pq3[offset]; // if( s < 100 || sq < 20 ) // continue; // } result = mycvRunHaarClassifierCascade( cascade, cvPoint(ix,iy), 0 ); if( result > 0 ) { if( pass < npass - 1 ) mask_row[ix] = 1; else { CvRect rect = cvRect(ix,iy,win_size.width,win_size.height); cvSeqPush( seq_thread[thread_id], &rect ); } } if( result < 0 ) _xstep = 1; } else if( mask_row[ix] ) { int result = mycvRunHaarClassifierCascade( cascade, cvPoint(ix,iy), stage_offset ); if( result > 0 ) { if( pass == npass - 1 ) { CvRect rect = cvRect(ix,iy,win_size.width,win_size.height); cvSeqPush( seq_thread[thread_id], &rect ); } } else mask_row[ix] = 0; } } } stage_offset = ((MyCvHidHaarClassifierCascade*)cascade->hid_cascade)->count; ((MyCvHidHaarClassifierCascade*)cascade->hid_cascade)->count = cascade->count; } // gather the results if( max_threads > 1 ) for( i = 0; i < max_threads; i++ ) { CvSeq* s = seq_thread[i]; int j, total = s->total; CvSeqBlock* b = s->first; for( j = 0; j < total; j += b->count, b = b->next ) cvSeqPushMulti( seq, b->data, b->count ); } if( find_biggest_object ) { CvSeq* bseq = min_neighbors > 0 ? big_seq : seq; if( min_neighbors > 0 && !scan_roi ) { // group retrieved rectangles in order to filter out noise int ncomp = cvSeqPartition( seq, 0, &idx_seq, myis_equal, 0 ); CV_CALL( comps = (CvAvgComp*)cvAlloc( (ncomp+1)*sizeof(comps[0]))); memset( comps, 0, (ncomp+1)*sizeof(comps[0])); #if VERY_ROUGH_SEARCH if( rough_search ) { for( i = 0; i < seq->total; i++ ) { CvRect r1 = *(CvRect*)cvGetSeqElem( seq, i ); int idx = *(int*)cvGetSeqElem( idx_seq, i ); assert( (unsigned)idx < (unsigned)ncomp ); comps[idx].neighbors++; comps[idx].rect.x += r1.x; comps[idx].rect.y += r1.y; comps[idx].rect.width += r1.width; comps[idx].rect.height += r1.height; } // calculate average bounding box for( i = 0; i < ncomp; i++ ) { int n = comps[i].neighbors; if( n >= min_neighbors ) { CvAvgComp comp; comp.rect.x = (comps[i].rect.x*2 + n)/(2*n); comp.rect.y = (comps[i].rect.y*2 + n)/(2*n); comp.rect.width = (comps[i].rect.width*2 + n)/(2*n); comp.rect.height = (comps[i].rect.height*2 + n)/(2*n); comp.neighbors = n; cvSeqPush( bseq, &comp ); } } } else #endif { for( i = 0 ; i <= ncomp; i++ ) comps[i].rect.x = comps[i].rect.y = INT_MAX; // count number of neighbors for( i = 0; i < seq->total; i++ ) { CvRect r1 = *(CvRect*)cvGetSeqElem( seq, i ); int idx = *(int*)cvGetSeqElem( idx_seq, i ); assert( (unsigned)idx < (unsigned)ncomp ); comps[idx].neighbors++; // rect.width and rect.height will store coordinate of right-bottom corner comps[idx].rect.x = MIN(comps[idx].rect.x, r1.x); comps[idx].rect.y = MIN(comps[idx].rect.y, r1.y); comps[idx].rect.width = MAX(comps[idx].rect.width, r1.x+r1.width-1); comps[idx].rect.height = MAX(comps[idx].rect.height, r1.y+r1.height-1); } // calculate enclosing box for( i = 0; i < ncomp; i++ ) { int n = comps[i].neighbors; if( n >= min_neighbors ) { CvAvgComp comp; int t; double min_scale = rough_search ? 0.6 : 0.4; comp.rect.x = comps[i].rect.x; comp.rect.y = comps[i].rect.y; comp.rect.width = comps[i].rect.width - comps[i].rect.x + 1; comp.rect.height = comps[i].rect.height - comps[i].rect.y + 1; // update min_size t = cvRound( comp.rect.width*min_scale ); min_size.width = MAX( min_size.width, t ); t = cvRound( comp.rect.height*min_scale ); min_size.height = MAX( min_size.height, t ); //expand the box by 20% because we could miss some neighbours //see 'is_equal' function #if 1 int offset = cvRound(comp.rect.width * 0.2); int right = MIN( img->cols-1, comp.rect.x+comp.rect.width-1 + offset ); int bottom = MIN( img->rows-1, comp.rect.y+comp.rect.height-1 + offset); comp.rect.x = MAX( comp.rect.x - offset, 0 ); comp.rect.y = MAX( comp.rect.y - offset, 0 ); comp.rect.width = right - comp.rect.x + 1; comp.rect.height = bottom - comp.rect.y + 1; #endif comp.neighbors = n; cvSeqPush( bseq, &comp ); } } } cvFree( &comps ); } // extract the biggest rect if( bseq->total > 0 ) { int max_area = 0; for( i = 0; i < bseq->total; i++ ) { CvAvgComp* comp = (CvAvgComp*)cvGetSeqElem( bseq, i ); int area = comp->rect.width * comp->rect.height; if( max_area < area ) { max_area = area; result_comp.rect = comp->rect; result_comp.neighbors = bseq == seq ? 1 : comp->neighbors; } } //Prepare information for further scanning inside the biggest rectangle #if VERY_ROUGH_SEARCH // change scan ranges to roi in case of required if( !rough_search && !scan_roi ) { scan_roi = true; scan_roi_rect = result_comp.rect; cvClearSeq(bseq); } else if( rough_search ) is_found = true; #else if( !scan_roi ) { scan_roi = true; scan_roi_rect = result_comp.rect; cvClearSeq(bseq); } #endif } } } } // t1 = (double)cvGetTickCount(); // printf( "factors time = %gms\n", (t1 - t)/tickFreqTimes1000); // t = t1; if( min_neighbors == 0 && !find_biggest_object ) { for( i = 0; i < seq->total; i++ ) { CvRect* rect = (CvRect*)cvGetSeqElem( seq, i ); CvAvgComp comp; comp.rect = *rect; comp.neighbors = 1; cvSeqPush( result_seq, &comp ); } } if( min_neighbors != 0 #if VERY_ROUGH_SEARCH && (!find_biggest_object || !rough_search) #endif ) { // group retrieved rectangles in order to filter out noise int ncomp = cvSeqPartition( seq, 0, &idx_seq, myis_equal, 0 ); CV_CALL( comps = (CvAvgComp*)cvAlloc( (ncomp+1)*sizeof(comps[0]))); memset( comps, 0, (ncomp+1)*sizeof(comps[0])); // count number of neighbors for( i = 0; i < seq->total; i++ ) { CvRect r1 = *(CvRect*)cvGetSeqElem( seq, i ); int idx = *(int*)cvGetSeqElem( idx_seq, i ); assert( (unsigned)idx < (unsigned)ncomp ); comps[idx].neighbors++; comps[idx].rect.x += r1.x; comps[idx].rect.y += r1.y; comps[idx].rect.width += r1.width; comps[idx].rect.height += r1.height; } // calculate average bounding box for( i = 0; i < ncomp; i++ ) { int n = comps[i].neighbors; if( n >= min_neighbors ) { CvAvgComp comp; comp.rect.x = (comps[i].rect.x*2 + n)/(2*n); comp.rect.y = (comps[i].rect.y*2 + n)/(2*n); comp.rect.width = (comps[i].rect.width*2 + n)/(2*n); comp.rect.height = (comps[i].rect.height*2 + n)/(2*n); comp.neighbors = comps[i].neighbors; cvSeqPush( seq2, &comp ); } } if( !find_biggest_object ) { // filter out small face rectangles inside large face rectangles for( i = 0; i < seq2->total; i++ ) { CvAvgComp r1 = *(CvAvgComp*)cvGetSeqElem( seq2, i ); int j, flag = 1; for( j = 0; j < seq2->total; j++ ) { CvAvgComp r2 = *(CvAvgComp*)cvGetSeqElem( seq2, j ); int distance = cvRound( r2.rect.width * 0.2 ); if( i != j && r1.rect.x >= r2.rect.x - distance && r1.rect.y >= r2.rect.y - distance && r1.rect.x + r1.rect.width <= r2.rect.x + r2.rect.width + distance && r1.rect.y + r1.rect.height <= r2.rect.y + r2.rect.height + distance && (r2.neighbors > MAX( 3, r1.neighbors ) || r1.neighbors < 3) ) { flag = 0; break; } } if( flag ) cvSeqPush( result_seq, &r1 ); } } else { int max_area = 0; for( i = 0; i < seq2->total; i++ ) { CvAvgComp* comp = (CvAvgComp*)cvGetSeqElem( seq2, i ); int area = comp->rect.width * comp->rect.height; if( max_area < area ) { max_area = area; result_comp = *comp; } } } } t1 = (double)cvGetTickCount(); // printf( "results eval time = %gms\n", (t1 - t)/tickFreqTimes1000); t = t1; if( find_biggest_object && result_comp.rect.width > 0 ) cvSeqPush( result_seq, &result_comp ); __END__; if( max_threads > 1 ) for( i = 0; i < max_threads; i++ ) { if( seq_thread[i] ) cvReleaseMemStorage( &seq_thread[i]->storage ); } cvReleaseMemStorage( &temp_storage ); cvReleaseMat( &sum ); cvReleaseMat( &sqsum ); cvReleaseMat( &tilted ); cvReleaseMat( &temp ); cvReleaseMat( &sumcanny ); cvReleaseMat( &norm_img ); cvReleaseMat( &img_small ); cvFree( &comps ); return result_seq; }