aundistort.cpp

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

    k[3] = 0.f;

    if(roi_step)
    {
        num_test = (img_width/2 - 3)/roi_step;
        if( num_test > (img_height/2)/roi_step ) num_test = (img_height/2)/roi_step;
    }
    else num_test = 1;
    if( num_test < 1 )  num_test = 1;

begin:
    trsWrite(TW_RUN|TW_CON, "\n  %d pass of 4 :\n", pass);
    for(itest=0; itest<num_test; itest++)
    {
        int ii = (itest*10)/num_test;
        int roi_offset  = roi_step*itest;
        int img_offset  = roi_offset*(step  + 1);
        int img_offset3 = roi_offset*(step3 + 3);
        size.width = img_width - 2*roi_offset;  size.height = img_height - 2*roi_offset;

        src->roi->xOffset  = src->roi->yOffset = roi_offset;
        src->roi->height   = size.height;  src->roi->width = size.width;
        dst->roi->xOffset  = dst->roi->yOffset = roi_offset;
        dst->roi->height   = size.height;  dst->roi->width = size.width;
        tst->roi->xOffset  = tst->roi->yOffset = roi_offset;
        tst->roi->height   = size.height;  tst->roi->width = size.width;
        src3->roi->xOffset = src3->roi->yOffset = roi_offset;
        src3->roi->height  = size.height;  src3->roi->width = size.width;
        dst3->roi->xOffset = dst3->roi->yOffset = roi_offset;
        dst3->roi->height  = size.height;  dst3->roi->width = size.width;
        tst3->roi->xOffset = tst3->roi->yOffset = roi_offset;
        tst3->roi->height  = size.height;  tst3->roi->width = size.width;

/*  8uC1 flavor test without interpolation */
        for(i=0; i<n; i++) dstImg[i] = tstImg[i] = 0;

        cvUnDistortInit ( src, a, k, data, 0 );
        cvUnDistort     ( src,  dst, data, 0 );
        UnDistortTest_C1( srcImg + img_offset, tstImg + img_offset, step, size, a, k, 0 );

        if( !img_offset )
        {
            norm = norm1 = 0.0;
            for(i=0; i<n; i++)
            {
                norm  += fabs( dstImg[i] - tstImg[i] );
                norm1 += fabs( tstImg[i] );
            }
            norm /= norm1;
            printf( " 8u C1 without interpolation:  %g\n", norm );
        }

        for(i=0; i<n; i++)
        {
            int d = dstImg[i] - tstImg[i];
            if( d > MAXDIFF || d < -MAXDIFF ) err1++;
        }

        for(i=0; i<n; i++) dstImg[i] = 0;

        cvUnDistortOnce ( src, dst, a, k, 0 );
        //for(i=0; i<n; i++)printf(" %d", dstImg[i]); getchar();

        if( !img_offset )
        {
            norm = norm1 = 0.0;
            for(i=0; i<n; i++)
            {
                norm  += fabs( dstImg[i] - tstImg[i] );
                norm1 += fabs( tstImg[i] );
            }
            norm /= norm1;
            printf( "                               %g\n", norm );
        }

        for(i=0; i<n; i++)
        {
            int d = dstImg[i] - tstImg[i];
            if( d > MAXDIFF || d < -MAXDIFF ) err10++;
        }

/*  8uC1 flavor test with interpolation */
        for(i=0; i<n; i++) dstImg[i] = tstImg[i] = 0;

        cvUnDistortInit ( src, a, k, data, 1 );
        cvUnDistort     ( src,  dst, data, 1 );
        UnDistortTest_C1( srcImg + img_offset, tstImg + img_offset, step, size, a, k, 1 );

        if( !img_offset )
        {
            norm = norm1 = 0.0;
            for(i=0; i<n; i++)
            {
                norm  += fabs( dstImg[i] - tstImg[i] );
                norm1 += fabs( tstImg[i] );
            }
            norm /= norm1;
            printf( " 8u C1 with    interpolation:  %g\n", norm );
        }

        for(i=0; i<n; i++)
        {
            int d = dstImg[i] - tstImg[i];
            if( d > MAXDIFF || d < -MAXDIFF ) err2++;
        }

        for(i=0; i<n; i++) dstImg[i] = 0;

        cvUnDistortOnce ( src, dst, a, k, 1 );

        if( !img_offset )
        {
            norm = norm1 = 0.0;
            for(i=0; i<n; i++)
            {
                norm  += fabs( dstImg[i] - tstImg[i] );
                norm1 += fabs( tstImg[i] );
            }
            norm /= norm1;
            printf( "                               %g\n", norm );
        }

        for(i=0; i<n; i++)
        {
            int d = dstImg[i] - tstImg[i];
            if( d > MAXDIFF || d < -MAXDIFF ) err20++;
        }

/*  8uC3 flavor test without interpolation */
        for(i=0; i<n3; i++) dstImg3[i] = tstImg3[i] = 0;

        cvUnDistortInit ( src3, a, k, data, 0 );
        cvUnDistort     ( src3, dst3, data, 0 );
        UnDistortTest_C3( srcImg3+img_offset3, tstImg3+img_offset3, step3, size, a, k, 0 );

        for(i=0; i<n3; i++)
        {
            int d = dstImg3[i] - tstImg3[i];
            if( d > MAXDIFF || d < -MAXDIFF ) err3++;
        }

        if( !img_offset )
        {
            norm = norm1 = 0.0;
            for(i=0; i<n3; i++)
            {
                norm  += fabs( dstImg3[i] - tstImg3[i] );
                norm1 += fabs( tstImg3[i] );
            }
            norm /= norm1;
            printf( " 8u C3 without interpolation:  %g\n", norm );
        }

        for(i=0; i<n3; i++) dstImg3[i] = 0;

        cvUnDistortOnce ( src3, dst3, a, k, 0 );

        if( !img_offset )
        {
            norm = norm1 = 0.0;
            for(i=0; i<n3; i++)
            {
                norm  += fabs( dstImg3[i] - tstImg3[i] );
                norm1 += fabs( tstImg3[i] );
            }
            norm /= norm1;
            printf( "                               %g\n", norm );
        }

        for(i=0; i<n3; i++)
        {
            int d = dstImg3[i] - tstImg3[i];
            if( d > MAXDIFF || d < -MAXDIFF ) err30++;
        }

/*  8uC3 flavor test with interpolation */
        for(i=0; i<n3; i++) dstImg3[i] = tstImg3[i] = 0;

        cvUnDistortInit ( src3, a, k, data, 1 );
        cvUnDistort     ( src3, dst3, data, 1 );
        UnDistortTest_C3( srcImg3+img_offset3, tstImg3+img_offset3, step3, size, a, k, 1 );

        for(i=0; i<n3; i++)
        {
            int d = dstImg3[i] - tstImg3[i];
            if( d > MAXDIFF || d < -MAXDIFF ) err4++;
        }

        if( !img_offset )
        {
            norm = norm1 = 0.0;
            for(i=0; i<n3; i++)
            {
                norm  += fabs( dstImg3[i] - tstImg3[i] );
                norm1 += fabs( tstImg3[i] );
            }
            norm /= norm1;
            printf( " 8u C3 wit     interpolation:  %g\n", norm );
        }

        for(i=0; i<n3; i++) dstImg3[i] = 0;

        cvUnDistortOnce ( src3, dst3, a, k, 1 );

        if( !img_offset )
        {
            norm = norm1 = 0.0;
            for(i=0; i<n3; i++)
            {
                norm  += fabs( dstImg3[i] - tstImg3[i] );
                norm1 += fabs( tstImg3[i] );
            }
            norm /= norm1;
            printf( "                               %g\n", norm );
        }

        for(i=0; i<n3; i++)
        {
            int d = dstImg3[i] - tstImg3[i];
            if( d > MAXDIFF || d < -MAXDIFF ) err40++;
        }

        if(ii>io) { trsWrite(TW_RUN|TW_CON, " %d%% ", 10*ii); io=ii; }
    }

    err5 = err1 + err2 + err3 + err4 + err10 + err20 + err30 + err40;
    err += err5;

    if( p < err1*100.f / (float)(n*num_test)   ) p = err1*100.f / (float)(n*num_test);
    if( p < err2*100.f / (float)(n*num_test)   ) p = err2*100.f / (float)(n*num_test);
    if( p < err3*100.f / (float)(3*n*num_test) ) p = err3*100.f / (float)(3*n*num_test);
    if( p < err4*100.f / (float)(3*n*num_test) ) p = err4*100.f / (float)(3*n*num_test);

    if( p < err10*100.f / (float)(n*num_test)   ) p = err10*100.f / (float)(n*num_test);
    if( p < err20*100.f / (float)(n*num_test)   ) p = err20*100.f / (float)(n*num_test);
    if( p < err30*100.f / (float)(3*n*num_test) ) p = err30*100.f / (float)(3*n*num_test);
    if( p < err40*100.f / (float)(3*n*num_test) ) p = err40*100.f / (float)(3*n*num_test);

