数组操作

详细说明

类
类	cv::LDA
	线性判别分析。 更多...
类	cv::PCA
	主成分分析。 更多...
类	cv::RNG
	随机数生成器。 更多...
类	cv::RNG_MT19937
	梅森旋转算法随机数生成器。 更多...
类	cv::SVD
	奇异值分解。 更多...

枚举
enum	cv::BorderTypes {   cv::BORDER_CONSTANT = 0 ,   cv::BORDER_REPLICATE = 1 ,   cv::BORDER_REFLECT = 2 ,   cv::BORDER_WRAP = 3 ,   cv::BORDER_REFLECT_101 = 4 ,   cv::BORDER_TRANSPARENT = 5 ,   cv::BORDER_REFLECT101 = BORDER_REFLECT_101 ,   cv::BORDER_DEFAULT = BORDER_REFLECT_101 ,   cv::BORDER_ISOLATED = 16 }
enum	cv::CmpTypes {   cv::CMP_EQ = 0 ,   cv::CMP_GT = 1 ,   cv::CMP_GE = 2 ,   cv::CMP_LT = 3 ,   cv::CMP_LE = 4 ,   cv::CMP_NE = 5 }
	比较类型 更多...
enum	cv::CovarFlags {   cv::COVAR_SCRAMBLED = 0 ,   cv::COVAR_NORMAL = 1 ,   cv::COVAR_USE_AVG = 2 ,   cv::COVAR_SCALE = 4 ,   cv::COVAR_ROWS = 8 ,   cv::COVAR_COLS = 16 }
	协方差标志。 更多...
enum	cv::DecompTypes {   cv::DECOMP_LU = 0 ,   cv::DECOMP_SVD = 1 ,   cv::DECOMP_EIG = 2 ,   cv::DECOMP_CHOLESKY = 3 ,   cv::DECOMP_QR = 4 ,   cv::DECOMP_NORMAL = 16 }
	矩阵分解类型 更多...
enum	cv::DftFlags {   cv::DFT_INVERSE = 1 ,   cv::DFT_SCALE = 2 ,   cv::DFT_ROWS = 4 ,   cv::DFT_COMPLEX_OUTPUT = 16 ,   cv::DFT_REAL_OUTPUT = 32 ,   cv::DFT_COMPLEX_INPUT = 64 ,   cv::DCT_INVERSE = DFT_INVERSE ,   cv::DCT_ROWS = DFT_ROWS }
enum	cv::GemmFlags {   cv::GEMM_1_T = 1 ,   cv::GEMM_2_T = 2 ,   cv::GEMM_3_T = 4 }
	广义矩阵乘法标志 更多...
enum	cv::NormTypes {   cv::NORM_INF = 1 ,   cv::NORM_L1 = 2 ,   cv::NORM_L2 = 4 ,   cv::NORM_L2SQR = 5 ,   cv::NORM_HAMMING = 6 ,   cv::NORM_HAMMING2 = 7 ,   cv::NORM_TYPE_MASK = 7 ,   cv::NORM_RELATIVE = 8 ,   cv::NORM_MINMAX = 32 }
enum	cv::ReduceTypes {   cv::REDUCE_SUM = 0 ,   cv::REDUCE_AVG = 1 ,   cv::REDUCE_MAX = 2 ,   cv::REDUCE_MIN = 3 ,   cv::REDUCE_SUM2 = 4 }
enum	cv::RotateFlags {   cv::ROTATE_90_CLOCKWISE = 0 ,   cv::ROTATE_180 = 1 ,   cv::ROTATE_90_COUNTERCLOCKWISE = 2 }

函数
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)
	计算二维向量的幅值和角度。
bool	cv::checkRange (InputArray a, bool quiet=true, Point *pos=0, double minVal=-DBL_MAX, double maxVal=DBL_MAX)
	检查输入数组中的每个元素是否含有无效值。
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)
	将数组转换为半精度浮点数。
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())
	在图像周围形成边框。
