数字图像处理课程作业二-车牌识别
写在最前
这是我大学课程的数字图像处理的实验报告，代码大部分是从网上直接复制使用，小部分是我自己改写的（例如matplotlib的使用），可以直接运行。内容比较详细，但是希望大家能够先理解一下思路再使用，学习图像处理的思路最重要。
1.实验目的:
巩固和综合应用数字图像相关知识，实现车牌识别，提高分析问题和解决问题的能力
2.实验要求
实现车牌定位、车牌字符分割和光学字符识别等，最终组成牌照号码输出
3.实验分析和流程：
- 需要对原始车牌图像进行预处理：灰度化，开运算消除毛刺噪声
- 对处理后的车牌图像进行二值化操作，而后利用canny边缘检测消除小的区域保留大的区域，而后颜色识别判断定位车牌位置
- 利用掩膜处理对定位车牌后的图像进行分割，直接分割出车牌
- 分割出车牌对车牌进行二值化处理，并且分割字符
- 对分割字符进行神经网络模型匹配，输出车牌字符串
流程图如下
4.核心处理图像函数分析
4.1 二值化处理
def threshold(src, thresh, maxval, type, dst=None):
参数说明：
- src: InputArray类型的src，输入数组，填单通道 , 8或32位浮点类型的Mat即可
- thresh:double类型的thresh，阈值的具体值
- maxval:double类型的maxval，当第五个参数阈值类型type取 THRESH_BINARY 或THRESH_BINARY_INV阈值类型时的最大值
- type: int类型的type，阈值类型
作用：为轮廓检测做铺垫
def morphologyEx(src, op, kernel, dst=None, anchor=None, iterations=None, borderType=None, borderValue=None):
参数说明:
- src传入的图片
- op进行变化的方式
- kernel表示方框的大小
作用：去除背景噪声毛刺
4.2 轮廓检测
def findContours(image, mode, method, contours=None, hierarchy=None, offset=None):
参数说明：
-
image：单通道图像矩阵，可以是灰度图，但更常用的是二值图像，一般是经过Canny、拉普拉斯等边 缘检测算子处理过的二值图像
-
mode：定义轮廓的检索模式,
-
method:定义轮廓的近似方法
作用: 检测出车牌的轮廓
4.3 车牌定位和框出
def inRange(src, lowerb, upperb, dst=None):
参数说明：
- src: InputArray类型的src，输入数组，填单通道 , 8或32位浮点类型的Mat即可
- lowerb: 最低阈值
- upperb: 最高阈值
作用：可实现二值化功能（这点类似threshold()函数），更关键的是可以同时针对多通道进行操作，使用起来非常方便，实现车牌定位
def rectangle(img, pt1, pt2, color, thickness=None, lineType=None, shift=None):
参数说明：
-
img：要做处理的图片
-
pt1：左上矩形的角坐标
-
pt2：右下矩形的角坐标
-
color：矩形的颜色
作用：框出车牌
5.实际图像处理代码
5.1 车牌预处理
def find_license(self,img):
'''
预处理函数
'''
m = 400 * img.shape[0] / img.shape[1]
# 压缩图像
img = cv2.resize(img, (400, int(m)), interpolation=cv2.INTER_CUBIC)
# BGR转换为灰度图像
gray_img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
# 灰度拉伸
stretchedimg = self.stretch(gray_img)
'''进行开运算，用来去除噪声'''
r = 16
h = w = r * 2 + 1
kernel = np.zeros((h, w), np.uint8)
cv2.circle(kernel, (r, r), r, 1, -1)
# 开运算
openingimg = cv2.morphologyEx(stretchedimg, cv2.MORPH_OPEN, kernel)
# 获取差分图，两幅图像做差 cv2.absdiff('图像1','图像2')
strtimg = cv2.absdiff(stretchedimg, openingimg)
# 图像二值化
binaryimg = self.dobinaryzation(strtimg)
# canny边缘检测
canny = cv2.Canny(binaryimg, binaryimg.shape[0], binaryimg.shape[1])
'''消除小的区域，保留大块的区域，从而定位车牌'''
# 进行闭运算
kernel = np.ones((5, 19), np.uint8)
closingimg = cv2.morphologyEx(canny, cv2.MORPH_CLOSE, kernel)
# 进行开运算
openingimg = cv2.morphologyEx(closingimg, cv2.MORPH_OPEN, kernel)
# 再次进行开运算
kernel = np.ones((11, 5), np.uint8)
openingimg = cv2.morphologyEx(openingimg, cv2.MORPH_OPEN, kernel)
# 消除小区域，定位车牌位置
rect = self.locate_license(openingimg, img)
return rect, img
分析:这一步主要是为了对原始车牌图像进行预处理：灰度化，开运算消除毛刺噪声
下图为预处理后的图像：
5.2 车牌框出
cv2.rectangle(afterimg, (rect[0], rect[1]), (rect[2], rect[3]), (0, 255, 0),2)
找到车牌轮廓的左上和右下坐标后就可以用矩形圈出
下图为车牌框出的图像：
5.3 车牌分割背景
def cut_license(self,afterimg, rect):
'''
图像分割函数
'''
# 转换为宽度和高度
rect[2] = rect[2] - rect[0]
rect[3] = rect[3] - rect[1]
rect_copy = tuple(rect.copy())
# 创建掩膜
mask = np.zeros(afterimg.shape[:2], np.uint8)
# 创建背景模型 大小只能为13*5，行数只能为1，单通道浮点型
bgdModel = np.zeros((1, 65), np.float64)
# 创建前景模型
fgdModel = np.zeros((1, 65), np.float64)
# 分割图像
cv2.grabCut(afterimg, mask, rect_copy, bgdModel, fgdModel, 5, cv2.GC_INIT_WITH_RECT)
mask2 = np.where((mask == 2) | (mask == 0), 0, 1).astype('uint8')
img_show = afterimg* mask2[:, :, np.newaxis]
# cv2.imshow('111',img_show)
return img_show
把车牌和背景分离开，即将车牌外的背景都变为黑色
下图为车牌和背景分离开的图片：
5.4 车牌分割
cutimg = cutimg[140:165, 151:240]
height, width = cutimg.shape[:2]
cutimg = cv2.resize(cutimg, (2 * width, 2 * height), interpolation=cv2.INTER_CUBIC)
plt.subplot(2, 3, 5)
虽然背景已经用黑色代替，但是车牌在图像占的比例太小，因此我们还需要对其进行提取处理，但缺点就行提取出的图像比较模糊，车牌的粤字已经模糊不清
效果如下：
5.5 分割后的车牌二值化
cv2.threshold(img_gray, 100, 255, cv2.THRESH_BINARY_INV, self.img_thre)
进行这步操作后我们就可以对车牌进行字符分割了
效果如下：
5.6 字符分割
img_list = []
n = 1
plt.figure()
img_num = 0
while n < self.width - 2:
n += 1
if (self.white[n] if self.arg else self.black[n]) > (0.15 * self.white_max if self.arg else 0.15 * self.black_max):
start = n
end = self.find_end(start)
n = end
if end - start > 5:
cj = self.img_thre[1:self.height, start:end]
img_num+=1
cj = cv2.cvtColor(cj, cv2.COLOR_RGB2BGR)
plt.subplot(2, 4, img_num)
plt.imshow(cj)
通过二值化的字和背景的对比，我们可以分割出黑色的和白色的背景，从而分割出车牌的多个字
效果图如下：
5.7 模版匹配
ocr = ddddocr.DdddOcr()
with open('thre_res.png', 'rb') as f:
image = f.read()
res = ocr.classification(image)
print(res)
分割出字符后，我们对每个字符进行神经网络模版匹配，这里我采用的是github上已经训练好的神经网络模型，直接调用它的api进行识别，但由于粤字实在模糊不清，没能输出粤的字符
效果如下：
6.整体图像呈现和思考
整体图像如下：
- 处理图像：
- 分割字符
7.感想和思考
在做实验过程中我也遇到了许多问题，在轮廓提取时，当车牌与车身背景对比不明显时，这个方案是适用的，可能还需要形状的识别，并且在提取和分割过程后，车牌的粤字已经模糊不清，很难再用模版进行识别。这些缺陷和问题都是我接下来学习更多知识后要解决的。
写在最后
如果觉得写的不错的小伙伴记得给个赞哦！欢迎评论与我交流！
2022.4.23更新
应评论要求现把完整代码写在如下：
import cv2
import numpy as np
import matplotlib.pyplot as plt
from matplotlib import font_manager
import ddddocr
font = font_manager.FontProperties(fname=r".\OPPOSans-H.ttf")
class Get_license():
def stretch(self, img):
'''
图像拉伸函数
'''
maxi = float(img.max())
mini = float(img.min())
for i in range(img.shape[0]):
for j in range(img.shape[1]):
img[i, j] = (255 / (maxi - mini) * img[i, j] - (255 * mini) / (maxi - mini))
return img
def dobinaryzation(self, img):
'''
二值化处理函数
'''
maxi = float(img.max())
mini = float(img.min())
x = maxi - ((maxi - mini) / 2)
# 二值化,返回阈值ret 和 二值化操作后的图像thresh
ret, thresh = cv2.threshold(img, x, 255, cv2.THRESH_BINARY)
# 返回二值化后的黑白图像
return thresh
def find_rectangle(self, contour):
'''
寻找矩形轮廓
'''
y, x = [], []
for p in contour:
y.append(p[0][0])
x.append(p[0][1])
return [min(y), min(x), max(y), max(x)]
def locate_license(self, img, afterimg):
'''
定位车牌号
'''
contours, hierarchy = cv2.findContours(img, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
# 找出最大的三个区域
block = []
for c in contours:
# 找出轮廓的左上点和右下点，由此计算它的面积和长度比
r = self.find_rectangle(c)
a = (r[2] - r[0]) * (r[3] - r[1]) # 面积
s = (r[2] - r[0]) * (r[3] - r[1]) # 长度比
block.append([r, a, s])
# 选出面积最大的3个区域
block = sorted(block, key=lambda b: b[1])[-3:]
# 使用颜色识别判断找出最像车牌的区域
maxweight, maxindex = 0, -1
for i in range(len(block)):
b = afterimg[block[i][0][1]:block[i][0][3], block[i][0][0]:block[i][0][2]]
# BGR转HSV
hsv = cv2.cvtColor(b, cv2.COLOR_BGR2HSV)
# 蓝色车牌的范围
lower = np.array([100, 50, 50])
upper = np.array([140, 255, 255])
# 根据阈值构建掩膜
mask = cv2.inRange(hsv, lower, upper)
# 统计权值
w1 = 0
for m in mask:
w1 += m / 255
w2 = 0
for n in w1:
w2 += n
# 选出最大权值的区域
if w2 > maxweight:
maxindex = i
maxweight = w2
return block[maxindex][0]
def find_license(self, img):
'''
预处理函数
'''
m = 400 * img.shape[0] / img.shape[1]
# 压缩图像
img = cv2.resize(img, (400, int(m)), interpolation=cv2.INTER_CUBIC)
# BGR转换为灰度图像
gray_img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
# 灰度拉伸
stretchedimg = self.stretch(gray_img)
'''进行开运算，用来去除噪声'''
r = 16
h = w = r * 2 + 1
kernel = np.zeros((h, w), np.uint8)
cv2.circle(kernel, (r, r), r, 1, -1)
# 开运算
openingimg = cv2.morphologyEx(stretchedimg, cv2.MORPH_OPEN, kernel)
# 获取差分图，两幅图像做差 cv2.absdiff('图像1','图像2')
strtimg = cv2.absdiff(stretchedimg, openingimg)
# 图像二值化
binaryimg = self.dobinaryzation(strtimg)
# canny边缘检测
canny = cv2.Canny(binaryimg, binaryimg.shape[0], binaryimg.shape[1])
'''消除小的区域，保留大块的区域，从而定位车牌'''
# 进行闭运算
kernel = np.ones((5, 19), np.uint8)
closingimg = cv2.morphologyEx(canny, cv2.MORPH_CLOSE, kernel)
# 进行开运算
openingimg = cv2.morphologyEx(closingimg, cv2.MORPH_OPEN, kernel)
# 再次进行开运算
kernel = np.ones((11, 5), np.uint8)
openingimg = cv2.morphologyEx(openingimg, cv2.MORPH_OPEN, kernel)
# 消除小区域，定位车牌位置
rect = self.locate_license(openingimg, img)
return rect, img
def cut_license(self, afterimg, rect):
'''
图像分割函数
'''
# 转换为宽度和高度
rect[2] = rect[2] - rect[0]
rect[3] = rect[3] - rect[1]
rect_copy = tuple(rect.copy())
# 创建掩膜
mask = np.zeros(afterimg.shape[:2], np.uint8)
# 创建背景模型 大小只能为13*5，行数只能为1，单通道浮点型
bgdModel = np.zeros((1, 65), np.float64)
# 创建前景模型
fgdModel = np.zeros((1, 65), np.float64)
# 分割图像
cv2.grabCut(afterimg, mask, rect_copy, bgdModel, fgdModel, 5, cv2.GC_INIT_WITH_RECT)
mask2 = np.where((mask == 2) | (mask == 0), 0, 1).astype('uint8')
img_show = afterimg * mask2[:, :, np.newaxis]
# cv2.imshow('111',img_show)
return img_show
class Segmentation():
def __init__(self, cutimg):
# 1、读取图像，并把图像转换为灰度图像并显示
# cutimg = cv2.imread("3.jpg") # 读取图片
img_gray = cv2.cvtColor(cutimg, cv2.COLOR_BGR2GRAY) # 转换了灰度化
# cv2.imshow('gray', img_gray) # 显示图片
cv2.waitKey(0)
# 2、将灰度图像二值化，设定阈值是100
self.img_thre = img_gray
cv2.threshold(img_gray, 100, 255, cv2.THRESH_BINARY_INV, self.img_thre)
cv2.waitKey(0)
# 3、保存黑白图片
# cv2.imwrite('thre_res.png', self.img_thre)
# 4、分割字符
self.white = [] # 记录每一列的白色像素总和
self.black = [] # ..........黑色.......
self.height = self.img_thre.shape[0]
self.width = self.img_thre.shape[1]
self.white_max = 0
self.black_max = 0
# 计算每一列的黑白色像素总和
for i in range(self.width):
s = 0 # 这一列白色总数
t = 0 # 这一列黑色总数
for j in range(self.height):
if self.img_thre[j][i] == 255:
s += 1
if self.img_thre[j][i] == 0:
t += 1
self.white_max = max(self.white_max, s)
self.black_max = max(self.black_max, t)
self.white.append(s)
self.black.append(t)
self.arg = False # False表示白底黑字；True表示黑底白字
if self.black_max > self.white_max:
self.arg = True
def heibai(self):
return self.img_thre
# 分割图像
def find_end(self, start_):
end_ = start_ + 1
for m in range(start_ + 1, self.width - 1):
if (self.black[m] if self.arg else self.white[m]) > (
0.85 * self.black_max if self.arg else 0.85 * self.white_max): # 0.95这个参数请多调整，对应下面的0.05
end_ = m
break
return end_
def display(self):
img_list = []
n = 1
plt.figure()
img_num = 0
while n < self.width - 2:
n += 1
if (self.white[n] if self.arg else self.black[n]) > (
0.15 * self.white_max if self.arg else 0.15 * self.black_max):
# 上面这些判断用来辨别是白底黑字还是黑底白字
# 0.05这个参数请多调整，对应上面的0.95
start = n
end = self.find_end(start)
n = end
if end - start > 5:
cj = self.img_thre[1:self.height, start:end]
img_num += 1
cj = cv2.cvtColor(cj, cv2.COLOR_RGB2BGR)
plt.subplot(2, 4, img_num)
plt.imshow(cj)
plt.show()
return self.img_thre
if __name__ == '__main__':
# 原始图像读入
img = cv2.imread('img.png')
img1 = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
plt.figure()
plt.subplot(2, 3, 1)
# print(11111)
plt.title('原始图像', fontproperties=font)
plt.imshow(img1)
license = Get_license()
# # 预处理图像
rect, afterimg = license.find_license(img)
afterimg = cv2.cvtColor(afterimg, cv2.COLOR_RGB2BGR)
plt.subplot(2, 3, 2)
plt.title('预处理后图像', fontproperties=font)
plt.imshow(afterimg)
# # 框出车牌号
cv2.rectangle(afterimg, (rect[0], rect[1]), (rect[2], rect[3]), (0, 255, 0), 2)
x1, y1, x2, y2 = int(rect[0]), int(rect[1]), int(rect[2]), int(rect[3])
print(x1, x2, y1, y2)
plt.subplot(2, 3, 3)
plt.title('车牌框出', fontproperties=font)
plt.imshow(afterimg)
# 分割车牌与背景
cutimg = license.cut_license(afterimg, rect)
plt.subplot(2, 3, 4)
plt.title('车牌背景去除', fontproperties=font)
plt.imshow(cutimg)
# print(int(_rect[0]), int(_rect[3]), int(_rect[2]), int(_rect[1]))
print(x1, y1, x2, y2)
# cutimg = cutimg[140:165, 151:240]
cutimg = cutimg[y1 + 3:y2 - 3, x1 + 12:x2 - 3]
# cutimg = cutimg[int(_rect[0]):int(_rect[3]),int(_rect[2]):int(_rect[1])]
# print(cutimg)
height, width = cutimg.shape[:2]
cutimg1 = cv2.resize(cutimg, (2 * width, 2 * height), interpolation=cv2.INTER_CUBIC)
plt.subplot(2, 3, 5)
# print(11111)
plt.title('分割车牌与背景', fontproperties=font)
plt.imshow(cutimg)
# 字符切割
seg = Segmentation(cutimg)
plt.subplot(2, 3, 6)
img_hei = seg.heibai()
img_hei = cv2.cvtColor(img_hei, cv2.COLOR_RGB2BGR)
plt.title('车牌二值化处理', fontproperties=font)
plt.imshow(img_hei)
seg.display()
plt.show()
# 神经网络模型识别车牌
ocr = ddddocr.DdddOcr()
with open('thre_res.png', 'rb') as f:
image = f.read()
res = ocr.classification(image)
print(res)
但是好像不能完美的匹配所有车牌图片，只能说具体图片得自己去优化