Delphi-OpenCV/source/ocv.compat.pas

// **************************************************************************************************
// Project Delphi-OpenCV
// **************************************************************************************************
// Contributor:
// Laentir Valetov
// email:laex@bk.ru
// Mikhail Grigorev
// email:sleuthound@gmail.com
// **************************************************************************************************
// 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://ocv.org
// Online docs: http://docs.ocv.org
// Q&A forum:   http://answers.ocv.org
// Dev zone:    http://code.ocv.org
// **************************************************************************************************
// Original file:
// opencv\modules\legacy\include\opencv2\legacy\compat.hpp
// *************************************************************************************************

//
{$I OpenCV.inc}
//

{$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 ocv.compat;

interface

uses ocv.core.types_c, ocv.imgproc.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));
  *)
function cvMatArray(rows: Integer; cols: Integer; type_: Integer; count: Integer; data: Pointer = nil): TCvMat; cdecl;

//
// #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));
*)
function cvMean(const image: pCvArr; const mask: pCvArr = nil): double; cdecl;

(*
  CV_EXPORTS double cvSumPixels( const CvArr* image );
*)
function cvSumPixels(const image: pCvArr): double; cdecl;

// 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
type
  // typedef struct CvRandState
  // {
  // CvRNG     state;    /* RNG state (the current seed and carry)*/
  // int       disttype; /* distribution type */
  // CvScalar  param[2]; /* parameters of RNG */
  // } CvRandState;
  pCvRandState = ^TCvRandState;

  TCvRandState = record
    state: TCvRNG; (* RNG state (the current seed and carry) *)
    disttype: Integer; (* distribution type *)
    param: array [0 .. 1] of TCvScalar; (* parameters of RNG *)
  end;

  /// * 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));
  *)
function cvContourBoundingRect(point_set: Pointer; update: Integer = 0): TCvRect; cdecl;

(*
  CV_EXPORTS double cvPseudoInverse( const CvArr* src, CvArr* dst );
*)
function cvPseudoInverse(const src: pCvArr; dst: pCvArr): double; cdecl;

// #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 );
*)
function cvHoughLines(image: pCvArr; rho: double; theta: double; threshold: Integer; lines: pfloat;
  linesNumber: Integer): Integer; cdecl;

(*
  CV_EXPORTS  int  cvHoughLinesP( CvArr* image, double rho,
  double theta, int threshold,
  int lineLength, int lineGap,
  int* lines, int linesNumber );
*)
function cvHoughLinesP(image: pCvArr; rho: double; theta: double; threshold: Integer; lineLength: Integer;
  lineGap: Integer; lines: pInteger; linesNumber: Integer): Integer; cdecl;

(*
  CV_EXPORTS  int  cvHoughLinesSDiv( CvArr* image, double rho, int srn,
  double theta, int stn, int threshold,
  float* lines, int linesNumber );
*)
function cvHoughLinesSDiv(image: pCvArr; rho: double; srn: Integer; theta: double; stn: Integer; threshold: Integer;
  lines: pfloat; linesNumber: Integer): Integer; cdecl;

(*
  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));
*)
function cvCalcEMD(const signature1: pfloat; size1: Integer; const signature2: pfloat; size2: Integer; dims: Integer;
  dist_type: Integer = CV_DIST_L2; dist_func: TCvDistanceFunction = nil; lower_bound: pfloat = nil;
  user_param: Pointer = nil): float; cdecl;

//
// 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 );
  *)
function cvFindChessBoardCornerGuesses(const arr: Pointer; thresharr: Pointer; storage: pCvMemStorage;
  pattern_size: TCvSize; corners: pCvPoint2D32f; corner_count: pInteger): Integer; cdecl;

//
/// * 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 = 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 = 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;

Type
  (*
    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;
  *)
  pCvMSERParams = ^TCvMSERParams;

  TCvMSERParams = record
    // ! delta, in the code, it compares (size_{i}-size_{i-delta})/size_{i-delta}
    delta: Integer;
    // ! prune the area which bigger than maxArea
    maxArea: Integer;
    // ! prune the area which smaller than minArea
    minArea: Integer;
    // ! prune the area have simliar size to its children
    maxVariation: Single;
    // ! trace back to cut off mser with diversity < min_diversity
    minDiversity: Single;
    /// //// the next few params for MSER of color image
    // ! for color image, the evolution steps
    maxEvolution: Integer;
    // ! the area threshold to cause re-initialize
    areaThreshold: double;
    // ! ignore too small margin
    minMargin: double;
    // ! the aperture size for edge blur
    edgeBlurSize: Integer;
  end;

  (*
    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) );
  *)
