python基于OpenCV模板匹配识别图片中的数字

前言

本博客主要实现利用OpenCV的模板匹配识别图像中的数字，然后把识别出来的数字输出到txt文件中，如果识别失败则输出“读取失败”。

操作环境：

• OpenCV - 4.1.0
• Python 3.8.1

程序目标

单个数字模板：（这些单个模板是我自己直接从图片上截取下来的）

要处理的图片：

终端输出：

文本输出：

思路讲解

代码讲解

首先定义两个会用到的函数

第一个是显示图片的函数，这样的话在显示图片的时候就比较方便了

1. def cv_show(name, img):
2. cv2.imshow(name, img)
3. cv2.waitKey(0)
4. cv2.destroyAllWindows()

第二个是图片缩放的函数

1. def resize(image, width=None, height=None, inter=cv2.INTER_AREA):
2. dim = None
3. (h, w) = image.shape[:2]
4. if width is None and height is None:
5. return image
6. if width is None:
7. r = height / float(h)
8. dim = (int(w * r), height)
9. else:
10. r = width / float(w)
11. dim = (width, int(h * r))
12. resized = cv2.resize(image, dim, interpolation=inter)
13. return resized

先把这个代码贴出来，方便后面单个函数代码的理解。

1. if __name__ == "__main__":
2. # 存放数字模板列表
3. digits = []
4. # 当前运行目录
5. now_dir = os.getcwd()
6. print("当前运行目录：" + now_dir)
7. numbers_address = now_dir + "\\numbers"
8. load_digits()
9. times = input("请输入程序运行次数：")
10. for i in range(1, int(times) + 1):
11. demo(i)
12. print("输出成功，请检查本地temp.txt文件")
13. while True:
14. if input("输入小写‘q'并回车退出") == 'q':
15. break

接下来是第一个主要函数，功能是加载数字模板并进行处理。

这个函数使用到了os模块，所以需要在开头import os

1. def load_digits():
2. # 加载数字模板
3. path = numbers_address # 这个地方就是获取当前运行目录 获取函数在主函数里面
4. filename = os.listdir(path) # 获取文件夹文件
5. for file in filename:
6. img = cv2.imread(numbers_address + "\\" + file) # 读取图片
7. img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) # 灰度处理
8. # 自动阈值二值化 把图片处理成黑底白字
9. img_temp = cv2.threshold(img_gray, 0, 255, cv2.THRESH_BINARY_INV | cv2.THRESH_OTSU)[1]
10. # 寻找数字轮廓
11. cnt = cv2.findContours(img_temp, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)[0]
12. # 获取数字矩形轮廓
13. x, y, w, h = cv2.boundingRect(cnt[0])
14. # 将单个数字区域进行缩放并存到列表中以备后面使用
15. digit_roi = cv2.resize(img_temp[y:y+h, x:x+w], (57, 88))
16. digits.append(digit_roi)

最后一个函数是程序的重点，实现功能就是识别出数字并输出。

不过这里把这个大函数分开两部分来讲解。

第一部分是对图片进行处理，最终把图片中的数字区域圈出来。

1. # 这两个都是核，参数可以改变
2. rectKernel = cv2.getStructuringElement(cv2.MORPH_RECT, (25, 25))
3. sqKernel = cv2.getStructuringElement(cv2.MORPH_RECT, (5, 5))
4. # 这个就是读取图片的，可以暂时不理解
5. target_path = now_dir + "\\" + "demo_" + str(index) + ".png"
6. img_origin = cv2.imread(target_path)
7. # 对图片进行缩放处理
8. img_origin = resize(img_origin, width=300)
9. # 灰度图
10. img_gray = cv2.cvtColor(img_origin, cv2.COLOR_BGR2GRAY)
11. # 高斯滤波 参数可以改变，选择效果最好的就可以
12. gaussian = cv2.GaussianBlur(img_gray, (5, 5), 1)、
13. # 自动二值化处理，黑底白字
14. img_temp = cv2.threshold(
15. gaussian, 0, 255, cv2.THRESH_BINARY_INV | cv2.THRESH_OTSU)[1]
16. # 顶帽操作
17. img_top = cv2.morphologyEx(img_temp, cv2.MORPH_TOPHAT, rectKernel)
18. # sobel操作
19. img_sobel_x = cv2.Sobel(img_top, cv2.CV_64F, 1, 0, ksize=7)
20. img_sobel_x = cv2.convertScaleAbs(img_sobel_x)
21. img_sobel_y = cv2.Sobel(img_top, cv2.CV_64F, 0, 1, ksize=7)
22. img_sobel_y = cv2.convertScaleAbs(img_sobel_y)
23. img_sobel_xy = cv2.addWeighted(img_sobel_x, 1, img_sobel_y, 1, 0)
24. # 闭操作
25. img_closed = cv2.morphologyEx(img_sobel_xy, cv2.MORPH_CLOSE, rectKernel)
26. # 自动二值化
27. thresh = cv2.threshold(
28. img_closed, 0, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)[1]
29. # 闭操作
30. img_closed = cv2.morphologyEx(thresh, cv2.MORPH_CLOSE, sqKernel)
31. # 寻找数字轮廓
32. cnts = cv2.findContours(
33. img_closed.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)[0]
34. # 轮廓排序
35. (cnts, boundingBoxes) = contours.sort_contours(cnts, "top-to-bottom")
36. # 存放正确数字序列（包含逗号）的轮廓，即过滤掉不需要的轮廓
37. right_loc = []
38. # 下面这个循环是对轮廓进行筛选，只有长宽比例大于2的才可以被添加到列表中
39. # 这个比例可以根据具体情况来改变。除此之外，还可以通过轮廓周长和轮廓面积等对轮廓进行筛选
40. for c in cnts:
41. x, y, w, h = cv2.boundingRect(c)
42. ar = w/float(h)
43. if ar > 2:
44. right_loc.append((x, y, w, h))

