OpenCV矩阵操作

矩阵类的成员函数可以进行很多基本的矩阵操作，在之前已经介绍过。除此之外，也有很多操作被表示为“友元”函数，它们的输入为矩阵类型，或者输出为矩阵类型，或者输入输出同为矩阵类型。下面将对这些函数及其参数进行详细介绍。

cv::abs()和cv::absdiff

cv::add()

cv::addWeighted()

cv::bitwise_and()

cv::bitwise_not()

cv::bitwise_or()

cv::bitwise_xor()

cv::calcCovarMatrix()

cv::cartToPolar()

cv::checkRange()

cv::compare()

cv::completeSymm()

cv::convertScaleAbs()

cv::countNonZero()

cv::cvarrToMat()

cv::dct()

cv::dft()

cv::cvtColor()

cv::determinant()

cv::divide()

cv::eigen()

cv::exp()

cv::flip()

cv::gemm()

cv::hconcat()

cv::idct()

cv::idft()

cv::inRange()

cv::invert()

cv::log()

cv::LUT()

cv::magnitude()

cv::Mahalanobis()

cv::max()

cv::mean()

cv::meanStdDev()

cv::merge()

cv::min()

cv::minMaxIdx()

cv::minMaxLoc()

cv::mixChannels()

cv::mulSpectrums()

cv::multiply()

cv::mulTransposed()

cv::norm()

cv::normalize()

cv::perspectiveTransform()

cv::phase()

cv::polarToCart()

cv::pow()

cv::randu()

cv::randn()

cv::randShuffle()

cv::reduce()

cv::repeat()

cv::scaleAdd()

cv::setIdentity()

cv::solve()

cv::solveCubic()

cv::solvePoly()

cv::sort()

cv::sortIdx()

cv::split()

cv::sqrt()

cv::subtract()

cv::sum()

cv::theRNG()

cv::trace()

cv::transform()

cv::transpose()

cv::abs()和cv::absdiff

cv::MatExpr cv::abs(InputArray src)

cv::MatExpr cv::abs(const cv::MatExpr& src)

作用：计算某些矩阵或矩阵的某些表达式的绝对值。

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

作用：计算两个矩阵中每对应元素之间的差值，并将该差值的绝对值放入目标矩阵的相应元素中。

对cv::abs()的调用会转换为对cv::absdiff()或其他函数的调用，并由这些函数处理。如，求m0-m1的绝对值和分别穿参为m0和m1作为src1和src2；求m0的绝对值可以转换成求m0和cv::Scalar::all(0)的差值。

cv::add()

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

作用：计算两个数组或数组与标量之间的每个元素的差异。dtype表示输出矩阵类型，默认为-1，表示和输入矩阵类型相同。

原理： $dst(I) = saturate(src1(I) + src2(I))$ （最简单的情况）

对于简单的情况：矩阵运算可得到相同的结果： $dst = src1+src2$

也支持： $dst += src1$ ，相当于add(dst, src1, dst)

cv::addWeighted()

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

作用：实现alpha混合，alpha和beta分别是src1和src2的混合强度，一般二者之和为1。

原理： $dst(I) = saturate(src1(I) * alpha + src2(I) * beta + gamma)$

cv::bitwise_and()

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

作用：逐元素按位与操作，将结果放于dst中。

原理： $dst(I) = src1(I) \wedge src2(I)$

如果不适用掩码，相当于： $dst = src1 \& src2$

cv::bitwise_not()

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

作用：逐元素按位反转操作，将结果放于dst中。

原理： $dst(I) = \sim src(I)$

如果不适用掩码，相当于： $dst = !src$

cv::bitwise_or()

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

作用：逐元素按位或操作，将结果放于dst中。

原理： $dst(I) = src1(I) \vee src2(I)$

如果不适用掩码，相当于： $dst = src1 \mid src2$

cv::bitwise_xor()

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

作用：逐元素按位异或操作，将结果放于dst中。

原理： $dst(I) = src1(I) \bigoplus src2(I)$

如果不适用掩码，相当于： $dst = src1 \^ \: src2$

cv::calcCovarMatrix()

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

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

作用：给定一些向量，假设这些向量表示的点是近似高斯分布的，计算这些点的均值和协方差矩阵，结果分别放在mean和covar中。

