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
cvSumPixels(const CvArr * image)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
cvmPerspectiveProject(const CvMat * mat,const CvArr * src,CvArr * dst)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
cvFillImage(CvArr * mat,double color)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
cvRandInit(CvRandState * state,double param1,double param2,int seed,int disttype CV_DEFAULT (CV_RAND_UNI))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 */
cvRand(CvRandState * state,CvArr * arr)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
cvbRand(CvRandState * state,float * dst,int len)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
cvbCartToPolar(const float * y,const float * x,float * magnitude,float * angle,int len)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
cvbFastArctan(const float * y,const float * x,float * angle,int len)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
cvbSqrt(const float * x,float * y,int len)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
cvbInvSqrt(const float * x,float * y,int len)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
cvbReciprocal(const float * x,float * y,int len)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
cvbFastExp(const float * x,double * y,int len)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
cvbFastLog(const double * x,float * y,int len)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
cvPseudoInverse(const CvArr * src,CvArr * dst)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 */
cvConvexHull(CvPoint * points,int num_points,CvRect * CV_UNREFERENCED (bound_rect),int orientation,int * hull,int * hullsize)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
cvMinAreaRect(CvPoint * points,int n,int CV_UNREFERENCED (left),int CV_UNREFERENCED (bottom),int CV_UNREFERENCED (right),int CV_UNREFERENCED (top),CvPoint2D32f * anchor,CvPoint2D32f * vect1,CvPoint2D32f * vect2)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
cvFitLine3D(CvPoint3D32f * points,int count,int dist,void * param,float reps,float aeps,float * line)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) */
cvFitLine2D(CvPoint2D32f * points,int count,int dist,void * param,float reps,float aeps,float * line)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
cvFitEllipse(const CvPoint2D32f * points,int count,CvBox2D * box)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
cvHoughLines(CvArr * image,double rho,double theta,int threshold,float * lines,int linesNumber)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
cvHoughLinesP(CvArr * image,double rho,double theta,int threshold,int lineLength,int lineGap,int * lines,int linesNumber)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
cvHoughLinesSDiv(CvArr * image,double rho,int srn,double theta,int stn,int threshold,float * lines,int linesNumber)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 */
cvFindFundamentalMatrix(int * points1,int * points2,int numpoints,int CV_UNREFERENCED (method),float * 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
cvFindChessBoardCornerGuesses(const void * arr,void * CV_UNREFERENCED (thresharr),CvMemStorage * CV_UNREFERENCED (storage),CvSize pattern_size,CvPoint2D32f * corners,int * corner_count)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 */
cvCalibrateCamera(int image_count,int * _point_counts,CvSize image_size,CvPoint2D32f * _image_points,CvPoint3D32f * _object_points,float * _distortion_coeffs,float * _camera_matrix,float * _translation_vectors,float * _rotation_matrices,int flags)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
cvCalibrateCamera_64d(int image_count,int * _point_counts,CvSize image_size,CvPoint2D64f * _image_points,CvPoint3D64f * _object_points,double * _distortion_coeffs,double * _camera_matrix,double * _translation_vectors,double * _rotation_matrices,int flags)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 */
cvFindExtrinsicCameraParams(int point_count,CvSize CV_UNREFERENCED (image_size),CvPoint2D32f * _image_points,CvPoint3D32f * _object_points,float * focal_length,CvPoint2D32f principal_point,float * _distortion_coeffs,float * _rotation_vector,float * _translation_vector)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 */
cvFindExtrinsicCameraParams_64d(int point_count,CvSize CV_UNREFERENCED (image_size),CvPoint2D64f * _image_points,CvPoint3D64f * _object_points,double * focal_length,CvPoint2D64f principal_point,double * _distortion_coeffs,double * _rotation_vector,double * _translation_vector)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 */
cvRodrigues(CvMat * rotation_matrix,CvMat * rotation_vector,CvMat * jacobian,int conv_type)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 */
cvProjectPoints(int point_count,CvPoint3D64f * _object_points,double * _rotation_vector,double * _translation_vector,double * focal_length,CvPoint2D64f principal_point,double * _distortion,CvPoint2D64f * _image_points,double * _deriv_points_rotation_matrix,double * _deriv_points_translation_vect,double * _deriv_points_focal,double * _deriv_points_principal_point,double * _deriv_points_distortion_coeffs)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 */
cvProjectPointsSimple(int point_count,CvPoint3D64f * _object_points,double * _rotation_matrix,double * _translation_vector,double * _camera_matrix,double * _distortion,CvPoint2D64f * _image_points)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
cvUnDistortOnce(const CvArr * src,CvArr * dst,const float * intrinsic_matrix,const float * distortion_coeffs,int CV_UNREFERENCED (interpolate))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 */
cvUnDistortInit(const CvArr * CV_UNREFERENCED (src),CvArr * undistortion_map,const float * A,const float * k,int CV_UNREFERENCED (interpolate))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
cvUnDistort(const CvArr * src,CvArr * dst,const CvArr * undistortion_map,int CV_UNREFERENCED (interpolate))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
cvKMeans(int num_clusters,float ** samples,int num_samples,int vec_size,CvTermCriteria termcrit,int * cluster_idx)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
cvStartScanGraph(CvGraph * graph,CvGraphScanner * scanner,CvGraphVtx * vtx CV_DEFAULT (NULL),int mask CV_DEFAULT (CV_GRAPH_ALL_ITEMS))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
cvEndScanGraph(CvGraphScanner * scanner)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_*/
1081