git.maemo.org Git - opencv/blob - cv/include/cvtypes.h

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