数组操作

详细描述

类
类	cv::LDA
	线性判别分析。更多...
类	cv::PCA
	主成分分析。更多...
类	cv::RNG
	随机数生成器。更多...
类	cv::RNG_MT19937
	Mersenne Twister 随机数生成器。更多...
类	cv::SVD
	奇异值分解。更多...

枚举
枚举	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 }
枚举	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 }
	比较类型 更多...
枚举	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 }
	协方差标志。更多...
枚举	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 }
	矩阵分解类型 更多...
枚举	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 }
枚举	cv::GemmFlags {   cv::GEMM_1_T = 1 ,   cv::GEMM_2_T = 2 ,   cv::GEMM_3_T = 4 }
	广义矩阵乘法标志 更多...
枚举	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 }
枚举	cv::ReduceTypes {   cv::REDUCE_SUM = 0 ,   cv::REDUCE_AVG = 1 ,   cv::REDUCE_MAX = 2 ,   cv::REDUCE_MIN = 3 ,   cv::REDUCE_SUM2 = 4 }
枚举	cv::RotateFlags {   cv::ROTATE_90_CLOCKWISE = 0 ,   cv::ROTATE_180 = 1 ,   cv::ROTATE_90_COUNTERCLOCKWISE = 2 }

函数
void	cv::absdiff (InputArray src1, InputArray src2, OutputArray dst)
	计算两个数组之间或数组与标量之间的逐元素绝对差。
void	cv::add (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray(), int dtype=-1)
	计算两个数组或数组与标量之间的逐元素和。
void	cv::addWeighted (InputArray src1, double alpha, InputArray src2, double beta, double gamma, OutputArray dst, int dtype=-1)
	计算两个数组的加权和。
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)
	朴素最近邻查找器
void	cv::bitwise_and (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray())
	计算两个数组的逐位合取 (dst = src1 & src2) 计算两个数组或数组与标量的逐元素位合取。
void	cv::bitwise_not (InputArray src, OutputArray dst, InputArray mask=noArray())
	反转数组的每个位。
void	cv::bitwise_or (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray())
	计算两个数组或数组与标量的逐元素位析取。
void	cv::bitwise_xor (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray())
	计算两个数组或数组与标量的逐元素位“异或”操作。
int	cv::borderInterpolate (int p, int len, int borderType)
	计算外推像素的源位置。
void	cv::broadcast (InputArray src, InputArray shape, OutputArray dst)
	将给定的 Mat 广播到给定的形状。
void	cv::calcCovarMatrix (const Mat *samples, int nsamples, Mat &covar, Mat &mean, int flags, int ctype=6)
	计算一组向量的协方差矩阵。
void	cv::calcCovarMatrix (InputArray samples, OutputArray covar, InputOutputArray mean, int flags, int ctype=6)
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)
	执行两个数组或数组与标量值的逐元素比较。
void	cv::completeSymm (InputOutputArray m, bool lowerToUpper=false)
	将方阵的下半部分或上半部分复制到另一半。
void	cv::convertFp16 (InputArray src, OutputArray dst)
	Converts an array to half precision floating number.
void	cv::convertScaleAbs (InputArray src, OutputArray dst, double alpha=1, double beta=0)
	缩放、计算绝对值并将结果转换为 8 位。
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)
	这是一个为方便起见提供的重载成员函数 (Python) 将矩阵复制到另一个矩阵。当指定操作掩码时，如果上面所示的 Mat::create 调用重新分配了矩阵，则在新分配的矩阵在复制数据之前将用全零初始化。
int	cv::countNonZero (InputArray src)
	Counts non-zero array elements.
void	cv::dct (InputArray src, OutputArray dst, int flags=0)
	执行一维或二维数组的正向或逆向离散余弦变换。
double	cv::determinant (InputArray mtx)
	返回方阵的浮点行列式。
void	cv::dft (InputArray src, OutputArray dst, int flags=0, int nonzeroRows=0)
	执行一维或二维浮点数组的正向或逆向离散傅里叶变换。
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)
	执行两个数组或标量除以数组的逐元素除法。
bool	cv::eigen (InputArray src, OutputArray eigenvalues, OutputArray eigenvectors=noArray())
	计算对称矩阵的特征值和特征向量。
void	cv::eigenNonSymmetric (InputArray src, OutputArray eigenvalues, OutputArray eigenvectors)
	计算非对称矩阵的特征值和特征向量（仅实特征值）。
void	cv::exp (InputArray src, OutputArray dst)
	计算每个数组元素的指数。
void	cv::extractChannel (InputArray src, OutputArray dst, int coi)
	从 src 中提取单个通道（coi 是基于 0 的索引）
void	cv::findNonZero (InputArray src, OutputArray idx)
	返回非零像素的位置列表。
void	cv::flip (InputArray src, OutputArray dst, int flipCode)
	沿垂直、水平或两个轴翻转 2D 数组。
void	cv::flipND (InputArray src, OutputArray dst, int axis)
	沿给定轴翻转 N 维数组。
void	cv::gemm (InputArray src1, InputArray src2, double alpha, InputArray src3, double beta, OutputArray dst, int flags=0)
	执行广义矩阵乘法。
int	cv::getOptimalDFTSize (int vecsize)
	返回给定向量大小的最佳 DFT 大小。
bool	cv::hasNonZero (InputArray src)
	检查是否存在至少一个非零数组元素。
void	cv::hconcat (const Mat *src, size_t nsrc, OutputArray dst)
	对给定矩阵进行水平连接。
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)
	计算一维或二维数组的逆离散余弦变换。
void	cv::idft (InputArray src, OutputArray dst, int flags=0, int nonzeroRows=0)
	计算一维或二维数组的逆离散傅里叶变换。
void	cv::inRange (InputArray src, InputArray lowerb, InputArray upperb, OutputArray dst)
	检查数组元素是否位于另外两个数组的元素之间。
void	cv::insertChannel (InputArray src, InputOutputArray dst, int coi)
	将单个通道插入 dst（coi 是基于 0 的索引）
double	cv::invert (InputArray src, OutputArray dst, int flags=DECOMP_LU)
	查找矩阵的逆或伪逆。
void	cv::log (InputArray src, OutputArray dst)
	计算每个数组元素的自然对数。
void	cv::LUT (InputArray src, InputArray lut, OutputArray dst)
	对数组执行查找表变换。
void	cv::magnitude (InputArray x, InputArray y, OutputArray magnitude)
	计算二维向量的幅度。
double	cv::Mahalanobis (InputArray v1, InputArray v2, InputArray icovar)
	计算两个向量之间的马哈拉诺比斯距离。
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)
	计算两个数组或数组与标量的逐元素最大值。
Scalar	cv::mean (InputArray src, InputArray mask=noArray())
	计算数组元素的平均值（均值）。
void	cv::meanStdDev (InputArray src, OutputArray mean, OutputArray stddev, InputArray mask=noArray())
void	cv::merge (const Mat *mv, size_t count, OutputArray dst)
	将多个单通道数组合并为一个多通道数组。
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)
	计算两个数组或数组与标量的逐元素最小值。
void	cv::minMaxIdx (InputArray src, double *minVal, double *maxVal=0, int *minIdx=0, int *maxIdx=0, InputArray mask=noArray())
	查找数组中的全局最小值和最大值。
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())
	查找数组中的全局最小值和最大值。
void	cv::mixChannels (const Mat *src, size_t nsrcs, Mat *dst, size_t ndsts, const int *fromTo, size_t npairs)
	将指定通道从输入数组复制到输出数组的指定通道。
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)
	执行两个傅里叶频谱的逐元素乘法。
void	cv::multiply (InputArray src1, InputArray src2, OutputArray dst, double scale=1, int dtype=-1)
	计算两个数组的逐元素缩放积。
void	cv::mulTransposed (InputArray src, OutputArray dst, bool aTa, InputArray delta=noArray(), double scale=1, int dtype=-1)
	计算矩阵及其转置的乘积。
double	cv::norm (const SparseMat &src, int normType)
double	cv::norm (InputArray src1, InputArray src2, int normType=NORM_L2, InputArray mask=noArray())
	计算绝对差范数或相对差范数。
double	cv::norm (InputArray src1, int normType=NORM_L2, InputArray mask=noArray())
	计算数组的绝对范数。
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())
	对数组的范数或值范围进行归一化。
void	cv::patchNaNs (InputOutputArray a, double val=0)
	将 NaN 替换为给定数字。
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)
	执行向量的透视矩阵变换。
void	cv::phase (InputArray x, InputArray y, OutputArray angle, bool angleInDegrees=false)
	计算二维向量的旋转角度。
void	cv::polarToCart (InputArray magnitude, InputArray angle, OutputArray x, OutputArray y, bool angleInDegrees=false)
	根据二维向量的幅度和角度计算其 x 和 y 坐标。
void	cv::pow (InputArray src, double power, OutputArray dst)
	将每个数组元素提升到指定幂。
double	cv::PSNR (InputArray src1, InputArray src2, double R=255.)
	计算峰值信噪比（PSNR）图像质量指标。
void	cv::randn (InputOutputArray dst, InputArray mean, InputArray stddev)
	用正态分布的随机数填充数组。
void	cv::randShuffle (InputOutputArray dst, double iterFactor=1., RNG *rng=0)
	随机打乱数组元素。
void	cv::randu (InputOutputArray dst, InputArray low, InputArray high)
	生成单个均匀分布的随机数或随机数数组。
void	cv::reduce (InputArray src, OutputArray dst, int dim, int rtype, int dtype=-1)
	将矩阵降维为向量。
void	cv::reduceArgMax (InputArray src, OutputArray dst, int axis, bool lastIndex=false)
	沿给定轴查找最大元素的索引。
void	cv::reduceArgMin (InputArray src, OutputArray dst, int axis, bool lastIndex=false)
	沿给定轴查找最小元素的索引。
Mat	cv::repeat (const Mat &src, int ny, int nx)
void	cv::repeat (InputArray src, int ny, int nx, OutputArray dst)
	用输入数组的重复副本填充输出数组。
void	cv::rotate (InputArray src, OutputArray dst, int rotateCode)
	将二维数组旋转 90 度的倍数。函数 cv::rotate 以三种不同方式之一旋转数组：顺时针旋转 90 度 (rotateCode = ROTATE_90_CLOCKWISE)。顺时针旋转 180 度 (rotateCode = ROTATE_180)。顺时针旋转 270 度 (rotateCode = ROTATE_90_COUNTERCLOCKWISE)。
void	cv::scaleAdd (InputArray src1, double alpha, InputArray src2, OutputArray dst)
	计算缩放数组与另一个数组的和。
void	cv::setIdentity (InputOutputArray mtx, const Scalar &s=Scalar(1))
	初始化一个缩放的单位矩阵。
void	cv::setRNGSeed (int seed)
	设置默认随机数生成器的状态。
bool	cv::solve (InputArray src1, InputArray src2, OutputArray dst, int flags=DECOMP_LU)
	求解一个或多个线性系统或最小二乘问题。
int	cv::solveCubic (InputArray coeffs, OutputArray roots)
	查找三次方程的实根。
double	cv::solvePoly (InputArray coeffs, OutputArray roots, int maxIters=300)
	查找多项式方程的实根或复根。
void	cv::sort (InputArray src, OutputArray dst, int flags)
	对矩阵的每行或每列进行排序。
void	cv::sortIdx (InputArray src, OutputArray dst, int flags)
	对矩阵的每行或每列进行排序。
void	cv::split (const Mat &src, Mat *mvbegin)
	将多通道数组分割为多个单通道数组。
void	cv::split (InputArray m, OutputArrayOfArrays mv)
void	cv::sqrt (InputArray src, OutputArray dst)
	计算数组元素的平方根。
void	cv::subtract (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray(), int dtype=-1)
	计算两个数组或数组与标量之间的逐元素差。
Scalar	cv::sum (InputArray src)
	计算数组元素的和。
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)
	交换两个矩阵。
void	cv::swap (UMat &a, UMat &b)
RNG &	cv::theRNG ()
	返回默认的随机数生成器。
Scalar	cv::trace (InputArray mtx)
	返回矩阵的迹。
void	cv::transform (InputArray src, OutputArray dst, InputArray m)
	对每个数组元素执行矩阵变换。
void	cv::transpose (InputArray src, OutputArray dst)
	转置矩阵。
void	cv::transposeND (InputArray src, const std::vector< int > &order, OutputArray dst)
	n维矩阵的转置。
void	cv::vconcat (const Mat *src, size_t nsrc, OutputArray dst)
	对给定矩阵执行垂直连接。
void	cv::vconcat (InputArray src1, InputArray src2, OutputArray dst)
void	cv::vconcat (InputArrayOfArrays src, OutputArray dst)

枚举类型文档

BorderTypes

枚举 cv::BorderTypes

#include <opencv2/core/base.hpp>

各种边界类型，下表中的图像边界用 | 字符表示，描述每种方法时使用。

以下示例显示了根据不同方法调用 copyMakeBorder 的结果。输入图像尺寸为 6x4（宽 x 高），并且 copyMakeBorder 函数在每个方向上都使用了 2 像素的边界大小，从而生成 10x8 分辨率的结果图像。

