Operations on arrays

Detailed Description

Classes
class	cv::LDA
	Linear Discriminant Analysis. More...
class	cv::PCA
	Principal Component Analysis. More...
class	cv::RNG
	Random Number Generator. More...
class	cv::RNG_MT19937
	Mersenne Twister random number generator. More...
class	cv::SVD
	Singular Value Decomposition. More...

Enumerations
enum	cv::BorderTypes {   cv::BORDER_CONSTANT = 0 ,   cv::BORDER_REPLICATE = 1 ,   cv::BORDER_REFLECT = 2 ,   cv::BORDER_WRAP = 3 ,   cv::BORDER_REFLECT_101 = 4 ,   cv::BORDER_TRANSPARENT = 5 ,   cv::BORDER_REFLECT101 = BORDER_REFLECT_101 ,   cv::BORDER_DEFAULT = BORDER_REFLECT_101 ,   cv::BORDER_ISOLATED = 16 }
enum	cv::CmpTypes {   cv::CMP_EQ = 0 ,   cv::CMP_GT = 1 ,   cv::CMP_GE = 2 ,   cv::CMP_LT = 3 ,   cv::CMP_LE = 4 ,   cv::CMP_NE = 5 }
	comparison types More...
enum	cv::CovarFlags {   cv::COVAR_SCRAMBLED = 0 ,   cv::COVAR_NORMAL = 1 ,   cv::COVAR_USE_AVG = 2 ,   cv::COVAR_SCALE = 4 ,   cv::COVAR_ROWS = 8 ,   cv::COVAR_COLS = 16 }
	Covariation flags. More...
enum	cv::DecompTypes {   cv::DECOMP_LU = 0 ,   cv::DECOMP_SVD = 1 ,   cv::DECOMP_EIG = 2 ,   cv::DECOMP_CHOLESKY = 3 ,   cv::DECOMP_QR = 4 ,   cv::DECOMP_NORMAL = 16 }
	matrix decomposition types More...
enum	cv::DftFlags {   cv::DFT_INVERSE = 1 ,   cv::DFT_SCALE = 2 ,   cv::DFT_ROWS = 4 ,   cv::DFT_COMPLEX_OUTPUT = 16 ,   cv::DFT_REAL_OUTPUT = 32 ,   cv::DFT_COMPLEX_INPUT = 64 ,   cv::DCT_INVERSE = DFT_INVERSE ,   cv::DCT_ROWS = DFT_ROWS }
enum	cv::GemmFlags {   cv::GEMM_1_T = 1 ,   cv::GEMM_2_T = 2 ,   cv::GEMM_3_T = 4 }
	generalized matrix multiplication flags More...
enum	cv::NormTypes {   cv::NORM_INF = 1 ,   cv::NORM_L1 = 2 ,   cv::NORM_L2 = 4 ,   cv::NORM_L2SQR = 5 ,   cv::NORM_HAMMING = 6 ,   cv::NORM_HAMMING2 = 7 ,   cv::NORM_TYPE_MASK = 7 ,   cv::NORM_RELATIVE = 8 ,   cv::NORM_MINMAX = 32 }
enum	cv::ReduceTypes {   cv::REDUCE_SUM = 0 ,   cv::REDUCE_AVG = 1 ,   cv::REDUCE_MAX = 2 ,   cv::REDUCE_MIN = 3 ,   cv::REDUCE_SUM2 = 4 }
enum	cv::RotateFlags {   cv::ROTATE_90_CLOCKWISE = 0 ,   cv::ROTATE_180 = 1 ,   cv::ROTATE_90_COUNTERCLOCKWISE = 2 }

Functions
void	cv::absdiff (InputArray src1, InputArray src2, OutputArray dst)
	Calculates the per-element absolute difference between two arrays or between an array and a scalar.
void	cv::add (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray(), int dtype=-1)
	Calculates the per-element sum of two arrays or an array and a scalar.
void	cv::addWeighted (InputArray src1, double alpha, InputArray src2, double beta, double gamma, OutputArray dst, int dtype=-1)
	Calculates the weighted sum of two arrays.
void	cv::batchDistance (InputArray src1, InputArray src2, OutputArray dist, int dtype, OutputArray nidx, int normType=NORM_L2, int K=0, InputArray mask=noArray(), int update=0, bool crosscheck=false)
	naive nearest neighbor finder
void	cv::bitwise_and (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray())
	computes bitwise conjunction of the two arrays (dst = src1 & src2) Calculates the per-element bit-wise conjunction of two arrays or an array and a scalar.
void	cv::bitwise_not (InputArray src, OutputArray dst, InputArray mask=noArray())
	Inverts every bit of an array.
void	cv::bitwise_or (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray())
	Calculates the per-element bit-wise disjunction of two arrays or an array and a scalar.
void	cv::bitwise_xor (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray())
	Calculates the per-element bit-wise "exclusive or" operation on two arrays or an array and a scalar.
int	cv::borderInterpolate (int p, int len, int borderType)
	Computes the source location of an extrapolated pixel.
void	cv::broadcast (InputArray src, const MatShape &shape, OutputArray dst)
	Broadcast the given Mat to the given shape.
void	cv::broadcast (InputArray src, InputArray shape, OutputArray dst)
	Broadcast the given Mat to the given shape.
void	cv::calcCovarMatrix (const Mat *samples, int nsamples, Mat &covar, Mat &mean, int flags, int ctype=CV_64F)
	Calculates the covariance matrix of a set of vectors.
void	cv::calcCovarMatrix (InputArray samples, OutputArray covar, InputOutputArray mean, int flags, int ctype=CV_64F)
void	cv::cartToPolar (InputArray x, InputArray y, OutputArray magnitude, OutputArray angle, bool angleInDegrees=false)
	Calculates the magnitude and angle of 2D vectors.
bool	cv::checkRange (InputArray a, bool quiet=true, Point *pos=0, double minVal=-DBL_MAX, double maxVal=DBL_MAX)
	Checks every element of an input array for invalid values.
void	cv::compare (InputArray src1, InputArray src2, OutputArray dst, int cmpop)
	Performs the per-element comparison of two arrays or an array and scalar value.
void	cv::completeSymm (InputOutputArray m, bool lowerToUpper=false)
	Copies the lower or the upper half of a square matrix to its another half.
void	cv::convertScaleAbs (InputArray src, OutputArray dst, double alpha=1, double beta=0)
	Scales, calculates absolute values, and converts the result to 8-bit.
void	cv::copyMakeBorder (InputArray src, OutputArray dst, int top, int bottom, int left, int right, int borderType, const Scalar &value=Scalar())
	Forms a border around an image.
void	cv::copyTo (InputArray src, OutputArray dst, InputArray mask)
	This is an overloaded member function, provided for convenience (python) Copies the matrix to another one. When the operation mask is specified, if the Mat::create call shown above reallocates the matrix, the newly allocated matrix is initialized with all zeros before copying the data.
int	cv::countNonZero (InputArray src)
	Counts non-zero array elements.
void	cv::dct (InputArray src, OutputArray dst, int flags=0)
	Performs a forward or inverse discrete Cosine transform of 1D or 2D array.
double	cv::determinant (InputArray mtx)
	Returns the determinant of a square floating-point matrix.
void	cv::dft (InputArray src, OutputArray dst, int flags=0, int nonzeroRows=0)
	Performs a forward or inverse Discrete Fourier transform of a 1D or 2D floating-point array.
void	cv::divide (double scale, InputArray src2, OutputArray dst, int dtype=-1)
void	cv::divide (InputArray src1, InputArray src2, OutputArray dst, double scale=1, int dtype=-1)
	Performs per-element division of two arrays or a scalar by an array.
bool	cv::eigen (InputArray src, OutputArray eigenvalues, OutputArray eigenvectors=noArray())
	Calculates eigenvalues and eigenvectors of a symmetric matrix.
void	cv::eigenNonSymmetric (InputArray src, OutputArray eigenvalues, OutputArray eigenvectors)
	Calculates eigenvalues and eigenvectors of a non-symmetric matrix (real eigenvalues only).
void	cv::exp (InputArray src, OutputArray dst)
	Calculates the exponent of every array element.
void	cv::extractChannel (InputArray src, OutputArray dst, int coi)
	Extracts a single channel from src (coi is 0-based index)
void	cv::findNonZero (InputArray src, OutputArray idx)
	Returns the list of locations of non-zero pixels.
void	cv::finiteMask (InputArray src, OutputArray mask)
	Generates a mask of finite float values, i.e. not NaNs nor Infs.
void	cv::flip (InputArray src, OutputArray dst, int flipCode)
	Flips a 2D array around vertical, horizontal, or both axes.
void	cv::flipND (InputArray src, OutputArray dst, int axis)
	Flips a n-dimensional at given axis.
void	cv::gemm (InputArray src1, InputArray src2, double alpha, InputArray src3, double beta, OutputArray dst, int flags=0)
	Performs generalized matrix multiplication.
int	cv::getOptimalDFTSize (int vecsize)
	Returns the optimal DFT size for a given vector size.
bool	cv::hasNonZero (InputArray src)
	Checks for the presence of at least one non-zero array element.
void	cv::hconcat (const Mat *src, size_t nsrc, OutputArray dst)
	Applies horizontal concatenation to given matrices.
void	cv::hconcat (InputArray src1, InputArray src2, OutputArray dst)
void	cv::hconcat (InputArrayOfArrays src, OutputArray dst)
void	cv::idct (InputArray src, OutputArray dst, int flags=0)
	Calculates the inverse Discrete Cosine Transform of a 1D or 2D array.
void	cv::idft (InputArray src, OutputArray dst, int flags=0, int nonzeroRows=0)
	Calculates the inverse Discrete Fourier Transform of a 1D or 2D array.
void	cv::inRange (InputArray src, InputArray lowerb, InputArray upperb, OutputArray dst)
	Checks if array elements lie between the elements of two other arrays.
void	cv::insertChannel (InputArray src, InputOutputArray dst, int coi)
	Inserts a single channel to dst (coi is 0-based index)
double	cv::invert (InputArray src, OutputArray dst, int flags=DECOMP_LU)
	Finds the inverse or pseudo-inverse of a matrix.
void	cv::log (InputArray src, OutputArray dst)
	Calculates the natural logarithm of every array element.
void	cv::LUT (InputArray src, InputArray lut, OutputArray dst)
	Performs a look-up table transform of an array.
void	cv::magnitude (InputArray x, InputArray y, OutputArray magnitude)
	Calculates the magnitude of 2D vectors.
double	cv::Mahalanobis (InputArray v1, InputArray v2, InputArray icovar)
	Calculates the Mahalanobis distance between two vectors.
void	cv::max (const Mat &src1, const Mat &src2, Mat &dst)
void	cv::max (const UMat &src1, const UMat &src2, UMat &dst)
void	cv::max (InputArray src1, InputArray src2, OutputArray dst)
	Calculates per-element maximum of two arrays or an array and a scalar.
Scalar	cv::mean (InputArray src, InputArray mask=noArray())
	Calculates an average (mean) of array elements.
void	cv::meanStdDev (InputArray src, OutputArray mean, OutputArray stddev, InputArray mask=noArray())
void	cv::merge (const Mat *mv, size_t count, OutputArray dst)
	Creates one multi-channel array out of several single-channel ones.
void	cv::merge (InputArrayOfArrays mv, OutputArray dst)
void	cv::min (const Mat &src1, const Mat &src2, Mat &dst)
void	cv::min (const UMat &src1, const UMat &src2, UMat &dst)
void	cv::min (InputArray src1, InputArray src2, OutputArray dst)
	Calculates per-element minimum of two arrays or an array and a scalar.
void	cv::minMaxIdx (InputArray src, double *minVal, double *maxVal=0, int *minIdx=0, int *maxIdx=0, InputArray mask=noArray())
	Finds the global minimum and maximum in an array.
void	cv::minMaxLoc (const SparseMat &a, double *minVal, double *maxVal, int *minIdx=0, int *maxIdx=0)
void	cv::minMaxLoc (InputArray src, double *minVal, double *maxVal=0, Point *minLoc=0, Point *maxLoc=0, InputArray mask=noArray())
	Finds the global minimum and maximum in an array.
void	cv::mixChannels (const Mat *src, size_t nsrcs, Mat *dst, size_t ndsts, const int *fromTo, size_t npairs)
	Copies specified channels from input arrays to the specified channels of output arrays.
void	cv::mixChannels (InputArrayOfArrays src, InputOutputArrayOfArrays dst, const int *fromTo, size_t npairs)
void	cv::mixChannels (InputArrayOfArrays src, InputOutputArrayOfArrays dst, const std::vector< int > &fromTo)
void	cv::mulSpectrums (InputArray a, InputArray b, OutputArray c, int flags, bool conjB=false)
	Performs the per-element multiplication of two Fourier spectrums.
void	cv::multiply (InputArray src1, InputArray src2, OutputArray dst, double scale=1, int dtype=-1)
	Calculates the per-element scaled product of two arrays.
void	cv::mulTransposed (InputArray src, OutputArray dst, bool aTa, InputArray delta=noArray(), double scale=1, int dtype=-1)
	Calculates the product of a matrix and its transposition.
double	cv::norm (const SparseMat &src, int normType)
double	cv::norm (InputArray src1, InputArray src2, int normType=NORM_L2, InputArray mask=noArray())
	Calculates an absolute difference norm or a relative difference norm.
double	cv::norm (InputArray src1, int normType=NORM_L2, InputArray mask=noArray())
	Calculates the absolute norm of an array.
void	cv::normalize (const SparseMat &src, SparseMat &dst, double alpha, int normType)
void	cv::normalize (InputArray src, InputOutputArray dst, double alpha=1, double beta=0, int norm_type=NORM_L2, int dtype=-1, InputArray mask=noArray())
	Normalizes the norm or value range of an array.
void	cv::patchNaNs (InputOutputArray a, double val=0)
	Replaces NaNs by given number.
void	cv::PCABackProject (InputArray data, InputArray mean, InputArray eigenvectors, OutputArray result)
void	cv::PCACompute (InputArray data, InputOutputArray mean, OutputArray eigenvectors, double retainedVariance)
void	cv::PCACompute (InputArray data, InputOutputArray mean, OutputArray eigenvectors, int maxComponents=0)
void	cv::PCACompute (InputArray data, InputOutputArray mean, OutputArray eigenvectors, OutputArray eigenvalues, double retainedVariance)
void	cv::PCACompute (InputArray data, InputOutputArray mean, OutputArray eigenvectors, OutputArray eigenvalues, int maxComponents=0)
void	cv::PCAProject (InputArray data, InputArray mean, InputArray eigenvectors, OutputArray result)
void	cv::perspectiveTransform (InputArray src, OutputArray dst, InputArray m)
	Performs the perspective matrix transformation of vectors.
void	cv::phase (InputArray x, InputArray y, OutputArray angle, bool angleInDegrees=false)
	Calculates the rotation angle of 2D vectors.
void	cv::polarToCart (InputArray magnitude, InputArray angle, OutputArray x, OutputArray y, bool angleInDegrees=false)
	Calculates x and y coordinates of 2D vectors from their magnitude and angle.
void	cv::pow (InputArray src, double power, OutputArray dst)
	Raises every array element to a power.
double	cv::PSNR (InputArray src1, InputArray src2, double R=255.)
	Computes the Peak Signal-to-Noise Ratio (PSNR) image quality metric.
void	cv::randn (InputOutputArray dst, InputArray mean, InputArray stddev)
	Fills the array with normally distributed random numbers.
void	cv::randShuffle (InputOutputArray dst, double iterFactor=1., RNG *rng=0)
	Shuffles the array elements randomly.
void	cv::randu (InputOutputArray dst, InputArray low, InputArray high)
	Generates a single uniformly-distributed random number or an array of random numbers.
void	cv::reduce (InputArray src, OutputArray dst, int dim, int rtype, int dtype=-1)
	Reduces a matrix to a vector.
void	cv::reduceArgMax (InputArray src, OutputArray dst, int axis, bool lastIndex=false)
	Finds indices of max elements along provided axis.
void	cv::reduceArgMin (InputArray src, OutputArray dst, int axis, bool lastIndex=false)
	Finds indices of min elements along provided axis.
Mat	cv::repeat (const Mat &src, int ny, int nx)
void	cv::repeat (InputArray src, int ny, int nx, OutputArray dst)
	Fills the output array with repeated copies of the input array.
void	cv::rotate (InputArray src, OutputArray dst, int rotateCode)
	Rotates a 2D array in multiples of 90 degrees. The function cv::rotate rotates the array in one of three different ways: Rotate by 90 degrees clockwise (rotateCode = ROTATE_90_CLOCKWISE). Rotate by 180 degrees clockwise (rotateCode = ROTATE_180). Rotate by 270 degrees clockwise (rotateCode = ROTATE_90_COUNTERCLOCKWISE).
void	cv::scaleAdd (InputArray src1, double alpha, InputArray src2, OutputArray dst)
	Calculates the sum of a scaled array and another array.
void	cv::setIdentity (InputOutputArray mtx, const Scalar &s=Scalar(1))
	Initializes a scaled identity matrix.
void	cv::setRNGSeed (int seed)
	Sets state of default random number generator.
bool	cv::solve (InputArray src1, InputArray src2, OutputArray dst, int flags=DECOMP_LU)
	Solves one or more linear systems or least-squares problems.
int	cv::solveCubic (InputArray coeffs, OutputArray roots)
	Finds the real roots of a cubic equation.
double	cv::solvePoly (InputArray coeffs, OutputArray roots, int maxIters=300)
	Finds the real or complex roots of a polynomial equation.
void	cv::sort (InputArray src, OutputArray dst, int flags)
	Sorts each row or each column of a matrix.
void	cv::sortIdx (InputArray src, OutputArray dst, int flags)
	Sorts each row or each column of a matrix.
void	cv::split (const Mat &src, Mat *mvbegin)
	Divides a multi-channel array into several single-channel arrays.
void	cv::split (InputArray m, OutputArrayOfArrays mv)
void	cv::sqrt (InputArray src, OutputArray dst)
	Calculates a square root of array elements.
void	cv::subtract (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray(), int dtype=-1)
	Calculates the per-element difference between two arrays or array and a scalar.
Scalar	cv::sum (InputArray src)
	Calculates the sum of array elements.
void	cv::SVBackSubst (InputArray w, InputArray u, InputArray vt, InputArray rhs, OutputArray dst)
void	cv::SVDecomp (InputArray src, OutputArray w, OutputArray u, OutputArray vt, int flags=0)
void	cv::swap (Mat &a, Mat &b)
	Swaps two matrices.
void	cv::swap (UMat &a, UMat &b)
RNG &	cv::theRNG ()
	Returns the default random number generator.
Scalar	cv::trace (InputArray mtx)
	Returns the trace of a matrix.
void	cv::transform (InputArray src, OutputArray dst, InputArray m)
	Performs the matrix transformation of every array element.
void	cv::transpose (InputArray src, OutputArray dst)
	Transposes a matrix.
void	cv::transposeND (InputArray src, const std::vector< int > &order, OutputArray dst)
	Transpose for n-dimensional matrices.
void	cv::vconcat (const Mat *src, size_t nsrc, OutputArray dst)
	Applies vertical concatenation to given matrices.
void	cv::vconcat (InputArray src1, InputArray src2, OutputArray dst)
void	cv::vconcat (InputArrayOfArrays src, OutputArray dst)

Enumeration Type Documentation

BorderTypes

enum cv::BorderTypes

#include <opencv2/core/base.hpp>

Various border types, image boundaries are denoted with |

See also

borderInterpolate, copyMakeBorder

