Calculates an optical flow for a sparse feature set using the iterative LucasKanade method with pyramids.
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=1e4 )¶
cv2.
calcOpticalFlowPyrLK
(prevImg, nextImg, prevPts[, nextPts[, status[, err[, winSize[, maxLevel[, criteria[, flags[, minEigThreshold]]]]]]]]) → nextPts, status, err¶
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)¶
cv.
CalcOpticalFlowPyrLK
(prev, curr, prevPyr, currPyr, prevFeatures, winSize, level, criteria, flags, guesses=None) > (currFeatures, status, track_error)¶Parameters: 


The function implements a sparse iterative version of the LucasKanade optical flow in pyramids. See [Bouguet00]. The function is parallelized with the TBB library.
Note
Constructs the image pyramid which can be passed to calcOpticalFlowPyrLK()
.
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)¶
cv2.
buildOpticalFlowPyramid
(img, winSize, maxLevel[, pyramid[, withDerivatives[, pyrBorder[, derivBorder[, tryReuseInputImage]]]]]) → retval, pyramid¶Parameters: 


Returns:  number of levels in constructed pyramid. Can be less than 
Computes a dense optical flow using the Gunnar Farneback’s algorithm.
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)¶
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)¶
cv2.
calcOpticalFlowFarneback
(prev, next, pyr_scale, levels, winsize, iterations, poly_n, poly_sigma, flags[, flow]) → flow¶Parameters: 


The function finds an optical flow for each prev
pixel using the [Farneback2003] algorithm so that
Note
Computes an optimal affine transformation between two 2D point sets.
Mat estimateRigidTransform
(InputArray src, InputArray dst, bool fullAffine)¶
cv2.
estimateRigidTransform
(src, dst, fullAffine) → retval¶Parameters: 


The function finds an optimal affine transform [Ab] (a 2 x 3
floatingpoint matrix) that approximates best the affine transformation between:
 Two point sets
 Two raster images. In this case, the function first finds some features in the
src
image and finds the corresponding features indst
image. After that, the problem is reduced to the first case.
In case of point sets, the problem is formulated as follows: you need to find a 2x2 matrix A and 2x1 vector b so that:
where
src[i]
anddst[i]
are the ith points insrc
anddst
, respectivelycan be either arbitrary (when
fullAffine=true
) or have a form ofwhen
fullAffine=false
.
Updates the motion history image by a moving silhouette.
void updateMotionHistory
(InputArray silhouette, InputOutputArray mhi, double timestamp, double duration)¶
cv2.
updateMotionHistory
(silhouette, mhi, timestamp, duration) → None¶
void cvUpdateMotionHistory
(const CvArr* silhouette, CvArr* mhi, double timestamp, double duration)¶
cv.
UpdateMotionHistory
(silhouette, mhi, timestamp, duration) → None¶Parameters: 


The function updates the motion history image as follows:
That is, MHI pixels where the motion occurs are set to the current timestamp
, while the pixels where the motion happened last time a long time ago are cleared.
The function, together with
calcMotionGradient()
and
calcGlobalOrientation()
, implements a motion templates technique described in
[Davis97] and [Bradski00].
See also the OpenCV sample motempl.c
that demonstrates the use of all the motion template functions.
Calculates a gradient orientation of a motion history image.
void calcMotionGradient
(InputArray mhi, OutputArray mask, OutputArray orientation, double delta1, double delta2, int apertureSize=3 )¶
cv2.
calcMotionGradient
(mhi, delta1, delta2[, mask[, orientation[, apertureSize]]]) → mask, orientation¶
void cvCalcMotionGradient
(const CvArr* mhi, CvArr* mask, CvArr* orientation, double delta1, double delta2, int aperture_size=3 )¶
cv.
CalcMotionGradient
(mhi, mask, orientation, delta1, delta2, apertureSize=3) → None¶Parameters: 


The function calculates a gradient orientation at each pixel as:
In fact,
fastAtan2()
and
phase()
are used so that the computed angle is measured in degrees and covers the full range 0..360. Also, the mask
is filled to indicate pixels where the computed angle is valid.
Note
Calculates a global motion orientation in a selected region.
double calcGlobalOrientation
(InputArray orientation, InputArray mask, InputArray mhi, double timestamp, double duration)¶
cv2.
calcGlobalOrientation
(orientation, mask, mhi, timestamp, duration) → retval¶
double cvCalcGlobalOrientation
(const CvArr* orientation, const CvArr* mask, const CvArr* mhi, double timestamp, double duration)¶
cv.
CalcGlobalOrientation
(orientation, mask, mhi, timestamp, duration) → float¶Parameters: 