输入图像
[[ 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_CONSTANT (使用常数值 255)
[[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_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_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_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_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]]

另请参见

borderInterpolate, copyMakeBorder

枚举器
BORDER_CONSTANT  Python: cv.BORDER_CONSTANT	iiiiii|abcdefgh|iiiiiii 带有某些指定的 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 - 将异常值视为透明。
BORDER_REFLECT101  Python: cv.BORDER_REFLECT101	与 BORDER_REFLECT_101 相同
BORDER_DEFAULT  Python: cv.BORDER_DEFAULT	与 BORDER_REFLECT_101 相同
BORDER_ISOLATED  Python: cv.BORDER_ISOLATED	插值受限于 ROI 边界内。

CmpTypes

枚举 cv::CmpTypes

#include <opencv2/core/base.hpp>

比较类型

枚举器
CMP_EQ  Python: cv.CMP_EQ	src1 等于 src2。
CMP_GT  Python: cv.CMP_GT	src1 大于 src2。
CMP_GE  Python: cv.CMP_GE	src1 大于或等于 src2。
CMP_LT  Python: cv.CMP_LT	src1 小于 src2。
CMP_LE  Python: cv.CMP_LE	src1 小于或等于 src2。
CMP_NE  Python: cv.CMP_NE	src1 不等于 src2。

CovarFlags

枚举 cv::CovarFlags

#include <opencv2/core.hpp>

协方差标志。

枚举器
COVAR_SCRAMBLED  Python: cv.COVAR_SCRAMBLED	输出协方差矩阵计算为 \[\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} ,...],\] 协方差矩阵将是 nsamples x nsamples。这种不寻常的协方差矩阵用于对一组非常大的向量进行快速 PCA（例如，参见用于人脸识别的 EigenFaces 技术）。这个“加扰”矩阵的特征值与真实协方差矩阵的特征值匹配。“真实”特征向量可以很容易地从“加扰”协方差矩阵的特征向量计算出来。
COVAR_NORMAL  Python: cv.COVAR_NORMAL	输出协方差矩阵计算为 \[\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_SCRAMBLED 和 COVAR_NORMAL 必须且只能指定其中一个。
COVAR_USE_AVG  Python: cv.COVAR_USE_AVG	如果指定了该标志，函数将不从输入向量计算均值，而是使用传入的均值向量。当均值已预先计算或已知时，或者当协方差矩阵分部分计算时，这很有用。在这种情况下，均值不是输入向量子集的均值向量，而是整个集的均值向量。
COVAR_SCALE  Python: cv.COVAR_SCALE	如果指定了该标志，则协方差矩阵将被缩放。在“正常”模式下，比例为 1./nsamples。在“加扰”模式下，比例是每个输入向量中元素总数的倒数。默认情况下（如果未指定该标志），协方差矩阵不进行缩放（scale=1）。
COVAR_ROWS  Python: cv.COVAR_ROWS	如果指定了该标志，则所有输入向量都将作为样本矩阵的行存储。在这种情况下，均值应为单行向量。
COVAR_COLS  Python: cv.COVAR_COLS	如果指定了该标志，则所有输入向量都将作为样本矩阵的列存储。在这种情况下，均值应为单列向量。

DecompTypes

枚举 cv::DecompTypes

#include <opencv2/core/base.hpp>

矩阵分解类型

枚举器
DECOMP_LU  Python: cv.DECOMP_LU	使用选择的最佳主元进行高斯消元。
DECOMP_SVD  Python: cv.DECOMP_SVD	奇异值分解 (SVD) 方法；系统可能超定和/或矩阵 src1 可能奇异
DECOMP_EIG  Python: cv.DECOMP_EIG	特征值分解；矩阵 src1 必须对称
DECOMP_CHOLESKY  Python: cv.DECOMP_CHOLESKY	Cholesky \(LL^T\) 分解；矩阵 src1 必须对称且正定
DECOMP_QR  Python: cv.DECOMP_QR	QR 分解；系统可能超定和/或矩阵 src1 可能奇异
DECOMP_NORMAL  Python: cv.DECOMP_NORMAL	虽然所有先前的标志都是互斥的，但此标志可以与任何先前标志一起使用；这意味着求解的是正规方程 \(\texttt{src1}^T\cdot\texttt{src1}\cdot\texttt{dst}=\texttt{src1}^T\texttt{src2}\)，而不是原始系统 \(\texttt{src1}\cdot\texttt{dst}=\texttt{src2}\)

DftFlags

枚举 cv::DftFlags

#include <opencv2/core/base.hpp>

枚举器
DFT_INVERSE  Python: cv.DFT_INVERSE	执行逆向一维或二维变换，而不是默认的正向变换。
DFT_SCALE  Python: cv.DFT_SCALE	缩放结果：将其除以数组元素的数量。通常，它与 DFT_INVERSE 结合使用。
DFT_ROWS  Python: cv.DFT_ROWS	对输入矩阵的每个独立行执行正向或逆向变换；此标志使您能够同时变换多个向量，并可用于减少开销（有时是处理本身开销的几倍）以执行 3D 及更高维度的变换等等。
DFT_COMPLEX_OUTPUT  Python: cv.DFT_COMPLEX_OUTPUT	执行一维或二维实数数组的正向变换；结果虽然是复数数组，但具有共轭对称性（CCS，详见下面的函数描述），并且这样的数组可以打包成与输入大小相同的实数数组，这是最快的选项，也是函数默认执行的操作；但是，您可能希望获得一个完整的复数数组（为了更简单的频谱分析等）——传递该标志以使函数生成一个完整大小的复数输出数组。
DFT_REAL_OUTPUT  Python: cv.DFT_REAL_OUTPUT	执行一维或二维复数数组的逆向变换；结果通常是相同大小的复数数组，但是，如果输入数组具有共轭复数对称性（例如，它是带有 DFT_COMPLEX_OUTPUT 标志的正向变换的结果），则输出是实数数组；虽然函数本身不检查输入是否对称，但您可以传递此标志，然后函数将假定对称性并生成实数输出数组（请注意，当输入打包成实数数组并执行逆向变换时，函数将输入视为打包的共轭复数对称数组，输出也将是实数数组）。
DFT_COMPLEX_INPUT  Python: cv.DFT_COMPLEX_INPUT	指定输入为复数输入。如果设置此标志，输入必须有 2 个通道。另一方面，为了向后兼容，如果输入有 2 个通道，则输入已被视为复数。
DCT_INVERSE  Python: cv.DCT_INVERSE	执行逆向一维或二维变换，而不是默认的正向变换。
DCT_ROWS  Python: cv.DCT_ROWS	对输入矩阵的每个独立行执行正向或逆向变换。此标志使您能够同时变换多个向量，并可用于减少开销（有时是处理本身开销的几倍）以执行 3D 及更高维度的变换等等。

GemmFlags

枚举 cv::GemmFlags

#include <opencv2/core/base.hpp>

广义矩阵乘法标志

枚举器
GEMM_1_T  Python: cv.GEMM_1_T	转置 src1
GEMM_2_T  Python: cv.GEMM_2_T	转置 src2
GEMM_3_T  Python: cv.GEMM_3_T	转置 src3

NormTypes

枚举 cv::NormTypes

#include <opencv2/core/base.hpp>

范数类型

src1 和 src2 表示输入数组。

枚举器
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	当有一个输入数组时，计算数组与零的 汉明 距离；当有两个输入数组时，计算两个数组之间的 汉明 距离。
NORM_HAMMING2  Python: cv.NORM_HAMMING2	类似于 NORM_HAMMING，但在计算中，输入序列的每两位将被相加并视为一位，用于与 NORM_HAMMING 相同的计算中。
NORM_TYPE_MASK  Python: cv.NORM_TYPE_MASK	位掩码，可用于将范数类型与范数标志分开
NORM_RELATIVE  Python: cv.NORM_RELATIVE	flag
NORM_MINMAX  Python: cv.NORM_MINMAX	flag

ReduceTypes

枚举 cv::ReduceTypes

#include <opencv2/core.hpp>

枚举器
REDUCE_SUM  Python: cv.REDUCE_SUM	输出是矩阵所有行/列的总和。
REDUCE_AVG  Python: cv.REDUCE_AVG	输出是矩阵所有行/列的平均向量。
REDUCE_MAX  Python: cv.REDUCE_MAX	输出是矩阵所有行/列的最大值（按列/行）。
REDUCE_MIN  Python: cv.REDUCE_MIN	输出是矩阵所有行/列的最小值（按列/行）。
REDUCE_SUM2  Python: cv.REDUCE_SUM2	输出是矩阵所有行/列的平方和。

RotateFlags

枚举 cv::RotateFlags

#include <opencv2/core.hpp>

枚举器
ROTATE_90_CLOCKWISE  Python: cv.ROTATE_90_CLOCKWISE	顺时针旋转 90 度。
ROTATE_180  Python: cv.ROTATE_180	顺时针旋转 180 度。
ROTATE_90_COUNTERCLOCKWISE  Python: cv.ROTATE_90_COUNTERCLOCKWISE	顺时针旋转 270 度。

函数文档

absdiff()

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

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

#include <opencv2/core.hpp>

计算两个数组之间或数组与标量之间的逐元素绝对差。

函数 cv::absdiff 计算：当两个数组具有相同大小和类型时的逐元素绝对差

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

当第二个数组由 Scalar 构造或具有与 src1 通道数相同数量的元素时，数组与标量之间的绝对差

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

当第一个数组由 Scalar 构造或具有与 src2 通道数相同数量的元素时，标量与数组之间的绝对差

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

其中 I 是数组元素的（多维）索引。在多通道数组的情况下，每个通道独立处理。

注意

当数组深度为 CV_32S 时，不应用饱和。在溢出情况下，甚至可能得到负值。

(Python) 请注意 src1/src2 是单个数字与元组/数组之间的不同行为。absdiff(src,X) 意味着 absdiff(src,(X,X,X,X))。absdiff(src,(X,)) 意味着 absdiff(src,(X,0,0,0))。

参数

src1	第一个输入数组或标量。
src2	第二个输入数组或标量。
dst	与输入数组具有相同大小和类型的输出数组。

另请参见

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>

计算两个数组或数组与标量之间的逐元素和。

函数 add 计算

• 当两个输入数组具有相同大小和相同通道数时的两个数组的和

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

• 当 src2 由 Scalar 构造或具有与 src1.channels() 相同数量的元素时，数组与标量的和

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

• 当 src1 由 Scalar 构造或具有与 src2.channels() 相同数量的元素时，标量与数组的和

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

  其中 I 是数组元素的多维索引。在多通道数组的情况下，每个通道独立处理。

列表中第一个函数可以用矩阵表达式替换

dst = src1 + src2;
dst += src1; // 等同于 add(dst, src1, dst);

输入数组和输出数组可以具有相同或不同的深度。例如，您可以将 16 位无符号数组添加到 8 位有符号数组，并将总和存储为 32 位浮点数组。输出数组的深度由 dtype 参数确定。在上面第二种和第三种情况中，以及在第一种情况中（当 src1.depth() == src2.depth() 时），dtype 可以设置为默认值 -1。在这种情况下，输出数组将具有与输入数组相同的深度，无论是 src1、src2 还是两者。

注意

当输出数组深度为 CV_32S 时，不应用饱和。在溢出情况下，甚至可能得到不正确的符号结果。

(Python) 请注意 src1/src2 是单个数字与元组/数组之间的不同行为。add(src,X) 意味着 add(src,(X,X,X,X))。add(src,(X,)) 意味着 add(src,(X,0,0,0))。

参数

src1	第一个输入数组或标量。
src2	第二个输入数组或标量。
dst	与输入数组具有相同大小和通道数的输出数组；深度由 dtype 或 src1/src2 定义。
mask	可选操作掩码 - 8 位单通道数组，指定要更改的输出数组元素。
dtype	输出数组的可选深度（参见下面的讨论）。

另请参见

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>

计算两个数组的加权和。

函数 addWeighted 计算两个数组的加权和，如下所示：

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

其中 I 是数组元素的多元索引。对于多通道数组，每个通道都独立处理。该函数可以用矩阵表达式替代：

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

注意

当输出数组深度为 CV_32S 时，不应用饱和。在溢出情况下，甚至可能得到不正确的符号结果。

参数

src1	第一个输入数组。
alpha	第一个数组元素的权重。
src2	第二个输入数组，其大小和通道数与 src1 相同。
beta	第二个数组元素的权重。
gamma	加到每个和中的标量。
dst	输出数组，其大小和通道数与输入数组相同。
dtype	可选的输出数组深度；当两个输入数组具有相同的深度时，dtype 可以设置为 -1，这等同于 src1.depth()。

另请参见

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>

朴素最近邻查找器

参见 http://en.wikipedia.org/wiki/Nearest_neighbor_search

待办

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>

计算两个数组的逐位合取 (dst = src1 & src2) 计算两个数组或数组与标量的逐元素位合取。

函数 cv::bitwise_and 计算逐元素位逻辑合取，适用于：当 src1 和 src2 大小相同时的两个数组

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

当 src2 由 Scalar 构造或具有与 src1.channels() 相同的元素数量时，一个数组与一个标量进行操作：

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

当 src1 由 Scalar 构造或具有与 src2.channels() 相同的元素数量时，一个标量与一个数组进行操作：

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

对于浮点数组，将使用其机器特定的位表示（通常符合 IEEE754 标准）进行操作。对于多通道数组，每个通道都独立处理。在上述第二种和第三种情况下，标量会首先转换为数组类型。

参数

src1	第一个输入数组或标量。
src2	第二个输入数组或标量。
dst	输出数组，其大小和类型与输入数组相同。
mask	可选的操作掩码，8 位单通道数组，指定输出数组中要更改的元素。

此函数的调用图如下

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>

反转数组的每个位。

函数 cv::bitwise_not 计算输入数组的逐元素位反转：

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

对于浮点输入数组，将使用其机器特定的位表示（通常符合 IEEE754 标准）进行操作。对于多通道数组，每个通道都独立处理。

参数

src	输入数组。
dst	输出数组，其大小和类型与输入数组相同。
mask	可选的操作掩码，8 位单通道数组，指定输出数组中要更改的元素。

此函数的调用图如下

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>

计算两个数组或数组与标量的逐元素位析取。

函数 cv::bitwise_or 计算逐元素位逻辑析取，适用于：当 src1 和 src2 大小相同时的两个数组

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

当 src2 由 Scalar 构造或具有与 src1.channels() 相同的元素数量时，一个数组与一个标量进行操作：

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

当 src1 由 Scalar 构造或具有与 src2.channels() 相同的元素数量时，一个标量与一个数组进行操作：

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

对于浮点数组，将使用其机器特定的位表示（通常符合 IEEE754 标准）进行操作。对于多通道数组，每个通道都独立处理。在上述第二种和第三种情况下，标量会首先转换为数组类型。

参数

src1	第一个输入数组或标量。
src2	第二个输入数组或标量。
dst	输出数组，其大小和类型与输入数组相同。
mask	可选的操作掩码，8 位单通道数组，指定输出数组中要更改的元素。

此函数的调用图如下

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>

计算两个数组或数组与标量的逐元素位“异或”操作。

函数 cv::bitwise_xor 计算逐元素位逻辑“异或”操作，适用于：当 src1 和 src2 大小相同时的两个数组

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

当 src2 由 Scalar 构造或具有与 src1.channels() 相同的元素数量时，一个数组与一个标量进行操作：

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

当 src1 由 Scalar 构造或具有与 src2.channels() 相同的元素数量时，一个标量与一个数组进行操作：

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

对于浮点数组，将使用其机器特定的位表示（通常符合 IEEE754 标准）进行操作。对于多通道数组，每个通道都独立处理。在上述第 2 种和第 3 种情况下，标量会首先转换为数组类型。

参数

src1	第一个输入数组或标量。
src2	第二个输入数组或标量。
dst	输出数组，其大小和类型与输入数组相同。
mask	可选的操作掩码，8 位单通道数组，指定输出数组中要更改的元素。

此函数的调用图如下

borderInterpolate()

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

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

#include <opencv2/core.hpp>

计算外推像素的源位置。

该函数计算并返回在使用指定外推边界模式时，对应于指定外推像素的源像素坐标。例如，如果您在水平方向使用 cv::BORDER_WRAP 模式，在垂直方向使用 cv::BORDER_REFLECT_101，并想计算浮点图像 img 中“虚拟”像素 Point(-5, 100) 的值，它看起来像这样：

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

通常，该函数不会被直接调用。它在过滤函数内部和 copyMakeBorder 中使用。

参数

p	沿某个轴线的外推像素的 0 索引坐标，可能小于 0 或大于等于 len
len	数组沿对应轴的长度。
borderType	边界类型，BorderTypes 之一，但 BORDER_TRANSPARENT 和 BORDER_ISOLATED 除外。当 borderType == BORDER_CONSTANT 时，无论 p 和 len 的值如何，函数总是返回 -1。

另请参见

copyMakeBorder

此函数的调用图如下

broadcast()

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

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

#include <opencv2/core.hpp>

将给定的 Mat 广播到给定的形状。

参数

src	输入数组
shape	目标形状。应为 CV_32S 类型的数字列表。请注意，不支持负值。
dst	具有给定形状的输出数组

此函数的调用图如下

calcCovarMatrix() [1/2]

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

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

#include <opencv2/core.hpp>

计算一组向量的协方差矩阵。

函数 cv::calcCovarMatrix 计算输入向量集的协方差矩阵，并可选地计算其均值向量。

参数

samples	以独立矩阵形式存储的样本
nsamples	样本数量
covar	类型为 ctype 且为方阵的输出协方差矩阵。
mean	输入或输出（取决于标志）数组，作为输入向量的平均值。
flags	操作标志，为 CovarFlags 的组合
ctype	矩阵类型；默认为 'CV_64F'。

另请参见

PCA, mulTransposed, Mahalanobis

待办

InputArrayOfArrays

此函数的调用图如下

calcCovarMatrix() [2/2] (重载)

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

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

#include <opencv2/core.hpp>

这是一个重载成员函数，为方便起见提供。它与上述函数的区别仅在于其接受的参数。

注意

使用 COVAR_ROWS 或 COVAR_COLS 标志

参数

samples	样本以单个矩阵的行/列形式存储。
covar	类型为 ctype 且为方阵的输出协方差矩阵。
mean	输入或输出（取决于标志）数组，作为输入向量的平均值。
flags	操作标志，为 CovarFlags 的组合
ctype	矩阵类型；默认为 'CV_64F'。

此函数的调用图如下

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.

函数 cv::cartToPolar 计算每个二维向量 (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}\]

