amotiontemplates.cpp

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

                atsRandSetBounds( &rng_state, 0, 1 );
                atsFillRandomImageEx( silh, &rng_state );

                iplCopy( mhi, mhi_copy );

                UpdateMHIByTimeEtalon( silh, mhi_copy, time_stamp, mhi_duration );

                cvUpdateMHIByTime( silh, mhi, time_stamp, mhi_duration );

                err = iplNorm( mhi, mhi_copy, IPL_C );

                if( err > max_err )
                {
                    merr_w    = w;
                    merr_h    = h;
                    merr_iter = i;
                    max_err   = err;
                    if( max_err > success_error_level ) goto test_exit;
                }
            }
            ATS_INCREASE( w, img_size_delta_type, img_size_delta );
        } /* end of the loop by w */

        ATS_INCREASE( h, img_size_delta_type, img_size_delta );
    }  /* end of the loop by h */

test_exit:

    silh->roi = mhi->roi = mhi_copy->roi = 0;

    atsReleaseImage( silh );
    atsReleaseImage( mhi );
    atsReleaseImage( mhi_copy );

    //if( code == TRS_OK )
    {
        trsWrite( ATS_LST, "Max err is %g at w = %d, h = %d, "
                           "iter = %d, seed = %08x",
                           max_err, merr_w, merr_h, 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 w = %d, h = %d, "
                           "iter = %d, seed = %08x",
                           w, h, i, seed );
        return trsResult( TRS_FAIL, "Function returns error code" );
    }*/
}