Enumerator
BORDER_CONSTANT  Python: cv.BORDER_CONSTANT	iiiiii|abcdefgh|iiiiiii with some specified i
BORDER_REPLICATE  Python: cv.BORDER_REPLICATE	aaaaaa|abcdefgh|hhhhhhh
BORDER_REFLECT  Python: cv.BORDER_REFLECT	fedcba|abcdefgh|hgfedcb
BORDER_WRAP  Python: cv.BORDER_WRAP	cdefgh|abcdefgh|abcdefg
BORDER_REFLECT_101  Python: cv.BORDER_REFLECT_101	gfedcb|abcdefgh|gfedcba
BORDER_TRANSPARENT  Python: cv.BORDER_TRANSPARENT	uvwxyz|abcdefgh|ijklmno - Treats outliers as transparent.
BORDER_REFLECT101  Python: cv.BORDER_REFLECT101	same as BORDER_REFLECT_101
BORDER_DEFAULT  Python: cv.BORDER_DEFAULT	same as BORDER_REFLECT_101
BORDER_ISOLATED  Python: cv.BORDER_ISOLATED	Interpolation restricted within the ROI boundaries.

CmpTypes

enum cv::CmpTypes

#include <opencv2/core/base.hpp>

comparison types

Enumerator
CMP_EQ  Python: cv.CMP_EQ	src1 is equal to src2.
CMP_GT  Python: cv.CMP_GT	src1 is greater than src2.
CMP_GE  Python: cv.CMP_GE	src1 is greater than or equal to src2.
CMP_LT  Python: cv.CMP_LT	src1 is less than src2.
CMP_LE  Python: cv.CMP_LE	src1 is less than or equal to src2.
CMP_NE  Python: cv.CMP_NE	src1 is unequal to src2.

CovarFlags

enum cv::CovarFlags

#include <opencv2/core.hpp>

Covariation flags.

Enumerator
COVAR_SCRAMBLED  Python: cv.COVAR_SCRAMBLED	The output covariance matrix is calculated as: \[\texttt{scale} \cdot [ \texttt{vects} [0]- \texttt{mean} , \texttt{vects} [1]- \texttt{mean} ,...]^T \cdot [ \texttt{vects} [0]- \texttt{mean} , \texttt{vects} [1]- \texttt{mean} ,...],\] The covariance matrix will be nsamples x nsamples. Such an unusual covariance matrix is used for fast PCA of a set of very large vectors (see, for example, the EigenFaces technique for face recognition). Eigenvalues of this "scrambled" matrix match the eigenvalues of the true covariance matrix. The "true" eigenvectors can be easily calculated from the eigenvectors of the "scrambled" covariance matrix.
COVAR_NORMAL  Python: cv.COVAR_NORMAL	The output covariance matrix is calculated as: \[\texttt{scale} \cdot [ \texttt{vects} [0]- \texttt{mean} , \texttt{vects} [1]- \texttt{mean} ,...] \cdot [ \texttt{vects} [0]- \texttt{mean} , \texttt{vects} [1]- \texttt{mean} ,...]^T,\] covar will be a square matrix of the same size as the total number of elements in each input vector. One and only one of COVAR_SCRAMBLED and COVAR_NORMAL must be specified.
COVAR_USE_AVG  Python: cv.COVAR_USE_AVG	If the flag is specified, the function does not calculate mean from the input vectors but, instead, uses the passed mean vector. This is useful if mean has been pre-calculated or known in advance, or if the covariance matrix is calculated by parts. In this case, mean is not a mean vector of the input sub-set of vectors but rather the mean vector of the whole set.
COVAR_SCALE  Python: cv.COVAR_SCALE	If the flag is specified, the covariance matrix is scaled. In the "normal" mode, scale is 1./nsamples . In the "scrambled" mode, scale is the reciprocal of the total number of elements in each input vector. By default (if the flag is not specified), the covariance matrix is not scaled ( scale=1 ).
COVAR_ROWS  Python: cv.COVAR_ROWS	If the flag is specified, all the input vectors are stored as rows of the samples matrix. mean should be a single-row vector in this case.
COVAR_COLS  Python: cv.COVAR_COLS	If the flag is specified, all the input vectors are stored as columns of the samples matrix. mean should be a single-column vector in this case.

DecompTypes

enum cv::DecompTypes

#include <opencv2/core/base.hpp>

matrix decomposition types

Enumerator
DECOMP_LU  Python: cv.DECOMP_LU	Gaussian elimination with the optimal pivot element chosen.
DECOMP_SVD  Python: cv.DECOMP_SVD	singular value decomposition (SVD) method; the system can be over-defined and/or the matrix src1 can be singular
DECOMP_EIG  Python: cv.DECOMP_EIG	eigenvalue decomposition; the matrix src1 must be symmetrical
DECOMP_CHOLESKY  Python: cv.DECOMP_CHOLESKY	Cholesky \(LL^T\) factorization; the matrix src1 must be symmetrical and positively defined
DECOMP_QR  Python: cv.DECOMP_QR	QR factorization; the system can be over-defined and/or the matrix src1 can be singular
DECOMP_NORMAL  Python: cv.DECOMP_NORMAL	while all the previous flags are mutually exclusive, this flag can be used together with any of the previous; it means that the normal equations \(\texttt{src1}^T\cdot\texttt{src1}\cdot\texttt{dst}=\texttt{src1}^T\texttt{src2}\) are solved instead of the original system \(\texttt{src1}\cdot\texttt{dst}=\texttt{src2}\)

DftFlags

enum cv::DftFlags

#include <opencv2/core/base.hpp>

Enumerator
DFT_INVERSE  Python: cv.DFT_INVERSE	performs an inverse 1D or 2D transform instead of the default forward transform.
DFT_SCALE  Python: cv.DFT_SCALE	scales the result: divide it by the number of array elements. Normally, it is combined with DFT_INVERSE.
DFT_ROWS  Python: cv.DFT_ROWS	performs a forward or inverse transform of every individual row of the input matrix; this flag enables you to transform multiple vectors simultaneously and can be used to decrease the overhead (which is sometimes several times larger than the processing itself) to perform 3D and higher-dimensional transformations and so forth.
DFT_COMPLEX_OUTPUT  Python: cv.DFT_COMPLEX_OUTPUT	performs a forward transformation of 1D or 2D real array; the result, though being a complex array, has complex-conjugate symmetry (CCS, see the function description below for details), and such an array can be packed into a real array of the same size as input, which is the fastest option and which is what the function does by default; however, you may wish to get a full complex array (for simpler spectrum analysis, and so on) - pass the flag to enable the function to produce a full-size complex output array.
DFT_REAL_OUTPUT  Python: cv.DFT_REAL_OUTPUT	performs an inverse transformation of a 1D or 2D complex array; the result is normally a complex array of the same size, however, if the input array has conjugate-complex symmetry (for example, it is a result of forward transformation with DFT_COMPLEX_OUTPUT flag), the output is a real array; while the function itself does not check whether the input is symmetrical or not, you can pass the flag and then the function will assume the symmetry and produce the real output array (note that when the input is packed into a real array and inverse transformation is executed, the function treats the input as a packed complex-conjugate symmetrical array, and the output will also be a real array).
DFT_COMPLEX_INPUT  Python: cv.DFT_COMPLEX_INPUT	specifies that input is complex input. If this flag is set, the input must have 2 channels. On the other hand, for backwards compatibility reason, if input has 2 channels, input is already considered complex.
DCT_INVERSE  Python: cv.DCT_INVERSE	performs an inverse 1D or 2D transform instead of the default forward transform.
DCT_ROWS  Python: cv.DCT_ROWS	performs a forward or inverse transform of every individual row of the input matrix. This flag enables you to transform multiple vectors simultaneously and can be used to decrease the overhead (which is sometimes several times larger than the processing itself) to perform 3D and higher-dimensional transforms and so forth.

GemmFlags

enum cv::GemmFlags

#include <opencv2/core/base.hpp>

generalized matrix multiplication flags

Enumerator
GEMM_1_T  Python: cv.GEMM_1_T	transposes src1
GEMM_2_T  Python: cv.GEMM_2_T	transposes src2
GEMM_3_T  Python: cv.GEMM_3_T	transposes src3

NormTypes

enum cv::NormTypes

#include <opencv2/core/base.hpp>

norm types

src1 and src2 denote input arrays.

Enumerator
NORM_INF  Python: cv.NORM_INF	\[ norm = \forkthree {\|\texttt{src1}\|_{L_{\infty}} = \max _I | \texttt{src1} (I)|}{if \(\texttt{normType} = \texttt{NORM_INF}\) } {\|\texttt{src1}-\texttt{src2}\|_{L_{\infty}} = \max _I | \texttt{src1} (I) - \texttt{src2} (I)|}{if \(\texttt{normType} = \texttt{NORM_INF}\) } {\frac{\|\texttt{src1}-\texttt{src2}\|_{L_{\infty}} }{\|\texttt{src2}\|_{L_{\infty}} }}{if \(\texttt{normType} = \texttt{NORM_RELATIVE | NORM_INF}\) } \]
NORM_L1  Python: cv.NORM_L1	\[ norm = \forkthree {\| \texttt{src1} \| _{L_1} = \sum _I | \texttt{src1} (I)|}{if \(\texttt{normType} = \texttt{NORM_L1}\)} { \| \texttt{src1} - \texttt{src2} \| _{L_1} = \sum _I | \texttt{src1} (I) - \texttt{src2} (I)|}{if \(\texttt{normType} = \texttt{NORM_L1}\) } { \frac{\|\texttt{src1}-\texttt{src2}\|_{L_1} }{\|\texttt{src2}\|_{L_1}} }{if \(\texttt{normType} = \texttt{NORM_RELATIVE | NORM_L1}\) } \]
NORM_L2  Python: cv.NORM_L2	\[ norm = \forkthree { \| \texttt{src1} \| _{L_2} = \sqrt{\sum_I \texttt{src1}(I)^2} }{if \(\texttt{normType} = \texttt{NORM_L2}\) } { \| \texttt{src1} - \texttt{src2} \| _{L_2} = \sqrt{\sum_I (\texttt{src1}(I) - \texttt{src2}(I))^2} }{if \(\texttt{normType} = \texttt{NORM_L2}\) } { \frac{\|\texttt{src1}-\texttt{src2}\|_{L_2} }{\|\texttt{src2}\|_{L_2}} }{if \(\texttt{normType} = \texttt{NORM_RELATIVE | NORM_L2}\) } \]
NORM_L2SQR  Python: cv.NORM_L2SQR	\[ norm = \forkthree { \| \texttt{src1} \| _{L_2} ^{2} = \sum_I \texttt{src1}(I)^2} {if \(\texttt{normType} = \texttt{NORM_L2SQR}\)} { \| \texttt{src1} - \texttt{src2} \| _{L_2} ^{2} = \sum_I (\texttt{src1}(I) - \texttt{src2}(I))^2 }{if \(\texttt{normType} = \texttt{NORM_L2SQR}\) } { \left(\frac{\|\texttt{src1}-\texttt{src2}\|_{L_2} }{\|\texttt{src2}\|_{L_2}}\right)^2 }{if \(\texttt{normType} = \texttt{NORM_RELATIVE | NORM_L2SQR}\) } \]
NORM_HAMMING  Python: cv.NORM_HAMMING	In the case of one input array, calculates the Hamming distance of the array from zero, In the case of two input arrays, calculates the Hamming distance between the arrays.
NORM_HAMMING2  Python: cv.NORM_HAMMING2	Similar to NORM_HAMMING, but in the calculation, each two bits of the input sequence will be added and treated as a single bit to be used in the same calculation as NORM_HAMMING.
NORM_TYPE_MASK  Python: cv.NORM_TYPE_MASK	bit-mask which can be used to separate norm type from norm flags
NORM_RELATIVE  Python: cv.NORM_RELATIVE	flag
NORM_MINMAX  Python: cv.NORM_MINMAX	flag

ReduceTypes

enum cv::ReduceTypes

#include <opencv2/core.hpp>

Enumerator
REDUCE_SUM  Python: cv.REDUCE_SUM	the output is the sum of all rows/columns of the matrix.
REDUCE_AVG  Python: cv.REDUCE_AVG	the output is the mean vector of all rows/columns of the matrix.
REDUCE_MAX  Python: cv.REDUCE_MAX	the output is the maximum (column/row-wise) of all rows/columns of the matrix.
REDUCE_MIN  Python: cv.REDUCE_MIN	the output is the minimum (column/row-wise) of all rows/columns of the matrix.
REDUCE_SUM2  Python: cv.REDUCE_SUM2	the output is the sum of all squared rows/columns of the matrix.

RotateFlags

enum cv::RotateFlags

#include <opencv2/core.hpp>

Enumerator
ROTATE_90_CLOCKWISE  Python: cv.ROTATE_90_CLOCKWISE	Rotate 90 degrees clockwise.
ROTATE_180  Python: cv.ROTATE_180	Rotate 180 degrees clockwise.
ROTATE_90_COUNTERCLOCKWISE  Python: cv.ROTATE_90_COUNTERCLOCKWISE	Rotate 270 degrees clockwise.

Function Documentation

absdiff()

void cv::absdiff	(	InputArray	src1,
		InputArray	src2,
		OutputArray	dst
	)

Python:
	cv.absdiff(	src1, src2[, dst]	) ->	dst

#include <opencv2/core.hpp>

Calculates the per-element absolute difference between two arrays or between an array and a scalar.

The function cv::absdiff calculates: Absolute difference between two arrays when they have the same size and type:

\[\texttt{dst}(I) = \texttt{saturate} (| \texttt{src1}(I) - \texttt{src2}(I)|)\]

Absolute difference between an array and a scalar when the second array is constructed from Scalar or has as many elements as the number of channels in src1:

\[\texttt{dst}(I) = \texttt{saturate} (| \texttt{src1}(I) - \texttt{src2} |)\]

Absolute difference between a scalar and an array when the first array is constructed from Scalar or has as many elements as the number of channels in src2:

\[\texttt{dst}(I) = \texttt{saturate} (| \texttt{src1} - \texttt{src2}(I) |)\]

where I is a multi-dimensional index of array elements. In case of multi-channel arrays, each channel is processed independently.

Note

Saturation is not applied when the arrays have the depth CV_32S. You may even get a negative value in the case of overflow.

(Python) Be careful to difference behaviour between src1/src2 are single number and they are tuple/array. absdiff(src,X) means absdiff(src,(X,X,X,X)). absdiff(src,(X,)) means absdiff(src,(X,0,0,0)).

Parameters

src1	first input array or a scalar.
src2	second input array or a scalar.
dst	output array that has the same size and type as input arrays.

See also

cv::abs(const Mat&)

add()

void cv::add	(	InputArray	src1,
		InputArray	src2,
		OutputArray	dst,
		InputArray	mask = noArray(),
		int	dtype = -1
	)

Python:
	cv.add(	src1, src2[, dst[, mask[, dtype]]]	) ->	dst

#include <opencv2/core.hpp>

Calculates the per-element sum of two arrays or an array and a scalar.

The function add calculates:

• Sum of two arrays when both input arrays have the same size and the same number of channels:

  \[\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) + \texttt{src2}(I)) \quad \texttt{if mask}(I) \ne0\]

• Sum of an array and a scalar when src2 is constructed from Scalar or has the same number of elements as src1.channels():

  \[\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) + \texttt{src2} ) \quad \texttt{if mask}(I) \ne0\]

• Sum of a scalar and an array when src1 is constructed from Scalar or has the same number of elements as src2.channels():

  \[\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1} + \texttt{src2}(I) ) \quad \texttt{if mask}(I) \ne0\]

  where I is a multi-dimensional index of array elements. In case of multi-channel arrays, each channel is processed independently.

The first function in the list above can be replaced with matrix expressions:

dst = src1 + src2;
dst += src1; // equivalent to add(dst, src1, dst);

The input arrays and the output array can all have the same or different depths. For example, you can add a 16-bit unsigned array to a 8-bit signed array and store the sum as a 32-bit floating-point array. Depth of the output array is determined by the dtype parameter. In the second and third cases above, as well as in the first case, when src1.depth() == src2.depth(), dtype can be set to the default -1. In this case, the output array will have the same depth as the input array, be it src1, src2 or both.

Note

Saturation is not applied when the output array has the depth CV_32S. You may even get result of an incorrect sign in the case of overflow.

(Python) Be careful to difference behaviour between src1/src2 are single number and they are tuple/array. add(src,X) means add(src,(X,X,X,X)). add(src,(X,)) means add(src,(X,0,0,0)).

Parameters

src1	first input array or a scalar.
src2	second input array or a scalar.
dst	output array that has the same size and number of channels as the input array(s); the depth is defined by dtype or src1/src2.
mask	optional operation mask - CV_8U, CV_8S or CV_Bool single channel array, that specifies elements of the output array to be changed.
dtype	optional depth of the output array (see the discussion below).

See also

subtract, addWeighted, scaleAdd, Mat::convertTo

addWeighted()

void cv::addWeighted	(	InputArray	src1,
		double	alpha,
		InputArray	src2,
		double	beta,
		double	gamma,
		OutputArray	dst,
		int	dtype = -1
	)

Python:
	cv.addWeighted(	src1, alpha, src2, beta, gamma[, dst[, dtype]]	) ->	dst

#include <opencv2/core.hpp>

Calculates the weighted sum of two arrays.

The function addWeighted calculates the weighted sum of two arrays as follows:

\[\texttt{dst} (I)= \texttt{saturate} ( \texttt{src1} (I)* \texttt{alpha} + \texttt{src2} (I)* \texttt{beta} + \texttt{gamma} )\]

where I is a multi-dimensional index of array elements. In case of multi-channel arrays, each channel is processed independently. The function can be replaced with a matrix expression:

dst = src1*alpha + src2*beta + gamma;

Note

Saturation is not applied when the output array has the depth CV_32S. You may even get result of an incorrect sign in the case of overflow.

Parameters

src1	first input array.
alpha	weight of the first array elements.
src2	second input array of the same size and channel number as src1.
beta	weight of the second array elements.
gamma	scalar added to each sum.
dst	output array that has the same size and number of channels as the input arrays.
dtype	optional depth of the output array; when both input arrays have the same depth, dtype can be set to -1, which will be equivalent to src1.depth().

See also

add, subtract, scaleAdd, Mat::convertTo

batchDistance()

void cv::batchDistance	(	InputArray	src1,
		InputArray	src2,
		OutputArray	dist,
		int	dtype,
		OutputArray	nidx,
		int	normType = NORM_L2,
		int	K = 0,
		InputArray	mask = noArray(),
		int	update = 0,
		bool	crosscheck = false
	)

Python:
	cv.batchDistance(	src1, src2, dtype[, dist[, nidx[, normType[, K[, mask[, update[, crosscheck]]]]]]]	) ->	dist, nidx

#include <opencv2/core.hpp>

naive nearest neighbor finder

see http://en.wikipedia.org/wiki/Nearest_neighbor_search

Todo:

document

bitwise_and()

void cv::bitwise_and	(	InputArray	src1,
		InputArray	src2,
		OutputArray	dst,
		InputArray	mask = noArray()
	)

Python:
	cv.bitwise_and(	src1, src2[, dst[, mask]]	) ->	dst

#include <opencv2/core.hpp>

computes bitwise conjunction of the two arrays (dst = src1 & src2) Calculates the per-element bit-wise conjunction of two arrays or an array and a scalar.

The function cv::bitwise_and calculates the per-element bit-wise logical conjunction for: Two arrays when src1 and src2 have the same size:

\[\texttt{dst} (I) = \texttt{src1} (I) \wedge \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0\]

An array and a scalar when src2 is constructed from Scalar or has the same number of elements as src1.channels():

\[\texttt{dst} (I) = \texttt{src1} (I) \wedge \texttt{src2} \quad \texttt{if mask} (I) \ne0\]

A scalar and an array when src1 is constructed from Scalar or has the same number of elements as src2.channels():

\[\texttt{dst} (I) = \texttt{src1} \wedge \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0\]

In case of floating-point arrays, their machine-specific bit representations (usually IEEE754-compliant) are used for the operation. In case of multi-channel arrays, each channel is processed independently. In the second and third cases above, the scalar is first converted to the array type.

Parameters