角度的计算精度约为 0.3 度。对于点 (0,0)，角度设置为 0。

参数

x	x 坐标数组；必须是单精度或双精度浮点数组。
y	y 坐标数组，其大小和类型必须与 x 相同。
magnitude	幅值输出数组，其大小和类型与 x 相同。
angle	角度输出数组，其大小和类型与 x 相同；角度以弧度（0 到 2*Pi）或度（0 到 360 度）为单位测量。
angleInDegrees	一个标志，指示角度是以弧度（默认为此）还是以度为单位测量。

另请参见

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.

函数 cv::checkRange 检查每个数组元素既不是 NaN 也不是无穷大。当 minVal > -DBL_MAX 且 maxVal < DBL_MAX 时，该函数还会检查每个值是否在 minVal 和 maxVal 之间。对于多通道数组，每个通道都独立处理。如果某些值超出范围，则第一个异常值的位置将存储在 pos 中（当 pos != NULL 时）。然后，函数要么返回 false（当 quiet=true 时），要么抛出异常。

参数

a	输入数组。
quiet	一个标志，指示当数组元素超出范围时，函数是静默返回 false 还是抛出异常。
pos	可选的输出参数，当不为 NULL 时，必须是指向 src.dims 个元素的数组的指针。
minVal	有效值范围的包含性下限。
maxVal	有效值范围的排他性上限。

此函数的调用图如下

compare()

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

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

#include <opencv2/core.hpp>

执行两个数组或数组与标量值的逐元素比较。

该函数比较：当 src1 和 src2 大小相同时的两个数组的元素：

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

当 src2 由 Scalar 构造或只包含单个元素时，src1 的元素与标量 src2 进行比较：

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

当 src1 由 Scalar 构造或只包含单个元素时，src1 与 src2 的元素进行比较：

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

当比较结果为真时，输出数组的相应元素设置为 255。比较操作可以用等效的矩阵表达式替代：

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

参数

src1	第一个输入数组或一个标量；当它是数组时，必须是单通道。
src2	第二个输入数组或一个标量；当它是数组时，必须是单通道。
dst	类型为 ref CV_8U 的输出数组，其大小和通道数与输入数组相同。
cmpop	一个标志，指定数组之间的对应关系（cv::CmpTypes）

另请参见

checkRange, min, max, threshold

此函数的调用图如下

completeSymm()

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

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

#include <opencv2/core.hpp>

将方阵的下半部分或上半部分复制到另一半。

函数 cv::completeSymm 将方阵的下半部分或上半部分复制到另一半。矩阵对角线保持不变：

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

参数

m	输入输出浮点方阵。
lowerToUpper	操作标志；如果为 true，则将下半部分复制到上半部分。否则，将上半部分复制到下半部分。

另请参见

flip, transpose

此函数的调用图如下

convertFp16()

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

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

#include <opencv2/core.hpp>

Converts an array to half precision floating number.

此函数将 FP32（单精度浮点）转换为 FP16（半精度浮点），或反之。CV_16S 格式用于表示 FP16 数据。有两种使用模式（src -> dst）：CV_32F -> CV_16S 和 CV_16S -> CV_32F。输入数组必须是 CV_32F 或 CV_16S 类型才能表示位深度。如果输入数组不是其中任何一种，函数将引发错误。半精度浮点格式定义在 IEEE 754-2008 中。

参数

src	输入数组。
dst	输出数组。

已弃用

请改用 Mat::convertTo 并使用 CV_16F。

此函数的调用图如下

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>

缩放、计算绝对值并将结果转换为 8 位。

对输入数组的每个元素，函数 convertScaleAbs 依次执行三个操作：缩放、取绝对值、转换为无符号 8 位类型：

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

对于多通道数组，该函数独立处理每个通道。当输出不是 8 位时，可以通过调用 Mat::convertTo 方法（或使用矩阵表达式），然后计算结果的绝对值来模拟此操作。例如：

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

参数

src	输入数组。
dst	输出数组。
alpha	可选的比例因子。
beta	添加到缩放值的可选增量。

另请参见

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

此函数的调用图如下

copyMakeBorder()

void cv::copyMakeBorder	(	InputArray	src,
		OutputArray	dst,
		int	top,
		int	bottom,
		int	左,
		int	右,
		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.

该函数将源图像复制到目标图像的中间。复制源图像的左侧、右侧、上方和下方区域将填充外推像素。这并非基于此的滤波函数所做（它们即时外推像素），而是其他更复杂的函数（包括您自己的函数）可能为简化图像边界处理而执行的操作。

该函数支持 src 已位于 dst 中间的情况。在这种情况下，函数不会复制 src 本身，而是简单地构建边界，例如：

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

注意

当源图像是较大图像的一部分（ROI）时，该函数将尝试使用 ROI 外部的像素来形成边界。要禁用此功能并始终进行外推（就好像 src 不是 ROI 一样），请使用 borderType | BORDER_ISOLATED。

参数

src	源图像。
dst	目标图像，其类型与 src 相同，大小为 Size(src.cols+left+right, src.rows+top+bottom) 。
top	顶部像素
bottom	底部像素
左	左侧像素
右	参数，指定从源图像矩形向每个方向外推的像素数量。例如，top=1, bottom=1, left=1, right=1 表示需要构建 1 像素宽的边界。
borderType	边界类型。详见 borderInterpolate。
值	如果 borderType == BORDER_CONSTANT，则为边界值。

另请参见

borderInterpolate

此函数的调用图如下

copyTo()

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

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

#include <opencv2/core.hpp>

这是一个为方便起见提供的重载成员函数 (Python) 将矩阵复制到另一个矩阵。当指定操作掩码时，如果上面所示的 Mat::create 调用重新分配了矩阵，则在新分配的矩阵在复制数据之前将用全零初始化。

参数

src	源矩阵。
dst	目标矩阵。如果在操作前其大小或类型不正确，则会重新分配。
mask	与 *this 大小相同的操作掩码。其非零元素指示需要复制哪些矩阵元素。掩码必须是 CV_8U 类型，并且可以有 1 个或多个通道。

此函数的调用图如下

countNonZero()

int cv::countNonZero

(

InputArray

src

)

Python
	cv.countNonZero(	src	) ->	retval

#include <opencv2/core.hpp>

Counts non-zero array elements.

该函数返回 src 中非零元素的数量。

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

该函数不适用于多通道数组。如果您需要计算所有通道中的非零数组元素，请首先使用 Mat::reshape 将数组重新解释为单通道。或者您可以使用 extractImageCOI、mixChannels 或 split 提取特定通道。

注意

• 如果仅关心是否存在非零元素，hasNonZero 会很有用。
• 如果非零数组元素的位置很重要，findNonZero 会很有用。

参数

src

单通道数组。

另请参见

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>

执行一维或二维数组的正向或逆向离散余弦变换。

函数 cv::dct 对一维或二维浮点数组执行正向或逆向离散余弦变换 (DCT)

• 一维N元素向量的正向余弦变换

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

  其中

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

  其中 \(\alpha_0=1\)，当 j > 0 时 \(\alpha_j=2\)。
• 一维N元素向量的逆向余弦变换

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

  （因为 \(C^{(N)}\) 是正交矩阵，\(C^{(N)} \cdot \left(C^{(N)}\right)^T = I\) ）
• M x N 矩阵的正向二维余弦变换

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

• M x N 矩阵的逆向二维余弦变换

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

该函数通过查看输入数组的标志和大小来选择操作模式

• 如果 (flags & DCT_INVERSE) == 0，则函数执行正向一维或二维变换。否则，执行逆向一维或二维变换。
• 如果 (flags & DCT_ROWS) != 0，则函数对每行执行一维变换。
• 如果数组是单列或单行，则函数执行一维变换。
• 如果以上条件均不满足，则函数执行二维变换。

注意

目前 dct 支持偶数大小的数组（2、4、6...）。对于数据分析和近似，您可以在必要时填充数组。此外，函数的性能在很大程度上取决于数组大小，并且不是单调的（参见 getOptimalDFTSize）。在当前实现中，大小为 N 的向量的 DCT 是通过大小为 N/2 的向量的 DFT 计算的。因此，最佳 DCT 大小 N1 >= N 可以计算为

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

参数

src	输入浮点数组。
dst	与 src 大小和类型相同的输出数组。
flags	变换标志，是 cv::DftFlags (DCT_*) 的组合

另请参见

dft, getOptimalDFTSize, idct

此函数的调用图如下

determinant()

double cv::determinant

(

InputArray

makePtr()

)

Python
	mtx	makePtr()	) ->	retval

