2图像处理--阈值与平滑处理、图像形态学处理、图像梯度处理、边缘检测_动态阈值 梯度 平滑

阈值与平滑处理

HSV： hsv=cv2.cvtColor(img,cv2.COLOR_BGR2HSV)
H - 色调（主波长）。
S - 饱和度（纯度/颜色的阴影）。
V值（强度）

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

import cv2 #opencv读取的格式是BGR
import numpy as np
import matplotlib.pyplot as plt#Matplotlib是RGB
%matplotlib inline 
ret, thresh1 = cv2.threshold(img_gray, 127, 255, cv2.THRESH_BINARY)
ret, thresh2 = cv2.threshold(img_gray, 127, 255, cv2.THRESH_BINARY_INV)
ret, thresh3 = cv2.threshold(img_gray, 127, 255, cv2.THRESH_TRUNC)
ret, thresh4 = cv2.threshold(img_gray, 127, 255, cv2.THRESH_TOZERO)
ret, thresh5 = cv2.threshold(img_gray, 127, 255, cv2.THRESH_TOZERO_INV)

titles = ['Original Image', 'BINARY', 'BINARY_INV', 'TRUNC', 'TOZERO', 'TOZERO_INV']
images = [img, 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
15
16
17
18

图像平滑

处理前

均值滤波 # 简单的平均卷积操作 乘以3-3全为1的矩阵求均值
blur = cv2.blur(img, (3, 3))

方框滤波 和均值滤波一样 # 基本和均值一样，可以选择归一化
box = cv2.boxFilter(img,-1,(3,3), normalize=True)

方框滤波 # 基本和均值一样，可以选择归一化,容易越界 ，越界取白（255）
box = cv2.boxFilter(img,-1,(3,3), normalize=False)

高斯滤波 # 高斯模糊的卷积核里的数值是满足高斯分布，相当于更重视中间的
aussian = cv2.GaussianBlur(img, (5, 5), 1)

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

# 展示所有的
res = np.hstack((blur,aussian,median))
#print (res)
cv2.imshow('median vs average', res)
cv2.waitKey(0)
cv2.destroyAllWindows()
1
2
3
4
5
6

图像形态学处理

形态学-腐蚀、膨胀操作

kernel = np.ones((3,3),np.uint8) #3-3矩阵，某个点不全为一个色，则被腐蚀
erosion = cv2.erode(img,kernel,iterations = 1) #iterations 迭代次数

kernel = np.ones((3,3),np.uint8)
dige_dilate = cv2.dilate(dige_erosion,kernel,iterations = 1)#膨胀

开运算与闭运算

# 开：先腐蚀，再膨胀  morphologyEx:形态学
img = cv2.imread('dige.png')

kernel = np.ones((5,5),np.uint8) 
opening = cv2.morphologyEx(img, cv2.MORPH_OPEN, kernel)

cv2.imshow('opening', opening)
cv2.waitKey(0)
cv2.destroyAllWindows()
1
2
3
4
5
6
7
8
9

# 闭：先膨胀，再腐蚀
img = cv2.imread('dige.png')

kernel = np.ones((5,5),np.uint8) 
closing = cv2.morphologyEx(img, cv2.MORPH_CLOSE, kernel)

cv2.imshow('closing', closing)
cv2.waitKey(0)
cv2.destroyAllWindows()

1
2
3
4
5
6
7
8
9
10

图像梯度处理

梯度运算

# 梯度=膨胀-腐蚀
pie = cv2.imread('pie.png')
kernel = np.ones((7,7),np.uint8) 
dilate = cv2.dilate(pie,kernel,iterations = 5)
erosion = cv2.erode(pie,kernel,iterations = 5)

res = np.hstack((dilate,erosion))

cv2.imshow('res', res)
cv2.waitKey(0)
cv2.destroyAllWindows()
1
2
3
4
5
6
7
8
9
10
11

gradient = cv2.morphologyEx(pie, cv2.MORPH_GRADIENT, kernel)

cv2.imshow('gradient', gradient)
cv2.waitKey(0)
cv2.destroyAllWindows()
1
2
3
4
5

礼帽与黑帽
礼帽 = 原始输入-开运算结果
黑帽 = 闭运算-原始输入

#礼帽
img = cv2.imread('dige.png')
tophat = cv2.morphologyEx(img, cv2.MORPH_TOPHAT, kernel)
cv2.imshow('tophat', tophat)
cv2.waitKey(0)
cv2.destroyAllWindows()
1
2
3
4
5
6

#黑帽
img = cv2.imread('dige.png')
blackhat  = cv2.morphologyEx(img,cv2.MORPH_BLACKHAT, kernel)
cv2.imshow('blackhat ', blackhat )
cv2.waitKey(0)
cv2.destroyAllWindows()
1
2
3
4
5
6

边缘检测

图像梯度-Sobel算子 Gx 水平 Gy垂直

dst = cv2.Sobel(src, ddepth, dx, dy, ksize)
ddepth:图像的深度
dx和dy分别表示水平和竖直方向
ksize是Sobel算子的大小
初始图像：

def cv_show(img,name):
    cv2.imshow(name,img)
    cv2.waitKey()
    cv2.destroyAllWindows()
sobelx = cv2.Sobel(img,cv2.CV_64F,1,0,ksize=3)#cv2.CV_64F 正负都能表示

cv_show(sobelx,'sobelx')
1
2
3
4
5
6
7

下图右边是缺失的；白(255)到黑(0)是正数，黑到白就是负数了，所有的负数会被截断成0，所以要取绝对值

sobelx = cv2.Sobel(img,cv2.CV_64F,1,0,ksize=3)
sobelx = cv2.convertScaleAbs(sobelx)#绝对值
cv_show(sobelx,'sobelx')
1
2
3

sobely = cv2.Sobel(img,cv2.CV_64F,0,1,ksize=3)
sobely = cv2.convertScaleAbs(sobely)  
cv_show(sobely,'sobely')
1
2
3

分别计算x和y，再求和；不建议直接计算(效果不如分开计算）

sobelxy = cv2.addWeighted(sobelx,0.5,sobely,0.5,0)#dst = src1 * alpha + src2 * beta + gamma;
cv_show(sobelxy,'sobelxy')
1
2

图像梯度-Scharr算子

### 图像梯度-laplacian算子（对噪音较为敏感）中间点-4个边缘点

初始图片

#不同算子的差异
img = cv2.imread('lena.jpg',cv2.IMREAD_GRAYSCALE)
sobelx = cv2.Sobel(img,cv2.CV_64F,1,0,ksize=3)
sobely = cv2.Sobel(img,cv2.CV_64F,0,1,ksize=3)
sobelx = cv2.convertScaleAbs(sobelx)   
sobely = cv2.convertScaleAbs(sobely)  
sobelxy =  cv2.addWeighted(sobelx,0.5,sobely,0.5,0)  

scharrx = cv2.Scharr(img,cv2.CV_64F,1,0)
scharry = cv2.Scharr(img,cv2.CV_64F,0,1)
scharrx = cv2.convertScaleAbs(scharrx)   
scharry = cv2.convertScaleAbs(scharry)  
scharrxy =  cv2.addWeighted(scharrx,0.5,scharry,0.5,0) 

laplacian = cv2.Laplacian(img,cv2.CV_64F)
laplacian = cv2.convertScaleAbs(laplacian)   

res = np.hstack((sobelxy,scharrxy,laplacian))
cv_show(res,'res')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

Canny边缘检测

• 1.    使用高斯滤波器，以平滑图像，滤除噪声。
     1

• 2.    计算图像中每个像素点的梯度强度和方向。
     1

• 3.    应用非极大值（Non-Maximum Suppression）抑制，以消除边缘检测带来的杂散响应。
     1

• 4.    应用双阈值（Double-Threshold）检测来确定真实的和潜在的边缘。
     1

• 5.    通过抑制孤立的弱边缘最终完成边缘检测。
     1

1:高斯滤波器

2:梯度和方向 （用sobel算子）

3：非极大值抑制

4：双阈值检测 下图c连到A，认为其实边界，b则不是

img=cv2.imread("lena.jpg",cv2.IMREAD_GRAYSCALE)

v1=cv2.Canny(img,80,150)#minVal,maxVal
v2=cv2.Canny(img,50,100)

res = np.hstack((v1,v2))
cv_show(res,'res')
1
2
3
4
5
6
7

img=cv2.imread("car.png",cv2.IMREAD_GRAYSCALE)

v1=cv2.Canny(img,120,250)
v2=cv2.Canny(img,50,100)

res = np.hstack((v1,v2))
cv_show(res,'res')
1
2
3
4
5
6
7