cvhaar.cpp.svn-base

来自「非结构化路识别」· SVN-BASE 代码 · 共 1,285 行 · 第 1/4 页

            stage_offset = hid_cascade->count;
            hid_cascade->count = hid_cascade_count0;
        }
    }

    if( min_neighbors != 0 )
    {
        // group retrieved rectangles in order to filter out noise 
        ncomp = cvPartitionSeq( seq, 0, &idx_seq, is_equal, 0, 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 );
            }
        }

        // 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 );
                /* cvSeqPush( result_seq, &r1.rect ); */
            }
        }
    }

    __END__;

    cvReleaseMemStorage( &temp_storage );
    cvReleaseImage( &sum );
    cvReleaseImage( &sqsum );
    cvReleaseImage( &tilted );
    cvReleaseImage( &temp );
    cvReleaseImage( &sumcanny );

    cvFree( (void**)&comps );

    return result_seq;
}


CV_IMPL void
cvReleaseHidHaarClassifierCascade( CvHidHaarClassifierCascade** cascade )
{
    CV_FUNCNAME("cvGetHaarClassifierCascadeWindowSize");

    __BEGIN__;

    void* c;

    if( !cascade )
        CV_ERROR( CV_StsNullPtr, "" );

    if( *cascade && (*cascade)->headerSize != sizeof(**cascade))
        CV_ERROR( CV_StsNullPtr, "Invalid CvHidHaarClassifierCascade header" );

    c = *cascade;
    *cascade = 0;
    cvFree( &c );

    __END__;
}


static CvHaarClassifierCascade*
icvLoadCascadeCART( const char** input_cascade, int n, CvSize origWindowSize )
{
    int i;
    CvHaarClassifierCascade* cascade = 0;

    cascade = (CvHaarClassifierCascade*)cvAlloc( sizeof(*cascade) +
                                           n*sizeof(*cascade->stageClassifier));
    cascade->count = n;
    cascade->origWindowSize = origWindowSize;
    cascade->stageClassifier = (CvHaarStageClassifier*)(cascade + 1);

    for( i = 0; i < n; i++ )
    {
        int j, count, l;
        float threshold = 0;
        const char* stage = input_cascade[i];
        int dl = 0;

        sscanf( stage, "%d%n", &count, &dl );
        stage += dl;
        
        assert( count > 0 );
        cascade->stageClassifier[i].count = count;
        cascade->stageClassifier[i].classifier =
            (CvHaarClassifier*)cvAlloc( count*sizeof(cascade->stageClassifier[i].classifier[0]));

        for( j = 0; j < count; j++ )
        {
            CvHaarClassifier* classifier = cascade->stageClassifier[i].classifier + j;
            int k, rects = 0;
            char str[100];
            
            sscanf( stage, "%d%n", &classifier->count, &dl );
            stage += dl;

            classifier->haarFeature = (CvHaarFeature*) cvAlloc( 
                classifier->count * ( sizeof( *classifier->haarFeature ) +
                                      sizeof( *classifier->threshold ) +
                                      sizeof( *classifier->left ) +
                                      sizeof( *classifier->right ) ) +
                (classifier->count + 1) * sizeof( *classifier->alpha ) );
            classifier->threshold = (float*) (classifier->haarFeature+classifier->count);
            classifier->left = (int*) (classifier->threshold + classifier->count);
            classifier->right = (int*) (classifier->left + classifier->count);
            classifier->alpha = (float*) (classifier->right + classifier->count);
            
            for( l = 0; l < classifier->count; l++ )
            {
                sscanf( stage, "%d%n", &rects, &dl );
                stage += dl;

                assert( rects >= 2 && rects <= CV_HAAR_FEATURE_MAX );

                for( k = 0; k < rects; k++ )
                {
                    CvRect r;
                    int band = 0;
                    sscanf( stage, "%d%d%d%d%d%f%n",
                            &r.x, &r.y, &r.width, &r.height, &band,
                            &(classifier->haarFeature[l].rect[k].weight), &dl );
                    stage += dl;
                    classifier->haarFeature[l].rect[k].r = r;
                }
                sscanf( stage, "%s%n", str, &dl );
                stage += dl;
            
                classifier->haarFeature[l].tilted = strncmp( str, "tilted", 6 ) == 0;
            
                for( k = rects; k < CV_HAAR_FEATURE_MAX; k++ )
                {
                    memset( classifier->haarFeature[l].rect + k, 0,
                            sizeof(classifier->haarFeature[l].rect[k]) );
                }
                
                sscanf( stage, "%f%d%d%n", &(classifier->threshold[l]), 
                                       &(classifier->left[l]),
                                       &(classifier->right[l]), &dl );
                stage += dl;
            }
            for( l = 0; l <= classifier->count; l++ )
            {
                sscanf( stage, "%f%n", &(classifier->alpha[l]), &dl );
                stage += dl;
            }
        }
       
        sscanf( stage, "%f%n", &threshold, &dl );
        stage += dl;

        cascade->stageClassifier[i].threshold = threshold;
    }

    return cascade;
}

