uiplutils.cpp

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

    if( fabs(D) > cf_max ) cf_max = fabs(D);
    if( fabs(E) > cf_max ) cf_max = fabs(E);

    cf_max = (1 << 20)/cf_max;

    *_A = A*cf_max;
    *_B = B*cf_max;
    *_C = C*cf_max;
    *_D = D*cf_max;
    *_E = E*cf_max;

    return code;
}


double atsCrossCorr( IplImage* imgA, IplImage* imgB, double deltaA, double deltaB )
{
    uchar* dataA;
    uchar* dataB;

    int stepA, stepB;
    CvSize sz, szB;
    int  depth = 0, ch = 0;
    int  depthB = 0, chB = 0;
    int  x, y;
    double sum = 0;
    
    atsGetImageInfo( imgA, (void**)&dataA, &stepA, &sz, &depth, &ch, 0 );
    atsGetImageInfo( imgB, (void**)&dataB, &stepB, &szB, &depthB, &chB, 0 );

    assert( sz.width == szB.width && sz.height == szB.height &&
            depth == depthB && ch == chB && ch == 1 );

    for( y = 0; y < sz.height; y++, dataA += stepA, dataB += stepB )
    {
        switch( depth )
        {
        case IPL_DEPTH_8U:
            for( x = 0; x < sz.width; x++ )
            {
                sum += (dataA[x] - deltaA)*(dataB[x] - deltaB );
            }
            break;
        case IPL_DEPTH_8S:
            for( x = 0; x < sz.width; x++ )
            {
                sum += (((char*)dataA)[x] - deltaA)*(((char*)dataB)[x] - deltaB );
            }
            break;
        case IPL_DEPTH_16S:
            for( x = 0; x < sz.width; x++ )
            {
                sum += (((short*)dataA)[x] - deltaA)*(((short*)dataB)[x] - deltaB );
            }
            break;
        case IPL_DEPTH_32F:
            for( x = 0; x < sz.width; x++ )
            {
                sum += (((float*)dataA)[x] - deltaA)*(((float*)dataB)[x] - deltaB );
            }
            break;
        default:
            assert(0);
            return -DBL_MAX;
        }
    }

    return sum;
}


void  atsClearBorder( IplImage* img )
{
    uchar* data = 0;
    int    i, step = 0;
    CvSize size;
    
    assert( img->depth == IPL_DEPTH_8U && img->nChannels == 1 );
    atsGetImageInfo( img, (void**)&data, &step, &size, 0, 0, 0 );
    
    /* clear bounds */
    for( i = 0; i < size.width; i++ )
        data[i] = data[(size.height-1)*step + i] = 0;

    for( i = 0; i < size.height; i++ )
        data[i*step] = data[i*step + size.width - 1] = 0;
}


void  atsGenerateBlobImage( IplImage* img, int min_blob_size, int max_blob_size,
                            int blob_count, int min_brightness, int max_brightness,
                            AtsRandState* rng_state )
{
    uchar* data;
    int    i, step;
    CvSize size;

    assert( img->depth == IPL_DEPTH_8U && img->nChannels == 1 );
    atsGetImageInfo( img, (void**)&data, &step, &size, 0, 0, 0 );
    iplSet( img, 0 );

    for( i = 0; i < blob_count; i++ )
    {
        CvPoint center;
        CvSize  axes;
        int angle = atsRandPlain32s( rng_state ) % 180;
        int brightness = atsRandPlain32s( rng_state ) %
                         (max_brightness - min_brightness) + min_brightness;
        center.x = atsRandPlain32s( rng_state ) % size.width;
        center.y = atsRandPlain32s( rng_state ) % size.height;
        axes.width = (atsRandPlain32s( rng_state ) %
                     (max_blob_size - min_blob_size) + min_blob_size + 1)/2;
        axes.height = (atsRandPlain32s( rng_state ) %
                      (max_blob_size - min_blob_size) + min_blob_size + 1)/2;
        
        cvEllipse( img, center, axes, angle, 0, 360, brightness, CV_FILLED ); 
    }
}


