【Python实战】——Python+Opencv是实现车牌自动识别

该篇文章将以实战形式演示利用Python结合Opencv实现车牌识别，全程涉及图像预处理、车牌定位、车牌分割、通过模板匹配识别结果输出。该项目对于智能交通、车辆管理等领域具有实际应用价值。通过自动识别车牌号码，可以实现车辆追踪、违章查询、停车场管理等功能，提高交通管理的效率和准确性。可用于车牌识别技术学习。

技术要点：

• OpenCV：用于图像处理和计算机视觉任务。
• Python：作为编程语言，具有简单易学、资源丰富等优点。
• 图像处理技术：如灰度化、噪声去除、边缘检测、形态学操作、透视变换等。

1 导入相关模块

1. import cv2
2. from matplotlib import pyplot as plt
3. import os
4. import numpy as np
5. from PIL import ImageFont, ImageDraw, Image

复制代码

2 相关功能函数定义

2.1 彩色图片显示函数（plt_show0）

1. def plt_show0(img):
2. b,g,r = cv2.split(img)
3. img = cv2.merge([r, g, b])
4. plt.imshow(img)
5. plt.show()

复制代码

cv2与plt的图像通道不同：cv2为[b,g,r];plt为[r, g, b]

2.2 灰度图片显示函数（plt_show）

1. def plt_show(img):
2. plt.imshow(img,cmap='gray')
3. plt.show()

复制代码

2.3 图像去噪函数（gray_guss）

1. def gray_guss(image):
2. image = cv2.GaussianBlur(image, (3, 3), 0)
3. gray_image = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
4. return gray_image

复制代码

此处演示使用高斯模糊去噪。

cv2.GaussianBlur参数说明：

• src：输入图像，可以是任意数量的通道，这些通道可以独立处理，但深度应为 CV_8U、CV_16U、CV_16S、CV_32F 或 CV_64F。
• ksize：高斯核的大小，必须是正奇数，例如 (3, 3)、(5, 5) 等。如果 ksize 的值为零，那么它会根据 sigmaX 和 sigmaY 的值来计算。
• sigmaX：X 方向上的高斯核标准偏差。
• dst：输出图像，大小和类型与 src 相同。
• sigmaY：Y 方向上的高斯核标准偏差，如果 sigmaY 是零，那么它会与 sigmaX 的值相同。如果 sigmaY 是负数，那么它会从 ksize.width 和 ksize.height 计算得出。
• borderType：像素外插法，有默认值。

2 图像预处理

2.1 图片读取

1. origin_image = cv2.imread('D:/image/car3.jpg')

复制代码

  此处演示识别车牌原图：

2.2 高斯去噪

1. origin_image = cv2.imread('D:/image/car3.jpg')
2. # 复制一张图片，在复制图上进行图像操作，保留原图
3. image = origin_image.copy()
4. gray_image = gray_guss(image)

复制代码

2.3 边缘检测

1. Sobel_x = cv2.Sobel(gray_image, cv2.CV_16S, 1, 0)
2. absX = cv2.convertScaleAbs(Sobel_x)
3. image = absX

复制代码

x方向上的边缘检测（增强边缘信息）。

2.4 阈值化

1. # 图像阈值化操作——获得二值化图
2. ret, image = cv2.threshold(image, 0, 255, cv2.THRESH_OTSU)
3. # 显示灰度图像
4. plt_show(image)

复制代码

  运行结果：

3 车牌定位

3.1 区域选择

1. kernelX = cv2.getStructuringElement(cv2.MORPH_RECT, (30, 10))
2. image = cv2.morphologyEx(image, cv2.MORPH_CLOSE, kernelX,iterations = 1)
3. # 显示灰度图像
4. plt_show(image)

复制代码

从图像中提取对表达和描绘区域形状有意义的图像分量。

  运行结果：

3.2 形态学操作

1. # 腐蚀（erode）和膨胀（dilate）
2. kernelX = cv2.getStructuringElement(cv2.MORPH_RECT, (50, 1))
3. kernelY = cv2.getStructuringElement(cv2.MORPH_RECT, (1, 20))
4. #x方向进行闭操作（抑制暗细节）
5. image = cv2.dilate(image, kernelX)
6. image = cv2.erode(image, kernelX)
7. #y方向的开操作
8. image = cv2.erode(image, kernelY)
9. image = cv2.dilate(image, kernelY)
10. # 中值滤波（去噪）
11. image = cv2.medianBlur(image, 21)
12. # 显示灰度图像
13. plt_show(image)

复制代码

使用膨胀和腐蚀操作来突出车牌区域。

   运行结果：

3.3 轮廓检测

1. contours, hierarchy = cv2.findContours(image, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
2. for item in contours:
3. rect = cv2.boundingRect(item)
4. x = rect[0]
5. y = rect[1]
6. weight = rect[2]
7. height = rect[3]
8. # 根据轮廓的形状特点，确定车牌的轮廓位置并截取图像
9. if (weight > (height * 3)) and (weight < (height * 4.5)):
10. image = origin_image[y:y + height, x:x + weight]
11. plt_show(image)

复制代码

4 车牌字符分割

4.1 高斯去噪

1. # 图像去噪灰度处理
2. gray_image = gray_guss(image)

复制代码

4.2 阈值化

1. ret, image = cv2.threshold(gray_image, 0, 255, cv2.THRESH_OTSU)
2. plt_show(image)

复制代码

  运行结果：

4.3 膨胀操作

1. #膨胀操作
2. kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (4, 4))
3. image = cv2.dilate(image, kernel)
4. plt_show(image)

复制代码

  运行结果：

4.4 车牌号排序

1. words = sorted(words,key=lambda s:s[0],reverse=False)
2. i = 0
3. #word中存放轮廓的起始点和宽高
4. for word in words:
5. # 筛选字符的轮廓
6. if (word[3] > (word[2] * 1.5)) and (word[3] < (word[2] * 5.5)) and (word[2] > 10):
7. i = i+1
8. if word[2] < 15:
9. splite_image = image[word[1]:word[1] + word[3], word[0]-word[2]:word[0] + word[2]*2]
10. else:
11. splite_image = image[word[1]:word[1] + word[3], word[0]:word[0] + word[2]]
12. word_images.append(splite_image)
13. print(i)
14. print(words)

复制代码

  运行结果：

1. 1
2. 2
3. 3
4. 4
5. 5
6. 6
7. 7
8. [[2, 0, 7, 70], [12, 6, 30, 55], [15, 7, 7, 9], [46, 6, 32, 55], [83, 30, 9, 9], [96, 7, 32, 55], [132, 8, 32, 55], [167, 8, 30, 54], [202, 62, 7, 6], [203, 7, 30, 55], [245, 7, 12, 54], [266, 0, 12, 70]]

复制代码

4.5 分割效果

1. for i,j in enumerate(word_images):
2. plt.subplot(1,7,i+1)
3. plt.imshow(word_images[i],cmap='gray')
4. plt.show()

复制代码

  运行结果：

5 模板匹配

5.1 准备模板

1. # 准备模板(template[0-9]为数字模板；)
2. template = ['0','1','2','3','4','5','6','7','8','9',
3. 'A','B','C','D','E','F','G','H','J','K','L','M','N','P','Q','R','S','T','U','V','W','X','Y','Z',
4. '藏','川','鄂','甘','赣','贵','桂','黑','沪','吉','冀','津','晋','京','辽','鲁','蒙','闽','宁',
5. '青','琼','陕','苏','皖','湘','新','渝','豫','粤','云','浙']
7. # 读取一个文件夹下的所有图片，输入参数是文件名，返回模板文件地址列表
8. def read_directory(directory_name):
9. referImg_list = []
10. for filename in os.listdir(directory_name):
11. referImg_list.append(directory_name + "/" + filename)
12. return referImg_list
14. # 获得中文模板列表（只匹配车牌的第一个字符）
15. def get_chinese_words_list():
16. chinese_words_list = []
17. for i in range(34,64):
18. #将模板存放在字典中
19. c_word = read_directory('D:/refer1/'+ template[i])
20. chinese_words_list.append(c_word)
21. return chinese_words_list
22. chinese_words_list = get_chinese_words_list()
25. # 获得英文模板列表（只匹配车牌的第二个字符）
26. def get_eng_words_list():
27. eng_words_list = []
28. for i in range(10,34):
29. e_word = read_directory('D:/refer1/'+ template[i])
30. eng_words_list.append(e_word)
31. return eng_words_list
32. eng_words_list = get_eng_words_list()
35. # 获得英文和数字模板列表（匹配车牌后面的字符）
36. def get_eng_num_words_list():
37. eng_num_words_list = []
38. for i in range(0,34):
39. word = read_directory('D:/refer1/'+ template[i])
40. eng_num_words_list.append(word)
41. return eng_num_words_list
42. eng_num_words_list = get_eng_num_words_list()

复制代码

此处需提前准备各类字符模板。

5.2 匹配结果