#include <opencv2/core.hpp>

返回方阵的浮点行列式。

函数 cv::determinant 计算并返回指定矩阵的行列式。对于小型矩阵（mtx.cols=mtx.rows<=3），使用直接方法。对于大型矩阵，函数使用带部分主元选择的 LU 分解。

对于对称正定矩阵，也可以使用特征分解来计算行列式。

参数

makePtr()

输入矩阵，必须是 CV_32FC1 或 CV_64FC1 类型，且为方阵。

另请参见

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>

执行一维或二维浮点数组的正向或逆向离散傅里叶变换。

函数 cv::dft 执行以下操作之一

• 一维N元素向量的正向傅里叶变换

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

  其中 \(F^{(N)}_{jk}=\exp(-2\pi i j k/N)\) 且 \(i=\sqrt{-1}\)
• 一维N元素向量的逆向傅里叶变换

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

  其中 \(F^*=\left(\textrm{Re}(F^{(N)})-\textrm{Im}(F^{(N)})\right)^T\)
• M x N 矩阵的正向二维傅里叶变换

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

• M x N 矩阵的逆向二维傅里叶变换

  \[\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}\]

对于实数（单通道）数据，正向傅里叶变换的输出频谱或逆向傅里叶变换的输入频谱可以采用称为 CCS（复共轭对称）的紧凑格式表示。它借鉴自 IPL（Intel* 图像处理库）。二维 CCS 频谱如下所示：

\[\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}\]

对于实向量的一维变换，输出类似于上述矩阵的第一行。

因此，函数根据输入数组的标志和大小选择操作模式

• 如果设置了 DFT_ROWS，或者输入数组为单行或单列，则当设置了 DFT_ROWS 时，函数对矩阵的每一行执行一维正向或逆向变换。否则，它执行二维变换。
• 如果输入数组为实数且未设置 DFT_INVERSE，则函数执行正向一维或二维变换
  • 当设置了 DFT_COMPLEX_OUTPUT 时，输出是与输入大小相同的复数矩阵。
  • 当未设置 DFT_COMPLEX_OUTPUT 时，输出是与输入大小相同的实数矩阵。在二维变换的情况下，它使用如上所示的紧凑格式。在单个一维变换的情况下，它看起来像上述矩阵的第一行。在多个一维变换的情况下（当使用 DFT_ROWS 标志时），输出矩阵的每一行看起来像上述矩阵的第一行。
• 如果输入数组为复数且未设置 DFT_INVERSE 或 DFT_REAL_OUTPUT，则输出是与输入大小相同的复数数组。函数根据 DFT_INVERSE 和 DFT_ROWS 标志，对整个输入数组或输入数组的每一行独立执行正向或逆向一维或二维变换。
• 当设置了 DFT_INVERSE 且输入数组为实数，或者输入数组为复数但设置了 DFT_REAL_OUTPUT 时，输出是与输入大小相同的实数数组。函数根据 DFT_INVERSE 和 DFT_ROWS 标志，对整个输入数组或每个单独的行执行一维或二维逆变换。

如果设置了 DFT_SCALE，则在变换后进行缩放。

与 dct 不同，该函数支持任意大小的数组。但只有那些大小可以分解为小素数（当前实现中为 2、3 和 5）乘积的数组才能高效处理。这种高效的 DFT 大小可以使用 getOptimalDFTSize 方法计算。

以下示例说明了如何计算两个二维实数数组的基于 DFT 的卷积

void convolveDFT(InputArray A, InputArray B, OutputArray C)
{
    // 如有需要，重新分配输出数组
C.create(abs(A.rows - B.rows)+1, abs(A.cols - B.cols)+1, A.type());
    Size dftSize;
    // 计算 DFT 变换的大小
dftSize.width = getOptimalDFTSize(A.cols + B.cols - 1);
dftSize.height = getOptimalDFTSize(A.rows + B.rows - 1);
 
    // 分配临时缓冲区并用 0 初始化它们
    Mat tempA(dftSize, A.type(), Scalar::all(0));
    Mat tempB(dftSize, B.type(), Scalar::all(0));
 
    // 将 A 和 B 分别复制到 tempA 和 tempB 的左上角
    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);
 
    // 现在对填充后的 A 和 B 进行原地变换；
    // 使用“nonzeroRows”提示以加快处理速度
    dft(tempA, tempA, 0, A.rows);
    dft(tempB, tempB, 0, B.rows);
 
    // 频谱相乘；
    // 该函数很好地处理了紧凑频谱表示
    mulSpectrums(tempA, tempB, tempA);
 
    // 将乘积从频域变换回来。
    // 即使所有结果行都将是非零的，
    // 您也只需要其中 C.rows 的前几行，因此您
    // 传入 nonzeroRows == C.rows
    dft(tempA, tempA, DFT_INVERSE + DFT_SCALE, C.rows);
 
    // 现在将结果复制回 C。
tempA(Rect(0, 0, C.cols, C.rows)).copyTo(C);
 
    // 所有临时缓冲区将自动释放
}

为了优化此示例，请考虑以下方法

• 由于 nonzeroRows != 0 被传递给正向变换调用，并且 A 和 B 分别复制到 tempA 和 tempB 的左上角，因此不需要清空整个 tempA 和 tempB。只需要清空矩阵最右侧的 tempA.cols - A.cols (tempB.cols - B.cols) 列。
• 这种基于 DFT 的卷积不必应用于整个大型数组，特别是当 B 明显小于 A 或反之亦然时。相反，您可以分部分计算卷积。为此，您需要将输出数组 C 分割成多个瓦片（tiles）。对于每个瓦片，估计计算此瓦片中卷积所需的 A 和 B 的哪些部分。如果 C 中的瓦片太小，由于重复工作，速度会大大降低。在最终情况下，当 C 中的每个瓦片都是单个像素时，算法等同于朴素卷积算法。如果瓦片太大，临时数组 tempA 和 tempB 会变得太大，并且由于缓存局部性差，也会导致速度下降。因此，在中间某个位置存在一个最佳瓦片大小。
• 如果 C 中不同的瓦片可以并行计算，从而分部分完成卷积，则循环可以多线程化。

上述所有改进都已在 matchTemplate 和 filter2D 中实现。因此，通过使用它们，您可以获得比上述理论上最优实现更好的性能。然而，这两个函数实际上计算的是互相关，而不是卷积，因此您需要使用 flip 对第二个卷积操作数 B 进行垂直和水平“翻转”。

注意

• 使用离散傅里叶变换的示例可以在 opencv_source_code/samples/cpp/dft.cpp 中找到。
• (Python) 使用 dft 功能执行维纳反卷积的示例可以在 opencv_source/samples/python/deconvolution.py 中找到。
• (Python) 重新排列傅里叶图像象限的示例可以在 opencv_source/samples/python/dft.py 中找到。

参数

src	可以是实数或复数的输入数组。
dst	输出数组，其大小和类型取决于标志。
flags	变换标志，表示 DftFlags 的组合
nonzeroRows	当参数不为零时，函数假定输入数组的（未设置 DFT_INVERSE 时）前 nonzeroRows 行或输出数组的（设置 DFT_INVERSE 时）前 nonzeroRows 行包含非零值，因此函数可以更高效地处理其余行并节省时间；这种技术对于使用 DFT 计算数组互相关或卷积非常有用。

另请参见

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>

这是一个重载成员函数，为方便起见提供。它与上述函数的区别仅在于其接受的参数。

此函数的调用图如下

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>

执行两个数组或标量除以数组的逐元素除法。

函数 cv::divide 将一个数组除以另一个数组

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

或者当没有 src1 时，将标量除以数组

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

多通道数组的不同通道独立处理。

对于整数类型，当 src2(I) 为零时，dst(I) 也将为零。

注意

对于浮点数据，对于零 src2(I) 值没有特殊定义的行为。使用常规浮点除法。浮点数据预期符合正确的 IEEE-754 行为（具有 NaN、Inf 结果值）。

当输出数组深度为 CV_32S 时，不应用饱和。在溢出情况下，甚至可能得到不正确的符号结果。

(Python) 请注意 src1/src2 为单个数字和为元组/数组时的行为差异。divide(src,X) 意味着 divide(src,(X,X,X,X))。divide(src,(X,)) 意味着 divide(src,(X,0,0,0))。

参数

src1	第一个输入数组。
src2	与 src1 大小和类型相同的第二个输入数组。
scale	标量因子。
dst	与 src2 大小和类型相同的输出数组。
dtype	输出数组的可选深度；如果为 -1，则 dst 将具有 src2.depth() 的深度，但在数组对数组的除法情况下，只有当 src1.depth()==src2.depth() 时，您才能传递 -1。

另请参见

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>

计算对称矩阵的特征值和特征向量。

函数 cv::eigen 计算对称矩阵 src 的特征值，或特征值和特征向量。

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

注意

使用 cv::eigenNonSymmetric 计算非对称矩阵的实特征值和特征向量。

参数

src	输入矩阵，必须具有 CV_32FC1 或 CV_64FC1 类型、方形大小并且是对称的 (src ^T^ == src)。
eigenvalues （特征值）	与 src 相同类型的特征值输出向量；特征值按降序存储。
eigenvectors （特征向量）	特征向量输出矩阵；其大小和类型与 src 相同；特征向量按与相应特征值相同的顺序作为后续矩阵行存储。

另请参见

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>

计算非对称矩阵的特征值和特征向量（仅实特征值）。

注意

假设为实特征值。

函数计算方阵 src 的特征值和特征向量（可选）。

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

参数

src	输入矩阵（CV_32FC1 或 CV_64FC1 类型）。
eigenvalues （特征值）	特征值输出向量（类型与 src 相同）。
eigenvectors （特征向量）	特征向量输出矩阵（类型与 src 相同）。特征向量按与相应特征值相同的顺序作为后续矩阵行存储。

另请参见

eigen

此函数的调用图如下

exp()

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

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

#include <opencv2/core.hpp>

计算每个数组元素的指数。

函数 cv::exp 计算输入数组每个元素的指数

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

对于单精度输入，最大相对误差约为 7e-6；对于双精度输入，小于 1e-10。目前，函数将非规格化值转换为输出零。特殊值（NaN、Inf）未处理。

参数

src	输入数组。
dst	与 `src` 相同大小和类型的输出数组。

另请参见

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

示例

samples/dnn/classification.cpp.

extractChannel()

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

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

#include <opencv2/core.hpp>

从 src 中提取单个通道（coi 是基于 0 的索引）

参数

src	输入数组
dst	输出数组
coi	要提取的通道索引

另请参见

mixChannels, split

此函数的调用图如下

findNonZero()

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

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

#include <opencv2/core.hpp>

返回非零像素的位置列表。

给定一个二进制矩阵（可能由 threshold()、compare()、>、== 等操作返回），将所有非零索引作为 cv::Mat 或 std::vector<cv::Point> (x,y) 返回。例如：

cv::Mat binaryImage; // 输入，二进制图像
cv::Mat locations; // 输出，非零像素的位置
cv::findNonZero(binaryImage, locations);
 
// 访问像素坐标
Point pnt = locations.at<Point>(i);

或者

cv::Mat binaryImage; // 输入，二进制图像
vector<Point> locations; // 输出，非零像素的位置
cv::findNonZero(binaryImage, locations);
 
// 访问像素坐标
Point pnt = locations[i];

该函数不适用于多通道数组。如果您需要在所有通道中查找非零元素，请先使用 Mat::reshape 将数组重新解释为单通道。或者您可以使用 extractImageCOI、mixChannels 或 split 提取特定通道。

注意

• 如果只关心非零数组元素的数量，则 countNonZero 会很有用。
• 如果仅关心是否存在非零元素，hasNonZero 会很有用。

参数

src	单通道数组
idx	输出数组，类型为 cv::Mat 或 std::vector<Point>，对应输入中的非零索引

另请参见

countNonZero, hasNonZero

此函数的调用图如下

flip()

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

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

#include <opencv2/core.hpp>

沿垂直、水平或两个轴翻转 2D 数组。

函数 cv::flip 以三种不同方式之一翻转数组（行和列索引从 0 开始）

\[\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.\]

使用该函数的示例场景如下： 垂直翻转图像 (flipCode == 0) 以在左上角和左下角图像原点之间切换。这是 Microsoft Windows* 操作系统中视频处理的典型操作。水平翻转图像，然后进行水平平移和绝对差值计算，以检查垂直轴对称性 (flipCode > 0)。同时水平和垂直翻转图像，然后进行平移和绝对差值计算，以检查中心对称性 (flipCode < 0)。反转点数组的顺序 (flipCode > 0 或 flipCode == 0)。

参数

src	输入数组。
dst	与 `src` 相同大小和类型的输出数组。
flipCode	指定如何翻转数组的标志；0 表示沿 x 轴翻转，正值（例如，1）表示沿 y 轴翻转。负值（例如，-1）表示沿两个轴翻转。

另请参见

transpose, repeat, completeSymm