cv::calcCovarMatrix()可能用到的flag参数值
flags参数的具体flag值	意义
cv::COVER_NOMAL	计算均值和协方差
cv::COVER_SCRAMBLED	快速PCA“scrambled”
cv::COVER_USE_AVERAGE	输入均值而不是计算均值
cv::COVER_SCALE	重新缩放输出的协方差矩阵
cv::COVER_ROWS	使用样本的行作为输入向量
cv::COVER_COLS	使用样本的列作为输入向量

标志cv::COVER_NOMAL和cv::COVER_SCRAMBLED是相互排斥的。

若选用cv::COVER_NOMAL，结果是n×n，因为：

$\sum \, _{normal}^{2}=\mathbb{Z}\begin{bmatrix} v_{0,0}-\bar{v}_{0}& \cdots & v_{m,0}-\bar{v}_{0} \\ \vdots & \ddots &\vdots \\ v_{0,n}-\bar{v}_{n}& \cdots & v_{m,n}-\bar{v}_{n} \end{bmatrix}\begin{bmatrix} v_{0,0}-\bar{v}_{0}& \cdots & v_{m,0}-\bar{v}_{0} \\ \vdots & \ddots &\vdots \\ v_{0,n}-\bar{v}_{n}& \cdots & v_{m,n}-\bar{v}_{n} \end{bmatrix}^{T}$

若选用cv::COVER_SCRAMBLED，结果是m×m，因为：

$\sum \, _{scrambled}^{2}=\mathbb{Z}\begin{bmatrix} v_{0,0}-\bar{v}_{0}& \cdots & v_{m,0}-\bar{v}_{0} \\ \vdots & \ddots &\vdots \\ v_{0,n}-\bar{v}_{n}& \cdots & v_{m,n}-\bar{v}_{n} \end{bmatrix}^{T}\begin{bmatrix} v_{0,0}-\bar{v}_{0}& \cdots & v_{m,0}-\bar{v}_{0} \\ \vdots & \ddots &\vdots \\ v_{0,n}-\bar{v}_{n}& \cdots & v_{m,n}-\bar{v}_{n} \end{bmatrix}$

其中 $\mathbb{Z}$ 是一个可选比例因子，除非使用cv::COVER_SCALE标志，否则它将被设置为1。和cv::COVER_NOMAL一起使用是1.0/m；和cv::COVER_SCRAMBLED一起使用是1.0/n。

cv::cartToPolar()

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

作用：计算两个二维向量的大小和角度，即极坐标表示。角度默认用弧度表示，除非angleDegrees=true。

原理： $magnitude(I) = \sqrt{x(I)^{2} + y(I)^{2}}$

$angle(I) = atan2(y(I), x(I))[\cdot 180/\pi ]$

注意：x和y的尺寸必须相同。设定点（0, 0）的角度为0，角度的计算精确到0.3度。

cv::checkRange()

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

作用：检查输入矩阵a中的每一个元素，并确定该元素是否在给定的范围内。

原理：quiet设置为true，若检查到有元素超出范围（NAN和inf值也被算超出范围），则结果返回false，否则返回false。

quiet设置为false，若检查到有元素超出范围，则抛出异常。

若指针pos不为NULL，则第一个异常值的位置将存储在pos中。

cv::compare()

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

作用：对src1和src2中的元素逐个进行比较，并将结果存入dst中。

原理：按cmpop指定的规则进行比较，匹配的标记为255，不匹配的标记为0。

cv::compare()使用的cmpop值以及由此产生的比较操作
cmpop的值	比较操作	矩阵运算实现
cv::CMP_EQ	src1(I) == src2(I)	dst = src1 == src2
cv::CMP_GT	src1(I) > src2(I)	dst = src1 > src2
cv::CMP_GE	src1(I) >= src2(I)	dst = src1 >= src2
cv::CMP_LT	src1(I) < src2(I)	dst = src1 < src2
cv::CMP_LE	src1(I) <= src2(I)	dst = src1 <= src2
cv::CMP_NE	src1(I) != src2(I)	dst = src1 != src2

cv::completeSymm()

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

作用：给定（二维）矩阵m，通过复制来使矩阵关于主对角线对称。

原理：若lowerToUpper=false， $m_{ij} = m_{ji}\: \: \: \: for\: i > j$ ，即将上三角的对称复制到下三角

若lowerToUpper=true， $m_{ij} = m_{ji}\: \: \: \: for\: i < j$ ，即将下三角的对称复制到上三角

cv::convertScaleAbs()

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

作用：① 通过因子alpha来重新调整原图像；

② 通过加因子beta来偏移；

③ 计算上述所求和的绝对值；

④ 将结果饱和映射到一个无符号字符型（8位）。