部分步骤的效果图：

可以看到在进行完最后一次闭操作后，一串数字全部变成白色区域，这样再进行轮廓检测就可以框出每一行数字的大致范围，这样就可以缩小数字处理的范围，可以在这些具体的区域内部对单个数字进行处理。

轮廓效果：

在这样进行以上步骤之后，就可以确定一行数字的范围了，下面就进行轮廓筛选把符合条件的轮廓存入列表。

注意：在代码中使用了(cnts, boundingBoxes) = contours.sort_contours(cnts, "top-to-bottom")

这个函数的使用需要导入imutils，这个模块具体使用方法可以浏览我的另一篇博客OpenCV学习笔记

函数的最后一部分就是对每个数字轮廓进行分割，取出单个数字的区域然后进行模板匹配。

1. for (gx, gy, gw, gh) in right_loc:
2. # 用于存放识别到的数字
3. digit_out = []
4. # 下面两个判断主要是防止出现越界的情况发生，如果发生的话图片读取会出错
5. if (gy-10 < 0):
6. now_gy = gy
7. else:
8. now_gy = gy-10
9. if (gx - 10 < 0):
10. now_gx = gx
11. else:
12. now_gx = gx-10
13. # 选择图片兴趣区域
14. img_digit = gaussian[now_gy:gy+gh+10, now_gx:gx+gw+10]
15. # 二值化处理
16. img_thresh = cv2.threshold(
17. img_digit, 0, 255, cv2.THRESH_BINARY_INV | cv2.THRESH_OTSU)[1]
18. # 寻找所有轮廓 找出每个数字的轮廓（包含逗号） 正确的话应该有9个轮廓
19. digitCnts = cv2.findContours(
20. img_thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)[0]
21. # 从左到右排列轮廓
22. # 这样排列的好处是，正常情况下可以确定逗号的位置方便后面删除逗号
23. (cnts, boundingBoxes) = contours.sort_contours(digitCnts, "left-to-right")
24. # cnts是元组，需要先转换成列表，因为后面会对元素进行删除处理
25. cnts = list(cnts)
26. flag = 0
27. # 判断轮廓数量是否有9个
28. if len(cnts) == 9:
29. # 删除逗号位置
30. del cnts[1]
31. del cnts[2]
32. del cnts[3]
33. del cnts[4]
34. # 可以在转成元组
35. cnts = tuple(cnts)
36. # 存放单个数字的矩形区域
37. num_roi = []
38. for c in cnts:
39. x, y, w, h = cv2.boundingRect(c)
40. num_roi.append((x, y, w, h))
41. # 对数字区域进行处理，把尺寸缩放到与数字模板相同
42. # 对其进行简单处理，方便与模板匹配，增加匹配率
43. for (rx, ry, rw, rh) in num_roi:
44. roi = img_digit[ry:ry+rh, rx:rx+rw]
45. roi = cv2.resize(roi, (57, 88))
46. # 高斯滤波
47. roi = cv2.GaussianBlur(roi, (5, 5), 1)
48. # 二值化
49. roi = cv2.threshold(
50. roi, 0, 255, cv2.THRESH_BINARY_INV | cv2.THRESH_OTSU)[1]
51. # 用于存放匹配率
52. source = []
53. # 遍历数字模板
54. for digitROI in digits:
55. # 进行模板匹配
56. res = cv2.matchTemplate(
57. roi, digitROI, cv2.TM_CCOEFF_NORMED)
58. max_val = cv2.minMaxLoc(res)[1]
59. source.append(max_val)
60. # 这个需要仔细理解 这个就是把0-9数字中匹配度最高的数字存放到列表中
61. digit_out.append(str(source.index(max(source))))
62. # 打印最终输出值
63. print(digit_out)
64. else:
65. print("读取失败")
66. flag = 1
67. # 将数字输出到txt文本中
68. t = ''
69. with open(now_dir + "\\temp.txt", 'a+') as q:
70. if flag == 0:
71. for content in digit_out:
72. t = t + str(content) + " "
73. q.write(t.strip(" "))
74. q.write('\n')
75. t = ''
76. else:
77. q.write("读取失败")
78. q.write('\n')

