Opencv基础知识整理_csdn opencv知识点

1. 基本操作

图像操作

• cv2.IMRED_COLOR：彩色图像
• cv2.IMREAD_GRAYSCALE: 灰度图像

import cv2
import numpy as np

path = "test.png" # 测试图像
img = cv2.imread(path, cv2.IMREAD_GRAYSCALE) # 默认是彩色图像，可以使用灰度图像

# numpy生成测试图像

# 图像读取函数
def cv_imshow(name, img):
    # 图像显示，也可以创建多个窗口
    cv2.imshow(name, img)
    # 等待时间，毫秒级，0表示任意终止
    cv2.waitKey(0)
    cv2.destroyAllWindows()

# 保存图像
cv2.imwrite('mytest.png', img)   # 保存成功会返回值

# 图像类型
type(img) # numpy.ndarray

# 图像像素点
img.size

# 图像存储类型
img.dtype # dtype('uint8')

# 截取图像--使用索引形式即可
img[0:200, 0:200]

# 颜色通道提取
b, g, r = cv2.split(img)

# 合并
img = cv2.merge((b, g, r))

# 只保留单通道
cur_img = img.copy()
cur_img[:,:,0] = 0 # B 通道置为0
cur_img[:,:.1] = 0 # G 通道置为0

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

边界填充

# 边界填充
top_size, bottom_size, left_size, right_size = (200,200,200,200)
replicate = cv2.copyMakeBorder(img, top_size, bottom_size, left_size, right_size, borderType=cv2.BORDER_REPLICATE) # 复制法，复制边缘像素
reflect = cv2.copyMakeBorder(img, top_size, bottom_size, left_size, right_size, borderType=cv2.BORDER_REFLECT) # 反射法，对感兴趣的图像中的像素两边进行复制
reflect101 = cv2.copyMakeBorder(img, top_size, bottom_size, left_size, right_size, borderType=cv2.BORDER_REFLECT_101) # 反射法，以最边缘像素为轴 gfedcb|abcdefgh|gfedcba
warp = cv2.copyMakeBorder(img, top_size, bottom_size, left_size, right_size, borderType=cv2.BORDER_WRAP) # 外包装法 cdefgh|abcdefgh|abcdefg
constant = cv2.copyMakeBorder(img, top_size, bottom_size, left_size, right_size, borderType=cv2.BORDER_CONSTANT, value=0) # 常量法，常数值填充

plt.subplot(231), plt.imshow(img, 'gray'), plt.title('ORIGINAL')
plt.subplot(232), plt.imshow(replicate, 'gray'), plt.title('replicate')
plt.subplot(233), plt.imshow(reflect, 'gray'), plt.title('reflect')
plt.subplot(234), plt.imshow(reflect101, 'gray'), plt.title('reflect101')
plt.subplot(235), plt.imshow(warp, 'gray'), plt.title('warp')
plt.subplot(236), plt.imshow(constant, 'gray'), plt.title('constant')
1
2
3
4
5
6
7
8
9
10
11
12
13
14

数值计算

img+10 # 图像每个位置+10
img+img # 相当于(img+img)%256   相同shape对应位置相加
cv2.add(img, img) # 相当于img+img
1
2
3

图像融合

# 两种图像img1(640, 640, 3) img2(320, 320, 3)
cv2.resize(img1, (320, 320))  # resize图像
# cv2.resize(img1, (0, 0), fx=0.5, fy=0.5) # 对图像x,y变成原来的0.5
cv2.addWeighted(img1, 0.4, img2, 0.5, 0) # 0.4*img1 + 0.5*img2 + 0
1
2
3
4

图像阈值
ret, dst = cv2.threshold(src, thresh, maxval, type)

