Opencv学习----矩阵操作-基本操作

5.1 基本操作

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

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

注意

当阵列具有深度CV_32S时，不应用饱和度。在溢出的情况下，您甚至可能得到负值。

参数

SRC1	第一个输入数组或标量。
SRC2	第二个输入数组或标量。
DST	输出数组，其大小和类型与输入数组相同。

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

计算两个数组或数组和标量的每元素总和。

注意

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

参数

SRC1	第一个输入数组或标量。
SRC2	第二个输入数组或标量。
DST	输出数组，其大小和通道数与输入数组相同; 深度由dtype或src1 / src2定义。
mask	可选操作掩码 - 8位单通道数组，指定要更改的输出数组的元素。
dtype	输出数组的可选深度。

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

计算两个数组的加权和。

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

注意

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

参数

src1	第一个输入数组。
alpha	第一阵列元素的重量。
src2	第二个输入数组，其大小和通道号与src1相同。
beta	第二阵列元件的重量。
gamma	标量加到每个总和。
dst	输出数组，其大小和通道数与输入数组相同。
dtype	输出数组的可选深度; 当两个输入数组具有相同的深度时，dtype可以设置为-1，这相当于src1.depth（）。

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

计算两个数组的逐位与(dst = src1 & src2)计算两个数组或数组与标量的逐元素逐位与。

参数

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

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

反转数组的每一位。

参数

src	输入数组。
dst	输出数组，其大小和类型与输入数组相同。
mask	可选操作掩码，8位单通道数组，指定要更改的输出数组的元素。

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

计算两个数组或数组和标量的每元素逐位或。

参数

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

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

在两个数组或数组和标量上计算每个元素按位“异或”运算。

参数

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

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

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

函数cv::checkRange检查每个数组元素既不是NaN也不是infinite。当minVal > -DBL_MAX和maxVal < DBL_MAX时，函数还检查minVal和maxVal之间的每个值。对于多通道阵列，每个通道都是独立处理的。如果某些值超出了范围，第一个异常值的位置将存储在pos中(当pos != NULL时)。然后，函数要么返回false(当quiet=true时)，要么抛出异常。

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

执行对两个数组或数组和标量值的每个元素的比较。

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

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

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

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

cv::convertFp16 (InputArray src, OutputArray dst)

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

该函数将FP32(单精度浮点数)从/转换为FP16(半精度浮点数)。CV_16S格式用于表示FP16数据。有两种使用模式(src -> dst): CV_32F -> CV_16S和CV_16S -> CV_32F。输入数组必须具有CV_32F或CV_16S类型来表示位深度。如果输入数组两者都不是，则函数将引发错误。IEEE 754-2008定义了半精度浮点数的格式。

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

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

对于多通道阵列，函数独立处理每个通道。当输出不是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) 也可以完成这项工作,
//但它会分配一个临时矩阵

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

执行广义矩阵乘法。

cv::extractChannel (InputArray src, OutputArray dst, int coi)

从src中提取单个通道(coi是基于0的索引)

cv::findNonZero (InputArray src, OutputArray idx)

返回非零像素的位置列表。

给定一个二进制矩阵(可能从一个操作返回，如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];

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

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

函数检查范围如下:

（1）对于单通道输入数组的每个元素:

（2）双通道数组:

也就是说，如果src（I）在指定的1D，2D，3D，...框内，则dst（I）设置为255（全1位），否则为0。

当下边界参数和/或上边界参数是标量时，应省略上述公式中下边和上边的索引（I）。

cv::insertChannel (InputArray src, InputOutputArray dst, int coi)

向dst插入单个通道（coi是从0开始的索引）

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

求矩阵的逆或伪逆。

cv::log (InputArray src, OutputArray dst)

计算每个数组元素的自然对数。

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

计算二维向量的大小。

函数cv:: amount计算由x、y数组对应元素构成的二维向量的大小:

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

计算两个向量之间的Mahalanobis距离。

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

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

cv::max (const UMat &src1, const UMat &src2, UMat &dst)

计算两个数组或一个数组和一个标量的每个元素的最大值。

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

计算数组元素的平均值。

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

计算数组元素的平均值和标准差。

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

cv::merge (InputArrayOfArrays mv, OutputArray dst)

函数cv::merge将多个数组合并成一个单一的多通道数组。也就是说，输出数组的每个元素都是输入数组元素的串联，其中第i个输入数组的元素被视为mv[i].channels()-元素向量。

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

cv::min (const Mat &src1, const Mat &src2, Mat &dst)

cv::min (const UMat &src1, const UMat &src2, UMat &dst)

计算两个数组或一个数组和一个标量的每个元素的最小值。

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

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