src1	first input array or a scalar.
src2	second input array or a scalar.
dst	output array that has the same size and type as the input arrays.
mask	optional operation mask, CV_8U, CV_8S or CV_Bool single channel array, that specifies elements of the output array to be changed.

bitwise_not()

void cv::bitwise_not	(	InputArray	src,
		OutputArray	dst,
		InputArray	mask = noArray()
	)

Python:
	cv.bitwise_not(	src[, dst[, mask]]	) ->	dst

#include <opencv2/core.hpp>

Inverts every bit of an array.

The function cv::bitwise_not calculates per-element bit-wise inversion of the input array:

\[\texttt{dst} (I) = \neg \texttt{src} (I)\]

In case of a floating-point input array, its machine-specific bit representation (usually IEEE754-compliant) is used for the operation. In case of multi-channel arrays, each channel is processed independently.

Parameters

src	input array.
dst	output array that has the same size and type as the input array.
mask	optional operation mask, CV_8U, CV_8S or CV_Bool single channel array, that specifies elements of the output array to be changed.

bitwise_or()

void cv::bitwise_or	(	InputArray	src1,
		InputArray	src2,
		OutputArray	dst,
		InputArray	mask = noArray()
	)

Python:
	cv.bitwise_or(	src1, src2[, dst[, mask]]	) ->	dst

#include <opencv2/core.hpp>

Calculates the per-element bit-wise disjunction of two arrays or an array and a scalar.

The function cv::bitwise_or calculates the per-element bit-wise logical disjunction for: Two arrays when src1 and src2 have the same size:

\[\texttt{dst} (I) = \texttt{src1} (I) \vee \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0\]

An array and a scalar when src2 is constructed from Scalar or has the same number of elements as src1.channels():

\[\texttt{dst} (I) = \texttt{src1} (I) \vee \texttt{src2} \quad \texttt{if mask} (I) \ne0\]

A scalar and an array when src1 is constructed from Scalar or has the same number of elements as src2.channels():

\[\texttt{dst} (I) = \texttt{src1} \vee \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0\]

In case of floating-point arrays, their machine-specific bit representations (usually IEEE754-compliant) are used for the operation. In case of multi-channel arrays, each channel is processed independently. In the second and third cases above, the scalar is first converted to the array type.

Parameters

src1	first input array or a scalar.
src2	second input array or a scalar.
dst	output array that has the same size and type as the input arrays.
mask	optional operation mask, CV_8U, CV_8S or CV_Bool single channel array, that specifies elements of the output array to be changed.

bitwise_xor()

void cv::bitwise_xor	(	InputArray	src1,
		InputArray	src2,
		OutputArray	dst,
		InputArray	mask = noArray()
	)

Python:
	cv.bitwise_xor(	src1, src2[, dst[, mask]]	) ->	dst

#include <opencv2/core.hpp>

Calculates the per-element bit-wise "exclusive or" operation on two arrays or an array and a scalar.

The function cv::bitwise_xor calculates the per-element bit-wise logical "exclusive-or" operation for: Two arrays when src1 and src2 have the same size:

\[\texttt{dst} (I) = \texttt{src1} (I) \oplus \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0\]

An array and a scalar when src2 is constructed from Scalar or has the same number of elements as src1.channels():

\[\texttt{dst} (I) = \texttt{src1} (I) \oplus \texttt{src2} \quad \texttt{if mask} (I) \ne0\]

A scalar and an array when src1 is constructed from Scalar or has the same number of elements as src2.channels():

\[\texttt{dst} (I) = \texttt{src1} \oplus \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0\]

In case of floating-point arrays, their machine-specific bit representations (usually IEEE754-compliant) are used for the operation. In case of multi-channel arrays, each channel is processed independently. In the 2nd and 3rd cases above, the scalar is first converted to the array type.

Parameters

src1	first input array or a scalar.
src2	second input array or a scalar.
dst	output array that has the same size and type as the input arrays.
mask	optional operation mask, CV_8U, CV_8S or CV_Bool single channel array, that specifies elements of the output array to be changed.

borderInterpolate()

int cv::borderInterpolate	(	int	p,
		int	len,
		int	borderType
	)

Python:
	cv.borderInterpolate(	p, len, borderType	) ->	retval

#include <opencv2/core.hpp>

Computes the source location of an extrapolated pixel.

The function computes and returns the coordinate of a donor pixel corresponding to the specified extrapolated pixel when using the specified extrapolation border mode. For example, if you use cv::BORDER_WRAP mode in the horizontal direction, cv::BORDER_REFLECT_101 in the vertical direction and want to compute value of the "virtual" pixel Point(-5, 100) in a floating-point image img, it looks like:

float val = img.at<float>(borderInterpolate(100, img.rows, cv::BORDER_REFLECT_101),
                          borderInterpolate(-5, img.cols, cv::BORDER_WRAP));

Normally, the function is not called directly. It is used inside filtering functions and also in copyMakeBorder.

Parameters

p	0-based coordinate of the extrapolated pixel along one of the axes, likely <0 or >= len
len	Length of the array along the corresponding axis.
borderType	Border type, one of the BorderTypes, except for BORDER_TRANSPARENT and BORDER_ISOLATED. When borderType==BORDER_CONSTANT, the function always returns -1, regardless of p and len.

See also

copyMakeBorder

broadcast() [1/2]

void cv::broadcast	(	InputArray	src,
		const MatShape &	shape,
		OutputArray	dst
	)

Python:
	cv.broadcast(	src, shape[, dst]	) ->	dst

#include <opencv2/core.hpp>

Broadcast the given Mat to the given shape.

Parameters

src	input array
shape	target shape. Note that negative values are not supported.
dst	output array that has the given shape

broadcast() [2/2]

void cv::broadcast	(	InputArray	src,
		InputArray	shape,
		OutputArray	dst
	)

Python:
	cv.broadcast(	src, shape[, dst]	) ->	dst

#include <opencv2/core.hpp>

Broadcast the given Mat to the given shape.

Parameters

src	input array
shape	target shape. Should be a list of CV_32S numbers. Note that negative values are not supported.
dst	output array that has the given shape

calcCovarMatrix() [1/2]

void cv::calcCovarMatrix	(	const Mat *	samples,
		int	nsamples,
		Mat &	covar,
		Mat &	mean,
		int	flags,
		int	ctype = CV_64F
	)

Python:
	cv.calcCovarMatrix(	samples, mean, flags[, covar[, ctype]]	) ->	covar, mean

#include <opencv2/core.hpp>

Calculates the covariance matrix of a set of vectors.

The function cv::calcCovarMatrix calculates the covariance matrix and, optionally, the mean vector of the set of input vectors.

Parameters

samples	samples stored as separate matrices
nsamples	number of samples
covar	output covariance matrix of the type ctype and square size.
mean	input or output (depending on the flags) array as the average value of the input vectors.
flags	operation flags as a combination of CovarFlags
ctype	type of the matrixl; it equals 'CV_64F' by default.

See also

PCA, mulTransposed, Mahalanobis

Todo:

InputArrayOfArrays

calcCovarMatrix() [2/2]

void cv::calcCovarMatrix	(	InputArray	samples,
		OutputArray	covar,
		InputOutputArray	mean,
		int	flags,
		int	ctype = CV_64F
	)

Python:
	cv.calcCovarMatrix(	samples, mean, flags[, covar[, ctype]]	) ->	covar, mean

#include <opencv2/core.hpp>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Note

use COVAR_ROWS or COVAR_COLS flag

Parameters

samples	samples stored as rows/columns of a single matrix.
covar	output covariance matrix of the type ctype and square size.
mean	input or output (depending on the flags) array as the average value of the input vectors.
flags	operation flags as a combination of CovarFlags
ctype	type of the matrixl; it equals 'CV_64F' by default.

cartToPolar()

void cv::cartToPolar	(	InputArray	x,
		InputArray	y,
		OutputArray	magnitude,
		OutputArray	angle,
		bool	angleInDegrees = false
	)

Python:
	cv.cartToPolar(	x, y[, magnitude[, angle[, angleInDegrees]]]	) ->	magnitude, angle

#include <opencv2/core.hpp>

Calculates the magnitude and angle of 2D vectors.

The function cv::cartToPolar calculates either the magnitude, angle, or both for every 2D vector (x(I),y(I)):

\[\begin{array}{l} \texttt{magnitude} (I)= \sqrt{\texttt{x}(I)^2+\texttt{y}(I)^2} , \\ \texttt{angle} (I)= \texttt{atan2} ( \texttt{y} (I), \texttt{x} (I))[ \cdot180 / \pi ] \end{array}\]

The angles are calculated with accuracy about 0.3 degrees. For the point (0,0), the angle is set to 0.

Parameters

x	array of x-coordinates; this must be a single-precision or double-precision floating-point array.
y	array of y-coordinates, that must have the same size and same type as x.
magnitude	output array of magnitudes of the same size and type as x.
angle	output array of angles that has the same size and type as x; the angles are measured in radians (from 0 to 2*Pi) or in degrees (0 to 360 degrees).
angleInDegrees	a flag, indicating whether the angles are measured in radians (which is by default), or in degrees.

See also

Sobel, Scharr

checkRange()

bool cv::checkRange	(	InputArray	a,
		bool	quiet = true,
		Point *	pos = 0,
		double	minVal = -DBL_MAX,
		double	maxVal = DBL_MAX
	)

Python:
	cv.checkRange(	a[, quiet[, minVal[, maxVal]]]	) ->	retval, pos

#include <opencv2/core.hpp>

Checks every element of an input array for invalid values.

The function cv::checkRange checks that every array element is neither NaN nor infinite. When minVal > -DBL_MAX and maxVal < DBL_MAX, the function also checks that each value is between minVal and maxVal. In case of multi-channel arrays, each channel is processed independently. If some values are out of range, position of the first outlier is stored in pos (when pos != NULL). Then, the function either returns false (when quiet=true) or throws an exception.

Parameters

a	input array.
quiet	a flag, indicating whether the functions quietly return false when the array elements are out of range or they throw an exception.
pos	optional output parameter, when not NULL, must be a pointer to array of src.dims elements.
minVal	inclusive lower boundary of valid values range.
maxVal	exclusive upper boundary of valid values range.

compare()

void cv::compare	(	InputArray	src1,
		InputArray	src2,
		OutputArray	dst,
		int	cmpop
	)

Python:
	cv.compare(	src1, src2, cmpop[, dst]	) ->	dst

#include <opencv2/core.hpp>

Performs the per-element comparison of two arrays or an array and scalar value.

The function compares: Elements of two arrays when src1 and src2 have the same size:

\[\texttt{dst} (I) = \texttt{src1} (I) \,\texttt{cmpop}\, \texttt{src2} (I)\]

Elements of src1 with a scalar src2 when src2 is constructed from Scalar or has a single element:

\[\texttt{dst} (I) = \texttt{src1}(I) \,\texttt{cmpop}\, \texttt{src2}\]

src1 with elements of src2 when src1 is constructed from Scalar or has a single element:

\[\texttt{dst} (I) = \texttt{src1} \,\texttt{cmpop}\, \texttt{src2} (I)\]

When the comparison result is true, the corresponding element of output array is set to 255. The comparison operations can be replaced with the equivalent matrix expressions:

Mat dst1 = src1 >= src2;
Mat dst2 = src1 < 8;
...

Parameters

src1	first input array or a scalar; when it is an array, it must have a single channel.
src2	second input array or a scalar; when it is an array, it must have a single channel.
dst	output array of type ref CV_8U that has the same size and the same number of channels as the input arrays.
cmpop	a flag, that specifies correspondence between the arrays (cv::CmpTypes)

See also

checkRange, min, max, threshold

completeSymm()

void cv::completeSymm	(	InputOutputArray	m,
		bool	lowerToUpper = false
	)

Python:
	cv.completeSymm(	m[, lowerToUpper]	) ->	m

#include <opencv2/core.hpp>

Copies the lower or the upper half of a square matrix to its another half.

The function cv::completeSymm copies the lower or the upper half of a square matrix to its another half. The matrix diagonal remains unchanged:

• \(\texttt{m}_{ij}=\texttt{m}_{ji}\) for \(i > j\) if lowerToUpper=false
• \(\texttt{m}_{ij}=\texttt{m}_{ji}\) for \(i < j\) if lowerToUpper=true

Parameters

m	input-output floating-point square matrix.
lowerToUpper	operation flag; if true, the lower half is copied to the upper half. Otherwise, the upper half is copied to the lower half.

See also

flip, transpose

convertScaleAbs()

void cv::convertScaleAbs	(	InputArray	src,
		OutputArray	dst,
		double	alpha = 1,
		double	beta = 0
	)

Python:
	cv.convertScaleAbs(	src[, dst[, alpha[, beta]]]	) ->	dst

#include <opencv2/core.hpp>

Scales, calculates absolute values, and converts the result to 8-bit.

On each element of the input array, the function convertScaleAbs performs three operations sequentially: scaling, taking an absolute value, conversion to an unsigned 8-bit type:

\[\texttt{dst} (I)= \texttt{saturate\_cast<uchar>} (| \texttt{src} (I)* \texttt{alpha} + \texttt{beta} |)\]

In case of multi-channel arrays, the function processes each channel independently. When the output is not 8-bit, the operation can be emulated by calling the Mat::convertTo method (or by using matrix expressions) and then by calculating an absolute value of the result. For example:

Mat_<float> A(30,30);
randu(A, Scalar(-100), Scalar(100));
Mat_<float> B = A*5 + 3;
B = abs(B);
// Mat_<float> B = abs(A*5+3) will also do the job,
// but it will allocate a temporary matrix

Parameters

src	input array.
dst	output array.
alpha	optional scale factor.
beta	optional delta added to the scaled values.

See also

Mat::convertTo, cv::abs(const Mat&)

copyMakeBorder()

void cv::copyMakeBorder	(	InputArray	src,
		OutputArray	dst,
		int	top,
		int	bottom,
		int	left,
		int	right,
		int	borderType,
		const Scalar &	value = Scalar()
	)

Python:
	cv.copyMakeBorder(	src, top, bottom, left, right, borderType[, dst[, value]]	) ->	dst

#include <opencv2/core.hpp>

Forms a border around an image.

The function copies the source image into the middle of the destination image. The areas to the left, to the right, above and below the copied source image will be filled with extrapolated pixels. This is not what filtering functions based on it do (they extrapolate pixels on-fly), but what other more complex functions, including your own, may do to simplify image boundary handling.

The function supports the mode when src is already in the middle of dst . In this case, the function does not copy src itself but simply constructs the border, for example:

// let border be the same in all directions
int border=2;
// constructs a larger image to fit both the image and the border
Mat gray_buf(rgb.rows + border*2, rgb.cols + border*2, rgb.depth());
// select the middle part of it w/o copying data
Mat gray(gray_canvas, Rect(border, border, rgb.cols, rgb.rows));
// convert image from RGB to grayscale
cvtColor(rgb, gray, COLOR_RGB2GRAY);
// form a border in-place
copyMakeBorder(gray, gray_buf, border, border,
               border, border, BORDER_REPLICATE);
// now do some custom filtering ...
...

Note

When the source image is a part (ROI) of a bigger image, the function will try to use the pixels outside of the ROI to form a border. To disable this feature and always do extrapolation, as if src was not a ROI, use borderType | BORDER_ISOLATED.

Parameters

src	Source image.
dst	Destination image of the same type as src and the size Size(src.cols+left+right, src.rows+top+bottom) .
top	the top pixels
bottom	the bottom pixels
left	the left pixels
right	Parameter specifying how many pixels in each direction from the source image rectangle to extrapolate. For example, top=1, bottom=1, left=1, right=1 mean that 1 pixel-wide border needs to be built.
borderType	Border type. See borderInterpolate for details.
value	Border value if borderType==BORDER_CONSTANT .

See also

borderInterpolate

copyTo()

void cv::copyTo	(	InputArray	src,
		OutputArray	dst,
		InputArray	mask
	)

Python:
	cv.copyTo(	src, mask[, dst]	) ->	dst

#include <opencv2/core.hpp>

This is an overloaded member function, provided for convenience (python) Copies the matrix to another one. When the operation mask is specified, if the Mat::create call shown above reallocates the matrix, the newly allocated matrix is initialized with all zeros before copying the data.

Parameters

src	source matrix.
dst	Destination matrix. If it does not have a proper size or type before the operation, it is reallocated.
mask	Operation mask of the same size as *this. Its non-zero elements indicate which matrix elements need to be copied. The mask has to be of type CV_8U, CV_8S or CV_Bool and can have 1 or multiple channels.

countNonZero()

int cv::countNonZero

(

InputArray

src

)

Python:
	cv.countNonZero(	src	) ->	retval

#include <opencv2/core.hpp>

Counts non-zero array elements.

The function returns the number of non-zero elements in src :

\[\sum _{I: \; \texttt{src} (I) \ne0 } 1\]

The function do not work with multi-channel arrays. If you need to count non-zero array elements across all the channels, use Mat::reshape first to reinterpret the array as single-channel. Or you may extract the particular channel using either extractImageCOI, or mixChannels, or split.

Note

• CV_16F/CV_16BF/CV_Bool/CV_64U/CV_64S/CV_32U are not supported for src.
• If only whether there are non-zero elements is important, hasNonZero is helpful.
• If the location of non-zero array elements is important, findNonZero is helpful.

Parameters

src	single-channel array.

See also

mean, meanStdDev, norm, minMaxLoc, calcCovarMatrix

findNonZero, hasNonZero

dct()

void cv::dct	(	InputArray	src,
		OutputArray	dst,
		int	flags = 0
	)

Python:
	cv.dct(	src[, dst[, flags]]	) ->	dst

#include <opencv2/core.hpp>

Performs a forward or inverse discrete Cosine transform of 1D or 2D array.

The function cv::dct performs a forward or inverse discrete Cosine transform (DCT) of a 1D or 2D floating-point array:

• Forward Cosine transform of a 1D vector of N elements:

  \[Y = C^{(N)} \cdot X\]

  where

  \[C^{(N)}_{jk}= \sqrt{\alpha_j/N} \cos \left ( \frac{\pi(2k+1)j}{2N} \right )\]

  and \(\alpha_0=1\), \(\alpha_j=2\) for j > 0.
• Inverse Cosine transform of a 1D vector of N elements:

  \[X = \left (C^{(N)} \right )^{-1} \cdot Y = \left (C^{(N)} \right )^T \cdot Y\]

  (since \(C^{(N)}\) is an orthogonal matrix, \(C^{(N)} \cdot \left(C^{(N)}\right)^T = I\) )
• Forward 2D Cosine transform of M x N matrix:

  \[Y = C^{(N)} \cdot X \cdot \left (C^{(N)} \right )^T\]

• Inverse 2D Cosine transform of M x N matrix:

  \[X = \left (C^{(N)} \right )^T \cdot X \cdot C^{(N)}\]

The function chooses the mode of operation by looking at the flags and size of the input array:

• If (flags & DCT_INVERSE) == 0, the function does a forward 1D or 2D transform. Otherwise, it is an inverse 1D or 2D transform.
• If (flags & DCT_ROWS) != 0, the function performs a 1D transform of each row.
• If the array is a single column or a single row, the function performs a 1D transform.
• If none of the above is true, the function performs a 2D transform.

Note

Currently dct supports even-size arrays (2, 4, 6 ...). For data analysis and approximation, you can pad the array when necessary. Also, the function performance depends very much, and not monotonically, on the array size (see getOptimalDFTSize ). In the current implementation DCT of a vector of size N is calculated via DFT of a vector of size N/2 . Thus, the optimal DCT size N1 >= N can be calculated as:

size_t getOptimalDCTSize(size_t N) { return 2*getOptimalDFTSize((N+1)/2); }
N1 = getOptimalDCTSize(N);

Parameters

src	input floating-point array.
dst	output array of the same size and type as src .
flags	transformation flags as a combination of cv::DftFlags (DCT_*)

See also

dft, getOptimalDFTSize, idct

determinant()

double cv::determinant

(

InputArray

mtx

)