此函数的调用图如下

flipND()

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

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

#include <opencv2/core.hpp>

沿给定轴翻转 N 维数组。

参数

src	输入数组
dst	与 src 形状相同的输出数组
axis（轴）	执行翻转的轴。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>

执行广义矩阵乘法。

函数 cv::gemm 执行广义矩阵乘法，类似于 BLAS level 3 中的 gemm 函数。例如，gemm(src1, src2, alpha, src3, beta, dst, GEMM_1_T + GEMM_3_T) 对应于

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

对于复数（双通道）数据，执行复数矩阵乘法。

该函数可以用矩阵表达式替换。例如，上述调用可以替换为

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

参数

src1	第一个相乘的输入矩阵，可以是实数（CV_32FC1, CV_64FC1）或复数（CV_32FC2, CV_64FC2）。
src2	与 src1 相同类型的第二个相乘的输入矩阵。
alpha	矩阵乘积的权重。
src3	第三个可选的增量矩阵，添加到矩阵乘积中；它应与 src1 和 src2 具有相同的类型。
beta	src3 的权重。
dst	输出矩阵；它具有适当的大小并且与输入矩阵类型相同。
flags	操作标志（cv::GemmFlags）

另请参见

mulTransposed, transform

此函数的调用图如下

getOptimalDFTSize()

int cv::getOptimalDFTSize

(

int

vecsize

)

Python
	cv.getOptimalDFTSize(	vecsize	) ->	retval

#include <opencv2/core.hpp>

返回给定向量大小的最佳 DFT 大小。

DFT 性能不是向量大小的单调函数。因此，当您计算两个数组的卷积或对数组进行频谱分析时，通常通过用零填充输入数据以获得稍大一点的数组会更有意义，这样可以比原始数组更快地进行变换。大小为二的幂（2、4、8、16、32 等）的数组处理速度最快。但是，大小为 2、3 和 5 的乘积（例如，300 = 5*5*3*2*2）的数组也能相当高效地处理。

函数 cv::getOptimalDFTSize 返回大于或等于 vecsize 的最小数字 N，以便可以高效地处理大小为 N 的向量的 DFT。在当前实现中，N = 2 ^p^ * 3 ^q^ * 5 ^r^，其中 p、q、r 为某些整数。

如果 vecsize 过大（非常接近 INT_MAX），函数将返回一个负数。

虽然该函数不能直接用于估计 DCT 变换的最佳向量大小（因为当前的 DCT 实现仅支持偶数大小的向量），但可以轻松地将其处理为 getOptimalDFTSize((vecsize+1)/2)*2。

参数

vecsize

向量大小。

另请参见

dft, dct, idft, idct, mulSpectrums

此函数的调用图如下

hasNonZero()

bool cv::hasNonZero

(

InputArray

src

)

Python
	cv.hasNonZero(	src	) ->	retval

#include <opencv2/core.hpp>

检查是否存在至少一个非零数组元素。

该函数返回 src 中是否存在非零元素。

该函数不适用于多通道数组。如果您需要检查所有通道中的非零数组元素，请先使用 Mat::reshape 将数组重新解释为单通道。或者您可以使用 extractImageCOI、mixChannels 或 split 提取特定通道。

注意

• 如果非零数组元素的位置很重要，findNonZero 会很有用。
• 如果非零数组元素的数量很重要，countNonZero 会很有用。

参数

src

单通道数组。

另请参见

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>

对给定矩阵进行水平连接。

该函数水平连接两个或更多（具有相同行数的）cv::Mat 矩阵。

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 );
// 输出
//[1, 2, 3;
// 1, 2, 3;
// 1, 2, 3;
// 1, 2, 3]

参数

src	输入数组或矩阵向量。所有矩阵必须具有相同的行数和相同的深度。
nsrc	src 中的矩阵数量。
dst	输出数组。它具有与 src 相同的行数和深度，以及 src 的列数之和。

另请参见

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>

这是一个重载成员函数，为方便起见提供。它与上述函数的区别仅在于其接受的参数。

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]

参数

src1	要进行水平连接的第一个输入数组。
src2	要进行水平连接的第二个输入数组。
dst	输出数组。它具有与 src1 和 src2 相同的行数和深度，以及 src1 和 src2 的列数之和。

此函数的调用图如下

hconcat() [3/3]

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

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

#include <opencv2/core.hpp>

这是一个重载成员函数，为方便起见提供。它与上述函数的区别仅在于其接受的参数。

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 );
// 输出
//[1, 2, 3;
// 1, 2, 3;
// 1, 2, 3;
// 1, 2, 3]

参数

src	输入数组或矩阵向量。所有矩阵必须具有相同的行数和相同的深度。
dst	输出数组。它具有与 src 相同的行数和深度，以及 src 的列数之和。相同深度。

此函数的调用图如下

idct()

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

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

#include <opencv2/core.hpp>

计算一维或二维数组的逆离散余弦变换。

idct(src, dst, flags) 等同于 dct(src, dst, flags | DCT_INVERSE)。

参数

src	输入浮点单通道数组。
dst	与 `src` 相同大小和类型的输出数组。
flags	操作标志。

另请参见

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>

计算一维或二维数组的逆离散傅里叶变换。

idft(src, dst, flags) 等同于 dft(src, dst, flags | DFT_INVERSE)。

注意

dft 和 idft 默认都不缩放结果。因此，您应该将 DFT_SCALE 显式传递给 dft 或 idft 之一，以使这些变换互逆。

另请参见

dft, dct, idct, mulSpectrums, getOptimalDFTSize

参数

src	输入浮点实数或复数数组。
dst	输出数组，其大小和类型取决于标志。
flags	操作标志（参见 dft 和 DftFlags）。
nonzeroRows	要处理的 dst 行数；其余行的内容未定义（参见 dft 描述中的卷积示例）。

此函数的调用图如下

inRange()

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

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

#include <opencv2/core.hpp>

检查数组元素是否位于另外两个数组的元素之间。

函数按如下方式检查范围：

• 对于单通道输入数组的每个元素

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

• 对于双通道数组

  \[\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\]

• 以此类推。

也就是说，如果 src(I) 在指定的一维、二维、三维等框内，则 dst(I) 设置为 255（所有 1 位），否则为 0。

当上下限参数是标量时，上述公式中 lowerb 和 upperb 处的索引 (I) 应省略。

参数

src	第一个输入数组。
lowerb	包含下限的数组或标量。
upperb	包含上限的数组或标量。
dst	与src大小相同且类型为CV_8U的输出数组。

此函数的调用图如下

insertChannel()

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

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

#include <opencv2/core.hpp>

将单个通道插入 dst（coi 是基于 0 的索引）

参数

src	输入数组
dst	输出数组
coi	插入通道的索引

另请参见

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>

查找矩阵的逆或伪逆。

函数 cv::invert 对矩阵 src 求逆并将结果存储在 dst 中。当矩阵 src 是奇异或非方阵时，函数计算伪逆矩阵（dst 矩阵），使得 norm(src*dst - I) 最小，其中 I 是单位矩阵。

对于 DECOMP_LU 方法，如果成功计算了逆矩阵，函数返回非零值；如果 src 是奇异的，则返回 0。

对于 DECOMP_SVD 方法，函数返回 src 的逆条件数（最小奇异值与最大奇异值的比率），如果 src 是奇异的，则返回 0。如果 src 是奇异的，SVD 方法将计算伪逆矩阵。

类似于 DECOMP_LU，DECOMP_CHOLESKY 方法仅适用于非奇异方阵，这些方阵也应是对称且正定的。在这种情况下，函数将逆矩阵存储在 dst 中并返回非零值。否则，返回 0。

参数

src	输入浮点 M x N 矩阵。
dst	N x M 大小且与 src 相同类型的输出矩阵。
flags	求逆方法（cv::DecompTypes）

另请参见

solve, SVD

此函数的调用图如下

log()

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

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

#include <opencv2/core.hpp>

计算每个数组元素的自然对数。

函数 cv::log 计算输入数组每个元素的自然对数

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

对零、负值和特殊值（NaN、Inf）的输出未定义。

参数

src	输入数组。
dst	与 src 大小和类型相同的输出数组。

另请参见

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

LUT()

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

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

#include <opencv2/core.hpp>

对数组执行查找表变换。

LUT 函数使用查找表中的值填充输出数组。条目的索引取自输入数组。也就是说，函数按以下方式处理 src 的每个元素：

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

其中

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

参数

src	8位元素的输入数组。
lut	包含 256 个元素的查找表；对于多通道输入数组，该表应为单通道（在这种情况下，所有通道使用相同的表）或与输入数组具有相同数量的通道。
dst	输出数组，其大小和通道数与 src 相同，深度与 lut 相同。

另请参见

convertScaleAbs, Mat::convertTo

此函数的调用图如下

magnitude()

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

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

#include <opencv2/core.hpp>

计算二维向量的幅度。

函数 cv::magnitude 计算由 x 和 y 数组的相应元素形成的二维向量的幅度

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

参数

x	向量的 x 坐标的浮点数组。
y	向量 y 坐标的浮点数组；其大小必须与 x 相同。
magnitude	与 x 大小和类型相同的输出数组。

另请参见

cartToPolar, polarToCart, phase, sqrt

此函数的调用图如下

Mahalanobis()

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

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

#include <opencv2/core.hpp>

计算两个向量之间的马哈拉诺比斯距离。

函数 cv::Mahalanobis 计算并返回两个向量之间的加权距离

\[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)})} }\]

协方差矩阵可以使用 calcCovarMatrix 函数计算，然后使用 invert 函数求逆（最好使用 DECOMP_SVD 方法，因为它最准确）。

参数

v2 )	第一个一维输入向量。
v2	第二个一维输入向量。
icovar	逆协方差矩阵。

此函数的调用图如下

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>

这是一个重载成员函数，为方便起见而提供。它与上述函数的唯一区别在于其接受的参数。用于避免与 const _Tp& std::min(const _Tp&, const _Tp&, _Compare) 冲突

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>

这是一个重载成员函数，为方便起见而提供。它与上述函数的唯一区别在于其接受的参数。用于避免与 const _Tp& std::min(const _Tp&, const _Tp&, _Compare) 冲突

max() [3/3]

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

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

#include <opencv2/core.hpp>

计算两个数组或数组与标量的逐元素最大值。

函数 cv::max 计算两个数组的逐元素最大值

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

或数组与标量

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

参数

src1	第一个输入数组。
src2	第二个输入数组，其大小和类型与 src1 相同。
dst	与 src1 大小和类型相同的输出数组。

另请参见

min, compare, inRange, minMaxLoc, MatrixExpressions

mean()

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

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

#include <opencv2/core.hpp>

计算数组元素的平均值（均值）。

函数 cv::mean 独立地为每个通道计算数组元素的平均值 M 并返回它

\[\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}\]

当所有掩码元素都为 0 时，函数返回 Scalar::all(0)。

参数

src	输入数组，应具有 1 到 4 个通道，以便结果可以存储在 Scalar_ 中。
mask	可选操作掩码。

另请参见

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>

计算数组元素的均值和标准差。

函数 cv::meanStdDev 独立地为每个通道计算数组元素的平均值和标准差 M，并通过输出参数返回它

\[\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}\]

当所有掩码元素都为 0 时，函数返回 mean=stddev=Scalar::all(0)。

注意

计算出的标准差仅是完整归一化协方差矩阵的对角线。如果需要完整的矩阵，您可以将多通道数组 M x N 重塑为单通道数组 M*N x mtx.channels()（仅当矩阵是连续的时才可能），然后将该矩阵传递给 calcCovarMatrix。

参数

src	输入数组，应具有 1 到 4 个通道，以便结果可以存储在 Scalar_ 中。
mean	输出参数：计算出的平均值。
stddev	输出参数：计算出的标准差。
mask	可选操作掩码。

另请参见

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>

将多个单通道数组合并为一个多通道数组。

函数 cv::merge 将多个数组合并为一个单一的多通道数组。也就是说，输出数组的每个元素将是输入数组元素的连接，其中第 i 个输入数组的元素被视为 mv[i].channels()-元素向量。

函数 cv::split 执行相反的操作。如果您需要以其他更高级的方式重新排列通道，请使用 cv::mixChannels。

以下示例展示了如何将 3 个单通道矩阵合并为一个 3 通道矩阵。

    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
    */

参数

mv	要合并的矩阵输入数组；mv 中的所有矩阵必须具有相同的大小和相同的深度。
count	当 mv 是普通 C 数组时输入矩阵的数量；它必须大于零。
dst	与 mv[0] 具有相同大小和深度的输出数组；通道数将等于参数 count。

另请参见

mixChannels, split, Mat::reshape

此函数的调用图如下

merge() [2/2]

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

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

#include <opencv2/core.hpp>

这是一个重载成员函数，为方便起见提供。它与上述函数的区别仅在于其接受的参数。

参数

mv	要合并的矩阵输入向量；mv 中的所有矩阵必须具有相同的大小和相同的深度。
dst	与 mv[0] 具有相同大小和深度的输出数组；通道数将是矩阵数组中的总通道数。

此函数的调用图如下

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>

这是一个重载成员函数，为方便起见而提供。它与上述函数的唯一区别在于其接受的参数。用于避免与 const _Tp& std::min(const _Tp&, const _Tp&, _Compare) 冲突

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>

