// --------------------------------- OpenCV license.txt ---------------------------
(* //    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.
  //
  //
  //                             License Agreement
  //                  For Open Source Computer Vision Library
  //
  //   Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
  //   Copyright (C) 2009, Willow Garage Inc., 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 the copyright holders 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. *)

(* /  **************************************************************************************************
  //                                 Project Delphi-OpenCV
  //  **************************************************************************************************
  //  Contributor:
  //  laentir Valetov
  //  email:laex@bk.ru
  //  **************************************************************************************************
  //  You may retrieve the latest version of this file at the GitHub,
  //  located at git://github.com/Laex/Delphi-OpenCV.git
  //  **************************************************************************************************
  //  License:
  //  The contents of this file are subject to the Mozilla Public License Version 1.1 (the "License");
  //  you may not use this file except in compliance with the License. You may obtain a copy of the
  //  License at http://www.mozilla.org/MPL/
  //
  //  Software distributed under the License is distributed on an "AS IS" basis, WITHOUT WARRANTY OF
  //  ANY KIND, either express or implied. See the License for the specific language governing rights
  //  and limitations under the License.
  //
  //  Alternatively, the contents of this file may be used under the terms of the
  //  GNU Lesser General Public License (the  "LGPL License"), in which case the
  //  provisions of the LGPL License are applicable instead of those above.
  //  If you wish to allow use of your version of this file only under the terms
  //  of the LGPL License and not to allow others to use your version of this file
  //  under the MPL, indicate your decision by deleting  the provisions above and
  //  replace  them with the notice and other provisions required by the LGPL
  //  License.  If you do not delete the provisions above, a recipient may use
  //  your version of this file under either the MPL or the LGPL License.
  //
  //  For more information about the LGPL: http://www.gnu.org/copyleft/lesser.html
  //  **************************************************************************************************
  //  Warning: Using Delphi XE3 syntax!
  //  **************************************************************************************************
  //  The Initial Developer of the Original Code:
  //  OpenCV: open source computer vision library
  //  Homepage:    http://opencv.org
  //  Online docs: http://docs.opencv.org
  //  Q&A forum:   http://answers.opencv.org
  //  Dev zone:    http://code.opencv.org
  //  **************************************************************************************************
  //  Original file:
  //  opencv\modules\legacy\include\opencv2\legacy\compat.hpp
  //  ************************************************************************************************* *)

{$IFDEF DEBUG}
{$A8,B-,C+,D+,E-,F-,G+,H+,I+,J-,K-,L+,M-,N+,O-,P+,Q+,R+,S-,T-,U-,V+,W+,X+,Y+,Z1}
{$ELSE}
{$A8,B-,C-,D-,E-,F-,G+,H+,I+,J-,K-,L-,M-,N+,O+,P+,Q-,R-,S-,T-,U-,V+,W-,X+,Y-,Z1}
{$ENDIF}
{$WARN SYMBOL_DEPRECATED OFF}
{$WARN SYMBOL_PLATFORM OFF}
{$WARN UNIT_PLATFORM OFF}
{$WARN UNSAFE_TYPE OFF}
{$WARN UNSAFE_CODE OFF}
{$WARN UNSAFE_CAST OFF}
{$POINTERMATH ON}
unit compat;

interface

Uses Core.types_c;

Type
  // typedef int CvMatType;
  TCvMatType = Integer;
  // typedef int CvDisMaskType;
  TCvDisMaskType = Integer;
  // typedef CvMat CvMatArray;
  TCvMatArray = TCvMat;

  // typedef int CvThreshType;
  TCvThreshType = Integer;
  // typedef int CvAdaptiveThreshMethod;
  TCvAdaptiveThreshMethod = Integer;
  // typedef int CvCompareMethod;
  TCvCompareMethod = Integer;
  // typedef int CvFontFace;
  TCvFontFace = Integer;
  // typedef int CvPolyApproxMethod;
  TCvPolyApproxMethod = Integer;
  // typedef int CvContoursMatchMethod;
  TCvContoursMatchMethod = Integer;
  // typedef int CvContourTreesMatchMethod;
  TCvContourTreesMatchMethod = Integer;
  // typedef int CvCoeffType;
  TCvCoeffType = Integer;
  // typedef int CvRodriguesType;
  TCvRodriguesType = Integer;
  // typedef int CvElementShape;
  TCvElementShape = Integer;
  // typedef int CvMorphOp;
  TCvMorphOp = Integer;
  // typedef int CvTemplMatchMethod;
  TCvTemplMatchMethod = Integer;

  // typedef CvPoint2D64f CvPoint2D64d;
  TCvPoint2D64d = TCvPoint2D64f;
  // typedef CvPoint3D64f CvPoint3D64d;
  TCvPoint3D64d = TCvPoint3D64f;

Var
  // Assigning values t​othe constants has been moved to the section of the module initialization
  CV_MAT32F: Integer; // = CV_32FC1;
  CV_MAT3x1_32F: Integer; // = CV_32FC1;
  CV_MAT4x1_32F: Integer; // = CV_32FC1;
  CV_MAT3x3_32F: Integer; // = CV_32FC1;
  CV_MAT4x4_32F: Integer; // = CV_32FC1;

  CV_MAT64D: Integer; // = CV_64FC1;
  CV_MAT3x1_64D: Integer; // = CV_64FC1;
  CV_MAT4x1_64D: Integer; // = CV_64FC1;
  CV_MAT3x3_64D: Integer; // = CV_64FC1;
  CV_MAT4x4_64D: Integer; // = CV_64FC1;

Const
  IPL_GAUSSIAN_5x5 = 7;

Type
  // typedef CvBox2D  CvBox2D32f;
  TCvBox2D32f = TCvBox2D;

  //
  /// * 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  CV_NOOP
  // #define cvSetMemoryManager     CV_NOOP
  //
  // #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) )
  //
Type
  // typedef float*   CvVect32f;
  TCvVect32f = pSingle;
  // typedef float*   CvMatr32f;
  TCvMatr32f = pSingle;
  // typedef double*  CvVect64d;
  TCvVect64d = PDouble;
  // typedef double*  CvMatr64d;
  TCvMatr64d = PDouble;
  //
  // 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 //////////////////////////////////

type
  pCvSURFPoint = ^TCvSURFPoint;

  TCvSURFPoint = packed record
    pt: TCvPoint2D32f;
    laplacian: Integer;
    size: Integer;
    dir: Single;
    hessian: Single;
  end;

  //
  // 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;
  // }
type
  pCvSURFParams = ^TCvSURFParams;

  TCvSURFParams = packed record
    extended: Integer;
    upright: Integer;
    hessianThreshold: double;

    nOctaves: Integer;
    nOctaveLayers: Integer;
  end;

  // CVAPI(CvSURFParams) cvSURFParams( double hessianThreshold, int extended CV_DEFAULT(0) );
function cvSURFParams(hessianThreshold: double; _extended: Integer = 0): TCvSURFParams; cdecl;

/// / 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)  );
procedure cvExtractSURF(const img: pCvArr; const mask: pCvArr; keypoints: ppCvSeq; descriptors: ppCvSeq;
  storage: pCvMemStorage; params: TCvSURFParams; useProvidedKeyPts: Integer = 0); cdecl;

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

implementation

Uses uLibName;

function cvSURFParams; external legacy_dll;
procedure cvExtractSURF; external legacy_dll;

initialization

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;

finalization

end.