- Main Page
- Related Pages
- Namespaces
- Classes
- Files

- File List
- File Members

# /usr/obj/OpenCV-2.2.0/OpenCV-2.2.0/modules/legacy/include/opencv2/legacy/compat.hpp

Go to the documentation of this file.

    00001 /*M///////////////////////////////////////////////////////////////////////////////////////
    00002 //
    00003 //  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
    00004 //
    00005 //  By downloading, copying, installing or using the software you agree to this license.
    00006 //  If you do not agree to this license, do not download, install,
    00007 //  copy or use the software.
    00008 //
    00009 //
    00010 //                        Intel License Agreement
    00011 //                For Open Source Computer Vision Library
    00012 //
    00013 // Copyright( C) 2000, Intel Corporation, all rights reserved.
    00014 // Third party copyrights are property of their respective owners.
    00015 //
    00016 // Redistribution and use in source and binary forms, with or without modification,
    00017 // are permitted provided that the following conditions are met:
    00018 //
    00019 //   * Redistribution's of source code must retain the above copyright notice,
    00020 //     this list of conditions and the following disclaimer.
    00021 //
    00022 //   * Redistribution's in binary form must reproduce the above copyright notice,
    00023 //     this list of conditions and the following disclaimer in the documentation
    00024 //     and/or other materials provided with the distribution.
    00025 //
    00026 //   * The name of Intel Corporation may not be used to endorse or promote products
    00027 //     derived from this software without specific prior written permission.
    00028 //
    00029 // This software is provided by the copyright holders and contributors "as is" and
    00030 // any express or implied warranties, including, but not limited to, the implied
    00031 // warranties of merchantability and fitness for a particular purpose are disclaimed.
    00032 // In no event shall the Intel Corporation or contributors be liable for any direct,
    00033 // indirect, incidental, special, exemplary, or consequential damages
    00034 //(including, but not limited to, procurement of substitute goods or services;
    00035 // loss of use, data, or profits; or business interruption) however caused
    00036 // and on any theory of liability, whether in contract, strict liability,
    00037 // or tort(including negligence or otherwise) arising in any way out of
    00038 // the use of this software, even if advised of the possibility of such damage.
    00039 //
    00040 //M*/
    00041
    00042 /*
    00043    A few macros and definitions for backward compatibility
    00044    with the previous versions of OpenCV. They are obsolete and
    00045    are likely to be removed in future. To check whether your code
    00046    uses any of these, define CV_NO_BACKWARD_COMPATIBILITY before
    00047    including cv.h.
    00048 */
    00049
    00050 #ifndef __OPENCV_COMPAT_HPP__
    00051 #define __OPENCV_COMPAT_HPP__
    00052
    00053 #include "opencv2/core/core_c.h"
    00054 #include "opencv2/imgproc/types_c.h"
    00055
    00056 #include <math.h>
    00057 #include <string.h>
    00058
    00059 #ifdef __cplusplus
    00060 extern "C" {
    00061 #endif
    00062
    00063 typedef int CvMatType;
    00064 typedef int CvDisMaskType;
    00065 typedef CvMat CvMatArray;
    00066
    00067 typedef int CvThreshType;
    00068 typedef int CvAdaptiveThreshMethod;
    00069 typedef int CvCompareMethod;
    00070 typedef int CvFontFace;
    00071 typedef int CvPolyApproxMethod;
    00072 typedef int CvContoursMatchMethod;
    00073 typedef int CvContourTreesMatchMethod;
    00074 typedef int CvCoeffType;
    00075 typedef int CvRodriguesType;
    00076 typedef int CvElementShape;
    00077 typedef int CvMorphOp;
    00078 typedef int CvTemplMatchMethod;
    00079
    00080 typedef CvPoint2D64f CvPoint2D64d;
    00081 typedef CvPoint3D64f CvPoint3D64d;
    00082
    00083 enum
    00084 {
    00085     CV_MAT32F      = CV_32FC1,
    00086     CV_MAT3x1_32F  = CV_32FC1,
    00087     CV_MAT4x1_32F  = CV_32FC1,
    00088     CV_MAT3x3_32F  = CV_32FC1,
    00089     CV_MAT4x4_32F  = CV_32FC1,
    00090
    00091     CV_MAT64D      = CV_64FC1,
    00092     CV_MAT3x1_64D  = CV_64FC1,
    00093     CV_MAT4x1_64D  = CV_64FC1,
    00094     CV_MAT3x3_64D  = CV_64FC1,
    00095     CV_MAT4x4_64D  = CV_64FC1
    00096 };
    00097
    00098 enum
    00099 {
    00100     IPL_GAUSSIAN_5x5 = 7
    00101 };
    00102
    00103 typedef CvBox2D  CvBox2D32f;
    00104
    00105 /* allocation/deallocation macros */
    00106 #define cvCreateImageData   cvCreateData
    00107 #define cvReleaseImageData  cvReleaseData
    00108 #define cvSetImageData      cvSetData
    00109 #define cvGetImageRawData   cvGetRawData
    00110
    00111 #define cvmAlloc            cvCreateData
    00112 #define cvmFree             cvReleaseData
    00113 #define cvmAllocArray       cvCreateData
    00114 #define cvmFreeArray        cvReleaseData
    00115
    00116 #define cvIntegralImage     cvIntegral
    00117 #define cvMatchContours     cvMatchShapes
    00118
    00119 CV_EXPORTS CvMat cvMatArray( int rows, int cols, int type,
    00120                             int count, void* data CV_DEFAULT(0));
    00121
    00122 #define cvUpdateMHIByTime  cvUpdateMotionHistory
    00123
    00124 #define cvAccMask cvAcc
    00125 #define cvSquareAccMask cvSquareAcc
    00126 #define cvMultiplyAccMask cvMultiplyAcc
    00127 #define cvRunningAvgMask(imgY, imgU, mask, alpha) cvRunningAvg(imgY, imgU, alpha, mask)
    00128
    00129 #define cvSetHistThresh  cvSetHistBinRanges
    00130 #define cvCalcHistMask(img, mask, hist, doNotClear) cvCalcHist(img, hist, doNotClear, mask)
    00131
    00132 CV_EXPORTS double cvMean( const CvArr* image, const CvArr* mask CV_DEFAULT(0));
    00133 CV_EXPORTS double cvSumPixels( const CvArr* image );
    00134 CV_EXPORTS void  cvMean_StdDev( const CvArr* image, double* mean, double* sdv,
    00135                                 const CvArr* mask CV_DEFAULT(0));
    00136
    00137 CV_EXPORTS void cvmPerspectiveProject( const CvMat* mat, const CvArr* src, CvArr* dst );
    00138 CV_EXPORTS void cvFillImage( CvArr* mat, double color );
    00139
    00140 #define cvCvtPixToPlane cvSplit
    00141 #define cvCvtPlaneToPix cvMerge
    00142
    00143 typedef struct CvRandState
    00144 {
    00145     CvRNG     state;    /* RNG state (the current seed and carry)*/
    00146     int       disttype; /* distribution type */
    00147     CvScalar  param[2]; /* parameters of RNG */
    00148 } CvRandState;
    00149
    00150 /* Changes RNG range while preserving RNG state */
    00151 CV_EXPORTS void  cvRandSetRange( CvRandState* state, double param1,
    00152                                  double param2, int index CV_DEFAULT(-1));
    00153
    00154 CV_EXPORTS void  cvRandInit( CvRandState* state, double param1,
    00155                              double param2, int seed,
    00156                              int disttype CV_DEFAULT(CV_RAND_UNI));
    00157
    00158 /* Fills array with random numbers */
    00159 CV_EXPORTS void cvRand( CvRandState* state, CvArr* arr );
    00160
    00161 #define cvRandNext( _state ) cvRandInt( &(_state)->state )
    00162
    00163 CV_EXPORTS void cvbRand( CvRandState* state, float* dst, int len );
    00164
    00165 CV_EXPORTS void  cvbCartToPolar( const float* y, const float* x,
    00166                                  float* magnitude, float* angle, int len );
    00167 CV_EXPORTS void  cvbFastArctan( const float* y, const float* x, float* angle, int len );
    00168 CV_EXPORTS void  cvbSqrt( const float* x, float* y, int len );
    00169 CV_EXPORTS void  cvbInvSqrt( const float* x, float* y, int len );
    00170 CV_EXPORTS void  cvbReciprocal( const float* x, float* y, int len );
    00171 CV_EXPORTS void  cvbFastExp( const float* x, double* y, int len );
    00172 CV_EXPORTS void  cvbFastLog( const double* x, float* y, int len );
    00173
    00174 CV_EXPORTS CvRect  cvContourBoundingRect( void* point_set, int update CV_DEFAULT(0));
    00175
    00176 CV_EXPORTS double cvPseudoInverse( const CvArr* src, CvArr* dst );
    00177 #define cvPseudoInv cvPseudoInverse
    00178
    00179 #define cvContourMoments( contour, moments ) cvMoments( contour, moments, 0 )
    00180
    00181 #define cvGetPtrAt              cvPtr2D
    00182 #define cvGetAt                 cvGet2D
    00183 #define cvSetAt(arr,val,y,x)    cvSet2D((arr),(y),(x),(val))
    00184
    00185 #define cvMeanMask  cvMean
    00186 #define cvMean_StdDevMask(img,mask,mean,sdv) cvMean_StdDev(img,mean,sdv,mask)
    00187
    00188 #define cvNormMask(imgA,imgB,mask,normType) cvNorm(imgA,imgB,normType,mask)
    00189
    00190 #define cvMinMaxLocMask(img, mask, min_val, max_val, min_loc, max_loc) \
    00191         cvMinMaxLoc(img, min_val, max_val, min_loc, max_loc, mask)
    00192
    00193 #define cvRemoveMemoryManager  cvSetMemoryManager
    00194
    00195 #define cvmSetZero( mat )               cvSetZero( mat )
    00196 #define cvmSetIdentity( mat )           cvSetIdentity( mat )
    00197 #define cvmAdd( src1, src2, dst )       cvAdd( src1, src2, dst, 0 )
    00198 #define cvmSub( src1, src2, dst )       cvSub( src1, src2, dst, 0 )
    00199 #define cvmCopy( src, dst )             cvCopy( src, dst, 0 )
    00200 #define cvmMul( src1, src2, dst )       cvMatMulAdd( src1, src2, 0, dst )
    00201 #define cvmTranspose( src, dst )        cvT( src, dst )
    00202 #define cvmInvert( src, dst )           cvInv( src, dst )
    00203 #define cvmMahalanobis(vec1, vec2, mat) cvMahalanobis( vec1, vec2, mat )
    00204 #define cvmDotProduct( vec1, vec2 )     cvDotProduct( vec1, vec2 )
    00205 #define cvmCrossProduct(vec1, vec2,dst) cvCrossProduct( vec1, vec2, dst )
    00206 #define cvmTrace( mat )                 (cvTrace( mat )).val[0]
    00207 #define cvmMulTransposed( src, dst, order ) cvMulTransposed( src, dst, order )
    00208 #define cvmEigenVV( mat, evec, eval, eps)   cvEigenVV( mat, evec, eval, eps )
    00209 #define cvmDet( mat )                   cvDet( mat )
    00210 #define cvmScale( src, dst, scale )     cvScale( src, dst, scale )
    00211
    00212 #define cvCopyImage( src, dst )         cvCopy( src, dst, 0 )
    00213 #define cvReleaseMatHeader              cvReleaseMat
    00214
    00215 /* Calculates exact convex hull of 2d point set */
    00216 CV_EXPORTS void cvConvexHull( CvPoint* points, int num_points,
    00217                              CvRect* bound_rect,
    00218                              int orientation, int* hull, int* hullsize );
    00219
    00220
    00221 CV_EXPORTS void cvMinAreaRect( CvPoint* points, int n,
    00222                               int left, int bottom,
    00223                               int right, int top,
    00224                               CvPoint2D32f* anchor,
    00225                               CvPoint2D32f* vect1,
    00226                               CvPoint2D32f* vect2 );
    00227
    00228 typedef int CvDisType;
    00229 typedef int CvChainApproxMethod;
    00230 typedef int CvContourRetrievalMode;
    00231
    00232 CV_EXPORTS  void  cvFitLine3D( CvPoint3D32f* points, int count, int dist,
    00233                     void *param, float reps, float aeps, float* line );
    00234
    00235 /* Fits a line into set of 2d points in a robust way (M-estimator technique) */
    00236 CV_EXPORTS  void  cvFitLine2D( CvPoint2D32f* points, int count, int dist,
    00237                     void *param, float reps, float aeps, float* line );
    00238
    00239 CV_EXPORTS  void  cvFitEllipse( const CvPoint2D32f* points, int count, CvBox2D* box );
    00240
    00241 /* Projects 2d points to one of standard coordinate planes
    00242    (i.e. removes one of coordinates) */
    00243 CV_EXPORTS  void  cvProject3D( CvPoint3D32f* points3D, int count,
    00244                               CvPoint2D32f* points2D,
    00245                               int xIndx CV_DEFAULT(0),
    00246                               int yIndx CV_DEFAULT(1));
    00247
    00248 /* Retrieves value of the particular bin
    00249    of x-dimensional (x=1,2,3,...) histogram */
    00250 #define cvQueryHistValue_1D( hist, idx0 ) \
    00251     ((float)cvGetReal1D( (hist)->bins, (idx0)))
    00252 #define cvQueryHistValue_2D( hist, idx0, idx1 ) \
    00253     ((float)cvGetReal2D( (hist)->bins, (idx0), (idx1)))
    00254 #define cvQueryHistValue_3D( hist, idx0, idx1, idx2 ) \
    00255     ((float)cvGetReal3D( (hist)->bins, (idx0), (idx1), (idx2)))
    00256 #define cvQueryHistValue_nD( hist, idx ) \
    00257     ((float)cvGetRealND( (hist)->bins, (idx)))
    00258
    00259 /* Returns pointer to the particular bin of x-dimesional histogram.
    00260    For sparse histogram the bin is created if it didn't exist before */
    00261 #define cvGetHistValue_1D( hist, idx0 ) \
    00262     ((float*)cvPtr1D( (hist)->bins, (idx0), 0))
    00263 #define cvGetHistValue_2D( hist, idx0, idx1 ) \
    00264     ((float*)cvPtr2D( (hist)->bins, (idx0), (idx1), 0))
    00265 #define cvGetHistValue_3D( hist, idx0, idx1, idx2 ) \
    00266     ((float*)cvPtr3D( (hist)->bins, (idx0), (idx1), (idx2), 0))
    00267 #define cvGetHistValue_nD( hist, idx ) \
    00268     ((float*)cvPtrND( (hist)->bins, (idx), 0))
    00269
    00270
    00271 #define CV_IS_SET_ELEM_EXISTS CV_IS_SET_ELEM
    00272
    00273
    00274 CV_EXPORTS  int  cvHoughLines( CvArr* image, double rho,
    00275                               double theta, int threshold,
    00276                               float* lines, int linesNumber );
    00277
    00278 CV_EXPORTS  int  cvHoughLinesP( CvArr* image, double rho,
    00279                                double theta, int threshold,
    00280                                int lineLength, int lineGap,
    00281                                int* lines, int linesNumber );
    00282
    00283
    00284 CV_EXPORTS  int  cvHoughLinesSDiv( CvArr* image, double rho, int srn,
    00285                                   double theta, int stn, int threshold,
    00286                                   float* lines, int linesNumber );
    00287
    00288 CV_EXPORTS  float  cvCalcEMD( const float* signature1, int size1,
    00289                              const float* signature2, int size2,
    00290                              int dims, int dist_type CV_DEFAULT(CV_DIST_L2),
    00291                              CvDistanceFunction dist_func CV_DEFAULT(0),
    00292                              float* lower_bound CV_DEFAULT(0),
    00293                              void* user_param CV_DEFAULT(0));
    00294
    00295 CV_EXPORTS  void  cvKMeans( int num_clusters, float** samples,
    00296                            int num_samples, int vec_size,
    00297                            CvTermCriteria termcrit, int* cluster_idx );
    00298
    00299 CV_EXPORTS void  cvStartScanGraph( CvGraph* graph, CvGraphScanner* scanner,
    00300                                   CvGraphVtx* vtx CV_DEFAULT(NULL),
    00301                                   int mask CV_DEFAULT(CV_GRAPH_ALL_ITEMS));
    00302
    00303 CV_EXPORTS  void  cvEndScanGraph( CvGraphScanner* scanner );
    00304
    00305
    00306 /* old drawing functions */
    00307 CV_EXPORTS void  cvLineAA( CvArr* img, CvPoint pt1, CvPoint pt2,
    00308                             double color, int scale CV_DEFAULT(0));
    00309
    00310 CV_EXPORTS void  cvCircleAA( CvArr* img, CvPoint center, int radius,
    00311                             double color, int scale CV_DEFAULT(0) );
    00312
    00313 CV_EXPORTS void  cvEllipseAA( CvArr* img, CvPoint center, CvSize axes,
    00314                               double angle, double start_angle,
    00315                               double end_angle, double color,
    00316                               int scale CV_DEFAULT(0) );
    00317
    00318 CV_EXPORTS void  cvPolyLineAA( CvArr* img, CvPoint** pts, int* npts, int contours,
    00319                               int is_closed, double color, int scale CV_DEFAULT(0) );
    00320
    00321 /****************************************************************************************\
    00322 *                                   Pixel Access Macros                                  *
    00323 \****************************************************************************************/
    00324
    00325 typedef struct _CvPixelPosition8u
    00326 {
    00327     uchar*  currline;      /* pointer to the start of the current pixel line   */
    00328     uchar*  topline;       /* pointer to the start of the top pixel line       */
    00329     uchar*  bottomline;    /* pointer to the start of the first line           */
    00330                                     /* which is below the image                         */
    00331     int     x;                      /* current x coordinate ( in pixels )               */
    00332     int     width;                  /* width of the image  ( in pixels )                */
    00333     int     height;                 /* height of the image  ( in pixels )               */
    00334     int     step;                   /* distance between lines ( in elements of single   */
    00335                                     /* plane )                                          */
    00336     int     step_arr[3];            /* array: ( 0, -step, step ). It is used for        */
    00337                                     /* vertical moving                                  */
    00338 } CvPixelPosition8u;
    00339
    00340 /* this structure differs from the above only in data type */
    00341 typedef struct _CvPixelPosition8s
    00342 {
    00343     schar*  currline;
    00344     schar*  topline;
    00345     schar*  bottomline;
    00346     int     x;
    00347     int     width;
    00348     int     height;
    00349     int     step;
    00350     int     step_arr[3];
    00351 } CvPixelPosition8s;
    00352
    00353 /* this structure differs from the CvPixelPosition8u only in data type */
    00354 typedef struct _CvPixelPosition32f
    00355 {
    00356     float*  currline;
    00357     float*  topline;
    00358     float*  bottomline;
    00359     int     x;
    00360     int     width;
    00361     int     height;
    00362     int     step;
    00363     int     step_arr[3];
    00364 } CvPixelPosition32f;
    00365
    00366
    00367 /* Initialize one of the CvPixelPosition structures.   */
    00368 /*  pos    - initialized structure                     */
    00369 /*  origin - pointer to the left-top corner of the ROI */
    00370 /*  step   - width of the whole image in bytes         */
    00371 /*  roi    - width & height of the ROI                 */
    00372 /*  x, y   - initial position                          */
    00373 #define CV_INIT_PIXEL_POS(pos, origin, _step, roi, _x, _y, orientation)    \
    00374     (                                                                        \
    00375     (pos).step = (_step)/sizeof((pos).currline[0]) * (orientation ? -1 : 1), \
    00376     (pos).width = (roi).width,                                               \
    00377     (pos).height = (roi).height,                                             \
    00378     (pos).bottomline = (origin) + (pos).step*(pos).height,                   \
    00379     (pos).topline = (origin) - (pos).step,                                   \
    00380     (pos).step_arr[0] = 0,                                                   \
    00381     (pos).step_arr[1] = -(pos).step,                                         \
    00382     (pos).step_arr[2] = (pos).step,                                          \
    00383     (pos).x = (_x),                                                          \
    00384     (pos).currline = (origin) + (pos).step*(_y) )
    00385
    00386
    00387 /* Move to specified point ( absolute shift ) */
    00388 /*  pos    - position structure               */
    00389 /*  x, y   - coordinates of the new position  */
    00390 /*  cs     - number of the image channels     */
    00391 #define CV_MOVE_TO( pos, _x, _y, cs )                                                   \
    00392 ((pos).currline = (_y) >= 0 && (_y) < (pos).height ? (pos).topline + ((_y)+1)*(pos).step : 0, \
    00393  (pos).x = (_x) >= 0 && (_x) < (pos).width ? (_x) : 0, (pos).currline + (_x) * (cs) )
    00394
    00395 /* Get current coordinates                    */
    00396 /*  pos    - position structure               */
    00397 /*  x, y   - coordinates of the new position  */
    00398 /*  cs     - number of the image channels     */
    00399 #define CV_GET_CURRENT( pos, cs )  ((pos).currline + (pos).x * (cs))
    00400
    00401 /* Move by one pixel relatively to current position */
    00402 /*  pos    - position structure                     */
    00403 /*  cs     - number of the image channels           */
    00404
    00405 /* left */
    00406 #define CV_MOVE_LEFT( pos, cs ) \
    00407  ( --(pos).x >= 0 ? (pos).currline + (pos).x*(cs) : 0 )
    00408
    00409 /* right */
    00410 #define CV_MOVE_RIGHT( pos, cs ) \
    00411  ( ++(pos).x < (pos).width ? (pos).currline + (pos).x*(cs) : 0 )
    00412
    00413 /* up */
    00414 #define CV_MOVE_UP( pos, cs ) \
    00415  (((pos).currline -= (pos).step) != (pos).topline ? (pos).currline + (pos).x*(cs) : 0 )
    00416
    00417 /* down */
    00418 #define CV_MOVE_DOWN( pos, cs ) \
    00419  (((pos).currline += (pos).step) != (pos).bottomline ? (pos).currline + (pos).x*(cs) : 0 )
    00420
    00421 /* left up */
    00422 #define CV_MOVE_LU( pos, cs ) ( CV_MOVE_LEFT(pos, cs), CV_MOVE_UP(pos, cs))
    00423
    00424 /* right up */
    00425 #define CV_MOVE_RU( pos, cs ) ( CV_MOVE_RIGHT(pos, cs), CV_MOVE_UP(pos, cs))
    00426
    00427 /* left down */
    00428 #define CV_MOVE_LD( pos, cs ) ( CV_MOVE_LEFT(pos, cs), CV_MOVE_DOWN(pos, cs))
    00429
    00430 /* right down */
    00431 #define CV_MOVE_RD( pos, cs ) ( CV_MOVE_RIGHT(pos, cs), CV_MOVE_DOWN(pos, cs))
    00432
    00433
    00434
    00435 /* Move by one pixel relatively to current position with wrapping when the position     */
    00436 /* achieves image boundary                                                              */
    00437 /*  pos    - position structure                                                         */
    00438 /*  cs     - number of the image channels                                               */
    00439
    00440 /* left */
    00441 #define CV_MOVE_LEFT_WRAP( pos, cs ) \
    00442  ((pos).currline + ( --(pos).x >= 0 ? (pos).x : ((pos).x = (pos).width-1))*(cs))
    00443
    00444 /* right */
    00445 #define CV_MOVE_RIGHT_WRAP( pos, cs ) \
    00446  ((pos).currline + ( ++(pos).x < (pos).width ? (pos).x : ((pos).x = 0))*(cs) )
    00447
    00448 /* up */
    00449 #define CV_MOVE_UP_WRAP( pos, cs ) \
    00450     ((((pos).currline -= (pos).step) != (pos).topline ? \
    00451     (pos).currline : ((pos).currline = (pos).bottomline - (pos).step)) + (pos).x*(cs) )
    00452
    00453 /* down */
    00454 #define CV_MOVE_DOWN_WRAP( pos, cs ) \
    00455     ((((pos).currline += (pos).step) != (pos).bottomline ? \
    00456     (pos).currline : ((pos).currline = (pos).topline + (pos).step)) + (pos).x*(cs) )
    00457
    00458 /* left up */
    00459 #define CV_MOVE_LU_WRAP( pos, cs ) ( CV_MOVE_LEFT_WRAP(pos, cs), CV_MOVE_UP_WRAP(pos, cs))
    00460 /* right up */
    00461 #define CV_MOVE_RU_WRAP( pos, cs ) ( CV_MOVE_RIGHT_WRAP(pos, cs), CV_MOVE_UP_WRAP(pos, cs))
    00462 /* left down */
    00463 #define CV_MOVE_LD_WRAP( pos, cs ) ( CV_MOVE_LEFT_WRAP(pos, cs), CV_MOVE_DOWN_WRAP(pos, cs))
    00464 /* right down */
    00465 #define CV_MOVE_RD_WRAP( pos, cs ) ( CV_MOVE_RIGHT_WRAP(pos, cs), CV_MOVE_DOWN_WRAP(pos, cs))
    00466
    00467 /* Numeric constants which used for moving in arbitrary direction  */
    00468 enum
    00469 {
    00470     CV_SHIFT_NONE = 2,
    00471     CV_SHIFT_LEFT = 1,
    00472     CV_SHIFT_RIGHT = 3,
    00473     CV_SHIFT_UP = 6,
    00474     CV_SHIFT_DOWN = 10,
    00475     CV_SHIFT_LU = 5,
    00476     CV_SHIFT_RU = 7,
    00477     CV_SHIFT_LD = 9,
    00478     CV_SHIFT_RD = 11
    00479 };
    00480
    00481 /* Move by one pixel in specified direction                                     */
    00482 /*  pos    - position structure                                                 */
    00483 /*  shift  - direction ( it's value must be one of the CV_SHIFT_Ö constants ) */
    00484 /*  cs     - number of the image channels                                       */
    00485 #define CV_MOVE_PARAM( pos, shift, cs )                                             \
    00486     ( (pos).currline += (pos).step_arr[(shift)>>2], (pos).x += ((shift)&3)-2,       \
    00487     ((pos).currline != (pos).topline && (pos).currline != (pos).bottomline &&       \
    00488     (pos).x >= 0 && (pos).x < (pos).width) ? (pos).currline + (pos).x*(cs) : 0 )
    00489
    00490 /* Move by one pixel in specified direction with wrapping when the               */
    00491 /* position achieves image boundary                                              */
    00492 /*  pos    - position structure                                                  */
    00493 /*  shift  - direction ( it's value must be one of the CV_SHIFT_Ö constants )  */
    00494 /*  cs     - number of the image channels                                        */
    00495 #define CV_MOVE_PARAM_WRAP( pos, shift, cs )                                        \
    00496     ( (pos).currline += (pos).step_arr[(shift)>>2],                                 \
    00497     (pos).currline = ((pos).currline == (pos).topline ?                             \
    00498     (pos).bottomline - (pos).step :                                                 \
    00499     (pos).currline == (pos).bottomline ?                                            \
    00500     (pos).topline + (pos).step : (pos).currline),                                   \
    00501                                                                                     \
    00502     (pos).x += ((shift)&3)-2,                                                       \
    00503     (pos).x = ((pos).x < 0 ? (pos).width-1 : (pos).x >= (pos).width ? 0 : (pos).x), \
    00504                                                                                     \
    00505     (pos).currline + (pos).x*(cs) )
    00506
    00507
    00508 typedef float*   CvVect32f;
    00509 typedef float*   CvMatr32f;
    00510 typedef double*  CvVect64d;
    00511 typedef double*  CvMatr64d;
    00512
    00513 CV_EXPORTS void cvUnDistortOnce( const CvArr* src, CvArr* dst,
    00514                                 const float* intrinsic_matrix,
    00515                                 const float* distortion_coeffs,
    00516                                 int interpolate );
    00517
    00518 /* the two functions below have quite hackerish implementations, use with care
    00519    (or, which is better, switch to cvUndistortInitMap and cvRemap instead */
    00520 CV_EXPORTS void cvUnDistortInit( const CvArr* src,
    00521                                 CvArr* undistortion_map,
    00522                                 const float* A, const float* k,
    00523                                 int interpolate );
    00524
    00525 CV_EXPORTS void  cvUnDistort( const CvArr* src, CvArr* dst,
    00526                              const CvArr* undistortion_map,
    00527                              int interpolate );
    00528
    00529 /* Find fundamental matrix */
    00530 CV_EXPORTS void  cvFindFundamentalMatrix( int* points1, int* points2,
    00531     int numpoints, int method, float* matrix );
    00532
    00533
    00534 CV_EXPORTS int cvFindChessBoardCornerGuesses( const void* arr, void* thresharr,
    00535                                CvMemStorage* storage,
    00536                                CvSize pattern_size, CvPoint2D32f * corners,
    00537                                int *corner_count );
    00538
    00539 /* Calibrates camera using multiple views of calibration pattern */
    00540 CV_EXPORTS void cvCalibrateCamera( int image_count, int* _point_counts,
    00541     CvSize image_size, CvPoint2D32f* _image_points, CvPoint3D32f* _object_points,
    00542     float* _distortion_coeffs, float* _camera_matrix, float* _translation_vectors,
    00543     float* _rotation_matrices, int flags );
    00544
    00545
    00546 CV_EXPORTS void cvCalibrateCamera_64d( int image_count, int* _point_counts,
    00547     CvSize image_size, CvPoint2D64f* _image_points, CvPoint3D64f* _object_points,
    00548     double* _distortion_coeffs, double* _camera_matrix, double* _translation_vectors,
    00549     double* _rotation_matrices, int flags );
    00550
    00551
    00552 /* Find 3d position of object given intrinsic camera parameters,
    00553    3d model of the object and projection of the object into view plane */
    00554 CV_EXPORTS void cvFindExtrinsicCameraParams( int point_count,
    00555     CvSize image_size, CvPoint2D32f* _image_points,
    00556     CvPoint3D32f* _object_points, float* focal_length,
    00557     CvPoint2D32f principal_point, float* _distortion_coeffs,
    00558     float* _rotation_vector, float* _translation_vector );
    00559
    00560 /* Variant of the previous function that takes double-precision parameters */
    00561 CV_EXPORTS void cvFindExtrinsicCameraParams_64d( int point_count,
    00562     CvSize image_size, CvPoint2D64f* _image_points,
    00563     CvPoint3D64f* _object_points, double* focal_length,
    00564     CvPoint2D64f principal_point, double* _distortion_coeffs,
    00565     double* _rotation_vector, double* _translation_vector );
    00566
    00567 /* Rodrigues transform */
    00568 enum
    00569 {
    00570     CV_RODRIGUES_M2V = 0,
    00571     CV_RODRIGUES_V2M = 1
    00572 };
    00573
    00574 /* Converts rotation_matrix matrix to rotation_matrix vector or vice versa */
    00575 CV_EXPORTS void  cvRodrigues( CvMat* rotation_matrix, CvMat* rotation_vector,
    00576                               CvMat* jacobian, int conv_type );
    00577
    00578 /* Does reprojection of 3d object points to the view plane */
    00579 CV_EXPORTS void  cvProjectPoints( int point_count, CvPoint3D64f* _object_points,
    00580     double* _rotation_vector, double*  _translation_vector,
    00581     double* focal_length, CvPoint2D64f principal_point,
    00582     double* _distortion, CvPoint2D64f* _image_points,
    00583     double* _deriv_points_rotation_matrix,
    00584     double* _deriv_points_translation_vect,
    00585     double* _deriv_points_focal,
    00586     double* _deriv_points_principal_point,
    00587     double* _deriv_points_distortion_coeffs );
    00588
    00589
    00590 /* Simpler version of the previous function */
    00591 CV_EXPORTS void  cvProjectPointsSimple( int point_count, CvPoint3D64f* _object_points,
    00592     double* _rotation_matrix, double*  _translation_vector,
    00593     double* _camera_matrix, double* _distortion, CvPoint2D64f* _image_points );
    00594
    00595
    00596 #define cvMake2DPoints cvConvertPointsHomogeneous
    00597 #define cvMake3DPoints cvConvertPointsHomogeneous
    00598
    00599 #define cvWarpPerspectiveQMatrix cvGetPerspectiveTransform
    00600
    00601 #define cvConvertPointsHomogenious cvConvertPointsHomogeneous
    00602
    00603
    00604 #ifdef __cplusplus
    00605 }
    00606 #endif
    00607
    00608 #endif

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines