_cveigenobjectstestfunctions.cpp

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

        float Em = (float)fabs(E[i]);
        for(j=i+1; j<n; j++)
        {
            float Ej = (float)fabs(E[j]);
            m  = ( Em < Ej ) ?  j :  m;
            Em = ( Em < Ej ) ? Ej : Em;
        }
        if( m != i )
        {
            int l;
            float b = E[i];
            E[i] = E[m];
            E[m] = b;
            for(j=0, k=i*n, l=m*n; j<n; j++, k++, l++)
            {
                b    = V[k];
                V[k] = V[l];
                V[l] = b;
            }
        }
    }

    return CV_NO_ERR;
}



/*______________________________________________________________________________________*/

CvStatus  _cvCalcEigenObjects_8u32fR_q( int      nObjects,
                                      uchar**  objects,
                                      int      objStep,
                                      float**  eigObjs,
                                      int      eigStep,
                                      CvSize size,
                                      float*   eigVals,
                                      float*   avg,
                                      int      avgStep,
                                      int*     nEigObjs,
                                      double*  eps      )
{
    int i, j, k, l;
    uchar *bu;
    float *c=0, *ev=0, *bf, *bf1, *bf2, m;
    CvStatus  r;


    if ( nObjects < 2 )                                         return CV_BADFACTOR_ERR;
    if ( size.width > objStep || 4*size.width > eigStep ||
         4*size.width > avgStep || size.height < 1)             return CV_BADSIZE_ERR;
    if ( objects == NULL || eigObjs == NULL || eigVals == NULL ||
         avg == NULL || nEigObjs == NULL || eps == NULL )       return CV_NULLPTR_ERR;
    for( i=0; i<nObjects;  i++ ) if( objects[i] == NULL ) return CV_NULLPTR_ERR;
    for( i=0; i<*nEigObjs; i++ ) if( eigObjs[i] == NULL ) return CV_NULLPTR_ERR;

    eigStep /= 4;
    avgStep /= 4;

/* Calculation of averaged object */
    bf = avg;
    for(i = 0; i < size.height; i++, bf += avgStep)
        for(j = 0; j < size.width; j++)
            bf[j] = 0.f;
    for(k = 0; k < nObjects; k++)
    {
        bu = objects[k];
        bf = avg;
        for(i = 0; i < size.height; i++, bu +=objStep, bf += avgStep)
            for(j = 0; j < size.width; j++)
                bf[j] += bu[j];
    }
    m = 1.0f/(float)nObjects;
    bf = avg;
    for(i = 0; i < size.height; i++, bf += avgStep)
        for(j = 0; j < size.width; j++)
            bf[j] *= m;

/* Calculation of covariance matrix */
    c  = (float*)icvAlloc ( sizeof(float)*nObjects*nObjects );
    if(c==NULL) return CV_OUTOFMEM_ERR;

    r = _cvCalcCovarMatrix_8u32fR_q ( nObjects, objects, objStep,
                                     avg, 4*avgStep, size, c );
    if(r) { icvFree((void**)&c );  return r; }

/* Calculation of eigenvalues & eigenvectors */
    ev = (float*)icvAlloc ( sizeof(float)*nObjects*nObjects );
    if(ev==NULL) { icvFree((void**)&c );  return CV_OUTOFMEM_ERR; }

    _cvJacobiEigens_32f( c, ev, eigVals, nObjects, 0.0f );
    icvFree((void**)&c );

    for(i=0; i<*nEigObjs; i++) if( fabs(eigVals[i]/eigVals[0]) < *eps ) break;
    *nEigObjs = i;
    *eps = fabs(eigVals[*nEigObjs-1]/eigVals[0]);

/* Calculation of eigenobjects */
    bf2 = ev;
    for(i=0; i<*nEigObjs; i++, bf2+=nObjects)
    {
        float  e = (float)(1.0/sqrt(eigVals[i]));
        float* u = eigObjs[i];

        bf  = u;
        for(l=0; l<size.height; l++, bf+=eigStep)
            for(j=0; j<size.width; j++) bf[j] = 0.0f;

        for(k=0; k<nObjects; k++)
        {
            float v = e*bf2[k];
            bf  = u;
            bu  = objects[k];
            bf1 = avg;
            for(l=0; l<size.height; l++, bf+=eigStep, bf1+=avgStep, bu+=objStep)
                for(j=0; j<size.width; j++) bf[j] += v * ((float)bu[j] - bf1[j]);
        }
    }

    icvFree((void**)&ev );
    return CV_NO_ERR;
} /* --- End of _cvCalcEigenObjects_8u32fR --- */
/*______________________________________________________________________________________*/

