cv/include/cvtypes.h - platform/external/opencv - Git at Google

 /*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*/

 #ifndef _CVTYPES_H_
 #define _CVTYPES_H_

 #ifndef SKIP_INCLUDES
   #include <assert.h>
   #include <stdlib.h>
 #endif

 /* spatial and central moments */
 typedef struct CvMoments
 {
     double  m00, m10, m01, m20, m11, m02, m30, m21, m12, m03; /* spatial moments */
     double  mu20, mu11, mu02, mu30, mu21, mu12, mu03; /* central moments */
     double  inv_sqrt_m00; /* m00 != 0 ? 1/sqrt(m00) : 0 */
 }
 CvMoments;

 /* Hu invariants */
 typedef struct CvHuMoments
 {
     double hu1, hu2, hu3, hu4, hu5, hu6, hu7; /* Hu invariants */
 }
 CvHuMoments;

 /**************************** Connected Component  **************************************/

 typedef struct CvConnectedComp
 {
     double area;    /* area of the connected component  */
     CvScalar value; /* average color of the connected component */
     CvRect rect;    /* ROI of the component  */
     CvSeq* contour; /* optional component boundary
                       (the contour might have child contours corresponding to the holes)*/
 }
 CvConnectedComp;

 /*
 Internal structure that is used for sequental retrieving contours from the image.
 It supports both hierarchical and plane variants of Suzuki algorithm.
 */
 typedef struct _CvContourScanner* CvContourScanner;

 /* contour retrieval mode */
 #define CV_RETR_EXTERNAL 0
 #define CV_RETR_LIST     1
 #define CV_RETR_CCOMP    2
 #define CV_RETR_TREE     3

 /* contour approximation method */
 #define CV_CHAIN_CODE               0
 #define CV_CHAIN_APPROX_NONE        1
 #define CV_CHAIN_APPROX_SIMPLE      2
 #define CV_CHAIN_APPROX_TC89_L1     3
 #define CV_CHAIN_APPROX_TC89_KCOS   4
 #define CV_LINK_RUNS                5

 /* Freeman chain reader state */
 typedef struct CvChainPtReader
 {
     CV_SEQ_READER_FIELDS()
     char      code;
     CvPoint   pt;
     schar     deltas[8][2];
 }
 CvChainPtReader;

 /* initializes 8-element array for fast access to 3x3 neighborhood of a pixel */
 #define  CV_INIT_3X3_DELTAS( deltas, step, nch )            \
     ((deltas)[0] =  (nch),  (deltas)[1] = -(step) + (nch),  \
      (deltas)[2] = -(step), (deltas)[3] = -(step) - (nch),  \
      (deltas)[4] = -(nch),  (deltas)[5] =  (step) - (nch),  \
      (deltas)[6] =  (step), (deltas)[7] =  (step) + (nch))

 /* Contour tree header */
 typedef struct CvContourTree
 {
     CV_SEQUENCE_FIELDS()
     CvPoint p1;            /* the first point of the binary tree root segment */
     CvPoint p2;            /* the last point of the binary tree root segment */
 }
 CvContourTree;

 /* Finds a sequence of convexity defects of given contour */
 typedef struct CvConvexityDefect
 {
     CvPoint* start; /* point of the contour where the defect begins */
     CvPoint* end; /* point of the contour where the defect ends */
     CvPoint* depth_point; /* the farthest from the convex hull point within the defect */
     float depth; /* distance between the farthest point and the convex hull */
 }
 CvConvexityDefect;

 /************ Data structures and related enumerations for Planar Subdivisions ************/

 typedef size_t CvSubdiv2DEdge;

 #define CV_QUADEDGE2D_FIELDS()     \
     int flags;                     \
     struct CvSubdiv2DPoint* pt[4]; \
     CvSubdiv2DEdge  next[4];

 #define CV_SUBDIV2D_POINT_FIELDS()\
     int            flags;      \
     CvSubdiv2DEdge first;      \
     CvPoint2D32f   pt;

 #define CV_SUBDIV2D_VIRTUAL_POINT_FLAG (1 << 30)

 typedef struct CvQuadEdge2D
 {
     CV_QUADEDGE2D_FIELDS()
 }
 CvQuadEdge2D;

 typedef struct CvSubdiv2DPoint
 {
     CV_SUBDIV2D_POINT_FIELDS()
 }
 CvSubdiv2DPoint;

 #define CV_SUBDIV2D_FIELDS()    \
     CV_GRAPH_FIELDS()           \
     int  quad_edges;            \
     int  is_geometry_valid;     \
     CvSubdiv2DEdge recent_edge; \
     CvPoint2D32f  topleft;      \
     CvPoint2D32f  bottomright;

 typedef struct CvSubdiv2D
 {
     CV_SUBDIV2D_FIELDS()
 }
 CvSubdiv2D;


 typedef enum CvSubdiv2DPointLocation
 {
     CV_PTLOC_ERROR = -2,
     CV_PTLOC_OUTSIDE_RECT = -1,
     CV_PTLOC_INSIDE = 0,
     CV_PTLOC_VERTEX = 1,
     CV_PTLOC_ON_EDGE = 2
 }
 CvSubdiv2DPointLocation;

 typedef enum CvNextEdgeType
 {
     CV_NEXT_AROUND_ORG   = 0x00,
     CV_NEXT_AROUND_DST   = 0x22,
     CV_PREV_AROUND_ORG   = 0x11,
     CV_PREV_AROUND_DST   = 0x33,
     CV_NEXT_AROUND_LEFT  = 0x13,
     CV_NEXT_AROUND_RIGHT = 0x31,
     CV_PREV_AROUND_LEFT  = 0x20,
     CV_PREV_AROUND_RIGHT = 0x02
 }
 CvNextEdgeType;

 /* get the next edge with the same origin point (counterwise) */
 #define  CV_SUBDIV2D_NEXT_EDGE( edge )  (((CvQuadEdge2D*)((edge) & ~3))->next[(edge)&3])


 /* Defines for Distance Transform */
 #define CV_DIST_USER    -1  /* User defined distance */
 #define CV_DIST_L1      1   /* distance = |x1-x2| + |y1-y2| */
 #define CV_DIST_L2      2   /* the simple euclidean distance */
 #define CV_DIST_C       3   /* distance = max(|x1-x2|,|y1-y2|) */
 #define CV_DIST_L12     4   /* L1-L2 metric: distance = 2(sqrt(1+x*x/2) - 1)) */
 #define CV_DIST_FAIR    5   /* distance = c^2(|x|/c-log(1+|x|/c)), c = 1.3998 */
 #define CV_DIST_WELSCH  6   /* distance = c^2/2(1-exp(-(x/c)^2)), c = 2.9846 */
 #define CV_DIST_HUBER   7   /* distance = |x|<c ? x^2/2 : c(|x|-c/2), c=1.345 */


 /* Filters used in pyramid decomposition */
 typedef enum CvFilter
 {
     CV_GAUSSIAN_5x5 = 7
 }
 CvFilter;

 /****************************************************************************************/
 /*                                    Older definitions                                 */
 /****************************************************************************************/

 typedef float*   CvVect32f;
 typedef float*   CvMatr32f;
 typedef double*  CvVect64d;
 typedef double*  CvMatr64d;

 typedef struct CvMatrix3
 {
     float m[3][3];
 }
 CvMatrix3;


 #ifdef __cplusplus
 extern "C" {
 #endif

 typedef float (CV_CDECL * CvDistanceFunction)( const float* a, const float* b, void* user_param );

 #ifdef __cplusplus
 }
 #endif

 typedef struct CvConDensation
 {
     int MP;
     int DP;
     float* DynamMatr;       /* Matrix of the linear Dynamics system  */
     float* State;           /* Vector of State                       */
     int SamplesNum;         /* Number of the Samples                 */
     float** flSamples;      /* arr of the Sample Vectors             */
     float** flNewSamples;   /* temporary array of the Sample Vectors */
     float* flConfidence;    /* Confidence for each Sample            */
     float* flCumulative;    /* Cumulative confidence                 */
     float* Temp;            /* Temporary vector                      */
     float* RandomSample;    /* RandomVector to update sample set     */
     struct CvRandState* RandS; /* Array of structures to generate random vectors */
 }
 CvConDensation;

 /*
 standard Kalman filter (in G. Welch' and G. Bishop's notation):

   x(k)=A*x(k-1)+B*u(k)+w(k)  p(w)~N(0,Q)
   z(k)=H*x(k)+v(k),   p(v)~N(0,R)
 */
 typedef struct CvKalman
 {
     int MP;                     /* number of measurement vector dimensions */
     int DP;                     /* number of state vector dimensions */
     int CP;                     /* number of control vector dimensions */

     /* backward compatibility fields */
 #if 1
     float* PosterState;         /* =state_pre->data.fl */
     float* PriorState;          /* =state_post->data.fl */
     float* DynamMatr;           /* =transition_matrix->data.fl */
     float* MeasurementMatr;     /* =measurement_matrix->data.fl */
     float* MNCovariance;        /* =measurement_noise_cov->data.fl */
     float* PNCovariance;        /* =process_noise_cov->data.fl */
     float* KalmGainMatr;        /* =gain->data.fl */
     float* PriorErrorCovariance;/* =error_cov_pre->data.fl */
     float* PosterErrorCovariance;/* =error_cov_post->data.fl */
     float* Temp1;               /* temp1->data.fl */
     float* Temp2;               /* temp2->data.fl */
 #endif

     CvMat* state_pre;           /* predicted state (x'(k)):
                                     x(k)=A*x(k-1)+B*u(k) */
     CvMat* state_post;          /* corrected state (x(k)):
                                     x(k)=x'(k)+K(k)*(z(k)-H*x'(k)) */
     CvMat* transition_matrix;   /* state transition matrix (A) */
     CvMat* control_matrix;      /* control matrix (B)
                                    (it is not used if there is no control)*/
     CvMat* measurement_matrix;  /* measurement matrix (H) */
     CvMat* process_noise_cov;   /* process noise covariance matrix (Q) */
     CvMat* measurement_noise_cov; /* measurement noise covariance matrix (R) */
     CvMat* error_cov_pre;       /* priori error estimate covariance matrix (P'(k)):
                                     P'(k)=A*P(k-1)*At + Q)*/
     CvMat* gain;                /* Kalman gain matrix (K(k)):
                                     K(k)=P'(k)*Ht*inv(H*P'(k)*Ht+R)*/
     CvMat* error_cov_post;      /* posteriori error estimate covariance matrix (P(k)):
                                     P(k)=(I-K(k)*H)*P'(k) */
     CvMat* temp1;               /* temporary matrices */
     CvMat* temp2;
     CvMat* temp3;
     CvMat* temp4;
     CvMat* temp5;
 }
 CvKalman;


 /*********************** Haar-like Object Detection structures **************************/
 #define CV_HAAR_MAGIC_VAL    0x42500000
 #define CV_TYPE_NAME_HAAR    "opencv-haar-classifier"

 #define CV_IS_HAAR_CLASSIFIER( haar )                                                    \
     ((haar) != NULL &&                                                                   \
     (((const CvHaarClassifierCascade*)(haar))->flags & CV_MAGIC_MASK)==CV_HAAR_MAGIC_VAL)

 #define CV_HAAR_FEATURE_MAX  3

 typedef struct CvHaarFeature
 {
     int  tilted;
     struct
     {
         CvRect r;
         float weight;
     } rect[CV_HAAR_FEATURE_MAX];
 }
 CvHaarFeature;

 typedef struct CvHaarClassifier
 {
     int count;
     CvHaarFeature* haar_feature;
     float* threshold;
     int* left;
     int* right;
     float* alpha;
 }
 CvHaarClassifier;

 typedef struct CvHaarStageClassifier
 {
     int  count;
     float threshold;
     CvHaarClassifier* classifier;

     int next;
     int child;
     int parent;
 }
 CvHaarStageClassifier;

 typedef struct CvHidHaarClassifierCascade CvHidHaarClassifierCascade;

 typedef struct CvHaarClassifierCascade
 {
     int  flags;
     int  count;
     CvSize orig_window_size;
     CvSize real_window_size;
     double scale;
     CvHaarStageClassifier* stage_classifier;
     CvHidHaarClassifierCascade* hid_cascade;
 }
 CvHaarClassifierCascade;

 typedef struct CvAvgComp
 {
     CvRect rect;
     int neighbors;
 }
 CvAvgComp;

 struct CvFeatureTree;

 #endif /*_CVTYPES_H_*/

 /* End of file. */
	/*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*/

	#ifndef _CVTYPES_H_
	#define _CVTYPES_H_

	#ifndef SKIP_INCLUDES
	#include <assert.h>
	#include <stdlib.h>
	#endif

	/* spatial and central moments */
	typedef struct CvMoments
	{
	double m00, m10, m01, m20, m11, m02, m30, m21, m12, m03; /* spatial moments */
	double mu20, mu11, mu02, mu30, mu21, mu12, mu03; /* central moments */
	double inv_sqrt_m00; /* m00 != 0 ? 1/sqrt(m00) : 0 */
	}
	CvMoments;

	/* Hu invariants */
	typedef struct CvHuMoments
	{
	double hu1, hu2, hu3, hu4, hu5, hu6, hu7; /* Hu invariants */
	}
	CvHuMoments;

	/************************** Connected Component ************************************/

	typedef struct CvConnectedComp
	{
	double area; /* area of the connected component */
	CvScalar value; /* average color of the connected component */
	CvRect rect; /* ROI of the component */
	CvSeq* contour; /* optional component boundary
	(the contour might have child contours corresponding to the holes)*/
	}
	CvConnectedComp;

	/*
	Internal structure that is used for sequental retrieving contours from the image.
	It supports both hierarchical and plane variants of Suzuki algorithm.
	*/
	typedef struct _CvContourScanner* CvContourScanner;

	/* contour retrieval mode */
	#define CV_RETR_EXTERNAL 0
	#define CV_RETR_LIST 1
	#define CV_RETR_CCOMP 2
	#define CV_RETR_TREE 3

	/* contour approximation method */
	#define CV_CHAIN_CODE 0
	#define CV_CHAIN_APPROX_NONE 1
	#define CV_CHAIN_APPROX_SIMPLE 2
	#define CV_CHAIN_APPROX_TC89_L1 3
	#define CV_CHAIN_APPROX_TC89_KCOS 4
	#define CV_LINK_RUNS 5

	/* Freeman chain reader state */
	typedef struct CvChainPtReader
	{
	CV_SEQ_READER_FIELDS()
	char code;
	CvPoint pt;
	schar deltas[8][2];
	}
	CvChainPtReader;

	/* initializes 8-element array for fast access to 3x3 neighborhood of a pixel */
	#define CV_INIT_3X3_DELTAS( deltas, step, nch ) \
	((deltas)[0] = (nch), (deltas)[1] = -(step) + (nch), \
	(deltas)[2] = -(step), (deltas)[3] = -(step) - (nch), \
	(deltas)[4] = -(nch), (deltas)[5] = (step) - (nch), \
	(deltas)[6] = (step), (deltas)[7] = (step) + (nch))

	/* Contour tree header */
	typedef struct CvContourTree
	{
	CV_SEQUENCE_FIELDS()
	CvPoint p1; /* the first point of the binary tree root segment */
	CvPoint p2; /* the last point of the binary tree root segment */
	}
	CvContourTree;

	/* Finds a sequence of convexity defects of given contour */
	typedef struct CvConvexityDefect
	{
	CvPoint* start; /* point of the contour where the defect begins */
	CvPoint* end; /* point of the contour where the defect ends */
	CvPoint* depth_point; /* the farthest from the convex hull point within the defect */
	float depth; /* distance between the farthest point and the convex hull */
	}
	CvConvexityDefect;

	/********** Data structures and related enumerations for Planar Subdivisions **********/

	typedef size_t CvSubdiv2DEdge;

	#define CV_QUADEDGE2D_FIELDS() \
	int flags; \
	struct CvSubdiv2DPoint* pt[4]; \
	CvSubdiv2DEdge next[4];

	#define CV_SUBDIV2D_POINT_FIELDS()\
	int flags; \
	CvSubdiv2DEdge first; \
	CvPoint2D32f pt;

	#define CV_SUBDIV2D_VIRTUAL_POINT_FLAG (1 << 30)

	typedef struct CvQuadEdge2D
	{
	CV_QUADEDGE2D_FIELDS()
	}
	CvQuadEdge2D;

	typedef struct CvSubdiv2DPoint
	{
	CV_SUBDIV2D_POINT_FIELDS()
	}
	CvSubdiv2DPoint;

	#define CV_SUBDIV2D_FIELDS() \
	CV_GRAPH_FIELDS() \
	int quad_edges; \
	int is_geometry_valid; \
	CvSubdiv2DEdge recent_edge; \
	CvPoint2D32f topleft; \
	CvPoint2D32f bottomright;

	typedef struct CvSubdiv2D
	{
	CV_SUBDIV2D_FIELDS()
	}
	CvSubdiv2D;


	typedef enum CvSubdiv2DPointLocation
	{
	CV_PTLOC_ERROR = -2,
	CV_PTLOC_OUTSIDE_RECT = -1,
	CV_PTLOC_INSIDE = 0,
	CV_PTLOC_VERTEX = 1,
	CV_PTLOC_ON_EDGE = 2
	}
	CvSubdiv2DPointLocation;

	typedef enum CvNextEdgeType
	{
	CV_NEXT_AROUND_ORG = 0x00,
	CV_NEXT_AROUND_DST = 0x22,
	CV_PREV_AROUND_ORG = 0x11,
	CV_PREV_AROUND_DST = 0x33,
	CV_NEXT_AROUND_LEFT = 0x13,
	CV_NEXT_AROUND_RIGHT = 0x31,
	CV_PREV_AROUND_LEFT = 0x20,
	CV_PREV_AROUND_RIGHT = 0x02
	}
	CvNextEdgeType;

	/* get the next edge with the same origin point (counterwise) */
	#define CV_SUBDIV2D_NEXT_EDGE( edge ) (((CvQuadEdge2D*)((edge) & ~3))->next[(edge)&3])


	/* Defines for Distance Transform */
	#define CV_DIST_USER -1 /* User defined distance */
	#define CV_DIST_L1 1 /* distance = \|x1-x2\| + \|y1-y2\| */
	#define CV_DIST_L2 2 /* the simple euclidean distance */
	#define CV_DIST_C 3 /* distance = max(\|x1-x2\|,\|y1-y2\|) */
	#define CV_DIST_L12 4 /* L1-L2 metric: distance = 2(sqrt(1+xx/2) - 1)) /
	#define CV_DIST_FAIR 5 /* distance = c^2(\|x\|/c-log(1+\|x\|/c)), c = 1.3998 */
	#define CV_DIST_WELSCH 6 /* distance = c^2/2(1-exp(-(x/c)^2)), c = 2.9846 */
	#define CV_DIST_HUBER 7 /* distance = \|x\|<c ? x^2/2 : c(\|x\|-c/2), c=1.345 */


	/* Filters used in pyramid decomposition */
	typedef enum CvFilter
	{
	CV_GAUSSIAN_5x5 = 7
	}
	CvFilter;

	/****************************************************************************************/
	/* Older definitions */
	/****************************************************************************************/

	typedef float* CvVect32f;
	typedef float* CvMatr32f;
	typedef double* CvVect64d;
	typedef double* CvMatr64d;

	typedef struct CvMatrix3
	{
	float m[3][3];
	}
	CvMatrix3;


	#ifdef __cplusplus
	extern "C" {
	#endif

	typedef float (CV_CDECL * CvDistanceFunction)( const float* a, const float* b, void* user_param );

	#ifdef __cplusplus
	}
	#endif

	typedef struct CvConDensation
	{
	int MP;
	int DP;
	float* DynamMatr; /* Matrix of the linear Dynamics system */
	float* State; /* Vector of State */
	int SamplesNum; /* Number of the Samples */
	float** flSamples; /* arr of the Sample Vectors */
	float** flNewSamples; /* temporary array of the Sample Vectors */
	float* flConfidence; /* Confidence for each Sample */
	float* flCumulative; /* Cumulative confidence */
	float* Temp; /* Temporary vector */
	float* RandomSample; /* RandomVector to update sample set */
	struct CvRandState* RandS; /* Array of structures to generate random vectors */
	}
	CvConDensation;

	/*
	standard Kalman filter (in G. Welch' and G. Bishop's notation):

	x(k)=Ax(k-1)+Bu(k)+w(k) p(w)~N(0,Q)
	z(k)=H*x(k)+v(k), p(v)~N(0,R)
	*/
	typedef struct CvKalman
	{
	int MP; /* number of measurement vector dimensions */
	int DP; /* number of state vector dimensions */
	int CP; /* number of control vector dimensions */

	/* backward compatibility fields */
	#if 1
	float* PosterState; /* =state_pre->data.fl */
	float* PriorState; /* =state_post->data.fl */
	float* DynamMatr; /* =transition_matrix->data.fl */
	float* MeasurementMatr; /* =measurement_matrix->data.fl */
	float* MNCovariance; /* =measurement_noise_cov->data.fl */
	float* PNCovariance; /* =process_noise_cov->data.fl */
	float* KalmGainMatr; /* =gain->data.fl */
	float* PriorErrorCovariance;/* =error_cov_pre->data.fl */
	float* PosterErrorCovariance;/* =error_cov_post->data.fl */
	float* Temp1; /* temp1->data.fl */
	float* Temp2; /* temp2->data.fl */
	#endif

	CvMat* state_pre; /* predicted state (x'(k)):
	x(k)=Ax(k-1)+Bu(k) */
	CvMat* state_post; /* corrected state (x(k)):
	x(k)=x'(k)+K(k)(z(k)-Hx'(k)) */
	CvMat* transition_matrix; /* state transition matrix (A) */
	CvMat* control_matrix; /* control matrix (B)
	(it is not used if there is no control)*/
	CvMat* measurement_matrix; /* measurement matrix (H) */
	CvMat* process_noise_cov; /* process noise covariance matrix (Q) */
	CvMat* measurement_noise_cov; /* measurement noise covariance matrix (R) */
	CvMat* error_cov_pre; /* priori error estimate covariance matrix (P'(k)):
	P'(k)=AP(k-1)At + Q)*/
	CvMat* gain; /* Kalman gain matrix (K(k)):
	K(k)=P'(k)Htinv(HP'(k)Ht+R)*/
	CvMat* error_cov_post; /* posteriori error estimate covariance matrix (P(k)):
	P(k)=(I-K(k)H)P'(k) */
	CvMat* temp1; /* temporary matrices */
	CvMat* temp2;
	CvMat* temp3;
	CvMat* temp4;
	CvMat* temp5;
	}
	CvKalman;


	/********************* Haar-like Object Detection structures ************************/
	#define CV_HAAR_MAGIC_VAL 0x42500000
	#define CV_TYPE_NAME_HAAR "opencv-haar-classifier"

	#define CV_IS_HAAR_CLASSIFIER( haar ) \
	((haar) != NULL && \
	(((const CvHaarClassifierCascade*)(haar))->flags & CV_MAGIC_MASK)==CV_HAAR_MAGIC_VAL)

	#define CV_HAAR_FEATURE_MAX 3

	typedef struct CvHaarFeature
	{
	int tilted;
	struct
	{
	CvRect r;
	float weight;
	} rect[CV_HAAR_FEATURE_MAX];
	}
	CvHaarFeature;

	typedef struct CvHaarClassifier
	{
	int count;
	CvHaarFeature* haar_feature;
	float* threshold;
	int* left;
	int* right;
	float* alpha;
	}
	CvHaarClassifier;

	typedef struct CvHaarStageClassifier
	{
	int count;
	float threshold;
	CvHaarClassifier* classifier;

	int next;
	int child;
	int parent;
	}
	CvHaarStageClassifier;

	typedef struct CvHidHaarClassifierCascade CvHidHaarClassifierCascade;

	typedef struct CvHaarClassifierCascade
	{
	int flags;
	int count;
	CvSize orig_window_size;
	CvSize real_window_size;
	double scale;
	CvHaarStageClassifier* stage_classifier;
	CvHidHaarClassifierCascade* hid_cascade;
	}
	CvHaarClassifierCascade;

	typedef struct CvAvgComp
	{
	CvRect rect;
	int neighbors;
	}
	CvAvgComp;

	struct CvFeatureTree;

	#endif /_CVTYPES_H_/

	/* End of file. */