apyramids.cpp

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

                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;
                default:
                    assert(0);
                    code = TRS_FAIL;
                    goto test_exit;
                }
                atsFillRandomImageEx( src, &rng_state );

                cvPyrDown( src, dst2, IPL_GAUSSIAN_5x5 );

                ipl_apply_gaussian( src, src2, ker );

                /* patch for IPL. "change" depth to 8u */
                if( depth != IPL_DEPTH_8U )
                {
                    src2->depth = dst->depth = IPL_DEPTH_8U;
                    src2->nChannels = dst->nChannels *= (depth&255)>>3;
                }

                iplDecimate( src2, dst, dst->roi->width,
                             src2->roi->width, dst->roi->height,
                             src2->roi->height, IPL_INTER_NN );

                /* restore depth */
                if( depth != IPL_DEPTH_8U )
                {
                    src2->depth = dst->depth = depth;
                    src2->nChannels = dst->nChannels /= (depth&255)>>3;
                }

                err0 = iplNorm( dst, dst2, IPL_C );

                if( err0 > max_err )
                {
                    max_err   = err0;
                    merr_w    = w;
                    merr_h    = h;
                    merr_iter = i;

                    if( max_err > success_error_level ) goto test_exit;
                }
            }
            ATS_INCREASE( w, img_size_delta_type, img_size_delta );
        }
        ATS_INCREASE( h, img_size_delta_type, img_size_delta );
    }

test_exit:

    src->roi = src2->roi = dst->roi = dst2->roi = 0;

    atsReleaseImage( src  );
    atsReleaseImage( src2 );
    atsReleaseImage( dst  );
    atsReleaseImage( dst2 );

    if( depth == IPL_DEPTH_32F )
        iplDeleteConvKernelFP( (IplConvKernelFP*)ker );
    else
        iplDeleteConvKernel( (IplConvKernel*)ker );

    if( code == TRS_OK )
    {
        trsWrite( ATS_LST,
                  "Maximum error is %g at w = %d, h = %d, iteration = %d",
                   max_err, merr_w, merr_h, merr_iter );

        return max_err <= success_error_level ?
            trsResult( TRS_OK, "No errors" ) :
            trsResult( TRS_FAIL, "Bad accuracy" );
    }
    else
    {
        trsWrite( ATS_LST,
                  "Fatal error (ROI ver) at w = %d, "
                  "h = %d, iteration = %d",
                  w, h, i );
        return trsResult( TRS_FAIL, "Function returns error code" );
    }
}


/******************************************************************\
*                        PyrUpCmpIPL                               *
\******************************************************************/
static int PyrUpCmpIPL( void* arg )
{
    const int   r = 2;
    int         code = TRS_OK;

    int         param = (int)arg;
    int         depth = param/2 == 2 ? IPL_DEPTH_32F :
                        param/2 == 1 ? IPL_DEPTH_8S  : IPL_DEPTH_8U;
    int         channels = param % 2 == 1 ? 3 : 1;

    int         w = 0, h = 0, i = 0;
    int         merr_w = 0, merr_h = 0, merr_iter = 0; /* where was maximum error */
    double      max_err = 0.;

    int         seed = atsGetSeed();

    double      success_error_level;
    void*       ker;
    IplROI      srcRoi, dstRoi, dstRoi2;

    IplImage    *src, *dst, *dst2, *dst3;
    AtsRandState rng_state;
    atsRandInit( &rng_state, 0, 1, seed );

    read_pyramid_params();

    if( !(ATS_RANGE( 0, ud_l, ud_h + 1)       &&
          ATS_RANGE( param/2, dt_l, dt_h + 1) &&
          ATS_RANGE( param%2, ch_l, ch_h + 1)))
          return TRS_UNDEF;

    ker = calc_kernel( depth == IPL_DEPTH_32F, 3 );

    src = atsCreateImage( max_img_size,   max_img_size, depth, channels, 0 );
    dst = atsCreateImage( max_img_size*2+r*2,max_img_size*2+r*2, depth, channels,0);
    dst2= atsCreateImage( max_img_size*2, max_img_size*2, depth, channels, 0 );
    dst3= atsCreateImage( max_img_size*2, max_img_size*2, depth, channels, 0 );

    srcRoi.coi = dstRoi.coi = dstRoi2.coi = 0;
    srcRoi.xOffset  = srcRoi.yOffset  = 0;
    dstRoi.xOffset  = dstRoi.yOffset  = r;
    dstRoi2.xOffset = dstRoi2.yOffset = 0;

    src->roi = &srcRoi;
    dst->roi = &dstRoi;
    dst2->roi= dst3->roi = &dstRoi2;

    success_error_level = depth == IPL_DEPTH_32F ? 1e-6 : 1;

    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*4;
            int     iters = (base_iters*2 + denom)/(2*denom);

            if( iters < 1 ) iters = 1;

            srcRoi.width  = w;
            srcRoi.height = h;
            dstRoi.width  = dstRoi2.width  = w*2;
            dstRoi.height = dstRoi2.height = h*2;

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

                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;
                default:
                    assert(0);
                    code = TRS_FAIL;
                    goto test_exit;
                }
                atsFillRandomImageEx( src, &rng_state );

                cvPyrUp( src, dst2, IPL_GAUSSIAN_5x5 );

                /* patch for IPL. "change" depth to 8u */
                if( depth != IPL_DEPTH_8U )
                {
                    src->depth = dst->depth = IPL_DEPTH_8U;
                    src->nChannels = dst->nChannels *= (depth&255)>>3;
                }

                iplZoom( src, dst, w*2, w, h*2, h, IPL_INTER_NN );

                /* restore depth */
                if( depth != IPL_DEPTH_8U )
                {
                    src->depth = dst->depth = depth;
                    src->nChannels = dst->nChannels /= (depth&255)>>3;
                }

                clear_even_rows_and_cols( dst );
                ipl_apply_gaussian( dst, dst3, ker );

                err0 = iplNorm( dst2, dst3, IPL_C );

                if( err0 > max_err )
                {
                    max_err   = err0;
                    merr_w    = w;
                    merr_h    = h;
                    merr_iter = i;

                    if( max_err > success_error_level ) goto test_exit;
                }
            }
            ATS_INCREASE( w, img_size_delta_type, img_size_delta );
        }
        ATS_INCREASE( h, img_size_delta_type, img_size_delta );
    }

