计算机视觉实战(九）信用卡数字识别项目(附完整代码)

我的微信公众号名称：AI研究订阅号
微信公众号ID：MultiAgent1024
公众号介绍：主要研究强化学习、计算机视觉、深度学习、机器学习等相关内容，分享学习过程中的学习笔记和心得！期待您的关注，欢迎一起学习交流进步！

  上一节计算机视觉实战(八）直方图与傅里叶变换的完整代码，回复关键字：直方图与傅里叶变换。上一节文末忘记说了。

项目概述

  我们要做的事情就是识别如下信用卡中的数字：

  大致方法流程：

1. 使用模板匹配方式对模板，以及输入图像进行轮廓检测（检测外轮廓）。
2. 得到当前轮廓的外接矩形。
3. 将模板中的外接矩形切割出来。
4. 使用矩形的长宽比之间的差异使得信用卡的数字矩形框能够被选择出来。
5. 将其进一步细分，与需要识别的信用卡当中的外接矩形resize成同样的大小。
6. 使用for循环依次检测。

代码解释：

  导入相关的工具包

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

  设置参数

ap = argparse.ArgumentParser()
ap.add_argument("-i", "--image", required=True,
   help="path to input image")
ap.add_argument("-t", "--template", required=True,
   help="path to template OCR-A image")
args = vars(ap.parse_args())

  指定信用卡类型

FIRST_NUMBER = {
   "3": "American Express",
   "4": "Visa",
   "5": "MasterCard",
   "6": "Discover Card"
}

  设置一下绘图函数，绘图展示

def cv_show(name,img):
   cv2.imshow(name, img)
   cv2.waitKey(0)
   cv2.destroyAllWindows()

  读取一个模板图像，因为这里没有调用分类算法，直接用的模板。如果背景比较复杂的话，可以调用一下分类的算法对目标进行识别。我们先读取一下，之后对其进行显示。

img = cv2.imread(args["template"]) 
cv_show('img',img)

  将其转化为灰度图，方便之后操作。调用cv2.cvtColor函数，设置cv2.COLOR_BGR2GRAY参数即可。显示出来结果如下图所示：

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)

  因为做轮廓检测的时候输入进来的一般都是二值图像，都是为了方便轮廓检测。所以这做二值处理。

  因为我们不仅需要轮廓的图像，还需要知道这个轮廓图像对应的标签是啥，所以我们需要计算轮廓，依据每个轮廓所在位置的不同将其进行划分。这里我们使用OpenCv中的cv2.findContours()函数来进行轮廓检测。函数用法

  cv2.findContours()函数接受的参数为二值图，即黑白的（不是灰度图）,cv2.RETR_EXTERNAL只检测外轮廓,cv2.CHAIN_APPROX_SIMPLE只保留终点坐标，返回的list中每个元素都是图像中的一个轮廓。

ref_, refCnts, hierarchy = cv2.findContours(ref.copy(), cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)

  依据检测出来的轮廓信息，我们就能将其轮廓画出来，并对其进行显示：

cv2.drawContours(img,refCnts,-1,(0,0,255),3) 
cv_show('img',img)

  将其从左到右排列，从左到右，从上到下，一句坐标信息就能知道其标签信息。

refCnts = myutils.sort_contours(refCnts, method="left-to-right")[0] 
digits = {}

def sort_contours(cnts, method="left-to-right"):
    reverse = False
    i = 0
    if method == "right-to-left" or method == "bottom-to-top":
        reverse = True
    if method == "top-to-bottom" or method == "bottom-to-top":
        i = 1
    boundingBoxes = [cv2.boundingRect(c) for c in cnts] #用一个最小的矩形，把找到的形状包起来x,y,h,w
    (cnts, boundingBoxes) = zip(*sorted(zip(cnts, boundingBoxes),
                                        key=lambda b: b[1][i], reverse=reverse))
    return cnts, boundingBoxes

  遍历每一个轮廓

for (i, c) in enumerate(refCnts):
   # 计算外接矩形并且resize成合适大小
   (x, y, w, h) = cv2.boundingRect(c)
   roi = ref[y:y + h, x:x + w]
   roi = cv2.resize(roi, (57, 88))
   # 每一个数字对应每一个模板
   digits[i] = roi

  到这里模板就已经算完了。接下来需要对信用卡图像进行处理。

  初始化卷积核：在形态学的操作过程当中，我们需要定义一些核，这个都是依据我们的实际任务而决定的。

rectKernel = cv2.getStructuringElement(cv2.MORPH_RECT, (9, 3))
sqKernel = cv2.getStructuringElement(cv2.MORPH_RECT, (5, 5))

  我们先读取数据,显示如下：

image = cv2.imread(args["image"])
cv_show('image',image)

  预处理一下，其结果显示如下所示：

image = myutils.resize(image, width=300)
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
cv_show('gray',gray)

  礼帽操作，突出更明亮的区域

tophat = cv2.morphologyEx(gray, cv2.MORPH_TOPHAT, rectKernel) 
cv_show('tophat',tophat)

gradX = cv2.Sobel(tophat, ddepth=cv2.CV_32F, dx=1, dy=0, #ksize=-1相当于用3*3的
   ksize=-1)

gradX = np.absolute(gradX)
(minVal, maxVal) = (np.min(gradX), np.max(gradX))
gradX = (255 * ((gradX - minVal) / (maxVal - minVal)))
gradX = gradX.astype("uint8")

print (np.array(gradX).shape)
cv_show('gradX',gradX)

  通过闭操作（先膨胀，再腐蚀）将数字连在一起

gradX = cv2.morphologyEx(gradX, cv2.MORPH_CLOSE, rectKernel) 
cv_show('gradX',gradX)

  参数THRESH_OTSU会自动寻找合适的阈值，适合双峰，需把阈值参数设置为0。

thresh = cv2.threshold(gradX, 0, 255,
   cv2.THRESH_BINARY | cv2.THRESH_OTSU)[1] 
cv_show('thresh',thresh)

  再来一个闭操作

thresh = cv2.morphologyEx(thresh, cv2.MORPH_CLOSE, sqKernel) #再来一个闭操作
cv_show('thresh',thresh)

  计算需要识别的目标图像轮廓

thresh_, threshCnts, hierarchy = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL,
   cv2.CHAIN_APPROX_SIMPLE)
