OpenCV  4.10.0
Open Source Computer Vision
Loading...
Searching...
No Matches
Functions
Motion Analysis and Object Tracking

Detailed Description

Functions

void cv::accumulate (InputArray src, InputOutputArray dst, InputArray mask=noArray())
 Adds an image to the accumulator image.
 
void cv::accumulateProduct (InputArray src1, InputArray src2, InputOutputArray dst, InputArray mask=noArray())
 Adds the per-element product of two input images to the accumulator image.
 
void cv::accumulateSquare (InputArray src, InputOutputArray dst, InputArray mask=noArray())
 Adds the square of a source image to the accumulator image.
 
void cv::accumulateWeighted (InputArray src, InputOutputArray dst, double alpha, InputArray mask=noArray())
 Updates a running average.
 
void cv::createHanningWindow (OutputArray dst, Size winSize, int type)
 This function computes a Hanning window coefficients in two dimensions.
 
void cv::divSpectrums (InputArray a, InputArray b, OutputArray c, int flags, bool conjB=false)
 Performs the per-element division of the first Fourier spectrum by the second Fourier spectrum.
 
Point2d cv::phaseCorrelate (InputArray src1, InputArray src2, InputArray window=noArray(), double *response=0)
 The function is used to detect translational shifts that occur between two images.
 

Function Documentation

◆ accumulate()

void cv::accumulate ( InputArray  src,
InputOutputArray  dst,
InputArray  mask = noArray() 
)
Python:
cv.accumulate(src, dst[, mask]) -> dst

#include <opencv2/imgproc.hpp>

Adds an image to the accumulator image.

The function adds src or some of its elements to dst :

\[\texttt{dst} (x,y) \leftarrow \texttt{dst} (x,y) + \texttt{src} (x,y) \quad \text{if} \quad \texttt{mask} (x,y) \ne 0\]

The function supports multi-channel images. Each channel is processed independently.

The function cv::accumulate can be used, for example, to collect statistics of a scene background viewed by a still camera and for the further foreground-background segmentation.

Parameters
srcInput image of type CV_8UC(n), CV_16UC(n), CV_32FC(n) or CV_64FC(n), where n is a positive integer.
dstAccumulator image with the same number of channels as input image, and a depth of CV_32F or CV_64F.
maskOptional operation mask.
See also
accumulateSquare, accumulateProduct, accumulateWeighted

◆ accumulateProduct()

void cv::accumulateProduct ( InputArray  src1,
InputArray  src2,
InputOutputArray  dst,
InputArray  mask = noArray() 
)
Python:
cv.accumulateProduct(src1, src2, dst[, mask]) -> dst

#include <opencv2/imgproc.hpp>

Adds the per-element product of two input images to the accumulator image.

The function adds the product of two images or their selected regions to the accumulator dst :

\[\texttt{dst} (x,y) \leftarrow \texttt{dst} (x,y) + \texttt{src1} (x,y) \cdot \texttt{src2} (x,y) \quad \text{if} \quad \texttt{mask} (x,y) \ne 0\]

The function supports multi-channel images. Each channel is processed independently.

Parameters
src1First input image, 1- or 3-channel, 8-bit or 32-bit floating point.
src2Second input image of the same type and the same size as src1 .
dstAccumulator image with the same number of channels as input images, 32-bit or 64-bit floating-point.
maskOptional operation mask.
See also
accumulate, accumulateSquare, accumulateWeighted

◆ accumulateSquare()

void cv::accumulateSquare ( InputArray  src,
InputOutputArray  dst,
InputArray  mask = noArray() 
)
Python:
cv.accumulateSquare(src, dst[, mask]) -> dst

#include <opencv2/imgproc.hpp>

Adds the square of a source image to the accumulator image.

The function adds the input image src or its selected region, raised to a power of 2, to the accumulator dst :

\[\texttt{dst} (x,y) \leftarrow \texttt{dst} (x,y) + \texttt{src} (x,y)^2 \quad \text{if} \quad \texttt{mask} (x,y) \ne 0\]

The function supports multi-channel images. Each channel is processed independently.

Parameters
srcInput image as 1- or 3-channel, 8-bit or 32-bit floating point.
dstAccumulator image with the same number of channels as input image, 32-bit or 64-bit floating-point.
maskOptional operation mask.
See also
accumulateSquare, accumulateProduct, accumulateWeighted

◆ accumulateWeighted()

void cv::accumulateWeighted ( InputArray  src,
InputOutputArray  dst,
double  alpha,
InputArray  mask = noArray() 
)
Python:
cv.accumulateWeighted(src, dst, alpha[, mask]) -> dst

#include <opencv2/imgproc.hpp>

Updates a running average.

The function calculates the weighted sum of the input image src and the accumulator dst so that dst becomes a running average of a frame sequence:

\[\texttt{dst} (x,y) \leftarrow (1- \texttt{alpha} ) \cdot \texttt{dst} (x,y) + \texttt{alpha} \cdot \texttt{src} (x,y) \quad \text{if} \quad \texttt{mask} (x,y) \ne 0\]

