Wondercoll
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros
cvcompat.h
Go to the documentation of this file.
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 /*
43  A few macros and definitions for backward compatibility
44  with the previous versions of OpenCV. They are obsolete and
45  are likely to be removed in future. To check whether your code
46  uses any of these, define CV_NO_BACKWARD_COMPATIBILITY before
47  including cv.h.
48 */
49 
50 #ifndef _CVCOMPAT_H_
51 #define _CVCOMPAT_H_
52 
53 #include <string.h>
54 
55 #ifdef __cplusplus
56  #define CV_UNREFERENCED(arg)
57 #else
58  #define CV_UNREFERENCED(arg) arg
59 #endif
60 
61 #define CvMatType int
62 #define CvDisMaskType int
63 #define CvMatArray CvMat
64 
65 #define CvThreshType int
66 #define CvAdaptiveThreshMethod int
67 #define CvCompareMethod int
68 #define CvFontFace int
69 #define CvPolyApproxMethod int
70 #define CvContoursMatchMethod int
71 #define CvContourTreesMatchMethod int
72 #define CvCoeffType int
73 #define CvRodriguesType int
74 #define CvElementShape int
75 #define CvMorphOp int
76 #define CvTemplMatchMethod int
77 
78 #define CvPoint2D64d CvPoint2D64f
79 #define CvPoint3D64d CvPoint3D64f
80 
81 #define CV_MAT32F CV_32FC1
82 #define CV_MAT3x1_32F CV_32FC1
83 #define CV_MAT4x1_32F CV_32FC1
84 #define CV_MAT3x3_32F CV_32FC1
85 #define CV_MAT4x4_32F CV_32FC1
86 
87 #define CV_MAT64D CV_64FC1
88 #define CV_MAT3x1_64D CV_64FC1
89 #define CV_MAT4x1_64D CV_64FC1
90 #define CV_MAT3x3_64D CV_64FC1
91 #define CV_MAT4x4_64D CV_64FC1
92 
93 #define IPL_GAUSSIAN_5x5 7
94 #define CvBox2D32f CvBox2D
95 
96 /* allocation/deallocation macros */
97 #define cvCreateImageData cvCreateData
98 #define cvReleaseImageData cvReleaseData
99 #define cvSetImageData cvSetData
100 #define cvGetImageRawData cvGetRawData
101 
102 #define cvmAlloc cvCreateData
103 #define cvmFree cvReleaseData
104 #define cvmAllocArray cvCreateData
105 #define cvmFreeArray cvReleaseData
106 
107 #define cvIntegralImage cvIntegral
108 #define cvMatchContours cvMatchShapes
109 
110 CV_INLINE CvMat cvMatArray( int rows, int cols, int type,
111  int count, void* data CV_DEFAULT(0))
112 {
113  return cvMat( rows*count, cols, type, data );
114 }
115 
116 #define cvUpdateMHIByTime cvUpdateMotionHistory
117 
118 #define cvAccMask cvAcc
119 #define cvSquareAccMask cvSquareAcc
120 #define cvMultiplyAccMask cvMultiplyAcc
121 #define cvRunningAvgMask(imgY, imgU, mask, alpha) cvRunningAvg(imgY, imgU, alpha, mask)
122 
123 #define cvSetHistThresh cvSetHistBinRanges
124 #define cvCalcHistMask(img, mask, hist, doNotClear) cvCalcHist(img, hist, doNotClear, mask)
125 
126 CV_INLINE double cvMean( const CvArr* image, const CvArr* mask CV_DEFAULT(0))
127 {
128  CvScalar mean = cvAvg( image, mask );
129  return mean.val[0];
130 }
131 
132 
133 CV_INLINE double cvSumPixels( const CvArr* image )
134 {
135  CvScalar scalar = cvSum( image );
136  return scalar.val[0];
137 }
138 
139 CV_INLINE void cvMean_StdDev( const CvArr* image, double* mean, double* sdv,
140  const CvArr* mask CV_DEFAULT(0))
141 {
142  CvScalar _mean, _sdv;
143  cvAvgSdv( image, &_mean, &_sdv, mask );
144 
145  if( mean )
146  *mean = _mean.val[0];
147 
148  if( sdv )
149  *sdv = _sdv.val[0];
150 }
151 
152 
153 CV_INLINE void cvmPerspectiveProject( const CvMat* mat, const CvArr* src, CvArr* dst )
154 {
155  CvMat tsrc, tdst;
156 
157  cvReshape( src, &tsrc, 3, 0 );
158  cvReshape( dst, &tdst, 3, 0 );
159 
160  cvPerspectiveTransform( &tsrc, &tdst, mat );
161 }
162 
163 
164 CV_INLINE void cvFillImage( CvArr* mat, double color )
165 {
166  cvSet( mat, cvColorToScalar(color, cvGetElemType(mat)), 0 );
167 }
168 
169 
170 #define cvCvtPixToPlane cvSplit
171 #define cvCvtPlaneToPix cvMerge
172 
173 typedef struct CvRandState
174 {
175  CvRNG state; /* RNG state (the current seed and carry)*/
176  int disttype; /* distribution type */
177  CvScalar param[2]; /* parameters of RNG */
178 }
179 CvRandState;
180 
181 
182 /* Changes RNG range while preserving RNG state */
183 CV_INLINE void cvRandSetRange( CvRandState* state, double param1,
184  double param2, int index CV_DEFAULT(-1))
185 {
186  if( !state )
187  {
188  cvError( CV_StsNullPtr, "cvRandSetRange", "Null pointer to RNG state", "cvcompat.h", 0 );
189  return;
190  }
191 
192  if( (unsigned)(index + 1) > 4 )
193  {
194  cvError( CV_StsOutOfRange, "cvRandSetRange", "index is not in -1..3", "cvcompat.h", 0 );
195  return;
196  }
197 
198  if( index < 0 )
199  {
200  state->param[0].val[0] = state->param[0].val[1] =
201  state->param[0].val[2] = state->param[0].val[3] = param1;
202  state->param[1].val[0] = state->param[1].val[1] =
203  state->param[1].val[2] = state->param[1].val[3] = param2;
204  }
205  else
206  {
207  state->param[0].val[index] = param1;
208  state->param[1].val[index] = param2;
209  }
210 }
211 
212 
213 CV_INLINE void cvRandInit( CvRandState* state, double param1,
214  double param2, int seed,
215  int disttype CV_DEFAULT(CV_RAND_UNI))
216 {
217  if( !state )
218  {
219  cvError( CV_StsNullPtr, "cvRandInit", "Null pointer to RNG state", "cvcompat.h", 0 );
220  return;
221  }
222 
223  if( disttype != CV_RAND_UNI && disttype != CV_RAND_NORMAL )
224  {
225  cvError( CV_StsBadFlag, "cvRandInit", "Unknown distribution type", "cvcompat.h", 0 );
226  return;
227  }
228 
229  state->state = (uint64)(seed ? seed : -1);
230  state->disttype = disttype;
231  cvRandSetRange( state, param1, param2, -1 );
232 }
233 
234 
235 /* Fills array with random numbers */
236 CV_INLINE void cvRand( CvRandState* state, CvArr* arr )
237 {
238  if( !state )
239  {
240  cvError( CV_StsNullPtr, "cvRand", "Null pointer to RNG state", "cvcompat.h", 0 );
241  return;
242  }
243  cvRandArr( &state->state, arr, state->disttype, state->param[0], state->param[1] );
244 }
245 
246 #define cvRandNext( _state ) cvRandInt( &(_state)->state )
247 
248 CV_INLINE void cvbRand( CvRandState* state, float* dst, int len )
249 {
250  CvMat mat = cvMat( 1, len, CV_32F, (void*)dst );
251  cvRand( state, &mat );
252 }
253 
254 
255 CV_INLINE void cvbCartToPolar( const float* y, const float* x,
256  float* magnitude, float* angle, int len )
257 {
258  CvMat mx = cvMat( 1, len, CV_32F, (void*)x );
259  CvMat my = mx;
260  CvMat mm = mx;
261  CvMat ma = mx;
262 
263  my.data.fl = (float*)y;
264  mm.data.fl = (float*)magnitude;
265  ma.data.fl = (float*)angle;
266 
267  cvCartToPolar( &mx, &my, &mm, angle ? &ma : NULL, 1 );
268 }
269 
270 
271 CV_INLINE void cvbFastArctan( const float* y, const float* x,
272  float* angle, int len )
273 {
274  CvMat mx = cvMat( 1, len, CV_32F, (void*)x );
275  CvMat my = mx;
276  CvMat ma = mx;
277 
278  my.data.fl = (float*)y;
279  ma.data.fl = (float*)angle;
280 
281  cvCartToPolar( &mx, &my, NULL, &ma, 1 );
282 }
283 
284 
285 CV_INLINE void cvbSqrt( const float* x, float* y, int len )
286 {
287  CvMat mx = cvMat( 1, len, CV_32F, (void*)x );
288  CvMat my = mx;
289  my.data.fl = (float*)y;
290 
291  cvPow( &mx, &my, 0.5 );
292 }
293 
294 
295 CV_INLINE void cvbInvSqrt( const float* x, float* y, int len )
296 {
297  CvMat mx = cvMat( 1, len, CV_32F, (void*)x );
298  CvMat my = mx;
299  my.data.fl = (float*)y;
300 
301  cvPow( &mx, &my, -0.5 );
302 }
303 
304 
305 CV_INLINE void cvbReciprocal( const float* x, float* y, int len )
306 {
307  CvMat mx = cvMat( 1, len, CV_32F, (void*)x );
308  CvMat my = mx;
309  my.data.fl = (float*)y;
310 
311  cvPow( &mx, &my, -1 );
312 }
313 
314 
315 CV_INLINE void cvbFastExp( const float* x, double* y, int len )
316 {
317  CvMat mx = cvMat( 1, len, CV_32F, (void*)x );
318  CvMat my = cvMat( 1, len, CV_64F, y );
319  cvExp( &mx, &my );
320 }
321 
322 
323 CV_INLINE void cvbFastLog( const double* x, float* y, int len )
324 {
325  CvMat mx = cvMat( 1, len, CV_64F, (void*)x );
326  CvMat my = cvMat( 1, len, CV_32F, y );
327  cvLog( &mx, &my );
328 }
329 
330 
331 CV_INLINE CvRect cvContourBoundingRect( void* point_set, int update CV_DEFAULT(0))
332 {
333  return cvBoundingRect( point_set, update );
334 }
335 
336 
337 CV_INLINE double cvPseudoInverse( const CvArr* src, CvArr* dst )
338 {
339  return cvInvert( src, dst, CV_SVD );
340 }
341 
342 #define cvPseudoInv cvPseudoInverse
343 
344 #define cvContourMoments( contour, moments ) \
345  cvMoments( contour, moments, 0 )
346 
347 #define cvGetPtrAt cvPtr2D
348 #define cvGetAt cvGet2D
349 #define cvSetAt(arr,val,y,x) cvSet2D((arr),(y),(x),(val))
350 
351 #define cvMeanMask cvMean
352 #define cvMean_StdDevMask(img,mask,mean,sdv) cvMean_StdDev(img,mean,sdv,mask)
353 
354 #define cvNormMask(imgA,imgB,mask,normType) cvNorm(imgA,imgB,normType,mask)
355 
356 #define cvMinMaxLocMask(img, mask, min_val, max_val, min_loc, max_loc) \
357  cvMinMaxLoc(img, min_val, max_val, min_loc, max_loc, mask)
358 
359 #define cvRemoveMemoryManager cvSetMemoryManager
360 
361 #define cvmSetZero( mat ) cvSetZero( mat )
362 #define cvmSetIdentity( mat ) cvSetIdentity( mat )
363 #define cvmAdd( src1, src2, dst ) cvAdd( src1, src2, dst, 0 )
364 #define cvmSub( src1, src2, dst ) cvSub( src1, src2, dst, 0 )
365 #define cvmCopy( src, dst ) cvCopy( src, dst, 0 )
366 #define cvmMul( src1, src2, dst ) cvMatMulAdd( src1, src2, 0, dst )
367 #define cvmTranspose( src, dst ) cvT( src, dst )
368 #define cvmInvert( src, dst ) cvInv( src, dst )
369 #define cvmMahalanobis(vec1, vec2, mat) cvMahalanobis( vec1, vec2, mat )
370 #define cvmDotProduct( vec1, vec2 ) cvDotProduct( vec1, vec2 )
371 #define cvmCrossProduct(vec1, vec2,dst) cvCrossProduct( vec1, vec2, dst )
372 #define cvmTrace( mat ) (cvTrace( mat )).val[0]
373 #define cvmMulTransposed( src, dst, order ) cvMulTransposed( src, dst, order )
374 #define cvmEigenVV( mat, evec, eval, eps) cvEigenVV( mat, evec, eval, eps )
375 #define cvmDet( mat ) cvDet( mat )
376 #define cvmScale( src, dst, scale ) cvScale( src, dst, scale )
377 
378 #define cvCopyImage( src, dst ) cvCopy( src, dst, 0 )
379 #define cvReleaseMatHeader cvReleaseMat
380 
381 /* Calculates exact convex hull of 2d point set */
382 CV_INLINE void cvConvexHull( CvPoint* points, int num_points,
383  CvRect* CV_UNREFERENCED(bound_rect),
384  int orientation, int* hull, int* hullsize )
385 {
386  CvMat points1 = cvMat( 1, num_points, CV_32SC2, points );
387  CvMat hull1 = cvMat( 1, num_points, CV_32SC1, hull );
388 
389  cvConvexHull2( &points1, &hull1, orientation, 0 );
390  *hullsize = hull1.cols;
391 }
392 
393 /* Calculates exact convex hull of 2d point set stored in a sequence */
394 #define cvContourConvexHull( contour, orientation, storage ) \
395  cvConvexHull2( contour, storage, orientation )
396 
397 /* Calculates approximate convex hull of 2d point set */
398 #define cvConvexHullApprox( points, num_points, bound_rect, bandwidth, \
399  orientation, hull, hullsize ) \
400 cvConvexHull( points, num_points, bound_rect, orientation, hull, hullsize )
401 
402 /* Calculates approximate convex hull of 2d point set stored in a sequence */
403 #define cvContourConvexHullApprox( contour, bandwidth, orientation, storage ) \
404  cvConvexHull2( contour, storage, orientation )
405 
406 
407 CV_INLINE void cvMinAreaRect( CvPoint* points, int n,
408  int CV_UNREFERENCED(left), int CV_UNREFERENCED(bottom),
409  int CV_UNREFERENCED(right), int CV_UNREFERENCED(top),
410  CvPoint2D32f* anchor,
411  CvPoint2D32f* vect1,
412  CvPoint2D32f* vect2 )
413 {
414  CvMat mat = cvMat( 1, n, CV_32SC2, points );
415  CvBox2D box = cvMinAreaRect2( &mat, 0 );
416  CvPoint2D32f pt[4];
417 
418  cvBoxPoints( box, pt );
419  *anchor = pt[0];
420  vect1->x = pt[1].x - pt[0].x;
421  vect1->y = pt[1].y - pt[0].y;
422  vect2->x = pt[3].x - pt[0].x;
423  vect2->y = pt[3].y - pt[0].y;
424 
425  CV_UNREFERENCED( (left, bottom, right, top) );
426 }
427 
428 typedef int CvDisType;
429 typedef int CvChainApproxMethod;
430 typedef int CvContourRetrievalMode;
431 
432 CV_INLINE void cvFitLine3D( CvPoint3D32f* points, int count, int dist,
433  void *param, float reps, float aeps, float* line )
434 {
435  CvMat mat = cvMat( 1, count, CV_32FC3, points );
436  float _param = param != NULL ? *(float*)param : 0.f;
437  assert( dist != CV_DIST_USER );
438  cvFitLine( &mat, dist, _param, reps, aeps, line );
439 }
440 
441 /* Fits a line into set of 2d points in a robust way (M-estimator technique) */
442 CV_INLINE void cvFitLine2D( CvPoint2D32f* points, int count, int dist,
443  void *param, float reps, float aeps, float* line )
444 {
445  CvMat mat = cvMat( 1, count, CV_32FC2, points );
446  float _param = param != NULL ? *(float*)param : 0.f;
447  assert( dist != CV_DIST_USER );
448  cvFitLine( &mat, dist, _param, reps, aeps, line );
449 }
450 
451 
452 CV_INLINE void cvFitEllipse( const CvPoint2D32f* points, int count, CvBox2D* box )
453 {
454  CvMat mat = cvMat( 1, count, CV_32FC2, (void*)points );
455  *box = cvFitEllipse2( &mat );
456 }
457 
458 /* Projects 2d points to one of standard coordinate planes
459  (i.e. removes one of coordinates) */
460 CV_INLINE void cvProject3D( CvPoint3D32f* points3D, int count,
461  CvPoint2D32f* points2D,
462  int xIndx CV_DEFAULT(0),
463  int yIndx CV_DEFAULT(1))
464 {
465  CvMat src = cvMat( 1, count, CV_32FC3, points3D );
466  CvMat dst = cvMat( 1, count, CV_32FC2, points2D );
467  float m[6] = {0,0,0,0,0,0};
468  CvMat M = cvMat( 2, 3, CV_32F, m );
469 
470  assert( (unsigned)xIndx < 3 && (unsigned)yIndx < 3 );
471  m[xIndx] = m[yIndx+3] = 1.f;
472 
473  cvTransform( &src, &dst, &M, NULL );
474 }
475 
476 
477 /* Retrieves value of the particular bin
478  of x-dimensional (x=1,2,3,...) histogram */
479 #define cvQueryHistValue_1D( hist, idx0 ) \
480  ((float)cvGetReal1D( (hist)->bins, (idx0)))
481 #define cvQueryHistValue_2D( hist, idx0, idx1 ) \
482  ((float)cvGetReal2D( (hist)->bins, (idx0), (idx1)))
483 #define cvQueryHistValue_3D( hist, idx0, idx1, idx2 ) \
484  ((float)cvGetReal3D( (hist)->bins, (idx0), (idx1), (idx2)))
485 #define cvQueryHistValue_nD( hist, idx ) \
486  ((float)cvGetRealND( (hist)->bins, (idx)))
487 
488 /* Returns pointer to the particular bin of x-dimesional histogram.
489  For sparse histogram the bin is created if it didn't exist before */
490 #define cvGetHistValue_1D( hist, idx0 ) \
491  ((float*)cvPtr1D( (hist)->bins, (idx0), 0))
492 #define cvGetHistValue_2D( hist, idx0, idx1 ) \
493  ((float*)cvPtr2D( (hist)->bins, (idx0), (idx1), 0))
494 #define cvGetHistValue_3D( hist, idx0, idx1, idx2 ) \
495  ((float*)cvPtr3D( (hist)->bins, (idx0), (idx1), (idx2), 0))
496 #define cvGetHistValue_nD( hist, idx ) \
497  ((float*)cvPtrND( (hist)->bins, (idx), 0))
498 
499 
500 #define CV_IS_SET_ELEM_EXISTS CV_IS_SET_ELEM
501 
502 
503 CV_INLINE int cvHoughLines( CvArr* image, double rho,
504  double theta, int threshold,
505  float* lines, int linesNumber )
506 {
507  CvMat linesMat = cvMat( 1, linesNumber, CV_32FC2, lines );
508  cvHoughLines2( image, &linesMat, CV_HOUGH_STANDARD,
509  rho, theta, threshold, 0, 0 );
510 
511  return linesMat.cols;
512 }
513 
514 
515 CV_INLINE int cvHoughLinesP( CvArr* image, double rho,
516  double theta, int threshold,
517  int lineLength, int lineGap,
518  int* lines, int linesNumber )
519 {
520  CvMat linesMat = cvMat( 1, linesNumber, CV_32SC4, lines );
521  cvHoughLines2( image, &linesMat, CV_HOUGH_PROBABILISTIC,
522  rho, theta, threshold, lineLength, lineGap );
523 
524  return linesMat.cols;
525 }
526 
527 
528 CV_INLINE int cvHoughLinesSDiv( CvArr* image, double rho, int srn,
529  double theta, int stn, int threshold,
530  float* lines, int linesNumber )
531 {
532  CvMat linesMat = cvMat( 1, linesNumber, CV_32FC2, lines );
533  cvHoughLines2( image, &linesMat, CV_HOUGH_MULTI_SCALE,
534  rho, theta, threshold, srn, stn );
535 
536  return linesMat.cols;
537 }
538 
539 
540 /* Find fundamental matrix */
541 CV_INLINE void cvFindFundamentalMatrix( int* points1, int* points2,
542  int numpoints, int CV_UNREFERENCED(method), float* matrix )
543 {
544  CvMat* pointsMat1;
545  CvMat* pointsMat2;
546  CvMat fundMatr = cvMat(3,3,CV_32F,matrix);
547  int i, curr = 0;
548 
549  pointsMat1 = cvCreateMat(3,numpoints,CV_64F);
550  pointsMat2 = cvCreateMat(3,numpoints,CV_64F);
551 
552  for( i = 0; i < numpoints; i++ )
553  {
554  cvmSet(pointsMat1,0,i,points1[curr]);//x
555  cvmSet(pointsMat1,1,i,points1[curr+1]);//y
556  cvmSet(pointsMat1,2,i,1.0);
557 
558  cvmSet(pointsMat2,0,i,points2[curr]);//x
559  cvmSet(pointsMat2,1,i,points2[curr+1]);//y
560  cvmSet(pointsMat2,2,i,1.0);
561  curr += 2;
562  }
563 
564  cvFindFundamentalMat(pointsMat1,pointsMat2,&fundMatr,CV_FM_RANSAC,1,0.99,0);
565 
566  cvReleaseMat(&pointsMat1);
567  cvReleaseMat(&pointsMat2);
568 }
569 
570 
571 
572 CV_INLINE int
573 cvFindChessBoardCornerGuesses( const void* arr, void* CV_UNREFERENCED(thresharr),
574  CvMemStorage * CV_UNREFERENCED(storage),
575  CvSize pattern_size, CvPoint2D32f * corners,
576  int *corner_count )
577 {
578  return cvFindChessboardCorners( arr, pattern_size, corners,
579  corner_count, CV_CALIB_CB_ADAPTIVE_THRESH );
580 }
581 
582 
583 /* Calibrates camera using multiple views of calibration pattern */
584 CV_INLINE void cvCalibrateCamera( int image_count, int* _point_counts,
585  CvSize image_size, CvPoint2D32f* _image_points, CvPoint3D32f* _object_points,
586  float* _distortion_coeffs, float* _camera_matrix, float* _translation_vectors,
587  float* _rotation_matrices, int flags )
588 {
589  int i, total = 0;
590  CvMat point_counts = cvMat( image_count, 1, CV_32SC1, _point_counts );
591  CvMat image_points, object_points;
592  CvMat dist_coeffs = cvMat( 4, 1, CV_32FC1, _distortion_coeffs );
593  CvMat camera_matrix = cvMat( 3, 3, CV_32FC1, _camera_matrix );
594  CvMat rotation_matrices = cvMat( image_count, 9, CV_32FC1, _rotation_matrices );
595  CvMat translation_vectors = cvMat( image_count, 3, CV_32FC1, _translation_vectors );
596 
597  for( i = 0; i < image_count; i++ )
598  total += _point_counts[i];
599 
600  image_points = cvMat( total, 1, CV_32FC2, _image_points );
601  object_points = cvMat( total, 1, CV_32FC3, _object_points );
602 
603  cvCalibrateCamera2( &object_points, &image_points, &point_counts, image_size,
604  &camera_matrix, &dist_coeffs, &rotation_matrices, &translation_vectors,
605  flags );
606 }
607 
608 
609 CV_INLINE void cvCalibrateCamera_64d( int image_count, int* _point_counts,
610  CvSize image_size, CvPoint2D64f* _image_points, CvPoint3D64f* _object_points,
611  double* _distortion_coeffs, double* _camera_matrix, double* _translation_vectors,
612  double* _rotation_matrices, int flags )
613 {
614  int i, total = 0;
615  CvMat point_counts = cvMat( image_count, 1, CV_32SC1, _point_counts );
616  CvMat image_points, object_points;
617  CvMat dist_coeffs = cvMat( 4, 1, CV_64FC1, _distortion_coeffs );
618  CvMat camera_matrix = cvMat( 3, 3, CV_64FC1, _camera_matrix );
619  CvMat rotation_matrices = cvMat( image_count, 9, CV_64FC1, _rotation_matrices );
620  CvMat translation_vectors = cvMat( image_count, 3, CV_64FC1, _translation_vectors );
621 
622  for( i = 0; i < image_count; i++ )
623  total += _point_counts[i];
624 
625  image_points = cvMat( total, 1, CV_64FC2, _image_points );
626  object_points = cvMat( total, 1, CV_64FC3, _object_points );
627 
628  cvCalibrateCamera2( &object_points, &image_points, &point_counts, image_size,
629  &camera_matrix, &dist_coeffs, &rotation_matrices, &translation_vectors,
630  flags );
631 }
632 
633 
634 
635 /* Find 3d position of object given intrinsic camera parameters,
636  3d model of the object and projection of the object into view plane */
637 CV_INLINE void cvFindExtrinsicCameraParams( int point_count,
638  CvSize CV_UNREFERENCED(image_size), CvPoint2D32f* _image_points,
639  CvPoint3D32f* _object_points, float* focal_length,
640  CvPoint2D32f principal_point, float* _distortion_coeffs,
641  float* _rotation_vector, float* _translation_vector )
642 {
643  CvMat image_points = cvMat( point_count, 1, CV_32FC2, _image_points );
644  CvMat object_points = cvMat( point_count, 1, CV_32FC3, _object_points );
645  CvMat dist_coeffs = cvMat( 4, 1, CV_32FC1, _distortion_coeffs );
646  float a[9];
647  CvMat camera_matrix = cvMat( 3, 3, CV_32FC1, a );
648  CvMat rotation_vector = cvMat( 1, 1, CV_32FC3, _rotation_vector );
649  CvMat translation_vector = cvMat( 1, 1, CV_32FC3, _translation_vector );
650 
651  a[0] = focal_length[0]; a[4] = focal_length[1];
652  a[2] = principal_point.x; a[5] = principal_point.y;
653  a[1] = a[3] = a[6] = a[7] = 0.f;
654  a[8] = 1.f;
655 
656  cvFindExtrinsicCameraParams2( &object_points, &image_points, &camera_matrix,
657  &dist_coeffs, &rotation_vector, &translation_vector );
658 }
659 
660 
661 /* Variant of the previous function that takes double-precision parameters */
662 CV_INLINE void cvFindExtrinsicCameraParams_64d( int point_count,
663  CvSize CV_UNREFERENCED(image_size), CvPoint2D64f* _image_points,
664  CvPoint3D64f* _object_points, double* focal_length,
665  CvPoint2D64f principal_point, double* _distortion_coeffs,
666  double* _rotation_vector, double* _translation_vector )
667 {
668  CvMat image_points = cvMat( point_count, 1, CV_64FC2, _image_points );
669  CvMat object_points = cvMat( point_count, 1, CV_64FC3, _object_points );
670  CvMat dist_coeffs = cvMat( 4, 1, CV_64FC1, _distortion_coeffs );
671  double a[9];
672  CvMat camera_matrix = cvMat( 3, 3, CV_64FC1, a );
673  CvMat rotation_vector = cvMat( 1, 1, CV_64FC3, _rotation_vector );
674  CvMat translation_vector = cvMat( 1, 1, CV_64FC3, _translation_vector );
675 
676  a[0] = focal_length[0]; a[4] = focal_length[1];
677  a[2] = principal_point.x; a[5] = principal_point.y;
678  a[1] = a[3] = a[6] = a[7] = 0.;
679  a[8] = 1.;
680 
681  cvFindExtrinsicCameraParams2( &object_points, &image_points, &camera_matrix,
682  &dist_coeffs, &rotation_vector, &translation_vector );
683 }
684 
685 
686 /* Rodrigues transform */
687 #define CV_RODRIGUES_M2V 0
688 #define CV_RODRIGUES_V2M 1
689 
690 /* Converts rotation_matrix matrix to rotation_matrix vector or vice versa */
691 CV_INLINE void cvRodrigues( CvMat* rotation_matrix, CvMat* rotation_vector,
692  CvMat* jacobian, int conv_type )
693 {
694  if( conv_type == CV_RODRIGUES_V2M )
695  cvRodrigues2( rotation_vector, rotation_matrix, jacobian );
696  else
697  cvRodrigues2( rotation_matrix, rotation_vector, jacobian );
698 }
699 
700 
701 /* Does reprojection of 3d object points to the view plane */
702 CV_INLINE void cvProjectPoints( int point_count, CvPoint3D64f* _object_points,
703  double* _rotation_vector, double* _translation_vector,
704  double* focal_length, CvPoint2D64f principal_point,
705  double* _distortion, CvPoint2D64f* _image_points,
706  double* _deriv_points_rotation_matrix,
707  double* _deriv_points_translation_vect,
708  double* _deriv_points_focal,
709  double* _deriv_points_principal_point,
710  double* _deriv_points_distortion_coeffs )
711 {
712  CvMat object_points = cvMat( point_count, 1, CV_64FC3, _object_points );
713  CvMat image_points = cvMat( point_count, 1, CV_64FC2, _image_points );
714  CvMat rotation_vector = cvMat( 3, 1, CV_64FC1, _rotation_vector );
715  CvMat translation_vector = cvMat( 3, 1, CV_64FC1, _translation_vector );
716  double a[9];
717  CvMat camera_matrix = cvMat( 3, 3, CV_64FC1, a );
718  CvMat dist_coeffs = cvMat( 4, 1, CV_64FC1, _distortion );
719  CvMat dpdr = cvMat( 2*point_count, 3, CV_64FC1, _deriv_points_rotation_matrix );
720  CvMat dpdt = cvMat( 2*point_count, 3, CV_64FC1, _deriv_points_translation_vect );
721  CvMat dpdf = cvMat( 2*point_count, 2, CV_64FC1, _deriv_points_focal );
722  CvMat dpdc = cvMat( 2*point_count, 2, CV_64FC1, _deriv_points_principal_point );
723  CvMat dpdk = cvMat( 2*point_count, 4, CV_64FC1, _deriv_points_distortion_coeffs );
724 
725  a[0] = focal_length[0]; a[4] = focal_length[1];
726  a[2] = principal_point.x; a[5] = principal_point.y;
727  a[1] = a[3] = a[6] = a[7] = 0.;
728  a[8] = 1.;
729 
730  cvProjectPoints2( &object_points, &rotation_vector, &translation_vector,
731  &camera_matrix, &dist_coeffs, &image_points,
732  &dpdr, &dpdt, &dpdf, &dpdc, &dpdk, 0 );
733 }
734 
735 
736 /* Simpler version of the previous function */
737 CV_INLINE void cvProjectPointsSimple( int point_count, CvPoint3D64f* _object_points,
738  double* _rotation_matrix, double* _translation_vector,
739  double* _camera_matrix, double* _distortion, CvPoint2D64f* _image_points )
740 {
741  CvMat object_points = cvMat( point_count, 1, CV_64FC3, _object_points );
742  CvMat image_points = cvMat( point_count, 1, CV_64FC2, _image_points );
743  CvMat rotation_matrix = cvMat( 3, 3, CV_64FC1, _rotation_matrix );
744  CvMat translation_vector = cvMat( 3, 1, CV_64FC1, _translation_vector );
745  CvMat camera_matrix = cvMat( 3, 3, CV_64FC1, _camera_matrix );
746  CvMat dist_coeffs = cvMat( 4, 1, CV_64FC1, _distortion );
747 
748  cvProjectPoints2( &object_points, &rotation_matrix, &translation_vector,
749  &camera_matrix, &dist_coeffs, &image_points,
750  0, 0, 0, 0, 0, 0 );
751 }
752 
753 
754 CV_INLINE void cvUnDistortOnce( const CvArr* src, CvArr* dst,
755  const float* intrinsic_matrix,
756  const float* distortion_coeffs,
757  int CV_UNREFERENCED(interpolate) )
758 {
759  CvMat _a = cvMat( 3, 3, CV_32F, (void*)intrinsic_matrix );
760  CvMat _k = cvMat( 4, 1, CV_32F, (void*)distortion_coeffs );
761  cvUndistort2( src, dst, &_a, &_k );
762 }
763 
764 
765 /* the two functions below have quite hackerish implementations, use with care
766  (or, which is better, switch to cvUndistortInitMap and cvRemap instead */
767 CV_INLINE void cvUnDistortInit( const CvArr* CV_UNREFERENCED(src),
768  CvArr* undistortion_map,
769  const float* A, const float* k,
770  int CV_UNREFERENCED(interpolate) )
771 {
772  union { uchar* ptr; float* fl; } data;
773  CvSize sz;
774  cvGetRawData( undistortion_map, &data.ptr, 0, &sz );
775  assert( sz.width >= 8 );
776  /* just save the intrinsic parameters to the map */
777  data.fl[0] = A[0]; data.fl[1] = A[4];
778  data.fl[2] = A[2]; data.fl[3] = A[5];
779  data.fl[4] = k[0]; data.fl[5] = k[1];
780  data.fl[6] = k[2]; data.fl[7] = k[3];
781 }
782 
783 CV_INLINE void cvUnDistort( const CvArr* src, CvArr* dst,
784  const CvArr* undistortion_map,
785  int CV_UNREFERENCED(interpolate) )
786 {
787  union { uchar* ptr; float* fl; } data;
788  float a[] = {0,0,0,0,0,0,0,0,1};
789  CvSize sz;
790  cvGetRawData( undistortion_map, &data.ptr, 0, &sz );
791  assert( sz.width >= 8 );
792  a[0] = data.fl[0]; a[4] = data.fl[1];
793  a[2] = data.fl[2]; a[5] = data.fl[3];
794  cvUnDistortOnce( src, dst, a, data.fl + 4, 1 );
795 }
796 
797 
798 CV_INLINE float cvCalcEMD( const float* signature1, int size1,
799  const float* signature2, int size2,
800  int dims, int dist_type CV_DEFAULT(CV_DIST_L2),
801  CvDistanceFunction dist_func CV_DEFAULT(0),
802  float* lower_bound CV_DEFAULT(0),
803  void* user_param CV_DEFAULT(0))
804 {
805  CvMat sign1 = cvMat( size1, dims + 1, CV_32FC1, (void*)signature1 );
806  CvMat sign2 = cvMat( size2, dims + 1, CV_32FC1, (void*)signature2 );
807 
808  return cvCalcEMD2( &sign1, &sign2, dist_type, dist_func, 0, 0, lower_bound, user_param );
809 }
810 
811 
812 CV_INLINE void cvKMeans( int num_clusters, float** samples,
813  int num_samples, int vec_size,
814  CvTermCriteria termcrit, int* cluster_idx )
815 {
816  CvMat* samples_mat = cvCreateMat( num_samples, vec_size, CV_32FC1 );
817  CvMat cluster_idx_mat = cvMat( num_samples, 1, CV_32SC1, cluster_idx );
818  int i;
819  for( i = 0; i < num_samples; i++ )
820  memcpy( samples_mat->data.fl + i*vec_size, samples[i], vec_size*sizeof(float));
821  cvKMeans2( samples_mat, num_clusters, &cluster_idx_mat, termcrit );
822  cvReleaseMat( &samples_mat );
823 }
824 
825 
826 CV_INLINE void cvStartScanGraph( CvGraph* graph, CvGraphScanner* scanner,
827  CvGraphVtx* vtx CV_DEFAULT(NULL),
828  int mask CV_DEFAULT(CV_GRAPH_ALL_ITEMS))
829 {
830  CvGraphScanner* temp_scanner;
831 
832  if( !scanner )
833  cvError( CV_StsNullPtr, "cvStartScanGraph", "Null scanner pointer", "cvcompat.h", 0 );
834 
835  temp_scanner = cvCreateGraphScanner( graph, vtx, mask );
836  *scanner = *temp_scanner;
837  cvFree( &temp_scanner );
838 }
839 
840 
841 CV_INLINE void cvEndScanGraph( CvGraphScanner* scanner )
842 {
843  if( !scanner )
844  cvError( CV_StsNullPtr, "cvEndScanGraph", "Null scanner pointer", "cvcompat.h", 0 );
845 
846  if( scanner->stack )
847  {
848  CvGraphScanner* temp_scanner = (CvGraphScanner*)cvAlloc( sizeof(*temp_scanner) );
849  *temp_scanner = *scanner;
850  cvReleaseGraphScanner( &temp_scanner );
851  memset( scanner, 0, sizeof(*scanner) );
852  }
853 }
854 
855 
856 #define cvKalmanUpdateByTime cvKalmanPredict
857 #define cvKalmanUpdateByMeasurement cvKalmanCorrect
858 
859 /* old drawing functions */
860 CV_INLINE void cvLineAA( CvArr* img, CvPoint pt1, CvPoint pt2,
861  double color, int scale CV_DEFAULT(0))
862 {
863  cvLine( img, pt1, pt2, cvColorToScalar(color, cvGetElemType(img)), 1, CV_AA, scale );
864 }
865 
866 CV_INLINE void cvCircleAA( CvArr* img, CvPoint center, int radius,
867  double color, int scale CV_DEFAULT(0) )
868 {
869  cvCircle( img, center, radius, cvColorToScalar(color, cvGetElemType(img)), 1, CV_AA, scale );
870 }
871 
872 CV_INLINE void cvEllipseAA( CvArr* img, CvPoint center, CvSize axes,
873  double angle, double start_angle,
874  double end_angle, double color,
875  int scale CV_DEFAULT(0) )
876 {
877  cvEllipse( img, center, axes, angle, start_angle, end_angle,
878  cvColorToScalar(color, cvGetElemType(img)), 1, CV_AA, scale );
879 }
880 
881 CV_INLINE void cvPolyLineAA( CvArr* img, CvPoint** pts, int* npts, int contours,
882  int is_closed, double color, int scale CV_DEFAULT(0) )
883 {
884  cvPolyLine( img, pts, npts, contours, is_closed,
885  cvColorToScalar(color, cvGetElemType(img)),
886  1, CV_AA, scale );
887 }
888 
889 
890 #define cvMake2DPoints cvConvertPointsHomogeneous
891 #define cvMake3DPoints cvConvertPointsHomogeneous
892 
893 #define cvWarpPerspectiveQMatrix cvGetPerspectiveTransform
894 
895 #define cvConvertPointsHomogenious cvConvertPointsHomogeneous
896 
897 /****************************************************************************************\
898 * Pixel Access Macros *
899 \****************************************************************************************/
900 
901 typedef struct _CvPixelPosition8u
902 {
903  uchar* currline; /* pointer to the start of the current pixel line */
904  uchar* topline; /* pointer to the start of the top pixel line */
905  uchar* bottomline; /* pointer to the start of the first line */
906  /* which is below the image */
907  int x; /* current x coordinate ( in pixels ) */
908  int width; /* width of the image ( in pixels ) */
909  int height; /* height of the image ( in pixels ) */
910  int step; /* distance between lines ( in elements of single */
911  /* plane ) */
912  int step_arr[3]; /* array: ( 0, -step, step ). It is used for */
913  /* vertical moving */
914 } CvPixelPosition8u;
915 
916 /* this structure differs from the above only in data type */
917 typedef struct _CvPixelPosition8s
918 {
919  schar* currline;
920  schar* topline;
921  schar* bottomline;
922  int x;
923  int width;
924  int height;
925  int step;
926  int step_arr[3];
927 } CvPixelPosition8s;
928 
929 /* this structure differs from the CvPixelPosition8u only in data type */
930 typedef struct _CvPixelPosition32f
931 {
932  float* currline;
933  float* topline;
934  float* bottomline;
935  int x;
936  int width;
937  int height;
938  int step;
939  int step_arr[3];
940 } CvPixelPosition32f;
941 
942 
943 /* Initialize one of the CvPixelPosition structures. */
944 /* pos - initialized structure */
945 /* origin - pointer to the left-top corner of the ROI */
946 /* step - width of the whole image in bytes */
947 /* roi - width & height of the ROI */
948 /* x, y - initial position */
949 #define CV_INIT_PIXEL_POS(pos, origin, _step, roi, _x, _y, orientation) \
950  ( \
951  (pos).step = (_step)/sizeof((pos).currline[0]) * (orientation ? -1 : 1), \
952  (pos).width = (roi).width, \
953  (pos).height = (roi).height, \
954  (pos).bottomline = (origin) + (pos).step*(pos).height, \
955  (pos).topline = (origin) - (pos).step, \
956  (pos).step_arr[0] = 0, \
957  (pos).step_arr[1] = -(pos).step, \
958  (pos).step_arr[2] = (pos).step, \
959  (pos).x = (_x), \
960  (pos).currline = (origin) + (pos).step*(_y) )
961 
962 
963 /* Move to specified point ( absolute shift ) */
964 /* pos - position structure */
965 /* x, y - coordinates of the new position */
966 /* cs - number of the image channels */
967 #define CV_MOVE_TO( pos, _x, _y, cs ) \
968 ((pos).currline = (_y) >= 0 && (_y) < (pos).height ? (pos).topline + ((_y)+1)*(pos).step : 0, \
969  (pos).x = (_x) >= 0 && (_x) < (pos).width ? (_x) : 0, (pos).currline + (_x) * (cs) )
970 
971 /* Get current coordinates */
972 /* pos - position structure */
973 /* x, y - coordinates of the new position */
974 /* cs - number of the image channels */
975 #define CV_GET_CURRENT( pos, cs ) ((pos).currline + (pos).x * (cs))
976 
977 /* Move by one pixel relatively to current position */
978 /* pos - position structure */
979 /* cs - number of the image channels */
980 
981 /* left */
982 #define CV_MOVE_LEFT( pos, cs ) \
983  ( --(pos).x >= 0 ? (pos).currline + (pos).x*(cs) : 0 )
984 
985 /* right */
986 #define CV_MOVE_RIGHT( pos, cs ) \
987  ( ++(pos).x < (pos).width ? (pos).currline + (pos).x*(cs) : 0 )
988 
989 /* up */
990 #define CV_MOVE_UP( pos, cs ) \
991  (((pos).currline -= (pos).step) != (pos).topline ? (pos).currline + (pos).x*(cs) : 0 )
992 
993 /* down */
994 #define CV_MOVE_DOWN( pos, cs ) \
995  (((pos).currline += (pos).step) != (pos).bottomline ? (pos).currline + (pos).x*(cs) : 0 )
996 
997 /* left up */
998 #define CV_MOVE_LU( pos, cs ) ( CV_MOVE_LEFT(pos, cs), CV_MOVE_UP(pos, cs))
999 
1000 /* right up */
1001 #define CV_MOVE_RU( pos, cs ) ( CV_MOVE_RIGHT(pos, cs), CV_MOVE_UP(pos, cs))
1002 
1003 /* left down */
1004 #define CV_MOVE_LD( pos, cs ) ( CV_MOVE_LEFT(pos, cs), CV_MOVE_DOWN(pos, cs))
1005 
1006 /* right down */
1007 #define CV_MOVE_RD( pos, cs ) ( CV_MOVE_RIGHT(pos, cs), CV_MOVE_DOWN(pos, cs))
1008 
1009 
1010 
1011 /* Move by one pixel relatively to current position with wrapping when the position */
1012 /* achieves image boundary */
1013 /* pos - position structure */
1014 /* cs - number of the image channels */
1015 
1016 /* left */
1017 #define CV_MOVE_LEFT_WRAP( pos, cs ) \
1018  ((pos).currline + ( --(pos).x >= 0 ? (pos).x : ((pos).x = (pos).width-1))*(cs))
1019 
1020 /* right */
1021 #define CV_MOVE_RIGHT_WRAP( pos, cs ) \
1022  ((pos).currline + ( ++(pos).x < (pos).width ? (pos).x : ((pos).x = 0))*(cs) )
1023 
1024 /* up */
1025 #define CV_MOVE_UP_WRAP( pos, cs ) \
1026  ((((pos).currline -= (pos).step) != (pos).topline ? \
1027  (pos).currline : ((pos).currline = (pos).bottomline - (pos).step)) + (pos).x*(cs) )
1028 
1029 /* down */
1030 #define CV_MOVE_DOWN_WRAP( pos, cs ) \
1031  ((((pos).currline += (pos).step) != (pos).bottomline ? \
1032  (pos).currline : ((pos).currline = (pos).topline + (pos).step)) + (pos).x*(cs) )
1033 
1034 /* left up */
1035 #define CV_MOVE_LU_WRAP( pos, cs ) ( CV_MOVE_LEFT_WRAP(pos, cs), CV_MOVE_UP_WRAP(pos, cs))
1036 /* right up */
1037 #define CV_MOVE_RU_WRAP( pos, cs ) ( CV_MOVE_RIGHT_WRAP(pos, cs), CV_MOVE_UP_WRAP(pos, cs))
1038 /* left down */
1039 #define CV_MOVE_LD_WRAP( pos, cs ) ( CV_MOVE_LEFT_WRAP(pos, cs), CV_MOVE_DOWN_WRAP(pos, cs))
1040 /* right down */
1041 #define CV_MOVE_RD_WRAP( pos, cs ) ( CV_MOVE_RIGHT_WRAP(pos, cs), CV_MOVE_DOWN_WRAP(pos, cs))
1042 
1043 /* Numeric constants which used for moving in arbitrary direction */
1044 #define CV_SHIFT_NONE 2
1045 #define CV_SHIFT_LEFT 1
1046 #define CV_SHIFT_RIGHT 3
1047 #define CV_SHIFT_UP 6
1048 #define CV_SHIFT_DOWN 10
1049 #define CV_SHIFT_LU 5
1050 #define CV_SHIFT_RU 7
1051 #define CV_SHIFT_LD 9
1052 #define CV_SHIFT_RD 11
1053 
1054 /* Move by one pixel in specified direction */
1055 /* pos - position structure */
1056 /* shift - direction ( it's value must be one of the CV_SHIFT_… constants ) */
1057 /* cs - number of the image channels */
1058 #define CV_MOVE_PARAM( pos, shift, cs ) \
1059  ( (pos).currline += (pos).step_arr[(shift)>>2], (pos).x += ((shift)&3)-2, \
1060  ((pos).currline != (pos).topline && (pos).currline != (pos).bottomline && \
1061  (pos).x >= 0 && (pos).x < (pos).width) ? (pos).currline + (pos).x*(cs) : 0 )
1062 
1063 /* Move by one pixel in specified direction with wrapping when the */
1064 /* position achieves image boundary */
1065 /* pos - position structure */
1066 /* shift - direction ( it's value must be one of the CV_SHIFT_… constants ) */
1067 /* cs - number of the image channels */
1068 #define CV_MOVE_PARAM_WRAP( pos, shift, cs ) \
1069  ( (pos).currline += (pos).step_arr[(shift)>>2], \
1070  (pos).currline = ((pos).currline == (pos).topline ? \
1071  (pos).bottomline - (pos).step : \
1072  (pos).currline == (pos).bottomline ? \
1073  (pos).topline + (pos).step : (pos).currline), \
1074  \
1075  (pos).x += ((shift)&3)-2, \
1076  (pos).x = ((pos).x < 0 ? (pos).width-1 : (pos).x >= (pos).width ? 0 : (pos).x), \
1077  \
1078  (pos).currline + (pos).x*(cs) )
1079 
1080 #endif/*_CVCOMPAT_H_*/
Generated on Thu Apr 4 2013 14:33:04 for Wondercoll by   doxygen 1.8.3.1