Python:
	cv.determinant(	mtx	) ->	retval

#include <opencv2/core.hpp>

Returns the determinant of a square floating-point matrix.

The function cv::determinant calculates and returns the determinant of the specified matrix. For small matrices ( mtx.cols=mtx.rows<=3 ), the direct method is used. For larger matrices, the function uses LU factorization with partial pivoting.

For symmetric positively-determined matrices, it is also possible to use eigen decomposition to calculate the determinant.

Parameters

mtx	input matrix that must have CV_32FC1 or CV_64FC1 type and square size.

See also

trace, invert, solve, eigen, MatrixExpressions

dft()

void cv::dft	(	InputArray	src,
		OutputArray	dst,
		int	flags = 0,
		int	nonzeroRows = 0
	)

Python:
	cv.dft(	src[, dst[, flags[, nonzeroRows]]]	) ->	dst

#include <opencv2/core.hpp>

Performs a forward or inverse Discrete Fourier transform of a 1D or 2D floating-point array.

The function cv::dft performs one of the following:

• Forward the Fourier transform of a 1D vector of N elements:

  \[Y = F^{(N)} \cdot X,\]

  where \(F^{(N)}_{jk}=\exp(-2\pi i j k/N)\) and \(i=\sqrt{-1}\)
• Inverse the Fourier transform of a 1D vector of N elements:

  \[\begin{array}{l} X'= \left (F^{(N)} \right )^{-1} \cdot Y = \left (F^{(N)} \right )^* \cdot y \\ X = (1/N) \cdot X, \end{array}\]

  where \(F^*=\left(\textrm{Re}(F^{(N)})-\textrm{Im}(F^{(N)})\right)^T\)
• Forward the 2D Fourier transform of a M x N matrix:

  \[Y = F^{(M)} \cdot X \cdot F^{(N)}\]

• Inverse the 2D Fourier transform of a M x N matrix:

  \[\begin{array}{l} X'= \left (F^{(M)} \right )^* \cdot Y \cdot \left (F^{(N)} \right )^* \\ X = \frac{1}{M \cdot N} \cdot X' \end{array}\]

In case of real (single-channel) data, the output spectrum of the forward Fourier transform or input spectrum of the inverse Fourier transform can be represented in a packed format called CCS (complex-conjugate-symmetrical). It was borrowed from IPL (Intel* Image Processing Library). Here is how 2D CCS spectrum looks:

\[\begin{bmatrix} Re Y_{0,0} & Re Y_{0,1} & Im Y_{0,1} & Re Y_{0,2} & Im Y_{0,2} & \cdots & Re Y_{0,N/2-1} & Im Y_{0,N/2-1} & Re Y_{0,N/2} \\ Re Y_{1,0} & Re Y_{1,1} & Im Y_{1,1} & Re Y_{1,2} & Im Y_{1,2} & \cdots & Re Y_{1,N/2-1} & Im Y_{1,N/2-1} & Re Y_{1,N/2} \\ Im Y_{1,0} & Re Y_{2,1} & Im Y_{2,1} & Re Y_{2,2} & Im Y_{2,2} & \cdots & Re Y_{2,N/2-1} & Im Y_{2,N/2-1} & Im Y_{1,N/2} \\ \hdotsfor{9} \\ Re Y_{M/2-1,0} & Re Y_{M-3,1} & Im Y_{M-3,1} & \hdotsfor{3} & Re Y_{M-3,N/2-1} & Im Y_{M-3,N/2-1}& Re Y_{M/2-1,N/2} \\ Im Y_{M/2-1,0} & Re Y_{M-2,1} & Im Y_{M-2,1} & \hdotsfor{3} & Re Y_{M-2,N/2-1} & Im Y_{M-2,N/2-1}& Im Y_{M/2-1,N/2} \\ Re Y_{M/2,0} & Re Y_{M-1,1} & Im Y_{M-1,1} & \hdotsfor{3} & Re Y_{M-1,N/2-1} & Im Y_{M-1,N/2-1}& Re Y_{M/2,N/2} \end{bmatrix}\]

In case of 1D transform of a real vector, the output looks like the first row of the matrix above.

So, the function chooses an operation mode depending on the flags and size of the input array:

• If DFT_ROWS is set or the input array has a single row or single column, the function performs a 1D forward or inverse transform of each row of a matrix when DFT_ROWS is set. Otherwise, it performs a 2D transform.
• If the input array is real and DFT_INVERSE is not set, the function performs a forward 1D or 2D transform:
  • When DFT_COMPLEX_OUTPUT is set, the output is a complex matrix of the same size as input.
  • When DFT_COMPLEX_OUTPUT is not set, the output is a real matrix of the same size as input. In case of 2D transform, it uses the packed format as shown above. In case of a single 1D transform, it looks like the first row of the matrix above. In case of multiple 1D transforms (when using the DFT_ROWS flag), each row of the output matrix looks like the first row of the matrix above.
• If the input array is complex and either DFT_INVERSE or DFT_REAL_OUTPUT are not set, the output is a complex array of the same size as input. The function performs a forward or inverse 1D or 2D transform of the whole input array or each row of the input array independently, depending on the flags DFT_INVERSE and DFT_ROWS.
• When DFT_INVERSE is set and the input array is real, or it is complex but DFT_REAL_OUTPUT is set, the output is a real array of the same size as input. The function performs a 1D or 2D inverse transformation of the whole input array or each individual row, depending on the flags DFT_INVERSE and DFT_ROWS.

If DFT_SCALE is set, the scaling is done after the transformation.

Unlike dct, the function supports arrays of arbitrary size. But only those arrays are processed efficiently, whose sizes can be factorized in a product of small prime numbers (2, 3, and 5 in the current implementation). Such an efficient DFT size can be calculated using the getOptimalDFTSize method.

The sample below illustrates how to calculate a DFT-based convolution of two 2D real arrays:

#include "opencv2/core.hpp"
#include "opencv2/core/utility.hpp"
#include "opencv2/imgproc.hpp"
#include "opencv2/imgcodecs.hpp"
#include "opencv2/highgui.hpp"
#include <iostream>
#include <stdio.h>
 
using namespace cv;
using namespace std;
 
static void convolveDFT(InputArray A, InputArray B, OutputArray C) {
    // Calculate the size of the output array
    int outputRows = A.rows() + B.rows() - 1;
    int outputCols = A.cols() + B.cols() - 1;
 
    // Reallocate the output array if needed
    C.create(outputRows, outputCols, A.type());
 
    Size dftSize;
    // Calculate the size of DFT transform
    dftSize.width = getOptimalDFTSize(A.cols() + B.cols() - 1);
    dftSize.height = getOptimalDFTSize(A.rows() + B.rows() - 1);
 
    // Allocate temporary buffers and initialize them with 0's
    Mat tempA(dftSize, A.type(), Scalar::all(0));
    Mat tempB(dftSize, B.type(), Scalar::all(0));
 
    // Copy A and B to the top-left corners of tempA and tempB, respectively
    Mat roiA(tempA, Rect(0, 0, A.cols(), A.rows()));
    A.copyTo(roiA);
    Mat roiB(tempB, Rect(0, 0, B.cols(), B.rows()));
    B.copyTo(roiB);
 
    // Now transform the padded A & B in-place;
    // use "nonzeroRows" hint for faster processing
    dft(tempA, tempA, 0, A.rows());
    dft(tempB, tempB, 0, B.rows());
 
    // Multiply the spectrums;
    // the function handles packed spectrum representations well
    mulSpectrums(tempA, tempB, tempA, 0);
 
    // Transform the product back from the frequency domain.
    // Even though all the result rows will be non-zero,
    // you need only the first C.rows of them, and thus you
    // pass nonzeroRows == C.rows
    dft(tempA, tempA, DFT_INVERSE + DFT_SCALE, C.rows());
 
    // Now copy the result back to C.
    tempA(Rect(0, 0, C.cols(), C.rows())).copyTo(C);
 
    // All the temporary buffers will be deallocated automatically
}
static void help(const char ** argv)
{
    printf("\nThis program demonstrates the use of convolution using discrete Fourier transform (DFT)\n"
           "An image is convolved with kernel filter using DFT.\n"
           "Usage:\n %s [input -- default lena.jpg]\n", argv[0]);
}
 
const char* keys =
{
    "{help h||}{@input|lena.jpg|input image file}"
};
 
int main(int argc, const char** argv) {
    // Load the image in grayscale
    help(argv);
    CommandLineParser parser(argc, argv, keys);
    if (parser.has("help"))
    {
        help(argv);
        return 0;
    }
    string filename = parser.get<string>(0);
    Mat img = imread(samples::findFile(filename), IMREAD_GRAYSCALE);
 
    // Check if the image is loaded successfully
    if (img.empty()) {
        std::cerr << "Error: Image not loaded!" << std::endl;
        return -1;
    }
 
    // Convert the image to CV_32F
    Mat img_32f;
    img.convertTo(img_32f, CV_32F);
 
    float kernelData[9] = { 1.0f/9, 1.0f/9, 1.0f/9, 1.0f/9, 1.0f/9, 1.0f/9, 1.0f/9, 1.0f/9, 1.0f/9 }; // example of blur filter, can be changed to other filter as well.
    Mat kernel(3, 3, CV_32F, kernelData);
 
    // Perform convolution of the image with the sharpening kernel
    Mat result;
    convolveDFT(img_32f, kernel, result);
 
    // Normalize the result for better visualization
    normalize(result, result, 0, 255, NORM_MINMAX);
 
    // Convert result back to 8-bit for display
    Mat result_8u;
    result.convertTo(result_8u, CV_8U);
 
    // Display the images
    imshow("Original Image", img);
    imshow("Output Image", result_8u);
 
    waitKey(0); // Wait for a key press to close the windows
    return 0;
}

An example on DFT-based convolution

To optimize this sample, consider the following approaches:

• Since nonzeroRows != 0 is passed to the forward transform calls and since A and B are copied to the top-left corners of tempA and tempB, respectively, it is not necessary to clear the whole tempA and tempB. It is only necessary to clear the tempA.cols - A.cols ( tempB.cols - B.cols) rightmost columns of the matrices.
• This DFT-based convolution does not have to be applied to the whole big arrays, especially if B is significantly smaller than A or vice versa. Instead, you can calculate convolution by parts. To do this, you need to split the output array C into multiple tiles. For each tile, estimate which parts of A and B are required to calculate convolution in this tile. If the tiles in C are too small, the speed will decrease a lot because of repeated work. In the ultimate case, when each tile in C is a single pixel, the algorithm becomes equivalent to the naive convolution algorithm. If the tiles are too big, the temporary arrays tempA and tempB become too big and there is also a slowdown because of bad cache locality. So, there is an optimal tile size somewhere in the middle.
• If different tiles in C can be calculated in parallel and, thus, the convolution is done by parts, the loop can be threaded.

All of the above improvements have been implemented in matchTemplate and filter2D . Therefore, by using them, you can get the performance even better than with the above theoretically optimal implementation. Though, those two functions actually calculate cross-correlation, not convolution, so you need to "flip" the second convolution operand B vertically and horizontally using flip .

Note

• An example using the discrete fourier transform can be found at opencv_source_code/samples/cpp/dft.cpp
• (Python) An example using the dft functionality to perform Wiener deconvolution can be found at opencv_source/samples/python/deconvolution.py
• (Python) An example rearranging the quadrants of a Fourier image can be found at opencv_source/samples/python/dft.py

Parameters

src	input array that could be real or complex.
dst	output array whose size and type depends on the flags .
flags	transformation flags, representing a combination of the DftFlags
nonzeroRows	when the parameter is not zero, the function assumes that only the first nonzeroRows rows of the input array (DFT_INVERSE is not set) or only the first nonzeroRows of the output array (DFT_INVERSE is set) contain non-zeros, thus, the function can handle the rest of the rows more efficiently and save some time; this technique is very useful for calculating array cross-correlation or convolution using DFT.

See also

dct, getOptimalDFTSize, mulSpectrums, filter2D, matchTemplate, flip, cartToPolar, magnitude, phase

divide() [1/2]

void cv::divide	(	double	scale,
		InputArray	src2,
		OutputArray	dst,
		int	dtype = -1
	)

Python:
	cv.divide(	src1, src2[, dst[, scale[, dtype]]]	) ->	dst
	cv.divide(	scale, src2[, dst[, dtype]]	) ->	dst

#include <opencv2/core.hpp>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

divide() [2/2]

void cv::divide	(	InputArray	src1,
		InputArray	src2,
		OutputArray	dst,
		double	scale = 1,
		int	dtype = -1
	)

Python:
	cv.divide(	src1, src2[, dst[, scale[, dtype]]]	) ->	dst
	cv.divide(	scale, src2[, dst[, dtype]]	) ->	dst

#include <opencv2/core.hpp>

Performs per-element division of two arrays or a scalar by an array.

The function cv::divide divides one array by another:

\[\texttt{dst(I) = saturate(src1(I)*scale/src2(I))}\]

or a scalar by an array when there is no src1 :

\[\texttt{dst(I) = saturate(scale/src2(I))}\]

Different channels of multi-channel arrays are processed independently.

For integer types when src2(I) is zero, dst(I) will also be zero.

Note

In case of floating point data there is no special defined behavior for zero src2(I) values. Regular floating-point division is used. Expect correct IEEE-754 behaviour for floating-point data (with NaN, Inf result values).

Saturation is not applied when the output array has the depth CV_32S. You may even get result of an incorrect sign in the case of overflow.

(Python) Be careful to difference behaviour between src1/src2 are single number and they are tuple/array. divide(src,X) means divide(src,(X,X,X,X)). divide(src,(X,)) means divide(src,(X,0,0,0)).

Parameters

src1	first input array.
src2	second input array of the same size and type as src1.
scale	scalar factor.
dst	output array of the same size and type as src2.
dtype	optional depth of the output array; if -1, dst will have depth src2.depth(), but in case of an array-by-array division, you can only pass -1 when src1.depth()==src2.depth().

See also

multiply, add, subtract

eigen()

bool cv::eigen	(	InputArray	src,
		OutputArray	eigenvalues,
		OutputArray	eigenvectors = noArray()
	)

Python:
	cv.eigen(	src[, eigenvalues[, eigenvectors]]	) ->	retval, eigenvalues, eigenvectors

#include <opencv2/core.hpp>

Calculates eigenvalues and eigenvectors of a symmetric matrix.

The function cv::eigen calculates just eigenvalues, or eigenvalues and eigenvectors of the symmetric matrix src:

src*eigenvectors.row(i).t() = eigenvalues.at<srcType>(i)*eigenvectors.row(i).t()

Note

Use cv::eigenNonSymmetric for calculation of real eigenvalues and eigenvectors of non-symmetric matrix.

Parameters

src	input matrix that must have CV_32FC1 or CV_64FC1 type, square size and be symmetrical (src ^T^ == src).
eigenvalues	output vector of eigenvalues of the same type as src; the eigenvalues are stored in the descending order.
eigenvectors	output matrix of eigenvectors; it has the same size and type as src; the eigenvectors are stored as subsequent matrix rows, in the same order as the corresponding eigenvalues.

See also

eigenNonSymmetric, completeSymm, PCA

eigenNonSymmetric()

void cv::eigenNonSymmetric	(	InputArray	src,
		OutputArray	eigenvalues,
		OutputArray	eigenvectors
	)

Python:
	cv.eigenNonSymmetric(	src[, eigenvalues[, eigenvectors]]	) ->	eigenvalues, eigenvectors

#include <opencv2/core.hpp>

Calculates eigenvalues and eigenvectors of a non-symmetric matrix (real eigenvalues only).

Note

Assumes real eigenvalues.

The function calculates eigenvalues and eigenvectors (optional) of the square matrix src:

src*eigenvectors.row(i).t() = eigenvalues.at<srcType>(i)*eigenvectors.row(i).t()

Parameters

src	input matrix (CV_32FC1 or CV_64FC1 type).
eigenvalues	output vector of eigenvalues (type is the same type as src).
eigenvectors	output matrix of eigenvectors (type is the same type as src). The eigenvectors are stored as subsequent matrix rows, in the same order as the corresponding eigenvalues.

See also

eigen

exp()

void cv::exp	(	InputArray	src,
		OutputArray	dst
	)

Python:
	cv.exp(	src[, dst]	) ->	dst

#include <opencv2/core.hpp>

Calculates the exponent of every array element.

The function cv::exp calculates the exponent of every element of the input array:

\[\texttt{dst} [I] = e^{ src(I) }\]

The maximum relative error is about 7e-6 for single-precision input and less than 1e-10 for double-precision input. Currently, the function converts denormalized values to zeros on output. Special values (NaN, Inf) are not handled.

Parameters

src	input array.
dst	output array of the same size and type as src.

See also

log, cartToPolar, polarToCart, phase, pow, sqrt, magnitude

Here is the call graph for this function:

extractChannel()

void cv::extractChannel	(	InputArray	src,
		OutputArray	dst,
		int	coi
	)

Python:
	cv.extractChannel(	src, coi[, dst]	) ->	dst

#include <opencv2/core.hpp>

Extracts a single channel from src (coi is 0-based index)

Parameters

src	input array
dst	output array
coi	index of channel to extract

See also

mixChannels, split

findNonZero()

void cv::findNonZero	(	InputArray	src,
		OutputArray	idx
	)

Python:
	cv.findNonZero(	src[, idx]	) ->	idx

#include <opencv2/core.hpp>

Returns the list of locations of non-zero pixels.

Given a binary matrix (likely returned from an operation such as threshold(), compare(), >, ==, etc, return all of the non-zero indices as a cv::Mat or std::vector<cv::Point> (x,y) For example:

cv::Mat binaryImage; // input, binary image
cv::Mat locations;   // output, locations of non-zero pixels
cv::findNonZero(binaryImage, locations);
 
// access pixel coordinates
Point pnt = locations.at<Point>(i);

or

cv::Mat binaryImage; // input, binary image
vector<Point> locations;   // output, locations of non-zero pixels
cv::findNonZero(binaryImage, locations);
 
// access pixel coordinates
Point pnt = locations[i];

The function do not work with multi-channel arrays. If you need to find non-zero elements across all the channels, use Mat::reshape first to reinterpret the array as single-channel. Or you may extract the particular channel using either extractImageCOI, or mixChannels, or split.

Note

• CV_16F/CV_16BF/CV_Bool/CV_64U/CV_64S/CV_32U are not supported for src.
• If only count of non-zero array elements is important, countNonZero is helpful.
• If only whether there are non-zero elements is important, hasNonZero is helpful.

Parameters

src	single-channel array
idx	the output array, type of cv::Mat or std::vector<Point>, corresponding to non-zero indices in the input

See also

countNonZero, hasNonZero

finiteMask()

void cv::finiteMask	(	InputArray	src,
		OutputArray	mask
	)

Python:
	cv.finiteMask(	src[, mask]	) ->	mask

#include <opencv2/core.hpp>

Generates a mask of finite float values, i.e. not NaNs nor Infs.

An element is set to to 255 (all 1-bits) if all channels are finite.

Parameters

src	Input matrix, should contain float or double elements of 1 to 4 channels
mask	Output matrix of the same size as input of type CV_8UC1

flip()

void cv::flip	(	InputArray	src,
		OutputArray	dst,
		int	flipCode
	)

Python:
	cv.flip(	src, flipCode[, dst]	) ->	dst

#include <opencv2/core.hpp>

Flips a 2D array around vertical, horizontal, or both axes.

The function cv::flip flips the array in one of three different ways (row and column indices are 0-based):

\[\texttt{dst} _{ij} = \left\{ \begin{array}{l l} \texttt{src} _{\texttt{src.rows}-i-1,j} & if\; \texttt{flipCode} = 0 \\ \texttt{src} _{i, \texttt{src.cols} -j-1} & if\; \texttt{flipCode} > 0 \\ \texttt{src} _{ \texttt{src.rows} -i-1, \texttt{src.cols} -j-1} & if\; \texttt{flipCode} < 0 \\ \end{array} \right.\]

The example scenarios of using the function are the following: Vertical flipping of the image (flipCode == 0) to switch between top-left and bottom-left image origin. This is a typical operation in video processing on Microsoft Windows* OS. Horizontal flipping of the image with the subsequent horizontal shift and absolute difference calculation to check for a vertical-axis symmetry (flipCode > 0). Simultaneous horizontal and vertical flipping of the image with the subsequent shift and absolute difference calculation to check for a central symmetry (flipCode < 0). Reversing the order of point arrays (flipCode > 0 or flipCode == 0).

Parameters

src	input array.
dst	output array of the same size and type as src.
flipCode	a flag to specify how to flip the array; 0 means flipping around the x-axis and positive value (for example, 1) means flipping around y-axis. Negative value (for example, -1) means flipping around both axes.

See also

transpose, repeat, completeSymm

flipND()

void cv::flipND	(	InputArray	src,
		OutputArray	dst,
		int	axis
	)

Python:
	cv.flipND(	src, axis[, dst]	) ->	dst

#include <opencv2/core.hpp>

Flips a n-dimensional at given axis.

Parameters

src	input array
dst	output array that has the same shape of src
axis	axis that performs a flip on. 0 <= axis < src.dims.

gemm()

void cv::gemm	(	InputArray	src1,
		InputArray	src2,
		double	alpha,
		InputArray	src3,
		double	beta,
		OutputArray	dst,
		int	flags = 0
	)

Python:
	cv.gemm(	src1, src2, alpha, src3, beta[, dst[, flags]]	) ->	dst

#include <opencv2/core.hpp>

Performs generalized matrix multiplication.

The function cv::gemm performs generalized matrix multiplication similar to the gemm functions in BLAS level 3. For example, gemm(src1, src2, alpha, src3, beta, dst, GEMM_1_T + GEMM_3_T) corresponds to

\[\texttt{dst} = \texttt{alpha} \cdot \texttt{src1} ^T \cdot \texttt{src2} + \texttt{beta} \cdot \texttt{src3} ^T\]

In case of complex (two-channel) data, performed a complex matrix multiplication.

The function can be replaced with a matrix expression. For example, the above call can be replaced with:

dst = alpha*src1.t()*src2 + beta*src3.t();

Parameters

src1	first multiplied input matrix that could be real(CV_32FC1, CV_64FC1) or complex(CV_32FC2, CV_64FC2).
src2	second multiplied input matrix of the same type as src1.
alpha	weight of the matrix product.
src3	third optional delta matrix added to the matrix product; it should have the same type as src1 and src2.
beta	weight of src3.
dst	output matrix; it has the proper size and the same type as input matrices.
flags	operation flags (cv::GemmFlags)

See also

mulTransposed, transform

getOptimalDFTSize()

int cv::getOptimalDFTSize

(

int

vecsize

)

Python:
	cv.getOptimalDFTSize(	vecsize	) ->	retval

#include <opencv2/core.hpp>

Returns the optimal DFT size for a given vector size.

DFT performance is not a monotonic function of a vector size. Therefore, when you calculate convolution of two arrays or perform the spectral analysis of an array, it usually makes sense to pad the input data with zeros to get a bit larger array that can be transformed much faster than the original one. Arrays whose size is a power-of-two (2, 4, 8, 16, 32, ...) are the fastest to process. Though, the arrays whose size is a product of 2's, 3's, and 5's (for example, 300 = 5*5*3*2*2) are also processed quite efficiently.

The function cv::getOptimalDFTSize returns the minimum number N that is greater than or equal to vecsize so that the DFT of a vector of size N can be processed efficiently. In the current implementation N = 2 ^p^ * 3 ^q^ * 5 ^r^ for some integer p, q, r.

The function returns a negative number if vecsize is too large (very close to INT_MAX ).

While the function cannot be used directly to estimate the optimal vector size for DCT transform (since the current DCT implementation supports only even-size vectors), it can be easily processed as getOptimalDFTSize((vecsize+1)/2)*2.

Parameters

vecsize

vector size.

See also

dft, dct, idft, idct, mulSpectrums

hasNonZero()

bool cv::hasNonZero

(

InputArray

src

)

Python:
	cv.hasNonZero(	src	) ->	retval

#include <opencv2/core.hpp>

Checks for the presence of at least one non-zero array element.

The function returns whether there are non-zero elements in src

The function do not work with multi-channel arrays. If you need to check non-zero array elements across all the channels, use Mat::reshape first to reinterpret the array as single-channel. Or you may extract the particular channel using either extractImageCOI, or mixChannels, or split.

Note

• CV_16F/CV_16BF/CV_Bool/CV_64U/CV_64S/CV_32U are not supported for src.
• If the location of non-zero array elements is important, findNonZero is helpful.
• If the count of non-zero array elements is important, countNonZero is helpful.

Parameters

src	single-channel array.

See also

mean, meanStdDev, norm, minMaxLoc, calcCovarMatrix

findNonZero, countNonZero

hconcat() [1/3]

void cv::hconcat	(	const Mat *	src,
		size_t	nsrc,
		OutputArray	dst
	)

Python:
	cv.hconcat(	src[, dst]	) ->	dst

#include <opencv2/core.hpp>

Applies horizontal concatenation to given matrices.

The function horizontally concatenates two or more cv::Mat matrices (with the same number of rows).

cv::Mat matArray[] = { cv::Mat(4, 1, CV_8UC1, cv::Scalar(1)),
                       cv::Mat(4, 1, CV_8UC1, cv::Scalar(2)),
                       cv::Mat(4, 1, CV_8UC1, cv::Scalar(3)),};
 
cv::Mat out;
cv::hconcat( matArray, 3, out );
//out:
//[1, 2, 3;
// 1, 2, 3;
// 1, 2, 3;
// 1, 2, 3]

Parameters

src	input array or vector of matrices. all of the matrices must have the same number of rows and the same depth.
nsrc	number of matrices in src.
dst	output array. It has the same number of rows and depth as the src, and the sum of cols of the src.

See also

cv::vconcat(const Mat*, size_t, OutputArray),

cv::vconcat(InputArrayOfArrays, OutputArray) and

cv::vconcat(InputArray, InputArray, OutputArray)

hconcat() [2/3]

void cv::hconcat	(	InputArray	src1,
		InputArray	src2,
		OutputArray	dst
	)

Python:
	cv.hconcat(	src[, dst]	) ->	dst

#include <opencv2/core.hpp>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

cv::Mat_<float> A = (cv::Mat_<float>(3, 2) << 1, 4,
                                              2, 5,
                                              3, 6);
cv::Mat_<float> B = (cv::Mat_<float>(3, 2) << 7, 10,
                                              8, 11,
                                              9, 12);
 
cv::Mat C;
cv::hconcat(A, B, C);
//C:
//[1, 4, 7, 10;
// 2, 5, 8, 11;
// 3, 6, 9, 12]

Parameters

src1	first input array to be considered for horizontal concatenation.
src2	second input array to be considered for horizontal concatenation.
dst	output array. It has the same number of rows and depth as the src1 and src2, and the sum of cols of the src1 and src2.

hconcat() [3/3]

void cv::hconcat	(	InputArrayOfArrays	src,
		OutputArray	dst
	)

Python:
	cv.hconcat(	src[, dst]	) ->	dst

#include <opencv2/core.hpp>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

std::vector<cv::Mat> matrices = { cv::Mat(4, 1, CV_8UC1, cv::Scalar(1)),
                                  cv::Mat(4, 1, CV_8UC1, cv::Scalar(2)),
                                  cv::Mat(4, 1, CV_8UC1, cv::Scalar(3)),};
 
cv::Mat out;
cv::hconcat( matrices, out );
//out:
//[1, 2, 3;
// 1, 2, 3;
// 1, 2, 3;
// 1, 2, 3]

Parameters

src	input array or vector of matrices. all of the matrices must have the same number of rows and the same depth.
dst	output array. It has the same number of rows and depth as the src, and the sum of cols of the src. same depth.

idct()

void cv::idct	(	InputArray	src,
		OutputArray	dst,
		int	flags = 0
	)

Python:
	cv.idct(	src[, dst[, flags]]	) ->	dst

#include <opencv2/core.hpp>

Calculates the inverse Discrete Cosine Transform of a 1D or 2D array.

idct(src, dst, flags) is equivalent to dct(src, dst, flags | DCT_INVERSE).

Parameters

src	input floating-point single-channel array.
dst	output array of the same size and type as src.
flags	operation flags.

See also

dct, dft, idft, getOptimalDFTSize

idft()

void cv::idft	(	InputArray	src,
		OutputArray	dst,
		int	flags = 0,
		int	nonzeroRows = 0
	)

Python:
	cv.idft(	src[, dst[, flags[, nonzeroRows]]]	) ->	dst

#include <opencv2/core.hpp>

Calculates the inverse Discrete Fourier Transform of a 1D or 2D array.

idft(src, dst, flags) is equivalent to dft(src, dst, flags | DFT_INVERSE) .

Note

None of dft and idft scales the result by default. So, you should pass DFT_SCALE to one of dft or idft explicitly to make these transforms mutually inverse.

See also

dft, dct, idct, mulSpectrums, getOptimalDFTSize

Parameters

src	input floating-point real or complex array.
dst	output array whose size and type depend on the flags.
flags	operation flags (see dft and DftFlags).
nonzeroRows	number of dst rows to process; the rest of the rows have undefined content (see the convolution sample in dft description.

inRange()

void cv::inRange	(	InputArray	src,
		InputArray	lowerb,
		InputArray	upperb,
		OutputArray	dst
	)

Python:
	cv.inRange(	src, lowerb, upperb[, dst]	) ->	dst

#include <opencv2/core.hpp>

Checks if array elements lie between the elements of two other arrays.

The function checks the range as follows:

• For every element of a single-channel input array:

  \[\texttt{dst} (I)= \texttt{lowerb} (I)_0 \leq \texttt{src} (I)_0 \leq \texttt{upperb} (I)_0\]

• For two-channel arrays:

  \[\texttt{dst} (I)= \texttt{lowerb} (I)_0 \leq \texttt{src} (I)_0 \leq \texttt{upperb} (I)_0 \land \texttt{lowerb} (I)_1 \leq \texttt{src} (I)_1 \leq \texttt{upperb} (I)_1\]

• and so forth.

That is, dst (I) is set to 255 (all 1 -bits) if src (I) is within the specified 1D, 2D, 3D, ... box and 0 otherwise.

When the lower and/or upper boundary parameters are scalars, the indexes (I) at lowerb and upperb in the above formulas should be omitted.

Parameters

src	first input array.
lowerb	inclusive lower boundary array or a scalar.
upperb	inclusive upper boundary array or a scalar.
dst	output array of the same size as src and CV_8U type.

insertChannel()

void cv::insertChannel	(	InputArray	src,
		InputOutputArray	dst,
		int	coi
	)

Python:
	cv.insertChannel(	src, dst, coi	) ->	dst

#include <opencv2/core.hpp>

Inserts a single channel to dst (coi is 0-based index)

Parameters

src	input array
dst	output array
coi	index of channel for insertion

See also

mixChannels, merge

invert()

double cv::invert	(	InputArray	src,
		OutputArray	dst,
		int	flags = DECOMP_LU
	)

Python:
	cv.invert(	src[, dst[, flags]]	) ->	retval, dst

#include <opencv2/core.hpp>

Finds the inverse or pseudo-inverse of a matrix.

The function cv::invert inverts the matrix src and stores the result in dst . When the matrix src is singular or non-square, the function calculates the pseudo-inverse matrix (the dst matrix) so that norm(src*dst - I) is minimal, where I is an identity matrix.

In case of the DECOMP_LU method, the function returns non-zero value if the inverse has been successfully calculated and 0 if src is singular.

In case of the DECOMP_SVD method, the function returns the inverse condition number of src (the ratio of the smallest singular value to the largest singular value) and 0 if src is singular. The SVD method calculates a pseudo-inverse matrix if src is singular.

Similarly to DECOMP_LU, the method DECOMP_CHOLESKY works only with non-singular square matrices that should also be symmetrical and positively defined. In this case, the function stores the inverted matrix in dst and returns non-zero. Otherwise, it returns 0.

Parameters

src	input floating-point M x N matrix.
dst	output matrix of N x M size and the same type as src.
flags	inversion method (cv::DecompTypes)

See also

solve, SVD

log()

void cv::log	(	InputArray	src,
		OutputArray	dst
	)

Python:
	cv.log(	src[, dst]	) ->	dst

#include <opencv2/core.hpp>

Calculates the natural logarithm of every array element.

The function cv::log calculates the natural logarithm of every element of the input array:

\[\texttt{dst} (I) = \log (\texttt{src}(I)) \]

Output on zero, negative and special (NaN, Inf) values is undefined.

Parameters

src	input array.
dst	output array of the same size and type as src .

See also

exp, cartToPolar, polarToCart, phase, pow, sqrt, magnitude

Here is the call graph for this function:

LUT()

void cv::LUT	(	InputArray	src,
		InputArray	lut,
		OutputArray	dst
	)

Python:
	cv.LUT(	src, lut[, dst]	) ->	dst

#include <opencv2/core.hpp>

Performs a look-up table transform of an array.

The function LUT fills the output array with values from the look-up table. Indices of the entries are taken from the input array. That is, the function processes each element of src as follows:

\[\texttt{dst} (I) \leftarrow \texttt{lut(src(I) + d)}\]

where

\[d = \fork{0}{if \(\texttt{src}\) has depth \(\texttt{CV_8U}\)}{128}{if \(\texttt{src}\) has depth \(\texttt{CV_8S}\)}\]

Note

CV_16F/CV_16BF/CV_Bool/CV_64U/CV_64S/CV_32U are not supported for lut.

Parameters

src	input array of 8-bit elements.
lut	look-up table of 256 elements; in case of multi-channel input array, the table should either have a single channel (in this case the same table is used for all channels) or the same number of channels as in the input array.
dst	output array of the same size and number of channels as src, and the same depth as lut.

See also

convertScaleAbs, Mat::convertTo

magnitude()

void cv::magnitude	(	InputArray	x,
		InputArray	y,
		OutputArray	magnitude
	)

Python:
	cv.magnitude(	x, y[, magnitude]	) ->	magnitude

#include <opencv2/core.hpp>

Calculates the magnitude of 2D vectors.

The function cv::magnitude calculates the magnitude of 2D vectors formed from the corresponding elements of x and y arrays:

\[\texttt{dst} (I) = \sqrt{\texttt{x}(I)^2 + \texttt{y}(I)^2}\]

Parameters

x	floating-point array of x-coordinates of the vectors.
y	floating-point array of y-coordinates of the vectors; it must have the same size as x.
magnitude	output array of the same size and type as x.

See also

cartToPolar, polarToCart, phase, sqrt

Mahalanobis()

double cv::Mahalanobis	(	InputArray	v1,
		InputArray	v2,
		InputArray	icovar
	)

Python:
	cv.Mahalanobis(	v1, v2, icovar	) ->	retval

#include <opencv2/core.hpp>

Calculates the Mahalanobis distance between two vectors.

The function cv::Mahalanobis calculates and returns the weighted distance between two vectors:

\[d( \texttt{vec1} , \texttt{vec2} )= \sqrt{\sum_{i,j}{\texttt{icovar(i,j)}\cdot(\texttt{vec1}(I)-\texttt{vec2}(I))\cdot(\texttt{vec1(j)}-\texttt{vec2(j)})} }\]

The covariance matrix may be calculated using the calcCovarMatrix function and then inverted using the invert function (preferably using the DECOMP_SVD method, as the most accurate).

Parameters

v1	first 1D input vector.
v2	second 1D input vector.
icovar	inverse covariance matrix.

max() [1/3]

void cv::max	(	const Mat &	src1,
		const Mat &	src2,
		Mat &	dst
	)

Python:
	cv.max(	src1, src2[, dst]	) ->	dst

#include <opencv2/core.hpp>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. needed to avoid conflicts with const _Tp& std::min(const _Tp&, const _Tp&, _Compare)

Here is the call graph for this function:

max() [2/3]

void cv::max	(	const UMat &	src1,
		const UMat &	src2,
		UMat &	dst
	)

Python:
	cv.max(	src1, src2[, dst]	) ->	dst

#include <opencv2/core.hpp>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. needed to avoid conflicts with const _Tp& std::min(const _Tp&, const _Tp&, _Compare)

Here is the call graph for this function:

max() [3/3]

void cv::max	(	InputArray	src1,
		InputArray	src2,
		OutputArray	dst
	)

Python:
	cv.max(	src1, src2[, dst]	) ->	dst

#include <opencv2/core.hpp>

Calculates per-element maximum of two arrays or an array and a scalar.

The function cv::max calculates the per-element maximum of two arrays:

\[\texttt{dst} (I)= \max ( \texttt{src1} (I), \texttt{src2} (I))\]

or array and a scalar:

\[\texttt{dst} (I)= \max ( \texttt{src1} (I), \texttt{value} )\]

Parameters

src1	first input array.
src2	second input array of the same size and type as src1 .
dst	output array of the same size and type as src1.

See also

min, compare, inRange, minMaxLoc, MatrixExpressions

Here is the call graph for this function:

mean()

Scalar cv::mean	(	InputArray	src,
		InputArray	mask = noArray()
	)

Python:
	cv.mean(	src[, mask]	) ->	retval

#include <opencv2/core.hpp>

Calculates an average (mean) of array elements.

The function cv::mean calculates the mean value M of array elements, independently for each channel, and return it:

\[\begin{array}{l} N = \sum _{I: \; \texttt{mask} (I) \ne 0} 1 \\ M_c = \left ( \sum _{I: \; \texttt{mask} (I) \ne 0}{ \texttt{mtx} (I)_c} \right )/N \end{array}\]

When all the mask elements are 0's, the function returns Scalar::all(0)

Parameters

src	input array that should have from 1 to 4 channels so that the result can be stored in Scalar_ .
mask	optional operation mask ot type CV_8U, CV_8S or CV_Bool.

See also

countNonZero, meanStdDev, norm, minMaxLoc

meanStdDev()

void cv::meanStdDev	(	InputArray	src,
		OutputArray	mean,
		OutputArray	stddev,
		InputArray	mask = noArray()
	)

Python:
	cv.meanStdDev(	src[, mean[, stddev[, mask]]]	) ->	mean, stddev

#include <opencv2/core.hpp>

Calculates a mean and standard deviation of array elements.

The function cv::meanStdDev calculates the mean and the standard deviation M of array elements independently for each channel and returns it via the output parameters:

\[\begin{array}{l} N = \sum _{I, \texttt{mask} (I) \ne 0} 1 \\ \texttt{mean} _c = \frac{\sum_{ I: \; \texttt{mask}(I) \ne 0} \texttt{src} (I)_c}{N} \\ \texttt{stddev} _c = \sqrt{\frac{\sum_{ I: \; \texttt{mask}(I) \ne 0} \left ( \texttt{src} (I)_c - \texttt{mean} _c \right )^2}{N}} \end{array}\]

When all the mask elements are 0's, the function returns mean=stddev=Scalar::all(0).

Note

The calculated standard deviation is only the diagonal of the complete normalized covariance matrix. If the full matrix is needed, you can reshape the multi-channel array M x N to the single-channel array M*N x mtx.channels() (only possible when the matrix is continuous) and then pass the matrix to calcCovarMatrix .

Parameters

src	input array that should have from 1 to 4 channels so that the results can be stored in Scalar_ 's.
mean	output parameter: calculated mean value.
stddev	output parameter: calculated standard deviation.
mask	optional operation mask of type CV_8U, CV_8S or CV_Bool.

See also

countNonZero, mean, norm, minMaxLoc, calcCovarMatrix

merge() [1/2]

void cv::merge	(	const Mat *	mv,
		size_t	count,
		OutputArray	dst
	)

Python:
	cv.merge(	mv[, dst]	) ->	dst

#include <opencv2/core.hpp>

Creates one multi-channel array out of several single-channel ones.

The function cv::merge merges several arrays to make a single multi-channel array. That is, each element of the output array will be a concatenation of the elements of the input arrays, where elements of i-th input array are treated as mv[i].channels()-element vectors.

The function cv::split does the reverse operation. If you need to shuffle channels in some other advanced way, use cv::mixChannels.

The following example shows how to merge 3 single channel matrices into a single 3-channel matrix.

    Mat m1 = (Mat_<uchar>(2,2) << 1,4,7,10);
    Mat m2 = (Mat_<uchar>(2,2) << 2,5,8,11);
    Mat m3 = (Mat_<uchar>(2,2) << 3,6,9,12);
 
    Mat channels[3] = {m1, m2, m3};
    Mat m;
    merge(channels, 3, m);
    /*
    m =
    [  1,   2,   3,   4,   5,   6;
       7,   8,   9,  10,  11,  12]
    m.channels() = 3
    */

Parameters

mv	input array of matrices to be merged; all the matrices in mv must have the same size and the same depth.
count	number of input matrices when mv is a plain C array; it must be greater than zero.
dst	output array of the same size and the same depth as mv[0]; The number of channels will be equal to the parameter count.

See also

mixChannels, split, Mat::reshape

merge() [2/2]

void cv::merge	(	InputArrayOfArrays	mv,
		OutputArray	dst
	)

Python:
	cv.merge(	mv[, dst]	) ->	dst

#include <opencv2/core.hpp>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Parameters

mv	input vector of matrices to be merged; all the matrices in mv must have the same size and the same depth.
dst	output array of the same size and the same depth as mv[0]; The number of channels will be the total number of channels in the matrix array.

min() [1/3]

void cv::min	(	const Mat &	src1,
		const Mat &	src2,
		Mat &	dst
	)

Python:
	cv.min(	src1, src2[, dst]	) ->	dst

#include <opencv2/core.hpp>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. needed to avoid conflicts with const _Tp& std::min(const _Tp&, const _Tp&, _Compare)

Here is the call graph for this function:

min() [2/3]

void cv::min	(	const UMat &	src1,
		const UMat &	src2,
		UMat &	dst
	)

Python:
	cv.min(	src1, src2[, dst]	) ->	dst

#include <opencv2/core.hpp>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. needed to avoid conflicts with const _Tp& std::min(const _Tp&, const _Tp&, _Compare)

Here is the call graph for this function:

min() [3/3]

void cv::min	(	InputArray	src1,
		InputArray	src2,
		OutputArray	dst
	)

Python:
	cv.min(	src1, src2[, dst]	) ->	dst

#include <opencv2/core.hpp>

Calculates per-element minimum of two arrays or an array and a scalar.

The function cv::min calculates the per-element minimum of two arrays:

\[\texttt{dst} (I)= \min ( \texttt{src1} (I), \texttt{src2} (I))\]

or array and a scalar:

\[\texttt{dst} (I)= \min ( \texttt{src1} (I), \texttt{value} )\]

Parameters

src1	first input array.
src2	second input array of the same size and type as src1.
dst	output array of the same size and type as src1.

See also

max, compare, inRange, minMaxLoc

Here is the call graph for this function:

minMaxIdx()

void cv::minMaxIdx	(	InputArray	src,
		double *	minVal,
		double *	maxVal = 0,
		int *	minIdx = 0,
		int *	maxIdx = 0,
		InputArray	mask = noArray()
	)

#include <opencv2/core.hpp>

Finds the global minimum and maximum in an array.

The function cv::minMaxIdx finds the minimum and maximum element values and their positions. The extremums are searched across the whole array or, if mask is not an empty array, in the specified array region. In case of a sparse matrix, the minimum is found among non-zero elements only. Multi-channel input is supported without mask and extremums indexes (should be nullptr).

Note

When minIdx is not NULL, it must have at least 2 elements (as well as maxIdx), even if src is a single-row or single-column matrix. In OpenCV (following MATLAB) each array has at least 2 dimensions, i.e. single-column matrix is Mx1 matrix (and therefore minIdx/maxIdx will be (i1,0)/(i2,0)) and single-row matrix is 1xN matrix (and therefore minIdx/maxIdx will be (0,j1)/(0,j2)).

CV_16F/CV_16BF/CV_Bool/CV_64U/CV_64S/CV_32U are not supported for src.

Parameters

src	input single-channel array.
minVal	pointer to the returned minimum value; NULL is used if not required.
maxVal	pointer to the returned maximum value; NULL is used if not required.
minIdx	pointer to the returned minimum location (in nD case); NULL is used if not required; Otherwise, it must point to an array of src.dims elements, the coordinates of the minimum element in each dimension are stored there sequentially.
maxIdx	pointer to the returned maximum location (in nD case). NULL is used if not required.
mask	specified array region

minMaxLoc() [1/2]

void cv::minMaxLoc	(	const SparseMat &	a,
		double *	minVal,
		double *	maxVal,
		int *	minIdx = 0,
		int *	maxIdx = 0
	)

Python:
	cv.minMaxLoc(	src[, mask]	) ->	minVal, maxVal, minLoc, maxLoc

#include <opencv2/core.hpp>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Parameters

a	input single-channel array.
minVal	pointer to the returned minimum value; NULL is used if not required.
maxVal	pointer to the returned maximum value; NULL is used if not required.
minIdx	pointer to the returned minimum location (in nD case); NULL is used if not required; Otherwise, it must point to an array of src.dims elements, the coordinates of the minimum element in each dimension are stored there sequentially.
maxIdx	pointer to the returned maximum location (in nD case). NULL is used if not required.

minMaxLoc() [2/2]

void cv::minMaxLoc	(	InputArray	src,
		double *	minVal,
		double *	maxVal = 0,
		Point *	minLoc = 0,
		Point *	maxLoc = 0,
		InputArray	mask = noArray()
	)

Python:
	cv.minMaxLoc(	src[, mask]	) ->	minVal, maxVal, minLoc, maxLoc

#include <opencv2/core.hpp>

Finds the global minimum and maximum in an array.

The function cv::minMaxLoc finds the minimum and maximum element values and their positions. The extremums are searched across the whole array or, if mask is not an empty array, in the specified array region.

In C++, if the input is multi-channel, you should omit the minLoc, maxLoc, and mask arguments (i.e. leave them as NULL, NULL, and noArray() respectively). These arguments are not supported for multi-channel input arrays. If working with multi-channel input and you need the minLoc, maxLoc, or mask arguments, then use Mat::reshape first to reinterpret the array as single-channel. Alternatively, you can extract the particular channel using either extractImageCOI, mixChannels, or split.

In Python, multi-channel input is not supported at all due to a limitation in the binding generation process (there is no way to set minLoc and maxLoc to NULL). A workaround is to operate on each channel individually or to use NumPy to achieve the same functionality.

Note

CV_16F/CV_16BF/CV_Bool/CV_64U/CV_64S/CV_32U are not supported for src.

Parameters

src	input single-channel array.
minVal	pointer to the returned minimum value; NULL is used if not required.
maxVal	pointer to the returned maximum value; NULL is used if not required.
minLoc	pointer to the returned minimum location (in 2D case); NULL is used if not required.
maxLoc	pointer to the returned maximum location (in 2D case); NULL is used if not required.
mask	optional mask used to select a sub-array of type CV_8U, CV_8S or CV_Bool.

See also

max, min, reduceArgMin, reduceArgMax, compare, inRange, extractImageCOI, mixChannels, split, Mat::reshape

mixChannels() [1/3]

void cv::mixChannels	(	const Mat *	src,
		size_t	nsrcs,
		Mat *	dst,
		size_t	ndsts,
		const int *	fromTo,
		size_t	npairs
	)

Python:
	cv.mixChannels(	src, dst, fromTo	) ->	dst

#include <opencv2/core.hpp>

Copies specified channels from input arrays to the specified channels of output arrays.

The function cv::mixChannels provides an advanced mechanism for shuffling image channels.

cv::split,cv::merge,cv::extractChannel,cv::insertChannel and some forms of cv::cvtColor are partial cases of cv::mixChannels.

In the example below, the code splits a 4-channel BGRA image into a 3-channel BGR (with B and R channels swapped) and a separate alpha-channel image:

Mat bgra( 100, 100, CV_8UC4, Scalar(255,0,0,255) );
Mat bgr( bgra.rows, bgra.cols, CV_8UC3 );
Mat alpha( bgra.rows, bgra.cols, CV_8UC1 );
 
// forming an array of matrices is a quite efficient operation,
// because the matrix data is not copied, only the headers
Mat out[] = { bgr, alpha };
// bgra[0] -> bgr[2], bgra[1] -> bgr[1],
// bgra[2] -> bgr[0], bgra[3] -> alpha[0]
int from_to[] = { 0,2, 1,1, 2,0, 3,3 };
mixChannels( &bgra, 1, out, 2, from_to, 4 );

Note

Unlike many other new-style C++ functions in OpenCV (see the introduction section and Mat::create ), cv::mixChannels requires the output arrays to be pre-allocated before calling the function.

Parameters

src	input array or vector of matrices; all of the matrices must have the same size and the same depth.
nsrcs	number of matrices in src.
dst	output array or vector of matrices; all the matrices must be allocated; their size and depth must be the same as in src[0].
ndsts	number of matrices in dst.
fromTo	array of index pairs specifying which channels are copied and where; fromTo[k*2] is a 0-based index of the input channel in src, fromTo[k*2+1] is an index of the output channel in dst; the continuous channel numbering is used: the first input image channels are indexed from 0 to src[0].channels()-1, the second input image channels are indexed from src[0].channels() to src[0].channels() + src[1].channels()-1, and so on, the same scheme is used for the output image channels; as a special case, when fromTo[k*2] is negative, the corresponding output channel is filled with zero .
npairs	number of index pairs in fromTo.

See also

split, merge, extractChannel, insertChannel, cvtColor

mixChannels() [2/3]

void cv::mixChannels	(	InputArrayOfArrays	src,
		InputOutputArrayOfArrays	dst,
		const int *	fromTo,
		size_t	npairs
	)

Python:
	cv.mixChannels(	src, dst, fromTo	) ->	dst

#include <opencv2/core.hpp>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Parameters

src	input array or vector of matrices; all of the matrices must have the same size and the same depth.
dst	output array or vector of matrices; all the matrices must be allocated; their size and depth must be the same as in src[0].
fromTo	array of index pairs specifying which channels are copied and where; fromTo[k*2] is a 0-based index of the input channel in src, fromTo[k*2+1] is an index of the output channel in dst; the continuous channel numbering is used: the first input image channels are indexed from 0 to src[0].channels()-1, the second input image channels are indexed from src[0].channels() to src[0].channels() + src[1].channels()-1, and so on, the same scheme is used for the output image channels; as a special case, when fromTo[k*2] is negative, the corresponding output channel is filled with zero .
npairs	number of index pairs in fromTo.

mixChannels() [3/3]

void cv::mixChannels	(	InputArrayOfArrays	src,
		InputOutputArrayOfArrays	dst,
		const std::vector< int > &	fromTo
	)

Python:
	cv.mixChannels(	src, dst, fromTo	) ->	dst

#include <opencv2/core.hpp>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Parameters

src	input array or vector of matrices; all of the matrices must have the same size and the same depth.
dst	output array or vector of matrices; all the matrices must be allocated; their size and depth must be the same as in src[0].
fromTo	array of index pairs specifying which channels are copied and where; fromTo[k*2] is a 0-based index of the input channel in src, fromTo[k*2+1] is an index of the output channel in dst; the continuous channel numbering is used: the first input image channels are indexed from 0 to src[0].channels()-1, the second input image channels are indexed from src[0].channels() to src[0].channels() + src[1].channels()-1, and so on, the same scheme is used for the output image channels; as a special case, when fromTo[k*2] is negative, the corresponding output channel is filled with zero .

mulSpectrums()

void cv::mulSpectrums	(	InputArray	a,
		InputArray	b,
		OutputArray	c,
		int	flags,
		bool	conjB = false
	)

Python:
	cv.mulSpectrums(	a, b, flags[, c[, conjB]]	) ->	c

#include <opencv2/core.hpp>

Performs the per-element multiplication of two Fourier spectrums.

The function cv::mulSpectrums performs the per-element multiplication of the two CCS-packed or complex matrices that are results of a real or complex Fourier transform.

The function, together with dft and idft, may be used to calculate convolution (pass conjB=false ) or correlation (pass conjB=true ) of two arrays rapidly. When the arrays are complex, they are simply multiplied (per element) with an optional conjugation of the second-array elements. When the arrays are real, they are assumed to be CCS-packed (see dft for details).

Parameters

a	first input array.
b	second input array of the same size and type as src1 .
c	output array of the same size and type as src1 .
flags	operation 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.
conjB	optional flag that conjugates the second input array before the multiplication (true) or not (false).

multiply()

void cv::multiply	(	InputArray	src1,
		InputArray	src2,
		OutputArray	dst,
		double	scale = 1,
		int	dtype = -1
	)

Python:
	cv.multiply(	src1, src2[, dst[, scale[, dtype]]]	) ->	dst

#include <opencv2/core.hpp>

Calculates the per-element scaled product of two arrays.

The function multiply calculates the per-element product of two arrays:

\[\texttt{dst} (I)= \texttt{saturate} ( \texttt{scale} \cdot \texttt{src1} (I) \cdot \texttt{src2} (I))\]

There is also a MatrixExpressions -friendly variant of the first function. See Mat::mul .

For a not-per-element matrix product, see gemm .

Note

Saturation is not applied when the output array has the depth CV_32S. You may even get result of an incorrect sign in the case of overflow.

(Python) Be careful to difference behaviour between src1/src2 are single number and they are tuple/array. multiply(src,X) means multiply(src,(X,X,X,X)). multiply(src,(X,)) means multiply(src,(X,0,0,0)).

Parameters

src1	first input array.
src2	second input array of the same size and the same type as src1.
dst	output array of the same size and type as src1.
scale	optional scale factor.
dtype	optional depth of the output array

See also

add, subtract, divide, scaleAdd, addWeighted, accumulate, accumulateProduct, accumulateSquare, Mat::convertTo

mulTransposed()

void cv::mulTransposed	(	InputArray	src,
		OutputArray	dst,
		bool	aTa,
		InputArray	delta = noArray(),
		double	scale = 1,
		int	dtype = -1
	)

Python:
	cv.mulTransposed(	src, aTa[, dst[, delta[, scale[, dtype]]]]	) ->	dst

#include <opencv2/core.hpp>

Calculates the product of a matrix and its transposition.

The function cv::mulTransposed calculates the product of src and its transposition:

\[\texttt{dst} = \texttt{scale} ( \texttt{src} - \texttt{delta} )^T ( \texttt{src} - \texttt{delta} )\]

if aTa=true, and

\[\texttt{dst} = \texttt{scale} ( \texttt{src} - \texttt{delta} ) ( \texttt{src} - \texttt{delta} )^T\]

otherwise. The function is used to calculate the covariance matrix. With zero delta, it can be used as a faster substitute for general matrix product A*B when B=A'

Parameters

src	input single-channel matrix. Note that unlike gemm, the function can multiply not only floating-point matrices.
dst	output square matrix.
aTa	Flag specifying the multiplication ordering. See the description below.
delta	Optional delta matrix subtracted from src before the multiplication. When the matrix is empty ( delta=noArray() ), it is assumed to be zero, that is, nothing is subtracted. If it has the same size as src, it is simply subtracted. Otherwise, it is "repeated" (see repeat ) to cover the full src and then subtracted. Type of the delta matrix, when it is not empty, must be the same as the type of created output matrix. See the dtype parameter description below.
scale	Optional scale factor for the matrix product.
dtype	Optional type of the output matrix. When it is negative, the output matrix will have the same type as src . Otherwise, it will be type=CV_MAT_DEPTH(dtype) that should be either CV_32F or CV_64F .

See also

calcCovarMatrix, gemm, repeat, reduce

norm() [1/3]

double cv::norm	(	const SparseMat &	src,
		int	normType
	)

Python:
	cv.norm(	src1[, normType[, mask]]	) ->	retval
	cv.norm(	src1, src2[, normType[, mask]]	) ->	retval

#include <opencv2/core.hpp>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Parameters

src	first input array.
normType	type of the norm (see NormTypes).

norm() [2/3]

double cv::norm	(	InputArray	src1,
		InputArray	src2,
		int	normType = NORM_L2,
		InputArray	mask = noArray()
	)

Python:
	cv.norm(	src1[, normType[, mask]]	) ->	retval
	cv.norm(	src1, src2[, normType[, mask]]	) ->	retval

#include <opencv2/core.hpp>

Calculates an absolute difference norm or a relative difference norm.

This version of cv::norm calculates the absolute difference norm or the relative difference norm of arrays src1 and src2. The type of norm to calculate is specified using NormTypes.

Parameters

src1	first input array.
src2	second input array of the same size and the same type as src1.
normType	type of the norm (see NormTypes).
mask	optional operation mask; it must have the same size as src1 and type CV_8UC1, CV_8S1 or CV_BoolC1.

norm() [3/3]

double cv::norm	(	InputArray	src1,
		int	normType = NORM_L2,
		InputArray	mask = noArray()
	)

Python:
	cv.norm(	src1[, normType[, mask]]	) ->	retval
	cv.norm(	src1, src2[, normType[, mask]]	) ->	retval

#include <opencv2/core.hpp>

Calculates the absolute norm of an array.

This version of norm calculates the absolute norm of src1. The type of norm to calculate is specified using NormTypes.

As example for one array consider the function \(r(x)= \begin{pmatrix} x \\ 1-x \end{pmatrix}, x \in [-1;1]\). The \( L_{1}, L_{2} \) and \( L_{\infty} \) norm for the sample value \(r(-1) = \begin{pmatrix} -1 \\ 2 \end{pmatrix}\) is calculated as follows

\begin{align*} \| r(-1) \|_{L_1} &= |-1| + |2| = 3 \\ \| r(-1) \|_{L_2} &= \sqrt{(-1)^{2} + (2)^{2}} = \sqrt{5} \\ \| r(-1) \|_{L_\infty} &= \max(|-1|,|2|) = 2 \end{align*}

and for \(r(0.5) = \begin{pmatrix} 0.5 \\ 0.5 \end{pmatrix}\) the calculation is

\begin{align*} \| r(0.5) \|_{L_1} &= |0.5| + |0.5| = 1 \\ \| r(0.5) \|_{L_2} &= \sqrt{(0.5)^{2} + (0.5)^{2}} = \sqrt{0.5} \\ \| r(0.5) \|_{L_\infty} &= \max(|0.5|,|0.5|) = 0.5. \end{align*}

The following graphic shows all values for the three norm functions \(\| r(x) \|_{L_1}, \| r(x) \|_{L_2}\) and \(\| r(x) \|_{L_\infty}\). It is notable that the \( L_{1} \) norm forms the upper and the \( L_{\infty} \) norm forms the lower border for the example function \( r(x) \).

When the mask parameter is specified and it is not empty, the norm is

If normType is not specified, NORM_L2 is used. calculated only over the region specified by the mask.

Multi-channel input arrays are treated as single-channel arrays, that is, the results for all channels are combined.

Hamming norms can only be calculated with CV_8U depth arrays.

Parameters

src1	first input array.
normType	type of the norm (see NormTypes).
mask	optional operation mask; it must have the same size as src1 and type CV_8UC1, CV_8SC1 or CV_BoolC1.

normalize() [1/2]

void cv::normalize	(	const SparseMat &	src,
		SparseMat &	dst,
		double	alpha,
		int	normType
	)

Python:
	cv.normalize(	src, dst[, alpha[, beta[, norm_type[, dtype[, mask]]]]]	) ->	dst

#include <opencv2/core.hpp>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Parameters

src	input array.
dst	output array of the same size as src .
alpha	norm value to normalize to or the lower range boundary in case of the range normalization.
normType	normalization type (see cv::NormTypes).

normalize() [2/2]

void cv::normalize	(	InputArray	src,
		InputOutputArray	dst,
		double	alpha = 1,
		double	beta = 0,
		int	norm_type = NORM_L2,
		int	dtype = -1,
		InputArray	mask = noArray()
	)

Python:
	cv.normalize(	src, dst[, alpha[, beta[, norm_type[, dtype[, mask]]]]]	) ->	dst

#include <opencv2/core.hpp>

Normalizes the norm or value range of an array.

The function cv::normalize normalizes scale and shift the input array elements so that

\[\| \texttt{dst} \| _{L_p}= \texttt{alpha}\]

(where p=Inf, 1 or 2) when normType=NORM_INF, NORM_L1, or NORM_L2, respectively; or so that

\[\min _I \texttt{dst} (I)= \texttt{alpha} , \, \, \max _I \texttt{dst} (I)= \texttt{beta}\]

when normType=NORM_MINMAX (for dense arrays only). The optional mask specifies a sub-array to be normalized. This means that the norm or min-n-max are calculated over the sub-array, and then this sub-array is modified to be normalized. If you want to only use the mask to calculate the norm or min-max but modify the whole array, you can use norm and Mat::convertTo.

In case of sparse matrices, only the non-zero values are analyzed and transformed. Because of this, the range transformation for sparse matrices is not allowed since it can shift the zero level.

Possible usage with some positive example data:

vector<double> positiveData = { 2.0, 8.0, 10.0 };
vector<double> normalizedData_l1, normalizedData_l2, normalizedData_inf, normalizedData_minmax;
 
// Norm to probability (total count)
// sum(numbers) = 20.0
// 2.0      0.1     (2.0/20.0)
// 8.0      0.4     (8.0/20.0)
// 10.0     0.5     (10.0/20.0)
normalize(positiveData, normalizedData_l1, 1.0, 0.0, NORM_L1);
 
// Norm to unit vector: ||positiveData|| = 1.0
// 2.0      0.15
// 8.0      0.62
// 10.0     0.77
normalize(positiveData, normalizedData_l2, 1.0, 0.0, NORM_L2);
 
// Norm to max element
// 2.0      0.2     (2.0/10.0)
// 8.0      0.8     (8.0/10.0)
// 10.0     1.0     (10.0/10.0)
normalize(positiveData, normalizedData_inf, 1.0, 0.0, NORM_INF);
 
// Norm to range [0.0;1.0]
// 2.0      0.0     (shift to left border)
// 8.0      0.75    (6.0/8.0)
// 10.0     1.0     (shift to right border)
normalize(positiveData, normalizedData_minmax, 1.0, 0.0, NORM_MINMAX);

Parameters

src	input array.
dst	output array of the same size as src .
alpha	norm value to normalize to or the lower range boundary in case of the range normalization.
beta	upper range boundary in case of the range normalization; it is not used for the norm normalization.
norm_type	normalization type (see cv::NormTypes).
dtype	when negative, the output array has the same type as src; otherwise, it has the same number of channels as src and the depth =CV_MAT_DEPTH(dtype).
mask	optional operation mask of type CV_8U, CV_8S or CV_Bool.

See also

norm, Mat::convertTo, SparseMat::convertTo

Examples

samples/cpp/pca.cpp.

patchNaNs()

void cv::patchNaNs	(	InputOutputArray	a,
		double	val = 0
	)

Python:
	cv.patchNaNs(	a[, val]	) ->	a

#include <opencv2/core.hpp>

Replaces NaNs by given number.

Parameters

a	input/output matrix (CV_32F or CV_64F type)
val	value to convert the NaNs

PCABackProject()

void cv::PCABackProject	(	InputArray	data,
		InputArray	mean,
		InputArray	eigenvectors,
		OutputArray	result
	)

Python:
	cv.PCABackProject(	data, mean, eigenvectors[, result]	) ->	result

#include <opencv2/core.hpp>

wrap PCA::backProject

PCACompute() [1/4]

void cv::PCACompute	(	InputArray	data,
		InputOutputArray	mean,
		OutputArray	eigenvectors,
		double	retainedVariance
	)

Python:
	cv.PCACompute(	data, mean[, eigenvectors[, maxComponents]]	) ->	mean, eigenvectors
	cv.PCACompute(	data, mean, retainedVariance[, eigenvectors]	) ->	mean, eigenvectors
	cv.PCACompute2(	data, mean[, eigenvectors[, eigenvalues[, maxComponents]]]	) ->	mean, eigenvectors, eigenvalues
	cv.PCACompute2(	data, mean, retainedVariance[, eigenvectors[, eigenvalues]]	) ->	mean, eigenvectors, eigenvalues

#include <opencv2/core.hpp>

wrap PCA::operator()

PCACompute() [2/4]

void cv::PCACompute	(	InputArray	data,
		InputOutputArray	mean,
		OutputArray	eigenvectors,
		int	maxComponents = 0
	)

Python:
	cv.PCACompute(	data, mean[, eigenvectors[, maxComponents]]	) ->	mean, eigenvectors
	cv.PCACompute(	data, mean, retainedVariance[, eigenvectors]	) ->	mean, eigenvectors
	cv.PCACompute2(	data, mean[, eigenvectors[, eigenvalues[, maxComponents]]]	) ->	mean, eigenvectors, eigenvalues
	cv.PCACompute2(	data, mean, retainedVariance[, eigenvectors[, eigenvalues]]	) ->	mean, eigenvectors, eigenvalues

#include <opencv2/core.hpp>

wrap PCA::operator()

PCACompute() [3/4]

void cv::PCACompute	(	InputArray	data,
		InputOutputArray	mean,
		OutputArray	eigenvectors,
		OutputArray	eigenvalues,
		double	retainedVariance
	)

Python:
	cv.PCACompute(	data, mean[, eigenvectors[, maxComponents]]	) ->	mean, eigenvectors
	cv.PCACompute(	data, mean, retainedVariance[, eigenvectors]	) ->	mean, eigenvectors
	cv.PCACompute2(	data, mean[, eigenvectors[, eigenvalues[, maxComponents]]]	) ->	mean, eigenvectors, eigenvalues
	cv.PCACompute2(	data, mean, retainedVariance[, eigenvectors[, eigenvalues]]	) ->	mean, eigenvectors, eigenvalues

#include <opencv2/core.hpp>

wrap PCA::operator() and add eigenvalues output parameter

PCACompute() [4/4]

void cv::PCACompute	(	InputArray	data,
		InputOutputArray	mean,
		OutputArray	eigenvectors,
		OutputArray	eigenvalues,
		int	maxComponents = 0
	)

Python:
	cv.PCACompute(	data, mean[, eigenvectors[, maxComponents]]	) ->	mean, eigenvectors
	cv.PCACompute(	data, mean, retainedVariance[, eigenvectors]	) ->	mean, eigenvectors
	cv.PCACompute2(	data, mean[, eigenvectors[, eigenvalues[, maxComponents]]]	) ->	mean, eigenvectors, eigenvalues
	cv.PCACompute2(	data, mean, retainedVariance[, eigenvectors[, eigenvalues]]	) ->	mean, eigenvectors, eigenvalues

#include <opencv2/core.hpp>

wrap PCA::operator() and add eigenvalues output parameter

PCAProject()

void cv::PCAProject	(	InputArray	data,
		InputArray	mean,
		InputArray	eigenvectors,
		OutputArray	result
	)

Python:
	cv.PCAProject(	data, mean, eigenvectors[, result]	) ->	result

#include <opencv2/core.hpp>

wrap PCA::project

perspectiveTransform()

void cv::perspectiveTransform	(	InputArray	src,
		OutputArray	dst,
		InputArray	m
	)

Python:
	cv.perspectiveTransform(	src, m[, dst]	) ->	dst

#include <opencv2/core.hpp>

Performs the perspective matrix transformation of vectors.

The function cv::perspectiveTransform transforms every element of src by treating it as a 2D or 3D vector, in the following way:

\[(x, y, z) \rightarrow (x'/w, y'/w, z'/w)\]

where

\[(x', y', z', w') = \texttt{mat} \cdot \begin{bmatrix} x & y & z & 1 \end{bmatrix}\]

and

\[w = \fork{w'}{if \(w' \ne 0\)}{\infty}{otherwise}\]

Here a 3D vector transformation is shown. In case of a 2D vector transformation, the z component is omitted.

Note

The function transforms a sparse set of 2D or 3D vectors. If you want to transform an image using perspective transformation, use warpPerspective . If you have an inverse problem, that is, you want to compute the most probable perspective transformation out of several pairs of corresponding points, you can use getPerspectiveTransform or findHomography .

Parameters

src	input two-channel or three-channel floating-point array; each element is a 2D/3D vector to be transformed.
dst	output array of the same size and type as src.
m	3x3 or 4x4 floating-point transformation matrix.

See also

transform, warpPerspective, getPerspectiveTransform, findHomography

phase()

void cv::phase	(	InputArray	x,
		InputArray	y,
		OutputArray	angle,
		bool	angleInDegrees = false
	)

Python:
	cv.phase(	x, y[, angle[, angleInDegrees]]	) ->	angle

#include <opencv2/core.hpp>

Calculates the rotation angle of 2D vectors.

The function cv::phase calculates the rotation angle of each 2D vector that is formed from the corresponding elements of x and y :

\[\texttt{angle} (I) = \texttt{atan2} ( \texttt{y} (I), \texttt{x} (I))\]

The angle estimation accuracy is about 0.3 degrees. When x(I)=y(I)=0 , the corresponding angle(I) is set to 0.

Parameters

x	input floating-point array of x-coordinates of 2D vectors.
y	input array of y-coordinates of 2D vectors; it must have the same size and the same type as x.
angle	output array of vector angles; it has the same size and same type as x .
angleInDegrees	when true, the function calculates the angle in degrees, otherwise, they are measured in radians.

polarToCart()

void cv::polarToCart	(	InputArray	magnitude,
		InputArray	angle,
		OutputArray	x,
		OutputArray	y,
		bool	angleInDegrees = false
	)

Python:
	cv.polarToCart(	magnitude, angle[, x[, y[, angleInDegrees]]]	) ->	x, y

#include <opencv2/core.hpp>

Calculates x and y coordinates of 2D vectors from their magnitude and angle.

The function cv::polarToCart calculates the Cartesian coordinates of each 2D vector represented by the corresponding elements of magnitude and angle:

\[\begin{array}{l} \texttt{x} (I) = \texttt{magnitude} (I) \cos ( \texttt{angle} (I)) \\ \texttt{y} (I) = \texttt{magnitude} (I) \sin ( \texttt{angle} (I)) \\ \end{array}\]

The relative accuracy of the estimated coordinates is about 1e-6.

Parameters

magnitude	input floating-point array of magnitudes of 2D vectors; it can be an empty matrix (=Mat()), in this case, the function assumes that all the magnitudes are =1; if it is not empty, it must have the same size and type as angle.
angle	input floating-point array of angles of 2D vectors.
x	output array of x-coordinates of 2D vectors; it has the same size and type as angle.
y	output array of y-coordinates of 2D vectors; it has the same size and type as angle.
angleInDegrees	when true, the input angles are measured in degrees, otherwise, they are measured in radians.

See also

cartToPolar, magnitude, phase, exp, log, pow, sqrt

pow()

void cv::pow	(	InputArray	src,
		double	power,
		OutputArray	dst
	)

Python:
	cv.pow(	src, power[, dst]	) ->	dst

#include <opencv2/core.hpp>

Raises every array element to a power.

The function cv::pow raises every element of the input array to power :

\[\texttt{dst} (I) = \fork{\texttt{src}(I)^{power}}{if \(\texttt{power}\) is integer}{|\texttt{src}(I)|^{power}}{otherwise}\]

So, for a non-integer power exponent, the absolute values of input array elements are used. However, it is possible to get true values for negative values using some extra operations. In the example below, computing the 5th root of array src shows:

Mat mask = src < 0;
pow(src, 1./5, dst);
subtract(Scalar::all(0), dst, dst, mask);

For some values of power, such as integer values, 0.5 and -0.5, specialized faster algorithms are used.

Special values (NaN, Inf) are not handled.

Parameters

src	input array.
power	exponent of power.
dst	output array of the same size and type as src.

See also

sqrt, exp, log, cartToPolar, polarToCart

Here is the call graph for this function:

PSNR()

double cv::PSNR	(	InputArray	src1,
		InputArray	src2,
		double	R = 255.
	)

Python:
	cv.PSNR(	src1, src2[, R]	) ->	retval

#include <opencv2/core.hpp>

Computes the Peak Signal-to-Noise Ratio (PSNR) image quality metric.

This function calculates the Peak Signal-to-Noise Ratio (PSNR) image quality metric in decibels (dB), between two input arrays src1 and src2. The arrays must have the same type.

The PSNR is calculated as follows:

\[ \texttt{PSNR} = 10 \cdot \log_{10}{\left( \frac{R^2}{MSE} \right) } \]

where R is the maximum integer value of depth (e.g. 255 in the case of CV_8U data) and MSE is the mean squared error between the two arrays.

Parameters

src1	first input array.
src2	second input array of the same size as src1.
R	the maximum pixel value (255 by default)

randn()

void cv::randn	(	InputOutputArray	dst,
		InputArray	mean,
		InputArray	stddev
	)

Python:
	cv.randn(	dst, mean, stddev	) ->	dst

#include <opencv2/core.hpp>

Fills the array with normally distributed random numbers.

The function cv::randn fills the matrix dst with normally distributed random numbers with the specified mean vector and the standard deviation matrix. The generated random numbers are clipped to fit the value range of the output array data type.

Parameters

dst	output array of random numbers; the array must be pre-allocated and have 1 to 4 channels.
mean	mean value (expectation) of the generated random numbers.
stddev	standard deviation of the generated random numbers; it can be either a vector (in which case a diagonal standard deviation matrix is assumed) or a square matrix.

See also

RNG, randu

randShuffle()

void cv::randShuffle	(	InputOutputArray	dst,
		double	iterFactor = 1.,
		RNG *	rng = 0
	)

Python:
	cv.randShuffle(	dst[, iterFactor]	) ->	dst

#include <opencv2/core.hpp>

Shuffles the array elements randomly.

The function cv::randShuffle shuffles the specified 1D array by randomly choosing pairs of elements and swapping them. The number of such swap operations will be dst.rows*dst.cols*iterFactor .

Parameters

dst	input/output numerical 1D array.
iterFactor	scale factor that determines the number of random swap operations (see the details below).
rng	optional random number generator used for shuffling; if it is zero, theRNG () is used instead.

See also

RNG, sort

Examples

modules/shape/samples/shape_example.cpp.

randu()

void cv::randu	(	InputOutputArray	dst,
		InputArray	low,
		InputArray	high
	)

Python:
	cv.randu(	dst, low, high	) ->	dst

#include <opencv2/core.hpp>

Generates a single uniformly-distributed random number or an array of random numbers.

Non-template variant of the function fills the matrix dst with uniformly-distributed random numbers from the specified range:

\[\texttt{low} _c \leq \texttt{dst} (I)_c < \texttt{high} _c\]

Parameters

dst	output array of random numbers; the array must be pre-allocated.
low	inclusive lower boundary of the generated random numbers.
high	exclusive upper boundary of the generated random numbers.

See also

RNG, randn, theRNG

reduce()

void cv::reduce	(	InputArray	src,
		OutputArray	dst,
		int	dim,
		int	rtype,
		int	dtype = -1
	)

Python:
	cv.reduce(	src, dim, rtype[, dst[, dtype]]	) ->	dst

#include <opencv2/core.hpp>

Reduces a matrix to a vector.

The function reduce reduces the matrix to a vector by treating the matrix rows/columns as a set of 1D vectors and performing the specified operation on the vectors until a single row/column is obtained. For example, the function can be used to compute horizontal and vertical projections of a raster image. In case of REDUCE_MAX and REDUCE_MIN, the output image should have the same type as the source one. In case of REDUCE_SUM, REDUCE_SUM2 and REDUCE_AVG, the output may have a larger element bit-depth to preserve accuracy. And multi-channel arrays are also supported in these two reduction modes.

The following code demonstrates its usage for a single channel matrix.

        Mat m = (Mat_<uchar>(3,2) << 1,2,3,4,5,6);
        Mat col_sum, row_sum;
 
        reduce(m, col_sum, 0, REDUCE_SUM, CV_32F);
        reduce(m, row_sum, 1, REDUCE_SUM, CV_32F);
        /*
        m =
        [  1,   2;
           3,   4;
           5,   6]
        col_sum =
        [9, 12]
        row_sum =
        [3;
         7;
         11]
         */

And the following code demonstrates its usage for a two-channel matrix.

        // two channels
        char d[] = {1,2,3,4,5,6};
        Mat m(3, 1, CV_8UC2, d);
        Mat col_sum_per_channel;
        reduce(m, col_sum_per_channel, 0, REDUCE_SUM, CV_32F);
        /*
        col_sum_per_channel =
        [9, 12]
        */

Parameters

src	input 2D matrix.
dst	output vector. Its size and type is defined by dim and dtype parameters.
dim	dimension index along which the matrix is reduced. 0 means that the matrix is reduced to a single row. 1 means that the matrix is reduced to a single column.
rtype	reduction operation that could be one of ReduceTypes
dtype	when negative, the output vector will have the same type as the input matrix, otherwise, its type will be CV_MAKE_TYPE(CV_MAT_DEPTH(dtype), src.channels()).

See also

repeat, reduceArgMin, reduceArgMax

reduceArgMax()

void cv::reduceArgMax	(	InputArray	src,
		OutputArray	dst,
		int	axis,
		bool	lastIndex = false
	)

Python:
	cv.reduceArgMax(	src, axis[, dst[, lastIndex]]	) ->	dst

#include <opencv2/core.hpp>

Finds indices of max elements along provided axis.

Note

• If input or output array is not continuous, this function will create an internal copy.
• NaN handling is left unspecified, see patchNaNs().
• The returned index is always in bounds of input matrix.

Parameters

src	input single-channel array.
dst	output array of type CV_32SC1 with the same dimensionality as src, except for axis being reduced - it should be set to 1.
lastIndex	whether to get the index of first or last occurrence of max.
axis	axis to reduce along.

See also

reduceArgMin, minMaxLoc, min, max, compare, reduce

reduceArgMin()

void cv::reduceArgMin	(	InputArray	src,
		OutputArray	dst,
		int	axis,
		bool	lastIndex = false
	)

Python:
	cv.reduceArgMin(	src, axis[, dst[, lastIndex]]	) ->	dst

#include <opencv2/core.hpp>

Finds indices of min elements along provided axis.

Note

• If input or output array is not continuous, this function will create an internal copy.
• NaN handling is left unspecified, see patchNaNs().
• The returned index is always in bounds of input matrix.

Parameters

src	input single-channel array.
dst	output array of type CV_32SC1 with the same dimensionality as src, except for axis being reduced - it should be set to 1.
lastIndex	whether to get the index of first or last occurrence of min.
axis	axis to reduce along.

See also

reduceArgMax, minMaxLoc, min, max, compare, reduce

repeat() [1/2]

Mat cv::repeat	(	const Mat &	src,
		int	ny,
		int	nx
	)

Python:
	cv.repeat(	src, ny, nx[, dst]	) ->	dst

#include <opencv2/core.hpp>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Parameters

src	input array to replicate.
ny	Flag to specify how many times the src is repeated along the vertical axis.
nx	Flag to specify how many times the src is repeated along the horizontal axis.

repeat() [2/2]

void cv::repeat	(	InputArray	src,
		int	ny,
		int	nx,
		OutputArray	dst
	)

Python:
	cv.repeat(	src, ny, nx[, dst]	) ->	dst

#include <opencv2/core.hpp>

Fills the output array with repeated copies of the input array.

The function cv::repeat duplicates the input array one or more times along each of the two axes:

\[\texttt{dst} _{ij}= \texttt{src} _{i\mod src.rows, \; j\mod src.cols }\]

The second variant of the function is more convenient to use with MatrixExpressions.

Parameters

src	input array to replicate.
ny	Flag to specify how many times the src is repeated along the vertical axis.
nx	Flag to specify how many times the src is repeated along the horizontal axis.
dst	output array of the same type as src.

See also

cv::reduce

rotate()

void cv::rotate	(	InputArray	src,
		OutputArray	dst,
		int	rotateCode
	)

Python:
	cv.rotate(	src, rotateCode[, dst]	) ->	dst

#include <opencv2/core.hpp>

Rotates a 2D array in multiples of 90 degrees. The function cv::rotate rotates the array in one of three different ways: Rotate by 90 degrees clockwise (rotateCode = ROTATE_90_CLOCKWISE). Rotate by 180 degrees clockwise (rotateCode = ROTATE_180). Rotate by 270 degrees clockwise (rotateCode = ROTATE_90_COUNTERCLOCKWISE).

Parameters

src	input array.
dst	output array of the same type as src. The size is the same with ROTATE_180, and the rows and cols are switched for ROTATE_90_CLOCKWISE and ROTATE_90_COUNTERCLOCKWISE.
rotateCode	an enum to specify how to rotate the array; see the enum RotateFlags

See also

transpose, repeat, completeSymm, flip, RotateFlags

scaleAdd()

void cv::scaleAdd	(	InputArray	src1,
		double	alpha,
		InputArray	src2,
		OutputArray	dst
	)

Python:
	cv.scaleAdd(	src1, alpha, src2[, dst]	) ->	dst

#include <opencv2/core.hpp>

Calculates the sum of a scaled array and another array.

The function scaleAdd is one of the classical primitive linear algebra operations, known as DAXPY or SAXPY in BLAS. It calculates the sum of a scaled array and another array:

\[\texttt{dst} (I)= \texttt{scale} \cdot \texttt{src1} (I) + \texttt{src2} (I)\]

The function can also be emulated with a matrix expression, for example:

Mat A(3, 3, CV_64F);
...
A.row(0) = A.row(1)*2 + A.row(2);

Parameters

src1	first input array.
alpha	scale factor for the first array.
src2	second input array of the same size and type as src1.
dst	output array of the same size and type as src1.

See also

add, addWeighted, subtract, Mat::dot, Mat::convertTo

setIdentity()

void cv::setIdentity	(	InputOutputArray	mtx,
		const Scalar &	s = Scalar(1)
	)

Python:
	cv.setIdentity(	mtx[, s]	) ->	mtx

#include <opencv2/core.hpp>

Initializes a scaled identity matrix.

The function cv::setIdentity initializes a scaled identity matrix:

\[\texttt{mtx} (i,j)= \fork{\texttt{value}}{ if \(i=j\)}{0}{otherwise}\]

The function can also be emulated using the matrix initializers and the matrix expressions:

Mat A = Mat::eye(4, 3, CV_32F)*5;
// A will be set to [[5, 0, 0], [0, 5, 0], [0, 0, 5], [0, 0, 0]]

Parameters

mtx	matrix to initialize (not necessarily square).
s	value to assign to diagonal elements.

See also

Mat::zeros, Mat::ones, Mat::setTo, Mat::operator=

setRNGSeed()

void cv::setRNGSeed

(

int

seed

)

Python:
	cv.setRNGSeed(	seed	) ->	None

#include <opencv2/core.hpp>

Sets state of default random number generator.

The function cv::setRNGSeed sets state of default random number generator to custom value.

Parameters

seed	new state for default random number generator

See also

RNG, randu, randn

solve()

bool cv::solve	(	InputArray	src1,
		InputArray	src2,
		OutputArray	dst,
		int	flags = DECOMP_LU
	)

Python:
	cv.solve(	src1, src2[, dst[, flags]]	) ->	retval, dst

#include <opencv2/core.hpp>

Solves one or more linear systems or least-squares problems.

The function cv::solve solves a linear system or least-squares problem (the latter is possible with SVD or QR methods, or by specifying the flag DECOMP_NORMAL ):

\[\texttt{dst} = \arg \min _X \| \texttt{src1} \cdot \texttt{X} - \texttt{src2} \|\]

If DECOMP_LU or DECOMP_CHOLESKY method is used, the function returns 1 if src1 (or \(\texttt{src1}^T\texttt{src1}\) ) is non-singular. Otherwise, it returns 0. In the latter case, dst is not valid. Other methods find a pseudo-solution in case of a singular left-hand side part.

Note

If you want to find a unity-norm solution of an under-defined singular system \(\texttt{src1}\cdot\texttt{dst}=0\) , the function solve will not do the work. Use SVD::solveZ instead.

Parameters

src1	input matrix on the left-hand side of the system.
src2	input matrix on the right-hand side of the system.
dst	output solution.
flags	solution (matrix inversion) method (DecompTypes)

See also

invert, SVD, eigen

solveCubic()

int cv::solveCubic	(	InputArray	coeffs,
		OutputArray	roots
	)

Python:
	cv.solveCubic(	coeffs[, roots]	) ->	retval, roots

#include <opencv2/core.hpp>

Finds the real roots of a cubic equation.

The function solveCubic finds the real roots of a cubic equation:

• if coeffs is a 4-element vector:

  \[\texttt{coeffs} [0] x^3 + \texttt{coeffs} [1] x^2 + \texttt{coeffs} [2] x + \texttt{coeffs} [3] = 0\]

• if coeffs is a 3-element vector:

  \[x^3 + \texttt{coeffs} [0] x^2 + \texttt{coeffs} [1] x + \texttt{coeffs} [2] = 0\]

The roots are stored in the roots array.

Parameters

coeffs	equation coefficients, an array of 3 or 4 elements.
roots	output array of real roots that has 1 or 3 elements.

Returns

number of real roots. It can be 0, 1 or 2.

solvePoly()

double cv::solvePoly	(	InputArray	coeffs,
		OutputArray	roots,
		int	maxIters = 300
	)

Python:
	cv.solvePoly(	coeffs[, roots[, maxIters]]	) ->	retval, roots

#include <opencv2/core.hpp>

Finds the real or complex roots of a polynomial equation.

The function cv::solvePoly finds real and complex roots of a polynomial equation:

\[\texttt{coeffs} [n] x^{n} + \texttt{coeffs} [n-1] x^{n-1} + ... + \texttt{coeffs} [1] x + \texttt{coeffs} [0] = 0\]

Parameters

coeffs	array of polynomial coefficients.
roots	output (complex) array of roots.
maxIters	maximum number of iterations the algorithm does.

sort()

void cv::sort	(	InputArray	src,
		OutputArray	dst,
		int	flags
	)

Python:
	cv.sort(	src, flags[, dst]	) ->	dst

#include <opencv2/core.hpp>

Sorts each row or each column of a matrix.

The function cv::sort sorts each matrix row or each matrix column in ascending or descending order. So you should pass two operation flags to get desired behaviour. If you want to sort matrix rows or columns lexicographically, you can use STL std::sort generic function with the proper comparison predicate.

Parameters

src	input single-channel array.
dst	output array of the same size and type as src.
flags	operation flags, a combination of SortFlags

See also

sortIdx, randShuffle

sortIdx()

void cv::sortIdx	(	InputArray	src,
		OutputArray	dst,
		int	flags
	)

Python:
	cv.sortIdx(	src, flags[, dst]	) ->	dst

#include <opencv2/core.hpp>

Sorts each row or each column of a matrix.

The function cv::sortIdx sorts each matrix row or each matrix column in the ascending or descending order. So you should pass two operation flags to get desired behaviour. Instead of reordering the elements themselves, it stores the indices of sorted elements in the output array. For example:

Mat A = Mat::eye(3,3,CV_32F), B;
sortIdx(A, B, SORT_EVERY_ROW + SORT_ASCENDING);
// B will probably contain
// (because of equal elements in A some permutations are possible):
// [[1, 2, 0], [0, 2, 1], [0, 1, 2]]

Parameters

src	input single-channel array.
dst	output integer array of the same size as src.
flags	operation flags that could be a combination of cv::SortFlags

See also

sort, randShuffle

split() [1/2]

void cv::split	(	const Mat &	src,
		Mat *	mvbegin
	)

Python:
	cv.split(	m[, mv]	) ->	mv

#include <opencv2/core.hpp>

Divides a multi-channel array into several single-channel arrays.

The function cv::split splits a multi-channel array into separate single-channel arrays:

\[\texttt{mv} [c](I) = \texttt{src} (I)_c\]

If you need to extract a single channel or do some other sophisticated channel permutation, use mixChannels.

The following example demonstrates how to split a 3-channel matrix into 3 single channel matrices.

    char d[] = {1,2,3,4,5,6,7,8,9,10,11,12};
    Mat m(2, 2, CV_8UC3, d);
    Mat channels[3];
    split(m, channels);
 
    /*
    channels[0] =
    [  1,   4;
       7,  10]
    channels[1] =
    [  2,   5;
       8,  11]
    channels[2] =
    [  3,   6;
       9,  12]
    */

Parameters

src	input multi-channel array.
mvbegin	output array; the number of arrays must match src.channels(); the arrays themselves are reallocated, if needed.

See also

merge, mixChannels, cvtColor

split() [2/2]

void cv::split	(	InputArray	m,
		OutputArrayOfArrays	mv
	)

Python:
	cv.split(	m[, mv]	) ->	mv

#include <opencv2/core.hpp>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Parameters

m	input multi-channel array.
mv	output vector of arrays; the arrays themselves are reallocated, if needed.

sqrt()

void cv::sqrt	(	InputArray	src,
		OutputArray	dst
	)

Python:
	cv.sqrt(	src[, dst]	) ->	dst

#include <opencv2/core.hpp>

Calculates a square root of array elements.

The function cv::sqrt calculates a square root of each input array element. In case of multi-channel arrays, each channel is processed independently. The accuracy is approximately the same as of the built-in std::sqrt .

Parameters

src	input floating-point array.
dst	output array of the same size and type as src.

Here is the call graph for this function:

subtract()

void cv::subtract	(	InputArray	src1,
		InputArray	src2,
		OutputArray	dst,
		InputArray	mask = noArray(),
		int	dtype = -1
	)

Python:
	cv.subtract(	src1, src2[, dst[, mask[, dtype]]]	) ->	dst

#include <opencv2/core.hpp>

Calculates the per-element difference between two arrays or array and a scalar.

The function subtract calculates:

• Difference between two arrays, when both input arrays have the same size and the same number of channels:

  \[\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) - \texttt{src2}(I)) \quad \texttt{if mask}(I) \ne0\]

• Difference between an array and a scalar, when src2 is constructed from Scalar or has the same number of elements as src1.channels():

  \[\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) - \texttt{src2} ) \quad \texttt{if mask}(I) \ne0\]

• Difference between a scalar and an array, when src1 is constructed from Scalar or has the same number of elements as src2.channels():

  \[\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1} - \texttt{src2}(I) ) \quad \texttt{if mask}(I) \ne0\]

