asamplers.cpp

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

                atsbRand32f( &rng_state, buf, count*channels );
                for( j = 0; j < count; j++, buf += channels )
                {
                    CvPoint t0 = get_coordinates( iterator.ptr, img );
                    CvPoint t1;

                    ptr = iterator.ptr;

                    img->depth = IPL_DEPTH_8U;
                    t1 = get_coordinates( byte_iterator.ptr, img );
                    img->depth = IPL_DEPTH_32F;
                    
                    if( t0.x != t1.x || t0.y != t1.y )
                    {
                        message = "32f iterator differs from 8u";
                        code = TRS_FAIL;
                        goto test_exit;
                    }

                    memcpy( iterator.ptr, buf, channels * sizeof(float) );
                    CV_NEXT_LINE_POINT( iterator );
                    CV_NEXT_LINE_POINT( byte_iterator );
                }

                if( err > success_error_level ) break;

                result = cvSampleLine( img, pt1, pt2, dst_buf );
                if( (int)result != count )
                {
                    message = "SampleLine fails";
                    code = TRS_FAIL;
                    goto test_exit;
                }

                count *= channels;
                for( j = 0; j < count; j++ )
                {
                    double t = fabs(((float*)src_buf)[j] - ((float*)dst_buf)[j]);
                    err = MAX( err, t );
                }
            }
            break;
        }

        end_pt = get_coordinates( ptr, img );
        if( end_pt.x != pt2.x || end_pt.y != pt2.y )
        {
            message = "Ending point of the iterator is wrong";
            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;
        }
    } /* end of the testing loop */

test_exit:

    img->roi = 0;
    atsReleaseImage( img );

    if( code == TRS_OK )
    {
        trsWrite( ATS_LST, "Max err is %g at i = %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 i = %d, seed = %08x", i, seed );
        return trsResult( TRS_FAIL, message );
    }
}



static void samp_rect_etalon( IplImage* src, IplImage* dst, CvPoint2D32f center )
{
    float* src_data = 0;
    float* dst_data = 0;
    int  src_step = 0;
    int  dst_step = 0;
    int  x, y;
    int  sx, sy;
    CvSize src_size, dst_size;
    float a, b;

    cvGetImageRawData( src, (uchar**)&src_data, &src_step, &src_size );
    cvGetImageRawData( dst, (uchar**)&dst_data, &dst_step, &dst_size );

    src_step /= 4;
    dst_step /= 4;

    sx = cvFloor( center.x );
    sy = cvFloor( center.y );

    a = center.x - sx;
    b = center.y - sy;

    sx -= dst_size.width/2;
    sy -= dst_size.height/2;

    #define normalize( v, high )    \
        if( v < 0 ) v = 0;          \
        if( v >= high ) v = high - 1;

    for( y = 0; y < dst_size.height; y++ )
        for( x = 0; x < dst_size.width; x++ )
        {
            int x1 = sx + x;
            int y1 = sy + y;
            int x2 = x1 + 1;
            int y2 = y1 + 1;
            
            normalize( x1, src_size.width  );
            normalize( x2, src_size.width  );
            normalize( y1, src_size.height );
            normalize( y2, src_size.height );

            float p0 = src_data[y1*src_step + x1];
            float p1 = src_data[y1*src_step + x2];
            float p2 = src_data[y2*src_step + x1];
            float p3 = src_data[y2*src_step + x2];

            p0 = p0 + a*(p1 - p0);
            p2 = p2 + a*(p3 - p2);
            p0 = p0 + b*(p2 - p0);

            dst_data[y*dst_step + x] = p0;
        }
}

