OpenCV 自带大量矩阵处理函数,本文记录相关内容。
序号 | 函数 | 描述 |
---|---|---|
1 | cv2.absdiff() | 计算两个矩阵差值的绝对值 |
2 | cv2.add() | 实现两个矩阵逐元素相加 |
3 | cv2.addWeighted() | 实现两个矩阵逐元素加权求和(以为混合值) |
4 | cv2.bitwise_and() | 计算两个矩阵逐元素按位与 |
5 | cv2.bitwise_not() | 按位非 |
6 | cv2.bitwise_or() | 计算两个矩阵逐元素按位或 |
7 | cv2.bitwise_xor() | 计算两个矩阵逐元素按位异或 |
8 | cv2.calcCovarMatrix() | 计算一组n维向量的协方差 |
9 | cv2.cartToPolar() | 计算二维向量的角度和幅度 |
10 | cv2.checkRange() | 检查矩阵的无效值 |
11 | cv2.compare() | 对两个矩阵中的所有元素应用所选择的比较运算符 |
12 | cv2.completeSymm() | 通过将一半元素复制到另一半来使矩阵对称 |
13 | cv2.convertScaleAbs() | 缩放矩阵,取绝对值,然后转换为8位无符号数 |
14 | cv2.countNonZero() | 计算矩阵中非零元素个数 |
15 | cv2.cvtColor() | 转换图像颜色空间 |
16 | cv2.dct() | 计算矩阵的离散余弦变换 |
17 | cv2.determinant() | 计算方阵的行列式 |
18 | cv2.dft() | 计算矩阵的离散傅里叶变换 |
19 | cv2.divide() | 实现两个矩阵逐元素相除 |
20 | cv2.eigen() | 计算方阵的特征值和特征向量 |
import cv2
import numpy as np
import mtutils as mt
from mtutils import PIS
img1.jpg
和 img2.jpg
计算两个矩阵差值的绝对值
matrix_a = np.random.random([5,5])
matrix_b = np.random.random([5,5])
res = cv2.absdiff(matrix_a, matrix_b)
实现两个矩阵逐元素相加
matrix_a = np.random.random([5,5])
matrix_b = np.random.random([5,5])
res = cv2.add(matrix_a, matrix_b)
实现两个矩阵逐元素加权求和(以为混合值)
addWeighted(src1, alpha, src2, beta, gamma)
参数说明src1图像1alpha图像1 权重 (例如 0.5)src2图像2beta图像2 权重 (例如 0.5)gamma附加偏置
image_1 = mt.cv_rgb_imread('img1.jpg')
image_1 = mt.image_resize(image_1, [300, 300])
image_2 = mt.cv_rgb_imread('img2.jpg')
image_2 = mt.image_resize(image_2, [300, 300])
res1 = cv2.addWeighted(image_1, 0.8, image_2, 0.3, 5)
res2 = cv2.addWeighted(image_1, 0.5, image_2, 0.5, 5)
PIS(image_1, image_2, res1, res2)
对应像素按位与
image_1 = mt.cv_rgb_imread('img1.jpg')
image_2 = mt.cv_rgb_imread('img2.jpg')
image_1 = mt.image_resize(image_1, [300, 300])
image_2 = mt.image_resize(image_2, [300, 300])
res = cv2.bitwise_and(image_1, image_2)
PIS(res)
(cv2.bitwise_and(image_1, image_2) == image_1 & image_2).all()
->
True
按位非
image_1 = mt.cv_rgb_imread('img1.jpg')
image_2 = mt.cv_rgb_imread('img2.jpg')
image_1 = mt.image_resize(image_1, [300, 300])
image_2 = mt.image_resize(image_2, [300, 300])
res = cv2.bitwise_not(image_1)
PIS(res)
计算两个矩阵逐元素按位或
image_1 = mt.cv_rgb_imread('img1.jpg')
image_2 = mt.cv_rgb_imread('img2.jpg')
image_1 = mt.image_resize(image_1, [300, 300])
image_2 = mt.image_resize(image_2, [300, 300])
res = cv2.bitwise_or(image_1, image_2)
PIS(res)
计算两个矩阵逐元素按位异或
image_1 = mt.cv_rgb_imread('img1.jpg')
image_2 = mt.cv_rgb_imread('img2.jpg')
image_1 = mt.image_resize(image_1, [300, 300])
image_2 = mt.image_resize(image_2, [300, 300])
res = cv2.bitwise_xor(image_1, image_2)
PIS(res)
给定一些向量,假设这些向量表示的点是近似高斯分布的,
cv2.calcCovarMatrix()
将计 算这些点的均值和协方差矩阵。
cv2.calcCovarMatrix(samples, flags[, covar[, mean[, ctype]]]) → covar, mean
Flags | 含义 |
---|---|
CV_COVAR_SCRAMBLED | 快速PCA“scrambled”协方差,转置位置不同的计算方式,与 CV_COVAR_NORMAL 互斥 |
CV_COVAR_NORMAL | 计算均值和协方差,正常计算协方差,与 CV_COVAR_SCRAMBLED 互斥 |
CV_COVAR_USE_AVG | 输入均值而不是计算均值(在均值已知情况下减少运算时间) |
CV_COVAR_SCALE | 重新缩放输出的协方差矩阵 |
CV_COVAR_ROWS | 使用样本的行作为输入向量(如输入向量为 m * n 则需要指定) |
CV_COVAR_COLS | 使用样本的列作为输入向量(如输入向量为 m * n 则需要指定) |
vector = np.array([[1,2,3], [4,5,6], [7, 8, 9]]).astype('float32')
covar, mean = cv2.calcCovarMatrix(vector, None, flags=cv2.COVAR_NORMAL | cv2.COVAR_COLS )
-->
covar
array([[2., 2., 2.],
[2., 2., 2.],
[2., 2., 2.]])
mean
array([[2.],
[5.],
[8.]])
计算二维向量的角度和幅度,笛卡尔坐标转极坐标
magnitude, angle = cv2.cartToPolar(x, y)
X, Y
向量 (float32 或 float64),返回相同维度的坐标转换结果vector = np.array([[1,1,1],[1,1,1]]).astype('float32')
X =vector
Y = vector
mag, ang = cv2.cartToPolar(X, Y)
-->
mag
array([[1.4142135, 1.4142135, 1.4142135],
[1.4142135, 1.4142135, 1.4142135]], dtype=float32)
ang
array([[0.7852316, 0.7852316, 0.7852316],
[0.7852316, 0.7852316, 0.7852316]], dtype=float32)
函数
cv2.checkRange()
检查输入矩阵src的每个元素,并确定该元素是否在给定范围内。范围由minVal
和maxVal
设置,但任何NaN或inf值也被认为超出范围。如果找到超出范围的值,除非将quiet设置为true,否则抛出异常。在这种情况下,如果所有值都在范 围内,返回值就为true;如果有任何值超出范围,返回值则为false。
image_1 = mt.cv_rgb_imread('img1.jpg')
cv2.checkRange(image_1, False, 0, 255)
该函数在两个矩阵
src1
和src2
中的对应元素之间进行逐元素比较,并将结果放在图像dst中。cv2.compare()
将最后一个参数作为比较运算符。在每种情况下,结果dst
的每个像素都是一个8位序列,匹配的像素被标记为255,不匹配的像素被设置为0。 通过 numpy 的矩阵运算也完全可以实现。
cv2.compare(src1, src2, cmpop)
cmp_op | 比较操作 |
---|---|
cv2.CMP_EQ | src1i == src2i |
cv2.CMP_GT | src1i > src2i |
cv2.CMP_GE | src1i >= src2i |
cv2.CMP_LT | src1i < src2i |
cv2.CMP_LE | src1i <= src2i |
cv2.CMP_NE | src1i != src2i |
vector_1 = np.random.random([5,5,5,5])
vector_2 = np.random.random([5,5,5,5])
res = cv2.compare(vector_1, vector_2, cmpop=cv2.CMP_GE)
-->
res
array([[[[ 0, 0, 0, 255, 255],
[ 0, 0, 255, 255, 255],
[ 0, 255, 255, 255, 255],
[255, 255, 0, 255, 0],
[ 0, 255, 0, 0, 255]],
...
res.shape
(5, 5, 5, 5)
给定一个(二维)矩阵 mtx,
cv2.completeSymm()
通过复制来使矩阵对称注1。具体来说,来自上三角形的所有元素都被复制到它们在矩阵下三角形对应的转置位置。tx的对角元素保持不变。如果标志lowerToUpper
设置为true,则来自下三角形的元素将被复制到上三角形中。
vector_1 = np.random.random([5,5])
res = cv2.completeSymm(vector_1, lowerToUpper=False)
-->
res
array([[0.2604316 , 0.57123429, 0.24625302, 0.51625787, 0.53749169],
[0.57123429, 0.2294393 , 0.17753148, 0.29501751, 0.34551 ],
[0.24625302, 0.17753148, 0.08954819, 0.3061089 , 0.57356678],
[0.51625787, 0.29501751, 0.3061089 , 0.54457652, 0.61120996],
[0.53749169, 0.34551 , 0.57356678, 0.61120996, 0.03919279]])
缩放矩阵,取绝对值,然后转换为8位无符号数 函数
cv2.convertScaleAbs()
实际上融多种功能于一体。它将按顺序执行四个操作。第一个操作是通过因子alpha
来重新调整源图像,第二个操作是通过(加)因子beta
来偏移,第三个操作是计算上述所求和的绝对值,第四个操作是将该结果(饱和)映射到一个无符号字符型(8位)。
cv2.convertScaleAbs(src, alpha=1.0, beta=0.0)
vector = np.random.random([100, 100]) * 200
res = cv2.convertScaleAbs(vector, alpha=1.0, beta=0.0)
-->
res
array([[ 22, 155, 35, ..., 123, 98, 187],
[137, 191, 163, ..., 19, 65, 105],
[176, 128, 137, ..., 56, 44, 85],
...,
[130, 47, 113, ..., 165, 60, 174],
[169, 172, 47, ..., 97, 107, 144],
[ 66, 78, 86, ..., 154, 113, 82]], dtype=uint8)
计算矩阵中非零元素个数
vector = np.random.random([100, 100])
vector = np.clip(vector - 0.3, 0, 1)
num = cv2.countNonZero(vector)
-->
num
7007
cv2.cvtColor()
函数用于将图像在保留相同数据类型的同时从一个颜色空间(通道数)转换到另一个颜色空间。
dst = cv2.cvtColor(src, code, dstCn=0)
输入矩阵src
可以是8位矩阵,16位无符号矩阵或32位浮点矩阵。输出矩阵dst
将具有与输入矩阵相同的尺寸和深度。要完成的转换操作由编码参数指定。最终参数dstCn
是目标图像中所需的通道数。如果给出默认值0,则通道数由src
中的通道数和转换编码确定。
计算矩阵的离散余弦变换
flags
参数的值执行离散余弦变换或离散余弦逆变换。源矩阵src
必须是一维或二维的,并且尺寸应该是偶数(如果需要,可以填充矩阵)。结果矩阵dst
将具有与src
相同的类型和尺寸。参数flags
是一个位域值,可以设置为cv2.DCT_INVERSE
或cv2.DCT_ROWS
中的一个或两个。
cv2.dct(src, flags) --> dst
src
需要为一维或二维的 float32 或 float64 数据flags
不设置默认正向变换flags
如果设置为cv2.DCT_INVERSE
,则实现逆变换而不是前向变换。flags
如果设置标志为cv2.DCT_ROWS
,则将二维n×m的输入视为长度为m的n个不同的一维向量。在这种情况下,每个这样的向量将被独立地变换。cv2.dct()
的性能很大程度上取决于传递给它的矩阵的确切尺寸,这种关系(性能与尺寸的关系)并不是单调的。只有一些尺寸是比其他尺寸表现出的性能更好。建议在将矩阵传递给 cv2.dct()
时,首先在比当前矩阵大的尺寸中确定最佳尺寸,然后将矩阵扩展为该尺寸。OpenCV 为你提供了一个合适的例程来计算这个值,称为 cv2.getOptimalDFTSize()
。
image = mt.cv_rgb_imread('img1.jpg')
image = mt.image_resize(image, [300, 300]).astype('float32')
image = mt.to_gray_image(image)
dct_res = cv2.dct(image)
inverse_img = cv2.dct(dct_res, flags=cv2.DCT_INVERSE)
PIS(image, (dct_res*150).astype('uint8'), inverse_img.astype('uint8'))
计算方阵的行列式
vector =(np.random.random([3, 3]) * 5).astype('int32').astype('float32')
res = cv2.determinant(vector)
-->
vector
array([[1., 2., 2.],
[0., 4., 3.],
[0., 3., 1.]], dtype=float32)
res
-5.0
计算矩阵的离散傅里叶变换
cv2.dft()
函数实现离散傅里叶变换以及其逆变换(取决于flags
参数)。源矩阵src
必须是一维或二维的。结果矩阵dst
将具有与src
相同的类型和尺寸。
参数flags
是一个位域值,可以设置为cv2.DFT_INVERSE
,cv2.DFT_ROWS
,cv2.DFT_SCALE
,cv2.DFT_COMPLEX_OUTPUT
或cv2.DFT_REALOUTPUT
中的一个或多个。
cv2.dft(src, flags=0, nonzeroRows=0)
cv2.DFT_INVERSE
,则完成逆变换。
cv2.DFT_ROWS
,则二维n×m输入被视为长度为m的n个不同的一维向量,并且每个这样的向量将独立变换。
cv2.DFT_SCALE
通过将结果除以矩阵中的元素数来标准化结果,这通常用于DFT_INVERSE,因为它保证逆的逆将具有正确的标准化。
cv2.DFT_COMPLEX_OUTPUT
:和cv2.DFT_REAL_OUTPUT
是有用的,因为当计算实数矩阵的傅里叶变换时,结果将有复共轭对称性。因此,即使结果是复数,结果矩阵的元素数量等于输入矩阵中的元素数量,而不是该数量的两倍。这样的压缩是cv2.dft()
的默认行为。
cv2.DFT_COMPLEX_OUTPUT
。在逆变换的情况下,输入(通常)为复数,输出也为复数。然而,如果输入矩阵(对逆变换的情况)具有复共轭对称性(例如,如果它本身是实数矩阵的傅里叶变换的结果),那么逆变换将是一个实数矩阵。如果知道是这种情况,并且希望结果矩阵表示为一个实数矩阵(从而使用一半的内存量),则可以设置cv2.DFT_REAL_OUTPUT
标志。
cv2.DFT_REAL_OUTPUT
标志,cv2.dft()
不会检查输入矩阵是否具有必要的对称性,它只是假定具有对称性。
cv2.dft()
的最后一个参数是nonzeroRows
,它默认为0,但如果设置它为任何非0值,将导致cv2.dft()
认为只有输入矩阵的前nonzeroRows
行是有意义的。如果cv2.DFT_INVERSE
被设置,那么就认为只有输出矩阵的前nonzeroRows
行是非零的。在使用cv2.dft()
计算卷积的互相关时,这个标志特别方便。
cv2.dft()
的性能很大程度上取决于传递给它的矩阵的确切尺寸,这种关系(性能与尺寸的关系)并不是线性的。只有一些尺寸是比其他尺寸表现出的性能更好。建议在将矩阵传递给cv2.dft()
时,首先在比当前矩阵大的尺寸中确定最佳尺寸,然后将矩阵扩展为该尺寸。OpenCV提供了一个合适的例程来计算这个值,称为cv2.getOptimalDFTSize()
。
image = mt.cv_rgb_imread('img1.jpg')
image = mt.image_resize(image, [300, 300]).astype('float32')
image = mt.to_gray_image(image)
dft_res = cv2.dft(image)
inverse_img = cv2.dft(dft_res, flags=cv2.DFT_INVERSE)
PIS(image, dft_res, inverse_img)
实现两个矩阵逐元素相除
mat_1 = np.random.random([5, 5, 5, 5])
mat_2 = np.random.random([5, 5, 5, 5])
res = cv2.divide(mat_1,mat_2)
计算方阵的特征值和特征向量
cv2.eigen(mat, lowindex=-1, highindex=-1)
cv2.eigen()
会计算出该矩阵的特征向量和特征值。矩阵必须为浮点类型之一。特征值矩阵以递减的顺序包含mat的特征值。如果要提供矩阵的特征向量,特征向量则以行的形式存储在矩阵中,并且与对应的特征值在特征值矩阵中的顺序相同。附加参数lowindex
和highindex
允许只计算一些特征值(两者必须一起使用)。例如,如果lowindex=0
和highindex=1
,就只计算最大的两个特征向量。mat = np.random.random([5, 5])
res = cv2.eigen(mat)
-->
res
(True, array([[ 2.38338798]...9424513]]), array([[ 0.48055992,...815113 ]]))
special variables
function variables
0:True
1:array([[ 2.38338798],
[ 0.95330573],
[ 0.09642702],
[-0.29716848],
[-0.99424513]])
2:array([[ 0.48055992, 0.47769814, 0.35204413, 0.55726429, 0.32617187],
[ 0.11930107, -0.17197101, 0.86940861, -0.32391572, -0.3088697 ],
[-0.1228634 , 0.55909817, 0.04237424, -0.67306158, 0.46637576],
[-0.49973229, -0.42185973, 0.30025171, 0.21678729, 0.65966218],
[ 0.70000117, -0.50167127, -0.16806823, -0.2907344 , 0.3815113 ]])
len():3