• The reverse difference between a scalar and an array in the case of SubRS:

  \[\texttt{dst}(I) = \texttt{saturate} ( \texttt{src2} - \texttt{src1}(I) ) \quad \texttt{if mask}(I) \ne0\]

  where I is a multi-dimensional index of array elements. In case of multi-channel arrays, each channel is processed independently.

The first function in the list above can be replaced with matrix expressions:

dst = src1 - src2;
dst -= src1; // equivalent to subtract(dst, src1, dst);

The input arrays and the output array can all have the same or different depths. For example, you can subtract to 8-bit unsigned arrays and store the difference in a 16-bit signed array. Depth of the output array is determined by dtype parameter. In the second and third cases above, as well as in the first case, when src1.depth() == src2.depth(), dtype can be set to the default -1. In this case the output array will have the same depth as the input array, be it src1, src2 or both.

Note

Saturation is not applied when the output array has the depth CV_32S. You may even get result of an incorrect sign in the case of overflow.

(Python) Be careful to difference behaviour between src1/src2 are single number and they are tuple/array. subtract(src,X) means subtract(src,(X,X,X,X)). subtract(src,(X,)) means subtract(src,(X,0,0,0)).

Parameters

src1	first input array or a scalar.
src2	second input array or a scalar.
dst	output array of the same size and the same number of channels as the input array.
mask	optional operation mask; this is CV_8U, CV8S or CV_Bool single channel array that specifies elements of the output array to be changed.
dtype	optional depth of the output array

