mirror of
https://github.com/Laex/Delphi-OpenCV.git
synced 2024-11-16 00:05:52 +01:00
2dcca0b554
[*] Rename files of: - Calib3d.pas in calib3d_s.pas - Tracking.pas in tracking_s.pas To ensure conformity with the file names OpenCV library [!] Modules used in the project without the inclusion of relative paths. Added instructions on how to add the module search path (see readme_en.txt) [+] Added an example Posit (cvReleasePOSITObject, cvPOSIT and others) (thanks to Frans van Daalen (CLubfitter73)) Signed-off-by: Laex <laex@bk.ru>
305 lines
15 KiB
ObjectPascal
305 lines
15 KiB
ObjectPascal
// --------------------------------- OpenCV license.txt ---------------------------
|
|
(* // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
|
|
//
|
|
// By downloading, copying, installing or using the software you agree to this license.
|
|
// If you do not agree to this license, do not download, install,
|
|
// copy or use the software.
|
|
//
|
|
//
|
|
// License Agreement
|
|
// For Open Source Computer Vision Library
|
|
//
|
|
// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
|
|
// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
|
|
// Third party copyrights are property of their respective owners.
|
|
//
|
|
// Redistribution and use in source and binary forms, with or without modification,
|
|
// are permitted provided that the following conditions are met:
|
|
//
|
|
// * Redistribution's of source code must retain the above copyright notice,
|
|
// this list of conditions and the following disclaimer.
|
|
//
|
|
// * Redistribution's in binary form must reproduce the above copyright notice,
|
|
// this list of conditions and the following disclaimer in the documentation
|
|
// and/or other materials provided with the distribution.
|
|
//
|
|
// * The name of the copyright holders may not be used to endorse or promote products
|
|
// derived from this software without specific prior written permission.
|
|
//
|
|
// This software is provided by the copyright holders and contributors "as is" and
|
|
// any express or implied warranties, including, but not limited to, the implied
|
|
// warranties of merchantability and fitness for a particular purpose are disclaimed.
|
|
// In no event shall the Intel Corporation or contributors be liable for any direct,
|
|
// indirect, incidental, special, exemplary, or consequential damages
|
|
// (including, but not limited to, procurement of substitute goods or services;
|
|
// loss of use, data, or profits; or business interruption) however caused
|
|
// and on any theory of liability, whether in contract, strict liability,
|
|
// or tort (including negligence or otherwise) arising in any way out of
|
|
// the use of this software, even if advised of the possibility of such damage. *)
|
|
|
|
(* / **************************************************************************************************
|
|
// Project Delphi-OpenCV
|
|
// **************************************************************************************************
|
|
// Contributor:
|
|
// laentir Valetov
|
|
// email:laex@bk.ru
|
|
// **************************************************************************************************
|
|
// You may retrieve the latest version of this file at the GitHub,
|
|
// located at git://github.com/Laex/Delphi-OpenCV.git
|
|
// **************************************************************************************************
|
|
// License:
|
|
// The contents of this file are subject to the Mozilla Public License Version 1.1 (the "License");
|
|
// you may not use this file except in compliance with the License. You may obtain a copy of the
|
|
// License at http://www.mozilla.org/MPL/
|
|
//
|
|
// Software distributed under the License is distributed on an "AS IS" basis, WITHOUT WARRANTY OF
|
|
// ANY KIND, either express or implied. See the License for the specific language governing rights
|
|
// and limitations under the License.
|
|
//
|
|
// Alternatively, the contents of this file may be used under the terms of the
|
|
// GNU Lesser General Public License (the "LGPL License"), in which case the
|
|
// provisions of the LGPL License are applicable instead of those above.
|
|
// If you wish to allow use of your version of this file only under the terms
|
|
// of the LGPL License and not to allow others to use your version of this file
|
|
// under the MPL, indicate your decision by deleting the provisions above and
|
|
// replace them with the notice and other provisions required by the LGPL
|
|
// License. If you do not delete the provisions above, a recipient may use
|
|
// your version of this file under either the MPL or the LGPL License.
|
|
//
|
|
// For more information about the LGPL: http://www.gnu.org/copyleft/lesser.html
|
|
// **************************************************************************************************
|
|
// Warning: Using Delphi XE3 syntax!
|
|
// **************************************************************************************************
|
|
// The Initial Developer of the Original Code:
|
|
// OpenCV: open source computer vision library
|
|
// Homepage: http://opencv.org
|
|
// Online docs: http://docs.opencv.org
|
|
// Q&A forum: http://answers.opencv.org
|
|
// Dev zone: http://code.opencv.org
|
|
// **************************************************************************************************
|
|
// Original file:
|
|
// opencv\modules\video\include\opencv2\video\tracking_c.h
|
|
// ************************************************************************************************* *)
|
|
|
|
{$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}
|
|
unit tracking_c;
|
|
|
|
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 );
|
|
procedure cvUpdateMotionHistory(const silhouette: pCvArr; mhi: pCvArr; timestamp: double; duration: double); cdecl;
|
|
|
|
/// * 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));
|
|
procedure cvCalcMotionGradient(const mhi: pCvArr; mask: pCvArr; orientation: pCvArr; delta1: double; delta2: double;
|
|
aperture_size: Integer = 3); cdecl;
|
|
|
|
/// * 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 );
|
|
function cvCalcGlobalOrientation(const orientation: pCvArr; const mask: pCvArr; const mhi: pCvArr; timestamp: double;
|
|
duration: double): double; cdecl;
|
|
|
|
/// * 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 );
|
|
function cvSegmentMotion(const mhi: pCvArr; seg_mask: pCvArr; storage: pCvMemStorage; timestamp: double;
|
|
seg_thresh: double): pCvSeq; cdecl;
|
|
|
|
/// ****************************************************************************************\
|
|
// * 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
|
|
// } // extern "C"
|
|
// #endif
|
|
//
|
|
//
|
|
// #endif // __OPENCV_TRACKING_C_H__
|
|
|
|
implementation
|
|
|
|
Uses
|
|
uLibName;
|
|
|
|
function cvCamShift; external tracking_DLL;
|
|
procedure cvCalcOpticalFlowPyrLK; external tracking_DLL;
|
|
procedure cvCalcOpticalFlowFarneback; external tracking_DLL;
|
|
|
|
procedure cvUpdateMotionHistory; external tracking_DLL;
|
|
procedure cvCalcMotionGradient; external tracking_DLL;
|
|
function cvSegmentMotion; external tracking_DLL;
|
|
function cvCalcGlobalOrientation; external tracking_DLL;
|
|
|
|
end.
|