• OpenCV模板匹配实现银行卡数字识别

    目录

    1，项目流程

    2，代码流程解读

    2.1 导入工具包

    2.2  设置参数

    2.3    指定信用卡类型

    2.4  展示图像

    ​编辑

    2.5  读取一个模板图像

    2.6  转化为灰度图--------->再转化为二值图像

    2.7  计算轮廓

    ​编辑

    2.8  导入我们要识别的图像，并预处理

    3，全部代码

    1，项目流程

    1. 导入所需的工具包。

    2. 设置命令行参数，包括输入图像和模板图像的路径。

    3. 定义信用卡类型的字典。

    4. 读取并预处理模板图像。首先将图像转换为灰度图像，然后进行二值化处理。

    5. 计算模板图像中每个数字的轮廓，并保存在字典中。

    6. 初始化卷积核，用于后续图像处理操作。

    7. 读取输入图像并进行预处理。首先调整图像大小为指定宽度，然后将图像转换为灰度图像。

    8. 对灰度图像进行礼帽操作，突出更明亮的区域。

    9. 计算图像的梯度，突出边缘信息。

    10. 通过闭操作将图像中的数字连在一起。

    11. 对图像进行二值化处理。

    12. 再次进行闭操作。

    13. 找到图像中的轮廓。

    14. 根据轮廓的宽高比和面积进行筛选，得到符合条件的轮廓。

    15. 对符合条件的轮廓进行排序，按照从左到右的顺序。

    16. 遍历每个轮廓中的数字。

    17. 提取每个数字所在的组，并进行预处理。

    18. 计算每个组中每个数字的轮廓。

    19. 对每个数字的轮廓与模板进行匹配，得到最合适的数字。

    20. 绘制矩形框和添加识别结果文本。

    21. 输出信用卡类型和完整的信用卡号码。

    22. 展示识别结果图像。

    2，代码流程解读

    2.1 导入工具包

    from imutils import contours
    import numpy as np
    import argparse
    import cv2
    import myutils
     

    2.2  设置参数

    设置了程序需要读入的图像和模板路径

    1. # 设置参数
    2. ap = argparse.ArgumentParser()
    3. ap.add_argument("-i", "--image", required=True,
    4. 	help="path to input image")
    5. ap.add_argument("-t", "--template", required=True,
    6. 	help="path to template OCR-A image")
    7. args = vars(ap.parse_args())

    2.3    指定信用卡类型

    在这里，我们指定各种信用卡的开头数字对应的信用卡类型。

    1. # 指定信用卡类型
    2. FIRST_NUMBER = {
    3. 	"3": "American Express",
    4. 	"4": "Visa",
    5. 	"5": "MasterCard",
    6. 	"6": "Discover Card"
    7. }

    2.4  展示图像

    自定义函数，用于可视化图像。

    1. # 绘图展示
    2. def cv_show(name,img):
    3. 	cv2.imshow(name, img)
    4. 	cv2.waitKey(0)
    5. 	cv2.destroyAllWindows()

    2.5  读取一个模板图像

    1. # 读取一个模板图像
    2. img = cv2.imread(args["template"])
    3. cv_show('img',img)

    2.6  转化为灰度图--------->再转化为二值图像

    将模板图像转化为灰度图像，并展示。

    # 灰度图
    ref = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    cv_show('ref',ref)
     

    将灰度图像进行二值化处理，并展示。

    # 二值图像
    ref = cv2.threshold(ref, 10, 255, cv2.THRESH_BINARY_INV)[1]
    cv_show('ref',ref)
     

    2.7  计算轮廓

    计算模板图片的轮廓，并对其进行排序和提取数字，以便后面和输入图像匹配。

    1. # 计算轮廓
    2. ref_, refCnts, hierarchy = cv2.findContours(ref.copy(), cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)
    3.  
    4. cv2.drawContours(img,refCnts,-1,(0,0,255),3) 
    5. cv_show('img',img)
    6. print (np.array(refCnts).shape)
    7. refCnts = myutils.sort_contours(refCnts, method="left-to-right")[0] #排序，从左到右，从上到下
    8. digits = {}
    9.  
    10. # 遍历每一个轮廓
    11. for (i, c) in enumerate(refCnts):
    12. 	# 计算外接矩形并且resize成合适大小
    13. 	(x, y, w, h) = cv2.boundingRect(c)
    14. 	roi = ref[y:y + h, x:x + w]
    15. 	roi = cv2.resize(roi, (57, 88))
    16.  
    17. 	# 每一个数字对应每一个模板
    18. 	digits[i] = roi

    2.8  导入我们要识别的图像，并预处理

    初始化卷积核，后面操作会用到

    # 初始化卷积核
    rectKernel = cv2.getStructuringElement(cv2.MORPH_RECT, (9, 3))
    sqKernel = cv2.getStructuringElement(cv2.MORPH_RECT, (5, 5))
     

    读入输入图像并进行预处理，包括将图像大小调整为宽度为300像素、转化为灰度图像、应用礼帽操作和 Sobel 滤波器等操作

    1. #读取输入图像，预处理
    2. image = cv2.imread(args["image"])
    3. cv_show('image',image)
    4. image = myutils.resize(image, width=300)
    5. gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    6. cv_show('gray',gray)
    7.  
    8. #礼帽操作，突出更明亮的区域
    9. tophat = cv2.morphologyEx(gray, cv2.MORPH_TOPHAT, rectKernel) 
    10. cv_show('tophat',tophat) 
    11. # 
    12. gradX = cv2.Sobel(tophat, ddepth=cv2.CV_32F, dx=1, dy=0, #ksize=-1相当于用3*3的
    13. 	ksize=-1)
    14.  
    15.  
    16. gradX = np.absolute(gradX)
    17. (minVal, maxVal) = (np.min(gradX), np.max(gradX))
    18. gradX = (255 * ((gradX - minVal) / (maxVal - minVal)))
    19. gradX = gradX.astype("uint8")
    20.  
    21. print (np.array(gradX).shape)
    22. cv_show('gradX',gradX)

    通过闭操作将数字连在一起

    1. #通过闭操作（先膨胀，再腐蚀）将数字连在一起
    2. gradX = cv2.morphologyEx(gradX, cv2.MORPH_CLOSE, rectKernel) 
    3. cv_show('gradX',gradX)
    计算处理后的图像中的轮廓

    1. # 计算轮廓
    2. thresh_, threshCnts, hierarchy = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL,
    3. 	cv2.CHAIN_APPROX_SIMPLE)
    4.  
    5. cnts = threshCnts
    6. cur_img = image.copy()
    7. cv2.drawContours(cur_img,cnts,-1,(0,0,255),3) 
    8. cv_show('img',cur_img)
    9. locs = []

    对于每个轮廓，检测并保留包含四个数字的矩形

    1. # 遍历轮廓
    2. for (i, c) in enumerate(cnts):
    3. 	# 计算矩形
    4. 	(x, y, w, h) = cv2.boundingRect(c)
    5. 	ar = w / float(h)
    6.  
    7. 	# 选择合适的区域，根据实际任务来，这里的基本都是四个数字一组
    8. 	if ar > 2.5 and ar < 4.0:
    9.  
    10. 		if (w > 40 and w < 55) and (h > 10 and h < 20):
    11. 			#符合的留下来
    12. 			locs.append((x, y, w, h))

    将保留的矩形按照从左到右的顺序排列

    1. # 将符合的轮廓从左到右排序
    2. locs = sorted(locs, key=lambda x:x[0])
    3. output = []

    遍历每一个轮廓中的数字，对于每个轮廓中的数字，使用模板匹配的方法计算匹配得分，并选择得分最高的数字作为结果。然后将该数字显示在输入图像上，并将结果保存在output列表中。

    1. # 遍历每一个轮廓中的数字
    2. for (i, (gX, gY, gW, gH)) in enumerate(locs):
    3. 	# initialize the list of group digits
    4. 	groupOutput = []
    5.  
    6. 	# 根据坐标提取每一个组
    7. 	group = gray[gY - 5:gY + gH + 5, gX - 5:gX + gW + 5]
    8. 	cv_show('group',group)
    9. 	# 预处理
    10. 	group = cv2.threshold(group, 0, 255,
    11. 		cv2.THRESH_BINARY | cv2.THRESH_OTSU)[1]
    12. 	cv_show('group',group)
    13. 	# 计算每一组的轮廓
    14. 	group_,digitCnts,hierarchy = cv2.findContours(group.copy(), cv2.RETR_EXTERNAL,
    15. 		cv2.CHAIN_APPROX_SIMPLE)
    16. 	digitCnts = contours.sort_contours(digitCnts,
    17. 		method="left-to-right")[0]
    18.  
    19. 	# 计算每一组中的每一个数值
    20. 	for c in digitCnts:
    21. 		# 找到当前数值的轮廓，resize成合适的的大小
    22. 		(x, y, w, h) = cv2.boundingRect(c)
    23. 		roi = group[y:y + h, x:x + w]
    24. 		roi = cv2.resize(roi, (57, 88))
    25. 		cv_show('roi',roi)
    26.  
    27. 		# 计算匹配得分
    28. 		scores = []
    29.  
    30. 		# 在模板中计算每一个得分
    31. 		for (digit, digitROI) in digits.items():
    32.         # 计算匹配得分
    33. 		scores = []
    34.  
    35. 		# 在模板中计算每一个得分
    36. 		for (digit, digitROI) in digits.items():
    37. 			# 使用相似性度量（差异越小，得分越高）
    38. 			result = cv2.matchTemplate(roi, digitROI,
    39. 				cv2.TM_CCOEFF)
    40. 			(_, score, _, _) = cv2.minMaxLoc(result)
    41. 			scores.append(score)
    42.  
    43. 		# 得到最合适的数字
    44. 		groupOutput.append(str(np.argmax(scores)))
    45.  
    46. 	# 获得这一组的数值并显示在图像上
    47. 	cv2.rectangle(image, (gX - 5, gY - 5),
    48. 		(gX + gW + 5, gY + gH + 5), (0, 255, 0), 2)
    49. 	cv2.putText(image, "".join(groupOutput), (gX, gY - 15),
    50. 		cv2.FONT_HERSHEY_SIMPLEX, 0.65, (0, 255, 0), 2)
    51.  
    52. 	# 将这一组的数值连接起来
    53. 	output.extend(groupOutput)

    ，输出结果，包括信用卡类型和信用卡号码，并在输入图像上展示结果

    1. # 输出结果
    2. print("Credit Card Type: {}".format(FIRST_NUMBER[output[0]]))
    3. print("Credit Card #: {}".format("".join(output)))
    4. cv2.imshow("Image", image)
    5. cv2.waitKey(0)

    3，全部代码

    1. # 导入工具包
    2. from imutils import contours
    3. import numpy as np
    4. import argparse
    5. import cv2
    6. import myutils
    7.  
    8. # 设置参数
    9. ap = argparse.ArgumentParser()
    10. ap.add_argument("-i", "--image", required=True,
    11. 	help="path to input image")
    12. ap.add_argument("-t", "--template", required=True,
    13. 	help="path to template OCR-A image")
    14. args = vars(ap.parse_args())
    15.  
    16. # 指定信用卡类型
    17. FIRST_NUMBER = {
    18. 	"3": "American Express",
    19. 	"4": "Visa",
    20. 	"5": "MasterCard",
    21. 	"6": "Discover Card"
    22. }
    23. # 绘图展示
    24. def cv_show(name,img):
    25. 	cv2.imshow(name, img)
    26. 	cv2.waitKey(0)
    27. 	cv2.destroyAllWindows()
    28. # 读取一个模板图像
    29. img = cv2.imread(args["template"])
    30. cv_show('img',img)
    31. # 灰度图
    32. ref = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    33. cv_show('ref',ref)
    34. # 二值图像
    35. ref = cv2.threshold(ref, 10, 255, cv2.THRESH_BINARY_INV)[1]
    36. cv_show('ref',ref)
    37.  
    38. # 计算轮廓
    39. #cv2.findContours()函数接受的参数为二值图，即黑白的（不是灰度图）,cv2.RETR_EXTERNAL只检测外轮廓，cv2.CHAIN_APPROX_SIMPLE只保留终点坐标
    40. #返回的list中每个元素都是图像中的一个轮廓
    41.  
    42. # ref_, refCnts, hierarchy = cv2.findContours(ref.copy(), cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)
    43. ref_, refCnts, hierarchy = cv2.findContours(ref.copy(), cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)
    44.  
    45. cv2.drawContours(img,refCnts,-1,(0,0,255),3) 
    46. cv_show('img',img)
    47. print (np.array(refCnts).shape)
    48. refCnts = myutils.sort_contours(refCnts, method="left-to-right")[0] #排序，从左到右，从上到下
    49. digits = {}
    50.  
    51. # 遍历每一个轮廓
    52. for (i, c) in enumerate(refCnts):
    53. 	# 计算外接矩形并且resize成合适大小
    54. 	(x, y, w, h) = cv2.boundingRect(c)
    55. 	roi = ref[y:y + h, x:x + w]
    56. 	roi = cv2.resize(roi, (57, 88))
    57.  
    58. 	# 每一个数字对应每一个模板
    59. 	digits[i] = roi
    60.  
    61. # 初始化卷积核
    62. rectKernel = cv2.getStructuringElement(cv2.MORPH_RECT, (9, 3))
    63. sqKernel = cv2.getStructuringElement(cv2.MORPH_RECT, (5, 5))
    64.  
    65. #读取输入图像，预处理
    66. image = cv2.imread(args["image"])
    67. cv_show('image',image)
    68. image = myutils.resize(image, width=300)
    69. gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    70. cv_show('gray',gray)
    71.  
    72. #礼帽操作，突出更明亮的区域
    73. tophat = cv2.morphologyEx(gray, cv2.MORPH_TOPHAT, rectKernel) 
    74. cv_show('tophat',tophat) 
    75. # 
    76. gradX = cv2.Sobel(tophat, ddepth=cv2.CV_32F, dx=1, dy=0, #ksize=-1相当于用3*3的
    77. 	ksize=-1)
    78.  
    79.  
    80. gradX = np.absolute(gradX)
    81. (minVal, maxVal) = (np.min(gradX), np.max(gradX))
    82. gradX = (255 * ((gradX - minVal) / (maxVal - minVal)))
    83. gradX = gradX.astype("uint8")
    84.  
    85. print (np.array(gradX).shape)
    86. cv_show('gradX',gradX)
    87.  
    88. #通过闭操作（先膨胀，再腐蚀）将数字连在一起
    89. gradX = cv2.morphologyEx(gradX, cv2.MORPH_CLOSE, rectKernel) 
    90. cv_show('gradX',gradX)
    91. #THRESH_OTSU会自动寻找合适的阈值，适合双峰，需把阈值参数设置为0
    92. thresh = cv2.threshold(gradX, 0, 255,
    93. 	cv2.THRESH_BINARY | cv2.THRESH_OTSU)[1] 
    94. cv_show('thresh',thresh)
    95.  
    96. #再来一个闭操作
    97.  
    98. thresh = cv2.morphologyEx(thresh, cv2.MORPH_CLOSE, sqKernel) #再来一个闭操作
    99. cv_show('thresh',thresh)
    100.  
    101. # 计算轮廓
    102.  
    103. thresh_, threshCnts, hierarchy = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL,
    104. 	cv2.CHAIN_APPROX_SIMPLE)
    105.  
    106. cnts = threshCnts
    107. cur_img = image.copy()
    108. cv2.drawContours(cur_img,cnts,-1,(0,0,255),3) 
    109. cv_show('img',cur_img)
    110. locs = []
    111.  
    112. # 遍历轮廓
    113. for (i, c) in enumerate(cnts):
    114. 	# 计算矩形
    115. 	(x, y, w, h) = cv2.boundingRect(c)
    116. 	ar = w / float(h)
    117.  
    118. 	# 选择合适的区域，根据实际任务来，这里的基本都是四个数字一组
    119. 	if ar > 2.5 and ar < 4.0:
    120.  
    121. 		if (w > 40 and w < 55) and (h > 10 and h < 20):
    122. 			#符合的留下来
    123. 			locs.append((x, y, w, h))
    124.  
    125. # 将符合的轮廓从左到右排序
    126. locs = sorted(locs, key=lambda x:x[0])
    127. output = []
    128.  
    129. # 遍历每一个轮廓中的数字
    130. for (i, (gX, gY, gW, gH)) in enumerate(locs):
    131. 	# initialize the list of group digits
    132. 	groupOutput = []
    133.  
    134. 	# 根据坐标提取每一个组
    135. 	group = gray[gY - 5:gY + gH + 5, gX - 5:gX + gW + 5]
    136. 	cv_show('group',group)
    137. 	# 预处理
    138. 	group = cv2.threshold(group, 0, 255,
    139. 		cv2.THRESH_BINARY | cv2.THRESH_OTSU)[1]
    140. 	cv_show('group',group)
    141. 	# 计算每一组的轮廓
    142. 	group_,digitCnts,hierarchy = cv2.findContours(group.copy(), cv2.RETR_EXTERNAL,
    143. 		cv2.CHAIN_APPROX_SIMPLE)
    144. 	digitCnts = contours.sort_contours(digitCnts,
    145. 		method="left-to-right")[0]
    146.  
    147. 	# 计算每一组中的每一个数值
    148. 	for c in digitCnts:
    149. 		# 找到当前数值的轮廓，resize成合适的的大小
    150. 		(x, y, w, h) = cv2.boundingRect(c)
    151. 		roi = group[y:y + h, x:x + w]
    152. 		roi = cv2.resize(roi, (57, 88))
    153. 		cv_show('roi',roi)
    154.  
    155. 		# 计算匹配得分
    156. 		scores = []
    157.  
    158. 		# 在模板中计算每一个得分
    159. 		for (digit, digitROI) in digits.items():
    160. 			# 模板匹配
    161. 			result = cv2.matchTemplate(roi, digitROI,
    162. 				cv2.TM_CCOEFF)
    163. 			(_, score, _, _) = cv2.minMaxLoc(result)
    164. 			scores.append(score)
    165.  
    166. 		# 得到最合适的数字
    167. 		groupOutput.append(str(np.argmax(scores)))
    168.  
    169. 	# 画出来
    170. 	cv2.rectangle(image, (gX - 5, gY - 5),
    171. 		(gX + gW + 5, gY + gH + 5), (0, 0, 255), 1)
    172. 	cv2.putText(image, "".join(groupOutput), (gX, gY - 15),
    173. 		cv2.FONT_HERSHEY_SIMPLEX, 0.65, (0, 0, 255), 2)
    174.  
    175. 	# 得到结果
    176. 	output.extend(groupOutput)
    177.  
    178. # 打印结果
    179. print("Credit Card Type: {}".format(FIRST_NUMBER[output[0]]))
    180. print("Credit Card #: {}".format("".join(output)))
    181. cv2.imshow("Image", image)
    182. cv2.waitKey(0)

  • 相关阅读:
    Mysql索引+事务+存储引擎
    CVPR2022 | MPViT: Multi-Path Vision Transformer for Dense Prediction
    传统Android 开发与 Android 音视频开发的差距……
    ES6展开运算符“...”
    【Gan教程 】 什么是变分自动编码器VAE？
    2022-08-09 mysql/stonedb-慢SQL-Q16分析
    使用IDEA创建一个SpringBoot项目
    ELK日志系统
    一些有趣的迹象：“前端已死”难道要成真了？
    OpenCV 4.0.0学习笔记 (一) 图像与视频的读写
  • 原文地址：https://blog.csdn.net/qq_53545309/article/details/133890675