pixeltopixelmorpher.cpp

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

                    if( costArray[ destOffset ] >= futureCost ) {
                        costArray[ destOffset ]     = futureCost;
                        xArray[ destOffset ]        = i;
                        yArray[ destOffset ]        = j;
                    }
                } // for( jTemp = j + 2; jTemp <= edges[ i * 2 + 3 ]; jTemp ++ )

            } // if( i != width_1 )

        } // for( i = edges[ j * 2 ]; i <= edges[ j * 2 + 1 ]; i ++ )

    } // for( j = 1; j < width; j ++ )

    // constraction of back path

    // searching for best initial point in the low right corner
    jTemp   = width - 1;
    i       = jTemp;
    j       = jTemp;
    int bestCost = costArray[ j * width + i ];
    for( iTemp = edges[ width * 2 - 2 ]; iTemp < edges[ width * 2 - 1 ]; iTemp ++ )
    {
        if( costArray[ jTemp * width + iTemp ] < bestCost ) {
            i           = iTemp;
            j           = jTemp;
            bestCost    = costArray[ jTemp * width + iTemp ];
        }
    }
    iTemp   = width - 1;
    for( jTemp = edges[ width * 2 - 2 ]; jTemp < edges[ width * 2 - 1 ]; jTemp ++ )
    {
        if( costArray[ jTemp * width + iTemp ] < bestCost ) {
            i           = iTemp;
            j           = jTemp;
            bestCost    = costArray[ jTemp * width + iTemp ];
        }
    }

    // filling back path
    *( numCorrArray )  = 0;
    _corrArray[ *( numCorrArray ) ]     = j;
    ( *( numCorrArray ) ) ++;
    _corrArray[ *( numCorrArray ) ]     = i;
    ( *( numCorrArray ) ) ++;

    srcOffset   = j * width + i;
    while( xArray[ srcOffset ] != END_OF_PATH )
    {
        i   = xArray[ srcOffset ];
        j   = yArray[ srcOffset ];
        _corrArray[ *( numCorrArray ) ]     = j;
        ( *( numCorrArray ) ) ++;
        _corrArray[ *( numCorrArray ) ]     = i;
        ( *( numCorrArray ) ) ++;
        srcOffset   = j * width + i;
    } // while( xArray[ j * width + i ] != END_OF_PATH )

    *( numCorrArray ) /= 2;

} // FindCorr

