数组操作

详细描述

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

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

函数
void	cv::absdiff (InputArray src1, InputArray src2, OutputArray dst)
	计算两个数组之间或数组与标量之间的逐元素绝对差。
void	cv::add (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray(), int dtype=-1)
	计算两个数组或数组与标量的逐元素和。
void	cv::addWeighted (InputArray src1, double alpha, InputArray src2, double beta, double gamma, OutputArray dst, int dtype=-1)
	计算两个数组的加权和。
void	cv::batchDistance (InputArray src1, InputArray src2, OutputArray dist, int dtype, OutputArray nidx, int normType=NORM_L2, int K=0, InputArray mask=noArray(), int update=0, bool crosscheck=false)
	最近邻查找器
void	cv::bitwise_and (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray())
	计算两个数组的按位与运算 (dst = src1 & src2)。计算两个数组或数组与标量的逐元素按位与运算。
void	cv::bitwise_not (InputArray src, OutputArray dst, InputArray mask=noArray())
	反转数组的每一位。
void	cv::bitwise_or (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray())
	计算两个数组或数组与标量的逐元素按位或运算。
void	cv::bitwise_xor (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray())
	计算两个数组或数组与标量的逐元素按位异或运算。
int	cv::borderInterpolate (int p, int len, int borderType)
	计算外推像素的源位置。
void	cv::broadcast (InputArray src, InputArray shape, OutputArray dst)
	将给定的 Mat 广播到给定的形状。
void	cv::calcCovarMatrix (const Mat *samples, int nsamples, Mat &covar, Mat &mean, int flags, int ctype=6)
	计算一组向量的协方差矩阵。
void	cv::calcCovarMatrix (InputArray samples, OutputArray covar, InputOutputArray mean, int flags, int ctype=6)
void	cv::cartToPolar (InputArray x, InputArray y, OutputArray magnitude, OutputArray angle, bool angleInDegrees=false)
	计算二维向量的幅度和角度。
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)。逆时针旋转90度 (rotateCode = ROTATE_90_COUNTERCLOCKWISE)。
void	cv::scaleAdd (InputArray src1, double alpha, InputArray src2, OutputArray dst)
	计算缩放后的数组与另一个数组的和。
void	cv::setIdentity (InputOutputArray mtx, const Scalar &s=Scalar(1))
	初始化一个缩放后的单位矩阵。
void	cv::setRNGSeed (int seed)
	设置默认随机数生成器的状态。
bool	cv::solve (InputArray src1, InputArray src2, OutputArray dst, int flags=DECOMP_LU)
	求解一个或多个线性系统或最小二乘问题。
int	cv::solveCubic (InputArray coeffs, OutputArray roots)
	查找三次方程的实根。
double	cv::solvePoly (InputArray coeffs, OutputArray roots, int maxIters=300)
	查找多项式方程的实根或复根。
void	cv::sort (InputArray src, OutputArray dst, int flags)
	对矩阵的每一行或每一列进行排序。
void	cv::sortIdx (InputArray src, OutputArray dst, int flags)
	对矩阵的每一行或每一列进行排序。
void	cv::split (const Mat &src, Mat *mvbegin)
	将多通道数组分割成多个单通道数组。
void	cv::split (InputArray m, OutputArrayOfArrays mv)
void	cv::sqrt (InputArray src, OutputArray dst)
	计算数组元素的平方根。
void	cv::subtract (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray(), int dtype=-1)
	计算两个数组或数组和标量之间的逐元素差。
Scalar	cv::sum (InputArray src)
	计算数组元素的和。
void	cv::SVBackSubst (InputArray w, InputArray u, InputArray vt, InputArray rhs, OutputArray dst)
void	cv::SVDecomp (InputArray src, OutputArray w, OutputArray u, OutputArray vt, int flags=0)
void	cv::swap (Mat &a, Mat &b)
	交换两个矩阵。
void	cv::swap (UMat &a, UMat &b)
RNG &	cv::theRNG ()
	返回默认的随机数生成器。
Scalar	cv::trace (InputArray mtx)
	返回矩阵的迹。
void	cv::transform (InputArray src, OutputArray dst, InputArray m)
	执行每个数组元素的矩阵变换。
void	cv::transpose (InputArray src, OutputArray dst)
	转置矩阵。
void	cv::transposeND (InputArray src, const std::vector< int > &order, OutputArray dst)
	n维矩阵的转置。
void	cv::vconcat (const Mat *src, size_t nsrc, OutputArray dst)
	将给定的矩阵进行垂直拼接。
void	cv::vconcat (InputArray src1, InputArray src2, OutputArray dst)
void	cv::vconcat (InputArrayOfArrays src, OutputArray dst)

枚举类型文档

BorderTypes

枚举 cv::BorderTypes

#include <opencv2/core/base.hpp>

各种边界类型，图像边界用|表示

参见

borderInterpolate, copyMakeBorder

枚举值
BORDER_CONSTANT  Python: cv.BORDER_CONSTANT	iiiiii|abcdefgh|iiiiiii 其中i为指定值
BORDER_REPLICATE  Python: cv.BORDER_REPLICATE	aaaaaa|abcdefgh|hhhhhhh
BORDER_REFLECT  Python: cv.BORDER_REFLECT	fedcba|abcdefgh|hgfedcb
BORDER_WRAP  Python: cv.BORDER_WRAP	cdefgh|abcdefgh|abcdefg
BORDER_REFLECT_101  Python: cv.BORDER_REFLECT_101	gfedcb|abcdefgh|gfedcba
BORDER_TRANSPARENT  Python: cv.BORDER_TRANSPARENT	uvwxyz|abcdefgh|ijklmno - 将异常值视为透明。
BORDER_REFLECT101  Python: cv.BORDER_REFLECT101	与BORDER_REFLECT_101相同
BORDER_DEFAULT  Python: cv.BORDER_DEFAULT	与BORDER_REFLECT_101相同
BORDER_ISOLATED  Python: cv.BORDER_ISOLATED	插值限制在ROI边界内。

CmpTypes

枚举 cv::CmpTypes

#include <opencv2/core/base.hpp>

比较类型

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

CovarFlags

枚举 cv::CovarFlags

#include <opencv2/core.hpp>

协方差标志。