1. # 获得英文和数字模板列表（匹配车牌后面的字符）
2. def get_eng_num_words_list():
3. eng_num_words_list = []
4. for i in range(0,34):
5. word = read_directory('D:/refer1/'+ template[i])
6. eng_num_words_list.append(word)
7. return eng_num_words_list
8. eng_num_words_list = get_eng_num_words_list()
11. # 读取一个模板地址与图片进行匹配，返回得分
12. def template_score(template,image):
13. #将模板进行格式转换
14. template_img=cv2.imdecode(np.fromfile(template,dtype=np.uint8),1)
15. template_img = cv2.cvtColor(template_img, cv2.COLOR_RGB2GRAY)
16. #模板图像阈值化处理——获得黑白图
17. ret, template_img = cv2.threshold(template_img, 0, 255, cv2.THRESH_OTSU)
18. # height, width = template_img.shape
19. # image_ = image.copy()
20. # image_ = cv2.resize(image_, (width, height))
21. image_ = image.copy()
22. #获得待检测图片的尺寸
23. height, width = image_.shape
24. # 将模板resize至与图像一样大小
25. template_img = cv2.resize(template_img, (width, height))
26. # 模板匹配，返回匹配得分
27. result = cv2.matchTemplate(image_, template_img, cv2.TM_CCOEFF)
28. return result[0][0]
31. # 对分割得到的字符逐一匹配
32. def template_matching(word_images):
33. results = []
34. for index,word_image in enumerate(word_images):
35. if index==0:
36. best_score = []
37. for chinese_words in chinese_words_list:
38. score = []
39. for chinese_word in chinese_words:
40. result = template_score(chinese_word,word_image)
41. score.append(result)
42. best_score.append(max(score))
43. i = best_score.index(max(best_score))
44. # print(template[34+i])
45. r = template[34+i]
46. results.append(r)
47. continue
48. if index==1:
49. best_score = []
50. for eng_word_list in eng_words_list:
51. score = []
52. for eng_word in eng_word_list:
53. result = template_score(eng_word,word_image)
54. score.append(result)
55. best_score.append(max(score))
56. i = best_score.index(max(best_score))
57. # print(template[10+i])
58. r = template[10+i]
59. results.append(r)
60. continue
61. else:
62. best_score = []
63. for eng_num_word_list in eng_num_words_list:
64. score = []
65. for eng_num_word in eng_num_word_list:
66. result = template_score(eng_num_word,word_image)
67. score.append(result)
68. best_score.append(max(score))
69. i = best_score.index(max(best_score))
70. # print(template[i])
71. r = template[i]
72. results.append(r)
73. continue
74. return results
77. word_images_ = word_images.copy()
78. # 调用函数获得结果
79. result = template_matching(word_images_)
80. print(result)
81. print( "".join(result))

复制代码

  运行结果：

1. ['渝', 'B', 'F', 'U', '8', '7', '1']
2. 渝BFU871

复制代码

“”.join(result)函数将列表转换为拼接好的字符串，方便结果显示

5.3 匹配效果展示

1. height,weight = origin_image.shape[0:2]
2. print(height)
3. print(weight)
5. image_1 = origin_image.copy()
6. cv2.rectangle(image_1, (int(0.2*weight), int(0.75*height)), (int(weight*0.9), int(height*0.95)), (0, 255, 0), 5)
8. #设置需要显示的字体
9. fontpath = "font/simsun.ttc"
10. font = ImageFont.truetype(fontpath,64)
11. img_pil = Image.fromarray(image_1)
12. draw = ImageDraw.Draw(img_pil)
13. #绘制文字信息
14. draw.text((int(0.2*weight)+25, int(0.75*height)), "".join(result), font = font, fill = (255, 255, 0))
15. bk_img = np.array(img_pil)
16. print(result)
17. print( "".join(result))
18. plt_show0(bk_img)

复制代码

  运行结果：

6完整代码

