1 /*M/////////////////////////////////////////////////////////////////////////////////////// 2 // 3 // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. 4 // 5 // By downloading, copying, installing or using the software you agree to this license. 6 // If you do not agree to this license, do not download, install, 7 // copy or use the software. 8 // 9 // 10 // Intel License Agreement 11 // For Open Source Computer Vision Library 12 // 13 // Copyright (C) 2000, Intel Corporation, all rights reserved. 14 // Third party copyrights are property of their respective owners. 15 // 16 // Redistribution and use in source and binary forms, with or without modification, 17 // are permitted provided that the following conditions are met: 18 // 19 // * Redistribution's of source code must retain the above copyright notice, 20 // this list of conditions and the following disclaimer. 21 // 22 // * Redistribution's in binary form must reproduce the above copyright notice, 23 // this list of conditions and the following disclaimer in the documentation 24 // and/or other materials provided with the distribution. 25 // 26 // * The name of Intel Corporation may not be used to endorse or promote products 27 // derived from this software without specific prior written permission. 28 // 29 // This software is provided by the copyright holders and contributors "as is" and 30 // any express or implied warranties, including, but not limited to, the implied 31 // warranties of merchantability and fitness for a particular purpose are disclaimed. 32 // In no event shall the Intel Corporation or contributors be liable for any direct, 33 // indirect, incidental, special, exemplary, or consequential damages 34 // (including, but not limited to, procurement of substitute goods or services; 35 // loss of use, data, or profits; or business interruption) however caused 36 // and on any theory of liability, whether in contract, strict liability, 37 // or tort (including negligence or otherwise) arising in any way out of 38 // the use of this software, even if advised of the possibility of such damage. 39 // 40 //M*/ 41 42 #ifndef _CVTYPES_H_ 43 #define _CVTYPES_H_ 44 45 #ifndef SKIP_INCLUDES 46 #include <assert.h> 47 #include <stdlib.h> 48 #endif 49 50 /* spatial and central moments */ 51 typedef struct CvMoments 52 { 53 double m00, m10, m01, m20, m11, m02, m30, m21, m12, m03; /* spatial moments */ 54 double mu20, mu11, mu02, mu30, mu21, mu12, mu03; /* central moments */ 55 double inv_sqrt_m00; /* m00 != 0 ? 1/sqrt(m00) : 0 */ 56 } 57 CvMoments; 58 59 /* Hu invariants */ 60 typedef struct CvHuMoments 61 { 62 double hu1, hu2, hu3, hu4, hu5, hu6, hu7; /* Hu invariants */ 63 } 64 CvHuMoments; 65 66 /**************************** Connected Component **************************************/ 67 68 typedef struct CvConnectedComp 69 { 70 double area; /* area of the connected component */ 71 CvScalar value; /* average color of the connected component */ 72 CvRect rect; /* ROI of the component */ 73 CvSeq* contour; /* optional component boundary 74 (the contour might have child contours corresponding to the holes)*/ 75 } 76 CvConnectedComp; 77 78 /* 79 Internal structure that is used for sequental retrieving contours from the image. 80 It supports both hierarchical and plane variants of Suzuki algorithm. 81 */ 82 typedef struct _CvContourScanner* CvContourScanner; 83 84 /* contour retrieval mode */ 85 #define CV_RETR_EXTERNAL 0 86 #define CV_RETR_LIST 1 87 #define CV_RETR_CCOMP 2 88 #define CV_RETR_TREE 3 89 90 /* contour approximation method */ 91 #define CV_CHAIN_CODE 0 92 #define CV_CHAIN_APPROX_NONE 1 93 #define CV_CHAIN_APPROX_SIMPLE 2 94 #define CV_CHAIN_APPROX_TC89_L1 3 95 #define CV_CHAIN_APPROX_TC89_KCOS 4 96 #define CV_LINK_RUNS 5 97 98 /* Freeman chain reader state */ 99 typedef struct CvChainPtReader 100 { 101 CV_SEQ_READER_FIELDS() 102 char code; 103 CvPoint pt; 104 schar deltas[8][2]; 105 } 106 CvChainPtReader; 107 108 /* initializes 8-element array for fast access to 3x3 neighborhood of a pixel */ 109 #define CV_INIT_3X3_DELTAS( deltas, step, nch ) \ 110 ((deltas)[0] = (nch), (deltas)[1] = -(step) + (nch), \ 111 (deltas)[2] = -(step), (deltas)[3] = -(step) - (nch), \ 112 (deltas)[4] = -(nch), (deltas)[5] = (step) - (nch), \ 113 (deltas)[6] = (step), (deltas)[7] = (step) + (nch)) 114 115 /* Contour tree header */ 116 typedef struct CvContourTree 117 { 118 CV_SEQUENCE_FIELDS() 119 CvPoint p1; /* the first point of the binary tree root segment */ 120 CvPoint p2; /* the last point of the binary tree root segment */ 121 } 122 CvContourTree; 123 124 /* Finds a sequence of convexity defects of given contour */ 125 typedef struct CvConvexityDefect 126 { 127 CvPoint* start; /* point of the contour where the defect begins */ 128 CvPoint* end; /* point of the contour where the defect ends */ 129 CvPoint* depth_point; /* the farthest from the convex hull point within the defect */ 130 float depth; /* distance between the farthest point and the convex hull */ 131 } 132 CvConvexityDefect; 133 134 /************ Data structures and related enumerations for Planar Subdivisions ************/ 135 136 typedef size_t CvSubdiv2DEdge; 137 138 #define CV_QUADEDGE2D_FIELDS() \ 139 int flags; \ 140 struct CvSubdiv2DPoint* pt[4]; \ 141 CvSubdiv2DEdge next[4]; 142 143 #define CV_SUBDIV2D_POINT_FIELDS()\ 144 int flags; \ 145 CvSubdiv2DEdge first; \ 146 CvPoint2D32f pt; 147 148 #define CV_SUBDIV2D_VIRTUAL_POINT_FLAG (1 << 30) 149 150 typedef struct CvQuadEdge2D 151 { 152 CV_QUADEDGE2D_FIELDS() 153 } 154 CvQuadEdge2D; 155 156 typedef struct CvSubdiv2DPoint 157 { 158 CV_SUBDIV2D_POINT_FIELDS() 159 } 160 CvSubdiv2DPoint; 161 162 #define CV_SUBDIV2D_FIELDS() \ 163 CV_GRAPH_FIELDS() \ 164 int quad_edges; \ 165 int is_geometry_valid; \ 166 CvSubdiv2DEdge recent_edge; \ 167 CvPoint2D32f topleft; \ 168 CvPoint2D32f bottomright; 169 170 typedef struct CvSubdiv2D 171 { 172 CV_SUBDIV2D_FIELDS() 173 } 174 CvSubdiv2D; 175 176 177 typedef enum CvSubdiv2DPointLocation 178 { 179 CV_PTLOC_ERROR = -2, 180 CV_PTLOC_OUTSIDE_RECT = -1, 181 CV_PTLOC_INSIDE = 0, 182 CV_PTLOC_VERTEX = 1, 183 CV_PTLOC_ON_EDGE = 2 184 } 185 CvSubdiv2DPointLocation; 186 187 typedef enum CvNextEdgeType 188 { 189 CV_NEXT_AROUND_ORG = 0x00, 190 CV_NEXT_AROUND_DST = 0x22, 191 CV_PREV_AROUND_ORG = 0x11, 192 CV_PREV_AROUND_DST = 0x33, 193 CV_NEXT_AROUND_LEFT = 0x13, 194 CV_NEXT_AROUND_RIGHT = 0x31, 195 CV_PREV_AROUND_LEFT = 0x20, 196 CV_PREV_AROUND_RIGHT = 0x02 197 } 198 CvNextEdgeType; 199 200 /* get the next edge with the same origin point (counterwise) */ 201 #define CV_SUBDIV2D_NEXT_EDGE( edge ) (((CvQuadEdge2D*)((edge) & ~3))->next[(edge)&3]) 202 203 204 /* Defines for Distance Transform */ 205 #define CV_DIST_USER -1 /* User defined distance */ 206 #define CV_DIST_L1 1 /* distance = |x1-x2| + |y1-y2| */ 207 #define CV_DIST_L2 2 /* the simple euclidean distance */ 208 #define CV_DIST_C 3 /* distance = max(|x1-x2|,|y1-y2|) */ 209 #define CV_DIST_L12 4 /* L1-L2 metric: distance = 2(sqrt(1+x*x/2) - 1)) */ 210 #define CV_DIST_FAIR 5 /* distance = c^2(|x|/c-log(1+|x|/c)), c = 1.3998 */ 211 #define CV_DIST_WELSCH 6 /* distance = c^2/2(1-exp(-(x/c)^2)), c = 2.9846 */ 212 #define CV_DIST_HUBER 7 /* distance = |x|<c ? x^2/2 : c(|x|-c/2), c=1.345 */ 213 214 215 /* Filters used in pyramid decomposition */ 216 typedef enum CvFilter 217 { 218 CV_GAUSSIAN_5x5 = 7 219 } 220 CvFilter; 221 222 /****************************************************************************************/ 223 /* Older definitions */ 224 /****************************************************************************************/ 225 226 typedef float* CvVect32f; 227 typedef float* CvMatr32f; 228 typedef double* CvVect64d; 229 typedef double* CvMatr64d; 230 231 typedef struct CvMatrix3 232 { 233 float m[3][3]; 234 } 235 CvMatrix3; 236 237 238 #ifdef __cplusplus 239 extern "C" { 240 #endif 241 242 typedef float (CV_CDECL * CvDistanceFunction)( const float* a, const float* b, void* user_param ); 243 244 #ifdef __cplusplus 245 } 246 #endif 247 248 typedef struct CvConDensation 249 { 250 int MP; 251 int DP; 252 float* DynamMatr; /* Matrix of the linear Dynamics system */ 253 float* State; /* Vector of State */ 254 int SamplesNum; /* Number of the Samples */ 255 float** flSamples; /* arr of the Sample Vectors */ 256 float** flNewSamples; /* temporary array of the Sample Vectors */ 257 float* flConfidence; /* Confidence for each Sample */ 258 float* flCumulative; /* Cumulative confidence */ 259 float* Temp; /* Temporary vector */ 260 float* RandomSample; /* RandomVector to update sample set */ 261 struct CvRandState* RandS; /* Array of structures to generate random vectors */ 262 } 263 CvConDensation; 264 265 /* 266 standard Kalman filter (in G. Welch' and G. Bishop's notation): 267 268 x(k)=A*x(k-1)+B*u(k)+w(k) p(w)~N(0,Q) 269 z(k)=H*x(k)+v(k), p(v)~N(0,R) 270 */ 271 typedef struct CvKalman 272 { 273 int MP; /* number of measurement vector dimensions */ 274 int DP; /* number of state vector dimensions */ 275 int CP; /* number of control vector dimensions */ 276 277 /* backward compatibility fields */ 278 #if 1 279 float* PosterState; /* =state_pre->data.fl */ 280 float* PriorState; /* =state_post->data.fl */ 281 float* DynamMatr; /* =transition_matrix->data.fl */ 282 float* MeasurementMatr; /* =measurement_matrix->data.fl */ 283 float* MNCovariance; /* =measurement_noise_cov->data.fl */ 284 float* PNCovariance; /* =process_noise_cov->data.fl */ 285 float* KalmGainMatr; /* =gain->data.fl */ 286 float* PriorErrorCovariance;/* =error_cov_pre->data.fl */ 287 float* PosterErrorCovariance;/* =error_cov_post->data.fl */ 288 float* Temp1; /* temp1->data.fl */ 289 float* Temp2; /* temp2->data.fl */ 290 #endif 291 292 CvMat* state_pre; /* predicted state (x'(k)): 293 x(k)=A*x(k-1)+B*u(k) */ 294 CvMat* state_post; /* corrected state (x(k)): 295 x(k)=x'(k)+K(k)*(z(k)-H*x'(k)) */ 296 CvMat* transition_matrix; /* state transition matrix (A) */ 297 CvMat* control_matrix; /* control matrix (B) 298 (it is not used if there is no control)*/ 299 CvMat* measurement_matrix; /* measurement matrix (H) */ 300 CvMat* process_noise_cov; /* process noise covariance matrix (Q) */ 301 CvMat* measurement_noise_cov; /* measurement noise covariance matrix (R) */ 302 CvMat* error_cov_pre; /* priori error estimate covariance matrix (P'(k)): 303 P'(k)=A*P(k-1)*At + Q)*/ 304 CvMat* gain; /* Kalman gain matrix (K(k)): 305 K(k)=P'(k)*Ht*inv(H*P'(k)*Ht+R)*/ 306 CvMat* error_cov_post; /* posteriori error estimate covariance matrix (P(k)): 307 P(k)=(I-K(k)*H)*P'(k) */ 308 CvMat* temp1; /* temporary matrices */ 309 CvMat* temp2; 310 CvMat* temp3; 311 CvMat* temp4; 312 CvMat* temp5; 313 } 314 CvKalman; 315 316 317 /*********************** Haar-like Object Detection structures **************************/ 318 #define CV_HAAR_MAGIC_VAL 0x42500000 319 #define CV_TYPE_NAME_HAAR "opencv-haar-classifier" 320 321 #define CV_IS_HAAR_CLASSIFIER( haar ) \ 322 ((haar) != NULL && \ 323 (((const CvHaarClassifierCascade*)(haar))->flags & CV_MAGIC_MASK)==CV_HAAR_MAGIC_VAL) 324 325 #define CV_HAAR_FEATURE_MAX 3 326 327 typedef struct CvHaarFeature 328 { 329 int tilted; 330 struct 331 { 332 CvRect r; 333 float weight; 334 } rect[CV_HAAR_FEATURE_MAX]; 335 } 336 CvHaarFeature; 337 338 typedef struct CvHaarClassifier 339 { 340 int count; 341 CvHaarFeature* haar_feature; 342 float* threshold; 343 int* left; 344 int* right; 345 float* alpha; 346 } 347 CvHaarClassifier; 348 349 typedef struct CvHaarStageClassifier 350 { 351 int count; 352 float threshold; 353 CvHaarClassifier* classifier; 354 355 int next; 356 int child; 357 int parent; 358 } 359 CvHaarStageClassifier; 360 361 typedef struct CvHidHaarClassifierCascade CvHidHaarClassifierCascade; 362 363 typedef struct CvHaarClassifierCascade 364 { 365 int flags; 366 int count; 367 CvSize orig_window_size; 368 CvSize real_window_size; 369 double scale; 370 CvHaarStageClassifier* stage_classifier; 371 CvHidHaarClassifierCascade* hid_cascade; 372 } 373 CvHaarClassifierCascade; 374 375 typedef struct CvAvgComp 376 { 377 CvRect rect; 378 int neighbors; 379 } 380 CvAvgComp; 381 382 struct CvFeatureTree; 383 384 #endif /*_CVTYPES_H_*/ 385 386 /* End of file. */ 387