// This function produces morphing of two images into one image, which includes morphed
// image or depth map
//      _leftImage              - pointer to left image
//      _leftLineStep           - size of line on left image in bytes
//      _rightImage             - pointer to right image
//      _rightLineStep          - size of line on right image in bytes
//      _resultImage            - pointer to result morphed image
//      _resultLineStep         - size of line on result image in bytes
//      _corrArray              - pointer to array with correspondences
//      _numCorrArray           - pointer to array with numbers correspondeces on each line
//      width                   - width of images
//      height                  - height of images
//      alpha                   - position of virtual camera ( 0 corresponds to left image, 1 - to right one )
//      imageNeed               - defines your wishes. if you want to see normal morphed image you have to set
//                                this parameter to morphNormalImage ( this is default value ), else if you want
//                                to see depth map you have to set this parameter to morphDepthMap and set the
//                                next parameter ( maxPixelDifference ) to real value
//      maxPixelDifference      - maximum value of pixel difference on two images
void CCvPixelToPixelMorpher::Morph( unsigned char* _leftImage,
            int _leftLineStep,
            unsigned char* _rightImage,
            int _rightLineStep,
            unsigned char* _resultImage,
            int _resultLineStep,
            int* _corrArray,
            int* _numCorrArray,
            int width,
            int height,
            float alpha,
            morphImageType imageNeed,
            int maxDifference
          )
{
    unsigned char* leftArray    = _leftImage;
    unsigned char* middleArray  = _resultImage;
    unsigned char* rightArray   = _rightImage;
    int leftLineSize            = _leftLineStep;
    int middleLineSize          = _resultLineStep;
    int rightLineSize           = _rightLineStep;

    int lineNumber;
    unsigned char* leftTemp;
    unsigned char* middleTemp;
    unsigned char* rightTemp;
    int leftPixel;
    int prevLeftPixel;
    int middlePixel;
    int prevMiddlePixel;
    int rightPixel;
    int prevRightPixel;
    int leftPixel3;
    int middlePixel3;
    int rightPixel3;
    int i;
    int j;
    int tempIndex;
    int* result;
    int number;
    float alpha1        = 1.0f - alpha;
    
    for( lineNumber = 0; lineNumber < height; lineNumber ++ )
    {
        leftTemp    = leftArray + leftLineSize * lineNumber;
        middleTemp  = middleArray + middleLineSize * lineNumber;
        rightTemp   = rightArray + rightLineSize * lineNumber;
        memset( ( void* )middleTemp, 0, middleLineSize );

        result = _corrArray + width * 2 * lineNumber;
        number = _numCorrArray[ lineNumber ];
        
        prevLeftPixel   = result[ number * 2 - 2 ];
        prevMiddlePixel = (int)( result[ number * 2 - 2 ] * alpha1 + result[ number * 2 - 1 ] * alpha );
        prevRightPixel  = result[ number * 2 - 1 ];
        for( i = number - 1; i >= 0; i -- )
        {
            leftPixel       = result[ i * 2 ];
            rightPixel      = result[ i * 2 + 1 ];
            middlePixel     = (int)( leftPixel * alpha1 + rightPixel * alpha );
            leftPixel3      = leftPixel * 3;
            middlePixel3    = middlePixel * 3;
            rightPixel3     = rightPixel * 3;
            
            if( imageNeed == morphDepthMap ) {
                int t   = leftPixel - rightPixel + maxDifference;
                t       = t < 0 ? -t : t;
                t       = t * 255 / maxDifference / 2;
                middleTemp[ middlePixel3 ]      = ( unsigned char )t;
                middleTemp[ middlePixel3 + 1 ]  = ( unsigned char )t;
                middleTemp[ middlePixel3 + 2 ]  = ( unsigned char )t;
            } // if( imageNeed == morphDepthMap )
            else
            {
                middleTemp[ middlePixel3 ] =
                    (unsigned char)( leftTemp[ leftPixel3 ] * alpha1 + rightTemp[ rightPixel3 ] * alpha );
                middleTemp[ middlePixel3 + 1 ] =
                    (unsigned char)( leftTemp[ leftPixel3 + 1 ] * alpha1 + rightTemp[ rightPixel3 + 1 ] * alpha );
                middleTemp[ middlePixel3 + 2 ] =
                    (unsigned char)( leftTemp[ leftPixel3 + 2 ] * alpha1 + rightTemp[ rightPixel3 + 2 ] * alpha );

                if( middlePixel - prevMiddlePixel > 1 ) // occlusion
                {
                    if( leftPixel - prevLeftPixel > 1 )
                    {
                        int LenSrc  = leftPixel - prevLeftPixel - 2;
                        int LenDest = middlePixel - prevMiddlePixel - 1;
                        for( j = prevMiddlePixel + 1; j < middlePixel; j ++ )
                        {
                            tempIndex   = prevLeftPixel + 1 + LenSrc * ( j - prevMiddlePixel - 1 ) / LenDest;
                            middleTemp[ j * 3 ]     = leftTemp[ tempIndex * 3 ];
                            middleTemp[ j * 3 + 1 ] = leftTemp[ tempIndex * 3 + 1 ];
                            middleTemp[ j * 3 + 2 ] = leftTemp[ tempIndex * 3 + 2 ];
                        }
                    } // if( leftPixel - prevLeftPixel > 1 )
                    else
                    {
                        int LenSrc  = rightPixel - prevRightPixel - 2;
                        int LenDest = middlePixel - prevMiddlePixel - 1;
                        for( j = prevMiddlePixel + 1; j < middlePixel; j ++ )
                        {
                            tempIndex   = prevRightPixel + 1 + LenSrc * ( j - prevMiddlePixel - 1 ) / LenDest;
                            middleTemp[ j * 3 ]     = rightTemp[ tempIndex * 3 ];
                            middleTemp[ j * 3 + 1 ] = rightTemp[ tempIndex * 3 + 1 ];
                            middleTemp[ j * 3 + 2 ] = rightTemp[ tempIndex * 3 + 2 ];
                        }
                    } // if( leftPixel - prevLeftPixel > 1 ) else
                    
                } // if( middlePixel - prevMiddlePixel > 1 )

            } // if( imageNeed == morphDepthMap ) else
            prevLeftPixel   = leftPixel;
            prevRightPixel  = rightPixel;
            prevMiddlePixel = middlePixel;
        } // for( i = number - 1; i >= 0; i -- )
        
    } // for( lineNumber = 0; lineNumber < LeftImage -> m_Raster -> GetHeight() )

} // Morph

// This function calculates color difference between two points ( one on the left image and one on the other )
//      _leftLine               - pointer to line on the left image
//      _rightLine              - pointer to line on the right image
//      lineSize                - width of line in points
//      x                       - index of interesting point on the left image
//      y                       - index of interesting point on the right image
int CCvPixelToPixelMorpher::distance( unsigned char* _leftLine,
                                      unsigned char* _rightLine,
                                      int lineSize,
                                      int x,
                                      int y
                                    )
{
    int IrMaxRed;
    int IrMinRed;
    int IrMaxGreen;
    int IrMinGreen;
    int IrMaxBlue;
    int IrMinBlue;

    int IlMaxRed;
    int IlMinRed;
    int IlMaxGreen;
    int IlMinGreen;
    int IlMaxBlue;
    int IlMinBlue;

    int DlRed;
    int DlGreen;
    int DlBlue;

    int DrRed;
    int DrGreen;
    int DrBlue;

    int DRed;
    int DGreen;
    int DBlue;

    int dist;

    int temp1;
    int temp2;


    int xState = 0;
    int yState = 0;
    int state;

    assert( lineSize > 0 );

    _Color* leftPixel       = ( _Color* )( _leftLine ) + x;
    _Color* rightPixel      = ( _Color* )( _rightLine ) + y;

    if( lineSize == 1 ) {
        DRed = leftPixel->red - rightPixel->red;
        DRed = MAX2( DRed, -DRed );
        DGreen = leftPixel->green - rightPixel->green;
        DGreen = MAX2( DGreen, -DGreen );
        DBlue = leftPixel->blue - rightPixel->blue;
        DBlue = MAX2( DBlue, -DBlue );
        return MAX3( DRed, DGreen, DBlue );
    }

    if( x == 0 ) {
        xState = -1;
    }
    else if( x == lineSize - 1 )
    {
        xState = 1;
    }

    if( y == 0 ) {
        yState = -1;
    }
    else if( y == lineSize - 1 )
    {
        yState = 1;
    }

    state = yState * 3 + xState;

    switch( state )
    {
    case 0: // xState = yState = 0
        {
            // Red
            temp1 = ( (leftPixel - 1)->red + leftPixel->red ) >> 1;
            temp2 = ( (leftPixel + 1)->red + leftPixel->red ) >> 1;