The function calculates an average
motion direction in the selected region and returns the angle between
0 degrees and 360 degrees. The average direction is computed from
the weighted orientation histogram, where a recent motion has a larger
weight and the motion occurred in the past has a smaller weight, as recorded in mhi
.
Splits a motion history image into a few parts corresponding to separate independent motions (for example, left hand, right hand).
void segmentMotion
(InputArray mhi, OutputArray segmask, vector<Rect>& boundingRects, double timestamp, double segThresh)¶
cv2.
segmentMotion
(mhi, timestamp, segThresh[, segmask]) → segmask, boundingRects¶
CvSeq* cvSegmentMotion
(const CvArr* mhi, CvArr* seg_mask, CvMemStorage* storage, double timestamp, double seg_thresh)¶
cv.
SegmentMotion
(mhi, seg_mask, storage, timestamp, seg_thresh) → boundingRects¶Parameters: 


The function finds all of the motion segments and marks them in segmask
with individual values (1,2,...). It also computes a vector with ROIs of motion connected components. After that the motion direction for every component can be calculated with calcGlobalOrientation()
using the extracted mask of the particular component.
Finds an object center, size, and orientation.
RotatedRect CamShift
(InputArray probImage, Rect& window, TermCriteria criteria)¶
cv2.
CamShift
(probImage, window, criteria) → retval, window¶
int cvCamShift
(const CvArr* prob_image, CvRect window, CvTermCriteria criteria, CvConnectedComp* comp, CvBox2D* box=NULL )¶
cv.
CamShift
(prob_image, window, criteria) > (int, comp, box)¶Parameters: 


Returns:  (in old interfaces) Number of iterations CAMSHIFT took to converge 
The function implements the CAMSHIFT object tracking algorithm
[Bradski98].
First, it finds an object center using
meanShift()
and then adjusts the window size and finds the optimal rotation. The function returns the rotated rectangle structure that includes the object position, size, and orientation. The next position of the search window can be obtained with RotatedRect::boundingRect()
.
See the OpenCV sample camshiftdemo.c
that tracks colored objects.
Note
Finds an object on a back projection image.
int meanShift
(InputArray probImage, Rect& window, TermCriteria criteria)¶
cv2.
meanShift
(probImage, window, criteria) → retval, window¶
int cvMeanShift
(const CvArr* prob_image, CvRect window, CvTermCriteria criteria, CvConnectedComp* comp)¶
cv.
MeanShift
(prob_image, window, criteria) → comp¶Parameters: 


Returns:  Number of iterations CAMSHIFT took to converge. 
The function implements the iterative object search algorithm. It takes the input back projection of an object and the initial position. The mass center in window
of the back projection image is computed and the search window center shifts to the mass center. The procedure is repeated until the specified number of iterations criteria.maxCount
is done or until the window center shifts by less than criteria.epsilon
. The algorithm is used inside
CamShift()
and, unlike
CamShift()
, the search window size or orientation do not change during the search. You can simply pass the output of
calcBackProject()
to this function. But better results can be obtained if you prefilter the back projection and remove the noise. For example, you can do this by retrieving connected components with
findContours()
, throwing away contours with small area (
contourArea()
), and rendering the remaining contours with
drawContours()
.
Note
KalmanFilter
¶Kalman filter class.
The class implements a standard Kalman filter
http://en.wikipedia.org/wiki/Kalman_filter, [Welch95]. However, you can modify transitionMatrix
, controlMatrix
, and measurementMatrix
to get an extended Kalman filter functionality. See the OpenCV sample kalman.cpp
.
Note
The constructors.
KalmanFilter::
KalmanFilter
()¶
KalmanFilter::
KalmanFilter
(int dynamParams, int measureParams, int controlParams=0, int type=CV_32F)¶
cv2.
KalmanFilter
([dynamParams, measureParams[, controlParams[, type]]]) → <KalmanFilter object>¶
CvKalman* cvCreateKalman
(int dynam_params, int measure_params, int control_params=0 )¶
cv.
CreateKalman
(dynam_params, measure_params, control_params=0) → CvKalman¶The full constructor.
Parameters: 


Note
In C API when CvKalman* kalmanFilter
structure is not needed anymore, it should be released with cvReleaseKalman(&kalmanFilter)
Reinitializes Kalman filter. The previous content is destroyed.
void KalmanFilter::
init
(int dynamParams, int measureParams, int controlParams=0, int type=CV_32F)¶Parameters: 


Computes a predicted state.
const Mat& KalmanFilter::
predict
(const Mat& control=Mat())¶
cv2.KalmanFilter.
predict
([control]) → retval¶
const CvMat* cvKalmanPredict
(CvKalman* kalman, const CvMat* control=NULL)¶
cv.
KalmanPredict
(kalman, control=None) → mat¶Parameters:  control – The optional input control 