#ifndef _MAX_PATH
#define _MAX_PATH 1024
#endif

extern const char* icvDefaultFaceCascade[];

CV_IMPL CvHaarClassifierCascade*
cvLoadHaarClassifierCascade( const char* directory, CvSize origWindowSize )
{
    const char** input_cascade = 0; 
    CvHaarClassifierCascade *cascade = 0;

    CV_FUNCNAME( "cvLoadHaarClassifierCascade" );

    __BEGIN__;

    int n;
    char name[_MAX_PATH];

    if( strcmp( directory, "<default_face_cascade>" ) == 0 )
    {
        input_cascade = icvDefaultFaceCascade;
        for( n = 0; input_cascade[n] != 0; n++ )
            ;
    }
    else
    {
        int i, size = 0;
        char* ptr;
        
        for( n = 0; ; n++ )
        {
            sprintf( name, "%s/%d/AdaBoostCARTHaarClassifier.txt", directory, n );
            FILE* f = fopen( name, "rb" );
            if( !f )
                break;
            fseek( f, 0, SEEK_END );
            size += ftell( f ) + 1;
            fclose(f);
        }

        size += (n+1)*sizeof(char*);
        CV_CALL( input_cascade = (const char**)cvAlloc( size ));
        ptr = (char*)(input_cascade + n + 1);

        for( i = 0; i < n; i++ )
        {
            sprintf( name, "%s/%d/AdaBoostCARTHaarClassifier.txt", directory, i );
            FILE* f = fopen( name, "rb" );
            if( !f )
                CV_ERROR( CV_StsError, "" );
            fseek( f, 0, SEEK_END );
            size = ftell( f );
            fseek( f, 0, SEEK_SET );
            fread( ptr, 1, size, f );
            fclose(f);
            input_cascade[i] = ptr;
            ptr += size;
            *ptr++ = '\0';
        }
        input_cascade[n] = 0;
    }

    if( n == 0 )
        CV_ERROR( CV_StsBadArg, "Invalid path" );

    cascade = icvLoadCascadeCART( input_cascade, n, origWindowSize );

    __END__;

    if( input_cascade != icvDefaultFaceCascade )
    {
        cvFree( (void**)&input_cascade );
    }

    if( cvGetErrStatus() < 0 )
        cvReleaseHaarClassifierCascade( &cascade );

    return cascade;
}


CV_IMPL void
cvReleaseHaarClassifierCascade( CvHaarClassifierCascade** cascade )
{
    if( cascade && *cascade )
    {
        int i;
        int j;

        for( i = 0; i < cascade[0]->count; i++ )
        {
            for( j = 0; j < cascade[0]->stageClassifier[i].count; j++ )
            {
                cvFree( (void**)
                    &(cascade[0]->stageClassifier[i].classifier[j].haarFeature) );
            }
            cvFree( (void**) &(cascade[0]->stageClassifier[i].classifier) );
        }
        cvFree( (void**)cascade );
    }
}


/* End of file. */