void	cv::copyTo (InputArray src, OutputArray dst, InputArray mask)
	这是一个重载的成员函数，为了方便 (python) 提供。将矩阵复制到另一个矩阵。指定操作掩码时，如果上述 Mat::create 调用重新分配了矩阵，则新分配的矩阵在复制数据前会被初始化为全零。
int	cv::countNonZero (InputArray src)
	统计非零数组元素的数量。
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)
	沿垂直轴、水平轴或双轴翻转二维数组。
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)

枚举类型文档 (Enumeration Type Documentation)

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

枚举值 (Enumerator)
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>

比较类型

枚举值 (Enumerator)
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>

协方差标志。

枚举值 (Enumerator)
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（例如，用于人脸识别的特征脸技术）。该“打乱”矩阵的特征值与真实协方差矩阵的特征值相匹配。可以通过“打乱”协方差矩阵的特征向量轻松计算出“真实”特征向量。
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 将是一个方阵，其大小与每个输入向量中的元素总数相同。必须指定 COVAR_SCRAMBLED 或 COVAR_NORMAL 中的一种且仅能指定一种。
COVAR_USE_AVG  Python: cv.COVAR_USE_AVG	如果指定该标志，函数将不从输入向量计算均值，而是使用传入的均值向量。如果均值已预先计算、已知，或者需要分批计算协方差矩阵，这将非常有用。在这种情况下，mean 不是输入向量子集的均值向量，而是整个集合的均值向量。
COVAR_SCALE  Python: cv.COVAR_SCALE	如果指定该标志，协方差矩阵将被缩放。在“普通”模式下，scale 为 1./nsamples。在“打乱”模式下，scale 为每个输入向量中元素总数的倒数。默认情况下（如果不指定该标志），协方差矩阵不进行缩放 (scale=1)。
COVAR_ROWS  Python: cv.COVAR_ROWS	如果指定该标志，所有输入向量都作为 samples 矩阵的行存储。在这种情况下，mean 应该是一个单行向量。
COVAR_COLS  Python: cv.COVAR_COLS	如果指定该标志，所有输入向量都作为 samples 矩阵的列存储。在这种情况下，mean 应该是一个单列向量。

DecompTypes

枚举 cv::DecompTypes

#include <opencv2/core/base.hpp>

矩阵分解类型

枚举值 (Enumerator)
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>

枚举值 (Enumerator)
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>

广义矩阵乘法标志

枚举值 (Enumerator)
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 表示输入数组。