函数cv :: minMaxIdx查找最小和最大元素值及其位置。在整个数组中搜索极值，或者如果掩码不是空数组，则在指定的数组区域中搜索极值。该功能不适用于多通道阵列。如果需要在所有通道中找到最小或最大元素，请首先使用Mat :: reshape将数组重新解释为单通道。或者您可以使用extractImageCOI或mixChannels或split来提取特定通道。在稀疏矩阵的情况下，仅在非零元素中找到最小值。

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

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

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

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

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

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

函数cv::mixChannels提供了一种高级的图像通道变换机制。

cv::split,cv::merge,cv::extractChannel,cv::insertChannel以及cv::cvtColor的一些形式都是cv:: mixchannel的部分案例。

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 (InputArray a, InputArray b, OutputArray c, int flags, bool conjB=false)

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

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

计算两个数组的每个元素缩放后的乘积。

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

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

计算数组的绝对值

cv::normalize (InputArray src, InputOutputArray dst, double alpha=1, double beta=0, int norm_type=NORM_L2, int dtype=-1, InputArraymask=noArray())

cv::normalize (const SparseMat &src, SparseMat &dst, double alpha, int normType)

数组元素归一化

vector<double> positiveData = { 2.0, 8.0, 10.0 };
vector<double> normalizedData_l1, normalizedData_l2, normalizedData_inf, normalizedData_minmax;
// Norm to probability (total count)
// 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);
// Norm to unit vector: ||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);
// Norm to max element
// 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);
// Norm to range [0.0;1.0]
// 2.0      0.0     (shift to left border)
// 8.0      0.75    (6.0/8.0)
// 10.0     1.0     (shift to right border)
normalize(positiveData, normalizedData_minmax, 1.0, 0.0, NORM_MINMAX);

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

将NaN转换为给定的数字

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

计算二维向量的旋转角度。

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

从二维向量的大小和角度计算它们的x和y坐标。

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

计算每个数组元素幂值。

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

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

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

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

随机打乱数组元素。

函数cv::randShuffle通过随机选择元素对并交换它们来打乱指定的一维数组。

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

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

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

将矩阵简化为向量。

函数reduce将矩阵行/列作为一维向量的集合，并对这些向量执行指定的操作，直到得到一个行/列，从而将矩阵简化为一个向量。例如，该函数可用于计算光栅图像的水平和垂直投影。对于REDUCE_MAX和REDUCE_MIN，输出图像应该与源图像具有相同的类型。在REDUCE_SUM和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]
*/

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

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

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

用输入数组的重复副本填充输出数组。

cv::rotate (InputArray src, OutputArray dst, int rotateCode)

以90度的倍数旋转2D数组。函数cv::rotate以三种不同的方式之一旋转数组:顺时针旋转90度(rotateCode = rotate_90_顺时针)。顺时针旋转180度(rotateCode = ROTATE_180)。顺时针旋转270度(rotateCode = rotate_90_逆时针旋转)。

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

计算一个缩放数组和另一个数组的和。

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

初始化一个缩放的单位矩阵。

cv::setRNGSeed (int seed)

设置默认随机数生成器的状态。

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

对矩阵的每行或每列进行排序。

函数cv :: sort按升序或降序对每个矩阵行或每个矩阵列进行排序。因此，您应该传递两个操作标志以获得所需的行为。如果要按字典顺序对矩阵行或列进行排序，可以使用STL std :: sort泛型函数和正确的比较谓词。

参数

src	输入单通道阵列。
dst	输出与src大小和类型相同的数组。
flags	操作标志，SortFlags的组合

 

enum SortFlags 
{ 
SORT_EVERY_ROW    = 0, //每个矩阵行都是独立排序的
SORT_EVERY_COLUMN = 1, //每个矩阵列都被排序，这个标志和前面的标志是独立的、互斥的.
SORT_ASCENDING    = 0, //每个矩阵行按升序排列。                                        
SORT_DESCENDING   = 16 //每个矩阵行按降序排列;这个标志和前面的标志也是互斥的。 
};

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

对矩阵的每行或每列进行排序。

Mat A = Mat::eye(3,3,CV_32F), B;
sortIdx(A, B, SORT_EVERY_ROW + SORT_ASCENDING);
// B will probably contain
// (because of equal elements in A some permutations are possible):
// [[1, 2, 0], [0, 2, 1], [0, 1, 2]]

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

cv::split (InputArray m, OutputArrayOfArrays mv)

将多通道数组划分为多个单通道数组。

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

cv::sqrt (InputArray src, OutputArray dst)

函数cv::sqrt计算每个输入数组元素的平方根。对于多通道阵列，每个通道都是独立处理的。精度与内置std::sqrt大致相同。

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

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

dst = src1 - src2;
dst -= src1; // equivalent to subtract(dst, src1, dst);

cv::sum (InputArray src)

计算数组元素的和。

cv::trace (InputArray mtx)

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

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

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

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

参数

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