原理： $dst(I) = saturate\_cast<uchar>(\left | src(I) * alpha+ beta \right |)$

cv::countNonZero()

int cv::countNonZero(InputArray src)

作用：返回矩阵src中的非0像素数

cv::cvarrToMat()

Mat cv::cvarrToMat(const CvArr* arr, bool copyData =false, bool allowND =true, int coiMode =0, AutoBuffer<double>* buf=0)

作用：将CvMat或IplImage转换成Mat

cv::dct()

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

作用：对一维或二维数组执行离散余弦变换或离散余弦逆变换。如果flags设置为DCT_INVERSE，则实现逆变换；若flags设置为DCT_ROWS，则将二维n×m的输入视为长度为m的n个不同的一维向量。

原理：

维数	公式
一维	正： $Y=C^{(N)}\cdot X$
一维	逆： $X=(C^{(N)})^{-1}\cdot Y=(C^{(N)})^{T}\cdot Y$
二维	正： $Y=C^{(N)}\cdot X\cdot (C^{(N)})^{T}$
二维	逆： $X=(C^{(N)})^{T}\cdot Y\cdot C^{(N)}$

其中， $C_{jk}^{(N)}=\sqrt{\alpha _{j}/N}\cdot cos(\frac{\pi (2k+1)j}{2N})$ ，并且 $\alpha _{0}=1, \alpha _{j0} = 2\:\: \: for\:\: j >0$

cv::dft()

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

作用：对一维或二维数组执行离散傅里叶变换以及其逆变换。nonzeroRows默认为0，当设置为非0值时，则认为只有前nonzeroRows行是非零行；若此时设有DFT_INVERSE，则认为只有输出矩阵的前nonzeroRows行是非零行。flags可取以下的值：

flags的值	作用
DFT_INVERSE	实现逆变换
DFT_ROWS	将二维n×m的输入视为长度为m的n个不同的一维向量
DFT_SCALE	将结果除以矩阵中的元素来标准化结果
DFT_COMPLEX_OUTPUT	（正：输入是实数，结果是共轭复数，元素数加倍，所以输出是压缩的）强制输出复数形式
DFT_REAL_OUTPUT	（逆：输入是复数，输出也是复数，但输入有复共轭对称性时，输出是实数，内存仅占一半）输出实数形式

原理：

其中， $F_{jk}^{(N)}=exp(-2\pi ijk/N) \: \: \: and \:\: \: i=\sqrt{-1}$

$F^*=(Re(F^{(N)}))-Im(F^{(N)})^T$

cv::cvtColor()

void cv::cvtColor(InputArray src, OutputArray dst, int code, int dstCn=0)

作用：将图像从一个颜色空间转换到另一个颜色空间。R、G、B通道值的常规取值范围为：0-255（CV_8U）、0-65535（CV_16U）、0-1（CV_32F）。code的取值及其意义如下所示。