float _cvCalcDecompCoeff_8u32fR_q( uchar*  obj,
                                   int     objStep,
                                   float*  eigObj,
                                   int     eigStep,
                                   float*  avg,
                                   int     avgStep,
                                   CvSize size )
{
    int i, k;
    float w = 0.0f;

    if ( size.width > objStep || 4*size.width > eigStep
         || 4*size.width > avgStep || size.height < 1)  return -1.0e30f;
    if ( obj == NULL || eigObj == NULL || avg == NULL ) return -1.0e30f;

    eigStep /= 4;
    avgStep /= 4;

    for(i = 0; i < size.height; i++, obj += objStep, eigObj += eigStep, avg += avgStep)
        for(k = 0; k < size.width; k++)
            w += eigObj[k]*( (float)obj[k] - avg[k] );

    return w;
}
/*______________________________________________________________________________________*/

CvStatus  _cvEigenDecomposite_8u32fR_q( uchar*  obj,
                                          int     objStep,
                                          int     nEigObjs,
                                          float** eigObjs,
                                          int     eigStep,
                                          float*  avg,
                                          int     avgStep,
                                          CvSize size,
                                          float*  coeffs )
{
    int i;

    if ( nEigObjs < 2 )                                    return CV_BADFACTOR_ERR;
    if ( size.width > objStep || 4*size.width > eigStep ||
         4*size.width > avgStep || size.height < 1)        return CV_BADSIZE_ERR;
    if ( obj == NULL || eigObjs == NULL || coeffs == NULL || avg == NULL)
        return CV_NULLPTR_ERR;

    for(i=0; i<nEigObjs; i++)
    {
        float w = _cvCalcDecompCoeff_8u32fR_q( obj, objStep, eigObjs[i], eigStep,
                                              avg, avgStep, size );
        if( w < -1.0e29f ) return CV_NOTDEFINED_ERR;
        coeffs[i] = w;
    }
    return CV_NO_ERR;
}
/*______________________________________________________________________________________*/

CvStatus  _cvEigenProjection_8u32fR_q( int     nEigObjs,
                                         float** eigens,
                                         int     eigStep,
                                         float*  coeffs,
                                         float*  avg,
                                         int     avgStep,
                                         uchar*  rest,
                                         int     restStep,
                                         CvSize size )
{
    int i, j, k;

    if ( size.width > avgStep || 4*size.width > eigStep || size.height < 1)
                                                        return CV_BADSIZE_ERR;
    if ( rest == NULL || eigens == NULL || avg == NULL || coeffs == NULL )
                                                        return CV_NULLPTR_ERR;
    eigStep /= 4;
    avgStep /= 4;

    for(i = 0; i < size.height; i++, rest+=restStep, avg+=avgStep)
    {
        int ij = i*eigStep;
        for(j = 0; j < size.width; j++, ij++)
        {
            float w = avg[j];
            for(k=0; k<nEigObjs-3; k+=4)
            {
                float* b = eigens[k];
                w += coeffs[k  ] * b[ij];
                b = eigens [k+1];
                w += coeffs[k+1] * b[ij];
                b = eigens [k+2];
                w += coeffs[k+2] * b[ij];
                b = eigens [k+3];
                w += coeffs[k+3] * b[ij];
            }
            for(; k<nEigObjs; k++)
            {
                float* b = eigens[k];
                w += coeffs[k] * b[ij];
            }
            w = w<-0.499999f ? -0.499999f : w>255.499f ? 255.499f : w;
            rest[j] = (uchar)cvRound( w );
        }
    }
    return CV_NO_ERR;
}
/*______________________________________________________________________________________*/

/*   << End  of  file >>  */