opencv(56) 案例：银行卡号识别

1 项目需求

已知银行卡卡号的数字模板ocr_a_reference.png，如下图

 和一张银行卡样图credit_card_01.png，如下图：

要求自动识别银行卡图片credit_card_01.png上的银行卡号码。

2 项目所需要的工具包介绍

2.1 python imutils包介绍

python imutils包可以很简洁的调用opencv接口，轻松实现图像的平移，旋转，缩放，骨架化等操作。

可以使用下列命令安装imutils包

(base) xxx@xxx-virtual-machine:~$ pip install imutils

2.2 pytesseract（文字OCR识别第三方库）

Tesseract是一个 由HP实验室开发 由Google维护的开源的光学字符识别（OCR）引擎，可以在 Apache 2.0 许可下获得。它可以直接使用，或者（对于程序员）使用 API​​ 从图像中提取输入，包括手写的或打印的文本。

与Microsoft Office Document Imaging（MODI）相比，我们可以不断的训练的库，使图像转换文本的能力不断增强；

训练的大致流程：安装jTessBoxEditor -> 获取样本文件 -> Merge样本文件 –> 生成BOX文件 -> 定义字符配置文件 -> 字符矫正 -> 执行批处理文件 -> 将生成的 traineddata 放 入tessdata 中。

如果团队深度需要，还可以以它为模板，开发出符合自身需求的OCR引擎。

安装  tesseract-ocr 包

(base) yundo@yundo-virtual-machine:~$ sudo apt-get install tesseract-ocr

安装 PIL PIL(python imaging library)是python中的图像处理库

(base) yundo@yundo-virtual-machine:~$ pip install pillow

安装 pytesseract

(base) yundo@yundo-virtual-machine:~$ pip install pytesseract

添加中文字库

要想识别的中文需要添加中文字库，需要在ubuntu  系统中 找到 tessdata  文件夹把中文字库放进去。也可以在线安装中文字库

(base) yundo@yundo-virtual-machine:~$ sudo apt-get install tesseract-ocr-chi-sim

代码测试

在~下新建image-ocr目录，在目录中放入图片english.png，如下：

在目录中放入图片chinese.png

在VScode中打开该目录，新建test-ocr.py，代码如下：

from PIL import Image
import pytesseract

# 识别中文
text = pytesseract.image_to_string(Image.open('chinese.png'),lang='chi_sim')
print(text)

# 识别英文
text = pytesseract.image_to_string(Image.open('english.png'))
print(text)

 运行结果如下：

OPEN CV 中文识别

Open Cv OCR

 至此，文字OCR识别安装成功。

3 思路

1. 识别模板图上面的10个数字的轮廓，并将识别结果按顺序排列。即数字0轮廓的索引为0，数字1轮廓的索引为1，依次类推，形成一个数字轮廓列表。
2. 将银行卡上的号码数字分为四个一组，在识别银行卡上的所有轮廓，剔除非银行卡号的轮廓，对每一组数字进行提取，与模板轮廓列表进行匹配，选取最大值（最接近模板）的索引，即为识别的数字。

4 详细代码如下

# 1 导入工具包
from imutils import contours
import numpy as np
import cv2

# 2 定义公共函数
# 2.1 定义绘图绘图展示函数
def cv_show(name,img):
    cv2.imshow(name, img)
    cv2.waitKey(0)
    cv2.destroyAllWindows()
    
# 2.2 改变图像大小函数
def resize(image, width=None, height=None, inter=cv2.INTER_AREA):
    dim = None
    (h, w) = image.shape[:2]
    if width is None and height is None:
        return image
    if width is None:
        r = height / float(h)
        dim = (int(w * r), height)
    else:
        r = width / float(w)
        dim = (width, int(h * r))
    resized = cv2.resize(image, dim, interpolation=inter)
    return resized

# 3 对模板数字进行处理，得到每个模板的数字。

# 3.1 定义对模板中的每个数字的边缘加上外接矩形并排序的函数
def sort_contours(cnts, method="left-to-right"):
    '''
    参数：cnts 模板图像中的图像轮廓
        method 方法：
    '''
    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

    # 用一个最小的矩形，把找到的形状包起来x,y,h,w
    boundingBoxes = [cv2.boundingRect(c) for c in cnts]
    # 将cnts、最小矩形，打包成一一对应的元组列表，如：
    #  [(cnt0,boundingBox0),(cnt1,boundingBox1),...]
    zipturple =  zip(cnts, boundingBoxes)
    # 对元组列表进行排序,reverse=True,降序，False（默认）升序
    zipturple = sorted(zipturple, key=lambda b: b[1][i], reverse=reverse)
    # 对排序后的元组再打包，形成列表，如下：
    #  [(cnt0,cnt1,...),(boundingBox0,boundingBox1,..)]
    (cnts, boundingBoxes) = zip(*zipturple)
    return cnts, boundingBoxes