1. # 导入所需模块
2. import cv2
3. from matplotlib import pyplot as plt
4. import os
5. import numpy as np
6. from PIL import ImageFont, ImageDraw, Image
7. # plt显示彩色图片
8. def plt_show0(img):
9. b,g,r = cv2.split(img)
10. img = cv2.merge([r, g, b])
11. plt.imshow(img)
12. plt.show()
14. # plt显示灰度图片
15. def plt_show(img):
16. plt.imshow(img,cmap='gray')
17. plt.show()
19. # 图像去噪灰度处理
20. def gray_guss(image):
21. image = cv2.GaussianBlur(image, (3, 3), 0)
22. gray_image = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
23. return gray_image
25. # 读取待检测图片
26. origin_image = cv2.imread('D:/image/car3.jpg')
27. # 复制一张图片，在复制图上进行图像操作，保留原图
28. image = origin_image.copy()
29. # 图像去噪灰度处理
30. gray_image = gray_guss(image)
31. # x方向上的边缘检测（增强边缘信息）
32. Sobel_x = cv2.Sobel(gray_image, cv2.CV_16S, 1, 0)
33. absX = cv2.convertScaleAbs(Sobel_x)
34. image = absX
36. # 图像阈值化操作——获得二值化图
37. ret, image = cv2.threshold(image, 0, 255, cv2.THRESH_OTSU)
38. # 显示灰度图像
39. plt_show(image)
40. # 形态学（从图像中提取对表达和描绘区域形状有意义的图像分量）——闭操作
41. kernelX = cv2.getStructuringElement(cv2.MORPH_RECT, (30, 10))
42. image = cv2.morphologyEx(image, cv2.MORPH_CLOSE, kernelX,iterations = 1)
43. # 显示灰度图像
44. plt_show(image)
47. # 腐蚀（erode）和膨胀（dilate）
48. kernelX = cv2.getStructuringElement(cv2.MORPH_RECT, (50, 1))
49. kernelY = cv2.getStructuringElement(cv2.MORPH_RECT, (1, 20))
50. #x方向进行闭操作（抑制暗细节）
51. image = cv2.dilate(image, kernelX)
52. image = cv2.erode(image, kernelX)
53. #y方向的开操作
54. image = cv2.erode(image, kernelY)
55. image = cv2.dilate(image, kernelY)
56. # 中值滤波（去噪）
57. image = cv2.medianBlur(image, 21)
58. # 显示灰度图像
59. plt_show(image)
61. # 获得轮廓
62. contours, hierarchy = cv2.findContours(image, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
64. for item in contours:
65. rect = cv2.boundingRect(item)
66. x = rect[0]
67. y = rect[1]
68. weight = rect[2]
69. height = rect[3]
70. # 根据轮廓的形状特点，确定车牌的轮廓位置并截取图像
71. if (weight > (height * 3)) and (weight < (height * 4.5)):
72. image = origin_image[y:y + height, x:x + weight]
73. plt_show(image)
76. #车牌字符分割
77. # 图像去噪灰度处理
78. gray_image = gray_guss(image)
80. # 图像阈值化操作——获得二值化图
81. ret, image = cv2.threshold(gray_image, 0, 255, cv2.THRESH_OTSU)
82. plt_show(image)
84. #膨胀操作
85. kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (4, 4))
86. image = cv2.dilate(image, kernel)
87. plt_show(image)
90. # 查找轮廓
91. contours, hierarchy = cv2.findContours(image, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
92. words = []
93. word_images = []
94. #对所有轮廓逐一操作
95. for item in contours:
96. word = []
97. rect = cv2.boundingRect(item)
98. x = rect[0]
99. y = rect[1]
100. weight = rect[2]
101. height = rect[3]
102. word.append(x)
103. word.append(y)
104. word.append(weight)
105. word.append(height)
106. words.append(word)
107. # 排序，车牌号有顺序。words是一个嵌套列表
108. words = sorted(words,key=lambda s:s[0],reverse=False)
109. i = 0
110. #word中存放轮廓的起始点和宽高
111. for word in words:
112. # 筛选字符的轮廓
113. if (word[3] > (word[2] * 1.5)) and (word[3] < (word[2] * 5.5)) and (word[2] > 10):
114. i = i+1
115. if word[2] < 15:
116. splite_image = image[word[1]:word[1] + word[3], word[0]-word[2]:word[0] + word[2]*2]
117. else:
118. splite_image = image[word[1]:word[1] + word[3], word[0]:word[0] + word[2]]
119. word_images.append(splite_image)
120. print(i)
121. print(words)
123. for i,j in enumerate(word_images):
124. plt.subplot(1,7,i+1)
125. plt.imshow(word_images[i],cmap='gray')
126. plt.show()
128. #模版匹配
129. # 准备模板(template[0-9]为数字模板；)
130. template = ['0','1','2','3','4','5','6','7','8','9',
131. 'A','B','C','D','E','F','G','H','J','K','L','M','N','P','Q','R','S','T','U','V','W','X','Y','Z',
132. '藏','川','鄂','甘','赣','贵','桂','黑','沪','吉','冀','津','晋','京','辽','鲁','蒙','闽','宁',
133. '青','琼','陕','苏','皖','湘','新','渝','豫','粤','云','浙']
135. # 读取一个文件夹下的所有图片，输入参数是文件名，返回模板文件地址列表
136. def read_directory(directory_name):
137. referImg_list = []
138. for filename in os.listdir(directory_name):
139. referImg_list.append(directory_name + "/" + filename)
140. return referImg_list
142. # 获得中文模板列表（只匹配车牌的第一个字符）
143. def get_chinese_words_list():
144. chinese_words_list = []
145. for i in range(34,64):
146. #将模板存放在字典中
147. c_word = read_directory('D:/refer1/'+ template[i])
148. chinese_words_list.append(c_word)
149. return chinese_words_list
150. chinese_words_list = get_chinese_words_list()
153. # 获得英文模板列表（只匹配车牌的第二个字符）
154. def get_eng_words_list():
155. eng_words_list = []
156. for i in range(10,34):
157. e_word = read_directory('D:/refer1/'+ template[i])
158. eng_words_list.append(e_word)
159. return eng_words_list
160. eng_words_list = get_eng_words_list()
163. # 获得英文和数字模板列表（匹配车牌后面的字符）
164. def get_eng_num_words_list():
165. eng_num_words_list = []
166. for i in range(0,34):
167. word = read_directory('D:/refer1/'+ template[i])
168. eng_num_words_list.append(word)
169. return eng_num_words_list
170. eng_num_words_list = get_eng_num_words_list()
173. # 读取一个模板地址与图片进行匹配，返回得分
174. def template_score(template,image):
175. #将模板进行格式转换
176. template_img=cv2.imdecode(np.fromfile(template,dtype=np.uint8),1)
177. template_img = cv2.cvtColor(template_img, cv2.COLOR_RGB2GRAY)
178. #模板图像阈值化处理——获得黑白图
179. ret, template_img = cv2.threshold(template_img, 0, 255, cv2.THRESH_OTSU)
180. # height, width = template_img.shape
181. # image_ = image.copy()
182. # image_ = cv2.resize(image_, (width, height))
183. image_ = image.copy()
184. #获得待检测图片的尺寸
185. height, width = image_.shape
186. # 将模板resize至与图像一样大小
187. template_img = cv2.resize(template_img, (width, height))
188. # 模板匹配，返回匹配得分
189. result = cv2.matchTemplate(image_, template_img, cv2.TM_CCOEFF)
190. return result[0][0]
193. # 对分割得到的字符逐一匹配
194. def template_matching(word_images):
195. results = []
196. for index,word_image in enumerate(word_images):
197. if index==0:
198. best_score = []
199. for chinese_words in chinese_words_list:
200. score = []
201. for chinese_word in chinese_words:
202. result = template_score(chinese_word,word_image)
203. score.append(result)
204. best_score.append(max(score))
205. i = best_score.index(max(best_score))
206. # print(template[34+i])
207. r = template[34+i]
208. results.append(r)
209. continue
210. if index==1:
211. best_score = []
212. for eng_word_list in eng_words_list:
213. score = []
214. for eng_word in eng_word_list:
215. result = template_score(eng_word,word_image)
216. score.append(result)
217. best_score.append(max(score))
218. i = best_score.index(max(best_score))
219. # print(template[10+i])
220. r = template[10+i]
221. results.append(r)
222. continue
223. else:
224. best_score = []
225. for eng_num_word_list in eng_num_words_list:
226. score = []
227. for eng_num_word in eng_num_word_list:
228. result = template_score(eng_num_word,word_image)
229. score.append(result)
230. best_score.append(max(score))
231. i = best_score.index(max(best_score))
232. # print(template[i])
233. r = template[i]
234. results.append(r)
235. continue
236. return results
239. word_images_ = word_images.copy()
240. # 调用函数获得结果
241. result = template_matching(word_images_)
242. print(result)
243. # "".join(result)函数将列表转换为拼接好的字符串，方便结果显示
244. print( "".join(result))
248. height,weight = origin_image.shape[0:2]
249. print(height)
250. print(weight)
252. image_1 = origin_image.copy()
253. cv2.rectangle(image_1, (int(0.2*weight), int(0.75*height)), (int(weight*0.9), int(height*0.95)), (0, 255, 0), 5)
255. #设置需要显示的字体
256. fontpath = "font/simsun.ttc"
257. font = ImageFont.truetype(fontpath,64)
258. img_pil = Image.fromarray(image_1)
259. draw = ImageDraw.Draw(img_pil)
260. #绘制文字信息
261. draw.text((int(0.2*weight)+25, int(0.75*height)), "".join(result), font = font, fill = (255, 255, 0))
262. bk_img = np.array(img_pil)
263. print(result)
264. print( "".join(result))
265. plt_show0(bk_img)

复制代码