static int calc_motion_gradient_test( void )
{
    const float max_time = 100.f;
    const float delta_range = 5.f;
    const float success_orient_error_level = 1;
    const float success_mask_error_level = 1;
    const int mhi_depth = IPL_DEPTH_32F;
    const int orient_depth = IPL_DEPTH_32F;
    const int mask_depth = IPL_DEPTH_8U;
    const int silh_depth = IPL_DEPTH_8U;
    const int channels = 1;
    const int origin = 0;

    int   seed = atsGetSeed();

    /* position where the maximum error occured */
    int   merr_w = 0, merr_h = 0, merr_iter = 0, merr_aperture_size = 0;

    /* test parameters */
    int     w = 0, h = 0, i = 0;
    int     aperture_size = 0;
    float   max_delta = 0.f, min_delta = 0.f;
    double  max_orient_err = 0., max_mask_err = 0.;
    //int     code = TRS_OK;

    IplROI       roi;
    IplImage    *orient, *silh, *orient2, *mask, *mask2, *mhi;
    IplImage    *dervX_min, *dervY_max;
    AtsRandState rng_state;
    atsRandInit( &rng_state, 0, 1, seed );

    read_mot_templ2_params();

    orient = atsCreateImage( max_img_size, max_img_size, orient_depth, channels, 0 );
    orient2 = atsCreateImage( max_img_size, max_img_size, orient_depth, channels, 0 );
    mhi = atsCreateImage( max_img_size, max_img_size, mhi_depth, channels, 0 );
    mask = atsCreateImage( max_img_size, max_img_size, mask_depth, channels, 0 );
    mask2 = atsCreateImage( max_img_size, max_img_size, mask_depth, channels, 0 );
    silh  = atsCreateImage( max_img_size, max_img_size, silh_depth, channels, 0 );
    dervX_min = atsCreateImage( max_img_size, max_img_size, mhi_depth, channels, 0 );
    dervY_max = atsCreateImage( max_img_size, max_img_size, mhi_depth, channels, 0 );

    iplSet( silh, 0 );

    roi.coi = 0;
    roi.xOffset = roi.yOffset = 0;

    orient->roi = orient2->roi = mhi->roi = mask->roi = mask2->roi = silh->roi = &roi;
    dervX_min->roi = dervY_max->roi = &roi;

    for( h = min_img_size; h <= max_img_size; )
    {
        for( w = min_img_size; w <= max_img_size; )
        {
            int  denom = (w - min_img_size + 1)*(h - min_img_size + 1)*channels;
            int  iters = (base_iters*2 + denom)/(2*denom);
            CvSize size;

            size.width = roi.width  = w;
            size.height = roi.height = h;

            if( iters < 1 ) iters = 1;

            for( i = 0; i < iters; i++ )
            {
                double err;

                atsRandSetBounds( &rng_state, 0, delta_range );

                max_delta = atsRand32f( &rng_state ) + delta_range;
                min_delta = atsRand32f( &rng_state );

                atsRandSetBounds( &rng_state, 0, max_time );
                atsFillRandomImageEx( mhi, &rng_state );

                /* cut off some motion */
                UpdateMHIByTimeEtalon( silh, mhi, max_time, max_time*2/3 );

                for( aperture_size = min_aperture_size; aperture_size <= max_aperture_size;
                     aperture_size += 2 )
                {
                    CalcMotionGradientEtalon( mhi, mask2, orient2, dervX_min, dervY_max,
                                              aperture_size, max_delta, min_delta, origin );

                    cvCalcMotionGradient( mhi, mask, orient, aperture_size,
                                          max_delta, min_delta );

                    /* compare angles */
                    err = compare_img_angles( orient, orient2, mask2 );

                    if( err > max_orient_err )
                    {
                        merr_w    = w;
                        merr_h    = h;
                        merr_iter = i;
                        merr_aperture_size = aperture_size;
                        max_orient_err   = err;
                        if( max_orient_err > success_orient_error_level )
                            goto test_exit;
                    }

                    iplSetErrMode( IPL_ErrModeParent );
                    err = iplNorm( mask, mask2, IPL_L1 );

                    iplXor( mask, mask2, mask );

                    if( err > max_mask_err )
                    {
                        merr_w    = w;
                        merr_h    = h;
                        merr_iter = i;
                        merr_aperture_size = aperture_size;
                        max_mask_err   = err;
                        if( max_mask_err > success_mask_error_level )
                            goto test_exit;
                    }

                    roi.xOffset = roi.yOffset = 0;
                    roi.width = w;
                    roi.height = h;
                }
            }
            ATS_INCREASE( w, img_size_delta_type, img_size_delta );
        } /* end of the loop by w */

        ATS_INCREASE( h, img_size_delta_type, img_size_delta );
    }  /* end of the loop by h */

test_exit:

    silh->roi = mhi->roi = mask->roi = mask2->roi = orient->roi = orient2->roi = 0;
    dervX_min->roi = dervY_max->roi = 0;

    atsReleaseImage( silh );
    atsReleaseImage( mhi );
    atsReleaseImage( mask );
    atsReleaseImage( mask2);
    atsReleaseImage( orient );
    atsReleaseImage( orient2 );
    atsReleaseImage( dervX_min );
    atsReleaseImage( dervY_max );

    //if( code == TRS_OK )
    {
        trsWrite( ATS_LST, "Max orient err is %g, Max mask err is %g at w = %d, h = %d, "
                           "iter = %d, aperture_size = %d, seed = %08x",
                           max_orient_err, max_mask_err, merr_w, merr_h, merr_iter,
                           merr_aperture_size, seed );

        return max_orient_err <= success_orient_error_level &&
               max_mask_err <= success_mask_error_level ?
            trsResult( TRS_OK, "No errors" ) :
               max_mask_err > success_mask_error_level ?
            trsResult( TRS_FAIL, "Bad mask accuracy" ) :
            trsResult( TRS_FAIL, "Bad orient accuracy" );
    }
    /*else
    {
        trsWrite( ATS_LST, "Fatal error at w = %d, h = %d, "
                           "iter = %d, aperture_size = %d, seed = %08x",
                           w, h, i, aperture_size, seed );
        return trsResult( TRS_FAIL, "Function returns error code" );
    }*/
}



