mirror of
https://github.com/Laex/Delphi-OpenCV.git
synced 2024-11-16 00:05:52 +01:00
7fcbee712c
Multidemo [+] fback_c (cvCalcOpticalFlowFarneback) [+] minarea (cvMinEnclosingCircle, cvMinAreaRect2) Signed-off-by: Laex <laex@bk.ru>
375 lines
15 KiB
ObjectPascal
375 lines
15 KiB
ObjectPascal
unit tracking;
|
|
|
|
interface
|
|
|
|
uses
|
|
Core.types_c, imgproc.types_c;
|
|
|
|
/// ****************************************************************************************\
|
|
// * Motion Analysis *
|
|
// \****************************************************************************************/
|
|
//
|
|
/// ************************************ optical flow ***************************************/
|
|
const
|
|
CV_LKFLOW_PYR_A_READY = 1;
|
|
CV_LKFLOW_PYR_B_READY = 2;
|
|
CV_LKFLOW_INITIAL_GUESSES = 4;
|
|
CV_LKFLOW_GET_MIN_EIGENVALS = 8;
|
|
|
|
/// * It is Lucas & Kanade method, modified to use pyramids.
|
|
// Also it does several iterations to get optical flow for
|
|
// every point at every pyramid level.
|
|
// Calculates optical flow between two images for certain set of points (i.e.
|
|
// it is a "sparse" optical flow, which is opposite to the previous 3 methods) */
|
|
|
|
// CVAPI(void) cvCalcOpticalFlowPyrLK(
|
|
// const CvArr* prev,
|
|
// const CvArr* curr,
|
|
// CvArr* prev_pyr, CvArr* curr_pyr,
|
|
// const CvPoint2D32f* prev_features,
|
|
// CvPoint2D32f* curr_features,
|
|
// int count,
|
|
// CvSize win_size,
|
|
// int level,
|
|
// char* status,
|
|
// float* track_error,
|
|
// CvTermCriteria criteria,
|
|
// int flags );
|
|
|
|
procedure cvCalcOpticalFlowPyrLK(const prev: pIplImage; const curr: pIplImage; prev_pyr: pIplImage; curr_pyr: pIplImage;
|
|
const prev_features: pCvPoint2D32f; curr_features: pCvPoint2D32f; count: Integer; win_size: TCvSize; level: Integer;
|
|
status: pCVChar; track_error: PSingle; criteria: TCvTermCriteria; flags: Integer); cdecl;
|
|
|
|
/// * Modification of a previous sparse optical flow algorithm to calculate
|
|
// affine flow */
|
|
// CVAPI(void) cvCalcAffineFlowPyrLK( const CvArr* prev, const CvArr* curr,
|
|
// CvArr* prev_pyr, CvArr* curr_pyr,
|
|
// const CvPoint2D32f* prev_features,
|
|
// CvPoint2D32f* curr_features,
|
|
// float* matrices, int count,
|
|
// CvSize win_size, int level,
|
|
// char* status, float* track_error,
|
|
// CvTermCriteria criteria, int flags );
|
|
//
|
|
/// * Estimate rigid transformation between 2 images or 2 point sets */
|
|
// CVAPI(int) cvEstimateRigidTransform( const CvArr* A, const CvArr* B,
|
|
// CvMat* M, int full_affine );
|
|
//
|
|
/// * Estimate optical flow for each pixel using the two-frame G. Farneback algorithm */
|
|
// CVAPI(void) cvCalcOpticalFlowFarneback( const CvArr* prev, const CvArr* next,
|
|
// CvArr* flow, double pyr_scale, int levels,
|
|
// int winsize, int iterations, int poly_n,
|
|
// double poly_sigma, int flags );
|
|
procedure cvCalcOpticalFlowFarneback(const prev: pCvMat; const next: pCvMat; flow: pCvMat; pyr_scale: double;
|
|
levels: Integer; winsize: Integer; iterations: Integer; poly_n: Integer; poly_sigma: double; flags: Integer); cdecl;
|
|
|
|
/// ********************************* motion templates *************************************/
|
|
//
|
|
/// ****************************************************************************************\
|
|
// * All the motion template functions work only with single channel images. *
|
|
// * Silhouette image must have depth IPL_DEPTH_8U or IPL_DEPTH_8S *
|
|
// * Motion history image must have depth IPL_DEPTH_32F, *
|
|
// * Gradient mask - IPL_DEPTH_8U or IPL_DEPTH_8S, *
|
|
// * Motion orientation image - IPL_DEPTH_32F *
|
|
// * Segmentation mask - IPL_DEPTH_32F *
|
|
// * All the angles are in degrees, all the times are in milliseconds *
|
|
// \****************************************************************************************/
|
|
//
|
|
/// * Updates motion history image given motion silhouette */
|
|
// CVAPI(void) cvUpdateMotionHistory( const CvArr* silhouette, CvArr* mhi,
|
|
// double timestamp, double duration );
|
|
//
|
|
/// * Calculates gradient of the motion history image and fills
|
|
// a mask indicating where the gradient is valid */
|
|
// CVAPI(void) cvCalcMotionGradient( const CvArr* mhi, CvArr* mask, CvArr* orientation,
|
|
// double delta1, double delta2,
|
|
// int aperture_size CV_DEFAULT(3));
|
|
//
|
|
/// * Calculates average motion direction within a selected motion region
|
|
// (region can be selected by setting ROIs and/or by composing a valid gradient mask
|
|
// with the region mask) */
|
|
// CVAPI(double) cvCalcGlobalOrientation( const CvArr* orientation, const CvArr* mask,
|
|
// const CvArr* mhi, double timestamp,
|
|
// double duration );
|
|
//
|
|
/// * Splits a motion history image into a few parts corresponding to separate independent motions
|
|
// (e.g. left hand, right hand) */
|
|
// CVAPI(CvSeq*) cvSegmentMotion( const CvArr* mhi, CvArr* seg_mask,
|
|
// CvMemStorage* storage,
|
|
// double timestamp, double seg_thresh );
|
|
|
|
|
|
|
|
// ****************************************************************************************\
|
|
// * Tracking *
|
|
// ****************************************************************************************/
|
|
|
|
{
|
|
/* Implements CAMSHIFT algorithm - determines object position, size and orientation
|
|
from the object histogram back project (extension of meanshift) */
|
|
CVAPI(int) cvCamShift( const CvArr* prob_image, CvRect window,
|
|
CvTermCriteria criteria, CvConnectedComp* comp,
|
|
CvBox2D* box CV_DEFAULT(NULL) );
|
|
}
|
|
|
|
function cvCamShift(const prob_image: pIplImage; window: TCvRect; criteria: TCvTermCriteria; comp: pCvConnectedComp;
|
|
box: pCvBox2D = nil): Integer; cdecl;
|
|
|
|
/// * Implements MeanShift algorithm - determines object position
|
|
// from the object histogram back project */
|
|
// CVAPI(int) cvMeanShift( const CvArr* prob_image, CvRect window,
|
|
// CvTermCriteria criteria, CvConnectedComp* comp );
|
|
//
|
|
/// *
|
|
// standard Kalman filter (in G. Welch' and G. Bishop's notation):
|
|
//
|
|
// x(k)=A*x(k-1)+B*u(k)+w(k) p(w)~N(0,Q)
|
|
// z(k)=H*x(k)+v(k), p(v)~N(0,R)
|
|
// */
|
|
// typedef struct CvKalman
|
|
// {
|
|
// int MP; /* number of measurement vector dimensions */
|
|
// int DP; /* number of state vector dimensions */
|
|
// int CP; /* number of control vector dimensions */
|
|
//
|
|
// /* backward compatibility fields */
|
|
// #if 1
|
|
// float* PosterState; /* =state_pre->data.fl */
|
|
// float* PriorState; /* =state_post->data.fl */
|
|
// float* DynamMatr; /* =transition_matrix->data.fl */
|
|
// float* MeasurementMatr; /* =measurement_matrix->data.fl */
|
|
// float* MNCovariance; /* =measurement_noise_cov->data.fl */
|
|
// float* PNCovariance; /* =process_noise_cov->data.fl */
|
|
// float* KalmGainMatr; /* =gain->data.fl */
|
|
// float* PriorErrorCovariance;/* =error_cov_pre->data.fl */
|
|
// float* PosterErrorCovariance;/* =error_cov_post->data.fl */
|
|
// float* Temp1; /* temp1->data.fl */
|
|
// float* Temp2; /* temp2->data.fl */
|
|
// #endif
|
|
//
|
|
// CvMat* state_pre; /* predicted state (x'(k)):
|
|
// x(k)=A*x(k-1)+B*u(k) */
|
|
// CvMat* state_post; /* corrected state (x(k)):
|
|
// x(k)=x'(k)+K(k)*(z(k)-H*x'(k)) */
|
|
// CvMat* transition_matrix; /* state transition matrix (A) */
|
|
// CvMat* control_matrix; /* control matrix (B)
|
|
// (it is not used if there is no control)*/
|
|
// CvMat* measurement_matrix; /* measurement matrix (H) */
|
|
// CvMat* process_noise_cov; /* process noise covariance matrix (Q) */
|
|
// CvMat* measurement_noise_cov; /* measurement noise covariance matrix (R) */
|
|
// CvMat* error_cov_pre; /* priori error estimate covariance matrix (P'(k)):
|
|
// P'(k)=A*P(k-1)*At + Q)*/
|
|
// CvMat* gain; /* Kalman gain matrix (K(k)):
|
|
// K(k)=P'(k)*Ht*inv(H*P'(k)*Ht+R)*/
|
|
// CvMat* error_cov_post; /* posteriori error estimate covariance matrix (P(k)):
|
|
// P(k)=(I-K(k)*H)*P'(k) */
|
|
// CvMat* temp1; /* temporary matrices */
|
|
// CvMat* temp2;
|
|
// CvMat* temp3;
|
|
// CvMat* temp4;
|
|
// CvMat* temp5;
|
|
// } CvKalman;
|
|
//
|
|
/// * Creates Kalman filter and sets A, B, Q, R and state to some initial values */
|
|
// CVAPI(CvKalman*) cvCreateKalman( int dynam_params, int measure_params,
|
|
// int control_params CV_DEFAULT(0));
|
|
//
|
|
/// * Releases Kalman filter state */
|
|
// CVAPI(void) cvReleaseKalman( CvKalman** kalman);
|
|
//
|
|
/// * Updates Kalman filter by time (predicts future state of the system) */
|
|
// CVAPI(const CvMat*) cvKalmanPredict( CvKalman* kalman,
|
|
// const CvMat* control CV_DEFAULT(NULL));
|
|
//
|
|
/// * Updates Kalman filter by measurement
|
|
// (corrects state of the system and internal matrices) */
|
|
// CVAPI(const CvMat*) cvKalmanCorrect( CvKalman* kalman, const CvMat* measurement );
|
|
//
|
|
// #define cvKalmanUpdateByTime cvKalmanPredict
|
|
// #define cvKalmanUpdateByMeasurement cvKalmanCorrect
|
|
//
|
|
//
|
|
// #ifdef __cplusplus
|
|
// }
|
|
//
|
|
// namespace cv
|
|
// {
|
|
//
|
|
/// /! updates motion history image using the current silhouette
|
|
// CV_EXPORTS_W void updateMotionHistory( InputArray silhouette, InputOutputArray mhi,
|
|
// double timestamp, double duration );
|
|
//
|
|
/// /! computes the motion gradient orientation image from the motion history image
|
|
// CV_EXPORTS_W void calcMotionGradient( InputArray mhi, OutputArray mask,
|
|
// OutputArray orientation,
|
|
// double delta1, double delta2,
|
|
// int apertureSize=3 );
|
|
//
|
|
/// /! computes the global orientation of the selected motion history image part
|
|
// CV_EXPORTS_W double calcGlobalOrientation( InputArray orientation, InputArray mask,
|
|
// InputArray mhi, double timestamp,
|
|
// double duration );
|
|
//
|
|
// CV_EXPORTS_W void segmentMotion(InputArray mhi, OutputArray segmask,
|
|
// CV_OUT std::vector<Rect>& boundingRects,
|
|
// double timestamp, double segThresh);
|
|
//
|
|
/// /! updates the object tracking window using CAMSHIFT algorithm
|
|
// CV_EXPORTS_W RotatedRect CamShift( InputArray probImage, CV_OUT CV_IN_OUT Rect& window,
|
|
// TermCriteria criteria );
|
|
//
|
|
/// /! updates the object tracking window using meanshift algorithm
|
|
// CV_EXPORTS_W int meanShift( InputArray probImage, CV_OUT CV_IN_OUT Rect& window,
|
|
// TermCriteria criteria );
|
|
//
|
|
/// *!
|
|
// Kalman filter.
|
|
//
|
|
// The class implements standard Kalman filter \url{http://en.wikipedia.org/wiki/Kalman_filter}.
|
|
// However, you can modify KalmanFilter::transitionMatrix, KalmanFilter::controlMatrix and
|
|
// KalmanFilter::measurementMatrix to get the extended Kalman filter functionality.
|
|
// */
|
|
// class CV_EXPORTS_W KalmanFilter
|
|
// {
|
|
// public:
|
|
// //! the default constructor
|
|
// CV_WRAP KalmanFilter();
|
|
// //! the full constructor taking the dimensionality of the state, of the measurement and of the control vector
|
|
// CV_WRAP KalmanFilter(int dynamParams, int measureParams, int controlParams=0, int type=CV_32F);
|
|
// //! re-initializes Kalman filter. The previous content is destroyed.
|
|
// void init(int dynamParams, int measureParams, int controlParams=0, int type=CV_32F);
|
|
//
|
|
// //! computes predicted state
|
|
// CV_WRAP const Mat& predict(const Mat& control=Mat());
|
|
// //! updates the predicted state from the measurement
|
|
// CV_WRAP const Mat& correct(const Mat& measurement);
|
|
//
|
|
// Mat statePre; //!< predicted state (x'(k)): x(k)=A*x(k-1)+B*u(k)
|
|
// Mat statePost; //!< corrected state (x(k)): x(k)=x'(k)+K(k)*(z(k)-H*x'(k))
|
|
// Mat transitionMatrix; //!< state transition matrix (A)
|
|
// Mat controlMatrix; //!< control matrix (B) (not used if there is no control)
|
|
// Mat measurementMatrix; //!< measurement matrix (H)
|
|
// Mat processNoiseCov; //!< process noise covariance matrix (Q)
|
|
// Mat measurementNoiseCov;//!< measurement noise covariance matrix (R)
|
|
// Mat errorCovPre; //!< priori error estimate covariance matrix (P'(k)): P'(k)=A*P(k-1)*At + Q)*/
|
|
// Mat gain; //!< Kalman gain matrix (K(k)): K(k)=P'(k)*Ht*inv(H*P'(k)*Ht+R)
|
|
// Mat errorCovPost; //!< posteriori error estimate covariance matrix (P(k)): P(k)=(I-K(k)*H)*P'(k)
|
|
//
|
|
// // temporary matrices
|
|
// Mat temp1;
|
|
// Mat temp2;
|
|
// Mat temp3;
|
|
// Mat temp4;
|
|
// Mat temp5;
|
|
// };
|
|
//
|
|
// enum
|
|
// {
|
|
// OPTFLOW_USE_INITIAL_FLOW = CV_LKFLOW_INITIAL_GUESSES,
|
|
// OPTFLOW_LK_GET_MIN_EIGENVALS = CV_LKFLOW_GET_MIN_EIGENVALS,
|
|
// OPTFLOW_FARNEBACK_GAUSSIAN = 256
|
|
// };
|
|
//
|
|
/// /! constructs a pyramid which can be used as input for calcOpticalFlowPyrLK
|
|
// CV_EXPORTS_W int buildOpticalFlowPyramid(InputArray img, OutputArrayOfArrays pyramid,
|
|
// Size winSize, int maxLevel, bool withDerivatives = true,
|
|
// int pyrBorder = BORDER_REFLECT_101, int derivBorder = BORDER_CONSTANT,
|
|
// bool tryReuseInputImage = true);
|
|
//
|
|
/// /! computes sparse optical flow using multi-scale Lucas-Kanade algorithm
|
|
// CV_EXPORTS_W void calcOpticalFlowPyrLK( InputArray prevImg, InputArray nextImg,
|
|
// InputArray prevPts, InputOutputArray nextPts,
|
|
// OutputArray status, OutputArray err,
|
|
// Size winSize=Size(21,21), int maxLevel=3,
|
|
// TermCriteria criteria=TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 0.01),
|
|
// int flags=0, double minEigThreshold=1e-4);
|
|
//
|
|
/// /! computes dense optical flow using Farneback algorithm
|
|
// CV_EXPORTS_W void calcOpticalFlowFarneback( InputArray prev, InputArray next,
|
|
// InputOutputArray flow, double pyr_scale, int levels, int winsize,
|
|
// int iterations, int poly_n, double poly_sigma, int flags );
|
|
//
|
|
/// /! estimates the best-fit Euqcidean, similarity, affine or perspective transformation
|
|
/// / that maps one 2D point set to another or one image to another.
|
|
// CV_EXPORTS_W Mat estimateRigidTransform( InputArray src, InputArray dst,
|
|
// bool fullAffine);
|
|
//
|
|
// enum
|
|
// {
|
|
// MOTION_TRANSLATION=0,
|
|
// MOTION_EUCLIDEAN=1,
|
|
// MOTION_AFFINE=2,
|
|
// MOTION_HOMOGRAPHY=3
|
|
// };
|
|
//
|
|
/// /! estimates the best-fit Translation, Euclidean, Affine or Perspective Transformation
|
|
/// / with respect to Enhanced Correlation Coefficient criterion that maps one image to
|
|
/// / another (area-based alignment)
|
|
/// /
|
|
/// / see reference:
|
|
/// / Evangelidis, G. E., Psarakis, E.Z., Parametric Image Alignment using
|
|
/// / Enhanced Correlation Coefficient Maximization, PAMI, 30(8), 2008
|
|
//
|
|
// CV_EXPORTS_W double findTransformECC(InputArray templateImage,
|
|
// InputArray inputImage,
|
|
// InputOutputArray warpMatrix,
|
|
// int motionType=MOTION_AFFINE,
|
|
// TermCriteria criteria=TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 50, 0.001));
|
|
//
|
|
//
|
|
/// /! computes dense optical flow using Simple Flow algorithm
|
|
// CV_EXPORTS_W void calcOpticalFlowSF(InputArray from,
|
|
// InputArray to,
|
|
// OutputArray flow,
|
|
// int layers,
|
|
// int averaging_block_size,
|
|
// int max_flow);
|
|
//
|
|
// CV_EXPORTS_W void calcOpticalFlowSF(InputArray from,
|
|
// InputArray to,
|
|
// OutputArray flow,
|
|
// int layers,
|
|
// int averaging_block_size,
|
|
// int max_flow,
|
|
// double sigma_dist,
|
|
// double sigma_color,
|
|
// int postprocess_window,
|
|
// double sigma_dist_fix,
|
|
// double sigma_color_fix,
|
|
// double occ_thr,
|
|
// int upscale_averaging_radius,
|
|
// double upscale_sigma_dist,
|
|
// double upscale_sigma_color,
|
|
// double speed_up_thr);
|
|
//
|
|
// class CV_EXPORTS DenseOpticalFlow : public Algorithm
|
|
// {
|
|
// public:
|
|
// virtual void calc(InputArray I0, InputArray I1, InputOutputArray flow) = 0;
|
|
// virtual void collectGarbage() = 0;
|
|
// };
|
|
//
|
|
/// / Implementation of the Zach, Pock and Bischof Dual TV-L1 Optical Flow method
|
|
/// /
|
|
/// / see reference:
|
|
/// / [1] C. Zach, T. Pock and H. Bischof, "A Duality Based Approach for Realtime TV-L1 Optical Flow".
|
|
/// / [2] Javier Sanchez, Enric Meinhardt-Llopis and Gabriele Facciolo. "TV-L1 Optical Flow Estimation".
|
|
// CV_EXPORTS Ptr<DenseOpticalFlow> createOptFlow_DualTVL1();
|
|
//
|
|
// }
|
|
//
|
|
// #endif
|
|
//
|
|
// #endif
|
|
|
|
implementation
|
|
|
|
Uses
|
|
uLibName;
|
|
|
|
function cvCamShift; external tracking_DLL;
|
|
procedure cvCalcOpticalFlowPyrLK; external tracking_DLL;
|
|
procedure cvCalcOpticalFlowFarneback; external tracking_DLL;
|
|
|
|
end.
|