cnts = threshCnts
cur_img = image.copy()
cv2.drawContours(cur_img,cnts,-1,(0,0,255),3) 
cv_show('img',cur_img)

  将轮廓依次检测出来，并排序。

locs = []
# 遍历轮廓
for (i, c) in enumerate(cnts):
   # 计算矩形
   (x, y, w, h) = cv2.boundingRect(c)
   ar = w / float(h)
   # 选择合适的区域，根据实际任务来，这里的基本都是四个数字一组
   if ar > 2.5 and ar < 4.0:
      if (w > 40 and w < 55) and (h > 10 and h < 20):
         #符合的留下来
         locs.append((x, y, w, h))
# 将符合的轮廓从左到右排序
locs = sorted(locs, key=lambda x:x[0])

  之后我们需要对目标图像的区域依次循环匹配，得到匹配分数最大的那一个。

output = []

# 遍历每一个轮廓中的数字
for (i, (gX, gY, gW, gH)) in enumerate(locs):
   # initialize the list of group digits
   groupOutput = []

   # 根据坐标提取每一个组
   group = gray[gY - 5:gY + gH + 5, gX - 5:gX + gW + 5]
   cv_show('group',group)
   # 预处理
   group = cv2.threshold(group, 0, 255,
      cv2.THRESH_BINARY | cv2.THRESH_OTSU)[1]
   cv_show('group',group)
   # 计算每一组的轮廓
   group_,digitCnts,hierarchy = cv2.findContours(group.copy(), cv2.RETR_EXTERNAL,
      cv2.CHAIN_APPROX_SIMPLE)
   digitCnts = contours.sort_contours(digitCnts,
      method="left-to-right")[0]

   # 计算每一组中的每一个数值
   for c in digitCnts:
      # 找到当前数值的轮廓，resize成合适的的大小
      (x, y, w, h) = cv2.boundingRect(c)
      roi = group[y:y + h, x:x + w]
      roi = cv2.resize(roi, (57, 88))
      cv_show('roi',roi)

      # 计算匹配得分
      scores = []

      # 在模板中计算每一个得分
      for (digit, digitROI) in digits.items():
         # 模板匹配
         result = cv2.matchTemplate(roi, digitROI,
            cv2.TM_CCOEFF)
         (_, score, _, _) = cv2.minMaxLoc(result)
         scores.append(score)

      # 得到最合适的数字
      groupOutput.append(str(np.argmax(scores)))

   # 画出来
   cv2.rectangle(image, (gX - 5, gY - 5),
      (gX + gW + 5, gY + gH + 5), (0, 0, 255), 1)
   cv2.putText(image, "".join(groupOutput), (gX, gY - 15),
      cv2.FONT_HERSHEY_SIMPLEX, 0.65, (0, 0, 255), 2)

   # 得到结果
   output.extend(groupOutput)

  完整代码后台回复：信用卡数字识别 。