• src: 输入图，只能输入单通道图像，通常来说为灰度图
• dst: 输出图
• thresh: 阈值 127
• maxval: 当像素值超过了阈值（或者小于阈值，根据type来决定）所赋予的值
• type: 二值化操作的类型，包含以下5中类型：cv2.THRESH_BINARY; cv2.THRESH_BINARY_INV; cv2.THRESH_TRUNC; cv2.THRESH_TOZERO; cv2.THERSH_TOZERO_INV
  • cv2.THRESH_BINARY 超过阈值部分取maxval（最大值），否则取0
  • cv2.THRESH_BINARY_INV THRESH_BINARY反转
  • cv2.THRESH_TRUNC 大于阈值部分设为阈值，否则不变
  • cv2.THRESH_TOZERO 大于阈值部分不改变，否则设为0
  • cv2.THERSH_TOZERO_INV cv2.THRESH_TOZERO反转

ret, thresh1 = cv2.threshold(img1, 127, 255, cv2.THRESH_BINARY)
ret, thresh2 = cv2.threshold(img1, 127, 255, cv2.THRESH_BINARY_INV)
ret, thresh3 = cv2.threshold(img1, 127, 255, cv2.THRESH_TRUNC)
ret, thresh4 = cv2.threshold(img1, 127, 255, cv2.THRESH_TOZERO)
ret, thresh5 = cv2.threshold(img1, 127, 255, cv2.THRESH_TOZERO_INV)

titles = ['Original Image', 'BINARY', 'BINARY_INV', 'TRUNC', 'TOZERO', 'TOZERO_INV']
images = [img1, thresh1, thresh2, thresh3, thresh4, thresh5]

for i in range(6):
    plt.subplot(2, 3, i+1), plt.imshow(images[i], 'gray')
    plt.title(titles[i])
    plt.xticks([]), plt.yticks([])
plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14

图像滤波

# 均值滤波
# 简单的平均卷积
blur = cv2.blur(img, (3,3))

# 方框滤波
# 基本和均值一样，可以选择归一化
box = cv2.boxFilter(img1, -1, (3,3), normalize=True) # noremalize=True 卷积除以个数，noremal=False 只是卷积求和

# 高斯滤波
# 同一中心点根据距离不同参数的比例不同
gaussian = cv2.GaussianBlur(img1, (5,5), 1)

# 中值滤波
# 相当于用中值代替
median = cv2.medianBlur(img, 5)

res = np.hstack((blur, gaussian, median))
cv_imshow('res', res)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

形态学-腐蚀操作

kernel = np.ones((5,5), np.uint8)
erosion = cv2.erode(img, kernel, iterations=1) # iterations 腐蚀次数
1
2

形态学-膨胀操作

kernel = np.ones((3, 3), np.uint8)
dige_dilate = cv2.dilate(img, kernel, iterations=1)
1
2

开运算与闭运算

# 开：先腐蚀，再膨胀
# 将毛刺去掉
kernel = np.ones((5,5), np.uint8)
opening = cv2.morphologyEx(img, cv2.MORPH_OPEN, kernel)

# 闭： 先膨胀，再腐蚀
# 扩张毛刺
kernel = np.ones((5,5), np.uint8)
opening = cv2.morphologyEx(img, cv2.MORPH_CLOSE, kernel)
1
2
3
4
5
6
7
8
9

梯度运算

# 梯度=膨胀-腐蚀
kernel = np.ones((7,7), np.uint8)
gradient = cv2.morphologyEx(pie, cv2.MORPH_GRADIENT, kernel) # 原图-腐蚀，默认iteration = 1
1
2
3

礼帽与黑帽

• 礼帽=原始输入-开运算结果 = 刺
• 黑帽=闭运算-原始输入 = 闭运算新生成的刺

# 礼帽
kernel = np.ones((5,5), np.uint8)
tophat = cv2.morphologyEx(img, cv2.MORPH_TOPHAT, kernel)
# 黑帽
tophat = cv2.morphologyEx(img, cv2.MORPH_BLACKHAT, kernel)
1
2
3
4
5

图像梯度-Sobel算子

• 图像突变位置–图像梯度
  $$G_x=\left[\begin{array}{ccc}-1& 0& +1\\ -2& 0& +2\\ -1& 0& +1\end{array}\right]\ast A$$
  $$G_y=\left[\begin{array}{ccc}-1& -2& -1\\ 0& 0& 0\\ +1& +2& +1\end{array}\right]\ast A$$