Updates the predicted state from the measurement.
const Mat& KalmanFilter::
correct
(const Mat& measurement)¶
cv2.KalmanFilter.
correct
(measurement) → retval¶
const CvMat* cvKalmanCorrect
(CvKalman* kalman, const CvMat* measurement)¶
cv.
KalmanCorrect
(kalman, measurement) → mat¶Parameters:  measurement – The measured system parameters 

BackgroundSubtractor
: public Algorithm
¶Base class for background/foreground segmentation.
class BackgroundSubtractor : public Algorithm
{
public:
virtual ~BackgroundSubtractor();
virtual void operator()(InputArray image, OutputArray fgmask, double learningRate=0);
virtual void getBackgroundImage(OutputArray backgroundImage) const;
};
The class is only used to define the common interface for the whole family of background/foreground segmentation algorithms.
Computes a foreground mask.
void BackgroundSubtractor::
operator()
(InputArray image, OutputArray fgmask, double learningRate=0)¶
cv2.BackgroundSubtractor.
apply
(image[, fgmask[, learningRate]]) → fgmask¶Parameters: 


Computes a background image.
void BackgroundSubtractor::
getBackgroundImage
(OutputArray backgroundImage) const
¶Parameters: 


Note
Sometimes the background image can be very blurry, as it contain the average background statistics.
BackgroundSubtractorMOG
: public BackgroundSubtractor
¶Gaussian Mixturebased Background/Foreground Segmentation Algorithm.
The class implements the algorithm described in P. KadewTraKuPong and R. Bowden, An improved adaptive background mixture model for realtime tracking with shadow detection, Proc. 2nd European Workshop on Advanced VideoBased Surveillance Systems, 2001: http://personal.ee.surrey.ac.uk/Personal/R.Bowden/publications/avbs01/avbs01.pdf
The constructors.
BackgroundSubtractorMOG::
BackgroundSubtractorMOG
()¶
BackgroundSubtractorMOG::
BackgroundSubtractorMOG
(int history, int nmixtures, double backgroundRatio, double noiseSigma=0)¶
cv2.
BackgroundSubtractorMOG
([history, nmixtures, backgroundRatio[, noiseSigma]]) → <BackgroundSubtractorMOG object>¶Parameters: 


Default constructor sets all parameters to default values.
Updates the background model and returns the foreground mask
void BackgroundSubtractorMOG::
operator()
(InputArray image, OutputArray fgmask, double learningRate=0)¶Parameters are the same as in BackgroundSubtractor::operator()
Gaussian Mixturebased Background/Foreground Segmentation Algorithm.
BackgroundSubtractorMOG2
: public BackgroundSubtractor
¶Here are important members of the class that control the algorithm, which you can set after constructing the class instance:
nmixtures
¶Maximum allowed number of mixture components. Actual number is determined dynamically per pixel.
backgroundRatio
¶Threshold defining whether the component is significant enough to be included into the background model ( corresponds to TB=1cf
from the paper??which paper??). cf=0.1 => TB=0.9
is default. For alpha=0.001
, it means that the mode should exist for approximately 105 frames before it is considered foreground.
varThresholdGen
¶Threshold for the squared Mahalanobis distance that helps decide when a sample is close to the existing components (corresponds to Tg
). If it is not close to any component, a new component is generated. 3 sigma => Tg=3*3=9
is default. A smaller Tg
value generates more components. A higher Tg
value may result in a small number of components but they can grow too large.
fVarInit
¶Initial variance for the newly generated components. It affects the speed of adaptation. The parameter value is based on your estimate of the typical standard deviation from the images. OpenCV uses 15 as a reasonable value.
fVarMin
¶Parameter used to further control the variance.
fVarMax
¶Parameter used to further control the variance.
fCT
¶Complexity reduction parameter. This parameter defines the number of samples needed to accept to prove the component exists. CT=0.05
is a default value for all the samples. By setting CT=0
you get an algorithm very similar to the standard Stauffer&Grimson algorithm.
nShadowDetection
¶The value for marking shadow pixels in the output foreground mask. Default value is 127.
fTau
¶Shadow threshold. The shadow is detected if the pixel is a darker version of the background. Tau
is a threshold defining how much darker the shadow can be. Tau= 0.5
means that if a pixel is more than twice darker then it is not shadow. See Prati,Mikic,Trivedi,Cucchiarra, Detecting Moving Shadows..., IEEE PAMI,2003.
The class implements the Gaussian mixture model background subtraction described in:
 Z.Zivkovic, Improved adaptive Gausian mixture model for background subtraction, International Conference Pattern Recognition, UK, August, 2004, http://www.zoranz.net/Publications/zivkovic2004ICPR.pdf. The code is very fast and performs also shadow detection. Number of Gausssian components is adapted per pixel.
 Z.Zivkovic, F. van der Heijden, Efficient Adaptive Density Estimapion per Image Pixel for the Task of Background Subtraction, Pattern Recognition Letters, vol. 27, no. 7, pages 773780, 2006. The algorithm similar to the standard Stauffer&Grimson algorithm with additional selection of the number of the Gaussian components based on: Z.Zivkovic, F.van der Heijden, Recursive unsupervised learning of finite mixture models, IEEE Trans. on Pattern Analysis and Machine Intelligence, vol.26, no.5, pages 651656, 2004.