test_exit:

    src->roi = dst->roi = dst2->roi = dst3->roi = 0;

    atsReleaseImage( src  );
    atsReleaseImage( dst  );
    atsReleaseImage( dst2 );
    atsReleaseImage( dst3 );

    if( depth == IPL_DEPTH_32F )
        iplDeleteConvKernelFP( (IplConvKernelFP*)ker );
    else
        iplDeleteConvKernel( (IplConvKernel*)ker );

    if( code == TRS_OK )
    {
        trsWrite( ATS_LST, " Maximum error is %g at w = %d, h = %d, iteration = %d",
                           max_err, merr_w, merr_h, merr_iter );

        return max_err <= success_error_level ?
            trsResult( TRS_OK, "No errors" ) :
            trsResult( TRS_FAIL, "Bad accuracy" );
    }
    else
    {
        trsWrite( ATS_LST,
                  "Fatal error (ROI ver) at w = %d, "
                  "h = %d, iteration = %d",
                  w, h, i );
        return trsResult( TRS_FAIL, "Function returns error code" );
    }
}

#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 InitAPyramids( void )
{
    trsRegArg( funcs[0],  test_desc, atsAlgoClass, PyrUpCmpIPL, _8U_C1 );
    trsRegArg( funcs[0],  test_desc, atsAlgoClass, PyrUpCmpIPL, _8U_C3 );
    trsRegArg( funcs[0],  test_desc, atsAlgoClass, PyrUpCmpIPL, _8S_C1 );
    trsRegArg( funcs[0],  test_desc, atsAlgoClass, PyrUpCmpIPL, _8S_C3 );
    trsRegArg( funcs[0],  test_desc, atsAlgoClass, PyrUpCmpIPL, _32F_C1 );
    trsRegArg( funcs[0],  test_desc, atsAlgoClass, PyrUpCmpIPL, _32F_C3 );

    trsRegArg( funcs[1],  test_desc, atsAlgoClass, PyrDownCmpIPL, _8U_C1 );
    trsRegArg( funcs[1],  test_desc, atsAlgoClass, PyrDownCmpIPL, _8U_C3 );
    trsRegArg( funcs[1],  test_desc, atsAlgoClass, PyrDownCmpIPL, _8S_C1 );
    trsRegArg( funcs[1],  test_desc, atsAlgoClass, PyrDownCmpIPL, _8S_C3 );
    trsRegArg( funcs[1], test_desc, atsAlgoClass, PyrDownCmpIPL, _32F_C1 );
    trsRegArg( funcs[1], test_desc, atsAlgoClass, PyrDownCmpIPL, _32F_C3 );

} /* InitAPyramids */

/* End of file. */

/* End of file. */