dst = cv2.Sobel(src, ddepth, dx, dy, ksize)

• ddepth: 图像的深度
• dx和dy分别表示水平和竖直方向
• ksize是Sobel算子的大小

sobelx = cv2.Sobel(img, cv2.CV_64F, 1, 0, ksize=3) # 水平梯度
# 白到黑是正数，黑到白是负数，负数会被截断成0，所以要取绝对值，方法如下：
sobelx = cv2.convertScaleAbs(sobelx)

sobelx = cv2.Sobel(img, cv2.CV_64F, 0, 1, ksize=3) # 垂直梯度
# 白到黑是正数，黑到白是负数，负数会被截断成0，所以要取绝对值，方法如下：
sobelx = cv2.convertScaleAbs(sobelx)

# 分别计算完x, y求和
sobelxy = cv2.addWeighted(sobelx, 0.5, sobely, 0.5, 0)

# 可以直接计算，但是不建议，效果不如分开合起来计算的好
sobelx = cv2.Sobel(img, cv2.CV_64F, 1, 1, ksize=3) # 水平垂直梯度
1
2
3
4
5
6
7
8
9
10
11
12
13

图像梯度-Scharr算子

• Sobel改进，更敏感，更细致
  $$G_x=\left[\begin{array}{ccc}-3& 0& 3\\ -10& 0& 10\\ -3& 0& 3\end{array}\right]\ast A$$
  $$G_y=\left[\begin{array}{ccc}-3& -10& -3\\ 0& 0& 0\\ 3& 10& 3\end{array}\right]\ast A$$

scharrx = cv2.Scharr(img, cv2.CV_64F, 1, 0)
scharry = cv2.Scharr(img, cv2.CV_64F, 0, 1)
scharrx = cv2.covertScaleAbs(scharrx)
scharry = cv2.covertScaleAbs(scharry)
scharrxy = cv2.addWeighted(scharrx, 0.5, scharry, 0.5, 0)
1
2
3
4
5

图像梯度-laplacian算子

• 对噪声点敏感，一般结合其他方法一起使用
  $$G=\left[\begin{array}{ccc}0& 1& 0\\ 1& -4& 1\\ 0& 1& 0\end{array}\right]$$

laplacian = cv2..Laplaciap(img, cv2.CV_64F)
laplacian = cv2.converScaleAbs(laplacian)
1
2

Canny边缘检测

• 1. 使用高斯滤波器，以平滑图像，滤除噪声。
• 2. 计算图像中每个像素点的梯度强度和方向。
• 3. 应用非极大值（Non-Maximum Suppression）抑制，以消除边缘检测带来的杂散相应。
• 4. 应用双阈值（Double-Threshold）检测来确定真实的和潜在的边缘。
• 5. 通过抑制孤立的弱边缘最终完成边缘检测。

1. 高斯滤波器
H = [ 0.0924 0.1192 0.0924 0.1192 0.1538 0.1192 0.0924 0.1192 0.0924 ] < − − − 归一化处理 H =

$$\begin{bmatrix} 0.0924&0.1192&0.0924\\ 0.1192&0.1538&0.1192\\ 0.0924&0.1192&0.0924\\ \end{bmatrix}$$ <---归一化处理 H= ​0.09240.11920.0924​0.11920.15380.1192​0.09240.11920.0924​ ​<−−−归一化处理
$$e=H\ast A=\left[\begin{array}{ccc}{h}_{11}& h_{12}& h_{13}\\ h_{21}& h_{22}& h_{23}\\ h_{31}& h_{32}& h_{33}\end{array}\right]\ast \left[\begin{array}{ccc}a& b& c\\ d& e& f\\ g& h& i\end{array}\right]=sum(\left[\begin{array}{ccc}a\times h_{11}& b\times h_{12}& c\times h_{13}\\ d\times h_{21}& e\times h_{22}& f\times h_{23}\\ g\times h_{31}& h\times h_{32}& i\times h_{33}\end{array}\right])$$

