Motion Templates ================ Motion templates is alternative technique for detecting motion and computing its direction. See ``samples/motempl.py``. updateMotionHistory ----------------------- Updates the motion history image by a moving silhouette. .. ocv:function:: void updateMotionHistory( InputArray silhouette, InputOutputArray mhi, double timestamp, double duration ) .. ocv:pyfunction:: cv2.updateMotionHistory(silhouette, mhi, timestamp, duration) -> mhi :param silhouette: Silhouette mask that has non-zero pixels where the motion occurs. :param mhi: Motion history image that is updated by the function (single-channel, 32-bit floating-point). :param timestamp: Current time in milliseconds or other units. :param duration: Maximal duration of the motion track in the same units as ``timestamp`` . The function updates the motion history image as follows: .. math:: \texttt{mhi} (x,y)= \forkthree{\texttt{timestamp}}{if $\texttt{silhouette}(x,y) \ne 0$}{0}{if $\texttt{silhouette}(x,y) = 0$ and $\texttt{mhi} < (\texttt{timestamp} - \texttt{duration})$}{\texttt{mhi}(x,y)}{otherwise} 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 :ocv:func:`calcMotionGradient` and :ocv:func:`calcGlobalOrientation` , implements a motion templates technique described in [Davis97]_ and [Bradski00]_. calcMotionGradient ---------------------- Calculates a gradient orientation of a motion history image. .. ocv:function:: void calcMotionGradient( InputArray mhi, OutputArray mask, OutputArray orientation, double delta1, double delta2, int apertureSize=3 ) .. ocv:pyfunction:: cv2.calcMotionGradient(mhi, delta1, delta2[, mask[, orientation[, apertureSize]]]) -> mask, orientation :param mhi: Motion history single-channel floating-point image. :param mask: Output mask image that has the type ``CV_8UC1`` and the same size as ``mhi`` . Its non-zero elements mark pixels where the motion gradient data is correct. :param orientation: Output motion gradient orientation image that has the same type and the same size as ``mhi`` . Each pixel of the image is a motion orientation, from 0 to 360 degrees. :param delta1: Minimal (or maximal) allowed difference between ``mhi`` values within a pixel neighborhood. :param delta2: Maximal (or minimal) allowed difference between ``mhi`` values within a pixel neighborhood. That is, the function finds the minimum ( :math:`m(x,y)` ) and maximum ( :math:`M(x,y)` ) ``mhi`` values over :math:`3 \times 3` neighborhood of each pixel and marks the motion orientation at :math:`(x, y)` as valid only if .. math:: \min ( \texttt{delta1} , \texttt{delta2} ) \le M(x,y)-m(x,y) \le \max ( \texttt{delta1} , \texttt{delta2} ). :param apertureSize: Aperture size of the :ocv:func:`Sobel` operator. The function calculates a gradient orientation at each pixel :math:`(x, y)` as: .. math:: \texttt{orientation} (x,y)= \arctan{\frac{d\texttt{mhi}/dy}{d\texttt{mhi}/dx}} In fact, :ocv:func:`fastAtan2` and :ocv:func:`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:: * (Python) An example on how to perform a motion template technique can be found at opencv_source_code/samples/python2/motempl.py calcGlobalOrientation ------------------------- Calculates a global motion orientation in a selected region. .. ocv:function:: double calcGlobalOrientation( InputArray orientation, InputArray mask, InputArray mhi, double timestamp, double duration ) .. ocv:pyfunction:: cv2.calcGlobalOrientation(orientation, mask, mhi, timestamp, duration) -> retval :param orientation: Motion gradient orientation image calculated by the function :ocv:func:`calcMotionGradient` . :param mask: Mask image. It may be a conjunction of a valid gradient mask, also calculated by :ocv:func:`calcMotionGradient` , and the mask of a region whose direction needs to be calculated. :param mhi: Motion history image calculated by :ocv:func:`updateMotionHistory` . :param timestamp: Timestamp passed to :ocv:func:`updateMotionHistory` . :param duration: Maximum duration of a motion track in milliseconds, passed to :ocv:func:`updateMotionHistory` . 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`` . segmentMotion ------------- Splits a motion history image into a few parts corresponding to separate independent motions (for example, left hand, right hand). .. ocv:function:: void segmentMotion(InputArray mhi, OutputArray segmask, vector& boundingRects, double timestamp, double segThresh) .. ocv:pyfunction:: cv2.segmentMotion(mhi, timestamp, segThresh[, segmask]) -> segmask, boundingRects :param mhi: Motion history image. :param segmask: Image where the found mask should be stored, single-channel, 32-bit floating-point. :param boundingRects: Vector containing ROIs of motion connected components. :param timestamp: Current time in milliseconds or other units. :param segThresh: Segmentation threshold that is recommended to be equal to the interval between motion history "steps" or greater. 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 :ocv:func:`calcGlobalOrientation` using the extracted mask of the particular component. .. [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