本文用于对之前openCV知识点学习的复习及实践。要求达到以下效果：

一、基本流程思路分析

本项目本质上就是进行模板匹配。

注：为多用到所学知识，为了加深理解多加了些步骤，实际上本项目可以很简单就能完成。

1.1 模板处理 

模板：

1. 转换成灰度图，二值化处理，用于轮廓检测。 
2. 我们将模板中的十个数字通过轮廓检测(外轮廓)，能够获得每个数字拐点处的坐标。
3. 将这些返回值对其使用外接矩形，我们能得到每个数字的外接矩形的(x,y,h,w)，上图是从左到右从小到大排列的，我们只需根据x的大小进行正向排序即可。
4. 循环遍历通过切片切出外接矩形，保存到字典中，对应0-9。

实际上：第二步我们可以直接将返回值倒序，得到对应0-9的正向拐点坐标列表，对其直接外接矩形切片即可。

1.2 银行卡处理

银行卡中呢有很多的干扰项，或者说是没用的地方，因为我们需要的只是中间的那一块数字。我们不直接选中的话，思路如下：

1. 将其转换为灰度图。
2. 礼帽操作(原始图像-开运算后的图像)，目的是突出更明亮的地方，不明白没关系最后会有总结。
3. 梯度处理，归一化。礼帽操作本次实验中去掉了背景部分，方便梯度处理对其进行差异描绘，更干净些。
4. 对梯度处理后的图像进行闭操作，此时如上图4000、1234、5678、9010这四块都连在一起是一个整体了。
5. 进行二值处理，用于后面轮廓检测，把那四块数字的轮廓检测出来。
6. 进行闭操作，原理同4。
7. 轮廓检测，我们所需要的这四段数字它们的外接矩形的长宽或者比例是与途中其它元素不同的，我们通过这一特征在轮廓检测返回的队列中筛选出需要的部分，保存下来。
8. 同样，根据x坐标的位置进行排序。
9. 有了这4段外接矩形的坐标，我们可以在原图片上把它们抠出来(切片)。
10. 对每一组进行轮廓检测、排序(倒序)，得到单个数字的轮廓，继续对其外接矩形切片。
11. 得到的每个数字的外接矩形矩阵，与模板中每个数字进行匹配，得分最高对应正确数字。

注：上述过程有很大优化的空间，这样做是为了加深理解，具体可看代码部分。

二、主要知识点罗列

图片读取、转换为灰度图、滤波操作等

略 

二值处理

ret, dst = cv2.threshold(src, thresh, maxval, type)

ret, dst： 返回阈值、输出图。

src： 输入图，只能输入单通道图像，通常来说为灰度图。

thresh： 阈值。

maxval： 当像素值超过了阈值（或者小于阈值，根据type来决定），所赋予的值。

type：二值化操作的类型，包含以下5种类型： 

cv2.THRESH_BINARY 超过阈值部分取maxval（最大值），否则取0

cv2.THRESH_BINARY_INV , THRESH_BINARY的反转

cv2.THRESH_TRUNC 大于阈值部分设为阈值，否则不变

cv2.THRESH_TOZERO 大于阈值部分不改变，否则设为0

cv2.THRESH_TOZERO_INV THRESH_TOZERO的反转

计算轮廓

cv2.findContours(img,mode,method) 

RETR_EXTERNAL ：只检索最外面的轮廓；( 本次使用)

RETR_LIST：检索所有的轮廓，并将其保存到一条链表当中；

RETR_CCOMP：检索所有的轮廓，并将他们组织为两层：顶层是各部分的外部边界，第二层是空洞的边界;

RETR_TREE：检索所有的轮廓，并重构嵌套轮廓的整个层次;(常用，推荐)

method:轮廓逼近方法

CHAIN_APPROX_NONE：以Freeman链码的方式输出轮廓，所有其他方法输出多边形（顶点的序列）。

CHAIN_APPROX_SIMPLE:压缩水平的、垂直的和斜的部分，也就是，函数只保留他们的终点部分。

绘制轮廓

cv2.drawContours(draw_img, refCnts, -1, (0, 0, 255), 2)

draw_img：要绘制的图片，会在该图片上直接进行修改。

refCnts: 轮廓

其它：-1指全部轮廓，0为最后一个轮廓，(0，0，255)颜色，2粗细。