2. 梯度和方向（Sobel）
$G=\sqrt{G_x^2+G_y^2}$
$\theta =arctan(\frac{G_y}{G_x})$
S x = [ − 1 0 1 − 2 0 2 − 1 0 1 ] S y = [ 1 2 1 0 0 0 − 1 − 2 − 1 ] S_x =

$$\begin{bmatrix} -1&0&1\\ -2&0&2\\ -1&0&1\\ \end{bmatrix}$$ S_y = $$\begin{bmatrix} 1&2&1\\ 0&0&0\\ -1&-2&-1\\ \end{bmatrix}$$ Sx​= ​−1−2−1​000​121​ ​Sy​= ​10−1​20−2​10−1​ ​
$$G_x=S_x\ast A=\left[\begin{array}{ccc}-1& 0& 1\\ -2& 0& 2\\ -1& 0& 1\end{array}\right]\ast \left[\begin{array}{ccc}a& b& c\\ d& e& f\\ h& g& i\end{array}\right]=sum(\left[\begin{array}{ccc}-a& 0& c\\ -2d& 0& 2f\\ -g& 0& i\end{array}\right])$$
$$G_y=S_y\ast A=\left[\begin{array}{ccc}1& 2& 1\\ 0& 0& 0\\ -1& -2& -1\end{array}\right]\ast \left[\begin{array}{ccc}a& b& c\\ d& e& f\\ h& g& i\end{array}\right]=sum(\left[\begin{array}{ccc}a& 2b& c\\ 0& 0& 0\\ -g& -2h& -i\end{array}\right])$$

3. 非极大值抑制

4. 双阈值检测

v = cv2.Canny(img, 80, 150) # minval = 80, maxval = 150 值越大对于边缘特征提取越细致，信息点过滤越多
1

图像金字塔

• 高斯金字塔
• 拉普拉斯金字塔
  
  高斯金字塔：向下采样方法（缩小）
  $$H=\frac{1}{25}\left[\begin{array}{ccccc}1& 4& 6& 4& 1\\ 4& 16& 24& 16& 4\\ 6& 24& 36& 24& 6\\ 4& 16& 24& 16& 4\\ 1& 4& 6& 4& 1\end{array}\right]$$
• 将$G_i$与高斯内核卷积
• 将所有偶数行和列去除

高斯金字塔：向上采样方法（放大）
[ 1 4 4 16 ] − − > [ 1 0 4 0 0 0 0 0 4 0 16 0 0 0 0 0 ]

$$\begin{bmatrix} 1&4\\ 4&16\\ \end{bmatrix}$$ --> $$\begin{bmatrix} 1&0&4&0\\ 0&0&0&0\\ 4&0&16&0\\ 0&0&0&0\\ \end{bmatrix}$$ [14​416​]−−> ​1040​0000​40160​0000​ ​

• 1. 将图像在每个方向扩大为原来的两倍，新增的行和列以0填充
• 2. 使用先前同样的内核（乘以4）与放大后的图像卷积，获得近似值

up = cv2.pyrUp(img)

down = cv2.pyrDown(img)
1
2
3

拉普拉斯金字塔
$$L_i=G_i-PyrUP(PyrDown(G_i))$$

img - cv2.pyrUp(cv2.pyrDown(img))
1

图像轮廓

1. 将原图像转为灰度图
2. 进行二值阈值筛选
3. 进行轮廓调用

cv2.findContours(img, mode, method)
mode:罗阔检索模式

• RETR_EXTERNAL：只检索最外面的轮廓
• RETR_LIST: 检索所有的轮廓，并将其保存到一条链表当中；
• RETR_CCOMP：健硕所有的轮廓，并将他们组织为两层；顶层是各部分的外部边界，第二层是空洞边界；
• RETR_TREE: 检索所有的轮廓，并重构嵌套轮廓的整个层次。

method：轮廓逼近方法