# 3.2 读取模板图像并处理图像
# 模板图
img = cv2.imread('ocr_a_reference.png')
cv_show('img',img)

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

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

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

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)

# 显示模板中的轮廓数量
print(f'模板图中有的轮廓数 = {len(refCnts)}')
#print (np.array(refCnts).shape)

# 对模板中的轮廓进行排序 从左到右，从上到下
refCnts = sort_contours(refCnts, method="left-to-right")[0]

# 3.4 每一个数字对应一个模板
digits = {}
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

# 4 对银行卡上的数字进行选取

# 4.1 定义信用卡类型
FIRST_NUMBER = {
    "3": "American Express",
    "4": "Visa",
    "5": "MasterCard",
    "6": "Discover Card"
}

# 4.2 初始化卷积核
rectKernel = cv2.getStructuringElement(cv2.MORPH_RECT, (9, 3))
sqKernel = cv2.getStructuringElement(cv2.MORPH_RECT, (5, 5))
 
# 4.3 读取输入图像，预处理
# 读取信用卡图片
# image = cv2.imread(args["image"]) #使用参数传递文件名失败？原因未找到
image = cv2.imread('images/credit_card_01.png')
cv_show('Card_image',image)

# 改变图像大小
image = resize(image, width=300)

# 灰度图
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
cv_show('Card_gray',gray)

# 礼帽操作=原图-开运算，突出更明亮的区域
tophat = cv2.morphologyEx(gray, cv2.MORPH_TOPHAT, rectKernel)
cv_show('Card_tophat',tophat)

# 使用sobel算子进行边缘检测，这里仅适用x方向的梯度。
# 因为经过实验，适用x,y混合的梯度，效果并不理想
gradX = cv2.Sobel(tophat, ddepth=cv2.CV_32F, dx=1, dy=0, ksize=-1)

# 求梯度的绝对值
gradX = np.absolute(gradX)

# 求梯度的最小、最大值
(minVal, maxVal) = (np.min(gradX), np.max(gradX))

# 梯度变换处理
gradX = (255 * ((gradX - minVal) / (maxVal - minVal)))

# 将梯度变成转换为8位图进行显示
gradX = gradX.astype("uint8")
print (f'Card gradX shape= {np.array(gradX).shape}')
cv_show('Card gradX',gradX)
 
#通过闭运算（先膨胀，再腐蚀）将银行卡的gradX梯度图上的数字连在一起
gradX = cv2.morphologyEx(gradX, cv2.MORPH_CLOSE, rectKernel)
cv_show('gradX',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)
 
# 计算二值化图的轮廓
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)

# 4.3 对非卡号数字进行剔除
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])

# 4.4 将卡号进行数字划分，进行模板匹配，得到每个数字图像所对应的数字，
output = []

# 对每4个数字块进行处理
for (i, (gX, gY, gW, gH)) in enumerate(locs):
    # initialize the list of group digits
    groupOutput = []
    # 根据坐标提取每一个组（4个数字为一组）在灰度图上的相应位置的图像
    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)
    # 计算每一组的轮廓
    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 = []
        # 与模板中的10个形状进行匹配，并逐一计算匹配情况
        for (digit, digitROI) in digits.items():
            # 模板匹配
            result = cv2.matchTemplate(roi, digitROI,
                cv2.TM_CCOEFF)
            # score 为当前匹配的最大值
            (_, score, _, _) = cv2.minMaxLoc(result)
            # 最终scores内保存每一个数值对模板中10个形状的匹配分值
            scores.append(score)
            print(score)   
        # 得到匹配图形的索引值，
        # 因为模板中的0123456789图形轮廓的索引值是0,1,2,3,4,5,6,7,8,9
        print(np.argmax(scores))
        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)
 
# 打印结果
print("Credit Card Type: {}".format(FIRST_NUMBER[output[0]]))
print("Credit Card #: {}".format("".join(output)))
cv2.imshow("Image", image)
cv2.waitKey(0)