See also

add, addWeighted, scaleAdd, Mat::convertTo

sum()

Scalar cv::sum

(

InputArray

src

)

Python:
	cv.sumElems(	src	) ->	retval

#include <opencv2/core.hpp>

Calculates the sum of array elements.

The function cv::sum calculates and returns the sum of array elements, independently for each channel.

Parameters

src	input array that must have from 1 to 4 channels.

See also

countNonZero, mean, meanStdDev, norm, minMaxLoc, reduce

SVBackSubst()

void cv::SVBackSubst	(	InputArray	w,
		InputArray	u,
		InputArray	vt,
		InputArray	rhs,
		OutputArray	dst
	)

Python:
	cv.SVBackSubst(	w, u, vt, rhs[, dst]	) ->	dst

#include <opencv2/core.hpp>

wrap SVD::backSubst

SVDecomp()

void cv::SVDecomp	(	InputArray	src,
		OutputArray	w,
		OutputArray	u,
		OutputArray	vt,
		int	flags = 0
	)

Python:
	cv.SVDecomp(	src[, w[, u[, vt[, flags]]]]	) ->	w, u, vt

#include <opencv2/core.hpp>

wrap SVD::compute

swap() [1/2]

void cv::swap	(	Mat &	a,
		Mat &	b
	)