这是一个重载成员函数，为方便起见而提供。它与上述函数的唯一区别在于其接受的参数。用于避免与 const _Tp& std::min(const _Tp&, const _Tp&, _Compare) 冲突

min() [3/3]

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

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

#include <opencv2/core.hpp>

计算两个数组或数组与标量的逐元素最小值。

函数 cv::min 计算两个数组的逐元素最小值

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

或数组与标量

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

参数

src1	第一个输入数组。
src2	与 src1 大小和类型相同的第二个输入数组。
dst	与 src1 大小和类型相同的输出数组。

另请参见

max, compare, inRange, minMaxLoc

minMaxIdx()

void cv::minMaxIdx	(	InputArray	src,
		如果传入NULL，则假定尺度参数c为1.0。否则，指向的变量将被设置为最优尺度。	minVal,
		如果传入NULL，则假定尺度参数c为1.0。否则，指向的变量将被设置为最优尺度。	maxVal = 0,
		int *	minIdx = 0,
		int *	maxIdx = 0,
		InputArray	mask = noArray() )

#include <opencv2/core.hpp>

查找数组中的全局最小值和最大值。

函数 cv::minMaxIdx 查找数组中的最小值、最大值及其位置。极值搜索范围可以是整个数组，或者在 mask 不为空时，搜索指定数组区域。对于稀疏矩阵，只在非零元素中查找最小值。支持多通道输入，但不带掩码和极值索引（应为 nullptr）。

注意

当 minIdx 不为 NULL 时，它必须至少包含 2 个元素（maxIdx 亦然），即使 src 是单行或单列矩阵。在 OpenCV 中（仿照 MATLAB），每个数组至少有 2 个维度，即单列矩阵是 Mx1 矩阵（因此 minIdx/maxIdx 将是 (i1,0)/(i2,0)），单行矩阵是 1xN 矩阵（因此 minIdx/maxIdx 将是 (0,j1)/(0,j2)）。

参数

src	单通道输入数组。
minVal	指向返回的最小值的指针；如果不需要，则使用 NULL。
maxVal	指向返回的最大值的指针；如果不需要，则使用 NULL。
minIdx	指向返回的最小值位置的指针（n 维情况下）；如果不需要，则使用 NULL；否则，它必须指向一个包含 src.dims 个元素的数组，其中按顺序存储了最小值元素在每个维度上的坐标。
maxIdx	指向返回的最大值位置的指针（n 维情况下）。如果不需要，则使用 NULL。
mask	指定的数组区域

此函数的调用图如下

minMaxLoc() [1/2]

void cv::minMaxLoc	(	const SparseMat &	a,
		如果传入NULL，则假定尺度参数c为1.0。否则，指向的变量将被设置为最优尺度。	minVal,
		如果传入NULL，则假定尺度参数c为1.0。否则，指向的变量将被设置为最优尺度。	maxVal,
		int *	minIdx = 0,
		int *	maxIdx = 0 )

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

#include <opencv2/core.hpp>

这是一个重载成员函数，为方便起见提供。它与上述函数的区别仅在于其接受的参数。

参数

a	单通道输入数组。
minVal	指向返回的最小值的指针；如果不需要，则使用 NULL。
maxVal	指向返回的最大值的指针；如果不需要，则使用 NULL。
minIdx	指向返回的最小值位置的指针（n 维情况下）；如果不需要，则使用 NULL；否则，它必须指向一个包含 src.dims 个元素的数组，其中按顺序存储了最小值元素在每个维度上的坐标。
maxIdx	指向返回的最大值位置的指针（n 维情况下）。如果不需要，则使用 NULL。

此函数的调用图如下

minMaxLoc() [2/2]

void cv::minMaxLoc	(	InputArray	src,
		如果传入NULL，则假定尺度参数c为1.0。否则，指向的变量将被设置为最优尺度。	minVal,
		如果传入NULL，则假定尺度参数c为1.0。否则，指向的变量将被设置为最优尺度。	maxVal = 0,
		Point *	minLoc = 0,
		Point *	maxLoc = 0,
		InputArray	mask = noArray() )

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

#include <opencv2/core.hpp>

查找数组中的全局最小值和最大值。

函数 cv::minMaxLoc 查找数组中的最小值、最大值及其位置。极值搜索范围可以是整个数组，或者在 mask 不为空时，搜索指定数组区域。

在 C++ 中，如果输入是多通道的，您应该省略 minLoc、maxLoc 和 mask 参数（即分别将它们保留为 NULL、NULL 和 noArray()）。多通道输入数组不支持这些参数。如果处理多通道输入且需要 minLoc、maxLoc 或 mask 参数，则应首先使用 Mat::reshape 将数组重新解释为单通道。或者，您可以使用 extractImageCOI、mixChannels 或 split 提取特定通道。

在 Python 中，由于绑定生成过程中的限制（无法将 minLoc 和 maxLoc 设置为 NULL），根本不支持多通道输入。解决方法是单独操作每个通道或使用 NumPy 实现相同的功能。

参数

src	单通道输入数组。
minVal	指向返回的最小值的指针；如果不需要，则使用 NULL。
maxVal	指向返回的最大值的指针；如果不需要，则使用 NULL。
minLoc (最小位置)	指向返回的最小值位置的指针（2D 情况下）；如果不需要，则使用 NULL。
maxLoc (最大位置)	指向返回的最大值位置的指针（2D 情况下）；如果不需要，则使用 NULL。
mask	用于选择子数组的可选掩码。

另请参见

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>

将指定通道从输入数组复制到输出数组的指定通道。

函数 cv::mixChannels 提供了一种高级机制，用于重新排列图像通道。

cv::split,cv::merge,cv::extractChannel,cv::insertChannel 和某些形式的 cv::cvtColor 是 cv::mixChannels 的部分情况。

在下面的示例中，代码将一个 4 通道 BGRA 图像分割成一个 3 通道 BGR 图像（其中 B 和 R 通道已交换）以及一个单独的 alpha 通道图像

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 );
 
// 形成矩阵数组是一个相当高效的操作，
// 因为矩阵数据不会被复制，只复制头部
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 );

注意

与 OpenCV 中许多其他新式 C++ 函数不同（参见介绍部分和 Mat::create），cv::mixChannels 要求在调用函数之前预先分配输出数组。

参数

src	输入数组或矩阵向量；所有矩阵必须具有相同的大小和深度。
nsrcs	src 中矩阵的数量。
dst	输出数组或矩阵向量；所有矩阵必须已分配；它们的大小和深度必须与 src[0] 相同。
ndsts	dst 中矩阵的数量。
fromTo	指定复制哪些通道以及复制到何处的索引对数组；fromTo[k*2] 是 src 中输入通道的基于 0 的索引，fromTo[k*2+1] 是 dst 中输出通道的索引；使用连续的通道编号：第一个输入图像通道的索引从 0 到 src[0].channels()-1，第二个输入图像通道的索引从 src[0].channels() 到 src[0].channels() + src[1].channels()-1，依此类推，输出图像通道也使用相同的方案；作为特殊情况，当 fromTo[k*2] 为负时，相应的输出通道填充为零。
npairs	fromTo 中索引对的数量。

另请参见

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>

这是一个重载成员函数，为方便起见提供。它与上述函数的区别仅在于其接受的参数。

参数

src	输入数组或矩阵向量；所有矩阵必须具有相同的大小和深度。
dst	输出数组或矩阵向量；所有矩阵必须已分配；它们的大小和深度必须与 src[0] 相同。
fromTo	指定复制哪些通道以及复制到何处的索引对数组；fromTo[k*2] 是 src 中输入通道的基于 0 的索引，fromTo[k*2+1] 是 dst 中输出通道的索引；使用连续的通道编号：第一个输入图像通道的索引从 0 到 src[0].channels()-1，第二个输入图像通道的索引从 src[0].channels() 到 src[0].channels() + src[1].channels()-1，依此类推，输出图像通道也使用相同的方案；作为特殊情况，当 fromTo[k*2] 为负时，相应的输出通道填充为零。
npairs	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>

这是一个重载成员函数，为方便起见提供。它与上述函数的区别仅在于其接受的参数。

参数

src	输入数组或矩阵向量；所有矩阵必须具有相同的大小和深度。
dst	输出数组或矩阵向量；所有矩阵必须已分配；它们的大小和深度必须与 src[0] 相同。
fromTo	指定复制哪些通道以及复制到何处的索引对数组；fromTo[k*2] 是 src 中输入通道的基于 0 的索引，fromTo[k*2+1] 是 dst 中输出通道的索引；使用连续的通道编号：第一个输入图像通道的索引从 0 到 src[0].channels()-1，第二个输入图像通道的索引从 src[0].channels() 到 src[0].channels() + src[1].channels()-1，依此类推，输出图像通道也使用相同的方案；作为特殊情况，当 fromTo[k*2] 为负时，相应的输出通道填充为零。

此函数的调用图如下

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>

执行两个傅里叶频谱的逐元素乘法。

函数 cv::mulSpectrums 对两个 CCS 打包或复数矩阵进行逐元素乘法运算，这些矩阵是实数或复数傅里叶变换的结果。

该函数与 dft 和 idft 一起，可用于快速计算两个数组的卷积（conjB=false）或相关（conjB=true）。当数组为复数时，它们会简单地进行逐元素乘法运算，并可选择对第二个数组的元素进行共轭。当数组为实数时，假定它们是 CCS 打包的（详情请参阅 dft）。

参数

a	第一个输入数组。
b	第二个输入数组，其大小和类型与 src1 相同。
c	输出数组，其大小和类型与 src1 相同。
flags	操作标志；目前，唯一支持的标志是 cv::DFT_ROWS，它表示 src1 和 src2 的每一行都是独立的 1D 傅里叶频谱。如果您不想使用此标志，则只需添加 0 作为值。
conjB	在乘法之前是否对第二个输入数组进行共轭的可选标志（true 为共轭，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>

计算两个数组的逐元素缩放积。

函数 multiply 计算两个数组的逐元素乘积

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

第一个函数还有一个 MatrixExpressions -友好的变体。请参阅 Mat::mul 。

对于非逐元素的矩阵乘积，请参见 gemm 。

注意

当输出数组深度为 CV_32S 时，不应用饱和。在溢出情况下，甚至可能得到不正确的符号结果。

(Python) 请注意 src1/src2 为单个数字与它们为元组/数组时的行为差异。multiply(src,X) 意味着 multiply(src,(X,X,X,X))。multiply(src,(X,)) 意味着 multiply(src,(X,0,0,0))。

参数

src1	第一个输入数组。
src2	与 src1 大小和类型相同的第二个输入数组。
dst	与 src1 大小和类型相同的输出数组。
scale	可选的比例因子。
dtype	输出数组的可选深度

另请参见

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>

计算矩阵及其转置的乘积。

函数 cv::mulTransposed 计算 src 及其转置的乘积

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

如果 aTa=true，以及

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

否则。该函数用于计算协方差矩阵。当 delta 为零时，它可以作为一般矩阵乘积 A*B（当 B=A'时）的更快替代方案。

参数

src	输入单通道矩阵。请注意，与 gemm 不同，该函数不仅可以乘以浮点矩阵。
dst	输出方阵。
aTa	指定乘法顺序的标志。请参阅下面的描述。
delta	在乘法之前从 src 中减去的可选 delta 矩阵。当矩阵为空（delta=noArray()）时，假定为零，即不减去任何东西。如果它与 src 具有相同的大小，则直接减去。否则，它会被“重复”（参见 repeat）以覆盖整个 src，然后进行减法运算。当 delta 矩阵不为空时，其类型必须与创建的输出矩阵的类型相同。请参阅下面的 dtype 参数描述。
scale	矩阵乘积的可选比例因子。
dtype	输出矩阵的可选类型。当它为负时，输出矩阵将与 src 具有相同的类型。否则，它的类型将是 type=CV_MAT_DEPTH(dtype)，应为 CV_32F 或 CV_64F。

另请参见

calcCovarMatrix, gemm, repeat, reduce

此函数的调用图如下

norm() [1/3]

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

Python
	src1[, normType[, mask]]	src1, src2[, normType[, mask]]	) ->	retval
	src1[, normType[, mask]]	norm() [2/2]	) ->	retval

#include <opencv2/core.hpp>

这是一个重载成员函数，为方便起见提供。它与上述函数的区别仅在于其接受的参数。

参数

src	第一个输入数组。
normType	范数类型（参见 NormTypes）。

此函数的调用图如下

norm() [2/3]

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

Python
	src1[, normType[, mask]]	src1, src2[, normType[, mask]]	) ->	retval
	src1[, normType[, mask]]	norm() [2/2]	) ->	retval

#include <opencv2/core.hpp>

计算绝对差范数或相对差范数。

此版本的 cv::norm 计算数组 src1 和 src2 的绝对差范数或相对差范数。要计算的范数类型使用 NormTypes 指定。

参数

src1	第一个输入数组。
src2	与 src1 大小和类型相同的第二个输入数组。
normType	范数类型（参见 NormTypes）。
mask	可选操作掩码；它必须与 src1 具有相同的大小和 CV_8UC1 类型。

此函数的调用图如下

norm() [3/3]

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

Python
	src1[, normType[, mask]]	src1, src2[, normType[, mask]]	) ->	retval
	src1[, normType[, mask]]	norm() [2/2]	) ->	retval

