modules/legacy/doc/motion_analysis.rst

   1 Motion Analysis
   2 ===============
   3
   4 .. highlight:: cpp
   5
   6
   7 CalcOpticalFlowBM
   8 -----------------
   9 Calculates the optical flow for two images by using the block matching method.
  10
  11 .. ocv:cfunction:: void cvCalcOpticalFlowBM( const CvArr* prev, const CvArr* curr, CvSize block_size, CvSize shift_size, CvSize max_range, int use_previous, CvArr* velx, CvArr* vely )
  12
  13         :param prev: First image, 8-bit, single-channel
  14
  15         :param curr: Second image, 8-bit, single-channel
  16
  17         :param block_size: Size of basic blocks that are compared
  18
  19         :param shift_size: Block coordinate increments
  20
  21         :param max_range: Size of the scanned neighborhood in pixels around the block
  22
  23         :param use_previous: Flag that specifies whether to use the input velocity as initial approximations or not.
  24
  25         :param velx: Horizontal component of the optical flow of
  26
  27             .. math::
  28
  29                 \left \lfloor   \frac{\texttt{prev->width} - \texttt{block\_size.width}}{\texttt{shift\_size.width}}   \right \rfloor \times \left \lfloor   \frac{\texttt{prev->height} - \texttt{block\_size.height}}{\texttt{shift\_size.height}}   \right \rfloor
  30
  31             size, 32-bit floating-point, single-channel
  32
  33         :param vely: Vertical component of the optical flow of the same size  ``velx`` , 32-bit floating-point, single-channel
  34
  35
  36 The function calculates the optical flow for overlapped blocks ``block_size.width x block_size.height`` pixels each, thus the velocity fields are smaller than the original images. For every block in  ``prev``
  37 the functions tries to find a similar block in ``curr`` in some neighborhood of the original block or shifted by ``(velx(x0,y0), vely(x0,y0))`` block as has been calculated by previous function call (if ``use_previous=1``)
  38
  39
  40 CalcOpticalFlowHS
  41 -----------------
  42 Calculates the optical flow for two images using Horn-Schunck algorithm.
  43
  44 .. ocv:cfunction:: void cvCalcOpticalFlowHS(const CvArr* prev, const CvArr* curr, int use_previous, CvArr* velx, CvArr* vely, double lambda, CvTermCriteria criteria)
  45
  46     :param prev: First image, 8-bit, single-channel
  47
  48     :param curr: Second image, 8-bit, single-channel
  49
  50     :param use_previous: Flag that specifies whether to use the input velocity as initial approximations or not.
  51
  52     :param velx: Horizontal component of the optical flow of the same size as input images, 32-bit floating-point, single-channel
  53
  54     :param vely: Vertical component of the optical flow of the same size as input images, 32-bit floating-point, single-channel
  55
  56     :param lambda: Smoothness weight. The larger it is, the smoother optical flow map you get.
  57
  58     :param criteria: Criteria of termination of velocity computing
  59
  60 The function computes the flow for every pixel of the first input image using the Horn and Schunck algorithm [Horn81]_. The function is obsolete. To track sparse features, use :ocv:func:`calcOpticalFlowPyrLK`. To track all the pixels, use :ocv:func:`calcOpticalFlowFarneback`.
  61
  62
  63 CalcOpticalFlowLK
  64 -----------------
  65
  66 Calculates the optical flow for two images using Lucas-Kanade algorithm.
  67
  68 .. ocv:cfunction:: void cvCalcOpticalFlowLK( const CvArr* prev, const CvArr* curr, CvSize win_size, CvArr* velx, CvArr* vely )
  69
  70     :param prev: First image, 8-bit, single-channel
  71
  72     :param curr: Second image, 8-bit, single-channel
  73
  74     :param win_size: Size of the averaging window used for grouping pixels
  75
  76     :param velx: Horizontal component of the optical flow of the same size as input images, 32-bit floating-point, single-channel
  77
  78     :param vely: Vertical component of the optical flow of the same size as input images, 32-bit floating-point, single-channel
  79
  80 The function computes the flow for every pixel of the first input image using the Lucas and Kanade algorithm [Lucas81]_. The function is obsolete. To track sparse features, use :ocv:func:`calcOpticalFlowPyrLK`. To track all the pixels, use :ocv:func:`calcOpticalFlowFarneback`.