枚举值 (Enumerator)
NORM_INF  Python: cv.NORM_INF	\[ norm = \forkthree {\|\texttt{src1}\|_{L_{\infty}} = \max _I | \texttt{src1} (I)|}{如果 \(\texttt{normType} = \texttt{NORM_INF}\) } {\|\texttt{src1}-\texttt{src2}\|_{L_{\infty}} = \max _I | \texttt{src1} (I) - \texttt{src2} (I)|}{如果 \(\texttt{normType} = \texttt{NORM_INF}\) } {\frac{\|\texttt{src1}-\texttt{src2}\|_{L_{\infty}} }{\|\texttt{src2}\|_{L_{\infty}} }}{如果 \(\texttt{normType} = \texttt{NORM_RELATIVE | NORM_INF}\) } \]
NORM_L1  Python: cv.NORM_L1	\[ norm = \forkthree {\| \texttt{src1} \| _{L_1} = \sum _I | \texttt{src1} (I)|}{如果 \(\texttt{normType} = \texttt{NORM_L1}\)} { \| \texttt{src1} - \texttt{src2} \| _{L_1} = \sum _I | \texttt{src1} (I) - \texttt{src2} (I)|}{如果 \(\texttt{normType} = \texttt{NORM_L1}\) } { \frac{\|\texttt{src1}-\texttt{src2}\|_{L_1} }{\|\texttt{src2}\|_{L_1}} }{如果 \(\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} }{如果 \(\texttt{normType} = \texttt{NORM_L2}\) } { \| \texttt{src1} - \texttt{src2} \| _{L_2} = \sqrt{\sum_I (\texttt{src1}(I) - \texttt{src2}(I))^2} }{如果 \(\texttt{normType} = \texttt{NORM_L2}\) } { \frac{\|\texttt{src1}-\texttt{src2}\|_{L_2} }{\|\texttt{src2}\|_{L_2}} }{如果 \(\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} {如果 \(\texttt{normType} = \texttt{NORM_L2SQR}\)} { \| \texttt{src1} - \texttt{src2} \| _{L_2} ^{2} = \sum_I (\texttt{src1}(I) - \texttt{src2}(I))^2 }{如果 \(\texttt{normType} = \texttt{NORM_L2SQR}\) } { \left(\frac{\|\texttt{src1}-\texttt{src2}\|_{L_2} }{\|\texttt{src2}\|_{L_2}}\right)^2 }{如果 \(\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	标志
NORM_MINMAX  Python: cv.NORM_MINMAX	标志

ReduceTypes

枚举 cv::ReduceTypes

#include <opencv2/core.hpp>

枚举值 (Enumerator)
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>

枚举值 (Enumerator)
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 度。

函数文档 (Function Documentation)

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

当第二个数组由标量构造，或者其元素数量与 src1 的通道数相同时，计算数组与标量之间的绝对差值

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

当第一个数组由标量构造，或者其元素数量与 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{如果 mask}(I) \ne0\]

• 当 src2 由标量构造，或者其元素数量与 src1.channels() 相同时，计算数组与标量之和

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

• 当 src1 由标量构造，或者其元素数量与 src2.channels() 相同时，计算标量与数组之和

  \[\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1} + \texttt{src2}(I) ) \quad \texttt{如果 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	距离,
		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

待办

文档

此函数的调用图

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）。
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）。
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>

计算二维向量的幅值和角度。

函数 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>

检查输入数组中的每个元素是否含有无效值。

函数 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)\]

当比较结果为 true 时，输出数组的相应元素设置为 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 将方阵的下半部分或上半部分复制到另一半。矩阵对角线保持不变

• 如果 lowerToUpper=false，则对于 \(i > j\)，\(\texttt{m}_{ij}=\texttt{m}_{ji}\)
• 如果 lowerToUpper=true，则对于 \(i < j\)，\(\texttt{m}_{ij}=\texttt{m}_{ji}\)

参数

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

另请参阅

flip, transpose

此函数的调用图

convertFp16()

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

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

#include <opencv2/core.hpp>

将数组转换为半精度浮点数。

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

参数

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

已弃用

请改用带 CV_16F 的 Mat::convertTo。

此函数的调用图

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) 也能完成任务，
// 但它会分配一个临时矩阵

参数

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

另请参阅

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

此函数的调用图

copyMakeBorder()

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

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

#include <opencv2/core.hpp>

在图像周围形成边框。

该函数将源图像复制到目标图像的中间。复制后的源图像左侧、右侧、上方和下方的区域将用外推像素填充。这与基于它的滤波函数所做的不同（它们是动态外推像素），但其他更复杂的函数（包括你自己的函数）可能会这样做，以简化图像边界处理。

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

// 假设所有方向的边界都相同
int border=2;
// 构建一个更大的图像以容纳图像和边界
Mat gray_buf(rgb.rows + border*2, rgb.cols + border*2, rgb.depth());
// 选择其中的中间部分而不复制数据
Mat gray(gray_canvas, Rect(border, border, rgb.cols, rgb.rows));
// 将图像从 RGB 转换为灰度
cvtColor(rgb, gray, COLOR_RGB2GRAY);
// 就地形成边界
copyMakeBorder(gray, gray_buf, border, border,
border, border, BORDER_REPLICATE);
// 现在进行一些自定义滤波 ...
...

注意

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

参数

src	源图像。
dst	与 src 类型相同且大小为 Size(src.cols+left+right, src.rows+top+bottom) 的目标图像。
top (上)	顶部像素
bottom (下)	底部像素
left (左)	左侧像素
right (右)	指定在源图像矩形的每个方向上外推多少个像素的参数。例如，top=1, bottom=1, left=1, right=1 意味着需要构建 1 像素宽的边界。
borderType	边界类型。详情请参阅 borderInterpolate。
value (值)	如果 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 类型，并且可以有一个或多个通道。