static int rect_smp_test( void* arg )
{
    const int min_img_size = 3;
    const double success_error_level = 1.0e-6;
    const char* message = "No errors";

    int   param = (int)arg;
    int   channels  = 1;
    int   depth = param/2;

    int   seed = atsGetSeed();

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

    /* test parameters */
    int     i = 0;
    double  max_err = 0.;
    int     code = TRS_OK;
    int     w = 0, h = 0, rw = 0, rh = 0;

    AtsRandState rng_state;
    IplImage*  src    = 0;
    IplImage*  src2   = 0;
    IplImage*  dst    = 0;
    IplImage*  dst2   = 0;
    IplImage*  srcptr = 0;
    CvPoint    err_pt = { 0, 0 };

    read_smp_params();

    if( !(ATS_RANGE( depth, dt_l, dt_h+1 ))) return TRS_UNDEF;

    depth = depth == 0 ? IPL_DEPTH_8U : depth == 1 ? IPL_DEPTH_8S : IPL_DEPTH_32F;

    src  = cvCreateImage( cvSize( img_size, img_size ), depth,         channels );
    dst  = cvCreateImage( cvSize( img_size, img_size ), IPL_DEPTH_32F, channels );
    dst2 = cvCreateImage( cvSize( img_size, img_size ), IPL_DEPTH_32F, channels );

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

    switch( depth )
    {
    case IPL_DEPTH_8U:
        atsRandSetBounds( &rng_state, 0, img8u_range );
        break;
    case IPL_DEPTH_8S:
        atsRandSetBounds( &rng_state, -img8s_range, img8s_range );
        break;
    case IPL_DEPTH_32F:
        atsRandSetBounds( &rng_state, -img32f_range, img32f_range );
        atsRandSetFloatBits( &rng_state, img32f_bits );
        break;
    }

    atsFillRandomImageEx( src, &rng_state );

    srcptr = src;
    if( depth != IPL_DEPTH_32F )
    {
        src2   = cvCreateImage( cvSize( img_size, img_size ), IPL_DEPTH_32F, channels );
        srcptr = src2;
        atsConvert( src, src2 );
    }

    for( i = 0; i < base_iters; i++ )
    {
        w  = atsRandPlain32s(&rng_state) % (img_size - min_img_size + 1) + min_img_size;
        h  = atsRandPlain32s(&rng_state) % (img_size - min_img_size + 1) + min_img_size;
        rw = atsRandPlain32s(&rng_state) % w + 1;
        rh = atsRandPlain32s(&rng_state) % h + 1;
        if( rw % 2 == 0 ) rw--;
        if( rh % 2 == 0 ) rh--;

        CvPoint2D32f center;
        center.x = atsRandPlane32f(&rng_state) * (w + rw*1.5f) - rw*0.7f;
        center.y = atsRandPlane32f(&rng_state) * (h + rh*1.5f) - rh*0.7f;

        cvSetImageROI( src, cvRect(0,0,w,h));
        cvSetImageROI( dst, cvRect(0,0,rw,rh));
        cvSetImageROI( dst2, cvRect(0,0,rw,rh));

        if( depth != IPL_DEPTH_32F )
        {
            cvSetImageROI( src2, cvRect(0,0,w,h));
        }

        samp_rect_etalon( srcptr, dst2, center );

        cvGetRectSubPix( src, dst, center );

        double err = iplNorm( dst, dst2, IPL_RELATIVEC );
        if( err > max_err )
        {
            max_err   = err;
            merr_iter = i;

            if( max_err > success_error_level )
            {
                err_pt = atsFindFirstErr( dst, dst2, success_error_level );
                goto test_exit;
            }
        }
    }

test_exit:

    cvReleaseImage( &src );
    cvReleaseImage( &src2 );
    cvReleaseImage( &dst );
    cvReleaseImage( &dst2 );

    if( code == TRS_OK )
    {
        trsWrite( ATS_LST, "Max err is %g at i = %d, first \"bad\" pt = (%d,%d), seed = %08x",
                  max_err, merr_iter, err_pt.x, err_pt.y, seed );

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



#define _8U_C1    0
#define _8U_C3    1
#define _8S_C1    2
#define _8S_C3    3
#define _32F_C1   4
#define _32F_C3   5


void InitASamplers( void )
{
    /* Registering test functions */
    trsRegArg( funcs[0], test_desc, atsAlgoClass, line_smp_test, _8U_C1 );
    trsRegArg( funcs[0], test_desc, atsAlgoClass, line_smp_test, _8U_C3 );
    trsRegArg( funcs[0], test_desc, atsAlgoClass, line_smp_test, _32F_C1 );
    trsRegArg( funcs[0], test_desc, atsAlgoClass, line_smp_test, _32F_C3 );

    trsRegArg( funcs[1], test_desc, atsAlgoClass, rect_smp_test, _8U_C1 );
    trsRegArg( funcs[1], test_desc, atsAlgoClass, rect_smp_test, _8S_C1 );
    trsRegArg( funcs[1], test_desc, atsAlgoClass, rect_smp_test, _32F_C1 );

} /* InitASamplers */


/* End of file. */