static int calc_global_orientation_test( void )
{
    const float max_time = 2000.f;
    const float mask_range = 3.f;
    const float success_orient_error_level = 30;
    const int mhi_depth = IPL_DEPTH_32F;
    const int orient_depth = IPL_DEPTH_32F;
    const int mask_depth = IPL_DEPTH_8U;
    const int silh_depth = IPL_DEPTH_8U;
    const int channels = 1;

    int   seed = atsGetSeed();

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

    /* test parameters */
    int     w = 0, h = 0, i = 0;
    float   time_stamp = 0.f, mhi_duration = 0.f;
    float   min_angle = 0.f, max_angle = 0.f;

    float   res_angle = 0.f, std_angle = 0.f;
    double  max_err = 0.;
    int     code = TRS_OK;

    IplROI       roi;
    IplImage    *orient, *silh, *mask, *mhi;
    AtsRandState rng_state;
    atsRandInit( &rng_state, 0, 1, seed );

    read_mot_templ2_params();

    orient = atsCreateImage( max_img_size, max_img_size, orient_depth, channels, 0 );
    mhi = atsCreateImage( max_img_size, max_img_size, mhi_depth, channels, 0 );
    mask = atsCreateImage( max_img_size, max_img_size, mask_depth, channels, 0 );
    silh  = atsCreateImage( max_img_size, max_img_size, silh_depth, channels, 0 );

    iplSet( silh, 0 );

    roi.coi = 0;
    roi.xOffset = roi.yOffset = 0;

    orient->roi = mhi->roi = mask->roi = silh->roi = &roi;

    for( h = MAX( 4, min_img_size); h <= max_img_size; )
    {
        for( w = MAX( 4, min_img_size); w <= max_img_size; )
        {
            int  denom = (w - min_img_size + 1)*(h - min_img_size + 1)*channels;
            int  iters = (base_iters*2 + denom)/(2*denom);
            CvSize size;

            if( iters < 1 ) iters = 1;

            size.width = roi.width  = w;
            size.height = roi.height = h;

            for( i = 0; i < iters; i++ )
            {
                double err;
                float  temp, delta = 0;

                atsRandSetBounds( &rng_state, 0, max_time );

                time_stamp = atsRand32f( &rng_state );
                mhi_duration = atsRand32f( &rng_state );

                if( time_stamp < mhi_duration )
                    ATS_SWAP( time_stamp, mhi_duration, temp );

                if( time_stamp < mhi_duration + 1 ) time_stamp += 1.f;

                atsRandSetBounds( &rng_state, mhi_duration, time_stamp );
                atsFillRandomImageEx( mhi, &rng_state );

                /* cut off some motion */
                UpdateMHIByTimeEtalon( silh, mhi, max_time, max_time*2/3 );

                /* generate random angles range */
                atsRandSetBounds( &rng_state, 0, 360 );
                min_angle = atsRand32f( &rng_state );
                max_angle = atsRand32f( &rng_state );

                if( min_angle > max_angle )
                    ATS_SWAP( min_angle, max_angle, temp );

                /* make orientation image */
                min_angle += (max_angle - min_angle)*0.3f;
                max_angle -= (max_angle - min_angle)*0.3f;

                atsRandSetBounds( &rng_state, min_angle, max_angle );
                atsFillRandomImageEx( orient, &rng_state );

                /* make mask image */
                atsRandSetBounds( &rng_state, 1, mask_range+1 );
                atsFillRandomImageEx( mask, &rng_state );
                iplSubtractS( mask, mask, (int)(mask_range - 1), 0 );

                CalcGlobalOrientationEtalon( orient, mask, mhi, time_stamp,
                                             mhi_duration, &std_angle, &delta );

                res_angle = (float)cvCalcGlobalOrientation( orient, mask, mhi,
                                                            time_stamp, mhi_duration );

                if( !(min_angle - success_orient_error_level <= res_angle &&
                      max_angle + success_orient_error_level >= res_angle) &&
                    !(min_angle - success_orient_error_level <= res_angle+360 &&
                      max_angle + success_orient_error_level >= res_angle+360)
                      && w > 4 && h > 4 )
                {
                    code = -2;
                    goto test_exit;
                }

                /* compare angles */
                err = atsCompareAngles( res_angle, std_angle );

                if( err > max_err )
                {
                    merr_w    = w;
                    merr_h    = h;
                    merr_iter = i;
                    max_err = err;
                    if( max_err > success_orient_error_level ) goto test_exit;
                }
            }
            ATS_INCREASE( w, img_size_delta_type, img_size_delta );
        } /* end of the loop by w */

        ATS_INCREASE( h, img_size_delta_type, img_size_delta );
    }  /* end of the loop by h */

test_exit:

    silh->roi = mhi->roi = mask->roi = orient->roi = 0;

    atsReleaseImage( silh );
    atsReleaseImage( mhi );
    atsReleaseImage( mask );
    atsReleaseImage( orient );

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

        return max_err <= success_orient_error_level ?
            trsResult( TRS_OK, "No errors" ) :
            trsResult( TRS_FAIL, "Bad orient accuracy" );
    }
    else
    {
        trsWrite( ATS_LST, "Fatal error at w = %d, h = %d, iter = %d, seed = %08x",
                           w, h, i, seed );
        return trsResult( TRS_FAIL, "Function returns error code" );
    }
}


void InitAMotionTemplates( void )
{
    trsReg( func_name[0], test_desc, atsAlgoClass, update_mhi_by_time_test );
    trsReg( func_name[1], test_desc, atsAlgoClass, calc_motion_gradient_test );
    trsReg( func_name[2], test_desc, atsAlgoClass, calc_global_orientation_test );

} /* InitAMotionTemplates */

/* End of file. */

/* End of file. */