• CHAIN_APPROX_NONE: 以Freeman链码的方式输出轮廓，所有其他方法输出多边形（顶点的序列）。
• CHAIN_APPROX_SIMPLE: 压缩水平的、垂直的和斜的部分，也就是，函数只保留他们的终点部分。

gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
ret, thresh = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)

contours, hierarchy = cv2.findContours(thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)

draw_img = img.copy() # 不拷贝会在img上留下轮廓痕迹
res = cv2.drawContours(draw_img, contours, -1, (0, 0, 255), 2) # -1表示所有轮廓目标，可以0,1,2...对应各种目标
1
2
3
4
5
6
7

轮廓特征

cnt = contours[0]
# 面积
cv2.contourArea(cnt)
# 周长，True表示闭合的
cv2.arcLength(cnt, True)
1
2
3
4
5

轮廓近似
以直代曲

gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
ret, thresh = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)

contours, hierarchy = cv2.findContours(thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)

cnt = contours[0]

# 1. 根据图像形状进行轮廓拟合
epsilon = 0.1*cv2.arcLength(cnt, True)  # 周长作为阈值，两点之前使用直线代替的阈值，阈值越小，线段越短，整体性越差
approx = cv2.approxPolyDP(cnt, epsilon, True)

draw_img = img.copy()
res = cv2.drawContours(draw_img, [approx], -1, (0,0,255), 2)
cv_show('res', res)

# 2. 根据边界矩形进行轮廓拟合
x, y, w, h = cv2.boundingRect(cnt)
rec_img = cv2.rectangle(draw_img, (x,y), (x+w, y+h), (0, 255, 0), 2)
cv_show('img', rec_img)

area = cv2.contourArea(cnt)
rect_area = w*h
extent = float(area) / rect_area
print(‘轮廓面积与边界矩形比’, extent)

# 3. 外接圆
(x, y), radius = cv2.minEnclosingCircle(cnt)
center = (int(x), int(y))
radius = int(radius)
rad_img = cv2.circle(draw_img, center, radius, (0, 255, 0), 2)
cv_show('img', rad_img)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

模板匹配

模板匹配和卷积原理很像，模板在原图像上从原点开始华东，计算模板与（图像被模板覆盖的地方）的差别程度，这个差别程度的计算方法在opencv里有6种，然后将每次计算的结果放在一个矩阵里，作为结果输出。假设原图形是AxB大小，而模板是axb大小，则输出结果的矩阵是(A-a+1)x(B-b+1)

• TM_SQDIFF: 计算平方不同，计算出来的值越小，越相关
• TM_CCORR: 计算相关性，计算出来的值越大，越相关
• TM_CCOEFF: 计算相关系数，计算出来的值越大，越相关
• TM_SQDIFF_NORMED: 计算归一化平方不同，计算出来的值越接近0，越相关
• TM_CCORR_NORMED: 计算归一化相关性，计算出来的值越接近1，越相关
• TM_CCOEFF_NORMED: 计算归一化相关系数，计算出来的值越接近1，越相关
• 归一化后的结果效果稳定

img = cv2.imread('', 0)
template = cv2.imread('', 0)
h, w = template.shape[:2]

methods = ['cv2.TM_CCOEFF', ‘cv2.TM_CCOEFF_NORMED’, ‘cv2.TM_CCORR’, 'cv2.TM_CCORR_NORMED', 'cv2.TM_SQDIFF', 'cv2.TM_SQDIFF_NORMED']
res = cv2.matchTemplate(img, template, 1, cv2.TM_SQDIFF)
min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(res)