颜色转换码
转换编码	意义
COLOR_BGR2BGRA	在RGB或BGR图像中加入alpha通道
COLOR_RGB2RGBA	在RGB或BGR图像中加入alpha通道
COLOR_BGRA2BGR	在RGB或BGR图像中删除alpha通道
COLOR_RGBA2RGB	在RGB或BGR图像中删除alpha通道
COLOR_BGR2RGBA	在加入alpha通道时将RGB转换为BGR颜色空间
COLOR_RGB2BGRA	在加入alpha通道时将RGB转换为BGR颜色空间
COLOR_RGBA2BGR	在删除alpha通道时将RGB转换为BGR颜色空间
COLOR_BGRA2RGB	在删除alpha通道时将RGB转换为BGR颜色空间
COLOR_BGR2RGB	在RGB或BGR颜色空间之间的转换（不含alpha通道）
COLOR_RGB2BGR	在RGB或BGR颜色空间之间的转换（不含alpha通道）
COLOR_BGRA2RGBA	在RGB或BGR颜色空间之间的转换（含alpha通道）
COLOR_RGBA2BGRA	在RGB或BGR颜色空间之间的转换（含alpha通道）
COLOR_BGR2GRAY	转换RGB或BGR颜色空间为灰度空间
COLOR_RGB2GRAY	转换RGB或BGR颜色空间为灰度空间
COLOR_GRAY2BGR	将灰度空间转换为RGB或BGR颜色空间
COLOR_GRAY2RGB	将灰度空间转换为RGB或BGR颜色空间
COLOR_GRAY2BGRA	将灰度空间转换为RGB或BGR颜色空间，并加入alpha通道
COLOR_GRAY2RGBA	将灰度空间转换为RGB或BGR颜色空间，并加入alpha通道
COLOR_BGRA2GRAY	转换RGB或BGR颜色空间为灰度空间，并加入alpha通道
COLOR_RGBA2GRAY	转换RGB或BGR颜色空间为灰度空间，并加入alpha通道
COLOR_BGR2BGR565	将RGB或GBR颜色空间转换为BGR565颜色表示
COLOR_RGB2BGR565	将RGB或GBR颜色空间转换为BGR565颜色表示
COLOR_BGR5652BGR	将BGR565颜色空间转换为RGB或BGR颜色空间
COLOR_BGR5652RGB	将BGR565颜色空间转换为RGB或BGR颜色空间
COLOR_BGRA2BGR565	将RGB或GBR颜色空间转换为BGR565颜色表示，并删除alpha通道
COLOR_RGBA2BGR565	将RGB或GBR颜色空间转换为BGR565颜色表示，并删除alpha通道
COLOR_BGR5652BGRA	将BGR565颜色空间转换为RGB或BGR颜色空间，并加入alpha通道
COLOR_BGR5652RGBA	将BGR565颜色空间转换为RGB或BGR颜色空间，并加入alpha通道
COLOR_GRAY2BGR565	将灰度空间转换为BGR565颜色表示（16位图像）
COLOR_BGR5652GRAY	将BGR565颜色空间转换灰度空间为表示（16位图像）
COLOR_BGR2BGR555	将RGB或GBR颜色空间转换为BGR555颜色表示
COLOR_RGB2BGR555	将RGB或GBR颜色空间转换为BGR555颜色表示
COLOR_BGR5552BGR	将BGR555颜色空间转换为RGB或BGR颜色空间
COLOR_BGR5552RGB	将BGR555颜色空间转换为RGB或BGR颜色空间
COLOR_BGRA2BGR555	将RGB或GBR颜色空间转换为BGR555颜色表示，并删除alpha通道
COLOR_RGBA2BGR555	将RGB或GBR颜色空间转换为BGR555颜色表示，并删除alpha通道
COLOR_BGR5552BGRA	将BGR555颜色空间转换为RGB或BGR颜色空间，并加入alpha通道
COLOR_BGR5552RGBA	将BGR555颜色空间转换为RGB或BGR颜色空间，并加入alpha通道
COLOR_GRAY2BGR555	将灰度空间转换为BGR555颜色表示（16位图像）
COLOR_BGR5552GRAY	将BGR555颜色空间转换灰度空间为表示（16位图像）
COLOR_BGR2XYZ	将RGB或GBR颜色空间转换为XYZ颜色表示
COLOR_RGB2XYZ	将RGB或GBR颜色空间转换为XYZ颜色表示
COLOR_XYZ2BGR	将XYZ颜色空间转换为RGB或BGR颜色空间
COLOR_XYZ2RGB	将XYZ颜色空间转换为RGB或BGR颜色空间
COLOR_BGR2YCrCb	将RGB或GBR颜色空间转换为YCrCb颜色表示
COLOR_RGB2YCrCb	将RGB或GBR颜色空间转换为YCrCb颜色表示
COLOR_YCrCb2BGR	将YCrCb颜色空间转换为RGB或BGR颜色空间
COLOR_YCrCb2RGB	将YCrCb颜色空间转换为RGB或BGR颜色空间
COLOR_BGR2HSV	将RGB或GBR颜色空间转换为HSV颜色表示
COLOR_RGB2HSV	将RGB或GBR颜色空间转换为HSV颜色表示
COLOR_HSV2BGR	将HSV颜色空间转换为RGB或BGR颜色空间
COLOR_HSV2RGB	将HSV颜色空间转换为RGB或BGR颜色空间
COLOR_BGR2Lab	将RGB或GBR颜色空间转换为Lab颜色表示
COLOR_RGB2Lab	将RGB或GBR颜色空间转换为Lab颜色表示
COLOR_Lab2BGR	将Lab颜色空间转换为RGB或BGR颜色空间
COLOR_Lab2RGB	将Lab颜色空间转换为RGB或BGR颜色空间
COLOR_BGR2Luv	将RGB或GBR颜色空间转换为Luv颜色表示
COLOR_RGB2Luv	将RGB或GBR颜色空间转换为Luv颜色表示
COLOR_Luv2BGR	将Luv颜色空间转换为RGB或BGR颜色空间
COLOR_Luv2RGB	将Luv颜色空间转换为RGB或BGR颜色空间
COLOR_BGR2HLS	将RGB或GBR颜色空间转换为HLS颜色表示
COLOR_RGB2HLS	将RGB或GBR颜色空间转换为HLS颜色表示
COLOR_HLS2BGR	将HLS颜色空间转换为RGB或BGR颜色空间
COLOR_HLS2RGB	将HLS颜色空间转换为RGB或BGR颜色空间
COLOR_BayerBG2BGR	从Bayer模块（单通道）转为RGB或BGR图像
COLOR_BayerGB2BGR
COLOR_BayerRG2BGR
COLOR_BayerGR2BGR
COLOR_BayerBG2RGB
COLOR_BayerGB2RGB
COLOR_BayerRG2RGB
COLOR_BayerGR2RGB

