00001 00005 /*M/////////////////////////////////////////////////////////////////////////////////////// 00006 // 00007 // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. 00008 // 00009 // By downloading, copying, installing or using the software you agree to this license. 00010 // If you do not agree to this license, do not download, install, 00011 // copy or use the software. 00012 // 00013 // 00014 // License Agreement 00015 // For Open Source Computer Vision Library 00016 // 00017 // Copyright (C) 2000-2008, Intel Corporation, all rights reserved. 00018 // Copyright (C) 2009, Willow Garage Inc., all rights reserved. 00019 // Third party copyrights are property of their respective owners. 00020 // 00021 // Redistribution and use in source and binary forms, with or without modification, 00022 // are permitted provided that the following conditions are met: 00023 // 00024 // * Redistribution's of source code must retain the above copyright notice, 00025 // this list of conditions and the following disclaimer. 00026 // 00027 // * Redistribution's in binary form must reproduce the above copyright notice, 00028 // this list of conditions and the following disclaimer in the documentation 00029 // and/or other materials provided with the distribution. 00030 // 00031 // * The name of the copyright holders may not be used to endorse or promote products 00032 // derived from this software without specific prior written permission. 00033 // 00034 // This software is provided by the copyright holders and contributors "as is" and 00035 // any express or implied warranties, including, but not limited to, the implied 00036 // warranties of merchantability and fitness for a particular purpose are disclaimed. 00037 // In no event shall the Intel Corporation or contributors be liable for any direct, 00038 // indirect, incidental, special, exemplary, or consequential damages 00039 // (including, but not limited to, procurement of substitute goods or services; 00040 // loss of use, data, or profits; or business interruption) however caused 00041 // and on any theory of liability, whether in contract, strict liability, 00042 // or tort (including negligence or otherwise) arising in any way out of 00043 // the use of this software, even if advised of the possibility of such damage. 00044 // 00045 //M*/ 00046 00047 #ifndef __OPENCV_TRACKING_HPP__ 00048 #define __OPENCV_TRACKING_HPP__ 00049 00050 #include "opencv2/core/core.hpp" 00051 #include "opencv2/imgproc/imgproc_c.h" 00052 00053 #ifdef __cplusplus 00054 extern "C" { 00055 #endif 00056 00057 /****************************************************************************************\ 00058 * Motion Analysis * 00059 \****************************************************************************************/ 00060 00061 /************************************ optical flow ***************************************/ 00062 00063 /* Calculates optical flow for 2 images using classical Lucas & Kanade algorithm */ 00064 CVAPI(void) cvCalcOpticalFlowLK( const CvArr* prev, const CvArr* curr, 00065 CvSize win_size, CvArr* velx, CvArr* vely ); 00066 00067 /* Calculates optical flow for 2 images using block matching algorithm */ 00068 CVAPI(void) cvCalcOpticalFlowBM( const CvArr* prev, const CvArr* curr, 00069 CvSize block_size, CvSize shift_size, 00070 CvSize max_range, int use_previous, 00071 CvArr* velx, CvArr* vely ); 00072 00073 /* Calculates Optical flow for 2 images using Horn & Schunck algorithm */ 00074 CVAPI(void) cvCalcOpticalFlowHS( const CvArr* prev, const CvArr* curr, 00075 int use_previous, CvArr* velx, CvArr* vely, 00076 double lambda, CvTermCriteria criteria ); 00077 00078 #define CV_LKFLOW_PYR_A_READY 1 00079 #define CV_LKFLOW_PYR_B_READY 2 00080 #define CV_LKFLOW_INITIAL_GUESSES 4 00081 #define CV_LKFLOW_GET_MIN_EIGENVALS 8 00082 00083 /* It is Lucas & Kanade method, modified to use pyramids. 00084 Also it does several iterations to get optical flow for 00085 every point at every pyramid level. 00086 Calculates optical flow between two images for certain set of points (i.e. 00087 it is a "sparse" optical flow, which is opposite to the previous 3 methods) */ 00088 CVAPI(void) cvCalcOpticalFlowPyrLK( const CvArr* prev, const CvArr* curr, 00089 CvArr* prev_pyr, CvArr* curr_pyr, 00090 const CvPoint2D32f* prev_features, 00091 CvPoint2D32f* curr_features, 00092 int count, 00093 CvSize win_size, 00094 int level, 00095 char* status, 00096 float* track_error, 00097 CvTermCriteria criteria, 00098 int flags ); 00099 00100 00101 /* Modification of a previous sparse optical flow algorithm to calculate 00102 affine flow */ 00103 CVAPI(void) cvCalcAffineFlowPyrLK( const CvArr* prev, const CvArr* curr, 00104 CvArr* prev_pyr, CvArr* curr_pyr, 00105 const CvPoint2D32f* prev_features, 00106 CvPoint2D32f* curr_features, 00107 float* matrices, int count, 00108 CvSize win_size, int level, 00109 char* status, float* track_error, 00110 CvTermCriteria criteria, int flags ); 00111 00112 /* Estimate rigid transformation between 2 images or 2 point sets */ 00113 CVAPI(int) cvEstimateRigidTransform( const CvArr* A, const CvArr* B, 00114 CvMat* M, int full_affine ); 00115 00116 /* Estimate optical flow for each pixel using the two-frame G. Farneback algorithm */ 00117 CVAPI(void) cvCalcOpticalFlowFarneback( const CvArr* prev, const CvArr* next, 00118 CvArr* flow, double pyr_scale, int levels, 00119 int winsize, int iterations, int poly_n, 00120 double poly_sigma, int flags ); 00121 00122 /********************************* motion templates *************************************/ 00123 00124 /****************************************************************************************\ 00125 * All the motion template functions work only with single channel images. * 00126 * Silhouette image must have depth IPL_DEPTH_8U or IPL_DEPTH_8S * 00127 * Motion history image must have depth IPL_DEPTH_32F, * 00128 * Gradient mask - IPL_DEPTH_8U or IPL_DEPTH_8S, * 00129 * Motion orientation image - IPL_DEPTH_32F * 00130 * Segmentation mask - IPL_DEPTH_32F * 00131 * All the angles are in degrees, all the times are in milliseconds * 00132 \****************************************************************************************/ 00133 00134 /* Updates motion history image given motion silhouette */ 00135 CVAPI(void) cvUpdateMotionHistory( const CvArr* silhouette, CvArr* mhi, 00136 double timestamp, double duration ); 00137 00138 /* Calculates gradient of the motion history image and fills 00139 a mask indicating where the gradient is valid */ 00140 CVAPI(void) cvCalcMotionGradient( const CvArr* mhi, CvArr* mask, CvArr* orientation, 00141 double delta1, double delta2, 00142 int aperture_size CV_DEFAULT(3)); 00143 00144 /* Calculates average motion direction within a selected motion region 00145 (region can be selected by setting ROIs and/or by composing a valid gradient mask 00146 with the region mask) */ 00147 CVAPI(double) cvCalcGlobalOrientation( const CvArr* orientation, const CvArr* mask, 00148 const CvArr* mhi, double timestamp, 00149 double duration ); 00150 00151 /* Splits a motion history image into a few parts corresponding to separate independent motions 00152 (e.g. left hand, right hand) */ 00153 CVAPI(CvSeq*) cvSegmentMotion( const CvArr* mhi, CvArr* seg_mask, 00154 CvMemStorage* storage, 00155 double timestamp, double seg_thresh ); 00156 00157 /****************************************************************************************\ 00158 * Tracking * 00159 \****************************************************************************************/ 00160 00161 /* Implements CAMSHIFT algorithm - determines object position, size and orientation 00162 from the object histogram back project (extension of meanshift) */ 00163 CVAPI(int) cvCamShift( const CvArr* prob_image, CvRect window, 00164 CvTermCriteria criteria, CvConnectedComp* comp, 00165 CvBox2D* box CV_DEFAULT(NULL) ); 00166 00167 /* Implements MeanShift algorithm - determines object position 00168 from the object histogram back project */ 00169 CVAPI(int) cvMeanShift( const CvArr* prob_image, CvRect window, 00170 CvTermCriteria criteria, CvConnectedComp* comp ); 00171 00172 /* 00173 standard Kalman filter (in G. Welch' and G. Bishop's notation): 00174 00175 x(k)=A*x(k-1)+B*u(k)+w(k) p(w)~N(0,Q) 00176 z(k)=H*x(k)+v(k), p(v)~N(0,R) 00177 */ 00178 typedef struct CvKalman 00179 { 00180 int MP; /* number of measurement vector dimensions */ 00181 int DP; /* number of state vector dimensions */ 00182 int CP; /* number of control vector dimensions */ 00183 00184 /* backward compatibility fields */ 00185 #if 1 00186 float* PosterState; /* =state_pre->data.fl */ 00187 float* PriorState; /* =state_post->data.fl */ 00188 float* DynamMatr; /* =transition_matrix->data.fl */ 00189 float* MeasurementMatr; /* =measurement_matrix->data.fl */ 00190 float* MNCovariance; /* =measurement_noise_cov->data.fl */ 00191 float* PNCovariance; /* =process_noise_cov->data.fl */ 00192 float* KalmGainMatr; /* =gain->data.fl */ 00193 float* PriorErrorCovariance;/* =error_cov_pre->data.fl */ 00194 float* PosterErrorCovariance;/* =error_cov_post->data.fl */ 00195 float* Temp1; /* temp1->data.fl */ 00196 float* Temp2; /* temp2->data.fl */ 00197 #endif 00198 00199 CvMat* state_pre; /* predicted state (x'(k)): 00200 x(k)=A*x(k-1)+B*u(k) */ 00201 CvMat* state_post; /* corrected state (x(k)): 00202 x(k)=x'(k)+K(k)*(z(k)-H*x'(k)) */ 00203 CvMat* transition_matrix; /* state transition matrix (A) */ 00204 CvMat* control_matrix; /* control matrix (B) 00205 (it is not used if there is no control)*/ 00206 CvMat* measurement_matrix; /* measurement matrix (H) */ 00207 CvMat* process_noise_cov; /* process noise covariance matrix (Q) */ 00208 CvMat* measurement_noise_cov; /* measurement noise covariance matrix (R) */ 00209 CvMat* error_cov_pre; /* priori error estimate covariance matrix (P'(k)): 00210 P'(k)=A*P(k-1)*At + Q)*/ 00211 CvMat* gain; /* Kalman gain matrix (K(k)): 00212 K(k)=P'(k)*Ht*inv(H*P'(k)*Ht+R)*/ 00213 CvMat* error_cov_post; /* posteriori error estimate covariance matrix (P(k)): 00214 P(k)=(I-K(k)*H)*P'(k) */ 00215 CvMat* temp1; /* temporary matrices */ 00216 CvMat* temp2; 00217 CvMat* temp3; 00218 CvMat* temp4; 00219 CvMat* temp5; 00220 } CvKalman; 00221 00222 /* Creates Kalman filter and sets A, B, Q, R and state to some initial values */ 00223 CVAPI(CvKalman*) cvCreateKalman( int dynam_params, int measure_params, 00224 int control_params CV_DEFAULT(0)); 00225 00226 /* Releases Kalman filter state */ 00227 CVAPI(void) cvReleaseKalman( CvKalman** kalman); 00228 00229 /* Updates Kalman filter by time (predicts future state of the system) */ 00230 CVAPI(const CvMat*) cvKalmanPredict( CvKalman* kalman, 00231 const CvMat* control CV_DEFAULT(NULL)); 00232 00233 /* Updates Kalman filter by measurement 00234 (corrects state of the system and internal matrices) */ 00235 CVAPI(const CvMat*) cvKalmanCorrect( CvKalman* kalman, const CvMat* measurement ); 00236 00237 #define cvKalmanUpdateByTime cvKalmanPredict 00238 #define cvKalmanUpdateByMeasurement cvKalmanCorrect 00239 00240 #ifdef __cplusplus 00241 } 00242 00243 namespace cv 00244 { 00245 00247 CV_EXPORTS_W void updateMotionHistory( InputArray silhouette, InputOutputArray mhi, 00248 double timestamp, double duration ); 00249 00251 CV_EXPORTS_W void calcMotionGradient( InputArray mhi, OutputArray mask, 00252 OutputArray orientation, 00253 double delta1, double delta2, 00254 int apertureSize=3 ); 00255 00257 CV_EXPORTS_W double calcGlobalOrientation( InputArray orientation, InputArray mask, 00258 InputArray mhi, double timestamp, 00259 double duration ); 00260 00261 CV_EXPORTS_W void segmentMotion(InputArray mhi, OutputArray segmask, 00262 vector<Rect>& boundingRects, 00263 double timestamp, double segThresh); 00264 00266 CV_EXPORTS_W RotatedRect CamShift( InputArray probImage, CV_IN_OUT Rect& window, 00267 TermCriteria criteria ); 00268 00270 CV_EXPORTS_W int meanShift( InputArray probImage, CV_IN_OUT Rect& window, 00271 TermCriteria criteria ); 00272 00280 class CV_EXPORTS_W KalmanFilter 00281 { 00282 public: 00284 CV_WRAP KalmanFilter(); 00286 CV_WRAP KalmanFilter(int dynamParams, int measureParams, int controlParams=0, int type=CV_32F); 00288 void init(int dynamParams, int measureParams, int controlParams=0, int type=CV_32F); 00289 00291 CV_WRAP const Mat& predict(const Mat& control=Mat()); 00293 CV_WRAP const Mat& correct(const Mat& measurement); 00294 00295 Mat statePre; 00296 Mat statePost; 00297 Mat transitionMatrix; 00298 Mat controlMatrix; 00299 Mat measurementMatrix; 00300 Mat processNoiseCov; 00301 Mat measurementNoiseCov; 00302 Mat errorCovPre; 00303 Mat gain; 00304 Mat errorCovPost; 00305 00306 // temporary matrices 00307 Mat temp1; 00308 Mat temp2; 00309 Mat temp3; 00310 Mat temp4; 00311 Mat temp5; 00312 }; 00313 00314 00315 enum { OPTFLOW_USE_INITIAL_FLOW=4, OPTFLOW_FARNEBACK_GAUSSIAN=256 }; 00316 00318 CV_EXPORTS_W void calcOpticalFlowPyrLK( InputArray prevImg, InputArray nextImg, 00319 InputArray prevPts, CV_OUT InputOutputArray nextPts, 00320 OutputArray status, OutputArray err, 00321 Size winSize=Size(15,15), int maxLevel=3, 00322 TermCriteria criteria=TermCriteria( 00323 TermCriteria::COUNT+TermCriteria::EPS, 00324 30, 0.01), 00325 double derivLambda=0.5, 00326 int flags=0 ); 00327 00329 CV_EXPORTS_W void calcOpticalFlowFarneback( InputArray prev, InputArray next, 00330 CV_OUT InputOutputArray flow, double pyr_scale, int levels, int winsize, 00331 int iterations, int poly_n, double poly_sigma, int flags ); 00332 00334 // that maps one 2D point set to another or one image to another. 00335 CV_EXPORTS_W Mat estimateRigidTransform( InputArray src, InputArray dst, 00336 bool fullAffine); 00337 00338 } 00339 00340 #endif 00341 00342 #endif