for meth in methods:
	img2 = img.copy()
	# 匹配方法的真值
	method = eval(meth)
	print(method)
	res = cv2.matchTemplate(img, template, 1, method)
	
	# 如果是平方差匹配TM_SQDIFF或归一化平方差匹配TM_SQDIFF_NORMED，取最小值
	if method in [cv2.TM_SQDIFF, cv2.TM_SQDIFF_NORMED]:
		top_left = min_loc
	else:
		top_left = max_loc
	bottom_right = (top_left[0] + w, top_left[1] + h)

	# 画矩形
	cv2.rectangle(img2, top_left, bottom_right, 255, 2)

	plt.subplot(121), plt.imshow(res, cmap='gray')
	plt.xticks([]), plt.yticks([]) # 隐藏坐标轴
	plt.subplot(122), plt.imshow(img2, cmap='gray')
	plt.xticks([]), plt.yticks([]) # 隐藏坐标轴
	plt.suptitle(meth)
	plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

匹配多个目标

img = cv2.imread('', 0)
template = cv2.imread('', 0)
h, w = template.shape[:2]

res = cv2.matchTemplate(img, template, 1, cv2.TM_CCOEFF_NORMED)
threshhold = 0.8
# 取匹配程度大于80%的坐标
loc = np.where(res >= threshold)
for pt in zip(*loc[::-1]):
	bottom_right = (pt[0] + w, pt[1] + h)
	cv2.rectangle(img, pt, bottom_right, (0, 0, 255), 2)
cv_show('img_rgb', img)
1
2
3
4
5
6
7
8
9
10
11
12

直方图

cv2.calcHist(images, channels, mask, histSize, ranges)

• images: 原图像图像格式为uint8或float32。当传入函数时，应用[]例如[img]
• channels: 同样用[]来高数函数统计图像的直方图，如果输入图像是灰度图它的值就是[0]，彩色图像传入的参数就是[0][1][2]，分别对应BGR。
• mask: 掩膜图像。统计整幅图像的直方图为None，统计图像某一部分的直方图就制作一个掩膜图像并使用它。
• histSize: BIN的数目
• ranges: 像素值范围常为[0-256]

hist_0 = cv2.calcHist([img], [0], None, [256], [0, 256])
hist_1 = cv2.calcHist([img], [1], None, [256], [0, 256])
hist_2 = cv2.calcHist([img], [2], None, [256], [0, 256])
hist.shape
plt.hist(img_nly.ravel(), 256)
plt.show()

# 或者
color = ('b', 'g', 'r')
for i, col in enumerate(color):
	histr = cv2.calcHist([img], [i], None, [256], [0, 256])
	plt.plot(histr, color=col)
	plt.xlim([0,256])
1
2
3
4
5
6
7
8
9
10
11
12
13

mask操作

w, h, _ = img.shape
mask = np.zeros(img.shape[:2], np.uint8)
mask[w//2-500:w//2+500, h//2-300:h//2+300] = 255
cv_imshow('mask', mask)

mask_img = cv2.bitwise_and(img_nly, img_nly, mask=mask) # 与操作
cv_imshow("mask_img", mask_img)

hist_full = cv2.calcHist([img], [0], None, [256], [0,256])
hist_mask = cv2.calcHist([img], [0], mask, [256], [0,256])
plt.subplot(221, plt.imshow(img, 'img'))
plt.subplot(222, plt.imshow(mask, 'img'))
plt.subplot(223, plt.imshow(mask_img, 'img'))
plt.subplot(224, plt.plot(hist_full), plt.plot(hist_mask))
plt.xlim([0,256])
plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

直方图均衡化
针对全图进行均衡化

# 原图直方图查看
plt.hist(img_nly.ravel(), 256)
plt.show()

# 单通道直方图均衡化
equ = cv2.equalizeHist(img_nly[:,:,0])
plt.hist(equ.ravel(), 256)
plt.show()

# 3通道直方图均衡化
B, G, R = cv2.split(img)
output_B = cv2.equalizeHist(B)
output_G = cv2.equalizeHist(G)
output_R = cv2.equalizeHist(R)
equ = cv2.merge((output_B, output_G, output_R))
plt.hist(equ.ravel(), 256)
plt.show()

# 结果对比
res = np.hstack((img, equ))
cv_imshow('res', res)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

自适应直方图均衡化
分块均衡化

# 实例化直方图
clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))
# 对三通道进行直方图均衡化
B, G, R = cv2.split(img)
res_clahe_B = clahe.apply(B)
res_clahe_G = clahe.apply(G)
res_clahe_R = clahe.apply(R)
res_clahe = cv2.merge((res_clahe_B, res_clahe_G, res_clahe_R))
res = np.hstack((img_nly, equ, res_clahe))
cv_imshow('img', res)
1
2
3
4
5
6
7
8
9
10