cv::determinant()

double cv::determinant(InputArray mtx)

作用：返回一个平方浮点矩阵的行列式。

cv::divide()

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

作用：将src1中的所有元素除以src2中的相应元素并乘scale，然后将结果刚在dst中。

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

作用：用scale除以src2中相应元素，然后将结果刚在dst中。

原理： $dst(I) = saturate(src1(I)*scale/src2(I))$

$dst(I) = saturate(scale/src2(I))$

cv::eigen()

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

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

cv::exp()

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

作用：求src中所有元素的指数，并将结果放在dst中。

原理： $dst[I]=e^{src(I)}$

cv::flip()

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

作用：将图像绕着x轴或y轴或双轴翻转。默认flipCode为0，绕x轴；>0，绕y轴；<0，绕双轴。

原理： $dst_{ij}=\left\{\begin{matrix} src_{src.rows-i-1,\: j} & if \: flipCode =0\\ src_{i, \: src.cols-j-1} & if \: flipCode >0\\ src_{src.rows-i-1,\:src.cols-j-1}& if \: flipCode <0 \end{matrix}\right.$

cv::gemm()

void cv::gemm(InputArray scr1, InputArray scr2, double alpha, InputArray scr3, double beta, Output dst, int flags=0)

作用：广义矩阵乘法，可实现矩阵乘法、转置后乘法、比例乘法等。

原理：通式： $dst=alpha\cdot op(src1)*op(src2)+beta\cdot op(src3)$

例如：cv::gemm(src1, src2, alpha, src3, beta, dst, cv::GEMM_!_T + cv::GEMM_3_T)的实际运算如下：

$dst=alpha\cdot src1^T*src2+beta\cdot src3^T$

cv::hconcat()

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

cv::hconcat(InputArrayOfArrays src, OutputArray dst)

作用：按行合并。

cv::idct()

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

作用：计算一维或二维数组的反离散余弦变换。和cv::dct(src, dst, flags | cv::DCT_INVERSE)作用相同。

cv::idft()

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

作用：计算一维或二维数组的离散傅里叶反变换。和cv::dft(src, dst, flags | cv::DFT_INVERSE, outputRows)作用相同。

cv::inRange()

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

作用：检查数组元素是否位于其他两个数组的元素之间。

原理：单通道： $dst(I)=lowerb(I)_{0}\leqslant src(I)_0\leqslant upperb(I)_0$

双通道： $dst(I)=lowerb(I)_{0}\leq src(I)_0\leq upperb(I)_0\wedge {lowerb(I)_{1}\leq src(I)_1\leq upperb(I)_1}$

cv::invert()

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

作用：求浮点型矩阵src的逆，支持一下几种求逆方法。

cv::invert()方法参数的可能值
参数值	意义	注意
cv::DECOMP_LU	高斯消除法	正定矩阵
cv::DECOMP_SVD	奇异值分解	奇异矩阵
cv::DECOMP_CHOLESKY		只用于对称正定矩阵

cv::log()

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

作用：求src的自然对数，并将结果放在dst中。

原理： $dst(I) = \left\{\begin{matrix} log(src(I)) & src(I) > 0\\ -C & src(I)\leqslant 0 \end{matrix}\right.$

cv::LUT()

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

作用：执行数组的查找表转换。

原理： $dst(I)\leftarrow lut(src(I) + d), d=\left\{\begin{matrix} 0 & src\: has\: depth\: CV\_8U\\ 128& src\: has\: depth\: CV\_8S \end{matrix}\right.$

cv::magnitude()

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

作用：计算二维向量场上笛卡尔坐标系到极坐标系转换的径向部分。

原理： $dst(I) = \sqrt{x(I)^2+y(I)^2}$

cv::Mahalanobis()

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

作用：计算两个矢量之间的马氏距离（一点到高斯分布中心之间的向量距离）。

原理： $d(v1, v2) = \sqrt{\sum_{i,\: j}icovar(i,\: j)\cdot (v1(I) - v2(I))\cdot (v1(j)-v2(j))}$

cv::max()

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

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

作用：计算src1和src2中每个对应元素的最大值。

原理： $dst(I)=\left\{\begin{matrix} max(src1(I), src2(I)) &two \: arrays \\ max(src1(I), value)& array\: and \: a\: scalar \end{matrix}\right.$

cv::mean()

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

作用：计算输入矩阵src中未被屏蔽的所有像素的平均值，如果为多通道，则为每个通道计算结果。

原理：

$N=\sum _{I:mask(I)\neq 0}1$

$M_c=(\sum _{I:mask(I)\neq 0}src(I)_c)/N$

cv::meanStdDev()

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

作用：计算输入矩阵src中未被屏蔽的所有像素的平均值及其标准差，如果为多通道，则为每个通道计算结果。

原理：

$N=\sum _{I:mask(I)\neq 0}1$

$M_c=(\sum _{I:mask(I)\neq 0}src(I)_c)/N$

$S_c=\sqrt{(\sum _{I:mask(I)\neq 0}(src(I)_c)-M_c)^2/N}$

cv::merge()

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

void cv::merge(const vector<cv::Mat>& mv, OutputArray dst)

作用：从多个单通道数组中创建一个多通道数组。

cv::min()

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

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

作用：计算src1和src2中每个对应元素的最大值。

原理： $dst(I)=\left\{\begin{matrix} mix(src1(I), src2(I)) &two \: arrays \\ mix(src1(I), value)& array\: and \: a\: scalar \end{matrix}\right.$

cv::minMaxIdx()

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

作用：找到src中未被屏蔽的元素的最大值和最小值及其索引。适用于任意维数单通道矩阵。

cv::minMaxLoc()

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

作用：找到src中未被屏蔽的元素的最大值和最小值及其索引。适用于二单通道矩阵。

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

作用：作用于稀疏矩阵，仅考虑有效元素。

cv::mixChannels()

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)

作用：将输入的src的通道按照特定的顺序重新排列，然后输出到std中。

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

cv::mulSpectrums()

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

作用：执行两个傅里叶谱的每个元素的乘法运算。该函数对两个由实数傅里叶变换或复数傅里叶变换得到的CCS-packed矩阵或复数矩阵进行每个元素的乘法运算。

该函数于dft或idft一起使用时，可快速计算两个矩阵的卷积（设置conjB=true）或相关性（设置conjB=false）。当两个矩阵是复数矩阵时，只需使用第二数组元素的可选共轭乘(每个元素)。当它们是实数矩阵时，则被看作是CCS-packed矩阵。

cv::multiply()

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

作用：将src1中的元素乘以src2中对应的元素，再乘以scale，得到的结果存在dst中。

原理： $dst(I)=saturate(scale\cdot src1(I)\cdot src2(I))$

cv::mulTransposed()

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

作用：用于计算二维单通道矩阵与其转置的乘积。delta有提供则先减去，但不限制其大小，大小不满足时采取填补，阿布cv::repeat()进行填补。若没有提供则，不需要减去这一步骤。

原理： $dst=\left\{\begin{matrix} scale(src-delta)^T(src-delta)& aTa=true\\ scale(src-delta)(src-delta)^T& aTa=false \end{matrix}\right.$

cv::norm()

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

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

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

作用：计算矩阵的范数，或是提供两个矩阵，计算两矩阵间的各种距离。

原理：

当src2=NULL时，对不同的normType值，计算范数的公式
normType	公式
cv::NORM_INF	$\left \\| src1 \right \\|_\infty =max_iabs(src1_i)$
cv::NORM_L1	$\left \\| src1 \right \\|_{L1} =\sum_iabs(src1_i)$
cv::NORM_L2	$\left \\| src1 \right \\|_{L2} =\sqrt{\sum_isrc1_i^2 }$

当src2非空时，对不同的normType值，计算范数的公式
normType	公式
cv::NORM_INF	$\left \\| src1-src2 \right \\|_{\infty }=max_iabs(src1_i-src2_i)$
cv::NORM_L1	$\left \\| src1-src2 \right \\|_{L1}=\sum_iabs(src1_i-src2_i)$
cv::NORM_L2	$\left \\| src1-src2 \right \\|_{L2}=\sum_i(src1_i-src2_i)^2$
cv::NORM_RELATIVE_INF	$\frac{\left \\| src1-src2 \right \\|_\infty }{\left \\| src2 \right \\|_\infty }$
cv::NORM_RELATIVE_L1	$\frac{\left \\| src1-src2 \right \\|_{L1}}{\left \\| src2 \right \\|_{L1}}$
cv::NORM_RELATIVE_L2	$\frac{\left \\| src1-src2 \right \\|_{L2}}{\left \\| src2 \right \\|_{L2}}$

cv::normalize()

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::normalize(const SparseMat& src, SparseMat& dst, double alpha, int normType)

作用：规范化数组的范数或值范围。

原理： $\left \| dst \right \|_{\infty ,\, L1,\, L2}=alpha$

$min(dst)=alpha,\: max(dst)=beta$

normType的可能值及其公式
normType	公式
cv::NORM_INF	$\left \\| dst \right \\|_\infty =max_iabs(dst_i)$
cv::NORM_L1	$\left \\| dst \right \\|_{L1} =\sum_iabs(dst_i)$
cv::NORM_L2	$\left \\| dst \right \\|_{L2} =\sqrt{\sum_idst_i^2 }$
cv::NORM_MINMAX	映射到区间[alpha, beta]

注：cv::NORM_MINMAX不适用于稀疏矩阵，原因是cv::MINMAX操作可以用于整体偏移，所有元素都变为非0元素，从而影响矩阵的稀疏性。

cv::perspectiveTransform()

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

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

原理：该函数将src的每个元素转换成一个2D或3D矢量，方法如下：

$\begin{bmatrix} x^'\\ y^'\\ z^'\\ \omega ^' \end{bmatrix} \rightarrow \begin{bmatrix} m \end{bmatrix} \begin{bmatrix} x\\ y\\ z\\ 1 \end{bmatrix}$ $\begin{bmatrix} x\\ y \\z \end{bmatrix} \rightarrow \begin{bmatrix} x^'/\omega \\ y^'/\omega\\ z^'/\omega \end{bmatrix}$

$\omega =\left\{\begin{matrix} \omega ^{'}, & \omega ^{'}\neq 0\\ \infty, & \omega ^{'}=0 \end{matrix}\right.$

cv::phase()

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

作用：对二维矢量场计算笛卡尔-极坐标转换的方位角部分。x和y均是单通道矩阵。

原理： $angle(I)=atan2(y(I), x(I))$

cv::polarToCart()

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

作用：从向量场的极坐标中计算笛卡尔坐标（x，y）。当anglelnDegrees为真，angle用角度表示，否则用弧度表示。

原理： $x(I)=magnitude(I)cos(angle(I))$

$y(I)=magnitude(I)sin(angle(I))$

cv::pow()

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

作用：对矩阵逐元素取power次幂。

原理：若power为整数，直接进行幂运算；否则，先计算原矩阵的绝对值，再进行p次幂（只要实数值）。

cv::randu()

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

作用：使用均匀分布随机填充矩阵dst。

cv::randn()

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

作用：使用随机正态分布的值填充矩阵dst。

cv::randShuffle()

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

作用：通过选择随机元素对并交换其位置来随机化一维矩阵中的元素。交换的数量等于矩阵的尺寸乘以可选因子iterFactor。可选随机生成器，若未提供，则采用theRNG()。

cv::reduce()

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

作用：对输入的矩阵的每一行或每一列进行系统转化，直到只剩一行或一列为止，是指称为vec。

原理：

参数rtype的值及其含义
值	含义
cv::REDUCE_SUM	计算向量的总和
cv::REDUCE_AVG	计算向量的平均值
cv::REDUCE_MAX	计算向量的最大值
cv::REDUCE_MIN	计算向量的最小值

dim的取值及其含义
值	含义
0	合并成一行
1	合并成一列

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

cv::repeat()

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

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

作用：将src中的内容复制到dst中，根据复制的次数填充dst。

cv::scaleAdd()

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

作用：计算两个矩阵的和，在求和之前，将比例因子scale应用于第一个矩阵，结果放在dst中。

原理： $dst(I)=scale\cdot src1(I)+src2(I)$

相当于： $dst=scale*src1+src2$

cv::setIdentity()

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

作用：将行数和列数相等的元素设置为s，默认为1，其他元素设置为0。

原理： $mtx(i,j)=\left\{\begin{matrix} s& i=j\\ 0& i\neq j \end{matrix}\right.$

cv::solve()

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

作用：基于cv::invert()的函数cv::solve()为求解线性系统提供了一条捷径，目标是寻找最优向量，并存在dst中。只支持浮点数据类型。结果返回0代表未找到或存在问题，否则代表找到一个解。

原理： $C=argmin_{dst}\left \| scr1\cdot dst-src2 \right \|$

flags参数的可能值
flags的值	含义
cv::DECOMP_LU	高斯消元法（LU分解）
cv::DECOMP_SVD	奇异值分解（SVD）
cv::DECOMP_CHOLESKY	对于对称正定矩阵
cv::DECOMP_EIG	特征值分解，只用于对称矩阵
cv::DECOMP_QR	QR因式分解
cv::DECOMP_NORMAL	可选附加标志，表示要求解标准方程

cv::solveCubic()

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

作用：给定由三或四个元素向量系数表示的三次多项式，计算其实根。

原理：① 四个元素： $coeffs[0]x^3 + coeffs[1]x^2 +coeffs[2]x + coeffs[3] = 0$

② 三个元素： $x^3+coeffs[0]x^2+coeffs[1]x+coeffs[2]=0$

cv::solvePoly()

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

作用：求多项式方程的实根或复根。

原理： $coeffs[n]x^n + coeffs[n -1]x^{n-1} + \cdots +coeffs[1]x + coeffs[0] = 0$

这些根不能保证是实根，对于n阶多项式（具有n+1个元素的coeffs），将存在n个根。因此，矩阵roots将返回双通道（实部，虚部）双精度矩阵。

cv::sort()

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

作用：分别对每行或每列进行排序，仅适用于单通道二维矩阵。

cv::sortIdx()

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

作用：分别对每行或每列进行排序，结果是与原矩阵大小相同但包含排序元素整数索引的新矩阵dst。仅适用于单通道二维矩阵。

cv::split()

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

作用：将多通道矩阵中的通道分成多个单通道。mvbegin存储的是指向结果的Mat对象的指针。

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

作用：将多通道矩阵中的通道分成多个单通道。mv存储的是结果矩阵，将分配内存。

cv::sqrt()

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

作用：计算矩阵中每个元素的平方根

cv::subtract()

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

作用：计算两个数组或数组与标量之间的每个元素的差异。

原理： $dst(I) = saturate(src1(I) - src2(I))$ （最简单的情况）

对于简单的情况：矩阵运算可得到相同的结果： $dst = src1 - src2$

也支持： $dst -= src1$ ，相当于subtract(dst, src1, dst)

cv::sum()

cv::Scalar cv::sum(InputArray src)

作用：计算矩阵src各个通道的所有像素的总和，最多四个通道。

cv::theRNG()

RNG& cv::theRNG()

作用：返回默认随机数生成器。函数cy:theRNG返回默认随机数生成器。每一个线程有一个单独的随机数生成器，所以可以在多线程环境中安全使用该函数。如果只需要使用这个生成器获得一个随机数或初始化一个数组，可以使用randu或randn代替。但是如果想在一个循环中产生很多随机数，使用这个函数检索生成器，然后使用RNG::operator_Tp()，这样速度要快得多。

cv::trace()

cv::Scalar cv::trace(InputArray mtx)

作用：求取矩阵的迹，返回一个标量

原理： $tr(mtx) = \sum_{i}mtx(i, i)$

在OpenCV中，迹是在cv::diag()的基础上实现的，因此输入的矩阵不需要是方阵。对于多通道矩阵，迹被计算为标量，因此标量的每个分量是响应通道上的和，最多有四个通道。

cv::transform()

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

作用：执行每个数组元素的矩阵变换，并将变换结果储存在dst中，该函数可用于N维点的几何变换、任意线性颜色空间变换(如各种RGB到YUV变换)、变换图像通道等。

原理：① m.cols == src.channels() 时， $dst(I) = m\cdot src(I)$

② m.cols == src.channels()+1时，src的通道空间向量将自动扩展1维，以1.0填充， $dst(I) = m\cdot [src(I); 1]$

cv::transpose()

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

作用：将src转置的结果赋给dst

原理： $dst(i, j) = src(j, i)$

注意：在复矩阵中不做复共轭。如有必要，应单独进行。

小结：本文主要介绍的就是以上内容，在OpenCV的官方文档中还有一些其他函数，如果有需要，大家可以点击一下网址，查看官方文档（英文）：https://docs.opencv.org/master/d2/de8/group__core__array.html