ahistograms.cpp

微软的基于HMM的人脸识别原代码, 非常经典的说

            trsWrite( ATS_CON | ATS_LST, "Uniform 8u calc, Intersection error: act %f   exp 0 - "
                                         "histograms not equals\n",
                      (float)cvCompareHist( hist1, hist3, CV_COMP_CHISQR ) );
            trsWrite( ATS_CON | ATS_LST, "Size " );
            for( i = 0; i < c_dims; i++ )
                trsWrite( ATS_CON | ATS_LST, "%d  ", hist1->dims[i] );
            trsWrite( ATS_CON | ATS_LST, "\n" );
            errors++;
        }

        /* Clearing histograms */
        if(type == CV_HIST_ARRAY)
        {
            memset(hist2->array, 1, hist2->dims[0] * hist2->mdims[0] * sizeof(*hist2->array));
            memset(hist3->array, 1, hist2->dims[0] * hist2->mdims[0] * sizeof(*hist2->array));
        }

        /* Calculating histograms 8s */
        cvCalcHist( src8s, hist2, 0 );
        cvCalcHist( src8s, hist3, 0 );
        /* Checking histogram */
        if( cvCompareHist( hist1, hist2, CV_COMP_CHISQR ) != 0 )
        {
            trsWrite( ATS_CON | ATS_LST, "Non uniform 8s calc, Intersection error: act %f   exp 0 - "
                                         "histograms not equals\n",
                      (float)cvCompareHist( hist1, hist2, CV_COMP_CHISQR ) );
            trsWrite( ATS_CON | ATS_LST, "Size " );
            for( i = 0; i < c_dims; i++ )
                trsWrite( ATS_CON | ATS_LST, "%d  ", hist1->dims[i] );
            trsWrite( ATS_CON | ATS_LST, "\n" );
            errors++;
        }
        if( cvCompareHist( hist1, hist3, CV_COMP_CHISQR ) != 0 )
        {
            trsWrite( ATS_CON | ATS_LST, "Uniform 8s calc, Intersection error: act %f   exp 0 - "
                                         "histograms not equals\n",
                      (float)cvCompareHist( hist1, hist3, CV_COMP_CHISQR ) );
            trsWrite( ATS_CON | ATS_LST, "Size " );
            for( i = 0; i < c_dims; i++ )
                trsWrite( ATS_CON | ATS_LST, "%d  ", hist1->dims[i] );
            trsWrite( ATS_CON | ATS_LST, "\n" );
            errors++;
        }

        /* Clearing histograms */
        if(type == CV_HIST_ARRAY)
        {
            memset(hist2->array, 1, hist2->dims[0] * hist2->mdims[0] * sizeof(*hist2->array));
            memset(hist3->array, 1, hist2->dims[0] * hist2->mdims[0] * sizeof(*hist2->array));
        }

        /* Calculating histograms 32f */
        cvCalcHist( src32f, hist2, 0 );
        cvCalcHist( src32f, hist3, 0 );
        /* Checking histogram */
        if( cvCompareHist( hist1, hist2, CV_COMP_CHISQR ) != 0 )
        {
            trsWrite( ATS_CON | ATS_LST, "Non uniform 32f calc, Intersection error: act %f   exp 0 - "
                                         "histograms not equals\n",
                      (float)cvCompareHist( hist1, hist2, CV_COMP_CHISQR ) );
            trsWrite( ATS_CON | ATS_LST, "Size " );
            for( i = 0; i < c_dims; i++ )
                trsWrite( ATS_CON | ATS_LST, "%d  ", hist1->dims[i] );
            trsWrite( ATS_CON | ATS_LST, "\n" );
            errors++;
        }
        if( cvCompareHist( hist1, hist3, CV_COMP_CHISQR ) != 0 )
        {
            trsWrite( ATS_CON | ATS_LST, "Uniform 32f calc, Intersection error: act %f   exp 0 - "
                                         "histograms not equals\n",
                      (float)cvCompareHist( hist1, hist3, CV_COMP_CHISQR ) );
            trsWrite( ATS_CON | ATS_LST, "Size " );
            for( i = 0; i < c_dims; i++ )
                trsWrite( ATS_CON | ATS_LST, "%d  ", hist1->dims[i] );
            trsWrite( ATS_CON | ATS_LST, "\n" );
            errors++;
        }

        for( i = 0; i < c_dims; i++ )
        {
            cvReleaseImage( &src8u[i] );
            cvReleaseImage( &src8s[i] );
            cvReleaseImage( &src32f[i] );
            icvFree( &thresh[i] );
            icvFree( &threshe[i] );
        }
        cvReleaseHist( &hist1 );
        cvReleaseHist( &hist2 );
        cvReleaseHist( &hist3 );

    }
    return errors ? trsResult( TRS_FAIL, "Total fixed %d errors", errors ) : TRS_OK;
}


static int foaCalcHistMask(void* _type)
{
    CvHistType type = (CvHistType)(int)_type;
    static int c_dimss;
    static int dims;
    static int init = 0;
    static int width;
    static int height;

    CvHistogram* hist1;
    CvHistogram* hist2;
    CvHistogram* hist3;

    int    c_dims;
    int    d[CV_HIST_MAX_DIM + 1];
    float* thresh[CV_HIST_MAX_DIM];
    float* threshe[CV_HIST_MAX_DIM];
    int    i, j, x, y, fl;
    IplImage* src8u[CV_HIST_MAX_DIM];
    IplImage* src8s[CV_HIST_MAX_DIM];
    IplImage* src32f[CV_HIST_MAX_DIM];
    int    step8u, step8s, step32f;
    IplImage* mask;
    int    mask_step;

    int errors = 0;

    if( !init )
    {
        init = 1;
        trsiRead( &c_dimss, "6", "Number of dimensions" );
        trsiRead( &dims, "10", "Size of every dimension" );
        trsiRead( &width, "16", "Width of source picture" );
        trsiRead( &height, "16", "Height of source picture" );
    }

    mask = cvCreateImage(cvSize(width, height), IPL_DEPTH_8U, 1);
    mask_step = mask->widthStep;
    for(i = 0; i < height * mask_step; i++) mask->imageData[i] = (uchar)(i & 1);

    for( c_dims = 1; c_dims <= c_dimss; c_dims++ )
    {
        trsWrite( ATS_CON, "Dimension %d\n", c_dims );
        /*Creating & filling histograms*/
        for( i = 0; i < c_dims; i++ ) d[i] = dims;
        hist1 = cvCreateHist( c_dims, d, type );
        hist2 = cvCreateHist( c_dims, d, type );
        hist3 = cvCreateHist( c_dims, d, type );

        for( i = 0; i < c_dims; i++ )
        {
            thresh[i] = (float*)icvAlloc( (hist1->dims[i] + 1) * sizeof(**hist1->thresh));
            threshe[i] = (float*)icvAlloc( 2 * sizeof(**hist1->thresh));
            thresh[i][0] = threshe[i][0] = 0.5;
            threshe[i][1] = thresh[i][hist1->dims[i]] = 0.5f + hist1->dims[i];
            for( j = 1; j < hist1->dims[i]; j++ ) thresh[i][j] = 0.5f + j;
        }

        cvSetHistThresh( hist2, thresh, 0 );
        cvSetHistThresh( hist3, threshe, 1 );

        for( i = 0; i < c_dims; i++ )
        {
            src8u[i] = cvCreateImage(cvSize(width, height), IPL_DEPTH_8U, 1);
            src8s[i] = cvCreateImage(cvSize(width, height), IPL_DEPTH_8S, 1);
            src32f[i] = cvCreateImage(cvSize(width, height), IPL_DEPTH_32F, 1);
        }
        
        step8u = src8u[0]->widthStep;
        step8s = src8s[0]->widthStep;
        step32f = src32f[0]->widthStep;

        for( i = 0; i < c_dims; i++ )
            for( y = 0; y < height; y++ )
                for( x = 0; x < width; x++ )
                {
                    ((float*)(src32f[i]->imageData))[y * step32f / 4 + x] =
                        src8u[i]->imageData[y * step8s + x] =
                        src8s[i]->imageData[y * step8u + x] = (char)x;
                }

        /* Filling control histogram */
        for( i = 0; i <= CV_HIST_MAX_DIM; i++ ) d[i] = 0;
        for( i = 0; i < c_dims; )
        {
            for( j = 1, fl = 1; j < c_dims; j++ ) fl &= (d[j-1] == d[j]);
            (*cvGetHistValue_nD( hist1, d )) = (float)(fl * height * !(d[0] & 1));
            for( i = 0; d[i]++, d[i] >= dims && i < CV_HIST_MAX_DIM; i++ ) d[i] = 0;
        }

        /* Clearing histograms */
        if(type == CV_HIST_ARRAY)
        {
            memset(hist2->array, 1, hist2->dims[0] * hist2->mdims[0] * sizeof(*hist2->array));
            memset(hist3->array, 1, hist2->dims[0] * hist2->mdims[0] * sizeof(*hist2->array));
        }

        /* Calculating histograms 8u */
        cvCalcHistMask( src8u, mask, hist2, 0 );
        cvCalcHistMask( src8u, mask, hist3, 0 );
        /* Checking histogram */
        if( cvCompareHist( hist1, hist2, CV_COMP_CHISQR ) != 0 )
        {
            trsWrite( ATS_CON | ATS_LST, "Non uniform 8u calc, Intersection error: act %f   exp 0 - "
                                         "histograms not equals\n",
                      (float)cvCompareHist( hist1, hist2, CV_COMP_CHISQR ) );
            trsWrite( ATS_CON | ATS_LST, "Size " );
            for( i = 0; i < c_dims; i++ )
                trsWrite( ATS_CON | ATS_LST, "%d  ", hist1->dims[i] );
            trsWrite( ATS_CON | ATS_LST, "\n" );
            errors++;
        }
        if( cvCompareHist( hist1, hist3, CV_COMP_CHISQR ) != 0 )
        {
            trsWrite( ATS_CON | ATS_LST, "Uniform 8u calc, Intersection error: act %f   exp 0 - "
                                         "histograms not equals\n",
                      (float)cvCompareHist( hist1, hist3, CV_COMP_CHISQR ) );
            trsWrite( ATS_CON | ATS_LST, "Size " );
            for( i = 0; i < c_dims; i++ )
                trsWrite( ATS_CON | ATS_LST, "%d  ", hist1->dims[i] );
            trsWrite( ATS_CON | ATS_LST, "\n" );
            errors++;
        }

        /* Clearing histograms */
        if(type == CV_HIST_ARRAY)
        {
            memset(hist2->array, 1, hist2->dims[0] * hist2->mdims[0] * sizeof(*hist2->array));
            memset(hist3->array, 1, hist2->dims[0] * hist2->mdims[0] * sizeof(*hist2->array));
        }

        /* Calculating histograms 8s */
        cvCalcHistMask( src8s, mask, hist2, 0 );
        cvCalcHistMask( src8s, mask, hist3, 0 );
        /* Checking histogram */
        if( cvCompareHist( hist1, hist2, CV_COMP_CHISQR ) != 0 )
        {
            trsWrite( ATS_CON | ATS_LST, "Non uniform 8s calc, Intersection error: act %f   exp 0 - "
                                         "histograms not equals\n",
                      (float)cvCompareHist( hist1, hist2, CV_COMP_CHISQR ) );
            trsWrite( ATS_CON | ATS_LST, "Size " );
            for( i = 0; i < c_dims; i++ )
                trsWrite( ATS_CON | ATS_LST, "%d  ", hist1->dims[i] );
            trsWrite( ATS_CON | ATS_LST, "\n" );
            errors++;
        }
        if( cvCompareHist( hist1, hist3, CV_COMP_CHISQR ) != 0 )
        {
            trsWrite( ATS_CON | ATS_LST, "Uniform 8s calc, Intersection error: act %f   exp 0 - "
                                         "histograms not equals\n",
                      (float)cvCompareHist( hist1, hist3, CV_COMP_CHISQR ) );
            trsWrite( ATS_CON | ATS_LST, "Size " );
            for( i = 0; i < c_dims; i++ )
                trsWrite( ATS_CON | ATS_LST, "%d  ", hist1->dims[i] );
            trsWrite( ATS_CON | ATS_LST, "\n" );
            errors++;
        }

        /* Clearing histograms */
        if(type == CV_HIST_ARRAY)
        {
            memset(hist2->array, 1, hist2->dims[0] * hist2->mdims[0] * sizeof(*hist2->array));
            memset(hist3->array, 1, hist2->dims[0] * hist2->mdims[0] * sizeof(*hist2->array));
        }

        /* Calculating histograms 32f */
        cvCalcHistMask( src32f, mask, hist2, 0 );
        cvCalcHistMask( src32f, mask, hist3, 0 );
        /* Checking histogram */
        if( cvCompareHist( hist1, hist2, CV_COMP_CHISQR ) != 0 )
        {
            trsWrite( ATS_CON | ATS_LST, "Non uniform 32f calc, Intersection error: act %f   exp 0 - "
                                         "histograms not equals\n",
                      (float)cvCompareHist( hist1, hist2, CV_COMP_CHISQR ) );
            trsWrite( ATS_CON | ATS_LST, "Size " );
            for( i = 0; i < c_dims; i++ )
                trsWrite( ATS_CON | ATS_LST, "%d  ", hist1->dims[i] );
            trsWrite( ATS_CON | ATS_LST, "\n" );
            errors++;
        }
        if( cvCompareHist( hist1, hist3, CV_COMP_CHISQR ) != 0 )
        {
            trsWrite( ATS_CON | ATS_LST, "Uniform 32f calc, Intersection error: act %f   exp 0 - "
                                         "histograms not equals\n",
                      (float)cvCompareHist( hist1, hist3, CV_COMP_CHISQR ) );
            trsWrite( ATS_CON | ATS_LST, "Size " );
            for( i = 0; i < c_dims; i++ )
                trsWrite( ATS_CON | ATS_LST, "%d  ", hist1->dims[i] );
            trsWrite( ATS_CON | ATS_LST, "\n" );
            errors++;
        }

        for( i = 0; i < c_dims; i++ )
        {
            cvReleaseImage( &src8u[i] );
            cvReleaseImage( &src8s[i] );
            cvReleaseImage( &src32f[i] );
            icvFree( &thresh[i] );
            icvFree( &threshe[i] );
        }
        cvReleaseHist( &hist1 );
        cvReleaseHist( &hist2 );
        cvReleaseHist( &hist3 );

    }
    cvReleaseImage(&mask);
    return errors ? trsResult( TRS_FAIL, "Total fixed %d errors", errors ) : TRS_OK;
}


static int foaBackProject(void* _type)
{
    CvHistType type = (CvHistType)(int)_type;
    static int c_dimss;
    static int dims;
    static int init = 0;
    static int width;
    static int height;

    CvHistogram* hist2;
    CvHistogram* hist3;

    int    c_dims;
    int    d[CV_HIST_MAX_DIM + 1];
    float* thresh[CV_HIST_MAX_DIM];
    float* threshe[CV_HIST_MAX_DIM];
    int    i, j, x, y, fl;
    IplImage* src8u[CV_HIST_MAX_DIM];
    IplImage* src8s[CV_HIST_MAX_DIM];
    IplImage* src32f[CV_HIST_MAX_DIM];
    IplImage* dst8u;
    IplImage* dst8s;