注意理解：digit_out.append(str(source.index(max(source))))

这个是很重要的，列表source存放模板匹配的每个数字的匹配率，求出其中最大值的索引值，因为数字模板是按照0-9排列的，索引source的匹配率也是按照0-9排列的，所以每个元素的索引值就与相匹配的数字相同。这样的话，取得最大值的索引值就相当于取到了匹配率最高的数字。

完整代码

1. from imutils import contours
2. import cv2
3. import os
4.  
5. def cv_show(name, img):
6. cv2.imshow(name, img)
7. cv2.waitKey(0)
8. cv2.destroyAllWindows()
9.  
10. def resize(image, width=None, height=None, inter=cv2.INTER_AREA):
11. dim = None
12. (h, w) = image.shape[:2]
13. if width is None and height is None:
14. return image
15. if width is None:
16. r = height / float(h)
17. dim = (int(w * r), height)
18. else:
19. r = width / float(w)
20. dim = (width, int(h * r))
21. resized = cv2.resize(image, dim, interpolation=inter)
22. return resized
23.  
24. def load_digits():
25. # 加载数字模板
26. path = numbers_address
27. filename = os.listdir(path)
28. for file in filename:
29. # print(file)
30. img = cv2.imread(
31. numbers_address + "\\" + file)
32. img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
33. img_temp = cv2.threshold(
34. img_gray, 0, 255, cv2.THRESH_BINARY_INV | cv2.THRESH_OTSU)[1]
35. cnt = cv2.findContours(img_temp, cv2.RETR_EXTERNAL,
36. cv2.CHAIN_APPROX_NONE)[0]
37. x, y, w, h = cv2.boundingRect(cnt[0])
38. digit_roi = cv2.resize(img_temp[y:y+h, x:x+w], (57, 88))
39. # 将数字模板存到列表中
40. digits.append(digit_roi)
41.  
42. def demo(index):
43. rectKernel = cv2.getStructuringElement(cv2.MORPH_RECT, (25, 25))
44. sqKernel = cv2.getStructuringElement(cv2.MORPH_RECT, (5, 5))
45. target_path = now_dir + "\\" + "demo_" + str(index) + ".png"
46. img_origin = cv2.imread(target_path)
47. img_origin = resize(img_origin, width=300)
48. img_gray = cv2.cvtColor(img_origin, cv2.COLOR_BGR2GRAY)
49. gaussian = cv2.GaussianBlur(img_gray, (5, 5), 1)
50. img_temp = cv2.threshold(
51. gaussian, 0, 255, cv2.THRESH_BINARY_INV | cv2.THRESH_OTSU)[1]
52. img_top = cv2.morphologyEx(img_temp, cv2.MORPH_TOPHAT, rectKernel)
53. img_sobel_x = cv2.Sobel(img_top, cv2.CV_64F, 1, 0, ksize=7)
54. img_sobel_x = cv2.convertScaleAbs(img_sobel_x)
55. img_sobel_y = cv2.Sobel(img_top, cv2.CV_64F, 0, 1, ksize=7)
56. img_sobel_y = cv2.convertScaleAbs(img_sobel_y)
57. img_sobel_xy = cv2.addWeighted(img_sobel_x, 1, img_sobel_y, 1, 0)
58. img_closed = cv2.morphologyEx(img_sobel_xy, cv2.MORPH_CLOSE, rectKernel)
59. thresh = cv2.threshold(
60. img_closed, 0, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)[1]
61. img_closed = cv2.morphologyEx(thresh, cv2.MORPH_CLOSE, sqKernel)
62. cnts = cv2.findContours(
63. img_closed.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)[0]
64. (cnts, boundingBoxes) = contours.sort_contours(cnts, "top-to-bottom")
65. draw_img = img_origin.copy()
66. draw_img = cv2.drawContours(draw_img, cnts, -1, (0, 0, 255), 1)
67. cv_show("666", draw_img)
68.  
69. # 存放正确数字序列（包含逗号）的轮廓，即过滤掉不需要的轮廓
70. right_loc = []
71. for c in cnts:
72. x, y, w, h = cv2.boundingRect(c)
73. ar = w/float(h)
74. if ar > 2:
75. right_loc.append((x, y, w, h))
76. for (gx, gy, gw, gh) in right_loc:
77. # 用于存放识别到的数字
78. digit_out = []
79. if (gy-10 < 0):
80. now_gy = gy
81. else:
82. now_gy = gy-10
83. if (gx - 10 < 0):
84. now_gx = gx
85. else:
86. now_gx = gx-10
87. img_digit = gaussian[now_gy:gy+gh+10, now_gx:gx+gw+10]
88. # 二值化处理
89. img_thresh = cv2.threshold(
90. img_digit, 0, 255, cv2.THRESH_BINARY_INV | cv2.THRESH_OTSU)[1]
91. # 寻找轮廓 找出每个数字的轮廓（包含逗号） 正确的话应该有9个轮廓
92. digitCnts = cv2.findContours(
93. img_thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)[0]
94. # 从左到右排列
95. (cnts, boundingBoxes) = contours.sort_contours(digitCnts, "left-to-right")
96. cnts = list(cnts)
97. flag = 0
98. if len(cnts) == 9:
99. del cnts[1]
100. del cnts[2]
101. del cnts[3]
102. del cnts[4]
103. cnts = tuple(cnts)
104. num_roi = []
105. for c in cnts:
106. x, y, w, h = cv2.boundingRect(c)
107. num_roi.append((x, y, w, h))
108. for (rx, ry, rw, rh) in num_roi:
109. roi = img_digit[ry:ry+rh, rx:rx+rw]
110. roi = cv2.resize(roi, (57, 88))
111. roi = cv2.GaussianBlur(roi, (5, 5), 1)
112. roi = cv2.threshold(
113. roi, 0, 255, cv2.THRESH_BINARY_INV | cv2.THRESH_OTSU)[1]
114. source = []
115. for digitROI in digits:
116. res = cv2.matchTemplate(
117. roi, digitROI, cv2.TM_CCOEFF_NORMED)
118. max_val = cv2.minMaxLoc(res)[1]
119. source.append(max_val)
120. digit_out.append(str(source.index(max(source))))
121. cv2.rectangle(img_origin, (gx-5, gy-5),
122. (gx+gw+5, gy+gh+5), (0, 0, 255), 1)
123. print(digit_out)
124. else:
125. print("读取失败")
126. flag = 1
127. t = ''
128. with open(now_dir + "\\temp.txt", 'a+') as q:
129. if flag == 0:
130. for content in digit_out:
131. t = t + str(content) + " "
132. q.write(t.strip(" "))
133. q.write('\n')
134. t = ''
135. else:
136. q.write("读取失败")
137. q.write('\n')
138.  
139. if __name__ == "__main__":
140. # 存放数字模板列表
141. digits = []
142. # 当前运行目录
143. now_dir = os.getcwd()
144. print("当前运行目录：" + now_dir)
145. numbers_address = now_dir + "\\numbers"
146. load_digits()
147. times = input("请输入程序运行次数：")
148. for i in range(1, int(times) + 1):
149. demo(i)
150. print("输出成功，请检查本地temp.txt文件")
151. cv2.waitKey(0)
152. cv2.destroyAllWindows()
153. while True:
154. if input("输入小写‘q'并回车退出") == 'q':
155. break

整个文件下载地址：https://wwe.lanzous.com/iLSDunf850b

注意：如果想同时识别多个图片话，需要将图片统一改名为“demo_ + 数字序号.png” 例如：demo_1.png demo_2.png 同时在运行代码时输入图片个数即可。

总结

这个程序代码相对来说不算复杂，主要是对图像的一些基础处理需要注意。因为不同的图像想要识别成功需要进行不同程度的基础处理，所以在做的时候可以多输出几张图片检查一下那一步效果不太好并及时进行修改调整，这样才能达到最终比较好的效果。

以上就是python基于OpenCV模板匹配识别图片中的数字的详细内容，更多关于python 识别图片中的数字的资料请关注服务器之家其它相关文章！

原文链接：https://blog.csdn.net/ZhuanShangNiDeXin/article/details/115291262