+++ /dev/null
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-// By downloading, copying, installing or using the software you agree to this license.
-// If you do not agree to this license, do not download, install,
-// copy or use the software.
-//
-//
-// Intel License Agreement
-// For Open Source Computer Vision Library
-//
-// Copyright (C) 2000, Intel Corporation, all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-//
-// * Redistribution's of source code must retain the above copyright notice,
-// this list of conditions and the following disclaimer.
-//
-// * Redistribution's in binary form must reproduce the above copyright notice,
-// this list of conditions and the following disclaimer in the documentation
-// and/or other materials provided with the distribution.
-//
-// * The name of Intel Corporation may not be used to endorse or promote products
-// derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is" and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-#include "_cvaux.h"
-
-CvStatus CV_STDCALL
-icvJacobiEigens_32f(float *A, float *V, float *E, int n, float eps)
-{
- int i, j, k, ind;
- float *AA = A, *VV = V;
- double Amax, anorm = 0, ax;
-
- if( A == NULL || V == NULL || E == NULL )
- return CV_NULLPTR_ERR;
- if( n <= 0 )
- return CV_BADSIZE_ERR;
- if( eps < 1.0e-7f )
- eps = 1.0e-7f;
-
- /*-------- Prepare --------*/
- for( i = 0; i < n; i++, VV += n, AA += n )
- {
- for( j = 0; j < i; j++ )
- {
- double Am = AA[j];
-
- anorm += Am * Am;
- }
- for( j = 0; j < n; j++ )
- VV[j] = 0.f;
- VV[i] = 1.f;
- }
-
- anorm = sqrt( anorm + anorm );
- ax = anorm * eps / n;
- Amax = anorm;
-
- while( Amax > ax )
- {
- Amax /= n;
- do /* while (ind) */
- {
- int p, q;
- float *V1 = V, *A1 = A;
-
- ind = 0;
- for( p = 0; p < n - 1; p++, A1 += n, V1 += n )
- {
- float *A2 = A + n * (p + 1), *V2 = V + n * (p + 1);
-
- for( q = p + 1; q < n; q++, A2 += n, V2 += n )
- {
- double x, y, c, s, c2, s2, a;
- float *A3, Apq = A1[q], App, Aqq, Aip, Aiq, Vpi, Vqi;
-
- if( fabs( Apq ) < Amax )
- continue;
-
- ind = 1;
-
- /*---- Calculation of rotation angle's sine & cosine ----*/
- App = A1[p];
- Aqq = A2[q];
- y = 5.0e-1 * (App - Aqq);
- x = -Apq / sqrt( (double)Apq * Apq + (double)y * y );
- if( y < 0.0 )
- x = -x;
- s = x / sqrt( 2.0 * (1.0 + sqrt( 1.0 - (double)x * x )));
- s2 = s * s;
- c = sqrt( 1.0 - s2 );
- c2 = c * c;
- a = 2.0 * Apq * c * s;
-
- /*---- Apq annulation ----*/
- A3 = A;
- for( i = 0; i < p; i++, A3 += n )
- {
- Aip = A3[p];
- Aiq = A3[q];
- Vpi = V1[i];
- Vqi = V2[i];
- A3[p] = (float) (Aip * c - Aiq * s);
- A3[q] = (float) (Aiq * c + Aip * s);
- V1[i] = (float) (Vpi * c - Vqi * s);
- V2[i] = (float) (Vqi * c + Vpi * s);
- }
- for( ; i < q; i++, A3 += n )
- {
- Aip = A1[i];
- Aiq = A3[q];
- Vpi = V1[i];
- Vqi = V2[i];
- A1[i] = (float) (Aip * c - Aiq * s);
- A3[q] = (float) (Aiq * c + Aip * s);
- V1[i] = (float) (Vpi * c - Vqi * s);
- V2[i] = (float) (Vqi * c + Vpi * s);
- }
- for( ; i < n; i++ )
- {
- Aip = A1[i];
- Aiq = A2[i];
- Vpi = V1[i];
- Vqi = V2[i];
- A1[i] = (float) (Aip * c - Aiq * s);
- A2[i] = (float) (Aiq * c + Aip * s);
- V1[i] = (float) (Vpi * c - Vqi * s);
- V2[i] = (float) (Vqi * c + Vpi * s);
- }
- A1[p] = (float) (App * c2 + Aqq * s2 - a);
- A2[q] = (float) (App * s2 + Aqq * c2 + a);
- A1[q] = A2[p] = 0.0f;
- } /*q */
- } /*p */
- }
- while( ind );
- Amax /= n;
- } /* while ( Amax > ax ) */
-
- for( i = 0, k = 0; i < n; i++, k += n + 1 )
- E[i] = A[k];
- /*printf(" M = %d\n", M); */
-
- /* -------- ordering -------- */
- for( i = 0; i < n; i++ )
- {
- int m = i;
- 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;
-}
-
-/*F///////////////////////////////////////////////////////////////////////////////////////
-// Name: icvCalcCovarMatrixEx_8u32fR
-// Purpose: The function calculates a covariance matrix for a group of input objects
-// (images, vectors, etc.). ROI supported.
-// Context:
-// Parameters: nObjects - number of source objects
-// objects - array of pointers to ROIs of the source objects
-// imgStep - full width of each source object row in bytes
-// avg - pointer to averaged object
-// avgStep - full width of averaged object row in bytes
-// size - ROI size of each source and averaged objects
-// covarMatrix - covariance matrix (output parameter; must be allocated
-// before call)
-//
-// Returns: CV_NO_ERR or error code
-//
-// Notes:
-//F*/
-static CvStatus CV_STDCALL
-icvCalcCovarMatrixEx_8u32fR( int nObjects, void *input, int objStep1,
- int ioFlags, int ioBufSize, uchar* buffer,
- void *userData, float *avg, int avgStep,
- CvSize size, float *covarMatrix )
-{
- int objStep = objStep1;
-
- /* ---- TEST OF PARAMETERS ---- */
-
- if( nObjects < 2 )
- return CV_BADFACTOR_ERR;
- if( ioFlags < 0 || ioFlags > 3 )
- return CV_BADFACTOR_ERR;
- if( ioFlags && ioBufSize < 1024 )
- return CV_BADFACTOR_ERR;
- if( ioFlags && buffer == NULL )
- return CV_NULLPTR_ERR;
- if( input == NULL || avg == NULL || covarMatrix == NULL )
- return CV_NULLPTR_ERR;
- if( size.width > objStep || 4 * size.width > avgStep || size.height < 1 )
- return CV_BADSIZE_ERR;
-
- avgStep /= 4;
-
- if( ioFlags & CV_EIGOBJ_INPUT_CALLBACK ) /* ==== USE INPUT CALLBACK ==== */
- {
- int nio, ngr, igr, n = size.width * size.height, mm = 0;
- CvCallback read_callback = ((CvInput *) & input)->callback;
- uchar *buffer2;
-
- objStep = n;
- nio = ioBufSize / n; /* number of objects in buffer */
- ngr = nObjects / nio; /* number of io groups */
- if( nObjects % nio )
- mm = 1;
- ngr += mm;
-
- buffer2 = (uchar *)cvAlloc( sizeof( uchar ) * n );
- if( buffer2 == NULL )
- return CV_OUTOFMEM_ERR;
-
- for( igr = 0; igr < ngr; igr++ )
- {
- int k, l;
- int io, jo, imin = igr * nio, imax = imin + nio;
- uchar *bu1 = buffer, *bu2;
-
- if( imax > nObjects )
- imax = nObjects;
-
- /* read igr group */
- for( io = imin; io < imax; io++, bu1 += n )
- {
- CvStatus r;
-
- r = (CvStatus)read_callback( io, (void *) bu1, userData );
- if( r )
- return r;
- }
-
- /* diagonal square calc */
- bu1 = buffer;
- for( io = imin; io < imax; io++, bu1 += n )
- {
- bu2 = bu1;
- for( jo = io; jo < imax; jo++, bu2 += n )
- {
- float w = 0.f;
- float *fu = avg;
- int ij = 0;
-
- for( k = 0; k < size.height; k++, fu += avgStep )
- for( l = 0; l < size.width; l++, ij++ )
- {
- float f = fu[l], u1 = bu1[ij], u2 = bu2[ij];
-
- w += (u1 - f) * (u2 - f);
- }
- covarMatrix[io * nObjects + jo] = covarMatrix[jo * nObjects + io] = w;
- }
- }
-
- /* non-diagonal elements calc */
- for( jo = imax; jo < nObjects; jo++ )
- {
- CvStatus r;
-
- bu1 = buffer;
- bu2 = buffer2;
-
- /* read jo object */
- r = (CvStatus)read_callback( jo, (void *) bu2, userData );
- if( r )
- return r;
-
- for( io = imin; io < imax; io++, bu1 += n )
- {
- float w = 0.f;
- float *fu = avg;
- int ij = 0;
-
- for( k = 0; k < size.height; k++, fu += avgStep )
- {
- for( l = 0; l < size.width - 3; l += 4, ij += 4 )
- {
- float f = fu[l];
- uchar u1 = bu1[ij];
- uchar u2 = bu2[ij];
-
- w += (u1 - f) * (u2 - f);
- f = fu[l + 1];
- u1 = bu1[ij + 1];
- u2 = bu2[ij + 1];
- w += (u1 - f) * (u2 - f);
- f = fu[l + 2];
- u1 = bu1[ij + 2];
- u2 = bu2[ij + 2];
- w += (u1 - f) * (u2 - f);
- f = fu[l + 3];
- u1 = bu1[ij + 3];
- u2 = bu2[ij + 3];
- w += (u1 - f) * (u2 - f);
- }
- for( ; l < size.width; l++, ij++ )
- {
- float f = fu[l], u1 = bu1[ij], u2 = bu2[ij];
-
- w += (u1 - f) * (u2 - f);
- }
- }
- covarMatrix[io * nObjects + jo] = covarMatrix[jo * nObjects + io] = w;
- }
- }
- } /* igr */
-
- cvFree( &buffer2 );
- } /* if() */
-
- else
- /* ==== NOT USE INPUT CALLBACK ==== */
- {
- int i, j;
- uchar **objects = (uchar **) (((CvInput *) & input)->data);
-
- for( i = 0; i < nObjects; i++ )
- {
- uchar *bu = objects[i];
-
- for( j = i; j < nObjects; j++ )
- {
- int k, l;
- float w = 0.f;
- float *a = avg;
- uchar *bu1 = bu;
- uchar *bu2 = objects[j];
-
- for( k = 0; k < size.height;
- k++, bu1 += objStep, bu2 += objStep, a += avgStep )
- {
- for( l = 0; l < size.width - 3; l += 4 )
- {
- float f = a[l];
- uchar u1 = bu1[l];
- uchar u2 = bu2[l];
-
- w += (u1 - f) * (u2 - f);
- f = a[l + 1];
- u1 = bu1[l + 1];
- u2 = bu2[l + 1];
- w += (u1 - f) * (u2 - f);
- f = a[l + 2];
- u1 = bu1[l + 2];
- u2 = bu2[l + 2];
- w += (u1 - f) * (u2 - f);
- f = a[l + 3];
- u1 = bu1[l + 3];
- u2 = bu2[l + 3];
- w += (u1 - f) * (u2 - f);
- }
- for( ; l < size.width; l++ )
- {
- float f = a[l];
- uchar u1 = bu1[l];
- uchar u2 = bu2[l];
-
- w += (u1 - f) * (u2 - f);
- }
- }
-
- covarMatrix[i * nObjects + j] = covarMatrix[j * nObjects + i] = w;
- }
- }
- } /* else */
-
- return CV_NO_ERR;
-}
-
-/*======================== end of icvCalcCovarMatrixEx_8u32fR ===========================*/
-
-
-static int
-icvDefaultBufferSize( void )
-{
- return 10 * 1024 * 1024;
-}
-
-/*F///////////////////////////////////////////////////////////////////////////////////////
-// Name: icvCalcEigenObjects_8u32fR
-// Purpose: The function calculates an orthonormal eigen basis and a mean (averaged)
-// object for a group of input objects (images, vectors, etc.). ROI supported.
-// Context:
-// Parameters: nObjects - number of source objects
-// input - pointer either to array of pointers to input objects
-// or to read callback function (depending on ioFlags)
-// imgStep - full width of each source object row in bytes
-// output - pointer either to array of pointers to output eigen objects
-// or to write callback function (depending on ioFlags)
-// eigStep - full width of each eigenobject row in bytes
-// size - ROI size of each source object
-// ioFlags - input/output flags (see Notes)
-// ioBufSize - input/output buffer size
-// userData - pointer to the structure which contains all necessary
-// data for the callback functions
-// calcLimit - determines the calculation finish conditions
-// avg - pointer to averaged object (has the same size as ROI)
-// avgStep - full width of averaged object row in bytes
-// eigVals - pointer to corresponding eigenvalues (array of <nObjects>
-// elements in descending order)
-//
-// Returns: CV_NO_ERR or error code
-//
-// Notes: 1. input/output data (that is, input objects and eigen ones) may either
-// be allocated in the RAM or be read from/written to the HDD (or any
-// other device) by read/write callback functions. It depends on the
-// value of ioFlags paramater, which may be the following:
-// CV_EIGOBJ_NO_CALLBACK, or 0;
-// CV_EIGOBJ_INPUT_CALLBACK;
-// CV_EIGOBJ_OUTPUT_CALLBACK;
-// CV_EIGOBJ_BOTH_CALLBACK, or
-// CV_EIGOBJ_INPUT_CALLBACK | CV_EIGOBJ_OUTPUT_CALLBACK.
-// The callback functions as well as the user data structure must be
-// developed by the user.
-//
-// 2. If ioBufSize = 0, or it's too large, the function dermines buffer size
-// itself.
-//
-// 3. Depending on calcLimit parameter, calculations are finished either if
-// eigenfaces number comes up to certain value or the relation of the
-// current eigenvalue and the largest one comes down to certain value
-// (or any of the above conditions takes place). The calcLimit->type value
-// must be CV_TERMCRIT_NUMB, CV_TERMCRIT_EPS or
-// CV_TERMCRIT_NUMB | CV_TERMCRIT_EPS. The function returns the real
-// values calcLimit->max_iter and calcLimit->epsilon.
-//
-// 4. eigVals may be equal to NULL (if you don't need eigen values in further).
-//
-//F*/
-static CvStatus CV_STDCALL
-icvCalcEigenObjects_8u32fR( int nObjects, void* input, int objStep,
- void* output, int eigStep, CvSize size,
- int ioFlags, int ioBufSize, void* userData,
- CvTermCriteria* calcLimit, float* avg,
- int avgStep, float *eigVals )
-{
- int i, j, n, iev = 0, m1 = nObjects - 1, objStep1 = objStep, eigStep1 = eigStep / 4;
- CvSize objSize, eigSize, avgSize;
- float *c = 0;
- float *ev = 0;
- float *bf = 0;
- uchar *buf = 0;
- void *buffer = 0;
- float m = 1.0f / (float) nObjects;
- CvStatus r;
-
- if( m1 > calcLimit->max_iter && calcLimit->type != CV_TERMCRIT_EPS )
- m1 = calcLimit->max_iter;
-
- /* ---- TEST OF PARAMETERS ---- */
-
- if( nObjects < 2 )
- return CV_BADFACTOR_ERR;
- if( ioFlags < 0 || ioFlags > 3 )
- return CV_BADFACTOR_ERR;
- if( input == NULL || output == NULL || avg == NULL )
- return CV_NULLPTR_ERR;
- if( size.width > objStep || 4 * size.width > eigStep ||
- 4 * size.width > avgStep || size.height < 1 )
- return CV_BADSIZE_ERR;
- if( !(ioFlags & CV_EIGOBJ_INPUT_CALLBACK) )
- for( i = 0; i < nObjects; i++ )
- if( ((uchar **) input)[i] == NULL )
- return CV_NULLPTR_ERR;
- if( !(ioFlags & CV_EIGOBJ_OUTPUT_CALLBACK) )
- for( i = 0; i < m1; i++ )
- if( ((float **) output)[i] == NULL )
- return CV_NULLPTR_ERR;
-
- avgStep /= 4;
- eigStep /= 4;
-
- if( objStep == size.width && eigStep == size.width && avgStep == size.width )
- {
- size.width *= size.height;
- size.height = 1;
- objStep = objStep1 = eigStep = eigStep1 = avgStep = size.width;
- }
- objSize = eigSize = avgSize = size;
-
- if( ioFlags & CV_EIGOBJ_INPUT_CALLBACK )
- {
- objSize.width *= objSize.height;
- objSize.height = 1;
- objStep = objSize.width;
- objStep1 = size.width;
- }
-
- if( ioFlags & CV_EIGOBJ_OUTPUT_CALLBACK )
- {
- eigSize.width *= eigSize.height;
- eigSize.height = 1;
- eigStep = eigSize.width;
- eigStep1 = size.width;
- }
-
- n = objSize.height * objSize.width * (ioFlags & CV_EIGOBJ_INPUT_CALLBACK) +
- 2 * eigSize.height * eigSize.width * (ioFlags & CV_EIGOBJ_OUTPUT_CALLBACK);
-
- /* Buffer size determination */
- if( ioFlags )
- {
- int size = icvDefaultBufferSize();
- ioBufSize = MIN( size, n );
- }
-
- /* memory allocation (if necesseay) */
-
- if( ioFlags & CV_EIGOBJ_INPUT_CALLBACK )
- {
- buf = (uchar *) cvAlloc( sizeof( uchar ) * objSize.width );
- if( buf == NULL )
- return CV_OUTOFMEM_ERR;
- }
-
- if( ioFlags )
- {
- buffer = (void *) cvAlloc( ioBufSize );
- if( buffer == NULL )
- {
- if( buf )
- cvFree( &buf );
- return CV_OUTOFMEM_ERR;
- }
- }
-
- /* Calculation of averaged object */
- bf = avg;
- for( i = 0; i < avgSize.height; i++, bf += avgStep )
- for( j = 0; j < avgSize.width; j++ )
- bf[j] = 0.f;
-
- for( i = 0; i < nObjects; i++ )
- {
- int k, l;
- uchar *bu = (ioFlags & CV_EIGOBJ_INPUT_CALLBACK) ? buf : ((uchar **) input)[i];
-
- if( ioFlags & CV_EIGOBJ_INPUT_CALLBACK )
- {
- CvCallback read_callback = ((CvInput *) & input)->callback;
-
- r = (CvStatus)read_callback( i, (void *) buf, userData );
- if( r )
- {
- if( buffer )
- cvFree( &buffer );
- if( buf )
- cvFree( &buf );
- return r;
- }
- }
-
- bf = avg;
- for( k = 0; k < avgSize.height; k++, bf += avgStep, bu += objStep1 )
- for( l = 0; l < avgSize.width; l++ )
- bf[l] += bu[l];
- }
-
- bf = avg;
- for( i = 0; i < avgSize.height; i++, bf += avgStep )
- for( j = 0; j < avgSize.width; j++ )
- bf[j] *= m;
-
- /* Calculation of covariance matrix */
- c = (float *) cvAlloc( sizeof( float ) * nObjects * nObjects );
-
- if( c == NULL )
- {
- if( buffer )
- cvFree( &buffer );
- if( buf )
- cvFree( &buf );
- return CV_OUTOFMEM_ERR;
- }
-
- r = icvCalcCovarMatrixEx_8u32fR( nObjects, input, objStep1, ioFlags, ioBufSize,
- (uchar *) buffer, userData, avg, 4 * avgStep, size, c );
- if( r )
- {
- cvFree( &c );
- if( buffer )
- cvFree( &buffer );
- if( buf )
- cvFree( &buf );
- return r;
- }
-
- /* Calculation of eigenvalues & eigenvectors */
- ev = (float *) cvAlloc( sizeof( float ) * nObjects * nObjects );
-
- if( ev == NULL )
- {
- cvFree( &c );
- if( buffer )
- cvFree( &buffer );
- if( buf )
- cvFree( &buf );
- return CV_OUTOFMEM_ERR;
- }
-
- if( eigVals == NULL )
- {
- eigVals = (float *) cvAlloc( sizeof( float ) * nObjects );
-
- if( eigVals == NULL )
- {
- cvFree( &c );
- cvFree( &ev );
- if( buffer )
- cvFree( &buffer );
- if( buf )
- cvFree( &buf );
- return CV_OUTOFMEM_ERR;
- }
- iev = 1;
- }
-
- r = icvJacobiEigens_32f( c, ev, eigVals, nObjects, 0.0f );
- cvFree( &c );
- if( r )
- {
- cvFree( &ev );
- if( buffer )
- cvFree( &buffer );
- if( buf )
- cvFree( &buf );
- if( iev )
- cvFree( &eigVals );
- return r;
- }
-
- /* Eigen objects number determination */
- if( calcLimit->type != CV_TERMCRIT_NUMBER )
- {
- for( i = 0; i < m1; i++ )
- if( fabs( eigVals[i] / eigVals[0] ) < calcLimit->epsilon )
- break;
- m1 = calcLimit->max_iter = i;
- }
- else
- m1 = calcLimit->max_iter;
- calcLimit->epsilon = (float) fabs( eigVals[m1 - 1] / eigVals[0] );
-
- for( i = 0; i < m1; i++ )
- eigVals[i] = (float) (1.0 / sqrt( (double)eigVals[i] ));
-
- /* ----------------- Calculation of eigenobjects ----------------------- */
- if( ioFlags & CV_EIGOBJ_OUTPUT_CALLBACK )
- {
- int nio, ngr, igr;
-
- nio = ioBufSize / (4 * eigSize.width); /* number of eigen objects in buffer */
- ngr = m1 / nio; /* number of io groups */
- if( nObjects % nio )
- ngr += 1;
-
- for( igr = 0; igr < ngr; igr++ )
- {
- int i, io, ie, imin = igr * nio, imax = imin + nio;
-
- if( imax > m1 )
- imax = m1;
-
- for( i = 0; i < eigSize.width * (imax - imin); i++ )
- ((float *) buffer)[i] = 0.f;
-
- for( io = 0; io < nObjects; io++ )
- {
- uchar *bu = ioFlags & CV_EIGOBJ_INPUT_CALLBACK ? buf : ((uchar **) input)[io];
-
- if( ioFlags & CV_EIGOBJ_INPUT_CALLBACK )
- {
- CvCallback read_callback = ((CvInput *) & input)->callback;
-
- r = (CvStatus)read_callback( io, (void *) buf, userData );
- if( r )
- {
- cvFree( &ev );
- if( iev )
- cvFree( &eigVals );
- if( buffer )
- cvFree( &buffer );
- if( buf )
- cvFree( &buf );
- return r;
- }
- }
-
- for( ie = imin; ie < imax; ie++ )
- {
- int k, l;
- uchar *bv = bu;
- float e = ev[ie * nObjects + io] * eigVals[ie];
- float *be = ((float *) buffer) + ((ie - imin) * eigStep);
-
- bf = avg;
- for( k = 0; k < size.height; k++, bv += objStep1,
- bf += avgStep, be += eigStep1 )
- {
- for( l = 0; l < size.width - 3; l += 4 )
- {
- float f = bf[l];
- uchar v = bv[l];
-
- be[l] += e * (v - f);
- f = bf[l + 1];
- v = bv[l + 1];
- be[l + 1] += e * (v - f);
- f = bf[l + 2];
- v = bv[l + 2];
- be[l + 2] += e * (v - f);
- f = bf[l + 3];
- v = bv[l + 3];
- be[l + 3] += e * (v - f);
- }
- for( ; l < size.width; l++ )
- be[l] += e * (bv[l] - bf[l]);
- }
- }
- } /* io */
-
- for( ie = imin; ie < imax; ie++ ) /* calculated eigen objects writting */
- {
- CvCallback write_callback = ((CvInput *) & output)->callback;
- float *be = ((float *) buffer) + ((ie - imin) * eigStep);
-
- r = (CvStatus)write_callback( ie, (void *) be, userData );
- if( r )
- {
- cvFree( &ev );
- if( iev )
- cvFree( &eigVals );
- if( buffer )
- cvFree( &buffer );
- if( buf )
- cvFree( &buf );
- return r;
- }
- }
- } /* igr */
- }
-
- else
- {
- int k, p, l;
-
- for( i = 0; i < m1; i++ ) /* e.o. annulation */
- {
- float *be = ((float **) output)[i];
-
- for( p = 0; p < eigSize.height; p++, be += eigStep )
- for( l = 0; l < eigSize.width; l++ )
- be[l] = 0.0f;
- }
-
- for( k = 0; k < nObjects; k++ )
- {
- uchar *bv = (ioFlags & CV_EIGOBJ_INPUT_CALLBACK) ? buf : ((uchar **) input)[k];
-
- if( ioFlags & CV_EIGOBJ_INPUT_CALLBACK )
- {
- CvCallback read_callback = ((CvInput *) & input)->callback;
-
- r = (CvStatus)read_callback( k, (void *) buf, userData );
- if( r )
- {
- cvFree( &ev );
- if( iev )
- cvFree( &eigVals );
- if( buffer )
- cvFree( &buffer );
- if( buf )
- cvFree( &buf );
- return r;
- }
- }
-
- for( i = 0; i < m1; i++ )
- {
- float v = eigVals[i] * ev[i * nObjects + k];
- float *be = ((float **) output)[i];
- uchar *bu = bv;
-
- bf = avg;
-
- for( p = 0; p < size.height; p++, bu += objStep1,
- bf += avgStep, be += eigStep1 )
- {
- for( l = 0; l < size.width - 3; l += 4 )
- {
- float f = bf[l];
- uchar u = bu[l];
-
- be[l] += v * (u - f);
- f = bf[l + 1];
- u = bu[l + 1];
- be[l + 1] += v * (u - f);
- f = bf[l + 2];
- u = bu[l + 2];
- be[l + 2] += v * (u - f);
- f = bf[l + 3];
- u = bu[l + 3];
- be[l + 3] += v * (u - f);
- }
- for( ; l < size.width; l++ )
- be[l] += v * (bu[l] - bf[l]);
- }
- } /* i */
- } /* k */
- } /* else */
-
- cvFree( &ev );
- if( iev )
- cvFree( &eigVals );
- else
- for( i = 0; i < m1; i++ )
- eigVals[i] = 1.f / (eigVals[i] * eigVals[i]);
- if( buffer )
- cvFree( &buffer );
- if( buf )
- cvFree( &buf );
- return CV_NO_ERR;
-}
-
-/* --- End of icvCalcEigenObjects_8u32fR --- */
-
-/*F///////////////////////////////////////////////////////////////////////////////////////
-// Name: icvCalcDecompCoeff_8u32fR
-// Purpose: The function calculates one decomposition coefficient of input object
-// using previously calculated eigen object and the mean (averaged) object
-// Context:
-// Parameters: obj - input object
-// objStep - its step (in bytes)
-// eigObj - pointer to eigen object
-// eigStep - its step (in bytes)
-// avg - pointer to averaged object
-// avgStep - its step (in bytes)
-// size - ROI size of each source object
-//
-// Returns: decomposition coefficient value or large negative value (if error)
-//
-// Notes:
-//F*/
-static float CV_STDCALL
-icvCalcDecompCoeff_8u32fR( 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;
-
- if( size.width == objStep && size.width == eigStep && size.width == avgStep )
- {
- size.width *= size.height;
- size.height = 1;
- objStep = eigStep = avgStep = size.width;
- }
-
- for( i = 0; i < size.height; i++, obj += objStep, eigObj += eigStep, avg += avgStep )
- {
- for( k = 0; k < size.width - 4; k += 4 )
- {
- float o = (float) obj[k];
- float e = eigObj[k];
- float a = avg[k];
-
- w += e * (o - a);
- o = (float) obj[k + 1];
- e = eigObj[k + 1];
- a = avg[k + 1];
- w += e * (o - a);
- o = (float) obj[k + 2];
- e = eigObj[k + 2];
- a = avg[k + 2];
- w += e * (o - a);
- o = (float) obj[k + 3];
- e = eigObj[k + 3];
- a = avg[k + 3];
- w += e * (o - a);
- }
- for( ; k < size.width; k++ )
- w += eigObj[k] * ((float) obj[k] - avg[k]);
- }
-
- return w;
-}
-
-/*F///////////////////////////////////////////////////////////////////////////////////////
-// Names: icvEigenDecomposite_8u32fR
-// Purpose: The function calculates all decomposition coefficients for input object
-// using previously calculated eigen objects basis and the mean (averaged)
-// object
-// Context:
-// Parameters: obj - input object
-// objStep - its step (in bytes)
-// nEigObjs - number of eigen objects
-// eigInput - pointer either to array of pointers to eigen objects
-// or to read callback function (depending on ioFlags)
-// eigStep - eigen objects step (in bytes)
-// ioFlags - input/output flags
-// iserData - pointer to the structure which contains all necessary
-// data for the callback function
-// avg - pointer to averaged object
-// avgStep - its step (in bytes)
-// size - ROI size of each source object
-// coeffs - calculated coefficients (output data)
-//
-// Returns: icv status
-//
-// Notes: see notes for icvCalcEigenObjects_8u32fR function
-//F*/
-static CvStatus CV_STDCALL
-icvEigenDecomposite_8u32fR( uchar * obj, int objStep, int nEigObjs,
- void *eigInput, int eigStep, int ioFlags,
- void *userData, float *avg, int avgStep,
- CvSize size, float *coeffs )
-{
- int i;
-
- if( nEigObjs < 2 )
- return CV_BADFACTOR_ERR;
- if( ioFlags < 0 || ioFlags > 1 )
- 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 || eigInput == NULL || coeffs == NULL || avg == NULL )
- return CV_NULLPTR_ERR;
- if( !ioFlags )
- for( i = 0; i < nEigObjs; i++ )
- if( ((uchar **) eigInput)[i] == NULL )
- return CV_NULLPTR_ERR;
-
- if( ioFlags ) /* callback */
-
- {
- float *buffer;
- CvCallback read_callback = ((CvInput *) & eigInput)->callback;
-
- eigStep = 4 * size.width;
-
- /* memory allocation */
- buffer = (float *) cvAlloc( sizeof( float ) * size.width * size.height );
-
- if( buffer == NULL )
- return CV_OUTOFMEM_ERR;
-
- for( i = 0; i < nEigObjs; i++ )
- {
- float w;
- CvStatus r = (CvStatus)read_callback( i, (void *) buffer, userData );
-
- if( r )
- {
- cvFree( &buffer );
- return r;
- }
- w = icvCalcDecompCoeff_8u32fR( obj, objStep, buffer,
- eigStep, avg, avgStep, size );
- if( w < -1.0e29f )
- {
- cvFree( &buffer );
- return CV_NOTDEFINED_ERR;
- }
- coeffs[i] = w;
- }
- cvFree( &buffer );
- }
-
- else
- /* no callback */
- for( i = 0; i < nEigObjs; i++ )
- {
- float w = icvCalcDecompCoeff_8u32fR( obj, objStep, ((float **) eigInput)[i],
- eigStep, avg, avgStep, size );
-
- if( w < -1.0e29f )
- return CV_NOTDEFINED_ERR;
- coeffs[i] = w;
- }
-
- return CV_NO_ERR;
-}
-
-
-/*F///////////////////////////////////////////////////////////////////////////////////////
-// Names: icvEigenProjection_8u32fR
-// Purpose: The function calculates object projection to the eigen sub-space (restores
-// an object) using previously calculated eigen objects basis, mean (averaged)
-// object and decomposition coefficients of the restored object
-// Context:
-// Parameters: nEigObjs - Number of eigen objects
-// eigens - Array of pointers to eigen objects
-// eigStep - Eigen objects step (in bytes)
-// coeffs - Previously calculated decomposition coefficients
-// avg - Pointer to averaged object
-// avgStep - Its step (in bytes)
-// rest - Pointer to restored object
-// restStep - Its step (in bytes)
-// size - ROI size of each object
-//
-// Returns: CV status
-//
-// Notes:
-//F*/
-static CvStatus CV_STDCALL
-icvEigenProjection_8u32fR( int nEigObjs, void *eigInput, int eigStep,
- int ioFlags, void *userData, float *coeffs,
- float *avg, int avgStep, uchar * rest,
- int restStep, CvSize size )
-{
- int i, j, k;
- float *buf;
- float *buffer = NULL;
- float *b;
- CvCallback read_callback = ((CvInput *) & eigInput)->callback;
-
- if( size.width > avgStep || 4 * size.width > eigStep || size.height < 1 )
- return CV_BADSIZE_ERR;
- if( rest == NULL || eigInput == NULL || avg == NULL || coeffs == NULL )
- return CV_NULLPTR_ERR;
- if( ioFlags < 0 || ioFlags > 1 )
- return CV_BADFACTOR_ERR;
- if( !ioFlags )
- for( i = 0; i < nEigObjs; i++ )
- if( ((uchar **) eigInput)[i] == NULL )
- return CV_NULLPTR_ERR;
- eigStep /= 4;
- avgStep /= 4;
-
- if( size.width == restStep && size.width == eigStep && size.width == avgStep )
- {
- size.width *= size.height;
- size.height = 1;
- restStep = eigStep = avgStep = size.width;
- }
-
- buf = (float *) cvAlloc( sizeof( float ) * size.width * size.height );
-
- if( buf == NULL )
- return CV_OUTOFMEM_ERR;
- b = buf;
- for( i = 0; i < size.height; i++, avg += avgStep, b += size.width )
- for( j = 0; j < size.width; j++ )
- b[j] = avg[j];
-
- if( ioFlags )
- {
- buffer = (float *) cvAlloc( sizeof( float ) * size.width * size.height );
-
- if( buffer == NULL )
- {
- cvFree( &buf );
- return CV_OUTOFMEM_ERR;
- }
- eigStep = size.width;
- }
-
- for( k = 0; k < nEigObjs; k++ )
- {
- float *e = ioFlags ? buffer : ((float **) eigInput)[k];
- float c = coeffs[k];
-
- if( ioFlags ) /* read eigen object */
- {
- CvStatus r = (CvStatus)read_callback( k, (void *) buffer, userData );
-
- if( r )
- {
- cvFree( &buf );
- cvFree( &buffer );
- return r;
- }
- }
-
- b = buf;
- for( i = 0; i < size.height; i++, e += eigStep, b += size.width )
- {
- for( j = 0; j < size.width - 3; j += 4 )
- {
- float b0 = c * e[j];
- float b1 = c * e[j + 1];
- float b2 = c * e[j + 2];
- float b3 = c * e[j + 3];
-
- b[j] += b0;
- b[j + 1] += b1;
- b[j + 2] += b2;
- b[j + 3] += b3;
- }
- for( ; j < size.width; j++ )
- b[j] += c * e[j];
- }
- }
-
- b = buf;
- for( i = 0; i < size.height; i++, avg += avgStep, b += size.width, rest += restStep )
- for( j = 0; j < size.width; j++ )
- {
- int w = cvRound( b[j] );
-
- w = !(w & ~255) ? w : w < 0 ? 0 : 255;
- rest[j] = (uchar) w;
- }
-
- cvFree( &buf );
- if( ioFlags )
- cvFree( &buffer );
- return CV_NO_ERR;
-}
-
-/*F///////////////////////////////////////////////////////////////////////////////////////
-// Name: cvCalcCovarMatrixEx
-// Purpose: The function calculates a covariance matrix for a group of input objects
-// (images, vectors, etc.).
-// Context:
-// Parameters: nObjects - number of source objects
-// input - pointer either to array of input objects
-// or to read callback function (depending on ioFlags)
-// ioFlags - input/output flags (see Notes to
-// cvCalcEigenObjects function)
-// ioBufSize - input/output buffer size
-// userData - pointer to the structure which contains all necessary
-// data for the callback functions
-// avg - averaged object
-// covarMatrix - covariance matrix (output parameter; must be allocated
-// before call)
-//
-// Notes: See Notes to cvCalcEigenObjects function
-//F*/
-
-CV_IMPL void
-cvCalcCovarMatrixEx( int nObjects, void* input, int ioFlags,
- int ioBufSize, uchar* buffer, void* userData,
- IplImage* avg, float* covarMatrix )
-{
- float *avg_data;
- int avg_step = 0;
- CvSize avg_size;
- int i;
-
- CV_FUNCNAME( "cvCalcCovarMatrixEx" );
-
- __BEGIN__;
-
- cvGetImageRawData( avg, (uchar **) & avg_data, &avg_step, &avg_size );
- if( avg->depth != IPL_DEPTH_32F )
- CV_ERROR( CV_BadDepth, cvUnsupportedFormat );
- if( avg->nChannels != 1 )
- CV_ERROR( CV_BadNumChannels, cvUnsupportedFormat );
-
- if( ioFlags == CV_EIGOBJ_NO_CALLBACK )
- {
- IplImage **images = (IplImage **) (((CvInput *) & input)->data);
- uchar **objects = (uchar **) cvAlloc( sizeof( uchar * ) * nObjects );
- int img_step = 0, old_step = 0;
- CvSize img_size = avg_size, old_size = avg_size;
-
- if( objects == NULL )
- CV_ERROR( CV_StsBadArg, "Insufficient memory" );
-
- for( i = 0; i < nObjects; i++ )
- {
- IplImage *img = images[i];
- uchar *img_data;
-
- cvGetImageRawData( img, &img_data, &img_step, &img_size );
- if( img->depth != IPL_DEPTH_8U )
- CV_ERROR( CV_BadDepth, cvUnsupportedFormat );
- if( img_size != avg_size || img_size != old_size )
- CV_ERROR( CV_StsBadArg, "Different sizes of objects" );
- if( img->nChannels != 1 )
- CV_ERROR( CV_BadNumChannels, cvUnsupportedFormat );
- if( i > 0 && img_step != old_step )
- CV_ERROR( CV_StsBadArg, "Different steps of objects" );
-
- old_step = img_step;
- old_size = img_size;
- objects[i] = img_data;
- }
-
- CV_CALL( icvCalcCovarMatrixEx_8u32fR( nObjects,
- (void*) objects,
- img_step,
- CV_EIGOBJ_NO_CALLBACK,
- 0,
- NULL,
- NULL,
- avg_data,
- avg_step,
- avg_size,
- covarMatrix ));
- cvFree( &objects );
- }
-
- else
-
- {
- CV_CALL( icvCalcCovarMatrixEx_8u32fR( nObjects,
- input,
- avg_step / 4,
- ioFlags,
- ioBufSize,
- buffer,
- userData,
- avg_data,
- avg_step,
- avg_size,
- covarMatrix ));
- }
-
- __END__;
-}
-
-/*F///////////////////////////////////////////////////////////////////////////////////////
-// Name: cvCalcEigenObjects
-// Purpose: The function calculates an orthonormal eigen basis and a mean (averaged)
-// object for a group of input objects (images, vectors, etc.).
-// Context:
-// Parameters: nObjects - number of source objects
-// input - pointer either to array of input objects
-// or to read callback function (depending on ioFlags)
-// output - pointer either to output eigen objects
-// or to write callback function (depending on ioFlags)
-// ioFlags - input/output flags (see Notes)
-// ioBufSize - input/output buffer size
-// userData - pointer to the structure which contains all necessary
-// data for the callback functions
-// calcLimit - determines the calculation finish conditions
-// avg - averaged object (has the same size as ROI)
-// eigVals - pointer to corresponding eigen values (array of <nObjects>
-// elements in descending order)
-//
-// Notes: 1. input/output data (that is, input objects and eigen ones) may either
-// be allocated in the RAM or be read from/written to the HDD (or any
-// other device) by read/write callback functions. It depends on the
-// value of ioFlags paramater, which may be the following:
-// CV_EIGOBJ_NO_CALLBACK, or 0;
-// CV_EIGOBJ_INPUT_CALLBACK;
-// CV_EIGOBJ_OUTPUT_CALLBACK;
-// CV_EIGOBJ_BOTH_CALLBACK, or
-// CV_EIGOBJ_INPUT_CALLBACK | CV_EIGOBJ_OUTPUT_CALLBACK.
-// The callback functions as well as the user data structure must be
-// developed by the user.
-//
-// 2. If ioBufSize = 0, or it's too large, the function dermines buffer size
-// itself.
-//
-// 3. Depending on calcLimit parameter, calculations are finished either if
-// eigenfaces number comes up to certain value or the relation of the
-// current eigenvalue and the largest one comes down to certain value
-// (or any of the above conditions takes place). The calcLimit->type value
-// must be CV_TERMCRIT_NUMB, CV_TERMCRIT_EPS or
-// CV_TERMCRIT_NUMB | CV_TERMCRIT_EPS. The function returns the real
-// values calcLimit->max_iter and calcLimit->epsilon.
-//
-// 4. eigVals may be equal to NULL (if you don't need eigen values in further).
-//
-//F*/
-CV_IMPL void
-cvCalcEigenObjects( int nObjects,
- void* input,
- void* output,
- int ioFlags,
- int ioBufSize,
- void* userData,
- CvTermCriteria* calcLimit,
- IplImage* avg,
- float* eigVals )
-{
- float *avg_data;
- int avg_step = 0;
- CvSize avg_size;
- int i;
- int nEigens = nObjects - 1;
-
- CV_FUNCNAME( "cvCalcEigenObjects" );
-
- __BEGIN__;
-
- cvGetImageRawData( avg, (uchar **) & avg_data, &avg_step, &avg_size );
- if( avg->depth != IPL_DEPTH_32F )
- CV_ERROR( CV_BadDepth, cvUnsupportedFormat );
- if( avg->nChannels != 1 )
- CV_ERROR( CV_BadNumChannels, cvUnsupportedFormat );
-
- if( nEigens > calcLimit->max_iter && calcLimit->type != CV_TERMCRIT_EPS )
- nEigens = calcLimit->max_iter;
-
- switch (ioFlags)
- {
- case CV_EIGOBJ_NO_CALLBACK:
- {
- IplImage **objects = (IplImage **) (((CvInput *) & input)->data);
- IplImage **eigens = (IplImage **) (((CvInput *) & output)->data);
- uchar **objs = (uchar **) cvAlloc( sizeof( uchar * ) * nObjects );
- float **eigs = (float **) cvAlloc( sizeof( float * ) * nEigens );
- int obj_step = 0, old_step = 0;
- int eig_step = 0, oldeig_step = 0;
- CvSize obj_size = avg_size, old_size = avg_size,
-
- eig_size = avg_size, oldeig_size = avg_size;
-
- if( objects == NULL || eigens == NULL )
- CV_ERROR( CV_StsBadArg, "Insufficient memory" );
-
- for( i = 0; i < nObjects; i++ )
- {
- IplImage *img = objects[i];
- uchar *obj_data;
-
- cvGetImageRawData( img, &obj_data, &obj_step, &obj_size );
- if( img->depth != IPL_DEPTH_8U )
- CV_ERROR( CV_BadDepth, cvUnsupportedFormat );
- if( obj_size != avg_size || obj_size != old_size )
- CV_ERROR( CV_StsBadArg, "Different sizes of objects" );
- if( img->nChannels != 1 )
- CV_ERROR( CV_BadNumChannels, cvUnsupportedFormat );
- if( i > 0 && obj_step != old_step )
- CV_ERROR( CV_StsBadArg, "Different steps of objects" );
-
- old_step = obj_step;
- old_size = obj_size;
- objs[i] = obj_data;
- }
- for( i = 0; i < nEigens; i++ )
- {
- IplImage *eig = eigens[i];
- float *eig_data;
-
- cvGetImageRawData( eig, (uchar **) & eig_data, &eig_step, &eig_size );
- if( eig->depth != IPL_DEPTH_32F )
- CV_ERROR( CV_BadDepth, cvUnsupportedFormat );
- if( eig_size != avg_size || eig_size != oldeig_size )
- CV_ERROR( CV_StsBadArg, "Different sizes of objects" );
- if( eig->nChannels != 1 )
- CV_ERROR( CV_BadNumChannels, cvUnsupportedFormat );
- if( i > 0 && eig_step != oldeig_step )
- CV_ERROR( CV_StsBadArg, "Different steps of objects" );
-
- oldeig_step = eig_step;
- oldeig_size = eig_size;
- eigs[i] = eig_data;
- }
- CV_CALL( icvCalcEigenObjects_8u32fR( nObjects, (void*) objs, obj_step,
- (void*) eigs, eig_step, obj_size,
- ioFlags, ioBufSize, userData,
- calcLimit, avg_data, avg_step, eigVals ));
- cvFree( &objs );
- cvFree( &eigs );
- break;
- }
-
- case CV_EIGOBJ_OUTPUT_CALLBACK:
- {
- IplImage **objects = (IplImage **) (((CvInput *) & input)->data);
- uchar **objs = (uchar **) cvAlloc( sizeof( uchar * ) * nObjects );
- int obj_step = 0, old_step = 0;
- CvSize obj_size = avg_size, old_size = avg_size;
-
- if( objects == NULL )
- CV_ERROR( CV_StsBadArg, "Insufficient memory" );
-
- for( i = 0; i < nObjects; i++ )
- {
- IplImage *img = objects[i];
- uchar *obj_data;
-
- cvGetImageRawData( img, &obj_data, &obj_step, &obj_size );
- if( img->depth != IPL_DEPTH_8U )
- CV_ERROR( CV_BadDepth, cvUnsupportedFormat );
- if( obj_size != avg_size || obj_size != old_size )
- CV_ERROR( CV_StsBadArg, "Different sizes of objects" );
- if( img->nChannels != 1 )
- CV_ERROR( CV_BadNumChannels, cvUnsupportedFormat );
- if( i > 0 && obj_step != old_step )
- CV_ERROR( CV_StsBadArg, "Different steps of objects" );
-
- old_step = obj_step;
- old_size = obj_size;
- objs[i] = obj_data;
- }
- CV_CALL( icvCalcEigenObjects_8u32fR( nObjects,
- (void*) objs,
- obj_step,
- output,
- avg_step,
- obj_size,
- ioFlags,
- ioBufSize,
- userData,
- calcLimit,
- avg_data,
- avg_step,
- eigVals ));
- cvFree( &objs );
- break;
- }
-
- case CV_EIGOBJ_INPUT_CALLBACK:
- {
- IplImage **eigens = (IplImage **) (((CvInput *) & output)->data);
- float **eigs = (float**) cvAlloc( sizeof( float* ) * nEigens );
- int eig_step = 0, oldeig_step = 0;
- CvSize eig_size = avg_size, oldeig_size = avg_size;
-
- if( eigens == NULL )
- CV_ERROR( CV_StsBadArg, "Insufficient memory" );
-
- for( i = 0; i < nEigens; i++ )
- {
- IplImage *eig = eigens[i];
- float *eig_data;
-
- cvGetImageRawData( eig, (uchar **) & eig_data, &eig_step, &eig_size );
- if( eig->depth != IPL_DEPTH_32F )
- CV_ERROR( CV_BadDepth, cvUnsupportedFormat );
- if( eig_size != avg_size || eig_size != oldeig_size )
- CV_ERROR( CV_StsBadArg, "Different sizes of objects" );
- if( eig->nChannels != 1 )
- CV_ERROR( CV_BadNumChannels, cvUnsupportedFormat );
- if( i > 0 && eig_step != oldeig_step )
- CV_ERROR( CV_StsBadArg, "Different steps of objects" );
-
- oldeig_step = eig_step;
- oldeig_size = eig_size;
- eigs[i] = eig_data;
- }
- CV_CALL( icvCalcEigenObjects_8u32fR( nObjects,
- input,
- avg_step / 4,
- (void*) eigs,
- eig_step,
- eig_size,
- ioFlags,
- ioBufSize,
- userData,
- calcLimit,
- avg_data,
- avg_step,
- eigVals ));
- cvFree( &eigs );
- break;
- }
- case CV_EIGOBJ_INPUT_CALLBACK | CV_EIGOBJ_OUTPUT_CALLBACK:
-
- CV_CALL( icvCalcEigenObjects_8u32fR( nObjects,
- input,
- avg_step / 4,
- output,
- avg_step,
- avg_size,
- ioFlags,
- ioBufSize,
- userData,
- calcLimit,
- avg_data,
- avg_step,
- eigVals ));
- break;
-
- default:
- CV_ERROR( CV_StsBadArg, "Unsupported i/o flag" );
- }
-
- __END__;
-}
-
-/*--------------------------------------------------------------------------------------*/
-/*F///////////////////////////////////////////////////////////////////////////////////////
-// Name: cvCalcDecompCoeff
-// Purpose: The function calculates one decomposition coefficient of input object
-// using previously calculated eigen object and the mean (averaged) object
-// Context:
-// Parameters: obj - input object
-// eigObj - eigen object
-// avg - averaged object
-//
-// Returns: decomposition coefficient value or large negative value (if error)
-//
-// Notes:
-//F*/
-
-CV_IMPL double
-cvCalcDecompCoeff( IplImage * obj, IplImage * eigObj, IplImage * avg )
-{
- double coeff = DBL_MAX;
-
- uchar *obj_data;
- float *eig_data;
- float *avg_data;
- int obj_step = 0, eig_step = 0, avg_step = 0;
- CvSize obj_size, eig_size, avg_size;
-
- CV_FUNCNAME( "cvCalcDecompCoeff" );
-
- __BEGIN__;
-
- cvGetImageRawData( obj, &obj_data, &obj_step, &obj_size );
- if( obj->depth != IPL_DEPTH_8U )
- CV_ERROR( CV_BadDepth, cvUnsupportedFormat );
- if( obj->nChannels != 1 )
- CV_ERROR( CV_BadNumChannels, cvUnsupportedFormat );
-
- cvGetImageRawData( eigObj, (uchar **) & eig_data, &eig_step, &eig_size );
- if( eigObj->depth != IPL_DEPTH_32F )
- CV_ERROR( CV_BadDepth, cvUnsupportedFormat );
- if( eigObj->nChannels != 1 )
- CV_ERROR( CV_BadNumChannels, cvUnsupportedFormat );
-
- cvGetImageRawData( avg, (uchar **) & avg_data, &avg_step, &avg_size );
- if( avg->depth != IPL_DEPTH_32F )
- CV_ERROR( CV_BadDepth, cvUnsupportedFormat );
- if( avg->nChannels != 1 )
- CV_ERROR( CV_BadNumChannels, cvUnsupportedFormat );
-
- if( obj_size != eig_size || obj_size != avg_size )
- CV_ERROR( CV_StsBadArg, "different sizes of images" );
-
- coeff = icvCalcDecompCoeff_8u32fR( obj_data, obj_step,
- eig_data, eig_step,
- avg_data, avg_step, obj_size );
-
- __END__;
-
- return coeff;
-}
-
-/*--------------------------------------------------------------------------------------*/
-/*F///////////////////////////////////////////////////////////////////////////////////////
-// Names: cvEigenDecomposite
-// Purpose: The function calculates all decomposition coefficients for input object
-// using previously calculated eigen objects basis and the mean (averaged)
-// object
-//
-// Parameters: obj - input object
-// nEigObjs - number of eigen objects
-// eigInput - pointer either to array of pointers to eigen objects
-// or to read callback function (depending on ioFlags)
-// ioFlags - input/output flags
-// userData - pointer to the structure which contains all necessary
-// data for the callback function
-// avg - averaged object
-// coeffs - calculated coefficients (output data)
-//
-// Notes: see notes for cvCalcEigenObjects function
-//F*/
-
-CV_IMPL void
-cvEigenDecomposite( IplImage* obj,
- int nEigObjs,
- void* eigInput,
- int ioFlags,
- void* userData,
- IplImage* avg,
- float* coeffs )
-{
- float *avg_data;
- uchar *obj_data;
- int avg_step = 0, obj_step = 0;
- CvSize avg_size, obj_size;
- int i;
-
- CV_FUNCNAME( "cvEigenDecomposite" );
-
- __BEGIN__;
-
- cvGetImageRawData( avg, (uchar **) & avg_data, &avg_step, &avg_size );
- if( avg->depth != IPL_DEPTH_32F )
- CV_ERROR( CV_BadDepth, cvUnsupportedFormat );
- if( avg->nChannels != 1 )
- CV_ERROR( CV_BadNumChannels, cvUnsupportedFormat );
-
- cvGetImageRawData( obj, &obj_data, &obj_step, &obj_size );
- if( obj->depth != IPL_DEPTH_8U )
- CV_ERROR( CV_BadDepth, cvUnsupportedFormat );
- if( obj->nChannels != 1 )
- CV_ERROR( CV_BadNumChannels, cvUnsupportedFormat );
-
- if( obj_size != avg_size )
- CV_ERROR( CV_StsBadArg, "Different sizes of objects" );
-
- if( ioFlags == CV_EIGOBJ_NO_CALLBACK )
- {
- IplImage **eigens = (IplImage **) (((CvInput *) & eigInput)->data);
- float **eigs = (float **) cvAlloc( sizeof( float * ) * nEigObjs );
- int eig_step = 0, old_step = 0;
- CvSize eig_size = avg_size, old_size = avg_size;
-
- if( eigs == NULL )
- CV_ERROR( CV_StsBadArg, "Insufficient memory" );
-
- for( i = 0; i < nEigObjs; i++ )
- {
- IplImage *eig = eigens[i];
- float *eig_data;
-
- cvGetImageRawData( eig, (uchar **) & eig_data, &eig_step, &eig_size );
- if( eig->depth != IPL_DEPTH_32F )
- CV_ERROR( CV_BadDepth, cvUnsupportedFormat );
- if( eig_size != avg_size || eig_size != old_size )
- CV_ERROR( CV_StsBadArg, "Different sizes of objects" );
- if( eig->nChannels != 1 )
- CV_ERROR( CV_BadNumChannels, cvUnsupportedFormat );
- if( i > 0 && eig_step != old_step )
- CV_ERROR( CV_StsBadArg, "Different steps of objects" );
-
- old_step = eig_step;
- old_size = eig_size;
- eigs[i] = eig_data;
- }
-
- CV_CALL( icvEigenDecomposite_8u32fR( obj_data,
- obj_step,
- nEigObjs,
- (void*) eigs,
- eig_step,
- ioFlags,
- userData,
- avg_data,
- avg_step,
- obj_size,
- coeffs ));
- cvFree( &eigs );
- }
-
- else
-
- {
- CV_CALL( icvEigenDecomposite_8u32fR( obj_data,
- obj_step,
- nEigObjs,
- eigInput,
- avg_step,
- ioFlags,
- userData,
- avg_data,
- avg_step,
- obj_size,
- coeffs ));
- }
-
- __END__;
-}
-
-/*--------------------------------------------------------------------------------------*/
-/*F///////////////////////////////////////////////////////////////////////////////////////
-// Name: cvEigenProjection
-// Purpose: The function calculates object projection to the eigen sub-space (restores
-// an object) using previously calculated eigen objects basis, mean (averaged)
-// object and decomposition coefficients of the restored object
-// Context:
-// Parameters: nEigObjs - number of eigen objects
-// eigInput - pointer either to array of pointers to eigen objects
-// or to read callback function (depending on ioFlags)
-// ioFlags - input/output flags
-// userData - pointer to the structure which contains all necessary
-// data for the callback function
-// coeffs - array of decomposition coefficients
-// avg - averaged object
-// proj - object projection (output data)
-//
-// Notes: see notes for cvCalcEigenObjects function
-//F*/
-
-CV_IMPL void
-cvEigenProjection( void* eigInput,
- int nEigObjs,
- int ioFlags,
- void* userData,
- float* coeffs,
- IplImage* avg,
- IplImage* proj )
-{
- float *avg_data;
- uchar *proj_data;
- int avg_step = 0, proj_step = 0;
- CvSize avg_size, proj_size;
- int i;
-
- CV_FUNCNAME( "cvEigenProjection" );
-
- __BEGIN__;
-
- cvGetImageRawData( avg, (uchar **) & avg_data, &avg_step, &avg_size );
- if( avg->depth != IPL_DEPTH_32F )
- CV_ERROR( CV_BadDepth, cvUnsupportedFormat );
- if( avg->nChannels != 1 )
- CV_ERROR( CV_BadNumChannels, cvUnsupportedFormat );
-
- cvGetImageRawData( proj, &proj_data, &proj_step, &proj_size );
- if( proj->depth != IPL_DEPTH_8U )
- CV_ERROR( CV_BadDepth, cvUnsupportedFormat );
- if( proj->nChannels != 1 )
- CV_ERROR( CV_BadNumChannels, cvUnsupportedFormat );
-
- if( proj_size != avg_size )
- CV_ERROR( CV_StsBadArg, "Different sizes of projects" );
-
- if( ioFlags == CV_EIGOBJ_NO_CALLBACK )
- {
- IplImage **eigens = (IplImage**) (((CvInput *) & eigInput)->data);
- float **eigs = (float**) cvAlloc( sizeof( float * ) * nEigObjs );
- int eig_step = 0, old_step = 0;
- CvSize eig_size = avg_size, old_size = avg_size;
-
- if( eigs == NULL )
- CV_ERROR( CV_StsBadArg, "Insufficient memory" );
-
- for( i = 0; i < nEigObjs; i++ )
- {
- IplImage *eig = eigens[i];
- float *eig_data;
-
- cvGetImageRawData( eig, (uchar **) & eig_data, &eig_step, &eig_size );
- if( eig->depth != IPL_DEPTH_32F )
- CV_ERROR( CV_BadDepth, cvUnsupportedFormat );
- if( eig_size != avg_size || eig_size != old_size )
- CV_ERROR( CV_StsBadArg, "Different sizes of objects" );
- if( eig->nChannels != 1 )
- CV_ERROR( CV_BadNumChannels, cvUnsupportedFormat );
- if( i > 0 && eig_step != old_step )
- CV_ERROR( CV_StsBadArg, "Different steps of objects" );
-
- old_step = eig_step;
- old_size = eig_size;
- eigs[i] = eig_data;
- }
-
- CV_CALL( icvEigenProjection_8u32fR( nEigObjs,
- (void*) eigs,
- eig_step,
- ioFlags,
- userData,
- coeffs,
- avg_data,
- avg_step,
- proj_data,
- proj_step,
- avg_size ));
- cvFree( &eigs );
- }
-
- else
-
- {
- CV_CALL( icvEigenProjection_8u32fR( nEigObjs,
- eigInput,
- avg_step,
- ioFlags,
- userData,
- coeffs,
- avg_data,
- avg_step,
- proj_data,
- proj_step,
- avg_size ));
- }
-
- __END__;
-}
-
-/* End of file. */
projects / opencv / blobdiff