#include <opencv2/core.hpp>

Swaps two matrices.

Here is the call graph for this function:

swap() [2/2]

void cv::swap	(	UMat &	a,
		UMat &	b
	)

#include <opencv2/core.hpp>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Here is the call graph for this function:

theRNG()

RNG & cv::theRNG

(

)

#include <opencv2/core.hpp>

Returns the default random number generator.

The function cv::theRNG returns the default random number generator. For each thread, there is a separate random number generator, so you can use the function safely in multi-thread environments. If you just need to get a single random number using this generator or initialize an array, you can use randu or randn instead. But if you are going to generate many random numbers inside a loop, it is much faster to use this function to retrieve the generator and then use RNG::operator _Tp() .

See also

RNG, randu, randn

trace()

Scalar cv::trace

(

InputArray

mtx

)

Python:
	cv.trace(	mtx	) ->	retval

#include <opencv2/core.hpp>

Returns the trace of a matrix.

The function cv::trace returns the sum of the diagonal elements of the matrix mtx .

\[\mathrm{tr} ( \texttt{mtx} ) = \sum _i \texttt{mtx} (i,i)\]

Parameters

mtx	input matrix.

transform()

void cv::transform	(	InputArray	src,
		OutputArray	dst,
		InputArray	m
	)

Python:
	cv.transform(	src, m[, dst]	) ->	dst