That is, alpha regulates the update speed (how fast the accumulator "forgets" about earlier images). The function supports multi-channel images. Each channel is processed independently.

Parameters
srcInput image as 1- or 3-channel, 8-bit or 32-bit floating point.
dstAccumulator image with the same number of channels as input image, 32-bit or 64-bit floating-point.
alphaWeight of the input image.
maskOptional operation mask.
See also
accumulate, accumulateSquare, accumulateProduct

◆ createHanningWindow()

void cv::createHanningWindow ( OutputArray  dst,
Size  winSize,
int  type 
)
Python:
cv.createHanningWindow(winSize, type[, dst]) -> dst

#include <opencv2/imgproc.hpp>

This function computes a Hanning window coefficients in two dimensions.

See (http://en.wikipedia.org/wiki/Hann_function) and (http://en.wikipedia.org/wiki/Window_function) for more information.

An example is shown below:

// create hanning window of size 100x100 and type CV_32F
Mat hann;
createHanningWindow(hann, Size(100, 100), CV_32F);
n-dimensional dense array class
Definition mat.hpp:812
Size2i Size
Definition types.hpp:370
#define CV_32F
Definition interface.h:78
void createHanningWindow(OutputArray dst, Size winSize, int type)
This function computes a Hanning window coefficients in two dimensions.
Parameters
dstDestination array to place Hann coefficients in
winSizeThe window size specifications (both width and height must be > 1)
typeCreated array type

◆ divSpectrums()

void cv::divSpectrums ( InputArray  a,
InputArray  b,
OutputArray  c,
int  flags,
bool  conjB = false 
)
Python:
cv.divSpectrums(a, b, flags[, c[, conjB]]) -> c

#include <opencv2/imgproc.hpp>

Performs the per-element division of the first Fourier spectrum by the second Fourier spectrum.

The function cv::divSpectrums performs the per-element division of the first array by the second array. The arrays are CCS-packed or complex matrices that are results of a real or complex Fourier transform.

Parameters
afirst input array.
bsecond input array of the same size and type as src1 .
coutput array of the same size and type as src1 .
flagsoperation flags; currently, the only supported flag is cv::DFT_ROWS, which indicates that each row of src1 and src2 is an independent 1D Fourier spectrum. If you do not want to use this flag, then simply add a 0 as value.
conjBoptional flag that conjugates the second input array before the multiplication (true) or not (false).

◆ phaseCorrelate()

Point2d cv::phaseCorrelate ( InputArray  src1,
InputArray  src2,
InputArray  window = noArray(),
double *  response = 0 
)
Python:
cv.phaseCorrelate(src1, src2[, window]) -> retval, response

#include <opencv2/imgproc.hpp>

The function is used to detect translational shifts that occur between two images.

The operation takes advantage of the Fourier shift theorem for detecting the translational shift in the frequency domain. It can be used for fast image registration as well as motion estimation. For more information please see http://en.wikipedia.org/wiki/Phase_correlation

Calculates the cross-power spectrum of two supplied source arrays. The arrays are padded if needed with getOptimalDFTSize.

The function performs the following equations:

  • First it applies a Hanning window (see http://en.wikipedia.org/wiki/Hann_function) to each image to remove possible edge effects. This window is cached until the array size changes to speed up processing time.
  • Next it computes the forward DFTs of each source array:

    \[\mathbf{G}_a = \mathcal{F}\{src_1\}, \; \mathbf{G}_b = \mathcal{F}\{src_2\}\]

    where \(\mathcal{F}\) is the forward DFT.
  • It then computes the cross-power spectrum of each frequency domain array:

    \[R = \frac{ \mathbf{G}_a \mathbf{G}_b^*}{|\mathbf{G}_a \mathbf{G}_b^*|}\]

  • Next the cross-correlation is converted back into the time domain via the inverse DFT:

    \[r = \mathcal{F}^{-1}\{R\}\]

  • Finally, it computes the peak location and computes a 5x5 weighted centroid around the peak to achieve sub-pixel accuracy.

    \[(\Delta x, \Delta y) = \texttt{weightedCentroid} \{\arg \max_{(x, y)}\{r\}\}\]

  • If non-zero, the response parameter is computed as the sum of the elements of r within the 5x5 centroid around the peak location. It is normalized to a maximum of 1 (meaning there is a single peak) and will be smaller when there are multiple peaks.
Parameters
src1Source floating point array (CV_32FC1 or CV_64FC1)
src2Source floating point array (CV_32FC1 or CV_64FC1)
windowFloating point array with windowing coefficients to reduce edge effects (optional).
responseSignal power within the 5x5 centroid around the peak, between 0 and 1 (optional).
Returns
detected phase shift (sub-pixel) between the two arrays.
See also
dft, getOptimalDFTSize, idft, mulSpectrums createHanningWindow