www.pudn.com > OpenCV-Intel.zip > cvtypes.h
/*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#include #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; char deltas[8][2]; int reserved[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| 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; #endif /*_CVTYPES_H_*/ /* End of file. */