Operations on arrays#

Detailed Description#

Classes#

Name	Description
`class` `cv::LDA`	Linear Discriminant Analysis. View details
`class` `cv::PCA`	Principal Component Analysis. View details
`class` `cv::RNG`	Random Number Generator. View details
`class` `cv::RNG_MT19937`	Mersenne Twister random number generator. View details
`class` `cv::SVD`	Singular Value Decomposition. View details

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
}

View details

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 View details

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. View details

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 View details

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
}

View details

enum cv::GemmFlags {
    cv::GEMM_1_T = 1,
    cv::GEMM_2_T = 2,
    cv::GEMM_3_T = 4
}

generalized matrix multiplication flags View details

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
}

View details

enum cv::ReduceTypes {
    cv::REDUCE_SUM = 0,
    cv::REDUCE_AVG = 1,
    cv::REDUCE_MAX = 2,
    cv::REDUCE_MIN = 3,
    cv::REDUCE_SUM2 = 4
}

View details

enum cv::RotateFlags {
    cv::ROTATE_90_CLOCKWISE = 0,
    cv::ROTATE_180 = 1,
    cv::ROTATE_90_COUNTERCLOCKWISE = 2
}

View details

Enumeration Type Documentation#

BorderTypes#

enum cv::BorderTypes

#include <opencv2/core/base.hpp>

Various border types, image boundaries are denoted with the | character in the table below, when describing each method.

The following examples show the result of the copyMakeBorder call according to different methods. Input image is 6x4 (width x height) size and the copyMakeBorder function is used with a border size of 2 pixels in each direction, giving a resulting image of 10x8 resolution.

Input image:
[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]
 [12 13 14 15 16 17]
 [18 19 20 21 22 23]]

Border type: BORDER_CONSTANT (a constant value of 255 is used)
[[255 255 255 255 255 255 255 255 255 255]
 [255 255 255 255 255 255 255 255 255 255]
 [255 255   0   1   2   3   4   5 255 255]
 [255 255   6   7   8   9  10  11 255 255]
 [255 255  12  13  14  15  16  17 255 255]
 [255 255  18  19  20  21  22  23 255 255]
 [255 255 255 255 255 255 255 255 255 255]
 [255 255 255 255 255 255 255 255 255 255]]

Border type: BORDER_REPLICATE
[[ 0  0  0  1  2  3  4  5  5  5]
 [ 0  0  0  1  2  3  4  5  5  5]
 [ 0  0  0  1  2  3  4  5  5  5]
 [ 6  6  6  7  8  9 10 11 11 11]
 [12 12 12 13 14 15 16 17 17 17]
 [18 18 18 19 20 21 22 23 23 23]
 [18 18 18 19 20 21 22 23 23 23]
 [18 18 18 19 20 21 22 23 23 23]]

Border type: BORDER_REFLECT
[[ 7  6  6  7  8  9 10 11 11 10]
 [ 1  0  0  1  2  3  4  5  5  4]
 [ 1  0  0  1  2  3  4  5  5  4]
 [ 7  6  6  7  8  9 10 11 11 10]
 [13 12 12 13 14 15 16 17 17 16]
 [19 18 18 19 20 21 22 23 23 22]
 [19 18 18 19 20 21 22 23 23 22]
 [13 12 12 13 14 15 16 17 17 16]]

Border type: BORDER_WRAP
[[16 17 12 13 14 15 16 17 12 13]
 [22 23 18 19 20 21 22 23 18 19]
 [ 4  5  0  1  2  3  4  5  0  1]
 [10 11  6  7  8  9 10 11  6  7]
 [16 17 12 13 14 15 16 17 12 13]
 [22 23 18 19 20 21 22 23 18 19]
 [ 4  5  0  1  2  3  4  5  0  1]
 [10 11  6  7  8  9 10 11  6  7]]

Border type: BORDER_REFLECT_101
[[14 13 12 13 14 15 16 17 16 15]
 [ 8  7  6  7  8  9 10 11 10  9]
 [ 2  1  0  1  2  3  4  5  4  3]
 [ 8  7  6  7  8  9 10 11 10  9]
 [14 13 12 13 14 15 16 17 16 15]
 [20 19 18 19 20 21 22 23 22 21]
 [14 13 12 13 14 15 16 17 16 15]
 [ 8  7  6  7  8  9 10 11 10  9]]

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.

`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.

`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}\)

`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.

`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

`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

`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.

`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.

Operations on arrays#

Detailed Description#

Classes#

Enumerations#

Enumeration Type Documentation#

BorderTypes#

CmpTypes#

CovarFlags#

DecompTypes#

DftFlags#

GemmFlags#

NormTypes#

ReduceTypes#

RotateFlags#

Function Documentation#

absdiff()#

add()#

addWeighted()#

batchDistance()#

bitwise_and()#

bitwise_not()#

bitwise_or()#

bitwise_xor()#

borderInterpolate()#

broadcast() [1/2]#

broadcast() [2/2]#

calcCovarMatrix() [1/2]#

calcCovarMatrix() [2/2]#

cartToPolar()#

checkRange()#

compare()#

completeSymm()#

convertScaleAbs()#

copyMakeBorder()#

copyTo()#

countNonZero()#

dct()#

determinant()#

dft()#

divide() [1/2]#

divide() [2/2]#

divSpectrums()#

eigen()#

eigenNonSymmetric()#

exp()#

extractChannel()#

findNonZero()#

finiteMask()#

flip()#

flipND()#

gemm()#

getOptimalDFTSize()#

hasNonZero()#

hconcat() [1/3]#

hconcat() [2/3]#

hconcat() [3/3]#

idct()#

idft()#

inRange()#

insertChannel()#

invert()#

log()#

LUT()#

magnitude()#

Mahalanobis()#

max() [1/3]#

max() [2/3]#

max() [3/3]#

mean()#

meanStdDev()#

merge() [1/2]#

merge() [2/2]#

min() [1/3]#

min() [2/3]#

min() [3/3]#

minMaxIdx()#

minMaxLoc() [1/2]#

minMaxLoc() [2/2]#

mixChannels() [1/3]#

mixChannels() [2/3]#