function cvMSERParams(delta: Integer = 5; min_area: Integer = 60; max_area: Integer = 14400;
  max_variation: float = 0.25; min_diversity: float = 0.2; max_evolution: Integer = 200; area_threshold: double = 1.01;
  min_margin: double = 0.003; edge_blur_size: Integer = 5): TCvMSERParams; cdecl;

/// / 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;
// }
Type
  (* typedef struct CvStarDetectorParams
    {
    int maxSize;
    int responseThreshold;
    int lineThresholdProjected;
    int lineThresholdBinarized;
    int suppressNonmaxSize;
    } CvStarDetectorParams;
  *)

  pCvStarDetectorParams = ^TCvStarDetectorParams;

  TCvStarDetectorParams = record
    maxSize: Integer;
    responseThreshold: Integer;
    lineThresholdProjected: Integer;
    lineThresholdBinarized: Integer;
    suppressNonmaxSize: Integer;
  end;

  (*
    // 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;
    // }
  *)
function cvStarDetectorParams(maxSize: Integer = 45; responseThreshold: Integer = 30;
  lineThresholdProjected: Integer = 10; lineThresholdBinarized: Integer = 8; suppressNonmaxSize: Integer = 5)
  : TCvStarDetectorParams; inline;

(*
  CVAPI(CvSeq* ) cvGetStarKeypoints( const CvArr* img, CvMemStorage* storage,
  CvStarDetectorParams params CV_DEFAULT(cvStarDetectorParams()));
*)
function cvGetStarKeypoints(const img: pCvArr; storage: pCvMemStorage;
  params: TCvStarDetectorParams { = CV_DEFAULT(cvStarDetectorParams()) } ): pCvSeq; cdecl;

implementation

uses ocv.lib;

const
  libname = legacy_lib;


  // function cvSURFParams; external legacy_lib;
  // procedure cvExtractSURF; external legacy_lib;

function cvMatArray; external libname;
function cvMean; external libname;
function cvSumPixels; external libname;
procedure cvMean_StdDev; external libname;
procedure cvmPerspectiveProject; external libname;
procedure cvFillImage; external libname;
procedure cvRandSetRange; external libname;
procedure cvRandInit; external libname;
procedure cvRand; external libname;
procedure cvbRand; external libname;
procedure cvbCartToPolar; external libname;
procedure cvbFastArctan; external libname;
procedure cvbSqrt; external libname;
procedure cvbInvSqrt; external libname;
procedure cvbReciprocal; external libname;
procedure cvbFastExp; external libname;
procedure cvbFastLog; external libname;
function cvContourBoundingRect; external libname;
function cvPseudoInverse; external libname;
procedure cvConvexHull; external libname;
procedure cvMinAreaRect; external libname;
procedure cvFitLine3D; external libname;
procedure cvFitLine2D; external libname;
procedure cvFitEllipse; external libname;
procedure cvProject3D; external libname;
function cvHoughLines; external libname;
function cvHoughLinesP; external libname;
function cvHoughLinesSDiv; external libname;
function cvCalcEMD; external libname;
procedure cvKMeans; external libname;
procedure cvStartScanGraph; external libname;
procedure cvEndScanGraph; external libname;
procedure cvLineAA; external libname;
procedure cvCircleAA; external libname;
procedure cvEllipseAA; external libname;
procedure cvPolyLineAA; external libname;
procedure cvUnDistortOnce; external libname;
procedure cvUnDistortInit; external libname;
procedure cvUnDistort; external libname;
procedure cvFindFundamentalMatrix; external libname;
function cvFindChessBoardCornerGuesses; external libname;
procedure cvCalibrateCamera; external libname;
procedure cvCalibrateCamera_64d; external libname;
procedure cvFindExtrinsicCameraParams; external libname;
procedure cvFindExtrinsicCameraParams_64d; external libname;
procedure cvRodrigues; external libname;
procedure cvProjectPoints; external libname;
procedure cvProjectPointsSimple; external libname;
function cvSURFParams; external libname;
procedure cvExtractSURF; external libname;
function cvMSERParams; external libname;
procedure cvExtractMSER; external libname;
function cvGetStarKeypoints; external libname;

function cvStarDetectorParams(maxSize: Integer = 45; responseThreshold: Integer = 30;
  lineThresholdProjected: Integer = 10; lineThresholdBinarized: Integer = 8; suppressNonmaxSize: Integer = 5)
  : TCvStarDetectorParams; inline;
begin
  Result.maxSize := maxSize;
  Result.responseThreshold := responseThreshold;
  Result.lineThresholdProjected := lineThresholdProjected;
  Result.lineThresholdBinarized := lineThresholdBinarized;
  Result.suppressNonmaxSize := suppressNonmaxSize;
end;

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.