#include <opencv2/core.hpp>

计算数组的绝对范数。

此版本的 norm 计算 src1 的绝对范数。要计算的范数类型使用 NormTypes 指定。

以一个数组为例，考虑函数 \(r(x)= \begin{pmatrix} x \\ 1-x \end{pmatrix}, x \in [-1;1]\)。样本值 \(r(-1) = \begin{pmatrix} -1 \\ 2 \end{pmatrix}\) 的 \( L_{1}, L_{2} \) 和 \( L_{\infty} \) 范数计算如下：

\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*}

对于 \(r(0.5) = \begin{pmatrix} 0.5 \\ 0.5 \end{pmatrix}\)，计算结果为：

\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*}

下图显示了三个范数函数 \(\| r(x) \|_{L_1}, \| r(x) \|_{L_2}\) 和 \(\| r(x) \|_{L_\infty}\) 的所有值。值得注意的是，\( L_{1} \) 范数构成了示例函数 \( r(x) \) 的上限，而 \( L_{\infty} \) 范数构成了下限。

当指定 mask 参数且不为空时，范数为

如果未指定 normType，则使用 NORM_L2。仅在掩码指定的区域上计算。

多通道输入数组被视为单通道数组，即所有通道的结果都会合并。

Hamming 范数只能使用 CV_8U 深度数组进行计算。

参数

src1	第一个输入数组。
normType	范数类型（参见 NormTypes）。
mask	可选操作掩码；它必须与 src1 具有相同的大小和 CV_8UC1 类型。

此函数的调用图如下

normalize() [1/2]

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

Python
	src, dst[, alpha[, beta[, norm_type[, dtype[, mask]]]]]	operator!=()	) ->	dst

#include <opencv2/core.hpp>

这是一个重载成员函数，为方便起见提供。它与上述函数的区别仅在于其接受的参数。

参数

src	输入数组。
dst	与 src 大小相同的输出数组。
alpha	归一化的范数值或范围归一化情况下的下限。
normType	归一化类型（参见 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
	src, dst[, alpha[, beta[, norm_type[, dtype[, mask]]]]]	operator!=()	) ->	dst

#include <opencv2/core.hpp>

对数组的范数或值范围进行归一化。

函数 cv::normalize 对输入数组元素进行归一化缩放和移位，使得

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

(其中 p=Inf、1 或 2) 当 normType 分别为 NORM_INF、NORM_L1 或 NORM_L2 时；或者使得

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

当 normType=NORM_MINMAX 时（仅适用于密集数组）。可选的 mask 指定要归一化的子数组。这意味着范数或最小-最大值是在子数组上计算的，然后该子数组被修改以进行归一化。如果您只想使用 mask 来计算范数或最小-最大值，但要修改整个数组，则可以使用 norm 和 Mat::convertTo。

对于稀疏矩阵，只分析和转换非零值。因此，不允许对稀疏矩阵进行范围转换，因为它会改变零级别。

带有一些正例数据的可能用法

vector<double> positiveData = { 2.0, 8.0, 10.0 };
vector<double> normalizedData_l1, normalizedData_l2, normalizedData_inf, normalizedData_minmax;
 
// 归一化为概率（总计数）
// 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);
 
// 归一化为单位向量: ||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);
 
// 归一化为最大元素
// 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);
 
// 归一化到范围 [0.0;1.0]
// 2.0 0.0 (左边界偏移)
// 8.0      0.75    (6.0/8.0)
// 10.0 1.0 (右边界偏移)
normalize(positiveData, normalizedData_minmax, 1.0, 0.0, NORM_MINMAX);

注意

由于舍入问题，最小-最大归一化可能导致值超出提供的边界。如果需要精确的范围一致性，可以使用以下变通方法：

• 使用双精度浮点（dtype = CV_64F）
• 手动裁剪值（cv::max(res, left_bound, res)、cv::min(res, right_bound, res) 或 np.clip）

参数

src	输入数组。
dst	与 src 大小相同的输出数组。
alpha	归一化的范数值或范围归一化情况下的下限。
beta	范围归一化情况下的上限；它不用于范数归一化。
norm_type	归一化类型（参见 cv::NormTypes）。
dtype	当为负时，输出数组与 src 具有相同的类型；否则，它与 src 具有相同的通道数，并且深度 =CV_MAT_DEPTH(dtype)。
mask	可选操作掩码。

另请参见

norm, Mat::convertTo, SparseMat::convertTo

示例

samples/cpp/pca.cpp.

此函数的调用图如下

patchNaNs()

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

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

#include <opencv2/core.hpp>

将 NaN 替换为给定数字。

参数

a	输入/输出矩阵（CV_32F 类型）。
val	用于转换 NaN 的值

此函数的调用图如下

PCABackProject()

void cv::PCABackProject	(	InputArray	data,
		InputArray	mean,
		InputArray	eigenvectors （特征向量）,
		OutputArray	result )

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

#include <opencv2/core.hpp>

封装 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>

封装 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>

封装 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>

封装 PCA::operator() 并添加特征值输出参数

此函数的调用图如下

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>

封装 PCA::operator() 并添加特征值输出参数

此函数的调用图如下

PCAProject()

void cv::PCAProject	(	InputArray	data,
		InputArray	mean,
		InputArray	eigenvectors （特征向量）,
		OutputArray	result )

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

#include <opencv2/core.hpp>

封装 PCA::project

此函数的调用图如下

perspectiveTransform()

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

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

#include <opencv2/core.hpp>

执行向量的透视矩阵变换。

函数 cv::perspectiveTransform 将 src 的每个元素视为 2D 或 3D 向量，并按以下方式进行变换：

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

其中

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

且

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

这里展示了 3D 向量变换。对于 2D 向量变换，z 分量被省略。

注意

该函数变换稀疏的 2D 或 3D 向量集。如果您想使用透视变换来变换图像，请使用 warpPerspective。如果您遇到逆问题，即想从几对对应点中计算出最可能的透视变换，则可以使用 getPerspectiveTransform 或 findHomography。

参数

src	输入双通道或三通道浮点数组；每个元素都是要变换的 2D/3D 向量。
dst	与 `src` 相同大小和类型的输出数组。
m	3x3 或 4x4 浮点变换矩阵。

另请参见

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>

计算二维向量的旋转角度。

函数 cv::phase 计算由 x 和 y 的相应元素形成的每个 2D 向量的旋转角度

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

角度估计精度约为 0.3 度。当 x(I)=y(I)=0 时，相应的 angle(I) 设置为 0。

参数

x	输入的二维向量 x 坐标浮点数组。
y	2D 向量 y 坐标的输入数组；它必须与 x 具有相同的大小和类型。
angle	向量角度的输出数组；它与 x 具有相同的大小和类型。
angleInDegrees	当为 true 时，函数以度为单位计算角度，否则以弧度为单位计算。

此函数的调用图如下

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>

根据二维向量的幅度和角度计算其 x 和 y 坐标。

函数 cv::polarToCart 计算由幅度和角度的相应元素表示的每个 2D 向量的笛卡尔坐标

\[\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}\]

估计坐标的相对精度约为 1e-6。

参数

magnitude	2D 向量幅度的浮点输入数组；它可以是一个空矩阵（=Mat()），在这种情况下，函数假定所有幅度都等于 1；如果它不为空，则它必须与 angle 具有相同的大小和类型。
angle	2D 向量角度的浮点输入数组。
x	2D 向量 x 坐标的输出数组；它与 angle 具有相同的大小和类型。
y	2D 向量 y 坐标的输出数组；它与 angle 具有相同的大小和类型。
angleInDegrees	当为 true 时，输入角度以度为单位测量，否则以弧度为单位测量。

另请参见

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>

将每个数组元素提升到指定幂。

函数 cv::pow 将输入数组的每个元素提升到指定幂

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

因此，对于非整数幂指数，使用输入数组元素的绝对值。但是，通过一些额外的操作，可以获得负值的真实值。在下面的示例中，计算数组 src 的 5 次方根显示：

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

对于某些幂值，例如整数值、0.5 和 -0.5，会使用专门的更快速的算法。

特殊值（NaN、Inf）不予处理。

参数

src	输入数组。
power	幂的指数。
dst	与 `src` 相同大小和类型的输出数组。

另请参见

sqrt, exp, log, cartToPolar, polarToCart

PSNR()

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

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

#include <opencv2/core.hpp>

计算峰值信噪比（PSNR）图像质量指标。

此函数计算两个输入数组 src1 和 src2 之间的峰值信噪比（PSNR）图像质量指标，以分贝（dB）为单位。数组必须具有相同的类型。

PSNR 计算如下：

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

其中 R 是深度的最大整数值（例如 CV_8U 数据的情况下为 255），MSE 是两个数组之间的均方误差。

参数

src1	第一个输入数组。
src2	与 src1 大小相同的第二个输入数组。
R	最大像素值（默认为 255）

此函数的调用图如下

randn()

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

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

#include <opencv2/core.hpp>

用正态分布的随机数填充数组。

函数 cv::randn 用指定均值向量和标准差矩阵的正态分布随机数填充矩阵 dst。生成的随机数会被裁剪以适应输出数组数据类型的值范围。

参数

dst	随机数的输出数组；该数组必须预先分配并具有 1 到 4 个通道。
mean	生成的随机数的平均值（期望）。
stddev	生成的随机数的标准差；它可以是向量（在这种情况下，假定为对角标准差矩阵）或方阵。

另请参见

RNG, randu

此函数的调用图如下

randShuffle()

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

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

#include <opencv2/core.hpp>

随机打乱数组元素。

函数 cv::randShuffle 通过随机选择元素对并交换它们来打乱指定的 1D 数组。此类交换操作的数量将是 dst.rows*dst.cols*iterFactor。

参数

dst	输入/输出数值 1D 数组。
iterFactor	确定随机交换操作数量的比例因子（参见下面的详细信息）。
rng	用于打乱的可选随机数生成器；如果为零，则改用 theRNG()。

另请参见

RNG, sort

示例

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>

生成单个均匀分布的随机数或随机数数组。

该函数的非模板变体使用指定范围内的均匀分布随机数填充矩阵 dst

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

参数

dst	随机数的输出数组；该数组必须预先分配。
low	生成的随机数的包含下限。
high	生成的随机数的独占上限。

另请参见

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>

将矩阵降维为向量。

函数 reduce 通过将矩阵行/列视为一组 1D 向量并对这些向量执行指定操作，直到获得单个行/列，从而将矩阵降维为向量。例如，该函数可用于计算栅格图像的水平和垂直投影。在 REDUCE_MAX 和 REDUCE_MIN 的情况下，输出图像应与源图像具有相同的类型。在 REDUCE_SUM、REDUCE_SUM2 和 REDUCE_AVG 的情况下，输出可能具有更大的元素位深度以保持精度。多通道数组也支持这两种缩减模式。

以下代码演示了它在单通道矩阵上的用法。

        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]
         */

以下代码演示了它在双通道矩阵上的用法。

        // 两个通道
        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]
        */

参数

src	输入 2D 矩阵。
dst	输出向量。其大小和类型由 dim 和 dtype 参数定义。
dim	矩阵沿其缩减的维度索引。0 表示将矩阵缩减为单行。1 表示将矩阵缩减为单列。
rtype	缩减操作，可以是 ReduceTypes 之一
dtype	当为负时，输出向量将与输入矩阵具有相同的类型，否则，其类型将为 CV_MAKE_TYPE(CV_MAT_DEPTH(dtype), src.channels())。

另请参见

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>

沿给定轴查找最大元素的索引。

注意

• 如果输入或输出数组不是连续的，此函数将创建一个内部副本。
• NaN 处理未明确指定，请参见 patchNaNs()。
• 返回的索引始终在输入矩阵的边界内。

参数

src	单通道输入数组。
dst	类型为 CV_32SC1 的输出数组，与 src 具有相同的维度，除了被缩减的轴——它应设置为 1。
lastIndex	获取最大值的第一个或最后一个出现位置的索引。
axis（轴）	要沿其缩减的轴。

另请参见

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>

沿给定轴查找最小元素的索引。

注意

• 如果输入或输出数组不是连续的，此函数将创建一个内部副本。
• NaN 处理未明确指定，请参见 patchNaNs()。
• 返回的索引始终在输入矩阵的边界内。

参数

src	单通道输入数组。
dst	类型为 CV_32SC1 的输出数组，与 src 具有相同的维度，除了被缩减的轴——它应设置为 1。
lastIndex	获取最小值的第一个或最后一个出现位置的索引。
axis（轴）	要沿其缩减的轴。

另请参见

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>

这是一个重载成员函数，为方便起见提供。它与上述函数的区别仅在于其接受的参数。

参数

src	要复制的输入数组。
ny	指定 src 沿垂直轴重复次数的标志。
nx	指定 src 沿水平轴重复次数的标志。

此函数的调用图如下

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>

用输入数组的重复副本填充输出数组。

函数 cv::repeat 沿两个轴中的每个轴重复输入数组一次或多次

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

该函数的第二个变体更方便与 MatrixExpressions 一起使用。

参数

src	要复制的输入数组。
ny	指定 src 沿垂直轴重复次数的标志。
nx	指定 src 沿水平轴重复次数的标志。
dst	与 src 类型相同的输出数组。

另请参见

cv::reduce

此函数的调用图如下

rotate()

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

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