傅里叶变换

时域和频域的转换

https://zhuanlan.zhihu.com/p/19763358

傅里叶变换作用

• 高频：变换剧烈的灰度分量，例如边界
• 低频：变化缓慢的灰度分量，例如一片大海

滤波

• 低通滤波器：只保留低频，会使得图像模糊

• 高通滤波器：只保留高频，会使得图像细节增强

• opencv中主要使用cv2.dft()和cv2.idft()，输入图像需要先转换成np.float32格式。

• 得到的结果中频率为0的部分会在左上角，通常要转换到中心位置，可以通过shift变换来实现。

• cv2.dft()返回的结果是双通道的（实部，虚部），通常还需要转换成图像格式才能展示（0，255）。

img_float32 = np.float32(img[:,:,0])

dft = cv2.dft(img_float32, flags = cv2.DFT_COMPLEX_OUTPUT) # 傅里叶变换
dft_shift = np.fft.fftshift(dft) # 移动

magnitude_spectrum = 20*np.log(cv2.magnitude(dft_shift[:,:,0], dft_shift[:,:,1])) # magnitude实部和虚部调整

plt.subplot(121), plt.imshow(img_nly, cmap='gray')
plt.title('Input Image'), plt.xticks([]), plt.yticks([])
plt.subplot(122), plt.imshow(magnitude_spectrum, cmap='gray')
plt.title('Magnitude Spectrum'), plt.xticks([]), plt.yticks([])
plt.show()
1
2
3
4
5
6
7
8
9
10
11
12

img_float32 = np.float32(img[:,:,0])

dft = cv2.dft(img_float32, flags = cv2.DFT_COMPLEX_OUTPUT)
dft_shift = np.fft.fftshift(dft)

rows, cols = img_nly.shape[:2]
crow, ccol = int(rows/2), int(cols/2)

# 低通滤波
mask = np.zeros((rows, cols, 2), np.uint8)
mask[crow-30:crow+30, ccol-30: ccol+30] = 1

# IDFT
fshift = dft_shift*mask
f_ishift = np.fft.ifftshift(fshift)
img_back = cv2.idft(f_ishift)
img_back = cv2.magnitude(img_back[:,:,0], img_back[:,:,1])

plt.subplot(121), plt.imshow(img_nly, cmap='gray')
plt.title('Input Image'), plt.xticks([]), plt.yticks([])
plt.subplot(122), plt.imshow(img_back, cmap='gray')
plt.title('Magnitude Spectrum'), plt.xticks([]), plt.yticks([])
plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

视频操作

• cv2.VideoCapture可以捕获摄像头，用数字来控制不同的设备，例如0,1

• 如果是视频文件，直接指定好路径即可

• cv2.COLOR_BGR2RGB 将BGR格式转换成RGB格式
  cv2.COLOR_BGR2GRAY 将BGR格式转换成灰度图片

• cv2.COLOR_BGR2BGRA 将BGR格式转换成BGR格式，cv2显示正常

• cv2.COLOR_BGR2HSV 将BGR格式转换成HSV格式

import cv2
import numpy as np

vc = cv2.VideoCapture('test.mp4') # 打开视频
# vc = cv2.VideoCapture(0) # 打开摄像头0

# 判断是否正确读取视频
if vc.isOpened():
    open, fram = vc.read()
else:
    open = False

# 播放视频
while open:
    ret, frame = vc.read()
    if frame is None:
        break
    if ret:
        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
        cv2.imshow('result', gray)
        if cv2.waitKey(10) & 0xFF == 27:  # 27退出键
            break
vc.release()
cv2.destroyAllWindows()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24