void  atsGetMoments( CvMoments* istate, AtsMomentState* astate )
{
    double inv_m00, s2, s3;

    astate->m00 = cvGetSpatialMoment( istate, 0, 0 );
    astate->m10 = cvGetSpatialMoment( istate, 1, 0 );
    astate->m01 = cvGetSpatialMoment( istate, 0, 1 );
    astate->m20 = cvGetSpatialMoment( istate, 2, 0 );
    astate->m11 = cvGetSpatialMoment( istate, 1, 1 );
    astate->m02 = cvGetSpatialMoment( istate, 0, 2 );
    astate->m30 = cvGetSpatialMoment( istate, 3, 0 );
    astate->m21 = cvGetSpatialMoment( istate, 2, 1 );
    astate->m12 = cvGetSpatialMoment( istate, 1, 2 );
    astate->m03 = cvGetSpatialMoment( istate, 0, 3 );

    astate->mu20 = cvGetCentralMoment( istate, 2, 0 );
    astate->mu11 = cvGetCentralMoment( istate, 1, 1 );
    astate->mu02 = cvGetCentralMoment( istate, 0, 2 );
    astate->mu30 = cvGetCentralMoment( istate, 3, 0 );
    astate->mu21 = cvGetCentralMoment( istate, 2, 1 );
    astate->mu12 = cvGetCentralMoment( istate, 1, 2 );
    astate->mu03 = cvGetCentralMoment( istate, 0, 3 );

    inv_m00 = astate->m00 == 0 ? 0 : 1./astate->m00;
    s2 = inv_m00*inv_m00;
    s3 = s2*sqrt(inv_m00);

    astate->nu20 = astate->mu20*s2;
    astate->nu11 = astate->mu11*s2;
    astate->nu02 = astate->mu02*s2;
    astate->nu30 = astate->mu30*s3;
    astate->nu21 = astate->mu21*s3;
    astate->nu12 = astate->mu12*s3;
    astate->nu03 = astate->mu03*s3;
}



/* Function Calculates separable symmetric kernels for Sobel and Gaussian operators */
void _atsCalcKer (char* Kernel,int order, int Size, int depth)
{
    /* Some Variables */
    
    int i,j;
    int oldsafe, newsafe;
    float oldval, newval;
    
    float* KerF = (float*)Kernel;
    
    
    if(depth!=IPL_DEPTH_32F)
    {
        int* KerI = (int*)Kernel;
        KerI[0] = 1;
        for(i = 1; i <= Size; i++)KerI[i] = 0;
        
        for(i = 0; i < Size-order-1; i++)
        {
            oldsafe = KerI[0];
            for(j = 1; j <= Size; j++)
            {
                newsafe = KerI[j]+KerI[j-1];
                KerI[j-1] = oldsafe;
                oldsafe = newsafe;
            }
        }
        for(i = 0; i < order; i++)
        {
            oldsafe = KerI[0];
            for(j = 1; j <= Size; j++)
            {
                newsafe = KerI[j]-KerI[j-1];
                KerI[j-1] = oldsafe;
                oldsafe = newsafe;
            }
        }
    }
    else
    {
        KerF[0] = 1;
        for(i = 1; i <= Size; i++)KerF[i] = 0;
        
        for(i = 0; i < Size-order-1; i++)
        {
            oldval = KerF[0];
            for(j = 1; j <= Size; j++)
            {
                newval = KerF[j]+KerF[j-1];
                KerF[j-1] = oldval;
                oldval = newval;
            }
        }
        for(i = 0; i < order; i++)
        {
            oldval = KerF[0];
            for(j = 1; j <= Size; j++)
            {
                newval = KerF[j]-KerF[j-1];
                KerF[j-1] = oldval;
                oldval = newval;
            }
        }
    }
    return;
}

void atsCalcKernel( int   datatype,
                    int   Xorder,
                    int   Yorder,
                    int   apertureSize,
                    char* KerX,
                    char* KerY,
                    CvSize* kerLens,
                    int origin)
{
    /* Some variables */
    int sizeX = (apertureSize>Xorder)?apertureSize:(((Xorder+1)/2)+3);
    int sizeY = (apertureSize>Yorder)?apertureSize:(((Yorder+1)/2)+3);
    int size = MAX(sizeX,sizeY);

    origin;

    _atsCalcKer(KerX,Xorder,size,datatype);
    _atsCalcKer(KerY,Yorder,size,datatype);

    kerLens->height = size;
    kerLens->width = size;
    return ;
}



/*
   Create IplConvKernelFP for calclulating derivative
*/
IplConvKernelFP* atsCalcDervConvKernel( int Xorder, int Yorder, int apertureSize, int origin )
{
    float    horz[32], vert[32];
    float    values[1024];
    int      i, j, k;
    CvSize   kerSize;

    atsCalcKernel( 32, Xorder, Yorder, apertureSize,
                   (char*)horz, (char*)vert, &kerSize, origin );

    if( kerSize.width == 0 )
    {
        kerSize.width = 1;
        horz[0] = 1.f;
    }

    if( kerSize.height == 0 )
    {
        kerSize.height = 1;
        vert[0] = 1.f;
    }

    for( i = 0, k = 0; i < kerSize.height; i++ )
        for( j = 0; j < kerSize.width; j++, k++ )
        {
            values[k] = horz[j]*vert[i];
        }

    return iplCreateConvKernelFP( kerSize.width, kerSize.height,
                     kerSize.width/2, kerSize.height/2, values );
}