//printf("\n  %d   %d   %d   %d\n  %d   %d   %d   %d      %7.3f%% errors\n",
//       err1, err2, err3, err4, err10, err20, err30, err40, p);

    switch( pass )
    {
    case 1:
        k[0] = -k[0];
        io = 0;
        err1 = err2 = err3 = err4 = err10 = err20 = err30 = err40 = 0;
        pass++;
        goto begin;
        break;
    case 2:
        k[0] = -k[0];
        k[2] = k[3] = 0.02f;
        io = 0;
        err1 = err2 = err3 = err4 = err10 = err20 = err30 = err40 = 0;
        pass++;
        goto begin;
        break;
    case 3:
        k[0] = -k[0];
        io = 0;
        err1 = err2 = err3 = err4 = err10 = err20 = err30 = err40 = 0;
        pass++;
        goto begin;
        break;
    }

    if( p < MAXPERCENT ) err = 0;

    cvReleaseImage( &src  );
    cvReleaseImage( &dst  );
    cvReleaseImage( &tst  );
    cvReleaseImage( &src3 );
    cvReleaseImage( &dst3 );
    cvReleaseImage( &tst3 );
    icvFree( (void**)&a      );
    icvFree( (void**)&k      );
    icvFree( (void**)&data   );

    if( err == 0 ) return trsResult( TRS_OK, "No errors fixed by this test" );
    else return trsResult( TRS_FAIL, "Total fixed %d errors", err );
    
} /*fma*/
/*------------------------------------------- Initialize function ------------------------ */
void InitAUnDistort( void )
{
   /* Registering test function */
    trsReg( FuncName, TestName, TestClass, fmaUnDistort );
} /* InitTEigenObjects */

/*  End of file  */