此函数的调用图

countNonZero()

int cv::countNonZero

(

InputArray

src

)

Python
	cv.countNonZero(	src	) ->	retval

#include <opencv2/core.hpp>

统计非零数组元素的数量。

该函数返回 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 )\]

  且当 j > 0 时，\(\alpha_0=1\)，\(\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

mtx (矩阵)

)

Python
	cv.determinant(	mtx (矩阵)	) ->	retval

#include <opencv2/core.hpp>

返回浮点方阵的行列式。

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

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

参数

mtx (矩阵)

输入矩阵，必须具有 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 中实现。因此，通过使用它们，您可以获得比上述理论上最佳实现更好的性能。虽然这两个函数实际上计算的是互相关（cross-correlation），而不是卷积，所以您需要使用 flip 将第二个卷积操作数 B 垂直和水平翻转。

注意

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

参数

src	输入数组，可以是实数或复数。
dst	输出数组，其大小和类型取决于标志。
flags (标志)	变换标志，代表 DftFlags 的组合
nonzeroRows (非零行数)	当该参数不为零时，函数假定只有输入数组的前 nonzeroRows 行（未设置 DFT_INVERSE）或只有输出数组的前 nonzeroRows 行（设置了 DFT_INVERSE）包含非零值，因此，函数可以更高效地处理其余行并节省时间；这种技术对于使用 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>

沿垂直轴、水平轴或双轴翻转二维数组。

函数 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* OS 上视频处理中的典型操作。水平翻转图像，随后进行水平位移和绝对差计算，以检查垂直轴对称性（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 第 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 的幂 (2, 4, 8, 16, 32, ...) 的数组处理速度最快。此外，大小为 2、3 和 5 的乘积（例如 300 = 5*5*3*2*2）的数组处理效率也相当高。

函数 cv::getOptimalDFTSize 返回大于或等于 vecsize 的最小整数 N，以便能高效处理大小为 N 的向量的 DFT。在当前实现中，对于某些整数 p, q, r，N = 2 ^p^ * 3 ^q^ * 5 ^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 );
//输出 (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) 以及

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 );
//输出 (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 或 idft 之一传递 DFT_SCALE，以使这些变换互为逆变换。

另请参阅

dft, dct, idct, mulSpectrums, getOptimalDFTSize

参数

src	输入浮点型实数或复数数组。
dst	输出数组，其尺寸和类型取决于标志（flags）。
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) 在指定的 1D, 2D, 3D, ... 盒子内，则 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 = \forkthree{0}{如果 \(\texttt{src}\) 深度为 \(\texttt{CV_8U}\) 或 \(\texttt{CV_16U}\)}{128}{如果 \(\texttt{src}\) 深度为 \(\texttt{CV_8S}\)}{32768}{如果 \(\texttt{src}\) 深度为 \(\texttt{CV_16S}\)}\]

参数

src	8位或16位整数元素的输入数组。
lut	具有 256 个元素（如果 src 深度为 CV_8U 或 CV_8S）或 65536 个元素（如果 src 深度为 CV_16U 或 CV_16S）的查找表；如果是多通道输入数组，该表应为单通道（此时所有通道使用同一张表）或与输入数组具有相同数量的通道。
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	v1,
		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 方法，因为它是最准确的）。

参数

v1	第一个一维输入向量。
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,
		double *	minVal,
		double *	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	指向返回最小值位置（nD 情况下）的指针；如果不需要则使用 NULL；否则，它必须指向一个具有 src.dims 个元素的数组，每个维度中最小元素的坐标将按顺序存储在那里。
maxIdx	指向返回最大值位置（nD 情况下）的指针。如果不需要则使用 NULL。
mask	指定的数组区域

此函数的调用图

minMaxLoc() [1/2]

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

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

#include <opencv2/core.hpp>

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

参数

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

此函数的调用图

minMaxLoc() [2/2]

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

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

#include <opencv2/core.hpp>

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

函数 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 格式包（CCS-packed）或复数矩阵执行逐元素乘法，这些矩阵是实数或复数傅里叶变换的结果。

