mirror of
https://github.com/Laex/Delphi-OpenCV.git
synced 2024-11-15 15:55:53 +01:00
1707 lines
61 KiB
ObjectPascal
1707 lines
61 KiB
ObjectPascal
(*
|
||
**************************************************************************************************
|
||
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
|
||
*************************************************************************************************
|
||
*)
|
||
|
||
unit ocv.compat;
|
||
|
||
{$I OpenCV.inc}
|
||
|
||
interface
|
||
|
||
uses
|
||
ocv.core.types_c,
|
||
ocv.imgproc.types_c,
|
||
ocv.core_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 tothe 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));
|
||
*)
|
||
{$IFDEF SAFELOADLIB}
|
||
|
||
type
|
||
TcvMatArray_fun = function(rows: Integer; cols: Integer; type_: Integer; count: Integer; data: Pointer = nil): TCvMat; cdecl;
|
||
|
||
Var
|
||
cvMatArray: TcvMatArray_fun;
|
||
{$ELSE}
|
||
function cvMatArray(rows: Integer; cols: Integer; type_: Integer; count: Integer; data: Pointer = nil): TCvMat; cdecl;
|
||
|
||
{$ENDIF}
|
||
// #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));
|
||
*)
|
||
{$IFDEF SAFELOADLIB}
|
||
|
||
Type
|
||
TcvMean = function(const image: PCvArr; const mask: PCvArr = nil): Double; cdecl;
|
||
|
||
var
|
||
cvMean: TcvMean;
|
||
{$ELSE}
|
||
function cvMean(const image: PCvArr; const mask: PCvArr = nil): Double; cdecl;
|
||
{$ENDIF}
|
||
(*
|
||
CV_EXPORTS double cvSumPixels( const CvArr* image );
|
||
*)
|
||
{$IFDEF SAFELOADLIB}
|
||
|
||
type
|
||
TcvSumPixels = function(const image: PCvArr): Double; cdecl;
|
||
|
||
var
|
||
cvSumPixels: TcvSumPixels;
|
||
{$ELSE}
|
||
function cvSumPixels(const image: PCvArr): Double; cdecl;
|
||
{$ENDIF}
|
||
(*
|
||
CV_EXPORTS void cvMean_StdDev( const CvArr* image, double* mean, double* sdv,
|
||
const CvArr* mask CV_DEFAULT(0));
|
||
*)
|
||
{$IFDEF SAFELOADLIB}
|
||
|
||
type
|
||
TcvMean_StdDev = procedure(const image: PCvArr; mean: PDouble; sdv: PDouble; const mask: PCvArr = nil); cdecl;
|
||
|
||
var
|
||
cvMean_StdDev: TcvMean_StdDev;
|
||
{$ELSE}
|
||
procedure cvMean_StdDev(const image: PCvArr; mean: PDouble; sdv: PDouble; const mask: PCvArr = nil); cdecl;
|
||
{$ENDIF}
|
||
(*
|
||
CV_EXPORTS void cvmPerspectiveProject( const CvMat* mat, const CvArr* src, CvArr* dst );
|
||
*)
|
||
{$IFDEF SAFELOADLIB}
|
||
|
||
type
|
||
TcvmPerspectiveProject = procedure(const mat: PCvMat; const src: PCvArr; dst: PCvArr); cdecl;
|
||
|
||
var
|
||
cvmPerspectiveProject: TcvmPerspectiveProject;
|
||
{$ELSE}
|
||
procedure cvmPerspectiveProject(const mat: PCvMat; const src: PCvArr; dst: PCvArr); cdecl;
|
||
{$ENDIF}
|
||
(*
|
||
CV_EXPORTS void cvFillImage( CvArr* mat, double color );
|
||
*)
|
||
{$IFDEF SAFELOADLIB}
|
||
|
||
type
|
||
TcvFillImage = procedure(mat: PCvArr; color: Double); cdecl;
|
||
|
||
var
|
||
cvFillImage: TcvFillImage;
|
||
{$ELSE}
|
||
procedure cvFillImage(mat: PCvArr; color: Double); cdecl;
|
||
{$ENDIF}
|
||
|
||
// #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));
|
||
*)
|
||
{$IFDEF SAFELOADLIB}
|
||
|
||
type
|
||
TcvRandSetRange = procedure(state: pCvRandState; param1: Double; param2: Double; index: Integer = -1); cdecl;
|
||
|
||
var
|
||
cvRandSetRange: TcvRandSetRange;
|
||
{$ELSE}
|
||
procedure cvRandSetRange(state: pCvRandState; param1: Double; param2: Double; index: Integer = -1); cdecl;
|
||
{$ENDIF}
|
||
(*
|
||
CV_EXPORTS void cvRandInit( CvRandState* state, double param1,
|
||
double param2, int seed,
|
||
int disttype CV_DEFAULT(CV_RAND_UNI));
|
||
*)
|
||
{$IFDEF SAFELOADLIB}
|
||
|
||
type
|
||
TcvRandInit = procedure(state: pCvRandState; param1: Double; param2: Double; seed: Integer; disttype: Integer = CV_RAND_UNI); cdecl;
|
||
|
||
var
|
||
cvRandInit: TcvRandInit;
|
||
{$ELSE}
|
||
procedure cvRandInit(state: pCvRandState; param1: Double; param2: Double; seed: Integer; disttype: Integer = CV_RAND_UNI); cdecl;
|
||
{$ENDIF}
|
||
(*
|
||
Fills array with random numbers
|
||
|
||
CV_EXPORTS void cvRand( CvRandState* state, CvArr* arr );
|
||
*)
|
||
{$IFDEF SAFELOADLIB}
|
||
|
||
type
|
||
TcvRand = procedure(state: pCvRandState; arr: PCvArr); cdecl;
|
||
|
||
var
|
||
cvRand: TcvRand;
|
||
{$ELSE}
|
||
procedure cvRand(state: pCvRandState; arr: PCvArr); cdecl;
|
||
{$ENDIF}
|
||
// #define cvRandNext( _state ) cvRandInt( &(_state)->state )
|
||
|
||
// CV_EXPORTS void cvbRand( CvRandState* state, float* dst, int len );
|
||
{$IFDEF SAFELOADLIB}
|
||
|
||
type
|
||
TcvbRand = procedure(state: pCvRandState; dst: PSingle; len: Integer); cdecl;
|
||
|
||
var
|
||
cvbRand: TcvbRand;
|
||
{$ELSE}
|
||
procedure cvbRand(state: pCvRandState; dst: PSingle; len: Integer); cdecl;
|
||
{$ENDIF}
|
||
// CV_EXPORTS void cvbCartToPolar( const float* y, const float* x, float* magnitude, float* angle, int len );
|
||
{$IFDEF SAFELOADLIB}
|
||
|
||
type
|
||
TcvbCartToPolar = procedure(const y: PSingle; const x: PSingle; Var magnitude: Single; Var angle: Single; len: Integer); cdecl;
|
||
|
||
var
|
||
cvbCartToPolar: TcvbCartToPolar;
|
||
{$ELSE}
|
||
procedure cvbCartToPolar(const y: PSingle; const x: PSingle; Var magnitude: Single; Var angle: Single; len: Integer); cdecl;
|
||
{$ENDIF}
|
||
// CV_EXPORTS void cvbFastArctan( const float* y, const float* x, float* angle, int len );
|
||
{$IFDEF SAFELOADLIB}
|
||
|
||
type
|
||
TcvbFastArctan = procedure(const y: PSingle; const x: PSingle; Var angle: Single; len: Integer); cdecl;
|
||
|
||
var
|
||
cvbFastArctan: TcvbFastArctan;
|
||
{$ELSE}
|
||
procedure cvbFastArctan(const y: PSingle; const x: PSingle; Var angle: Single; len: Integer); cdecl;
|
||
{$ENDIF}
|
||
// CV_EXPORTS void cvbSqrt( const float* x, float* y, int len );
|
||
{$IFDEF SAFELOADLIB}
|
||
|
||
type
|
||
TcvbSqrt = procedure(const x: PSingle; Var y: Single; len: Integer); cdecl;
|
||
|
||
var
|
||
cvbSqrt: TcvbSqrt;
|
||
{$ELSE}
|
||
procedure cvbSqrt(const x: PSingle; Var y: Single; len: Integer); cdecl;
|
||
{$ENDIF}
|
||
// CV_EXPORTS void cvbInvSqrt( const float* x, float* y, int len );
|
||
{$IFDEF SAFELOADLIB}
|
||
|
||
type
|
||
TcvbInvSqrt = procedure(const x: PSingle; Var y: Single; len: Integer); cdecl;
|
||
|
||
var
|
||
cvbInvSqrt: TcvbInvSqrt;
|
||
{$ELSE}
|
||
procedure cvbInvSqrt(const x: PSingle; Var y: Single; len: Integer); cdecl;
|
||
{$ENDIF}
|
||
// CV_EXPORTS void cvbReciprocal( const float* x, float* y, int len );
|
||
{$IFDEF SAFELOADLIB}
|
||
|
||
type
|
||
TcvbReciprocal = procedure(const x: PSingle; var y: Single; len: Integer); cdecl;
|
||
|
||
var
|
||
cvbReciprocal: TcvbReciprocal;
|
||
{$ELSE}
|
||
procedure cvbReciprocal(const x: PSingle; var y: Single; len: Integer); cdecl;
|
||
{$ENDIF}
|
||
// CV_EXPORTS void cvbFastExp( const float* x, double* y, int len );
|
||
{$IFDEF SAFELOADLIB}
|
||
|
||
type
|
||
TcvbFastExp = procedure(const x: PSingle; Var y: Double; len: Integer); cdecl;
|
||
|
||
var
|
||
cvbFastExp: TcvbFastExp;
|
||
{$ELSE}
|
||
procedure cvbFastExp(const x: PSingle; Var y: Double; len: Integer); cdecl;
|
||
{$ENDIF}
|
||
// CV_EXPORTS void cvbFastLog( const double* x, float* y, int len );
|
||
{$IFDEF SAFELOADLIB}
|
||
|
||
type
|
||
TcvbFastLog = procedure(const x: PDouble; Var y: Single; len: Integer); cdecl;
|
||
|
||
var
|
||
cvbFastLog: TcvbFastLog;
|
||
{$ELSE}
|
||
procedure cvbFastLog(const x: PDouble; Var y: Single; len: Integer); cdecl;
|
||
{$ENDIF}
|
||
(*
|
||
CV_EXPORTS CvRect cvContourBoundingRect( void* point_set, int update CV_DEFAULT(0));
|
||
*)
|
||
{$IFDEF SAFELOADLIB}
|
||
|
||
type
|
||
TcvContourBoundingRect = function(point_set: Pointer; update: Integer = 0): TCvRect; cdecl;
|
||
|
||
var
|
||
cvContourBoundingRect: TcvContourBoundingRect;
|
||
{$ELSE}
|
||
function cvContourBoundingRect(point_set: Pointer; update: Integer = 0): TCvRect; cdecl;
|
||
{$ENDIF}
|
||
(*
|
||
CV_EXPORTS double cvPseudoInverse( const CvArr* src, CvArr* dst );
|
||
*)
|
||
{$IFDEF SAFELOADLIB}
|
||
|
||
type
|
||
TcvPseudoInverse = function(const src: PCvArr; dst: PCvArr): Double; cdecl;
|
||
|
||
var
|
||
cvPseudoInverse: TcvPseudoInverse;
|
||
{$ELSE}
|
||
function cvPseudoInverse(const src: PCvArr; dst: PCvArr): Double; cdecl;
|
||
{$ENDIF}
|
||
// #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 );
|
||
*)
|
||
{$IFDEF SAFELOADLIB}
|
||
|
||
type
|
||
TcvConvexHull = procedure(points: PCvPoint; num_points: Integer; bound_rect: PCvRect; orientation: Integer; Var hull: Integer;
|
||
Var hullsize: Integer); cdecl;
|
||
|
||
var
|
||
cvConvexHull: TcvConvexHull;
|
||
{$ELSE}
|
||
procedure cvConvexHull(points: PCvPoint; num_points: Integer; bound_rect: PCvRect; orientation: Integer; Var hull: Integer;
|
||
Var hullsize: Integer); cdecl;
|
||
{$ENDIF}
|
||
(*
|
||
CV_EXPORTS void cvMinAreaRect( CvPoint* points, int n,
|
||
int left, int bottom,
|
||
int right, int top,
|
||
CvPoint2D32f* anchor,
|
||
CvPoint2D32f* vect1,
|
||
CvPoint2D32f* vect2 );
|
||
*)
|
||
{$IFDEF SAFELOADLIB}
|
||
|
||
type
|
||
TcvMinAreaRect = procedure(points: PCvPoint; n: Integer; left: Integer; bottom: Integer; right: Integer; top: Integer; anchor: PCvPoint2D32f;
|
||
vect1: PCvPoint2D32f; vect2: PCvPoint2D32f); cdecl;
|
||
|
||
var
|
||
cvMinAreaRect: TcvMinAreaRect;
|
||
{$ELSE}
|
||
procedure cvMinAreaRect(points: PCvPoint; n: Integer; left: Integer; bottom: Integer; right: Integer; top: Integer; anchor: PCvPoint2D32f;
|
||
vect1: PCvPoint2D32f; vect2: PCvPoint2D32f); cdecl;
|
||
{$ENDIF}
|
||
|
||
Type
|
||
TCvDisType = type Integer;
|
||
TCvChainApproxMethod = type Integer;
|
||
TCvContourRetrievalMode = type Integer;
|
||
|
||
(*
|
||
CV_EXPORTS void cvFitLine3D( CvPoint3D32f* points, int count, int dist,
|
||
void *param, float reps, float aeps, float* line );
|
||
*)
|
||
{$IFDEF SAFELOADLIB}
|
||
|
||
type
|
||
TcvFitLine3D = procedure(points: PCvPoint3D32f; count: Integer; dist: Integer; param: Pointer; reps: Single; aeps: Single; Var line: Single); cdecl;
|
||
|
||
var
|
||
cvFitLine3D: TcvFitLine3D;
|
||
{$ELSE}
|
||
procedure cvFitLine3D(points: PCvPoint3D32f; count: Integer; dist: Integer; param: Pointer; reps: Single; aeps: Single; Var line: Single); cdecl;
|
||
{$ENDIF}
|
||
(*
|
||
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 );
|
||
*)
|
||
{$IFDEF SAFELOADLIB}
|
||
|
||
type
|
||
TcvFitLine2D = procedure(points: PCvPoint2D32f; count: Integer; dist: Integer; param: Pointer; reps: Single; aeps: Single; Var line: Single); cdecl;
|
||
|
||
var
|
||
cvFitLine2D: TcvFitLine2D;
|
||
{$ELSE}
|
||
procedure cvFitLine2D(points: PCvPoint2D32f; count: Integer; dist: Integer; param: Pointer; reps: Single; aeps: Single; Var line: Single); cdecl;
|
||
{$ENDIF}
|
||
// CV_EXPORTS void cvFitEllipse( const CvPoint2D32f* points, int count, CvBox2D* box );
|
||
{$IFDEF SAFELOADLIB}
|
||
|
||
type
|
||
TcvFitEllipse = procedure(const points: PCvPoint2D32f; count: Integer; Var box: TCvBox2D); cdecl;
|
||
|
||
var
|
||
cvFitEllipse: TcvFitEllipse;
|
||
{$ELSE}
|
||
procedure cvFitEllipse(const points: PCvPoint2D32f; count: Integer; Var box: TCvBox2D); cdecl;
|
||
{$ENDIF}
|
||
(*
|
||
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));
|
||
*)
|
||
{$IFDEF SAFELOADLIB}
|
||
|
||
type
|
||
TcvProject3D = procedure(points3D: PCvPoint3D32f; count: Integer; points2D: PCvPoint2D32f; xIndx: Integer = 0; yIndx: Integer = 1); cdecl;
|
||
|
||
var
|
||
cvProject3D: TcvProject3D;
|
||
{$ELSE}
|
||
procedure cvProject3D(points3D: PCvPoint3D32f; count: Integer; points2D: PCvPoint2D32f; xIndx: Integer = 0; yIndx: Integer = 1); cdecl;
|
||
{$ENDIF}
|
||
(* 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 );
|
||
*)
|
||
{$IFDEF SAFELOADLIB}
|
||
|
||
type
|
||
TcvHoughLines = function(image: PCvArr; rho: Double; theta: Double; threshold: Integer; lines: pfloat; linesNumber: Integer): Integer; cdecl;
|
||
|
||
var
|
||
cvHoughLines: TcvHoughLines;
|
||
{$ELSE}
|
||
function cvHoughLines(image: PCvArr; rho: Double; theta: Double; threshold: Integer; lines: pfloat; linesNumber: Integer): Integer; cdecl;
|
||
{$ENDIF}
|
||
(*
|
||
CV_EXPORTS int cvHoughLinesP( CvArr* image, double rho,
|
||
double theta, int threshold,
|
||
int lineLength, int lineGap,
|
||
int* lines, int linesNumber );
|
||
*)
|
||
{$IFDEF SAFELOADLIB}
|
||
|
||
type
|
||
TcvHoughLinesP = function(image: PCvArr; rho: Double; theta: Double; threshold: Integer; lineLength: Integer; lineGap: Integer; lines: pInteger;
|
||
linesNumber: Integer): Integer; cdecl;
|
||
|
||
var
|
||
cvHoughLinesP: TcvHoughLinesP;
|
||
{$ELSE}
|
||
function cvHoughLinesP(image: PCvArr; rho: Double; theta: Double; threshold: Integer; lineLength: Integer; lineGap: Integer; lines: pInteger;
|
||
linesNumber: Integer): Integer; cdecl;
|
||
{$ENDIF}
|
||
(*
|
||
CV_EXPORTS int cvHoughLinesSDiv( CvArr* image, double rho, int srn,
|
||
double theta, int stn, int threshold,
|
||
float* lines, int linesNumber );
|
||
*)
|
||
{$IFDEF SAFELOADLIB}
|
||
|
||
type
|
||
TcvHoughLinesSDiv = function(image: PCvArr; rho: Double; srn: Integer; theta: Double; stn: Integer; threshold: Integer; lines: pfloat;
|
||
linesNumber: Integer): Integer; cdecl;
|
||
|
||
var
|
||
cvHoughLinesSDiv: TcvHoughLinesSDiv;
|
||
{$ELSE}
|
||
function cvHoughLinesSDiv(image: PCvArr; rho: Double; srn: Integer; theta: Double; stn: Integer; threshold: Integer; lines: pfloat;
|
||
linesNumber: Integer): Integer; cdecl;
|
||
{$ENDIF}
|
||
(*
|
||
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));
|
||
*)
|
||
{$IFDEF SAFELOADLIB}
|
||
|
||
type
|
||
TcvCalcEMD = function(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;
|
||
|
||
var
|
||
cvCalcEMD: TcvCalcEMD;
|
||
|
||
{$ELSE}
|
||
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;
|
||
{$ENDIF}
|
||
(*
|
||
CV_EXPORTS void cvKMeans( int num_clusters, float** samples,
|
||
int num_samples, int vec_size,
|
||
CvTermCriteria termcrit, int* cluster_idx );
|
||
*)
|
||
{$IFDEF SAFELOADLIB}
|
||
|
||
type
|
||
TcvKMeans = procedure(num_clusters: Integer; Var samples: PSingle; num_samples: Integer; vec_size: Integer; termcrit: TCvTermCriteria;
|
||
Var cluster_idx: Integer); cdecl;
|
||
|
||
var
|
||
cvKMeans: TcvKMeans;
|
||
{$ELSE}
|
||
procedure cvKMeans(num_clusters: Integer; Var samples: PSingle; num_samples: Integer; vec_size: Integer; termcrit: TCvTermCriteria;
|
||
Var cluster_idx: Integer); cdecl;
|
||
{$ENDIF}
|
||
(*
|
||
CV_EXPORTS void cvStartScanGraph( CvGraph* graph, CvGraphScanner* scanner,
|
||
CvGraphVtx* vtx CV_DEFAULT(NULL),
|
||
int mask CV_DEFAULT(CV_GRAPH_ALL_ITEMS));
|
||
*)
|
||
{$IFDEF SAFELOADLIB}
|
||
|
||
type
|
||
TcvStartScanGraph = procedure(graph: PCvGraph; scanner: PCvGraphScanner; vtx: PCvGraphVtx = nil; mask: Integer = CV_GRAPH_ALL_ITEMS); cdecl;
|
||
|
||
var
|
||
cvStartScanGraph: TcvStartScanGraph;
|
||
{$ELSE}
|
||
procedure cvStartScanGraph(graph: PCvGraph; scanner: PCvGraphScanner; vtx: PCvGraphVtx = nil; mask: Integer = CV_GRAPH_ALL_ITEMS); cdecl;
|
||
{$ENDIF}
|
||
// CV_EXPORTS void cvEndScanGraph( CvGraphScanner* scanner );
|
||
{$IFDEF SAFELOADLIB}
|
||
|
||
type
|
||
TcvEndScanGraph = procedure(scanner: PCvGraphScanner); cdecl;
|
||
|
||
var
|
||
cvEndScanGraph: TcvEndScanGraph;
|
||
{$ELSE}
|
||
procedure cvEndScanGraph(scanner: PCvGraphScanner); cdecl;
|
||
{$ENDIF}
|
||
(* old drawing functions *)
|
||
|
||
(*
|
||
CV_EXPORTS void cvLineAA( CvArr* img, CvPoint pt1, CvPoint pt2,
|
||
double color, int scale CV_DEFAULT(0));
|
||
*)
|
||
{$IFDEF SAFELOADLIB}
|
||
|
||
type
|
||
TcvLineAA = procedure(img: PCvArr; pt1: TCvPoint; pt2: TCvPoint; color: Double; scale: Integer = 0); cdecl;
|
||
|
||
var
|
||
cvLineAA: TcvLineAA;
|
||
{$ELSE}
|
||
procedure cvLineAA(img: PCvArr; pt1: TCvPoint; pt2: TCvPoint; color: Double; scale: Integer = 0); cdecl;
|
||
{$ENDIF}
|
||
(*
|
||
CV_EXPORTS void cvCircleAA( CvArr* img, CvPoint center, int radius,
|
||
double color, int scale CV_DEFAULT(0) );
|
||
*)
|
||
{$IFDEF SAFELOADLIB}
|
||
|
||
type
|
||
TcvCircleAA = procedure(img: PCvArr; center: TCvPoint; radius: Integer; color: Double; scale: Integer = 0); cdecl;
|
||
|
||
var
|
||
cvCircleAA: TcvCircleAA;
|
||
{$ELSE}
|
||
procedure cvCircleAA(img: PCvArr; center: TCvPoint; radius: Integer; color: Double; scale: Integer = 0); cdecl;
|
||
{$ENDIF}
|
||
(*
|
||
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) );
|
||
*)
|
||
{$IFDEF SAFELOADLIB}
|
||
|
||
type
|
||
TcvEllipseAA = procedure(img: PCvArr; center: TCvPoint; axes: TCvSize; angle: Double; start_angle: Double; end_angle: Double; color: Double;
|
||
scale: Integer = 0); cdecl;
|
||
|
||
var
|
||
cvEllipseAA: TcvEllipseAA;
|
||
{$ELSE}
|
||
procedure cvEllipseAA(img: PCvArr; center: TCvPoint; axes: TCvSize; angle: Double; start_angle: Double; end_angle: Double; color: Double;
|
||
scale: Integer = 0); cdecl;
|
||
{$ENDIF}
|
||
(*
|
||
CV_EXPORTS void cvPolyLineAA( CvArr* img, CvPoint** pts, int* npts, int contours,
|
||
int is_closed, double color, int scale CV_DEFAULT(0) );
|
||
*)
|
||
{$IFDEF SAFELOADLIB}
|
||
|
||
type
|
||
TcvPolyLineAA = procedure(img: PCvArr; Var pts: PCvPoint; Var npts: Integer; contours: Integer; is_closed: Integer; color: Double;
|
||
scale: Integer = 0); cdecl;
|
||
|
||
var
|
||
cvPolyLineAA: TcvPolyLineAA;
|
||
{$ELSE}
|
||
procedure cvPolyLineAA(img: PCvArr; Var pts: PCvPoint; Var npts: Integer; contours: Integer; is_closed: Integer; color: Double;
|
||
scale: Integer = 0); cdecl;
|
||
{$ENDIF}
|
||
|
||
(* ***************************************************************************************\
|
||
* Pixel Access Macros *
|
||
\*************************************************************************************** *)
|
||
Type
|
||
// 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;
|
||
|
||
TCvPixelPosition8u = record
|
||
currline: PUChar; (* pointer to the start of the current pixel line *)
|
||
topline: PUChar; (* pointer to the start of the top pixel line *)
|
||
bottomline: PUChar; (* pointer to the start of the first line *)
|
||
(* which is below the image *)
|
||
x: Integer; (* current x coordinate ( in pixels ) *)
|
||
width: Integer; (* width of the image ( in pixels ) *)
|
||
height: Integer; (* height of the image ( in pixels ) *)
|
||
step: Integer; (* distance between lines ( in elements of single *)
|
||
(* plane ) *)
|
||
step_arr: array [0 .. 2] of Integer; (* array: ( 0, -step, step ). It is used for *)
|
||
(* vertical moving *)
|
||
end;
|
||
|
||
/// * 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;
|
||
|
||
TCvPixelPosition8s = record
|
||
currline: Pschar;
|
||
topline: Pschar;
|
||
bottomline: Pschar;
|
||
x: Integer;
|
||
width: Integer;
|
||
height: Integer;
|
||
step: Integer;
|
||
step_arr: array [0 .. 2] of Integer;
|
||
end;
|
||
|
||
/// * 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;
|
||
|
||
TCvPixelPosition32f = record
|
||
currline: PSingle;
|
||
topline: PSingle;
|
||
bottomline: PSingle;
|
||
x: Integer;
|
||
width: Integer;
|
||
height: Integer;
|
||
step: Integer;
|
||
step_arr: array [0 .. 2] of Integer;
|
||
end;
|
||
|
||
(* 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) )
|
||
*)
|
||
procedure CV_INIT_PIXEL_POS(var pos: TCvPixelPosition8u; origin, _step: Integer; roi: TIplROI; _x, _y, orientation: Integer); inline; overload;
|
||
procedure CV_INIT_PIXEL_POS(var pos: TCvPixelPosition8s; origin, _step: Integer; roi: TIplROI; _x, _y, orientation: Integer); inline; overload;
|
||
procedure CV_INIT_PIXEL_POS(var pos: TCvPixelPosition32f; origin, _step: Integer; roi: TIplROI; _x, _y, orientation: Integer); inline; overload;
|
||
|
||
(* 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))
|
||
|
||
const
|
||
(* Numeric constants which used for moving in arbitrary direction *)
|
||
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 );
|
||
*)
|
||
{$IFDEF SAFELOADLIB}
|
||
|
||
type
|
||
TcvUnDistortOnce = procedure(const src: PCvArr; dst: PCvArr; const intrinsic_matrix: PSingle; const distortion_coeffs: PSingle;
|
||
interpolate: Integer); cdecl;
|
||
|
||
var
|
||
cvUnDistortOnce: TcvUnDistortOnce;
|
||
|
||
{$ELSE}
|
||
procedure cvUnDistortOnce(const src: PCvArr; dst: PCvArr; const intrinsic_matrix: PSingle; const distortion_coeffs: PSingle;
|
||
interpolate: Integer); cdecl;
|
||
{$ENDIF}
|
||
(*
|
||
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 );
|
||
*)
|
||
{$IFDEF SAFELOADLIB}
|
||
|
||
type
|
||
TcvUnDistortInit = procedure(const src: PCvArr; undistortion_map: PCvArr; const A: PSingle; const k: PSingle; interpolate: Integer); cdecl;
|
||
TcvUnDistort = procedure(const src: PCvArr; dst: PCvArr; const undistortion_map: PCvArr; interpolate: Integer); cdecl;
|
||
|
||
var
|
||
cvUnDistortInit: TcvUnDistortInit;
|
||
cvUnDistort: TcvUnDistort;
|
||
|
||
{$ELSE}
|
||
procedure cvUnDistortInit(const src: PCvArr; undistortion_map: PCvArr; const A: PSingle; const k: PSingle; interpolate: Integer); cdecl;
|
||
procedure cvUnDistort(const src: PCvArr; dst: PCvArr; const undistortion_map: PCvArr; interpolate: Integer); cdecl;
|
||
{$ENDIF}
|
||
(*
|
||
Find fundamental matrix
|
||
|
||
CV_EXPORTS void cvFindFundamentalMatrix( int* points1, int* points2,
|
||
int numpoints, int method, float* matrix );
|
||
*)
|
||
{$IFDEF SAFELOADLIB}
|
||
|
||
type
|
||
TcvFindFundamentalMatrix = procedure(Var points1: Integer; Var points2: Integer; numpoints: Integer; method: Integer; Var matrix: Single); cdecl;
|
||
|
||
var
|
||
cvFindFundamentalMatrix: TcvFindFundamentalMatrix;
|
||
{$ELSE}
|
||
procedure cvFindFundamentalMatrix(Var points1: Integer; Var points2: Integer; numpoints: Integer; method: Integer; Var matrix: Single); cdecl;
|
||
{$ENDIF}
|
||
(*
|
||
CV_EXPORTS int cvFindChessBoardCornerGuesses( const void* arr, void* thresharr,
|
||
CvMemStorage* storage,
|
||
CvSize pattern_size, CvPoint2D32f * corners,
|
||
int *corner_count );
|
||
*)
|
||
{$IFDEF SAFELOADLIB}
|
||
|
||
type
|
||
TcvFindChessBoardCornerGuesses = function(const arr: Pointer; thresharr: Pointer; storage: PCvMemStorage; pattern_size: TCvSize;
|
||
corners: PCvPoint2D32f; corner_count: pInteger): Integer; cdecl;
|
||
|
||
var
|
||
cvFindChessBoardCornerGuesses: TcvFindChessBoardCornerGuesses;
|
||
|
||
{$ELSE}
|
||
function cvFindChessBoardCornerGuesses(const arr: Pointer; thresharr: Pointer; storage: PCvMemStorage; pattern_size: TCvSize; corners: PCvPoint2D32f;
|
||
corner_count: pInteger): Integer; cdecl;
|
||
{$ENDIF}
|
||
(*
|
||
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 );
|
||
*)
|
||
{$IFDEF SAFELOADLIB}
|
||
|
||
type
|
||
TcvCalibrateCamera = procedure(image_count: Integer; Var _point_counts: Integer; image_size: TCvSize; _image_points: PCvPoint2D32f;
|
||
_object_points: PCvPoint3D32f; _distortion_coeffs: PSingle; _camera_matrix: PSingle; _translation_vectors: PSingle; _rotation_matrices: PSingle;
|
||
flags: Integer); cdecl;
|
||
|
||
var
|
||
cvCalibrateCamera: TcvCalibrateCamera;
|
||
{$ELSE}
|
||
procedure cvCalibrateCamera(image_count: Integer; Var _point_counts: Integer; image_size: TCvSize; _image_points: PCvPoint2D32f;
|
||
_object_points: PCvPoint3D32f; _distortion_coeffs: PSingle; _camera_matrix: PSingle; _translation_vectors: PSingle; _rotation_matrices: PSingle;
|
||
flags: Integer); cdecl;
|
||
{$ENDIF}
|
||
(*
|
||
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 );
|
||
*)
|
||
{$IFDEF SAFELOADLIB}
|
||
|
||
type
|
||
TcvCalibrateCamera_64d = procedure(image_count: Integer; Var _point_counts: Integer; image_size: TCvSize; _image_points: PCvPoint2D64f;
|
||
_object_points: PCvPoint3D64f; _distortion_coeffs: PDouble; _camera_matrix: PDouble; _translation_vectors: PDouble; _rotation_matrices: PDouble;
|
||
flags: Integer); cdecl;
|
||
|
||
var
|
||
cvCalibrateCamera_64d: TcvCalibrateCamera_64d;
|
||
{$ELSE}
|
||
procedure cvCalibrateCamera_64d(image_count: Integer; Var _point_counts: Integer; image_size: TCvSize; _image_points: PCvPoint2D64f;
|
||
_object_points: PCvPoint3D64f; _distortion_coeffs: PDouble; _camera_matrix: PDouble; _translation_vectors: PDouble; _rotation_matrices: PDouble;
|
||
flags: Integer); cdecl;
|
||
{$ENDIF}
|
||
(*
|
||
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 );
|
||
*)
|
||
{$IFDEF SAFELOADLIB}
|
||
|
||
type
|
||
TcvFindExtrinsicCameraParams = procedure(point_count: Integer; image_size: TCvSize; _image_points: PCvPoint2D32f; _object_points: PCvPoint3D32f;
|
||
focal_length: PSingle; principal_point: TCvPoint2D32f; _distortion_coeffs: PSingle; _rotation_vector: PSingle;
|
||
_translation_vector: PSingle); cdecl;
|
||
|
||
var
|
||
cvFindExtrinsicCameraParams: TcvFindExtrinsicCameraParams;
|
||
|
||
{$ELSE}
|
||
procedure cvFindExtrinsicCameraParams(point_count: Integer; image_size: TCvSize; _image_points: PCvPoint2D32f; _object_points: PCvPoint3D32f;
|
||
focal_length: PSingle; principal_point: TCvPoint2D32f; _distortion_coeffs: PSingle; _rotation_vector: PSingle; _translation_vector: PSingle); cdecl;
|
||
{$ENDIF}
|
||
(*
|
||
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 );
|
||
*)
|
||
{$IFDEF SAFELOADLIB}
|
||
|
||
type
|
||
TcvFindExtrinsicCameraParams_64d = procedure(point_count: Integer; image_size: TCvSize; _image_points: PCvPoint2D64f; _object_points: PCvPoint3D64f;
|
||
focal_length: PDouble; principal_point: TCvPoint2D64f; _distortion_coeffs: PDouble; _rotation_vector: PDouble;
|
||
_translation_vector: PDouble); cdecl;
|
||
|
||
var
|
||
cvFindExtrinsicCameraParams_64d: TcvFindExtrinsicCameraParams_64d;
|
||
{$ELSE}
|
||
procedure cvFindExtrinsicCameraParams_64d(point_count: Integer; image_size: TCvSize; _image_points: PCvPoint2D64f; _object_points: PCvPoint3D64f;
|
||
focal_length: PDouble; principal_point: TCvPoint2D64f; _distortion_coeffs: PDouble; _rotation_vector: PDouble; _translation_vector: PDouble); cdecl;
|
||
{$ENDIF}
|
||
|
||
const
|
||
(* Rodrigues transform *)
|
||
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 );
|
||
*)
|
||
{$IFDEF SAFELOADLIB}
|
||
|
||
type
|
||
TcvRodrigues = procedure(rotation_matrix: PCvMat; rotation_vector: PCvMat; jacobian: PCvMat; conv_type: Integer); cdecl;
|
||
|
||
var
|
||
cvRodrigues: TcvRodrigues;
|
||
{$ELSE}
|
||
procedure cvRodrigues(rotation_matrix: PCvMat; rotation_vector: PCvMat; jacobian: PCvMat; conv_type: Integer); cdecl;
|
||
{$ENDIF}
|
||
(*
|
||
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 );
|
||
*)
|
||
{$IFDEF SAFELOADLIB}
|
||
|
||
type
|
||
TcvProjectPoints = procedure(point_count: Integer; _object_points: PCvPoint3D64f; _rotation_vector: PDouble; _translation_vector: PDouble;
|
||
focal_length: PDouble; principal_point: TCvPoint2D64f; _distortion: PDouble; _image_points: PCvPoint2D64f; _deriv_points_rotation_matrix: PDouble;
|
||
_deriv_points_translation_vect: PDouble; _deriv_points_focal: PDouble; _deriv_points_principal_point: PDouble;
|
||
_deriv_points_distortion_coeffs: PDouble); cdecl;
|
||
|
||
var
|
||
cvProjectPoints: TcvProjectPoints;
|
||
{$ELSE}
|
||
procedure cvProjectPoints(point_count: Integer; _object_points: PCvPoint3D64f; _rotation_vector: PDouble; _translation_vector: PDouble;
|
||
focal_length: PDouble; principal_point: TCvPoint2D64f; _distortion: PDouble; _image_points: PCvPoint2D64f; _deriv_points_rotation_matrix: PDouble;
|
||
_deriv_points_translation_vect: PDouble; _deriv_points_focal: PDouble; _deriv_points_principal_point: PDouble;
|
||
_deriv_points_distortion_coeffs: PDouble); cdecl;
|
||
{$ENDIF}
|
||
(*
|
||
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 );
|
||
*)
|
||
{$IFDEF SAFELOADLIB}
|
||
|
||
type
|
||
TcvProjectPointsSimple = procedure(point_count: Integer; _object_points: PCvPoint3D64f; _rotation_matrix: PDouble; _translation_vector: PDouble;
|
||
_camera_matrix: PDouble; _distortion: PDouble; _image_points: PCvPoint2D64f); cdecl;
|
||
|
||
var
|
||
cvProjectPointsSimple: TcvProjectPointsSimple;
|
||
{$ELSE}
|
||
procedure cvProjectPointsSimple(point_count: Integer; _object_points: PCvPoint3D64f; _rotation_matrix: PDouble; _translation_vector: PDouble;
|
||
_camera_matrix: PDouble; _distortion: PDouble; _image_points: PCvPoint2D64f); cdecl;
|
||
{$ENDIF}
|
||
// #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;
|
||
// }
|
||
*)
|
||
|
||
function cvSURFPoint(pt: TCvPoint2D32f; laplacian: Integer; size: Integer; dir: Single = 0; hessian: Single = 0): TCvSURFPoint; inline;
|
||
|
||
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) );
|
||
{$IFDEF SAFELOADLIB}
|
||
|
||
type
|
||
TcvSURFParams_fun = function(hessianThreshold: Double; _extended: Integer = 0): TCvSURFParams; cdecl;
|
||
|
||
var
|
||
cvSURFParams: TcvSURFParams_fun;
|
||
|
||
{$ELSE}
|
||
function cvSURFParams(hessianThreshold: Double; _extended: Integer = 0): TCvSURFParams; cdecl;
|
||
{$ENDIF}
|
||
(*
|
||
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) );
|
||
*)
|
||
{$IFDEF SAFELOADLIB}
|
||
|
||
type
|
||
TcvExtractSURF = procedure(const img: PCvArr; const mask: PCvArr; keypoints: ppCvSeq; descriptors: ppCvSeq; storage: PCvMemStorage;
|
||
params: TCvSURFParams; useProvidedKeyPts: Integer = 0); cdecl;
|
||
|
||
var
|
||
cvExtractSURF: TcvExtractSURF;
|
||
{$ELSE}
|
||
procedure cvExtractSURF(const img: PCvArr; const mask: PCvArr; keypoints: ppCvSeq; descriptors: ppCvSeq; storage: PCvMemStorage;
|
||
params: TCvSURFParams; useProvidedKeyPts: Integer = 0); cdecl;
|
||
{$ENDIF}
|
||
|
||
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) );
|
||
*)
|
||
{$IFDEF SAFELOADLIB}
|
||
|
||
type
|
||
TCvMSERParams_fun = function(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;
|
||
|
||
var
|
||
cvMSERParams: TCvMSERParams_fun;
|
||
{$ELSE}
|
||
//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;
|
||
{$ENDIF}
|
||
(*
|
||
Extracts the contours of Maximally Stable Extremal Regions
|
||
|
||
CVAPI(void) cvExtractMSER( CvArr* _img, CvArr* _mask, CvSeq** contours, CvMemStorage* storage, CvMSERParams params );
|
||
*)
|
||
{$IFDEF SAFELOADLIB}
|
||
|
||
type
|
||
TcvExtractMSER = procedure(_img: PCvArr; _mask: PCvArr; Var contours: pCvSeq; storage: PCvMemStorage; params: TCvMSERParams); cdecl;
|
||
|
||
var
|
||
cvExtractMSER: TcvExtractMSER;
|
||
{$ELSE}
|
||
//procedure cvExtractMSER(_img: PCvArr; _mask: PCvArr; Var contours: pCvSeq; storage: PCvMemStorage; params: TCvMSERParams); cdecl;
|
||
{$ENDIF}
|
||
|
||
Type
|
||
(*
|
||
typedef struct CvStarKeypoint
|
||
{
|
||
CvPoint pt;
|
||
int size;
|
||
float response;
|
||
} CvStarKeypoint;
|
||
*)
|
||
TCvStarKeypoint = record
|
||
pt: TCvPoint;
|
||
size: Integer;
|
||
response: Single;
|
||
end;
|
||
|
||
(*
|
||
CV_INLINE CvStarKeypoint cvStarKeypoint(CvPoint pt, int size, float response)
|
||
{
|
||
CvStarKeypoint kpt;
|
||
kpt.pt = pt;
|
||
kpt.size = size;
|
||
kpt.response = response;
|
||
return kpt;
|
||
}
|
||
*)
|
||
function cvStarKeypoint(pt: TCvPoint; size: Integer; response: Single): TCvStarKeypoint; inline;
|
||
|
||
(* typedef struct CvStarDetectorParams
|
||
{
|
||
int maxSize;
|
||
int responseThreshold;
|
||
int lineThresholdProjected;
|
||
int lineThresholdBinarized;
|
||
int suppressNonmaxSize;
|
||
} CvStarDetectorParams;
|
||
*)
|
||
|
||
Type
|
||
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()));
|
||
*)
|
||
{$IFDEF SAFELOADLIB}
|
||
|
||
type
|
||
TcvGetStarKeypoints = function(const img: PCvArr; storage: PCvMemStorage; params: TCvStarDetectorParams { = CV_DEFAULT(cvStarDetectorParams()) } )
|
||
: pCvSeq; cdecl;
|
||
|
||
var
|
||
cvGetStarKeypoints: TcvGetStarKeypoints;
|
||
{$ELSE}
|
||
function cvGetStarKeypoints(const img: PCvArr; storage: PCvMemStorage; params: TCvStarDetectorParams { = CV_DEFAULT(cvStarDetectorParams()) } )
|
||
: pCvSeq; cdecl;
|
||
{$ENDIF}
|
||
{$IF DEFINED(SAFELOADLIB) AND DEFINED(DEBUG)}
|
||
procedure Init_opencv_legacy_lib;
|
||
{$ENDIF}
|
||
|
||
implementation
|
||
|
||
uses ocv.lib;
|
||
|
||
const
|
||
compat_lib = legacy_lib;
|
||
|
||
procedure CV_INIT_PIXEL_POS(var pos: TCvPixelPosition8u; origin, _step: Integer; roi: TIplROI; _x, _y, orientation: Integer);
|
||
begin
|
||
pos.step := _step div sizeof(pos.currline[0]);
|
||
if orientation <> 0 then
|
||
pos.step := -pos.step;
|
||
pos.width := roi.width;
|
||
pos.height := roi.height;
|
||
pos.bottomline := PUChar(origin + pos.step * pos.height);
|
||
pos.topline := PUChar(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 := PUChar(origin + pos.step * _y);
|
||
end;
|
||
|
||
procedure CV_INIT_PIXEL_POS(var pos: TCvPixelPosition8s; origin, _step: Integer; roi: TIplROI; _x, _y, orientation: Integer);
|
||
begin
|
||
pos.step := _step div sizeof(pos.currline[0]);
|
||
if orientation <> 0 then
|
||
pos.step := -pos.step;
|
||
pos.width := roi.width;
|
||
pos.height := roi.height;
|
||
pos.bottomline := Pschar(origin + pos.step * pos.height);
|
||
pos.topline := Pschar(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 := Pschar(origin + pos.step * _y);
|
||
end;
|
||
|
||
procedure CV_INIT_PIXEL_POS(var pos: TCvPixelPosition32f; origin, _step: Integer; roi: TIplROI; _x, _y, orientation: Integer);
|
||
begin
|
||
pos.step := _step div sizeof(pos.currline[0]);
|
||
if orientation <> 0 then
|
||
pos.step := -pos.step;
|
||
pos.width := roi.width;
|
||
pos.height := roi.height;
|
||
pos.bottomline := PSingle(origin + pos.step * pos.height);
|
||
pos.topline := PSingle(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 := PSingle(origin + pos.step * _y);
|
||
end;
|
||
|
||
function cvSURFPoint(pt: TCvPoint2D32f; laplacian: Integer; size: Integer; dir: Single = 0; hessian: Single = 0): TCvSURFPoint; inline;
|
||
begin
|
||
Result.pt := pt;
|
||
Result.laplacian := laplacian;
|
||
Result.size := size;
|
||
Result.dir := dir;
|
||
Result.hessian := hessian;
|
||
end;
|
||
|
||
function cvStarKeypoint(pt: TCvPoint; size: Integer; response: Single): TCvStarKeypoint;
|
||
begin
|
||
Result.pt := pt;
|
||
Result.size := size;
|
||
Result.response := response;
|
||
end;
|
||
|
||
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;
|
||
|
||
{$IFDEF SAFELOADLIB}
|
||
|
||
Var
|
||
compatDLL: Cardinal;
|
||
|
||
procedure Init_opencv_legacy_lib;
|
||
begin
|
||
compatDLL := ocvLoadLibrary(compat_lib);
|
||
Assert(compatDLL <> 0, 'Can not init ' + compat_lib);
|
||
|
||
cvMatArray := ocvGetProcAddress('cvMatArray', compatDLL);
|
||
cvMean := ocvGetProcAddress('cvMean', compatDLL);
|
||
cvSumPixels := ocvGetProcAddress('cvSumPixels', compatDLL);
|
||
cvMean_StdDev := ocvGetProcAddress('cvMean_StdDev', compatDLL);
|
||
cvmPerspectiveProject := ocvGetProcAddress('cvmPerspectiveProject', compatDLL);
|
||
cvFillImage := ocvGetProcAddress('cvFillImage', compatDLL);
|
||
cvRandSetRange := ocvGetProcAddress('cvRandSetRange', compatDLL);
|
||
cvRandInit := ocvGetProcAddress('cvRandInit', compatDLL);
|
||
cvRand := ocvGetProcAddress('cvRand', compatDLL);
|
||
cvbRand := ocvGetProcAddress('cvbRand', compatDLL);
|
||
cvbCartToPolar := ocvGetProcAddress('cvbCartToPolar', compatDLL);
|
||
cvbFastArctan := ocvGetProcAddress('cvbFastArctan', compatDLL);
|
||
cvbSqrt := ocvGetProcAddress('cvbSqrt', compatDLL);
|
||
cvbInvSqrt := ocvGetProcAddress('cvbInvSqrt', compatDLL);
|
||
cvbReciprocal := ocvGetProcAddress('cvbReciprocal', compatDLL);
|
||
cvbFastExp := ocvGetProcAddress('cvbFastExp', compatDLL);
|
||
cvbFastLog := ocvGetProcAddress('cvbFastLog', compatDLL);
|
||
cvContourBoundingRect := ocvGetProcAddress('cvContourBoundingRect', compatDLL);
|
||
cvPseudoInverse := ocvGetProcAddress('cvPseudoInverse', compatDLL);
|
||
cvConvexHull := ocvGetProcAddress('cvConvexHull', compatDLL);
|
||
cvMinAreaRect := ocvGetProcAddress('cvMinAreaRect', compatDLL);
|
||
cvFitLine3D := ocvGetProcAddress('cvFitLine3D', compatDLL);
|
||
cvFitLine2D := ocvGetProcAddress('cvFitLine2D', compatDLL);
|
||
cvFitEllipse := ocvGetProcAddress('cvFitEllipse', compatDLL);
|
||
cvProject3D := ocvGetProcAddress('cvProject3D', compatDLL);
|
||
cvHoughLines := ocvGetProcAddress('cvHoughLines', compatDLL);
|
||
cvHoughLinesP := ocvGetProcAddress('cvHoughLinesP', compatDLL);
|
||
cvHoughLinesSDiv := ocvGetProcAddress('cvHoughLinesSDiv', compatDLL);
|
||
cvCalcEMD := ocvGetProcAddress('cvCalcEMD', compatDLL);
|
||
cvKMeans := ocvGetProcAddress('cvKMeans', compatDLL);
|
||
cvStartScanGraph := ocvGetProcAddress('cvStartScanGraph', compatDLL);
|
||
cvEndScanGraph := ocvGetProcAddress('cvEndScanGraph', compatDLL);
|
||
cvLineAA := ocvGetProcAddress('cvLineAA', compatDLL);
|
||
cvCircleAA := ocvGetProcAddress('cvCircleAA', compatDLL);
|
||
cvEllipseAA := ocvGetProcAddress('cvEllipseAA', compatDLL);
|
||
cvPolyLineAA := ocvGetProcAddress('cvPolyLineAA', compatDLL);
|
||
cvUnDistortOnce := ocvGetProcAddress('cvUnDistortOnce', compatDLL);
|
||
cvUnDistortInit := ocvGetProcAddress('cvUnDistortInit', compatDLL);
|
||
cvUnDistort := ocvGetProcAddress('cvUnDistort', compatDLL);
|
||
cvFindFundamentalMatrix := ocvGetProcAddress('cvFindFundamentalMatrix', compatDLL);
|
||
cvFindChessBoardCornerGuesses := ocvGetProcAddress('cvFindChessBoardCornerGuesses', compatDLL);
|
||
cvCalibrateCamera := ocvGetProcAddress('cvCalibrateCamera', compatDLL);
|
||
cvCalibrateCamera_64d := ocvGetProcAddress('cvCalibrateCamera_64d', compatDLL);
|
||
cvFindExtrinsicCameraParams := ocvGetProcAddress('cvFindExtrinsicCameraParams', compatDLL);
|
||
cvFindExtrinsicCameraParams_64d := ocvGetProcAddress('cvFindExtrinsicCameraParams_64d', compatDLL);
|
||
cvRodrigues := ocvGetProcAddress('cvRodrigues', compatDLL);
|
||
cvProjectPoints := ocvGetProcAddress('cvProjectPoints', compatDLL);
|
||
cvProjectPointsSimple := ocvGetProcAddress('cvProjectPointsSimple', compatDLL);
|
||
cvSURFParams := ocvGetProcAddress('cvSURFParams', compatDLL);
|
||
cvExtractSURF := ocvGetProcAddress('cvExtractSURF', compatDLL);
|
||
// cvMSERParams := ocvGetProcAddress('cvMSERParams', compatDLL);
|
||
// cvExtractMSER := ocvGetProcAddress('cvExtractMSER', compatDLL);
|
||
cvGetStarKeypoints := ocvGetProcAddress('cvGetStarKeypoints', compatDLL);
|
||
|
||
end;
|
||
{$ELSE}
|
||
function cvMatArray; external legacy_lib;
|
||
function cvMean; external legacy_lib;
|
||
function cvSumPixels; external legacy_lib;
|
||
procedure cvMean_StdDev; external legacy_lib;
|
||
procedure cvmPerspectiveProject; external legacy_lib;
|
||
procedure cvFillImage; external legacy_lib;
|
||
procedure cvRandSetRange; external legacy_lib;
|
||
procedure cvRandInit; external legacy_lib;
|
||
procedure cvRand; external legacy_lib;
|
||
procedure cvbRand; external legacy_lib;
|
||
procedure cvbCartToPolar; external legacy_lib;
|
||
procedure cvbFastArctan; external legacy_lib;
|
||
procedure cvbSqrt; external legacy_lib;
|
||
procedure cvbInvSqrt; external legacy_lib;
|
||
procedure cvbReciprocal; external legacy_lib;
|
||
procedure cvbFastExp; external legacy_lib;
|
||
procedure cvbFastLog; external legacy_lib;
|
||
function cvContourBoundingRect; external legacy_lib;
|
||
function cvPseudoInverse; external legacy_lib;
|
||
procedure cvConvexHull; external legacy_lib;
|
||
procedure cvMinAreaRect; external legacy_lib;
|
||
procedure cvFitLine3D; external legacy_lib;
|
||
procedure cvFitLine2D; external legacy_lib;
|
||
procedure cvFitEllipse; external legacy_lib;
|
||
procedure cvProject3D; external legacy_lib;
|
||
function cvHoughLines; external legacy_lib;
|
||
function cvHoughLinesP; external legacy_lib;
|
||
function cvHoughLinesSDiv; external legacy_lib;
|
||
function cvCalcEMD; external legacy_lib;
|
||
procedure cvKMeans; external legacy_lib;
|
||
procedure cvStartScanGraph; external legacy_lib;
|
||
procedure cvEndScanGraph; external legacy_lib;
|
||
procedure cvLineAA; external legacy_lib;
|
||
procedure cvCircleAA; external legacy_lib;
|
||
procedure cvEllipseAA; external legacy_lib;
|
||
procedure cvPolyLineAA; external legacy_lib;
|
||
procedure cvUnDistortOnce; external legacy_lib;
|
||
procedure cvUnDistortInit; external legacy_lib;
|
||
procedure cvUnDistort; external legacy_lib;
|
||
procedure cvFindFundamentalMatrix; external legacy_lib;
|
||
function cvFindChessBoardCornerGuesses; external legacy_lib;
|
||
procedure cvCalibrateCamera; external legacy_lib;
|
||
procedure cvCalibrateCamera_64d; external legacy_lib;
|
||
procedure cvFindExtrinsicCameraParams; external legacy_lib;
|
||
procedure cvFindExtrinsicCameraParams_64d; external legacy_lib;
|
||
procedure cvRodrigues; external legacy_lib;
|
||
procedure cvProjectPoints; external legacy_lib;
|
||
procedure cvProjectPointsSimple; external legacy_lib;
|
||
function cvSURFParams; external legacy_lib;
|
||
procedure cvExtractSURF; external legacy_lib;
|
||
//function cvMSERParams; external legacy_lib;
|
||
//procedure cvExtractMSER; external legacy_lib;
|
||
function cvGetStarKeypoints; external legacy_lib;
|
||
{$ENDIF}
|
||
|
||
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;
|
||
|
||
{$IFDEF SAFELOADLIB}
|
||
Init_opencv_legacy_lib;
|
||
{$ENDIF}
|
||
|
||
end.
|