#include <opencv2/core.hpp>

Performs the matrix transformation of every array element.

The function cv::transform performs the matrix transformation of every element of the array src and stores the results in dst :

\[\texttt{dst} (I) = \texttt{m} \cdot \texttt{src} (I)\]

(when m.cols=src.channels() ), or

\[\texttt{dst} (I) = \texttt{m} \cdot [ \texttt{src} (I); 1]\]

(when m.cols=src.channels()+1 )

Every element of the N -channel array src is interpreted as N -element vector that is transformed using the M x N or M x (N+1) matrix m to M-element vector - the corresponding element of the output array dst .

The function may be used for geometrical transformation of N -dimensional points, arbitrary linear color space transformation (such as various kinds of RGB to YUV transforms), shuffling the image channels, and so forth.

Parameters

src	input array that must have as many channels (1 to 4) as m.cols or m.cols-1.
dst	output array of the same size and depth as src; it has as many channels as m.rows.
m	transformation 2x2 or 2x3 floating-point matrix.

See also

perspectiveTransform, getAffineTransform, estimateAffine2D, warpAffine, warpPerspective

transpose()

void cv::transpose	(	InputArray	src,
		OutputArray	dst
	)

Python:
	cv.transpose(	src[, dst]	) ->	dst

#include <opencv2/core.hpp>

Transposes a matrix.

The function cv::transpose transposes the matrix src :

\[\texttt{dst} (i,j) = \texttt{src} (j,i)\]

Note

No complex conjugation is done in case of a complex matrix. It should be done separately if needed.

Parameters

src	input array.
dst	output array of the same type as src.

transposeND()

void cv::transposeND	(	InputArray	src,
		const std::vector< int > &	order,
		OutputArray	dst
	)

Python:
	cv.transposeND(	src, order[, dst]	) ->	dst

#include <opencv2/core.hpp>

Transpose for n-dimensional matrices.

Note

Input should be continuous single-channel matrix.

Parameters

src	input array.
order	a permutation of [0,1,..,N-1] where N is the number of axes of src. The i'th axis of dst will correspond to the axis numbered order[i] of the input.
dst	output array of the same type as src.

vconcat() [1/3]

void cv::vconcat	(	const Mat *	src,
		size_t	nsrc,
		OutputArray	dst
	)

Python:
	cv.vconcat(	src[, dst]	) ->	dst

#include <opencv2/core.hpp>

Applies vertical concatenation to given matrices.

The function vertically concatenates two or more cv::Mat matrices (with the same number of cols).

cv::Mat matArray[] = { cv::Mat(1, 4, CV_8UC1, cv::Scalar(1)),
                       cv::Mat(1, 4, CV_8UC1, cv::Scalar(2)),
                       cv::Mat(1, 4, CV_8UC1, cv::Scalar(3)),};
 
cv::Mat out;
cv::vconcat( matArray, 3, out );
//out:
//[1,   1,   1,   1;
// 2,   2,   2,   2;
// 3,   3,   3,   3]

Parameters

src	input array or vector of matrices. all of the matrices must have the same number of cols and the same depth.
nsrc	number of matrices in src.
dst	output array. It has the same number of cols and depth as the src, and the sum of rows of the src.

See also

cv::hconcat(const Mat*, size_t, OutputArray),

cv::hconcat(InputArrayOfArrays, OutputArray) and

cv::hconcat(InputArray, InputArray, OutputArray)

vconcat() [2/3]

void cv::vconcat	(	InputArray	src1,
		InputArray	src2,
		OutputArray	dst
	)

Python:
	cv.vconcat(	src[, dst]	) ->	dst

#include <opencv2/core.hpp>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

cv::Mat_<float> A = (cv::Mat_<float>(3, 2) << 1, 7,
                                              2, 8,
                                              3, 9);
cv::Mat_<float> B = (cv::Mat_<float>(3, 2) << 4, 10,
                                              5, 11,
                                              6, 12);
 
cv::Mat C;
cv::vconcat(A, B, C);
//C:
//[1, 7;
// 2, 8;
// 3, 9;
// 4, 10;
// 5, 11;
// 6, 12]

Parameters

src1	first input array to be considered for vertical concatenation.
src2	second input array to be considered for vertical concatenation.
dst	output array. It has the same number of cols and depth as the src1 and src2, and the sum of rows of the src1 and src2.

vconcat() [3/3]

void cv::vconcat	(	InputArrayOfArrays	src,
		OutputArray	dst
	)

Python:
	cv.vconcat(	src[, dst]	) ->	dst

#include <opencv2/core.hpp>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

std::vector<cv::Mat> matrices = { cv::Mat(1, 4, CV_8UC1, cv::Scalar(1)),
                                  cv::Mat(1, 4, CV_8UC1, cv::Scalar(2)),
                                  cv::Mat(1, 4, CV_8UC1, cv::Scalar(3)),};
 
cv::Mat out;
cv::vconcat( matrices, out );
//out:
//[1,   1,   1,   1;
// 2,   2,   2,   2;
// 3,   3,   3,   3]

Parameters

src	input array or vector of matrices. all of the matrices must have the same number of cols and the same depth
dst	output array. It has the same number of cols and depth as the src, and the sum of rows of the src. same depth.