/* patch */
void* icvAlloc_( int lSize )
{
    long pPointer = (long)malloc( lSize + 64 + 4);
    
    if( pPointer == NULL ) return NULL;
    *(long*)(((pPointer + 32 + 4) & 0xffffffe0) - 4) = (long)pPointer;
    return (void*)((pPointer + 32 + 4) & 0xffffffe0);
} /* icvAlloc */


void  icvFree_( void** ppPointer )
{
    void* pPointer;
    
    /* Checking for bad pointer */
    if( ppPointer && *ppPointer )
    {
        pPointer = *ppPointer;
        *ppPointer = 0;

        /* Pointer must be align by 32 */
        assert( ((long)pPointer & 0x1f) == 0 );
    
        free( (void*)*(long*)((long)pPointer - 4) );
    }
}


CvPoint  atsFindFirstErr( IplImage* imgA, IplImage* imgB, double eps )
{
    uchar* imgA_data = 0;
    uchar* imgB_data = 0;
    int imgA_step = 0;
    int imgB_step = 0;
    CvSize imgA_size;
    CvSize imgB_size;
    int x = 0, y = 0;

    cvGetImageRawData( imgA, &imgA_data, &imgA_step, &imgA_size );
    cvGetImageRawData( imgB, &imgB_data, &imgB_step, &imgB_size );

    assert( imgA_size.width == imgB_size.width && imgA_size.height == imgB_size.height );
    assert( imgA->depth == imgB->depth && imgA->nChannels == imgB->nChannels );

    imgA_size.width *= imgA->nChannels;

    for( y = 0; y < imgA_size.height; y++, imgA_data += imgA_step, imgB_data += imgB_step )
    {
        switch( imgA->depth )
        {
        case IPL_DEPTH_8U:
            for( x = 0; x < imgA_size.width; x++ )
            {
                int t = imgA_data[x] - imgB_data[x];
                if( abs(t) > eps )
                    goto exit_func;
            }
            break;
        case IPL_DEPTH_8S:
            for( x = 0; x < imgA_size.width; x++ )
            {
                int t = ((char*)imgA_data)[x] - ((char*)imgB_data)[x];
                if( abs(t) > eps )
                    goto exit_func;
            }
            break;
        case IPL_DEPTH_16S:
            for( x = 0; x < imgA_size.width; x++ )
            {
                int t = ((short*)imgA_data)[x] - ((short*)imgB_data)[x];
                if( abs(t) > eps )
                    goto exit_func;
            }
            break;
        case IPL_DEPTH_32S:
            for( x = 0; x < imgA_size.width; x++ )
            {
                int t = ((int*)imgA_data)[x] - ((int*)imgB_data)[x];
                if( abs(t) > eps )
                    goto exit_func;
            }
            break;
        case IPL_DEPTH_32F:
            for( x = 0; x < imgA_size.width; x++ )
            {
                float t = ((float*)imgA_data)[x] - ((float*)imgB_data)[x];
                if( fabs(t) > eps )
                    goto exit_func;
            }
            break;
        default:
            assert(0);
        }
    }

exit_func:

    return x < imgA_size.width && y < imgA_size.height ?
           cvPoint( x / imgA->nChannels, y ) : cvPoint( -1, -1 );
}


void atsScaleAddImage( IplImage* src, IplImage* dst, double scale, double shift )
{
    char*  src_data = 0;
    char*  dst_data = 0;
    int    src_step = 0, dst_step = 0;
    CvSize sz, sz2;
    int    x, y;

    assert( dst->depth == IPL_DEPTH_32F );
    assert( src->nChannels == dst->nChannels );

    if( src->depth != IPL_DEPTH_32F )
    {
        atsConvert( src, dst );
        src = dst;
    }

    atsGetImageInfo( src, (void**)&src_data, &src_step, &sz, 0, 0, 0 );
    atsGetImageInfo( dst, (void**)&dst_data, &dst_step, &sz2, 0, 0, 0 );

    assert( sz.width == sz2.width && sz.height == sz2.height );

    sz.width *= src->nChannels;

    for( y = 0; y < sz.height; y++, src += src_step, dst += dst_step )
    {
        for( x = 0; x < sz.width; x++ )
        {
            ((float*)dst_data)[x] = (float)(((float*)src_data)[x]*scale + shift);
        }
    }
}


CvPoint atsRandPoint( AtsRandState* rng_state, CvSize size )
{
    CvPoint pt;

    pt.x = atsRandPlain32s( rng_state ) % size.width;
    pt.y = atsRandPlain32s( rng_state ) % size.height;

    return pt;
}


CvPoint2D32f atsRandPoint2D32f( AtsRandState* rng_state, CvSize size )
{
    CvPoint2D32f pt;

    pt.x = (float)(atsRandPlain32s( rng_state ) % size.width);
    pt.y = (float)(atsRandPlain32s( rng_state ) % size.height);

    return pt;
}


/* End of file. */