枚举值
COVAR_SCRAMBLED  Python: cv.COVAR_SCRAMBLED	输出协方差矩阵计算如下： $$\mathtt{\text{scale}}\cdot [\mathtt{\text{vects}}[0]-\mathtt{\text{mean}},\mathtt{\text{vects}}[1]-\mathtt{\text{mean}},...{]}^T\cdot [\mathtt{\text{vects}}[0]-\mathtt{\text{mean}},\mathtt{\text{vects}}[1]-\mathtt{\text{mean}},...],$$ 协方差矩阵将为nsamples x nsamples。这种不寻常的协方差矩阵用于对一组非常大的向量进行快速PCA（例如，参见用于人脸识别的EigenFaces技术）。这个“扰乱”矩阵的特征值与真实协方差矩阵的特征值匹配。“真实”特征向量可以很容易地从“扰乱”协方差矩阵的特征向量计算出来。
COVAR_NORMAL  Python: cv.COVAR_NORMAL	输出协方差矩阵计算如下： $$\mathtt{\text{scale}}\cdot [\mathtt{\text{vects}}[0]-\mathtt{\text{mean}},\mathtt{\text{vects}}[1]-\mathtt{\text{mean}},...]\cdot [\mathtt{\text{vects}}[0]-\mathtt{\text{mean}},\mathtt{\text{vects}}[1]-\mathtt{\text{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	如果指定了此标志，则所有输入向量都将存储为样本矩阵的行。在这种情况下，mean 应该是一个单行向量。
COVAR_COLS  Python: cv.COVAR_COLS	如果指定了此标志，则所有输入向量都将存储为样本矩阵的列。在这种情况下，mean 应该是一个单列向量。

DecompTypes

枚举 cv::DecompTypes

#include <opencv2/core/base.hpp>

矩阵分解类型

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

DftFlags

枚举 cv::DftFlags

#include <opencv2/core/base.hpp>

枚举值
DFT_INVERSE  Python: cv.DFT_INVERSE	执行逆 1D 或 2D 变换，而不是默认的正向变换。
DFT_SCALE  Python: cv.DFT_SCALE	缩放结果：将其除以数组元素的数量。通常，它与 DFT_INVERSE 组合使用。
DFT_ROWS  Python: cv.DFT_ROWS	对输入矩阵的每一行执行正向或逆变换；此标志使您可以同时变换多个向量，并且可用于减少开销（有时比处理本身大几倍）以执行 3D 和更高维度的变换等等。
DFT_COMPLEX_OUTPUT  Python: cv.DFT_COMPLEX_OUTPUT	执行 1D 或 2D 实数数组的正向变换；结果虽然是复数数组，但具有复共轭对称性 (CCS，有关详细信息，请参见下面的函数描述)，并且此类数组可以打包到与输入大小相同的实数数组中，这是最快的方法，也是函数默认执行的操作；但是，您可能希望获得完整的复数数组（以便进行更简单的频谱分析等） - 传递此标志以使函数生成全尺寸的复数输出数组。
DFT_REAL_OUTPUT  Python: cv.DFT_REAL_OUTPUT	执行 1D 或 2D 复数数组的逆变换；结果通常是相同大小的复数数组，但是，如果输入数组具有复共轭对称性（例如，它是使用 DFT_COMPLEX_OUTPUT 标志进行正向变换的结果），则输出是实数数组；虽然函数本身不会检查输入是否对称，但您可以传递此标志，然后函数将假设对称性并生成实数输出数组（请注意，当输入打包到实数数组中并执行逆变换时，函数将输入视为打包的复共轭对称数组，输出也将是实数数组）。
DFT_COMPLEX_INPUT  Python: cv.DFT_COMPLEX_INPUT	指定输入为复数输入。如果设置此标志，则输入必须有 2 个通道。另一方面，出于向后兼容性的原因，如果输入有 2 个通道，则输入已被视为复数。
DCT_INVERSE  Python: cv.DCT_INVERSE	执行逆 1D 或 2D 变换，而不是默认的正向变换。
DCT_ROWS  Python: cv.DCT_ROWS	对输入矩阵的每一行执行正向或反向变换。此标志允许您同时变换多个向量，并可用于降低开销（有时比处理本身大几倍），以执行3D和更高维度的变换等。

GemmFlags

枚举 cv::GemmFlags

#include <opencv2/core/base.hpp>

广义矩阵乘法标志

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

NormTypes

枚举 cv::NormTypes

#include <opencv2/core/base.hpp>

范数类型

src1 和 src2 表示输入数组。

枚举值
NORM_INF  Python: cv.NORM_INF	$$norm=\{\begin{array}{ll}\parallel \mathtt{\text{src1}}{\parallel }_{L_{\mathrm{\infty }}}=\underset{I}{max}|\mathtt{\text{src1}}(I)|& \text{if }\mathtt{\text{normType}}=\mathtt{\text{NORM\_INF}}\\ \parallel \mathtt{\text{src1}}-\mathtt{\text{src2}}{\parallel }_{L_{\mathrm{\infty }}}=\underset{I}{max}|\mathtt{\text{src1}}(I)-\mathtt{\text{src2}}(I)|& \text{if }\mathtt{\text{normType}}=\mathtt{\text{NORM\_INF}}\\ \frac{\parallel \mathtt{\text{src1}}-\mathtt{\text{src2}}{\parallel }_{L_{\mathrm{\infty }}}}{\parallel \mathtt{\text{src2}}{\parallel }_{L_{\mathrm{\infty }}}}& \text{if }\mathtt{\text{normType}}=\mathtt{\text{NORM\_RELATIVE | NORM\_INF}}\end{array}$$
NORM_L1  Python: cv.NORM_L1	$$norm=\{\begin{array}{ll}\parallel \mathtt{\text{src1}}{\parallel }_{L_1}=\sum _I|\mathtt{\text{src1}}(I)|& \text{if }\mathtt{\text{normType}}=\mathtt{\text{NORM\_L1}}\\ \parallel \mathtt{\text{src1}}-\mathtt{\text{src2}}{\parallel }_{L_1}=\sum _I|\mathtt{\text{src1}}(I)-\mathtt{\text{src2}}(I)|& \text{if }\mathtt{\text{normType}}=\mathtt{\text{NORM\_L1}}\\ \frac{\parallel \mathtt{\text{src1}}-\mathtt{\text{src2}}{\parallel }_{L_1}}{\parallel \mathtt{\text{src2}}{\parallel }_{L_1}}& \text{if }\mathtt{\text{normType}}=\mathtt{\text{NORM\_RELATIVE | NORM\_L1}}\end{array}$$
NORM_L2  Python: cv.NORM_L2	$$norm=\{\begin{array}{ll}\parallel \mathtt{\text{src1}}{\parallel }_{L_2}=\sqrt{\sum _I\mathtt{\text{src1}}(I{)}^2}& \text{if }\mathtt{\text{normType}}=\mathtt{\text{NORM\_L2}}\\ \parallel \mathtt{\text{src1}}-\mathtt{\text{src2}}{\parallel }_{L_2}=\sqrt{\sum _I(\mathtt{\text{src1}}(I)-\mathtt{\text{src2}}(I){)}^2}& \text{if }\mathtt{\text{normType}}=\mathtt{\text{NORM\_L2}}\\ \frac{\parallel \mathtt{\text{src1}}-\mathtt{\text{src2}}{\parallel }_{L_2}}{\parallel \mathtt{\text{src2}}{\parallel }_{L_2}}& \text{if }\mathtt{\text{normType}}=\mathtt{\text{NORM\_RELATIVE | NORM\_L2}}\end{array}$$
NORM_L2SQR  Python: cv.NORM_L2SQR	$$norm=\{\begin{array}{ll}\parallel \mathtt{\text{src1}}{\parallel }_{L_2}^2=\sum _I\mathtt{\text{src1}}(I{)}^2& \text{if }\mathtt{\text{normType}}=\mathtt{\text{NORM\_L2SQR}}\\ \parallel \mathtt{\text{src1}}-\mathtt{\text{src2}}{\parallel }_{L_2}^2=\sum _I(\mathtt{\text{src1}}(I)-\mathtt{\text{src2}}(I){)}^2& \text{if }\mathtt{\text{normType}}=\mathtt{\text{NORM\_L2SQR}}\\ {\left(\frac{\parallel \mathtt{\text{src1}}-\mathtt{\text{src2}}{\parallel }_{L_2}}{\parallel \mathtt{\text{src2}}{\parallel }_{L_2}}\right)}^2& \text{if }\mathtt{\text{normType}}=\mathtt{\text{NORM\_RELATIVE | NORM\_L2SQR}}\end{array}$$
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>

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

RotateFlags

枚举 cv::RotateFlags

#include <opencv2/core.hpp>

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

函数文档

absdiff()

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

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

#include <opencv2/core.hpp>

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

函数 cv::absdiff 计算：当两个数组大小和类型相同时，计算它们之间的绝对差

$$\mathtt{\text{dst}}(I)=\mathtt{\text{saturate}}(|\mathtt{\text{src1}}(I)-\mathtt{\text{src2}}(I)|)$$

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

$$\mathtt{\text{dst}}(I)=\mathtt{\text{saturate}}(|\mathtt{\text{src1}}(I)-\mathtt{\text{src2}}|)$$

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

$$\mathtt{\text{dst}}(I)=\mathtt{\text{saturate}}(|\mathtt{\text{src1}}-\mathtt{\text{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计算

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

  $$\mathtt{\text{dst}}(I)=\mathtt{\text{saturate}}(\mathtt{\text{src1}}(I)+\mathtt{\text{src2}}(I))\mathtt{\text{if mask}}(I)\ne 0$$

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

  $$\mathtt{\text{dst}}(I)=\mathtt{\text{saturate}}(\mathtt{\text{src1}}(I)+\mathtt{\text{src2}})\mathtt{\text{if mask}}(I)\ne 0$$

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

  $$\mathtt{\text{dst}}(I)=\mathtt{\text{saturate}}(\mathtt{\text{src1}}+\mathtt{\text{src2}}(I))\mathtt{\text{if mask}}(I)\ne 0$$

  其中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函数计算两个数组的加权和，如下所示：

$$\mathtt{\text{dst}}(I)=\mathtt{\text{saturate}}(\mathtt{\text{src1}}(I)\ast \mathtt{\text{alpha}}+\mathtt{\text{src2}}(I)\ast \mathtt{\text{beta}}+\mathtt{\text{gamma}})$$

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

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

注意

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

参数

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

参见

add，subtract，scaleAdd，Mat::convertTo

此函数的调用图如下所示

batchDistance()

void cv::batchDistance	(	InputArray	src1,
		InputArray	src2,
		OutputArray	dist,
		int	输出数组的可选深度（参见下面的讨论）。,
		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大小相同时的两个数组

$$\mathtt{\text{dst}}(I)=\mathtt{\text{src1}}(I)\wedge \mathtt{\text{src2}}(I)\mathtt{\text{if mask}}(I)\ne 0$$

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

$$\mathtt{\text{dst}}(I)=\mathtt{\text{src1}}(I)\wedge \mathtt{\text{src2}}\mathtt{\text{if mask}}(I)\ne 0$$

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

$$\mathtt{\text{dst}}(I)=\mathtt{\text{src1}}\wedge \mathtt{\text{src2}}(I)\mathtt{\text{if mask}}(I)\ne 0$$

对于浮点数组，它们的机器特定位表示（通常符合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计算输入数组的逐元素按位反转

$$\mathtt{\text{dst}}(I)=\mathrm{\neg }\mathtt{\text{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 大小相同时，对两个数组进行运算。

$$\mathtt{\text{dst}}(I)=\mathtt{\text{src1}}(I)\vee \mathtt{\text{src2}}(I)\mathtt{\text{if mask}}(I)\ne 0$$

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

$$\mathtt{\text{dst}}(I)=\mathtt{\text{src1}}(I)\vee \mathtt{\text{src2}}\mathtt{\text{if mask}}(I)\ne 0$$

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

$$\mathtt{\text{dst}}(I)=\mathtt{\text{src1}}\vee \mathtt{\text{src2}}(I)\mathtt{\text{if mask}}(I)\ne 0$$

对于浮点数组，它们的机器特定位表示（通常符合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 大小相同时，对两个数组进行运算。

$$\mathtt{\text{dst}}(I)=\mathtt{\text{src1}}(I)\oplus \mathtt{\text{src2}}(I)\mathtt{\text{if mask}}(I)\ne 0$$

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

$$\mathtt{\text{dst}}(I)=\mathtt{\text{src1}}(I)\oplus \mathtt{\text{src2}}\mathtt{\text{if mask}}(I)\ne 0$$

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

$$\mathtt{\text{dst}}(I)=\mathtt{\text{src1}}\oplus \mathtt{\text{src2}}(I)\mathtt{\text{if mask}}(I)\ne 0$$

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

参数

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

此函数的调用图如下所示

borderInterpolate()

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

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

#include <opencv2/core.hpp>

计算外推像素的源位置。

该函数计算并返回使用指定的边界外推模式时，对应于指定外推像素的供体像素的坐标。例如，如果在水平方向上使用 cv::BORDER_WRAP 模式，在垂直方向上使用 cv::BORDER_REFLECT_101 模式，并想要计算浮点图像 img 中“虚拟”像素 Point(-5, 100) 的值，则如下所示：

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

通常，不会直接调用此函数。它用于过滤函数以及 copyMakeBorder 中。

参数

p	沿其中一个轴的外推像素的基于 0 的坐标，可能 <0 或 >= len
len	沿相应轴的数组长度。
borderType	边界类型，是 BorderTypes 之一，但 BORDER_TRANSPARENT 和 BORDER_ISOLATED 除外。当 borderType==BORDER_CONSTANT 时，无论 p 和 len 如何，函数始终返回 -1。

参见

copyMakeBorder

此函数的调用图如下所示

broadcast()

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

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

#include <opencv2/core.hpp>

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

参数

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

此函数的调用图如下所示

calcCovarMatrix() [1/2]

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

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

#include <opencv2/core.hpp>

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

函数 cv::calcCovarMatrix 计算一组输入向量的协方差矩阵，以及可选的均值向量。

参数

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

参见

PCA，mulTransposed，Mahalanobis

待办事项

InputArrayOfArrays

此函数的调用图如下所示

calcCovarMatrix() [2/2]

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

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

#include <opencv2/core.hpp>

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

注意

使用 COVAR_ROWS 或 COVAR_COLS 标志

参数

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

此函数的调用图如下所示

cartToPolar()

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

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

#include <opencv2/core.hpp>

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

函数 cv::cartToPolar 为每个二维向量 (x(I),y(I)) 计算幅度、角度或两者。

$$\begin{array}{l}\mathtt{\text{magnitude}}(I)=\sqrt{\mathtt{\text{x}}(I{)}^2+\mathtt{\text{y}}(I{)}^2},\\ \mathtt{\text{angle}}(I)=\mathtt{\text{atan2}}(\mathtt{\text{y}}(I),\mathtt{\text{x}}(I))[\cdot 180/\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 大小相同时，比较两个数组的元素

$$\mathtt{\text{dst}}(I)=\mathtt{\text{src1}}(I)\mathtt{\text{cmpop}}\mathtt{\text{src2}}(I)$$

当 src2 由 Scalar 构造或只有一个元素时，比较 src1 的元素与标量 src2

$$\mathtt{\text{dst}}(I)=\mathtt{\text{src1}}(I)\mathtt{\text{cmpop}}\mathtt{\text{src2}}$$

当 src1 由 Scalar 构造或只有一个元素时，比较 src1 与 src2 的元素

$$\mathtt{\text{dst}}(I)=\mathtt{\text{src1}}\mathtt{\text{cmpop}}\mathtt{\text{src2}}(I)$$

当比较结果为真时，输出数组的对应元素将设置为 255。比较运算可以用等效的矩阵表达式替换：

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

参数

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

参见

checkRange, min, max, threshold

此函数的调用图如下所示

completeSymm()

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

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

#include <opencv2/core.hpp>

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

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

• ${\mathtt{\text{m}}}_{ij}={\mathtt{\text{m}}}_{ji}$ for $i>j$ if lowerToUpper=false
• ${\mathtt{\text{m}}}_{ij}={\mathtt{\text{m}}}_{ji}$ for $i<j$ if lowerToUpper=true

参数

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

参见

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 类型来表示位深度。如果输入数组既不是 CV_32F 也不是 CV_16S，则函数将引发错误。半精度浮点的格式在 IEEE 754-2008 中定义。

参数

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

已弃用

使用Mat::convertTo，并使用 CV_16F 代替。

此函数的调用图如下所示

convertScaleAbs()

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

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

#include <opencv2/core.hpp>

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

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

$$\mathtt{\text{dst}}(I)=\mathtt{\text{saturate\_cast<uchar>}}(|\mathtt{\text{src}}(I)\ast \mathtt{\text{alpha}}+\mathtt{\text{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	上边界,
		int	下边界,
		int	左边界,
		int	右边界,
		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=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 类型，并且可以具有 1 个或多个通道。

此函数的调用图如下所示

countNonZero()

int cv::countNonZero

(

InputArray

src

)

Python
	cv.countNonZero(	src	) ->	retval

#include <opencv2/core.hpp>

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

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

$$\sum _{I:\mathtt{\text{src}}(I)\ne 0}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_{jk}^{(N)}=\sqrt{{\alpha }_j/N}\cos \left(\frac{\pi (2k+1)j}{2N}\right)$$

  且 ${\alpha }_0=1$，${\alpha }_j=2$ 对于 j > 0。
• 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_{jk}^{(N)}=\exp (-2\pi ijk/N)$且$i=\sqrt{-1}$
• 对N个元素的一维向量的反向傅里叶变换

  $$\begin{array}{l}{X}^{\prime }={\left(F^{(N)}\right)}^{-1}\cdot Y={\left(F^{(N)}\right)}^{\ast }\cdot y\\ X=(1/N)\cdot X,\end{array}$$

  其中$F^{\ast }={(\text{Re}(F^{(N)})-\text{Im}(F^{(N)}))}^T$
• 对M x N矩阵的正向二维傅里叶变换

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

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

  $$\begin{array}{l}{X}^{\prime }={\left(F^{(M)}\right)}^{\ast }\cdot Y\cdot {\left(F^{(N)}\right)}^{\ast }\\ X=\frac{1}{M\cdot N}\cdot X^{\prime }\end{array}$$

对于实数(单通道)数据，正向傅里叶变换的输出频谱或反向傅里叶变换的输入频谱可以用称为 *CCS* (复共轭对称) 的压缩格式表示。它借鉴自IPL(Intel*图像处理库)。以下是二维 *CCS* 频谱的样子

$$\left[\begin{array}{ccccccccc}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}\\ \dots \\ Re{Y}_{M/2-1,0}& Re{Y}_{M-3,1}& Im{Y}_{M-3,1}& \dots & 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}& \dots & 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}& \dots & Re{Y}_{M-1,N/2-1}& Im{Y}_{M-1,N/2-1}& Re{Y}_{M/2,N/2}\end{array}\right]$$

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

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

• 如果设置了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）乘积的数组才能高效处理。可以使用getOptimalDFTSize方法计算这种高效的DFT大小。

下面的示例演示如何计算两个二维实数数组的基于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分割成多个块。对于每个块，估计计算该块卷积所需的A和B的哪些部分。如果C中的块太小，由于重复工作，速度会大幅下降。在极端情况下，当C中的每个块都是单个像素时，该算法就等同于朴素的卷积算法。如果块太大，临时数组tempA和tempB就会变得太大，并且由于缓存局部性差也会导致速度下降。因此，在两者之间存在一个最佳的块大小。
• 如果C中不同的块可以并行计算，从而分块完成卷积，则循环可以进行线程化。

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

注意

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

参数

src	可以是实数或复数的输入数组。
dst	大小和类型取决于标志的输出数组。
flags	变换标志，表示DftFlags的组合。
nonzeroRows（非零行数）	当参数不为零时，函数假设只有输入数组的前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将一个数组除以另一个数组

$$\mathtt{\text{dst(I) = saturate(src1(I)*scale/src2(I))}}$$

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

$$\mathtt{\text{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大小和类型相同的输出数组。
输出数组的可选深度（参见下面的讨论）。	输出数组的可选深度；如果为-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 计算输入数组每个元素的指数。

$$\mathtt{\text{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 基）

$${\mathtt{\text{dst}}}_{ij}=\{\begin{array}{ll}{\mathtt{\text{src}}}_{\mathtt{\text{src.rows}}-i-1,j}& if\mathtt{\text{flipCode}}=0\\ {\mathtt{\text{src}}}_{i,\mathtt{\text{src.cols}}-j-1}& if\mathtt{\text{flipCode}}>0\\ {\mathtt{\text{src}}}_{\mathtt{\text{src.rows}}-i-1,\mathtt{\text{src.cols}}-j-1}& if\mathtt{\text{flipCode}}<0\end{array}$$

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

参数

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

参见

transpose, repeat, completeSymm

此函数的调用图如下所示

flipND()

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

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

#include <opencv2/core.hpp>

沿给定轴翻转n维数组。

参数

src	输入数组
dst	与 src 形状相同的输出数组
axis	执行翻转的轴。0 <= axis < src.dims。

此函数的调用图如下所示

gemm()

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

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

#include <opencv2/core.hpp>

执行广义矩阵乘法。

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

$$\mathtt{\text{dst}}=\mathtt{\text{alpha}}\cdot {\mathtt{\text{src1}}}^T\cdot \mathtt{\text{src2}}+\mathtt{\text{beta}}\cdot {\mathtt{\text{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。在当前实现中，N = 2 ^p^ * 3 ^q^ * 5 ^r^，其中 p、q、r 为整数。

如果 vecsize 太大（非常接近 INT_MAX），则函数返回负数。

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

参数

vecsize

向量大小。

参见

dft, dct, idft, idct, mulSpectrums

此函数的调用图如下所示

hasNonZero()

bool cv::hasNonZero

(

InputArray

src

)

Python
	cv.hasNonZero(	src	) ->	retval

#include <opencv2/core.hpp>

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

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

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

注意

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

参数

src

单通道数组。

参见

mean，meanStdDev，norm，minMaxLoc，calcCovarMatrix

findNonZero, countNonZero

此函数的调用图如下所示

hconcat() [1/3]

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

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

#include <opencv2/core.hpp>

将水平串联应用于给定的矩阵。

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

cv::Mat matArray[] = { cv::Mat(4, 1, CV_8UC1, cv::Scalar(1)),
                       cv::Mat(4, 1, CV_8UC1, cv::Scalar(2)),
                       cv::Mat(4, 1, CV_8UC1, cv::Scalar(3)),};
 
cv::Mat out;
cv::hconcat( matArray, 3, out );
//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_SCALE 传递给 dft 或 idft 之一，以使这些变换互为逆变换。

参见

dft，dct，idct，mulSpectrums，getOptimalDFTSize

参数

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

此函数的调用图如下所示

inRange()

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

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

#include <opencv2/core.hpp>

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

函数检查范围如下：

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

  $$\mathtt{\text{dst}}(I)=\mathtt{\text{lowerb}}(I{)}_0\le \mathtt{\text{src}}(I{)}_0\le \mathtt{\text{upperb}}(I{)}_0$$

• 对于双通道数组：

  $$\mathtt{\text{dst}}(I)=\mathtt{\text{lowerb}}(I{)}_0\le \mathtt{\text{src}}(I{)}_0\le \mathtt{\text{upperb}}(I{)}_0\wedge \mathtt{\text{lowerb}}(I{)}_1\le \mathtt{\text{src}}(I{)}_1\le \mathtt{\text{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。SVD 方法计算伪逆矩阵，如果 src 为奇异矩阵。

与 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 计算输入数组每个元素的自然对数：

$$\mathtt{\text{dst}}(I)=\log (\mathtt{\text{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 的每个元素如下：

$$\mathtt{\text{dst}}(I)\leftarrow \mathtt{\text{lut(src(I) + d)}}$$

其中

$$d=\{\begin{array}{ll}0& \text{if }\mathtt{\text{src}}\text{ has depth }\mathtt{\text{CV\_8U}}\\ 128& \text{if }\mathtt{\text{src}}\text{ has depth }\mathtt{\text{CV\_8S}}\end{array}$$

参数

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

参见

convertScaleAbs，Mat::convertTo

此函数的调用图如下所示

magnitude()

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

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

#include <opencv2/core.hpp>

计算二维向量的幅度。

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

$$\mathtt{\text{dst}}(I)=\sqrt{\mathtt{\text{x}}(I{)}^2+\mathtt{\text{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(\mathtt{\text{vec1}},\mathtt{\text{vec2}})=\sqrt{\sum _{i,j}\mathtt{\text{icovar(i,j)}}\cdot (\mathtt{\text{vec1}}(I)-\mathtt{\text{vec2}}(I))\cdot (\mathtt{\text{vec1(j)}}-\mathtt{\text{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 计算两个数组的按元素最大值

$$\mathtt{\text{dst}}(I)=max(\mathtt{\text{src1}}(I),\mathtt{\text{src2}}(I))$$

或数组和标量

$$\mathtt{\text{dst}}(I)=max(\mathtt{\text{src1}}(I),\mathtt{\text{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:\mathtt{\text{mask}}(I)\ne 0}1\\ M_c=\left(\sum _{I:\mathtt{\text{mask}}(I)\ne 0}\mathtt{\text{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,\mathtt{\text{mask}}(I)\ne 0}1\\ {\mathtt{\text{mean}}}_c=\frac{\sum _{I:\mathtt{\text{mask}}(I)\ne 0}\mathtt{\text{src}}(I{)}_c}{N}\\ {\mathtt{\text{stddev}}}_c=\sqrt{\frac{\sum _{I:\mathtt{\text{mask}}(I)\ne 0}{(\mathtt{\text{src}}(I{)}_c-{\mathtt{\text{mean}}}_c)}^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 计算两个数组的逐元素最小值

$$\mathtt{\text{dst}}(I)=min(\mathtt{\text{src1}}(I),\mathtt{\text{src2}}(I))$$

或数组和标量

$$\mathtt{\text{dst}}(I)=min(\mathtt{\text{src1}}(I),\mathtt{\text{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	返回最小位置的指针（在二维情况下）；如果不需要，则使用 NULL。
maxLoc	返回最大位置的指针（在二维情况下）；如果不需要，则使用 NULL。
mask	用于选择子数组的可选掩码。

参见

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

此函数的调用图如下所示

mixChannels() [1/3]

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

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

#include <opencv2/core.hpp>

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

函数 cv::mixChannels 提供了一种用于混洗图像通道的高级机制。

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

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

Mat bgra( 100, 100, CV_8UC4, Scalar(255,0,0,255) );
Mat bgr( bgra.rows, bgra.cols, CV_8UC3 );
Mat alpha( bgra.rows, bgra.cols, CV_8UC1 );
 
// 形成矩阵数组是一个相当高效的操作，
// 因为不会复制矩阵数据，只复制头部信息
Mat out[] = { bgr, alpha };
// bgra[0] -> bgr[2], bgra[1] -> bgr[1],
// bgra[2] -> bgr[0], bgra[3] -> alpha[0]
int from_to[] = { 0,2, 1,1, 2,0, 3,3 };
mixChannels( &bgra, 1, out, 2, from_to, 4 );

注意

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

参数

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

参见

split，merge，extractChannel，insertChannel，cvtColor

此函数的调用图如下所示

mixChannels() [2/3]

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

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

#include <opencv2/core.hpp>

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

参数

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

此函数的调用图如下所示

mixChannels() [3/3]

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

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

#include <opencv2/core.hpp>

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

参数

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

此函数的调用图如下所示

mulSpectrums()

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

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

#include <opencv2/core.hpp>

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

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

该函数与dft和idft一起可以使用，可以快速计算两个数组的卷积 (pass conjB=false) 或相关性 (pass conjB=true)。当数组为复数时，它们将简单地（逐元素）相乘，并可以选择对第二个数组的元素进行共轭。当数组为实数时，假定它们是CCS打包的（有关详细信息，请参见dft）。

参数

a	第一个输入数组。
b	第二个输入数组，大小和类型与 src1 相同。
c	与src1大小和类型相同的输出数组。
flags	操作标志；目前，唯一支持的标志是cv::DFT_ROWS，它表示src1和src2的每一行都是独立的一维傅里叶谱。如果您不想使用此标志，则只需添加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 函数计算两个数组的逐元素乘积

$$\mathtt{\text{dst}}(I)=\mathtt{\text{saturate}}(\mathtt{\text{scale}}\cdot \mathtt{\text{src1}}(I)\cdot \mathtt{\text{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 (缩放因子)	可选的比例因子。
输出数组的可选深度（参见下面的讨论）。	输出数组的可选深度

参见

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 及其转置的乘积

$$\mathtt{\text{dst}}=\mathtt{\text{scale}}(\mathtt{\text{src}}-\mathtt{\text{delta}}{)}^T(\mathtt{\text{src}}-\mathtt{\text{delta}})$$

如果 aTa=true，则

$$\mathtt{\text{dst}}=\mathtt{\text{scale}}(\mathtt{\text{src}}-\mathtt{\text{delta}})(\mathtt{\text{src}}-\mathtt{\text{delta}}{)}^T$$

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

参数

src	输入单通道矩阵。请注意，与 gemm 不同，该函数不仅可以乘以浮点矩阵。
dst	输出方阵。
aTa	指定乘法顺序的标志。请参见下面的描述。
delta	在乘法之前从 src 中减去的可选 delta 矩阵。当矩阵为空时 (delta=noArray())，则假定它为零，即不减去任何值。如果它与 src 大小相同，则直接减去。否则，它将被“重复”（参见 repeat）以覆盖整个 src，然后减去。当 delta 矩阵不为空时，其类型必须与创建的输出矩阵的类型相同。请参见下面 dtype 参数的描述。
scale (缩放因子)	矩阵乘积的可选比例因子。
输出数组的可选深度（参见下面的讨论）。	输出矩阵的可选类型。当它为负数时，输出矩阵将与 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)=\left(\begin{array}{c}x\\ 1-x\end{array}\right),x\in [-1;1]$。对于样本值 $r(-1)=\left(\begin{array}{c}-1\\ 2\end{array}\right)$，$L_1,L_2$ 和 $L_{\mathrm{\infty }}$ 范数计算如下

$$\begin{array}{rl}\parallel r(-1){\parallel }_{L_1}& =|-1|+|2|=3\\ \parallel r(-1){\parallel }_{L_2}& =\sqrt{(-1{)}^2+(2{)}^2}=\sqrt{5}\\ \parallel r(-1){\parallel }_{L_{\mathrm{\infty }}}& =max(|-1|,|2|)=2\end{array}$$

对于 $r(0.5)=\left(\begin{array}{c}0.5\\ 0.5\end{array}\right)$，计算结果为

$$\begin{array}{rl}\parallel r(0.5){\parallel }_{L_1}& =|0.5|+|0.5|=1\\ \parallel r(0.5){\parallel }_{L_2}& =\sqrt{(0.5{)}^2+(0.5{)}^2}=\sqrt{0.5}\\ \parallel r(0.5){\parallel }_{L_{\mathrm{\infty }}}& =max(|0.5|,|0.5|)=0.5.\end{array}$$

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

当指定掩码参数且它不为空时，范数为

如果未指定 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 归一化缩放并移动输入数组元素，以便

$$\parallel \mathtt{\text{dst}}{\parallel }_{L_p}=\mathtt{\text{alpha}}$$

(其中 p=Inf, 1 或 2) 当 normType=NORM_INF, NORM_L1 或 NORM_L2 时；或者以便

$$\underset{I}{min}\mathtt{\text{dst}}(I)=\mathtt{\text{alpha}},\underset{I}{max}\mathtt{\text{dst}}(I)=\mathtt{\text{beta}}$$

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

对于稀疏矩阵，仅分析和转换非零值。因此，不允许对稀疏矩阵进行范围变换，因为它可以移动零电平。

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

vector<double> positiveData = { 2.0, 8.0, 10.0 };
vector<double> normalizedData_l1, normalizedData_l2, normalizedData_inf, normalizedData_minmax;
 
// 范数到概率（总数）
// sum(numbers) = 20.0
// 2.0      0.1     (2.0/20.0)
// 8.0      0.4     (8.0/20.0)
// 10.0     0.5     (10.0/20.0)
normalize(positiveData, normalizedData_l1, 1.0, 0.0, NORM_L1);
 
// 范数到单位向量：||positiveData|| = 1.0
// 2.0      0.15
// 8.0      0.62
// 10.0     0.77
normalize(positiveData, normalizedData_l2, 1.0, 0.0, NORM_L2);
 
// 归一化到最大元素
// 2.0      0.2     (2.0/10.0)
// 8.0      0.8     (8.0/10.0)
// 10.0     1.0     (10.0/10.0)
normalize(positiveData, normalizedData_inf, 1.0, 0.0, NORM_INF);
 
// 归一化到范围 [0.0;1.0]
// 2.0 0.0 (左边界偏移)
// 8.0      0.75    (6.0/8.0)
// 10.0 1.0 (右边界偏移)
normalize(positiveData, normalizedData_minmax, 1.0, 0.0, NORM_MINMAX);

参数

src	输入数组。
dst	与 src 大小相同的输出数组。
alpha	要归一化的范数值或范围归一化情况下较低的范围边界。
beta	范围归一化时的上限边界；在范数归一化中未使用。
norm_type	归一化类型（参见 cv::NormTypes）。
输出数组的可选深度（参见下面的讨论）。	当为负数时，输出数组与src具有相同的类型；否则，它与src具有相同的通道数，深度 =CV_MAT_DEPTH(dtype).
mask	可选操作掩码。

参见

norm, Mat::convertTo, SparseMat::convertTo

示例

samples/cpp/pca.cpp.

此函数的调用图如下所示

patchNaNs()

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

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

#include <opencv2/core.hpp>

用给定数字替换NaN。

参数

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

此函数的调用图如下所示

PCABackProject()

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

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

#include <opencv2/core.hpp>

包装 PCA::backProject

此函数的调用图如下所示

PCACompute() [1/4]

void cv::PCACompute	(	InputArray	data,
		InputOutputArray	mean,
		OutputArray	eigenvectors (特征向量),
		double	retainedVariance )

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

#include <opencv2/core.hpp>

包装 PCA::operator()

此函数的调用图如下所示

PCACompute() [2/4]

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

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

#include <opencv2/core.hpp>

包装 PCA::operator()

此函数的调用图如下所示

PCACompute() [3/4]

void cv::PCACompute	(	InputArray	data,
		InputOutputArray	mean,
		OutputArray	eigenvectors (特征向量),
		OutputArray	eigenvalues (特征值),
		double	retainedVariance )

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

#include <opencv2/core.hpp>

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

此函数的调用图如下所示

PCACompute() [4/4]

void cv::PCACompute	(	InputArray	data,
		InputOutputArray	mean,
		OutputArray	eigenvectors (特征向量),
		OutputArray	eigenvalues (特征值),
		int	maxComponents = 0 )

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

#include <opencv2/core.hpp>

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

此函数的调用图如下所示

PCAProject()

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

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

#include <opencv2/core.hpp>

包装 PCA::project

此函数的调用图如下所示

perspectiveTransform()

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

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

#include <opencv2/core.hpp>

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

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

$$(x,y,z)\to (x^{\prime }/w,y^{\prime }/w,z^{\prime }/w)$$

其中

$$(x^{\prime },y^{\prime },z^{\prime },w^{\prime })=\mathtt{\text{mat}}\cdot \left[\begin{array}{cccc}x& y& z& 1\end{array}\right]$$

和

$$w=\{\begin{array}{ll}{w}^{\prime }& \text{if }{w}^{\prime }\ne 0\\ \mathrm{\infty }& \text{otherwise}\end{array}$$

这里显示了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的对应元素形成的每个二维向量的旋转角

$$\mathtt{\text{angle}}(I)=\mathtt{\text{atan2}}(\mathtt{\text{y}}(I),\mathtt{\text{x}}(I))$$

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

参数

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

此函数的调用图如下所示

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 计算由幅度和角度的对应元素表示的每个二维向量的笛卡尔坐标

$$\begin{array}{l}\mathtt{\text{x}}(I)=\mathtt{\text{magnitude}}(I)\cos (\mathtt{\text{angle}}(I))\\ \mathtt{\text{y}}(I)=\mathtt{\text{magnitude}}(I)\sin (\mathtt{\text{angle}}(I))\end{array}$$

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

参数

magnitude	输入二维向量幅度的浮点数组；它可以是空矩阵(=Mat())，在这种情况下，函数假设所有幅度都=1；如果它不是空的，它必须与angle具有相同的大小和类型。
angle	输入二维向量的角度浮点数组。
x	二维向量x坐标的输出数组；它与angle具有相同的大小和类型。
y	二维向量y坐标的输出数组；它与angle具有相同的大小和类型。
angleInDegrees	为真时，输入角度以度数测量，否则以弧度测量。

参见

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将输入数组的每个元素提高到power次方

$$\mathtt{\text{dst}}(I)=\{\begin{array}{ll}\mathtt{\text{src}}(I{)}^{power}& \text{如果}\mathtt{\text{power}}\text{是整数}\\ |\mathtt{\text{src}}(I){|}^{power}& \text{否则}\end{array}$$

因此，对于非整数幂指数，使用输入数组元素的绝对值。但是，可以使用一些额外的操作来获得负值的真实值。在下面的示例中，计算数组 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 的计算方法如下

$$\mathtt{\text{PSNR}}=10\cdot {\log }_{10}\left(\frac{R^2}{MSE}\right)$$

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

参数

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

此函数的调用图如下所示

randn()

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

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

#include <opencv2/core.hpp>

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

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

参数

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

参见

RNG, randu

此函数的调用图如下所示

randShuffle()

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

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

#include <opencv2/core.hpp>

随机打乱数组元素。

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

参数

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

参见

RNG, sort

示例

modules/shape/samples/shape_example.cpp.

此函数的调用图如下所示

randu()

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

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

#include <opencv2/core.hpp>

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

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

$${\mathtt{\text{low}}}_c\le \mathtt{\text{dst}}(I{)}_c<{\mathtt{\text{high}}}_c$$

参数

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

参见

RNG, randn, theRNG

此函数的调用图如下所示

reduce()

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

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

#include <opencv2/core.hpp>

将矩阵简化为向量。

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

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

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

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

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

参数

src	输入的二维矩阵。
dst	输出向量。其大小和类型由dim和dtype参数定义。
dim	矩阵沿其进行约简的维度索引。0表示矩阵约简为单行。1表示矩阵约简为单列。
rtype	约简操作，可以是以下ReduceTypes之一
输出数组的可选深度（参见下面的讨论）。	如果为负数，则输出向量的类型与输入矩阵相同，否则，其类型将为CV_MAKE_TYPE(CV_MAT_DEPTH(dtype), src.channels())。

参见

repeat，reduceArgMin，reduceArgMax

此函数的调用图如下所示

reduceArgMax()

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

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

#include <opencv2/core.hpp>

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

注意

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

参数

src	输入单通道数组。
dst	类型为CV_32SC1的输出数组，其维度与src相同，但被约简的轴除外——它应设置为1。
lastIndex	是否获取最大值的第一次或最后一次出现的索引。
axis	要沿其约简的轴。

参见

reduceArgMin，minMaxLoc，min，max，compare，reduce

此函数的调用图如下所示

reduceArgMin()

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

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

#include <opencv2/core.hpp>

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

注意

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

参数

src	输入单通道数组。
dst	类型为CV_32SC1的输出数组，其维度与src相同，但被约简的轴除外——它应设置为1。
lastIndex	是否获取最小值的第一次或最后一次出现的索引。
axis	要沿其约简的轴。

参见

reduceArgMax，minMaxLoc，min，max，compare，reduce

此函数的调用图如下所示

repeat() [1/2]

cv::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沿两个轴中的每一个轴复制输入数组一次或多次

$${\mathtt{\text{dst}}}_{ij}={\mathtt{\text{src}}}_{i\mathrm{mod}src.rows,j\mathrm{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)。逆时针旋转90度 (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。它计算缩放数组与另一个数组的和

$$\mathtt{\text{dst}}(I)=\mathtt{\text{scale}}\cdot \mathtt{\text{src1}}(I)+\mathtt{\text{src2}}(I)$$

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

cv::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初始化一个缩放的单位矩阵

$$\mathtt{\text{mtx}}(i,j)=\{\begin{array}{ll}\mathtt{\text{value}}& \text{ if }i=j\\ 0& \text{otherwise}\end{array}$$

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

cv::Mat A = cv::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	) ->	无

#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 来实现）。

$$\mathtt{\text{dst}}=\arg \underset{X}{min}\parallel \mathtt{\text{src1}}\cdot \mathtt{\text{X}}-\mathtt{\text{src2}}\parallel$$

如果使用DECOMP_LU 或DECOMP_CHOLESKY 方法，如果 src1（或${\mathtt{\text{src1}}}^T\mathtt{\text{src1}}$）是非奇异的，则函数返回 1。否则，返回 0。在后一种情况下，dst 无效。其他方法在左侧部分奇异的情况下找到伪解。

注意

如果要找到欠定奇异系统$\mathtt{\text{src1}}\cdot \mathtt{\text{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 元素向量

  $$\mathtt{\text{coeffs}}[0]x^3+\mathtt{\text{coeffs}}[1]x^2+\mathtt{\text{coeffs}}[2]x+\mathtt{\text{coeffs}}[3]=0$$

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

  $$x^3+\mathtt{\text{coeffs}}[0]x^2+\mathtt{\text{coeffs}}[1]x+\mathtt{\text{coeffs}}[2]=0$$

根存储在 roots 数组中。

参数

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

返回值

实根的数量。可以是 0、1 或 2。

此函数的调用图如下所示

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 查找多项式方程的实根和复根

$$\mathtt{\text{coeffs}}[n]x^n+\mathtt{\text{coeffs}}[n-1]x^{n-1}+...+\mathtt{\text{coeffs}}[1]x+\mathtt{\text{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 将多通道数组拆分为单独的单通道数组

$$\mathtt{\text{mv}}[c](I)=\mathtt{\text{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,
		输出数组数组	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函数计算

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

  $$\mathtt{\text{dst}}(I)=\mathtt{\text{saturate}}(\mathtt{\text{src1}}(I)-\mathtt{\text{src2}}(I))\mathtt{\text{if mask}}(I)\ne 0$$

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

  $$\mathtt{\text{dst}}(I)=\mathtt{\text{saturate}}(\mathtt{\text{src1}}(I)-\mathtt{\text{src2}})\mathtt{\text{if mask}}(I)\ne 0$$

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

  $$\mathtt{\text{dst}}(I)=\mathtt{\text{saturate}}(\mathtt{\text{src1}}-\mathtt{\text{src2}}(I))\mathtt{\text{if mask}}(I)\ne 0$$

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

  $$\mathtt{\text{dst}}(I)=\mathtt{\text{saturate}}(\mathtt{\text{src2}}-\mathtt{\text{src1}}(I))\mathtt{\text{if mask}}(I)\ne 0$$

  其中 I 是数组元素的多维索引。对于多通道数组，每个通道都独立处理。

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

dst = src1 - src2;
dst -= src1; // equivalent to 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位单通道数组，指定要更改的输出数组的元素。
输出数组的可选深度（参见下面的讨论）。	输出数组的可选深度

参见

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{t}\mathrm{r}(\mathtt{\text{mtx}})=\sum _i\mathtt{\text{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中

$$\mathtt{\text{dst}}(I)=\mathtt{\text{m}}\cdot \mathtt{\text{src}}(I)$$

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

$$\mathtt{\text{dst}}(I)=\mathtt{\text{m}}\cdot [\mathtt{\text{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	输入数组，必须具有与m.cols或m.cols-1相同数量的通道（1到4）。
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

$$\mathtt{\text{dst}}(i,j)=\mathtt{\text{src}}(j,i)$$

注意

对于复数矩阵，不会进行复共轭运算。如果需要，应单独进行。

参数

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

此函数的调用图如下所示

transposeND()

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

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

#include <opencv2/core.hpp>

n维矩阵的转置。

注意

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

参数

src	输入数组。
顺序	[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的行数之和。相同的深度。

此函数的调用图如下所示