排序

refCnts = contours.sort_contours(refCnts, method="left-to-right")[0]

返回排序后的轮廓。

礼帽操作

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

原图-开运算，本次实验用它获得我们想要保留的部分。

开运算：先腐蚀后膨胀。

闭运算

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

先膨胀后腐蚀，本次实验目的是将每组数“模糊处理”使其连在一起。

模板匹配

res = cv2.matchTemplate(img, template, cv2.TM_SQDIFF)

模板匹配和卷积原理很像，假如原图形是AxB大小，而模板是axb大小，则输出结果的矩阵是(A-a+1)x(B-b+1)。

TM_SQDIFF：计算平方不同，计算出来的值越小，越相关

TM_CCORR：计算相关性，计算出来的值越大，越相关

TM_CCOEFF：计算相关系数，计算出来的值越大，越相关

TM_SQDIFF_NORMED：计算归一化平方不同，计算出来的值越接近0，越相关

TM_CCORR_NORMED：计算归一化相关性，计算出来的值越接近1，越相关

TM_CCOEFF_NORMED：计算归一化相关系数，计算出来的值越接近1，越相关

min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(res)

 最小值最大值及其坐标位置，具体看模板匹配使用的方法是什么。

更多初级知识点：

openCV第三篇_老师我作业忘带了的博客-CSDN博客

三、代码部分

3.1 代码讲解 

3.1.1 处理模板 

导包

import cv2
import numpy as np
from imutils import contours # 排序操作，也可以不用。

定义绘图展示函数

def cv_show(name, img):
    cv2.imshow(name, img)
    cv2.waitKey(0) # 按键结束
    cv2.destroyAllWindows()

模板读取、灰度、二值化 

# 读取模板图像
img = cv2.imread('ocr_a_reference.png')

# 转换为灰度图 也可读取时直接转换
ref = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

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

轮廓检测、排序

# 轮廓检测
refCnts, hierarchy = cv2.findContours(ref, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
'''
draw_img = img.copy()
cv2.drawContours(draw_img, refCnts, -1, (0, 0, 255), 2) # 第0个轮廓是9 第1个轮廓是8......
cv_show('draw_img',draw_img)
'''

# 排序(倒序操作) 得到正序0-9的轮廓
refCnts = sorted(refCnts,key=lambda b: b[0][0][0], reverse=False)

遍历对这10个轮廓，做外接矩形，对外接矩形区域在二值化图ref上做切片，即把他们一个个抠出来，保存在 digits 字典中。

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))

    # 每一个数字对应每一个模板，此时模板中的10个数字分别被保存到了字典中
    digits[i] = roi

3.1.2 处理银行卡

初始化卷积核，读取输入图像。

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

# 读入银行卡
image = cv2.imread('./images/credit_card_01.png')

统一大小，这里建议让它变小一点，处理像素少一点，后面闭运算让其模糊也方便一些。

set_width = 300 # 自己设定 这里我统一了宽度
rate = set_width/image.shape[:2][1]
image = cv2.resize(image,(0,0),fx=rate,fy=rate)

转为灰度图

# 同样也可以在第一步完成
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

礼帽，突出更明亮的区域，可以看到此时银行卡后面的花纹基本已经消失了。 。

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

梯度运算，这里使用Sobel算子，只进行了x方向计算。前面的礼帽操作是的我们梯度运算结果更干净些。

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

gradX = np.absolute(gradX) # 绝对值，白-黑 黑-白
# 或者写为 cv2.convertScaleAbs(sobelx)

# 归一化处理
(minVal, maxVal) = (np.min(gradX), np.max(gradX))
# gradX与最小值之间的距离占区间长度的几分之几
gradX = (255 * ((gradX - minVal) / (maxVal - minVal)))  
gradX = gradX.astype("uint8")

闭运算、二值化、闭运算

# 闭运算 把银行卡卡号那里弄模糊
gradX = cv2.morphologyEx(gradX, cv2.MORPH_CLOSE, rectKernel)

# 二值化，用于之后轮廓检测。
thresh = cv2.threshold(gradX, 0, 255,
                       cv2.THRESH_BINARY | cv2.THRESH_OTSU)[1]

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

轮廓检测

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

遍历所有轮廓，得到想要的四组数字，并排序。