该函数与 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 为零时，它可以作为当 B=A' 时通用矩阵乘积 A*B 的更快替代方案。

参数

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	normType )

Python
	cv.norm(	src1[, normType[, mask]]	) ->	retval
	cv.norm(	src1, src2[, normType[, mask]]	) ->	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
	cv.norm(	src1[, normType[, mask]]	) ->	retval
	cv.norm(	src1, src2[, normType[, mask]]	) ->	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
	cv.norm(	src1[, normType[, mask]]	) ->	retval
	cv.norm(	src1, src2[, normType[, mask]]	) ->	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}\) 的所有值。值得注意的是，对于示例函数 \( r(x) \)，\( L_{1} \) 范数形成了上限，而 \( 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	normType )

Python
	cv.normalize(	src, dst[, alpha[, beta[, norm_type[, dtype[, mask]]]]]	) ->	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
	cv.normalize(	src, dst[, alpha[, beta[, norm_type[, dtype[, mask]]]]]	) ->	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 指定要归一化的子数组。这意味着范数或最小值/最大值是根据该子数组计算的，然后修改该子数组以进行归一化。如果您只想使用掩码来计算范数或最小最大值，但修改整个数组，您可以使用 norm 和 Mat::convertTo。

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

使用一些正数示例数据的可能用法

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（非数字值）替换为指定值。

此函数原位（in-place）修改输入矩阵。输入矩阵必须是 CV_32F 或 CV_64F 类型；不支持其他类型。

参数

a	输入/输出矩阵 (CV_32F 或 CV_64F 类型)。
val	用于替换 NaN 的值（默认为 0）。

此函数的调用图

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() 并增加 eigenvalues 输出参数

此函数的调用图

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() 并增加 eigenvalues 输出参数

此函数的调用图

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'}{如果 \(w' \ne 0\)}{\infty}{否则}\]

此处显示的是 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 对应元素构成的每个二维向量的旋转角度

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

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

参数

x	二维向量 x 坐标的输入浮点数组。
y	二维向量 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 计算由对应 magnitude 和 angle 元素表示的每个二维向量的笛卡尔坐标

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

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

参数

magnitude (幅度)	二维向量幅值的输入浮点数组；它可以是一个空矩阵 (=Mat())，在这种情况下，函数假设所有幅值均为 1；如果不为空，它必须与 angle 具有相同的尺寸和类型。
angle (角度)	二维向量角度的输入浮点数组。
x	二维向量 x 坐标的输出数组；它与 angle 具有相同的尺寸和类型。
y	二维向量 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}}{如果 \(\texttt{power}\) 是整数}{|\texttt{src}(I)|^{power}}{否则}\]

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

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

对于某些 power 值，如整数、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) } \text{ (dB)} \]

其中 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 通过随机选择元素对并交换它们来打乱指定的一维数组。此类交换操作的数量将为 dst.rows*dst.cols*iterFactor。

参数

dst	输入/输出数值型一维数组。
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 通过将矩阵行/列视为一组一维向量，并在这些向量上执行指定操作，直到获得单行/列，从而将矩阵归约为向量。例如，该函数可用于计算光栅图像的水平和垂直投影。在 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 相同的维数，除了被缩减的轴（axis）——该轴应设置为 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 相同的维数，除了被缩减的轴（axis）——该轴应设置为 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	mtx (矩阵),
		const Scalar &	s = Scalar(1) )

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

#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]]

参数

mtx (矩阵)	待初始化的矩阵（不一定是方阵）。
s	分配给对角线元素的值。

另请参阅

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

此函数的调用图

setRNGSeed()

void cv::setRNGSeed

(

int

seed

)

Python
	cv.setRNGSeed(	seed	) ->	None

#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>

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

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

mtx (矩阵)

)

Python
	cv.trace(	mtx (矩阵)	) ->	retval

#include <opencv2/core.hpp>

返回矩阵的迹。

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

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

参数

mtx (矩阵)

输入矩阵。

此函数的调用图

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

参数

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

此函数的调用图