一，opencv模块core内容第二部分——Operations on Arrays（对数组的操作）
计算机图像都是以矩阵的形式存储一个个像素点，而这些各种矩阵在计算机内存中实际上是以数组的形式真实存在的，只不过是通过类和面向对象的方式将其封装成了和matlab类似的矩阵。所以，各种对矩阵（数组）的操作也是opencv中核心内容之一。其基本功能和作用就相当于matlab中那些对矩阵操作的函数。
">
二，各个操作矩阵（数组）的函数
abs（绝对值函数）
1
2
3
4
5
6
7C++: MatExpr abs(const Mat& m)
C++: MatExpr abs(const MatExpr& e)
Parameters:
m – matrix.
e – matrix expression.
MatExpr - 就是一个Mat
C = abs(A);absdiff(计算两个矩阵差的绝对值)
1
C++: void absdiff(InputArray src1, InputArray src2, OutputArray dst)
两个输入参数src1和src2都是InputArray类型的，因而src1和src2不一定是Mat类型的数据。
有以下几种情况:
* src1 和src2是具有相同大小和类型的数组 `dst(I) = saturate(|src1(I) - src2(I)|)`
* src1和src2分别是数组和Scalar，并且数组的元素都是Scalar，或者数组元素通道数和Scalar相同`dat(I) = saturate(|src1(I) - src2|)`
* 与第二种情况相反`dat(I) = saturate(|src1 - src2（I）|)`
注意：当数组的深度为CV_32S时，并不会对数组进行饱和操作，然后可能计算后数据溢出，得到一个负数（即使进行了绝对值操作）
add(矩阵相加)
1
C++: void add(InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray(), int dtype=-1)
addWeighted
1
C++: void addWeighted(InputArray src1, double alpha, InputArray src2, double beta, double gamma, OutputArray dst, int dtype=-1)
也就是dst(I) = saturate(src1(I) * alpha + src2(I) * beta +gama)
- bitwise_add(按位相与)
1
C++: void bitwise_and(InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray())
也就是将数组每个元素按位相与dst(I) = saturate(src1(I) & src2(I))dat(I) = saturate(src1(I) & src2)dat(I) = saturate(src1 & src2（I）)
- bitwise_not(按位取非)
1
C++: void bitwise_not(InputArray src, OutputArray dst, InputArray mask=noArray())
也就是将数组每个元素按位取反
- bitwise_or（按位相或）
1
C++: void bitwise_or(InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray())
也就是将数组每个元素按位相或dst(I) = saturate(src1(I) | src2(I))dat(I) = saturate(src1(I) | src2)dat(I) = saturate(src1 | src2（I）)
bitwise_xor（按位异或）
1
C++: void bitwise_xor(InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray())
calcCovarMatrix
1
2C++: void calcCovarMatrix(const Mat* samples, int nsamples, Mat& covar, Mat& mean, int flags, int ctype=CV_64F)
C++: void calcCovarMatrix(InputArray samples, OutputArray covar, OutputArray mean, int flags, int ctype=CV_64F)
计算数组的协方差矩阵，mean是数组的均值，covar是输出的协方差矩阵，flags的值决定了输出的协方差矩阵的计算方法
flags 可能的取值：
* CV_COVAR_SCRAMBLED $scale*[vects[0] - mean, vects[1] - mean, ···]^T*[vects[0] - mean, vects[1] - mean, ···]$
* CV_COVAR_NORMAL $scale*[vects[0] - mean, vects[1] - mean, ···]*[vects[0] - mean, vects[1] - mean, ···]^T$
* CV_COVAR_USE_AVG 当flags被置为这个值时，mean将不再是输出的有输入数组计算出的均值，而是由我们提前计算好的或者是已知的均值作为参数传递进去
* CV_COVAR_SCALE 当flags被置为这个值时，输出的协方差矩阵covar将会乘上一个缩放因子scale。在norma和scrambled两种模式下的缩放因子scale都是1，只要flags补位scale模式，缩放因子都会被置为1.
* CV_COVAR_ROWS 当flags被置为这个值时，输入矩阵mat将会按行计算每一行的均值和协方差
* CV_COVAR_COLS 当flags被置为这个值时，输入矩阵mat将会按列计算每一列的均值和协方差
总之，本函数的主要作用就是计算输入数组的协方差，同时也可以计算其均值。
- cartToPolar
1
C++: void cartToPolar(InputArray x, InputArray y, OutputArray magnitude, OutputArray angle, bool angleInDegrees=false)
该函数将输入数组x和y转化为极坐标形式。
$mangnitude(I)^2 = x(I)^2 + y(I)^2$
$angle(I) = atan2(y(I), x(I))[180*pi]$
- checkRange
1
C++: bool checkRange(InputArray a, bool quiet=true, Point* pos=0, double minVal=-DBL_MAX, double maxVal=DBL_MAX )
该函数的作用是检查输入数组的每一个元素的值是否在有效范围内。
- compare
1
C++: void compare(InputArray src1, InputArray src2, OutputArray dst, int cmpop)
该函数比较两个数组的每一个元素的大小或者比较一个数组和一个标量的大小
flag cmpop的值类型：
* CMP_EQ src1 == src2
* CMP_GT src1 > src2
* CMP_GE src1 >= src2
* CMP_LT src1< src2
* CMP_LE src1 <= src2
* CMP_NE src1 != src2
- completeSymm
1
C++: void completeSymm(InputOutputArray mtx, bool lowerToUpper=false)
将输入矩阵（方阵）的下半或者是上半部分复制到另一半。构造了一个对称矩阵
- convertScaleAbs
1
C++: void convertScaleAbs(InputArray src, OutputArray dst, double alpha=1, double beta=0)
该函数对输入数组的每个元素有三个操作。缩放（scale），取绝对值（| |），转换到8bit数据。
`dst(I) = saturate_cast< uchar>(|src(I) alpha +beta|)`
- countNonZero
1
C++: int countNonZero(InputArray src)
计算输入数组中的非零元素的个数
- cvarrToMat
1
C++: Mat cvarrToMat(const CvArr* arr, bool copyData=false, bool allowND=true, int coiMode=0 )
将CvMat，IplImage或者是CvMatND等c语言类型的结构转换为Mat
- dct
1
C++: void dct(InputArray src, OutputArray dst, int flags=0)
对一维数组或者是二维数组执行一次正向或者是逆向的离散余弦变换
flags 的取值：DCT_INVERSE，对数组执行正想变换，而默认的是flags=0执行正向变换
DCT_ROWS，对输入矩阵的每一行执行正向或者是逆向变换
所有的可能情况：
1. 一维数组正向变换$Y = C^{(N)} \cdot X$
同时$C^{(N)}_{jk}= \sqrt{\alpha_j/N} \cos \left ( \frac{\pi(2k+1)j}{2N} \right )$而且$\alpha_0=1, \alpha_j=2 for j > 0.$
2. 一维数组逆向变换$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$ )
3. 二维数组正向变换$Y = C^{(N)} \cdot X \cdot \left (C^{(N)} \right )^T$
4. 二维数组逆向变换$X = \left (C^{(N)} \right )^T \cdot X \cdot C^{(N)}$
该函数根据输入数组的尺寸和flags的类型来决定执行何种操作。
- dft
1
C++: void dft(InputArray src, OutputArray dst, int flags=0, int nonzeroRows=0)
该函数对输入浮点型数组（一维或者2维）执行向前或逆向的离散傅里叶变换
flags的可能取值为：
DFT_INVERSE， 执行逆向傅里叶变换，默认执行正向傅里叶变换
DFT_SCALE，对结果进行缩放，通常和DFT_INVERSE一起使用
DFT_ROWS，对输入矩阵的每一行执行傅里叶变换
DFT_COMPLEX_OUTPUT，对实数数组执行傅里叶变换后，结果虽然是一个复数数组，但是却具有对偶性质，这样的数组可以包装成一个和原输入数组一样大小的实数数组，这种操作是默认的，而且快速。但是如果你非要使用原始的复数数组，那么就要设定这个参数了。这个函数就会产生一个原始大小的数组。
DFT_REAL_OUTPUT，对复数数组执行傅里叶逆变换后，结果会是一个和复数数组一样大小的复数数组。但是如果输入的复数数组是一个具有复数对偶性质的数组（例如由实数数组通过 DFT_COMPLEX_OUTPUT得到的复数数组），结果就会是一个实数数组。由于函数本身不会检查输入数组的对偶性质，所以你可以传递 DFT_REAL_OUTPUT来让函数认为输入数组是对偶的，然后输出的就是实数数组了
nonzeroRows的作用：当该参数不为零时，函数会假定只有输入数组或者只有输出数组的第一个非零行包含非零值，然后函数就直接操作第一个非零行剩下的行了，这样会让计算速度加快，节省时间。
以下是离散傅里叶变换的基本公式：
1. 一维正变换$Y = F^{(N)} \cdot X,F^{(N)}_{jk}=\exp(-2\pi i j k/N) $ and $i=\sqrt{-1}$
2. 一维逆变换$\begin{array}{l} X'= \left (F^{(N)} \right )^{-1} \cdot Y = \left (F^{(N)} \right )^* \cdot y \\ X = (1/N) \cdot X, \end{array},F^*=\left(\textrm{Re}(F^{(N)})-\textrm{Im}(F^{(N)})\right)^T$
3. 二维正变换$Y = F^{(M)} \cdot X \cdot F^{(N)}$
4. 二维逆变换$\begin{array}{l} X'= \left (F^{(M)} \right )^* \cdot Y \cdot \left (F^{(N)} \right )^* \\ X = \frac{1}{M \cdot N} \cdot X' \end{array}$
- divide
1
C++: void divide(InputArray src1, InputArray src2, OutputArray dst, double scale=1, int dtype=-1)
两个数组相除
具体情况有
$$\texttt{dst(I) = saturate(src1(I)*scale/src2(I))} $$
$$\texttt{dst(I) = saturate(scale/src2(I))} $$
- determinant
1
C++: double determinant(InputArray mtx)
计算浮点方阵的行列式（适用于小型矩阵），大型矩阵有其他更快速的算法。
- eigen
1
2C++: bool eigen(InputArray src, OutputArray eigenvalues, int lowindex=-1, int highindex=-1)
C++: bool eigen(InputArray src, OutputArray eigenvalues, OutputArray eigenvectors, int lowindex=-1, int highindex=-1)
该函数就算对称矩阵的特征值或者是特征值和特征向量
- exp
1
C++: void exp(InputArray src, OutputArray dst)
对数组执行指数操作。
$\texttt{dst} [I] = e^{ src(I) }$
- extractImageCOI
1
C++: void extractImageCOI(const CvArr* arr, OutputArray coiimg, int coi=-1 )
提取出选定的图像通道（该函数是从c语言类型的老式图像中提取通道）
- insertImageCOI
1
C++: void insertImageCOI(InputArray coiimg, CvArr* arr, int coi=-1 )
将基于c++的选定的图像通道复制到基于c的图像数组中
- flip
1
C++: void flip(InputArray src, OutputArray dst, int flipCode)
将一个2为数组在x或y或xy方向上进行反向
$$
\texttt{dst} _{ij} =
\left\{
\begin{array}{l l}
\texttt{src} _{\texttt{src.rows}-i-1,j} & if\; \texttt{flipCode} = 0 \\
\texttt{src} _{i, \texttt{src.cols} -j-1} & if\; \texttt{flipCode} > 0 \\
\texttt{src} _{ \texttt{src.rows} -i-1, \texttt{src.cols} -j-1} & if\; \texttt{flipCode} < 0 \\
\end{array}
\right.
$$
- gemm
1
C++: void gemm(InputArray src1, InputArray src2, double alpha, InputArray src3, double beta, OutputArray dst, int flags=0 )
表示一个广义的数组相乘
$\texttt{dst} = \texttt{alpha} \cdot \texttt{src1} ^T \cdot \texttt{src2} + \texttt{beta} \cdot \texttt{src3} ^T$
该函数可以被一个矩阵表达式替换dst = alpha*src1.t()*src2 + beta*src3.t();
- getConvertElem
1
2C++: ConvertData getConvertElem(int fromType, int toType)
C++: ConvertScaleData getConvertScaleElem(int fromType, int toType)
返回一个单像素的变换值。该函数返回的是一个函数指针，该函数将一个像素值类型转到另一个类型。1
2typedef void (*ConvertData)(const void* from, void* to, int cn)
typedef void (*ConvertScaleData)(const void* from, void* to, int cn, double alpha, double beta)
同时也可以对数组进行操作，只要设置cn = matrix.colsmatrix.rowsmatrix.channels()。
- getOptimalDFTSize
1
C++: int getOptimalDFTSize(int vecsize)
对一个给定的数组尺寸计算出它最好的DFT变换尺寸。
idct，idft
逆余弦函数变换，逆傅里叶变换inRange
1
C++: void inRange(InputArray src, InputArray lowerb, InputArray upperb, OutputArray dst)
检查输入数组是否在另外两个数组之间
单通道数组：
$$
\texttt{dst} (I)= \texttt{lowerb} (I)_0 \leq \texttt{src} (I)_0 \leq \texttt{upperb} (I)_0
$$
双通道数组
$$
\texttt{dst} (I)= \texttt{lowerb} (I)_0 \leq \texttt{src} (I)_0 \leq \texttt{upperb} (I)_0 \land \texttt{lowerb} (I)_1 \leq \texttt{src} (I)_1 \leq \texttt{upperb} (I)_1
$$
- invert
1
C++: double invert(InputArray src, OutputArray dst, int flags=DECOMP_LU)
求一个矩阵的逆或者是伪逆矩阵（逆矩阵的广义形式）
- log
1
C++: void log(InputArray src, OutputArray dst)
求矩阵的对数
$\texttt{dst} (I) = {\log |\texttt{src}(I)| } { if \texttt{src}(I) \ne 0 }$
$\texttt{dst} (I) = {\texttt{C }} { otherwise }$
- LUT
1
C++: void LUT(InputArray src, InputArray lut, OutputArray dst, int interpolation=0 )
对数组执行 显示查找表（look-up table） 变换。
$ \texttt{dst} (I) \leftarrow \texttt{lut(src(I) + d)}$
$d = {0} $ if src has depth CV_8U
$d = {128}$ if src has depth CV_8S
- magnitude
1
C++: void magnitude(InputArray x, InputArray y, OutputArray magnitude)
计算2维数组的模
$ \texttt{dst} (I) = \sqrt{\texttt{x}(I)^2 + \texttt{y}(I)^2}$
- Mahalanobis
1
C++: double Mahalanobis(InputArray v1, InputArray v2, InputArray icovar)
计算两个数组间的马氏距离。
$d( \texttt{vec1} , \texttt{vec2} )= \sqrt{\sum_{i,j}{\texttt{icovar(i,j)}\cdot(\texttt{vec1}(I)-\texttt{vec2}(I))\cdot(\texttt{vec1(j)}-\texttt{vec2(j)})} }$
- max
1
2
3
4
5
6C++: MatExpr max(const Mat& a, const Mat& b)
C++: MatExpr max(const Mat& a, double s)
C++: MatExpr max(double s, const Mat& a)
C++: void max(InputArray src1, InputArray src2, OutputArray dst)
C++: void max(const Mat& src1, const Mat& src2, Mat& dst)
C++: void max(const Mat& src1, double src2, Mat& dst)
计算两个数组或者一个数组和标量中的最大值
$\texttt{dst} (I)= \max ( \texttt{src1} (I), \texttt{src2} (I))$
$\texttt{dst} (I)= \max ( \texttt{src1} (I), \texttt{value} )$
- mean
1
C++: Scalar mean(InputArray src, InputArray mask=noArray())
计算数组的均值
$\begin{array}{l} N = \sum _{I: \; \texttt{mask} (I) \ne 0} 1 \ M_c = \left ( \sum _{I: \; \texttt{mask} (I) \ne 0}{ \texttt{mtx} (I)_c} \right )/N \end{array}$
- meanStdDev
1
C++: void meanStdDev(InputArray src, OutputArray mean, OutputArray stddev, InputArray mask=noArray())
计算数组的均值和标准差
$\begin{array}{l} N = \sum _{I, \texttt{mask} (I) \ne 0} 1 \ \texttt{mean} _c = \frac{\sum_{ I: \; \texttt{mask}(I) \ne 0} \texttt{src} (I)_c}{N} \ \texttt{stddev} _c = \sqrt{\frac{\sum_{ I: \; \texttt{mask}(I) \ne 0} \left ( \texttt{src} (I)_c - \texttt{mean} _c \right )^2}{N}} \end{array}$
- merge
1
2C++: void merge(const Mat* mv, size_t count, OutputArray dst)
C++: void merge(InputArrayOfArrays mv, OutputArray dst)
将一些单通道数组合并为一个多通道数组。
- min
1
2
3
4
5C++: MatExpr min(const Mat& a, const Mat& b)
C++: MatExpr min(const Mat& a, double s)
C++: MatExpr min(double s, const Mat& a)
C++: void min(InputArray src1, InputArray src2, OutputArray dst)
C++: void min(const Mat& src1, const Mat& src2, Mat& dst)
计算两个数组或者是数组和标量中的最小值
$\texttt{dst} (I)= \min ( \texttt{src1} (I), \texttt{src2} (I))$
$\texttt{dst} (I)= \min ( \texttt{src1} (I), \texttt{value} )$
- minMaxIdx
1
C++: void minMaxIdx(InputArray src, double* minVal, double* maxVal, int* minIdx=0, int* maxIdx=0, InputArray mask=noArray())
找到整个数组中最小的和最大的值，以及他们的索引
该函数只能对单通道数组进行操作，若要对多通道数组进行操作，需要提前将其分为单通道，可以用Mat::reshape()或者是extractImageCOI() , or mixChannels() , or split() 等。
加入输入矩阵是稀疏矩阵，最小值将会在非零元素中寻找。
- minMaxLoc
1
2C++: void minMaxLoc(InputArray src, double* minVal, double* maxVal=0, Point* minLoc=0, Point* maxLoc=0, InputArray mask=noArray())
C++: void minMaxLoc(const SparseMat& a, double* minVal, double* maxVal, int* minIdx=0, int* maxIdx=0 )
在整个数组中找到最小值，最大值以及他们的位置。和minMaxIdx相似，不支持多通道数组。
- minChannels
1
2C++: void mixChannels(const Mat* src, size_t nsrcs, Mat* dst, size_t ndsts, const int* fromTo, size_t npairs)
C++: void mixChannels(const vector<Mat>& src, vector<Mat>& dst, const int* fromTo, size_t npairs)
将输入数组中指定的通道数据复制到输出数组中指定的通道中。
fromTo 数组：
from[K2]表示输入矩阵数组中的输入通道索引，而from[k2+1]表示输出矩阵数组中的输出通道索引。第一幅输入图像（矩阵）的通道索引被放置在是0-src[0].channels()-1,第二幅输入图像（矩阵）的通道索引被放置在是src[0].channels()-src[0].channels+src[1].channels()-1，依次类推。相同的方法也应用于输出图像数组。作为一种特殊情况，当from[k*2]是负数时，相应的输出通道被0填充。
有如下实例1
2
3
4
5
6
7
8
9
10
11Mat rgba( 100, 100, CV_8UC4, Scalar(1,2,3,4) );
Mat bgr( rgba.rows, rgba.cols, CV_8UC3 );
Mat alpha( rgba.rows, rgba.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 };
// rgba[0] -> bgr[2], rgba[1] -> bgr[1],
// rgba[2] -> bgr[0], rgba[3] -> alpha[0]
int from_to[] = { 0,2, 1,1, 2,0, 3,3 };
mixChannels( &rgba, 1, out, 2, from_to, 4 );
该实例将4通道的rgba图像四个通道分别复制给了3通道的bgr和单通道的alpha。
- mulSpectrums
1
C++: void mulSpectrums(InputArray a, InputArray b, OutputArray c, int flags, bool conjB=false )
对两个傅里叶变换得到的频谱数组进行相乘运算。
该函数与dft（），idft（）一起被用于计算卷积（conjB=false）或者是相关性（conjB=true）。
- multiply
1
C++: void multiply(InputArray src1, InputArray src2, OutputArray dst, double scale=1, int dtype=-1 )
计算两个数组的相乘（每个元素相乘，点乘）。
$\texttt{dst} (I)= \texttt{saturate} ( \texttt{scale} \cdot \texttt{src1} (I) \cdot \texttt{src2} (I))$
- mulTransposed
1
C++: void mulTransposed(InputArray src, OutputArray dst, bool aTa, InputArray delta=noArray(), double scale=1, int dtype=-1 )
$\texttt{dst} = \texttt{scale} ( \texttt{src} - \texttt{delta} )^T ( \texttt{src} - \texttt{delta} )$
if aTa=true , and
$\texttt{dst} = \texttt{scale} ( \texttt{src} - \texttt{delta} ) ( \texttt{src} - \texttt{delta} )^T$
- norm
1
2C++: double norm(InputArray src1, int normType=NORM_L2, InputArray mask=noArray())
C++: double norm(InputArray src1, InputArray src2, int normType=NORM_L2, InputArray mask=noArray() )
计算输入数组的标准基。
当仅有输入数组src1时
if normType = NORM_INF $norm = {|\texttt{src1}|_{L_{\infty}} = \max _I | \texttt{src1} (I)|}$
if normType = NORM_L1 $norm = { | \texttt{src1} | _{L_1} = \sum _I | \texttt{src1} (I)|}$
if normType = NORM_L2 $norm = { | \texttt{src1} | _{L_2} = \sqrt{\sum_I \texttt{src1}(I)^2} }$
当输入数组有src1 和src2时
if normType = NORM_INF $norm = {\frac{|\texttt{src1}-\texttt{src2}|_{L_{\infty}} }{|\texttt{src2}|_{L_{\infty}} }}$
if normType = NORM_L1 $norm = { \frac{|\texttt{src1}-\texttt{src2}|_{L_1} }{|\texttt{src2}|_{L_1}} }$
if normType = NORM_L2 $norm = { \frac{|\texttt{src1}-\texttt{src2}|_{L_2} }{|\texttt{src2}|_{L_2}} }$
normalize
1
2C++: void normalize(InputArray src, OutputArray dst, double alpha=1, double beta=0, int norm_type=NORM_L2, int dtype=-1, InputArray mask=noArray() )
C++: void normalize(const SparseMat& src, SparseMat& dst, double alpha, int normType)PCA（主成分分析类）
该类用来计算一个数组集合的主要成分。这种主要成分包含了由输入数组集合计算得到的协方差矩阵的特征向量，PCA类也可以将向量和由主成分定义的新的坐标空间互相转换。在这个新的坐标系统中，每一个来自于输入集合的向量。······phase
1
C++: void phase(InputArray x, InputArray y, OutputArray angle, bool angleInDegrees=false)
计算2D向量的相位（旋转角）。
$\texttt{angle} (I) = \texttt{atan2} ( \texttt{y} (I), \texttt{x} (I))$
其计算精度大约是0.3度。
- polarToCart
1
C++: void polarToCart(InputArray magnitude, InputArray angle, OutputArray x, OutputArray y, bool angleInDegrees=false)
从输入数组的模和相位计算其直角坐标中的x和y。
- pow
1
C++: void pow(InputArray src, double power, OutputArray dst)
计算数组的幂次方
$\texttt{dst} (I) = {\texttt{src}(I)^p }$ if power is integer
$\texttt{dst} (I) = {|\texttt{src}(I)|^p }$ otherwise
RNG
随机数生成器。randu
1
2C++: template<typename _Tp> _Tp randu()
C++: void randu(InputOutputArray dst, InputArray low, InputArray high)
生成一组均匀分布的随机数组
- randn
1
C++: void randn(InputOutputArray dst, InputArray mean, InputArray stddev)
生成一组正太分布的随机数组
- randShuffle
1
C++: void randShuffle(InputOutputArray dst, double iterFactor=1., RNG* rng=0 )¶
将数组元素顺序打乱
- reduce
1
C++: void reduce(InputArray src, OutputArray dst, int dim, int rtype, int dtype=-1 )
将一个矩阵将为一个向量。
- repeat
1
2C++: void repeat(InputArray src, int ny, int nx, OutputArray dst)
C++: Mat repeat(const Mat& src, int ny, int nx)
将一个数组（x和y方向上）重复的填充到输出数组中。
- scaleAdd
1
C++: void scaleAdd(InputArray src1, double alpha, InputArray src2, OutputArray dst)
$\texttt{dst} (I)= \texttt{scale} \cdot \texttt{src1} (I) + \texttt{src2} (I)$
- setIdentity
1
C++: void setIdentity(InputOutputArray mtx, const Scalar& s=Scalar(1) )
得到一个被缩放的I矩阵。
- solve
1
C++: bool solve(InputArray src1, InputArray src2, OutputArray dst, int flags=DECOMP_LU)
解决一个或者多个线性系统或者最小二乘法问题。
- solveCubic
1
C++: int solveCubic(InputArray coeffs, OutputArray roots)
找到一个3次多项式的实根或者复根
$\texttt{coeffs} [0] x^3 + \texttt{coeffs} [1] x^2 + \texttt{coeffs} [2] x + \texttt{coeffs} [3] = 0$
$x^3 + \texttt{coeffs} [0] x^2 + \texttt{coeffs} [1] x + \texttt{coeffs} [2] = 0$
- solvePoly
1
C++: double solvePoly(InputArray coeffs, OutputArray roots, int maxIters=300 )
$\texttt{coeffs} [n] x^{n} + \texttt{coeffs} [n-1] x^{n-1} + … + \texttt{coeffs} [1] x + \texttt{coeffs} [0] = 0$
找到一个多项式等式的实根或者复根。
- sort
1
C++: void sort(InputArray src, OutputArray dst, int flags)
为一个矩阵的每行或者每列排序
- sortIdx
1
C++: void sortIdx(InputArray src, OutputArray dst, int flags)
为一个矩阵的每行或者每列排序
- split
1
2C++: void split(const Mat& src, Mat* mvbegin)
C++: void split(InputArray m, OutputArrayOfArrays mv)
将一个多通道数组分解为几个单通道数组。
$\texttt{mv} c = \texttt{src} (I)_c$
- sqrt
- subtract
1
C++: void subtract(InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray(), int dtype=-1)
计算两个数组或者一个数组和一个标量相减。
- SVD
一个为浮点类型的矩阵计算单值分解的类。 - sum
1
C++: Scalar sum(InputArray src)
计算数组元素的和
- trace
1
C++: Scalar trace(InputArray mtx)
返回矩阵的迹
$\mathrm{tr} ( \texttt{mtx} ) = \sum _i \texttt{mtx} (i,i)$
- theRNG
1
C++: RNG& theRNG()
返回默认的随机数生成器
transform
1
C++: void transform(InputArray src, OutputArray dst, InputArray m)
transpose
1
C++: void transpose(InputArray src, OutputArray dst)
矩阵转置
$\texttt{dst} (i,j) = \texttt{src} (j,i)$