locs = []

# 遍历轮廓
for (i, c) in enumerate(threshCnts):
    # 计算矩形
    (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))


# 将符合的这四组轮廓按x从左到右排序
locs = sorted(locs, key=lambda x: x[0])

遍历这四组数

output = []

# 遍历每一个轮廓中的数字
for (i, (gX, gY, gW, gH)) in enumerate(locs):
    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)
    
    # 就是个排序 真正的顺序我们都知道，可以自己用sort函数
    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 = []

        # 在模板中计算每一个得分  字典digits记录了模板0-9
        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)

输出结果

print("Credit Card #: {}".format("".join(output)))
# cv_show("Image", image)

Credit Card #: 4000123456789010

3.2 完整代码  直接copy

我去掉了图片展示，直接输出文本结果。 

import cv2
import numpy as np
from imutils import contours  # 排序操作，也可以不用。


# 绘图展示
def cv_show(name, img):
    cv2.imshow(name, img)
    cv2.waitKey(0)
    cv2.destroyAllWindows()


# 读取一个模板图像
img = cv2.imread('ocr_a_reference.png', )
# 灰度图
ref = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
# 二值图像
ref = cv2.threshold(ref, 10, 255, cv2.THRESH_BINARY_INV)[1]

# 轮廓检测
refCnts, hierarchy = cv2.findContours(ref, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
# 排序(倒序操作) 得到正序0-9的轮廓
refCnts = sorted(refCnts, key=lambda b: b[0][0][0], reverse=False)

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))
    # 每一个数字对应每一个模板，此时模板中的10个数字分别被保存到了字典中
    digits[i] = roi

# 初始化卷积核
rectKernel = cv2.getStructuringElement(cv2.MORPH_RECT, (9, 3))
sqKernel = cv2.getStructuringElement(cv2.MORPH_RECT, (5, 5))
# 读入银行卡
image = cv2.imread('./images/credit_card_01.png')

# 统一大小，这里建议让它变小一点，处理像素少一点，后面闭运算让其模糊也方便一些。
set_width = 300  # 自己设定 这里我统一了宽度
rate = set_width / image.shape[:2][1]
image = cv2.resize(image, (0, 0), fx=rate, fy=rate)

# 转为灰度图
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# 礼帽，突出更明亮的区域
tophat = cv2.morphologyEx(gray, cv2.MORPH_TOPHAT, rectKernel)

# 梯度运算，这里使用Sobel算子，只进行了x方向计算。前面的礼帽操作是的我们梯度运算结果更干净些。
# ksize=-1相当于用3*3的
gradX = cv2.Sobel(tophat, ddepth=cv2.CV_32F, dx=1, dy=0, ksize=-1)

gradX = np.absolute(gradX)  # 绝对值，白-黑 黑-白
# 或者写为 cv2.convertScaleAbs(sobelx)

# 归一化处理
(minVal, maxVal) = (np.min(gradX), np.max(gradX))
# gradX与最小值之间的距离占区间长度的几分之几
gradX = (255 * ((gradX - minVal) / (maxVal - minVal)))
gradX = gradX.astype("uint8")

# 闭运算 把银行卡卡号那里弄模糊
gradX = cv2.morphologyEx(gradX, cv2.MORPH_CLOSE, rectKernel)
# 二值化，用于之后轮廓检测。
thresh = cv2.threshold(gradX, 0, 255,
                       cv2.THRESH_BINARY | cv2.THRESH_OTSU)[1]
# 再来一个闭操作
thresh = cv2.morphologyEx(thresh, cv2.MORPH_CLOSE, sqKernel)

# 轮廓检测
threshCnts, hierarchy = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL,
                                         cv2.CHAIN_APPROX_SIMPLE)

locs = []
# 遍历轮廓
for (i, c) in enumerate(threshCnts):
    # 计算矩形
    (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))

# 将符合的这四组轮廓按x从左到右排序
locs = sorted(locs, key=lambda x: x[0])

# 遍历这四组数
output = []

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

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

    # 就是个排序 真正的顺序我们都知道，可以自己用sort函数
    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))

        # 计算匹配得分
        scores = []

        # 在模板中计算每一个得分  字典digits记录了模板0-9
        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)
    
print("Credit Card #: {}".format("".join(output)))