#include <opencv2/core.hpp>

将二维数组旋转 90 度的倍数。函数 cv::rotate 以三种不同方式之一旋转数组：顺时针旋转 90 度 (rotateCode = ROTATE_90_CLOCKWISE)。顺时针旋转 180 度 (rotateCode = ROTATE_180)。顺时针旋转 270 度 (rotateCode = ROTATE_90_COUNTERCLOCKWISE)。

参数

src	输入数组。
dst	与 src 类型相同的输出数组。对于 ROTATE_180，大小相同，而对于 ROTATE_90_CLOCKWISE 和 ROTATE_90_COUNTERCLOCKWISE，行和列会互换。
rotateCode	一个枚举，用于指定如何旋转数组；参见枚举 RotateFlags

另请参见

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>

计算缩放数组与另一个数组的和。

函数 scaleAdd 是经典的基本线性代数运算之一，在 BLAS 中称为 DAXPY 或 SAXPY。它计算一个缩放数组与另一个数组的和

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

该函数也可以通过矩阵表达式模拟，例如

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

参数

src1	第一个输入数组。
alpha	第一个数组的比例因子。
src2	与 src1 大小和类型相同的第二个输入数组。
dst	与 src1 大小和类型相同的输出数组。

另请参见

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

此函数的调用图如下

setIdentity()

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

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

#include <opencv2/core.hpp>

初始化一个缩放的单位矩阵。

函数 cv::setIdentity 初始化一个缩放的单位矩阵

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

该函数也可以使用矩阵初始化器和矩阵表达式模拟

Mat A = Mat::eye(4, 3, CV_32F)*5;
// A 将被设置为 [[5, 0, 0], [0, 5, 0], [0, 0, 5], [0, 0, 0]]

参数

makePtr()	要初始化的矩阵（不一定是方阵）。
s	赋给对角线元素的值。

另请参见

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

此函数的调用图如下

setRNGSeed()

void cv::setRNGSeed

(

int

seed

)

Python
	cv.setRNGSeed(	seed	) ->	无

#include <opencv2/core.hpp>

设置默认随机数生成器的状态。

函数 cv::setRNGSeed 将默认随机数生成器的状态设置为自定义值。

参数

seed	默认随机数生成器的新状态

另请参见

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>

求解一个或多个线性系统或最小二乘问题。

函数 cv::solve 解决线性系统或最小二乘问题（后者可通过 SVD 或 QR 方法，或通过指定标志 DECOMP_NORMAL 来实现）

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

如果使用 DECOMP_LU 或 DECOMP_CHOLESKY 方法，则当 src1 (或 \(\texttt{src1}^T\texttt{src1}\) ) 非奇异时，函数返回 1。否则，返回 0。在这种情况下，dst 无效。其他方法在左侧部分奇异的情况下找到伪解。

注意

如果您想找到欠定奇异系统 \(\texttt{src1}\cdot\texttt{dst}=0\) 的单位范数解，则 solve 函数无法完成此工作。请改用 SVD::solveZ。

参数

src1	系统左侧的输入矩阵。
src2	系统右侧的输入矩阵。
dst	输出解。
flags	解（矩阵求逆）方法（DecompTypes）

另请参见

invert, SVD, eigen

此函数的调用图如下

solveCubic()

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

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

#include <opencv2/core.hpp>

查找三次方程的实根。

函数 solveCubic 查找三次方程的实数根

• 如果 coeffs 是一个 4 元素向量

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

• 如果 coeffs 是一个 3 元素向量

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

根存储在roots数组中。

参数

coeffs	方程系数，一个包含 3 或 4 个元素的数组。
roots	实数根的输出数组，包含 0、1、2 或 3 个元素。

返回

实数根的数量。它可以是 -1（所有实数）、0、1、2 或 3。

此函数的调用图如下

solvePoly()

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

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

#include <opencv2/core.hpp>

查找多项式方程的实根或复根。

函数 cv::solvePoly 查找多项式方程的实数根和复数根

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

参数

coeffs	多项式系数数组。
roots	（复数）根的输出数组。
maxIters	算法执行的最大迭代次数。

此函数的调用图如下

sort()

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

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

#include <opencv2/core.hpp>

对矩阵的每行或每列进行排序。

函数 cv::sort 对矩阵的每一行或每一列进行升序或降序排序。因此，您应该传递两个操作标志以获得所需行为。如果您想按字典顺序对矩阵行或列进行排序，可以使用带有适当比较谓词的 STL std::sort 泛型函数。

参数

src	单通道输入数组。
dst	与 `src` 相同大小和类型的输出数组。
flags	操作标志，是 SortFlags 的组合

另请参见

sortIdx, randShuffle

此函数的调用图如下

sortIdx()

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

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

#include <opencv2/core.hpp>

对矩阵的每行或每列进行排序。

函数 cv::sortIdx 对矩阵的每一行或每一列进行升序或降序排序。因此，您应该传递两个操作标志以获得所需行为。它不是重新排列元素本身，而是将排序元素的索引存储在输出数组中。例如

Mat A = Mat::eye(3,3,CV_32F), B;
sortIdx(A, B, SORT_EVERY_ROW + SORT_ASCENDING);
// B 将可能包含
// (由于 A 中元素相等，可能存在一些排列)
// [[1, 2, 0], [0, 2, 1], [0, 1, 2]]

参数

src	单通道输入数组。
dst	与 src 大小相同的整数输出数组。
flags	操作标志，可以是 cv::SortFlags 的组合

另请参见

sort, randShuffle

此函数的调用图如下

split() [1/2]

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

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

#include <opencv2/core.hpp>

将多通道数组分割为多个单通道数组。

函数 cv::split 将多通道数组分割成单独的单通道数组

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

如果您需要提取单个通道或进行其他复杂的通道置换，请使用 mixChannels。

以下示例演示如何将 3 通道矩阵分割成 3 个单通道矩阵。

    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]
    */

参数

src	输入多通道数组。
mvbegin	输出数组；数组数量必须与 src.channels() 匹配；如果需要，数组本身会被重新分配。

另请参见

merge, mixChannels, cvtColor

此函数的调用图如下

split() [2/2]

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

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

#include <opencv2/core.hpp>

这是一个重载成员函数，为方便起见提供。它与上述函数的区别仅在于其接受的参数。

参数

m	输入多通道数组。
mv	输出数组向量；如果需要，数组本身会被重新分配。

此函数的调用图如下

sqrt()

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

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

#include <opencv2/core.hpp>

计算数组元素的平方根。

函数 cv::sqrt 计算输入数组每个元素的平方根。对于多通道数组，每个通道独立处理。精度与内置的 std::sqrt 大致相同。

参数

src	输入浮点数组。
dst	与 `src` 相同大小和类型的输出数组。

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>

计算两个数组或数组与标量之间的逐元素差。

函数 subtract 计算

• 两个数组之间的差，当两个输入数组具有相同大小和相同通道数时

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

• 数组与标量之间的差，当 src2 由 Scalar 构造或具有与 src1.channels() 相同数量的元素时

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

• 标量与数组之间的差，当 src1 由 Scalar 构造或具有与 src2.channels() 相同数量的元素时

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

• 在 SubRS 的情况下，标量与数组之间的反向差

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

  其中 I 是数组元素的（多维）索引。在多通道数组的情况下，每个通道独立处理。

列表中第一个函数可以用矩阵表达式替换

dst = src1 - src2;
dst -= src1; // 等同于 subtract(dst, src1, dst);

输入数组和输出数组可以具有相同或不同的深度。例如，您可以将 8 位无符号数组相减并将差值存储在 16 位有符号数组中。输出数组的深度由 dtype 参数决定。在上述第二种和第三种情况以及第一种情况中，当 src1.depth() == src2.depth() 时，dtype 可以设置为默认值 -1。在这种情况下，输出数组将与输入数组（无论是 src1、src2 还是两者）具有相同的深度。

注意

当输出数组深度为 CV_32S 时，不应用饱和。在溢出情况下，甚至可能得到不正确的符号结果。

(Python) 请注意 src1/src2 为单个数字与它们为元组/数组时的行为差异。subtract(src,X) 意味着 subtract(src,(X,X,X,X))。subtract(src,(X,)) 意味着 subtract(src,(X,0,0,0))。

参数

src1	第一个输入数组或标量。
src2	第二个输入数组或标量。
dst	与输入数组具有相同大小和相同通道数的输出数组。
mask	可选操作掩码；这是一个 8 位单通道数组，用于指定要更改的输出数组元素。
dtype	输出数组的可选深度

另请参见

add, addWeighted, scaleAdd, Mat::convertTo

此函数的调用图如下

sum()

Scalar cv::sum

(

InputArray

src

)

Python
	cv.sumElems(	src	) ->	retval

#include <opencv2/core.hpp>

计算数组元素的和。

函数 cv::sum 计算并返回数组元素的总和，每个通道独立计算。

参数

src	输入数组，必须有 1 到 4 个通道。

另请参见

countNonZero, mean, meanStdDev, norm, minMaxLoc, reduce

示例

samples/dnn/classification.cpp.

此函数的调用图如下

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>

交换两个矩阵。

示例

samples/cpp/lkdemo.cpp.

swap() [2/2]

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

#include <opencv2/core.hpp>

这是一个重载成员函数，为方便起见提供。它与上述函数的区别仅在于其接受的参数。

theRNG()

RNG & cv::theRNG

(

)

#include <opencv2/core.hpp>

返回默认的随机数生成器。

函数 cv::theRNG 返回默认的随机数生成器。每个线程都有一个独立的随机数生成器，因此您可以在多线程环境中安全地使用此函数。如果您只需要使用此生成器获取单个随机数或初始化数组，可以使用 randu 或 randn 代替。但是，如果您打算在循环中生成许多随机数，则使用此函数检索生成器，然后使用 RNG::operator _Tp() 会快得多。

另请参见

RNG, randu, randn

此函数的调用图如下

trace()

Scalar cv::trace

(

InputArray

makePtr()

)

Python
	由  1.12.0 生成于 2025年7月3日 星期四 12:14:36，面向 OpenCV	makePtr()	) ->	retval

#include <opencv2/core.hpp>

返回矩阵的迹。

函数 cv::trace 返回矩阵 mtx 对角线元素的和。

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

参数

makePtr()

输入矩阵。

此函数的调用图如下

transform()

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

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

#include <opencv2/core.hpp>

对每个数组元素执行矩阵变换。

函数 cv::transform 对数组 src 的每个元素执行矩阵变换，并将结果存储在 dst 中

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

（当 m.cols=src.channels() 时），或

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

（当 m.cols=src.channels()+1 时）

N通道数组 src 的每个元素都被解释为 N 元素向量，该向量使用 M x N 或 M x (N+1) 矩阵 m 变换为 M 元素向量——即输出数组 dst 的相应元素。

该函数可用于 N 维点的几何变换、任意线性色彩空间变换（例如各种 RGB 到 YUV 变换）、图像通道的重排等等。

参数

src	输入数组，其通道数（1 到 4）必须与 m.cols 或 m.cols-1 相同。
dst	输出数组，与 src 具有相同的大小和深度；其通道数与 m.rows 相同。
m	变换矩阵，2x2 或 2x3 浮点矩阵。

另请参见

perspectiveTransform, getAffineTransform, estimateAffine2D, warpAffine, warpPerspective

此函数的调用图如下

transpose()

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

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

#include <opencv2/core.hpp>

转置矩阵。

函数 cv::transpose 转置矩阵 src

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

注意

对于复数矩阵，不执行复共轭。如果需要，应单独执行。

参数

src	输入数组。
dst	与 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>

n维矩阵的转置。

注意

输入应为连续的单通道矩阵。

参数

src	输入数组。
order	一个 [0,1,..,N-1] 的排列，其中 N 是 src 的轴数。dst 的第 i 个轴将对应于输入的 order[i] 编号的轴。
dst	与 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>

对给定矩阵执行垂直连接。

此函数将两个或更多 cv::Mat 矩阵垂直连接（它们必须具有相同的列数）。

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 );
// 输出
//[1,   1,   1,   1;
// 2,   2,   2,   2;
// 3,   3,   3,   3]

参数

src	输入数组或矩阵向量。所有矩阵必须具有相同的列数和相同的深度。
nsrc	src 中的矩阵数量。
dst	输出数组。它与 src 具有相同的列数和深度，行数是 src 的行数之和。

另请参见

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

cv::hconcat(InputArrayOfArrays, OutputArray) 和

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>

这是一个重载成员函数，为方便起见提供。它与上述函数的区别仅在于其接受的参数。

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]

参数

src1	第一个用于垂直连接的输入数组。
src2	第二个用于垂直连接的输入数组。
dst	输出数组。它与 src1 和 src2 具有相同的列数和深度，行数是 src1 和 src2 行数之和。

此函数的调用图如下

vconcat() [3/3]

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

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

#include <opencv2/core.hpp>

这是一个重载成员函数，为方便起见提供。它与上述函数的区别仅在于其接受的参数。

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 );
// 输出
//[1,   1,   1,   1;
// 2,   2,   2,   2;
// 3,   3,   3,   3]

参数

src	输入数组或矩阵向量。所有矩阵必须具有相同的列数和相同的深度。
dst	输出数组。它与 src 具有相同的列数和深度，行数是 src 的行数之和。深度相同。

此函数的调用图如下