sci2c arduino updated

1 files changed, 740 insertions, 0 deletions

diff --git a/thirdparty/includes/OpenCV/opencv2/legacy/compat.hpp b/thirdparty/includes/OpenCV/opencv2/legacy/compat.hpp
new file mode 100644
index 0000000..5b5495e
--- /dev/null
+++ b/thirdparty/includes/OpenCV/opencv2/legacy/compat.hpp
@@ -0,0 +1,740 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                        Intel License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright( C) 2000, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+//(including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort(including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+/*
+   A few macros and definitions for backward compatibility
+   with the previous versions of OpenCV. They are obsolete and
+   are likely to be removed in future. To check whether your code
+   uses any of these, define CV_NO_BACKWARD_COMPATIBILITY before
+   including cv.h.
+*/
+
+#ifndef __OPENCV_COMPAT_HPP__
+#define __OPENCV_COMPAT_HPP__
+
+#include "opencv2/core/core_c.h"
+#include "opencv2/imgproc/types_c.h"
+
+#include <math.h>
+#include <string.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef int CvMatType;
+typedef int CvDisMaskType;
+typedef CvMat CvMatArray;
+
+typedef int CvThreshType;
+typedef int CvAdaptiveThreshMethod;
+typedef int CvCompareMethod;
+typedef int CvFontFace;
+typedef int CvPolyApproxMethod;
+typedef int CvContoursMatchMethod;
+typedef int CvContourTreesMatchMethod;
+typedef int CvCoeffType;
+typedef int CvRodriguesType;
+typedef int CvElementShape;
+typedef int CvMorphOp;
+typedef int CvTemplMatchMethod;
+
+typedef CvPoint2D64f CvPoint2D64d;
+typedef CvPoint3D64f CvPoint3D64d;
+
+enum
+{
+    CV_MAT32F      = CV_32FC1,
+    CV_MAT3x1_32F  = CV_32FC1,
+    CV_MAT4x1_32F  = CV_32FC1,
+    CV_MAT3x3_32F  = CV_32FC1,
+    CV_MAT4x4_32F  = CV_32FC1,
+
+    CV_MAT64D      = CV_64FC1,
+    CV_MAT3x1_64D  = CV_64FC1,
+    CV_MAT4x1_64D  = CV_64FC1,
+    CV_MAT3x3_64D  = CV_64FC1,
+    CV_MAT4x4_64D  = CV_64FC1
+};
+
+enum
+{
+    IPL_GAUSSIAN_5x5 = 7
+};
+
+typedef CvBox2D  CvBox2D32f;
+
+/* allocation/deallocation macros */
+#define cvCreateImageData   cvCreateData
+#define cvReleaseImageData  cvReleaseData
+#define cvSetImageData      cvSetData
+#define cvGetImageRawData   cvGetRawData
+
+#define cvmAlloc            cvCreateData
+#define cvmFree             cvReleaseData
+#define cvmAllocArray       cvCreateData
+#define cvmFreeArray        cvReleaseData
+
+#define cvIntegralImage     cvIntegral
+#define cvMatchContours     cvMatchShapes
+
+CV_EXPORTS CvMat cvMatArray( int rows, int cols, int type,
+                            int count, void* data CV_DEFAULT(0));
+
+#define cvUpdateMHIByTime  cvUpdateMotionHistory
+
+#define cvAccMask cvAcc
+#define cvSquareAccMask cvSquareAcc
+#define cvMultiplyAccMask cvMultiplyAcc
+#define cvRunningAvgMask(imgY, imgU, mask, alpha) cvRunningAvg(imgY, imgU, alpha, mask)
+
+#define cvSetHistThresh  cvSetHistBinRanges
+#define cvCalcHistMask(img, mask, hist, doNotClear) cvCalcHist(img, hist, doNotClear, mask)
+
+CV_EXPORTS double cvMean( const CvArr* image, const CvArr* mask CV_DEFAULT(0));
+CV_EXPORTS double cvSumPixels( const CvArr* image );
+CV_EXPORTS void  cvMean_StdDev( const CvArr* image, double* mean, double* sdv,
+                                const CvArr* mask CV_DEFAULT(0));
+
+CV_EXPORTS void cvmPerspectiveProject( const CvMat* mat, const CvArr* src, CvArr* dst );
+CV_EXPORTS void cvFillImage( CvArr* mat, double color );
+
+#define cvCvtPixToPlane cvSplit
+#define cvCvtPlaneToPix cvMerge
+
+typedef struct CvRandState
+{
+    CvRNG     state;    /* RNG state (the current seed and carry)*/
+    int       disttype; /* distribution type */
+    CvScalar  param[2]; /* parameters of RNG */
+} CvRandState;
+
+/* Changes RNG range while preserving RNG state */
+CV_EXPORTS void  cvRandSetRange( CvRandState* state, double param1,
+                                 double param2, int index CV_DEFAULT(-1));
+
+CV_EXPORTS void  cvRandInit( CvRandState* state, double param1,
+                             double param2, int seed,
+                             int disttype CV_DEFAULT(CV_RAND_UNI));
+
+/* Fills array with random numbers */
+CV_EXPORTS void cvRand( CvRandState* state, CvArr* arr );
+
+#define cvRandNext( _state ) cvRandInt( &(_state)->state )
+
+CV_EXPORTS void cvbRand( CvRandState* state, float* dst, int len );
+
+CV_EXPORTS void  cvbCartToPolar( const float* y, const float* x,
+                                 float* magnitude, float* angle, int len );
+CV_EXPORTS void  cvbFastArctan( const float* y, const float* x, float* angle, int len );
+CV_EXPORTS void  cvbSqrt( const float* x, float* y, int len );
+CV_EXPORTS void  cvbInvSqrt( const float* x, float* y, int len );
+CV_EXPORTS void  cvbReciprocal( const float* x, float* y, int len );
+CV_EXPORTS void  cvbFastExp( const float* x, double* y, int len );
+CV_EXPORTS void  cvbFastLog( const double* x, float* y, int len );
+
+CV_EXPORTS CvRect  cvContourBoundingRect( void* point_set, int update CV_DEFAULT(0));
+
+CV_EXPORTS double cvPseudoInverse( const CvArr* src, CvArr* dst );
+#define cvPseudoInv cvPseudoInverse
+
+#define cvContourMoments( contour, moments ) cvMoments( contour, moments, 0 )
+
+#define cvGetPtrAt              cvPtr2D
+#define cvGetAt                 cvGet2D
+#define cvSetAt(arr,val,y,x)    cvSet2D((arr),(y),(x),(val))
+
+#define cvMeanMask  cvMean
+#define cvMean_StdDevMask(img,mask,mean,sdv) cvMean_StdDev(img,mean,sdv,mask)
+
+#define cvNormMask(imgA,imgB,mask,normType) cvNorm(imgA,imgB,normType,mask)
+
+#define cvMinMaxLocMask(img, mask, min_val, max_val, min_loc, max_loc) \
+        cvMinMaxLoc(img, min_val, max_val, min_loc, max_loc, mask)
+
+#define cvRemoveMemoryManager  cvSetMemoryManager
+
+#define cvmSetZero( mat )               cvSetZero( mat )
+#define cvmSetIdentity( mat )           cvSetIdentity( mat )
+#define cvmAdd( src1, src2, dst )       cvAdd( src1, src2, dst, 0 )
+#define cvmSub( src1, src2, dst )       cvSub( src1, src2, dst, 0 )
+#define cvmCopy( src, dst )             cvCopy( src, dst, 0 )
+#define cvmMul( src1, src2, dst )       cvMatMulAdd( src1, src2, 0, dst )
+#define cvmTranspose( src, dst )        cvT( src, dst )
+#define cvmInvert( src, dst )           cvInv( src, dst )
+#define cvmMahalanobis(vec1, vec2, mat) cvMahalanobis( vec1, vec2, mat )
+#define cvmDotProduct( vec1, vec2 )     cvDotProduct( vec1, vec2 )
+#define cvmCrossProduct(vec1, vec2,dst) cvCrossProduct( vec1, vec2, dst )
+#define cvmTrace( mat )                 (cvTrace( mat )).val[0]
+#define cvmMulTransposed( src, dst, order ) cvMulTransposed( src, dst, order )
+#define cvmEigenVV( mat, evec, eval, eps)   cvEigenVV( mat, evec, eval, eps )
+#define cvmDet( mat )                   cvDet( mat )
+#define cvmScale( src, dst, scale )     cvScale( src, dst, scale )
+
+#define cvCopyImage( src, dst )         cvCopy( src, dst, 0 )
+#define cvReleaseMatHeader              cvReleaseMat
+
+/* Calculates exact convex hull of 2d point set */
+CV_EXPORTS void cvConvexHull( CvPoint* points, int num_points,
+                             CvRect* bound_rect,
+                             int orientation, int* hull, int* hullsize );
+
+
+CV_EXPORTS void cvMinAreaRect( CvPoint* points, int n,
+                              int left, int bottom,
+                              int right, int top,
+                              CvPoint2D32f* anchor,
+                              CvPoint2D32f* vect1,
+                              CvPoint2D32f* vect2 );
+
+typedef int CvDisType;
+typedef int CvChainApproxMethod;
+typedef int CvContourRetrievalMode;
+
+CV_EXPORTS  void  cvFitLine3D( CvPoint3D32f* points, int count, int dist,
+                    void *param, float reps, float aeps, float* line );
+
+/* Fits a line into set of 2d points in a robust way (M-estimator technique) */
+CV_EXPORTS  void  cvFitLine2D( CvPoint2D32f* points, int count, int dist,
+                    void *param, float reps, float aeps, float* line );
+
+CV_EXPORTS  void  cvFitEllipse( const CvPoint2D32f* points, int count, CvBox2D* box );
+
+/* Projects 2d points to one of standard coordinate planes
+   (i.e. removes one of coordinates) */
+CV_EXPORTS  void  cvProject3D( CvPoint3D32f* points3D, int count,
+                              CvPoint2D32f* points2D,
+                              int xIndx CV_DEFAULT(0),
+                              int yIndx CV_DEFAULT(1));
+
+/* Retrieves value of the particular bin
+   of x-dimensional (x=1,2,3,...) histogram */
+#define cvQueryHistValue_1D( hist, idx0 ) \
+    ((float)cvGetReal1D( (hist)->bins, (idx0)))
+#define cvQueryHistValue_2D( hist, idx0, idx1 ) \
+    ((float)cvGetReal2D( (hist)->bins, (idx0), (idx1)))
+#define cvQueryHistValue_3D( hist, idx0, idx1, idx2 ) \
+    ((float)cvGetReal3D( (hist)->bins, (idx0), (idx1), (idx2)))
+#define cvQueryHistValue_nD( hist, idx ) \
+    ((float)cvGetRealND( (hist)->bins, (idx)))
+
+/* Returns pointer to the particular bin of x-dimesional histogram.
+   For sparse histogram the bin is created if it didn't exist before */
+#define cvGetHistValue_1D( hist, idx0 ) \
+    ((float*)cvPtr1D( (hist)->bins, (idx0), 0))
+#define cvGetHistValue_2D( hist, idx0, idx1 ) \
+    ((float*)cvPtr2D( (hist)->bins, (idx0), (idx1), 0))
+#define cvGetHistValue_3D( hist, idx0, idx1, idx2 ) \
+    ((float*)cvPtr3D( (hist)->bins, (idx0), (idx1), (idx2), 0))
+#define cvGetHistValue_nD( hist, idx ) \
+    ((float*)cvPtrND( (hist)->bins, (idx), 0))
+
+
+#define CV_IS_SET_ELEM_EXISTS CV_IS_SET_ELEM
+
+
+CV_EXPORTS  int  cvHoughLines( CvArr* image, double rho,
+                              double theta, int threshold,
+                              float* lines, int linesNumber );
+
+CV_EXPORTS  int  cvHoughLinesP( CvArr* image, double rho,
+                               double theta, int threshold,
+                               int lineLength, int lineGap,
+                               int* lines, int linesNumber );
+
+
+CV_EXPORTS  int  cvHoughLinesSDiv( CvArr* image, double rho, int srn,
+                                  double theta, int stn, int threshold,
+                                  float* lines, int linesNumber );
+
+CV_EXPORTS  float  cvCalcEMD( const float* signature1, int size1,
+                             const float* signature2, int size2,
+                             int dims, int dist_type CV_DEFAULT(CV_DIST_L2),
+                             CvDistanceFunction dist_func CV_DEFAULT(0),
+                             float* lower_bound CV_DEFAULT(0),
+                             void* user_param CV_DEFAULT(0));
+
+CV_EXPORTS  void  cvKMeans( int num_clusters, float** samples,
+                           int num_samples, int vec_size,
+                           CvTermCriteria termcrit, int* cluster_idx );
+
+CV_EXPORTS void  cvStartScanGraph( CvGraph* graph, CvGraphScanner* scanner,
+                                  CvGraphVtx* vtx CV_DEFAULT(NULL),
+                                  int mask CV_DEFAULT(CV_GRAPH_ALL_ITEMS));
+
+CV_EXPORTS  void  cvEndScanGraph( CvGraphScanner* scanner );
+
+
+/* old drawing functions */
+CV_EXPORTS void  cvLineAA( CvArr* img, CvPoint pt1, CvPoint pt2,
+                            double color, int scale CV_DEFAULT(0));
+
+CV_EXPORTS void  cvCircleAA( CvArr* img, CvPoint center, int radius,
+                            double color, int scale CV_DEFAULT(0) );
+
+CV_EXPORTS void  cvEllipseAA( CvArr* img, CvPoint center, CvSize axes,
+                              double angle, double start_angle,
+                              double end_angle, double color,
+                              int scale CV_DEFAULT(0) );
+
+CV_EXPORTS void  cvPolyLineAA( CvArr* img, CvPoint** pts, int* npts, int contours,
+                              int is_closed, double color, int scale CV_DEFAULT(0) );
+
+/****************************************************************************************\
+*                                   Pixel Access Macros                                  *
+\****************************************************************************************/
+
+typedef struct _CvPixelPosition8u
+{
+    uchar*  currline;      /* pointer to the start of the current pixel line   */
+    uchar*  topline;       /* pointer to the start of the top pixel line       */
+    uchar*  bottomline;    /* pointer to the start of the first line           */
+                                    /* which is below the image                         */
+    int     x;                      /* current x coordinate ( in pixels )               */
+    int     width;                  /* width of the image  ( in pixels )                */
+    int     height;                 /* height of the image  ( in pixels )               */
+    int     step;                   /* distance between lines ( in elements of single   */
+                                    /* plane )                                          */
+    int     step_arr[3];            /* array: ( 0, -step, step ). It is used for        */
+                                    /* vertical moving                                  */
+} CvPixelPosition8u;
+
+/* this structure differs from the above only in data type */
+typedef struct _CvPixelPosition8s
+{
+    schar*  currline;
+    schar*  topline;
+    schar*  bottomline;
+    int     x;
+    int     width;
+    int     height;
+    int     step;
+    int     step_arr[3];
+} CvPixelPosition8s;
+
+/* this structure differs from the CvPixelPosition8u only in data type */
+typedef struct _CvPixelPosition32f
+{
+    float*  currline;
+    float*  topline;
+    float*  bottomline;
+    int     x;
+    int     width;
+    int     height;
+    int     step;
+    int     step_arr[3];
+} CvPixelPosition32f;
+
+
+/* Initialize one of the CvPixelPosition structures.   */
+/*  pos    - initialized structure                     */
+/*  origin - pointer to the left-top corner of the ROI */
+/*  step   - width of the whole image in bytes         */
+/*  roi    - width & height of the ROI                 */
+/*  x, y   - initial position                          */
+#define CV_INIT_PIXEL_POS(pos, origin, _step, roi, _x, _y, orientation)    \
+    (                                                                        \
+    (pos).step = (_step)/sizeof((pos).currline[0]) * (orientation ? -1 : 1), \
+    (pos).width = (roi).width,                                               \
+    (pos).height = (roi).height,                                             \
+    (pos).bottomline = (origin) + (pos).step*(pos).height,                   \
+    (pos).topline = (origin) - (pos).step,                                   \
+    (pos).step_arr[0] = 0,                                                   \
+    (pos).step_arr[1] = -(pos).step,                                         \
+    (pos).step_arr[2] = (pos).step,                                          \
+    (pos).x = (_x),                                                          \
+    (pos).currline = (origin) + (pos).step*(_y) )
+
+
+/* Move to specified point ( absolute shift ) */
+/*  pos    - position structure               */
+/*  x, y   - coordinates of the new position  */
+/*  cs     - number of the image channels     */
+#define CV_MOVE_TO( pos, _x, _y, cs )                                                   \
+((pos).currline = (_y) >= 0 && (_y) < (pos).height ? (pos).topline + ((_y)+1)*(pos).step : 0, \
+ (pos).x = (_x) >= 0 && (_x) < (pos).width ? (_x) : 0, (pos).currline + (_x) * (cs) )
+
+/* Get current coordinates                    */
+/*  pos    - position structure               */
+/*  x, y   - coordinates of the new position  */
+/*  cs     - number of the image channels     */
+#define CV_GET_CURRENT( pos, cs )  ((pos).currline + (pos).x * (cs))
+
+/* Move by one pixel relatively to current position */
+/*  pos    - position structure                     */
+/*  cs     - number of the image channels           */
+
+/* left */
+#define CV_MOVE_LEFT( pos, cs ) \
+ ( --(pos).x >= 0 ? (pos).currline + (pos).x*(cs) : 0 )
+
+/* right */
+#define CV_MOVE_RIGHT( pos, cs ) \
+ ( ++(pos).x < (pos).width ? (pos).currline + (pos).x*(cs) : 0 )
+
+/* up */
+#define CV_MOVE_UP( pos, cs ) \
+ (((pos).currline -= (pos).step) != (pos).topline ? (pos).currline + (pos).x*(cs) : 0 )
+
+/* down */
+#define CV_MOVE_DOWN( pos, cs ) \
+ (((pos).currline += (pos).step) != (pos).bottomline ? (pos).currline + (pos).x*(cs) : 0 )
+
+/* left up */
+#define CV_MOVE_LU( pos, cs ) ( CV_MOVE_LEFT(pos, cs), CV_MOVE_UP(pos, cs))
+
+/* right up */
+#define CV_MOVE_RU( pos, cs ) ( CV_MOVE_RIGHT(pos, cs), CV_MOVE_UP(pos, cs))
+
+/* left down */
+#define CV_MOVE_LD( pos, cs ) ( CV_MOVE_LEFT(pos, cs), CV_MOVE_DOWN(pos, cs))
+
+/* right down */
+#define CV_MOVE_RD( pos, cs ) ( CV_MOVE_RIGHT(pos, cs), CV_MOVE_DOWN(pos, cs))
+
+
+
+/* Move by one pixel relatively to current position with wrapping when the position     */
+/* achieves image boundary                                                              */
+/*  pos    - position structure                                                         */
+/*  cs     - number of the image channels                                               */
+
+/* left */
+#define CV_MOVE_LEFT_WRAP( pos, cs ) \
+ ((pos).currline + ( --(pos).x >= 0 ? (pos).x : ((pos).x = (pos).width-1))*(cs))
+
+/* right */
+#define CV_MOVE_RIGHT_WRAP( pos, cs ) \
+ ((pos).currline + ( ++(pos).x < (pos).width ? (pos).x : ((pos).x = 0))*(cs) )
+
+/* up */
+#define CV_MOVE_UP_WRAP( pos, cs ) \
+    ((((pos).currline -= (pos).step) != (pos).topline ? \
+    (pos).currline : ((pos).currline = (pos).bottomline - (pos).step)) + (pos).x*(cs) )
+
+/* down */
+#define CV_MOVE_DOWN_WRAP( pos, cs ) \
+    ((((pos).currline += (pos).step) != (pos).bottomline ? \
+    (pos).currline : ((pos).currline = (pos).topline + (pos).step)) + (pos).x*(cs) )
+
+/* left up */
+#define CV_MOVE_LU_WRAP( pos, cs ) ( CV_MOVE_LEFT_WRAP(pos, cs), CV_MOVE_UP_WRAP(pos, cs))
+/* right up */
+#define CV_MOVE_RU_WRAP( pos, cs ) ( CV_MOVE_RIGHT_WRAP(pos, cs), CV_MOVE_UP_WRAP(pos, cs))
+/* left down */
+#define CV_MOVE_LD_WRAP( pos, cs ) ( CV_MOVE_LEFT_WRAP(pos, cs), CV_MOVE_DOWN_WRAP(pos, cs))
+/* right down */
+#define CV_MOVE_RD_WRAP( pos, cs ) ( CV_MOVE_RIGHT_WRAP(pos, cs), CV_MOVE_DOWN_WRAP(pos, cs))
+
+/* Numeric constants which used for moving in arbitrary direction  */
+enum
+{
+    CV_SHIFT_NONE = 2,
+    CV_SHIFT_LEFT = 1,
+    CV_SHIFT_RIGHT = 3,
+    CV_SHIFT_UP = 6,
+    CV_SHIFT_DOWN = 10,
+    CV_SHIFT_LU = 5,
+    CV_SHIFT_RU = 7,
+    CV_SHIFT_LD = 9,
+    CV_SHIFT_RD = 11
+};
+
+/* Move by one pixel in specified direction                                     */
+/*  pos    - position structure                                                 */
+/*  shift  - direction ( it's value must be one of the CV_SHIFT_Ö constants ) */
+/*  cs     - number of the image channels                                       */
+#define CV_MOVE_PARAM( pos, shift, cs )                                             \
+    ( (pos).currline += (pos).step_arr[(shift)>>2], (pos).x += ((shift)&3)-2,       \
+    ((pos).currline != (pos).topline && (pos).currline != (pos).bottomline &&       \
+    (pos).x >= 0 && (pos).x < (pos).width) ? (pos).currline + (pos).x*(cs) : 0 )
+
+/* Move by one pixel in specified direction with wrapping when the               */
+/* position achieves image boundary                                              */
+/*  pos    - position structure                                                  */
+/*  shift  - direction ( it's value must be one of the CV_SHIFT_Ö constants )  */
+/*  cs     - number of the image channels                                        */
+#define CV_MOVE_PARAM_WRAP( pos, shift, cs )                                        \
+    ( (pos).currline += (pos).step_arr[(shift)>>2],                                 \
+    (pos).currline = ((pos).currline == (pos).topline ?                             \
+    (pos).bottomline - (pos).step :                                                 \
+    (pos).currline == (pos).bottomline ?                                            \
+    (pos).topline + (pos).step : (pos).currline),                                   \
+                                                                                    \
+    (pos).x += ((shift)&3)-2,                                                       \
+    (pos).x = ((pos).x < 0 ? (pos).width-1 : (pos).x >= (pos).width ? 0 : (pos).x), \
+                                                                                    \
+    (pos).currline + (pos).x*(cs) )
+
+
+typedef float*   CvVect32f;
+typedef float*   CvMatr32f;
+typedef double*  CvVect64d;
+typedef double*  CvMatr64d;
+
+CV_EXPORTS void cvUnDistortOnce( const CvArr* src, CvArr* dst,
+                                const float* intrinsic_matrix,
+                                const float* distortion_coeffs,
+                                int interpolate );
+
+/* the two functions below have quite hackerish implementations, use with care
+   (or, which is better, switch to cvUndistortInitMap and cvRemap instead */
+CV_EXPORTS void cvUnDistortInit( const CvArr* src,
+                                CvArr* undistortion_map,
+                                const float* A, const float* k,
+                                int interpolate );
+
+CV_EXPORTS void  cvUnDistort( const CvArr* src, CvArr* dst,
+                             const CvArr* undistortion_map,
+                             int interpolate );
+
+/* Find fundamental matrix */
+CV_EXPORTS void  cvFindFundamentalMatrix( int* points1, int* points2,
+    int numpoints, int method, float* matrix );
+
+
+CV_EXPORTS int cvFindChessBoardCornerGuesses( const void* arr, void* thresharr,
+                               CvMemStorage* storage,
+                               CvSize pattern_size, CvPoint2D32f * corners,
+                               int *corner_count );
+
+/* Calibrates camera using multiple views of calibration pattern */
+CV_EXPORTS void 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 );
+
+
+CV_EXPORTS void 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 );
+
+
+/* Find 3d position of object given intrinsic camera parameters,
+   3d model of the object and projection of the object into view plane */
+CV_EXPORTS void cvFindExtrinsicCameraParams( int point_count,
+    CvSize image_size, CvPoint2D32f* _image_points,
+    CvPoint3D32f* _object_points, float* focal_length,
+    CvPoint2D32f principal_point, float* _distortion_coeffs,
+    float* _rotation_vector, float* _translation_vector );
+
+/* Variant of the previous function that takes double-precision parameters */
+CV_EXPORTS void cvFindExtrinsicCameraParams_64d( int point_count,
+    CvSize image_size, CvPoint2D64f* _image_points,
+    CvPoint3D64f* _object_points, double* focal_length,
+    CvPoint2D64f principal_point, double* _distortion_coeffs,
+    double* _rotation_vector, double* _translation_vector );
+
+/* Rodrigues transform */
+enum
+{
+    CV_RODRIGUES_M2V = 0,
+    CV_RODRIGUES_V2M = 1
+};
+
+/* Converts rotation_matrix matrix to rotation_matrix vector or vice versa */
+CV_EXPORTS void  cvRodrigues( CvMat* rotation_matrix, CvMat* rotation_vector,
+                              CvMat* jacobian, int conv_type );
+
+/* Does reprojection of 3d object points to the view plane */
+CV_EXPORTS void  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 );
+
+
+/* Simpler version of the previous function */
+CV_EXPORTS void  cvProjectPointsSimple( int point_count, CvPoint3D64f* _object_points,
+    double* _rotation_matrix, double*  _translation_vector,
+    double* _camera_matrix, double* _distortion, CvPoint2D64f* _image_points );
+
+
+#define cvMake2DPoints cvConvertPointsHomogeneous
+#define cvMake3DPoints cvConvertPointsHomogeneous
+
+#define cvWarpPerspectiveQMatrix cvGetPerspectiveTransform
+
+#define cvConvertPointsHomogenious cvConvertPointsHomogeneous
+
+
+//////////////////////////////////// feature extractors: obsolete API //////////////////////////////////
+
+typedef struct CvSURFPoint
+{
+    CvPoint2D32f pt;
+
+    int          laplacian;
+    int          size;
+    float        dir;
+    float        hessian;
+
+} CvSURFPoint;
+
+CV_INLINE CvSURFPoint cvSURFPoint( CvPoint2D32f pt, int laplacian,
+                                  int size, float dir CV_DEFAULT(0),
+                                  float hessian CV_DEFAULT(0))
+{
+    CvSURFPoint kp;
+
+    kp.pt        = pt;
+    kp.laplacian = laplacian;
+    kp.size      = size;
+    kp.dir       = dir;
+    kp.hessian   = hessian;
+
+    return kp;
+}
+
+typedef struct CvSURFParams
+{
+    int    extended;
+    int    upright;
+    double hessianThreshold;
+
+    int    nOctaves;
+    int    nOctaveLayers;
+
+} CvSURFParams;
+
+CVAPI(CvSURFParams) cvSURFParams( double hessianThreshold, int extended CV_DEFAULT(0) );
+
+// If useProvidedKeyPts!=0, keypoints are not detected, but descriptors are computed
+//  at the locations provided in keypoints (a CvSeq of CvSURFPoint).
+CVAPI(void) cvExtractSURF( const CvArr* img, const CvArr* mask,
+                          CvSeq** keypoints, CvSeq** descriptors,
+                          CvMemStorage* storage, CvSURFParams params,
+                             int useProvidedKeyPts CV_DEFAULT(0)  );
+
+/*!
+ Maximal Stable Regions Parameters
+ */
+typedef struct CvMSERParams
+{
+    //! delta, in the code, it compares (size_{i}-size_{i-delta})/size_{i-delta}
+    int delta;
+    //! prune the area which bigger than maxArea
+    int maxArea;
+    //! prune the area which smaller than minArea
+    int minArea;
+    //! prune the area have simliar size to its children
+    float maxVariation;
+    //! trace back to cut off mser with diversity < min_diversity
+    float minDiversity;
+
+    /////// the next few params for MSER of color image
+
+    //! for color image, the evolution steps
+    int maxEvolution;
+    //! the area threshold to cause re-initialize
+    double areaThreshold;
+    //! ignore too small margin
+    double minMargin;
+    //! the aperture size for edge blur
+    int edgeBlurSize;
+} CvMSERParams;
+
+CVAPI(CvMSERParams) cvMSERParams( int delta CV_DEFAULT(5), int min_area CV_DEFAULT(60),
+                                 int max_area CV_DEFAULT(14400), float max_variation CV_DEFAULT(.25f),
+                                 float min_diversity CV_DEFAULT(.2f), int max_evolution CV_DEFAULT(200),
+                                 double area_threshold CV_DEFAULT(1.01),
+                                 double min_margin CV_DEFAULT(.003),
+                                 int edge_blur_size CV_DEFAULT(5) );
+
+// Extracts the contours of Maximally Stable Extremal Regions
+CVAPI(void) cvExtractMSER( CvArr* _img, CvArr* _mask, CvSeq** contours, CvMemStorage* storage, CvMSERParams params );
+
+
+typedef struct CvStarKeypoint
+{
+    CvPoint pt;
+    int size;
+    float response;
+} CvStarKeypoint;
+
+CV_INLINE CvStarKeypoint cvStarKeypoint(CvPoint pt, int size, float response)
+{
+    CvStarKeypoint kpt;
+    kpt.pt = pt;
+    kpt.size = size;
+    kpt.response = response;
+    return kpt;
+}
+
+typedef struct CvStarDetectorParams
+{
+    int maxSize;
+    int responseThreshold;
+    int lineThresholdProjected;
+    int lineThresholdBinarized;
+    int suppressNonmaxSize;
+} CvStarDetectorParams;
+
+CV_INLINE CvStarDetectorParams cvStarDetectorParams(
+                                                    int maxSize CV_DEFAULT(45),
+                                                    int responseThreshold CV_DEFAULT(30),
+                                                    int lineThresholdProjected CV_DEFAULT(10),
+                                                    int lineThresholdBinarized CV_DEFAULT(8),
+                                                    int suppressNonmaxSize CV_DEFAULT(5))
+{
+    CvStarDetectorParams params;
+    params.maxSize = maxSize;
+    params.responseThreshold = responseThreshold;
+    params.lineThresholdProjected = lineThresholdProjected;
+    params.lineThresholdBinarized = lineThresholdBinarized;
+    params.suppressNonmaxSize = suppressNonmaxSize;
+
+    return params;
+}
+
+CVAPI(CvSeq*) cvGetStarKeypoints( const CvArr* img, CvMemStorage* storage,
+                                 CvStarDetectorParams params CV_DEFAULT(cvStarDetectorParams()));
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif