acontours.cpp

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

            {
                CvSeq* seq1 = icvNextSeq( &iterator1 );
                CvSeq* seq2 = icvNextSeq( &iterator2 );
                CvSeqReader reader;
                CvSeqReader reader2;

                if( !seq2 )
                    break;

                assert( seq1 );

                cvStartReadSeq( seq1, &reader );
                cvStartReadSeq( seq2, &reader2 );

                for( int j = 0; j < seq1->total; j++ )
                {
                    CvPoint pt;
                    CvPoint pt2;

                    CV_READ_SEQ_ELEM( pt, reader );
                    CV_READ_SEQ_ELEM( pt2, reader2 );

                    if( pt.x != pt2.x || pt.y != pt2.y )
                    {
                        code = TRS_FAIL;
                        goto test_exit;
                    }
                }
            }

            if( count3 != count )
            {
                code = TRS_FAIL;
                goto test_exit;
            }
        }

        if( err > max_err )
        {
            merr_iter = i;
            max_err   = err;
            if( max_err > success_error_level ) goto test_exit;
        }

        cvClearMemStorage( storage );
    }

test_exit:

    cvReleaseMemStorage( &storage );

    cvReleaseImage( &src_img );
    cvReleaseImage( &dst1_img );
    cvReleaseImage( &dst2_img );
    cvReleaseImage( &dst3_img );

    if( code == TRS_OK )
    {
        trsWrite( ATS_LST, "Max err is %g at iter = %d, seed = %08x",
                           max_err, merr_iter, seed );

        return max_err <= success_error_level ?
            trsResult( TRS_OK, "No errors" ) :
            trsResult( TRS_FAIL, "Bad accuracy" );
    }
    else
    {
        trsWrite( ATS_LST, "Fatal error at iter = %d, seed = %08x", i, seed );
        return trsResult( TRS_FAIL, "Test failed" );
    }
}


int get_slice_length( CvSeq* seq, CvSlice slice )
{
    int total = seq->total;
    int length;

    /*if( slice.startIndex == slice.endIndex )
        return 0;*/
    if( slice.startIndex < 0 )
        slice.startIndex += total;
    if( slice.endIndex < 0 )
        slice.endIndex += total;
    length = slice.endIndex - slice.startIndex;
    if( length < 0 ) length += total;
    if( length < 0 ) length += total;
    if( length > total ) length = total;

    return length;
}


double calc_contour_perimeter( CvPoint* array, int count )
{
    int i;
    double s = 0;

    for( i = 0; i < count - 1; i++ )
    {
        int dx = array[i].x - array[i+1].x;
        int dy = array[i].y - array[i+1].y;
        
        s += sqrt(dx*dx + dy*dy);
    }

    return s;
}


static int contour_perimeter_test( void )
{
    const double  success_error_level = 1e-4;
    const int max_delta = 100;

    int     seed  = 0x6efaebdb; //atsGetSeed();

    /* position where the maximum error occured */
    int     merr_iter = 0;

    /* test parameters */
    int     i = 0, j = 0;
    int     curr_size = 0;
    CvPoint*  array = 0;
    double  max_err = 0.;
    int     code = TRS_OK;

    AtsRandState rng_state;
    CvMemStorage* storage;
    CvSize size;

    atsRandInit( &rng_state, 0, 1, seed );

    read_contour_params();

    size = cvSize( img_size, img_size*3/4 );

    storage = cvCreateMemStorage(atsRandPlain32s(&rng_state) % max_storage_size );

    for( i = 0; i < base_iters; i++ )
    {
        double perimeter, etalon_perimeter;
        double err = 0;
        int count = atsRandPlain32s( &rng_state ) % (max_contour_size) + 1;
        int len, flag = 0;
        CvSlice slice; 
        CvSeqReader reader;
        CvPoint pt0 = { 0, 0 };

        CvSeq* contour = cvCreateSeq( CV_SEQ_CONTOUR, sizeof(CvContour),
                                      sizeof(CvPoint), storage );

        for( j = 0; j < count; j++ )
        {
            CvPoint pt;

            if( j % 10 == 0 )
            {
                pt0 = atsRandPoint(&rng_state, size);
            }

            pt.x = atsRandPlain32s(&rng_state) % max_delta - max_delta/2;
            pt.y = atsRandPlain32s(&rng_state) % max_delta - max_delta/2;

            cvSeqPush( contour, &pt0 );

            pt0.x += pt.x;
            pt0.y += pt.y;
        }

        if( i % 10 == 0 )
        {
            slice = CV_WHOLE_SEQ(contour);
        }
        else
        {
            slice.startIndex = atsRandPlain32s( &rng_state ) % (count*3) - count;
            slice.endIndex = atsRandPlain32s( &rng_state ) % (count*3) - count;
        }

        perimeter = cvContourPerimeter( contour, slice );
 
        if( perimeter < 0 )
        {
            code = TRS_FAIL;
            goto test_exit;
        }

        slice.endIndex++;

        len = get_slice_length( contour, slice );
        if( len == 0 )
        {
            len = count;
            slice.startIndex = (slice.startIndex + count*2) % count;
            slice.endIndex = slice.startIndex + len;
            flag = 1;
        }

        if( len + 1 > curr_size )
        {
            curr_size = len + 1;
            array = (CvPoint*)realloc( array, curr_size*sizeof(array[0]) );
        }
        
        cvCvtSeqToArray( contour, array, slice );

        cvStartReadSeq( contour, &reader, 0 );
        cvSetSeqReaderPos( &reader, slice.startIndex, 0 );

        for( j = 0; j < len; j++ )
        {
            CvPoint pt;
            CV_READ_SEQ_ELEM( pt, reader );
            if( array[j].x != pt.x || array[j].y != pt.y )
            {
                code = TRS_FAIL;
                goto test_exit;
            }
        }

        if( len - flag == contour->total )
        {
            array[len++] = array[0];
        }

        etalon_perimeter = calc_contour_perimeter( array, len );

        assert( etalon_perimeter >= 0 );

        err = fabs(perimeter - etalon_perimeter)/(etalon_perimeter + DBL_EPSILON);

        if( err > max_err )
        {
            merr_iter = i;
            max_err   = err;
            if( max_err > success_error_level )
                goto test_exit;
        }

        cvClearMemStorage( storage );
    }

test_exit:

    cvReleaseMemStorage( &storage );
    if(array)
        free(array);

    if( code == TRS_OK )
    {
        trsWrite( ATS_LST, "Max err is %g at iter = %d, seed = %08x",
                           max_err, merr_iter, seed );

        return max_err <= success_error_level ?
            trsResult( TRS_OK, "No errors" ) :
            trsResult( TRS_FAIL, "Bad accuracy" );
    }
    else
    {
        trsWrite( ATS_LST, "Fatal error at iter = %d, seed = %08x", i, seed );
        return trsResult( TRS_FAIL, "Test failed" );
    }
}


void InitAContours()
{
    trsReg( funcName[0], testName[0], atsAlgoClass, contour_retrieving_test );
    trsReg( funcName[1], testName[1], atsAlgoClass, contour_perimeter_test );
}

/* End of file. */