The constructors.
BackgroundSubtractorMOG2::
BackgroundSubtractorMOG2
()¶
BackgroundSubtractorMOG2::
BackgroundSubtractorMOG2
(int history, float varThreshold, bool bShadowDetection=true )¶Parameters: 


Updates the background model and computes the foreground mask
void BackgroundSubtractorMOG2::
operator()
(InputArray image, OutputArray fgmask, double learningRate=1)¶Returns background image
void BackgroundSubtractorMOG2::
getBackgroundImage
(OutputArray backgroundImage)¶Calculate an optical flow using “SimpleFlow” algorithm.
void calcOpticalFlowSF
(Mat& from, Mat& to, Mat& flow, int layers, int averaging_block_size, int max_flow)¶
void calcOpticalFlowSF
(Mat& from, Mat& to, Mat& 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)¶Parameters: 


See [Tao2012]. And site of project  http://graphics.berkeley.edu/papers/TaoSAN201205/.
Note
“Dual TV L1” Optical Flow Algorithm.
Ptr<DenseOpticalFlow> createOptFlow_DualTVL1
()¶The class implements the “Dual TV L1” optical flow algorithm described in [Zach2007] and [Javier2012] .
Here are important members of the class that control the algorithm, which you can set after constructing the class instance:
 double
tau
¶Time step of the numerical scheme.
 double
lambda
¶Weight parameter for the data term, attachment parameter. This is the most relevant parameter, which determines the smoothness of the output. The smaller this parameter is, the smoother the solutions we obtain. It depends on the range of motions of the images, so its value should be adapted to each image sequence.
 double
theta
¶Weight parameter for (u  v)^2, tightness parameter. It serves as a link between the attachment and the regularization terms. In theory, it should have a small value in order to maintain both parts in correspondence. The method is stable for a large range of values of this parameter.
 int
nscales
¶Number of scales used to create the pyramid of images.
 int
warps
¶Number of warpings per scale. Represents the number of times that I1(x+u0) and grad( I1(x+u0) ) are computed per scale. This is a parameter that assures the stability of the method. It also affects the running time, so it is a compromise between speed and accuracy.
 double
epsilon
¶Stopping criterion threshold used in the numerical scheme, which is a tradeoff between precision and running time. A small value will yield more accurate solutions at the expense of a slower convergence.
 int
iterations
¶Stopping criterion iterations number used in the numerical scheme.
Calculates an optical flow.
void DenseOpticalFlow::
calc
(InputArray I0, InputArray I1, InputOutputArray flow)¶Parameters: 


Releases all inner buffers.
void DenseOpticalFlow::
collectGarbage
()¶[Bouguet00]  (1, 2) JeanYves Bouguet. Pyramidal Implementation of the Lucas Kanade Feature Tracker. 
[Bradski98]  Bradski, G.R. “Computer Vision Face Tracking for Use in a Perceptual User Interface”, Intel, 1998 
[Bradski00]  Davis, J.W. and Bradski, G.R. “Motion Segmentation and Pose Recognition with Motion History Gradients”, WACV00, 2000 
[Davis97]  Davis, J.W. and Bobick, A.F. “The Representation and Recognition of Action Using Temporal Templates”, CVPR97, 1997 
[Farneback2003]  Gunnar Farneback, Twoframe motion estimation based on polynomial expansion, Lecture Notes in Computer Science, 2003, (2749), , 363370. 
[Horn81]  Berthold K.P. Horn and Brian G. Schunck. Determining Optical Flow. Artificial Intelligence, 17, pp. 185203, 1981. 
[Lucas81]  Lucas, B., and Kanade, T. An Iterative Image Registration Technique with an Application to Stereo Vision, Proc. of 7th International Joint Conference on Artificial Intelligence (IJCAI), pp. 674679. 
[Welch95]  Greg Welch and Gary Bishop “An Introduction to the Kalman Filter”, 1995 
[Tao2012]  Michael Tao, Jiamin Bai, Pushmeet Kohli and Sylvain Paris. SimpleFlow: A Noniterative, Sublinear Optical Flow Algorithm. Computer Graphics Forum (Eurographics 2012) 
[Zach2007] 

[Javier2012]  Javier Sanchez, Enric MeinhardtLlopis and Gabriele Facciolo. “TVL1 Optical Flow Estimation”. 