OpenCV 矩阵常用操作，比如 addWeighted, flip, hconcat, reduce, merge, norm, repeat, split, sort, mulSpectrum 等

最新推荐文章于 2024-01-10 14:58:14 发布

程序员阿德

最新推荐文章于 2024-01-10 14:58:14 发布

阅读量1.5k

点赞数 2

分类专栏： C++ OpenCV 文章标签： C++ OpenCV 图像处理

本文链接：https://blog.csdn.net/baidu_36639782/article/details/117265287

版权

C++ 同时被 2 个专栏收录

5 篇文章 0 订阅

订阅专栏

OpenCV

4 篇文章 0 订阅

订阅专栏

平时经常会用到一些 C++ OpenCV 矩阵 Mat 常用的函数，每次用到都要到官网去查看，现在特地整理了一下。

下面的函数均来自于 https://docs.opencv.org/master/d2/de8/group__core__array.html

文章最后有惊喜哦~

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

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值，计算范数的公式

当src2非空时，对不同的normType值，计算范数的公式

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的可能值及其公式

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

cv::compare()

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

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

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

cv::compare()使用的cmpop值以及由此产生的比较操作

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个不同的一维向量。

原理：

其中， $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可取以下的值：

原理： $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）。

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::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)$

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参数值

标志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}$

其中是一个可选比例因子，除非使用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::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::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::perspectiveTransform()

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

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

原理：该函数将src的每个元素转换成一个2D或3D矢量。

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::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参数的可能值

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::reduce()

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

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

参数rtype的值及其含义

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

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

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

作者简介

我是阿德，一名五年工作经验的软件开发工程师，985高校非科班程序员，热爱编程与开源，

此公众号【程序员阿德】专注于分享各种计算机干货，包括但不限于计算机组成原理、数据结构与算法、计算机网络、操作系统、数据库、Linux等。

相信你能够在这里有所收获，精进为一名优秀程序员，我们一起加油~

现在关注公众号 [程序员阿德] ，回复【书籍】可以获取我精心挑选的10本经典计算机电子书，加速你的成长。

程序员阿德

关注

2
点赞
踩
10

收藏

觉得还不错? 一键收藏
1
评论
OpenCV 矩阵常用操作，比如 addWeighted, flip, hconcat, reduce, merge, norm, repeat, split, sort, mulSpectrum 等

平时经常会用到一些 C++ OpenCV 矩阵 Mat常用的函数，每次用到都要到官网去查看，现在特地整理了一下。下面的函数均来自于https://docs.opencv.org/master/d2/de8/group__core__array.htmlcv::mixChannels()voidcv::mixChannels(const Mat* src, size_t nsrcs, Mat* dst, size_t ndsts, const int* fromTo, size_t n...
复制链接

扫一扫