在这里插入图片描述
@toc

1.项目意义

在日常生活中，常常需要输入自己的银行卡号。银行为保证卡号的唯一性和账号的安全性，会将卡号设计偏长，对于视力不好的人群以及老人不是很友好。传统银行卡服务时的人工识别银行卡号码太过费时费力。所以银行卡号的自动识别变得越来越重要。银行卡卡号的自动识别对实现银行卡的有效管理和进行银行卡的相关服务具有重要的理论意义和实际应用价值。本项目设计了一个银行卡卡号自动识别程序，传入银行卡照片即可获取银行卡号，为生活提供了遍历。。程序效果如下：

2.模板匹配

本项目中主要使用的方法为模板匹配，在opencv中也提供了API，为cv2.matchTemplate函数，现在我们一起来看一下这个函数的用法。
cv2.matchTemplate(img,img_Temp,method)

  • img:传入的需要匹配的图片

  • img_Temp:匹配的模板

  • method：模板匹配的算法，主要有：

    • 平方差匹配（cv.TM_SQDIFF）：利用模板与图像之间的平方差进行匹配，最好的匹配是0，匹配越差，匹配的值越大。
    • 相关匹配(cv.TM_CCORR):利用模板与图像间的乘法进行匹配，数值越大表示匹配程度较高，越小表示匹配效果差。
    • 利用相关系数匹配(cv.TM_CCOEFF):利用模板与图像间的相关系数匹配，1表示完美的匹配，-1表示最差的匹配。
    • cv.TM_SQDIFF_NORMED
    • cv.TM_CCORR_NORMED
    • cv.TM_CCOEFF_NORMED

在这里详细介绍一下我这个项目所使用的cv.TM_SQDIFF算法，这也是在模板匹配中最常用的算法，算法的公式为：
$$ \sum_{x, y}[\operatorname{Img}(x, y)-\text { imgTemp }(x, y)]^2$$
这与我们在机器学习中所提到的最小二乘法非常相似，都是先求对应位置的差，再平方变成正数，最后求和。从这个算法我们不能发现模板匹配也有一定的局限性：只能对特定的图片进行模板匹配，如果匹配目标发生旋转或大小变化那么算法失效！

本次项目所用的模板如下：

[Alt]

3.图像二值化

二值化是图像分割的一种最简单的方法。二值化可以把灰度图像转换成二值图像。把大于某个临界灰度值(阈值)的像素灰度设为灰度极大值(255)，把小于这个值的像素灰度设为灰度极小值（0），从而实现二值化，简单来说：设定一个阈值valve，对于视频信号矩阵中的每一行，从左至右比较各像素值和阈值的大小，若图像灰度值大于或等于阈值，则判定该像素对应的255；反之，小于阈值的灰度值则为0。就是将图像上的像素点的灰度值设置为0或255，也就是将整个图像呈现出明显的黑白效果。

作用：去除干扰信息，方便后期的处理

图像的二值化分为全局阈值以及自适应阈值，下面我们分别来进行讲解。

3.1全局阈值

全局阈值即规定一个数字，将大于这个数字的像素全部变为指定的一个数，小于这个值的变为另一个数。我们首先看API函数，然后以具体以的例子来做讲解。对应全局阈值，opencv提供的API为：
cv2.threshold(src,thresh,maxVal,tpye)

  • src：输入的图片对象

  • thresh：阈值

  • maxVal：归成的最大值，归成的最小值为0，也就是黑色

  • tpye：cv2.THRESH_BINARY和cv2.THRESH_BINARY_INV

    • cv2.THRESH_BINARY:
      在这里插入图片描述
    • cv2.THRESH_BINARY_INV
      在这里插入图片描述

3.2全局阈值代码即效果展示

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
"""
@Project ：OpenCV识别银行卡数字 
@File    ：test.py
@IDE     ：PyCharm 
@Author  ：咋
@Date    ：2023/1/14 17:17 
"""
import cv2
import numpy as np
# 读取图片
image = cv2.imread("Handsome.jpg")
# 转化为灰度图
image = cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)
# 调整图片大小
image = cv2.resize(image,(640,480))
# 全局阈值处理
thresh,threshold_img = cv2.threshold(image,120,255,cv2.THRESH_BINARY)
# 展示图片
cv2.imshow("image",np.hstack((image,threshold_img)))
# cv2.imshow("image",image)
cv2.waitKey(0)
# 销毁窗口
cv2.destroyAllWindows()

在这里插入图片描述

3.3 自适应阈值

自适应阈值是根据周围的像素来确定当前的像素，同样我们结合AIP来讲解其中的原理。在opencv中为我们提供了自适应阈值的函数，为cv2.adaptiveThreshold()
cv2.adapptiveThreshold(src,maxVal,adaptiveMethod,type,blockSize,C)

  • src:输入的图片对象

  • maxVal:与全局阈值一样，指规定的最大值

  • adaptiveMethod：着重讲解一下我们项目中所用到的cv2.ADAPTIVE_THRESH_MEAN_C
    在这里插入图片描述

    • cv2.ADAPTIVE_THRESH_MEAN_C取周围的像素作为判断当前像素值的依据，当blockSize为3时，即取3*3的卷积核，thresh = 9个像素平均灰度-C，那么图上的就等于90-10=80。这里的C即为一个常数，可以理解为偏置。此次项目中选择的tpye就是cv2.THRESH_BINARY，它的函数我们之前也提到过：
      在这里插入图片描述

  • tpye：即为：cv2.THRESH_BINARY和cv2.THRESH_BINARY_INV

  • blockSize:领域的大小，和卷积核非常相似，对此不熟悉的可以看我之前的CNN卷积神经网络的猫狗识别这篇文章：CNN卷积神经网络的猫狗识别

3.4自适应阈值代码即效果展示

在这里插入图片描述

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
"""
@Project ：OpenCV识别银行卡数字 
@File    ：全局阈值.py
@IDE     ：PyCharm 
@Author  ：咋
@Date    ：2023/1/14 17:17 
"""
import cv2
import numpy as np
# 读取图片
image = cv2.imread("cat_dog.jpg")
# 转化为灰度图
image = cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)
# 调整图片大小
image = cv2.resize(image,(640,480))
# 全局阈值处理，注意有两个返回值，所以需要两个变量来接受
thresh,threshold_img = cv2.threshold(image,120,255,cv2.THRESH_BINARY)
# 展示图片
cv2.imshow("image",np.hstack((image,threshold_img)))
# cv2.imshow("image",image)
cv2.waitKey(0)
# 销毁窗口
cv2.destroyAllWindows()

4.轮廓筛选

4.1轮廓检测

我直接来看API，在opencv中也给我们提供了轮廓检测的函数，在这里多说一句，由于opencv底层是C++写的，所以很多代码命名规范与Python不同，所以在python中调用API的时候，一定要分清楚大小写。轮廓检测的函数是cv2.findContours()
cv2.findContours(image,mode,method)

  • image:传入的需要进行处理的图片
  • mode:轮廓检索的方式：

在这里插入图片描述

  • method:轮廓近似方法：
    在这里插入图片描述

在此次项目中，我们轮廓检索模式为cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE。值得注意的是，返回值有两个，我们需要的是第一个contours，第二个hierarchy对我们没什么价值，我们用一个参数接收就可以了，重要的是contours，我们后面的很多操作都要用到检测出来的轮廓列表。

4.2绘制轮廓

在上面检测完轮廓之后返回了一个轮廓列表，在opencv中也给我们提供了绘制轮廓的API：cv2.drawContours(image,contours,i,color,thickness)

  • image:需要绘制的图片
  • contours：上述检测出来的轮廓列表
  • i：列表中第i个轮廓，如果选-1的话即所有轮廓
  • color：绘制的颜色
  • thickness：线宽，-1即填充

4.3轮廓筛选代码及效果展示

在这里插入图片描述

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
"""
@Project ：OpenCV识别银行卡数字 
@File    ：轮廓检测.py
@IDE     ：PyCharm 
@Author  ：咋
@Date    ：2023/1/14 18:30 
"""
import cv2
import numpy as np
# 读取图片
image = cv2.imread("img.png")
# 转化为灰度图
image = cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)
# 调整图片大小
image = cv2.resize(image,(640,480))
true_img = image.copy()
# 自适应阈值处理
threshold_img = cv2.adaptiveThreshold(image,255,cv2.ADAPTIVE_THRESH_MEAN_C,cv2.THRESH_BINARY,21,-10)
cv2.imshow("threshold_img",threshold_img)
# 轮廓检测
contours,hierarchy = cv2.findContours(threshold_img,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
print(contours)
image_draw = cv2.drawContours(image,contours,-1,(0,255,255),5)
# 展示图片
cv2.imshow("image",np.hstack((true_img,image_draw)))
# cv2.imshow("image",image_draw)
cv2.waitKey(0)
# 销毁窗口
cv2.destroyAllWindows()

5.形态学变化

5.1腐蚀

cv2.erode(image,kernel,iterations)

  • image：需要进行操作的图片对象
  • kernel:领域的大小
  • iterations:迭代的次数

腐蚀的原理很简单，就是用规定领域内像素的最小值代替当前的像素值，迭代次数就是腐蚀一边之后，是否还要腐蚀多次，腐蚀越多，图片的像素越小，图片也会越黑。

5.2膨胀

cv2.dilate(img,kernel,iterations)

  • image：需要进行操作的图片对象
  • kernel:领域的大小
  • iterations:迭代的次数

膨胀的原理和腐蚀非常相似，只不过膨胀是用邻域内像素的最大值代替当前的像素值，其他的参数意义一样。

5.3开运算和闭运算、礼帽和黑帽

开运算与闭运算以及下面所要介绍的礼帽黑帽所用的API的是一样的，只不是是op参数不同。
cv2.morghologyEx(image,op,kernel)

  • cv2.MORPH_OPEN:开运算，腐蚀—>膨胀
  • cv2.MORPH_CLOSE:闭运算，膨胀—>腐蚀
  • cv2.MORPH_TOPHAT:礼帽，开运算减原图 得到噪声图像
  • cv2.MORPH_BLACKHAT:黑帽 闭运算减原图 得到图像内的孔洞
    开运算：
    含义：先腐蚀后膨胀，去除背景（黑）中的噪声
    闭运算：
    含义：先膨胀后腐蚀，去除背景（白）中的黑色孔洞
    在这里插入图片描述
    礼帽：
    cv2.
    含义：开运算与原图做差
    黑帽：
    cv2.
    含义：闭运算与原图做差
    在这里插入图片描述

6.项目实战

6.1读取图片转化为灰度图

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
"""
@Project ：OpenCV识别银行卡数字 
@File    ：6.1导入包读取图片.py
@IDE     ：PyCharm 
@Author  ：咋
@Date    ：2023/1/14 19:54 
"""
import cv2
import numpy as np
# 读取图片
image = cv2.imread("bank_card41.jpg")
# 转化为灰度图
image = cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)
# 调整图片大小
image = cv2.resize(image,(4*image.shape[1],4*image.shape[0]))
cv2.imshow("image",image)
cv2.waitKey(0)
# 销毁窗口
cv2.destroyAllWindows()

在这里插入图片描述

6.2自适应阈值处理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
"""
@Project ：OpenCV识别银行卡数字 
@File    ：6.2自适应阈值处理.py
@IDE     ：PyCharm 
@Author  ：咋
@Date    ：2023/1/14 19:57 
"""
import cv2
import numpy as np
# 读取图片
image = cv2.imread("bank_card4.jpg")
# 转化为灰度图
image = cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)
# 调整图片大小
image = cv2.resize(image,(640,480))
# 自适应阈值处理
threshold_img = cv2.adaptiveThreshold(image,255,cv2.ADAPTIVE_THRESH_MEAN_C,cv2.THRESH_BINARY,21,3)
# 取反操作
thresh = cv2.bitwise_not(threshold_img)
cv2.imshow("image",np.hstack((image,thresh)))
cv2.waitKey(0)
# 销毁窗口
cv2.destroyAllWindows()

在这里插入图片描述

6.3第一次寻找合适的轮廓

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
"""
@Project ：OpenCV识别银行卡数字 
@File    ：6.3寻找合适的轮廓.py
@IDE     ：PyCharm 
@Author  ：咋
@Date    ：2023/1/14 19:59 
"""
import cv2
import numpy as np
# 读取图片
image = cv2.imread("bank_card41.jpg")
# 转化为灰度图
image = cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)
# 调整图片大小
image = cv2.resize(image,(4*image.shape[1],4*image.shape[0]))
# 自适应阈值处理
threshold_img = cv2.adaptiveThreshold(image,255,cv2.ADAPTIVE_THRESH_MEAN_C,cv2.THRESH_BINARY,21,3)
# 取反操作
thresh = cv2.bitwise_not(threshold_img)
# 寻找合适的轮廓
contours,hierarchy = cv2.findContours(thresh,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
print(contours)
# 判断合适的轮廓
for i in range(len(contours)):
    # 根据轮廓的面积
    if cv2.contourArea(contours[i]) < 60:
        thresh = cv2.drawContours(thresh, contours, i, (0,0,0), -1)

cv2.imshow("image",np.vstack((image,thresh)))
cv2.waitKey(0)
# 销毁窗口
cv2.destroyAllWindows()

6.4黑帽+腐蚀操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
"""
@Project ：OpenCV识别银行卡数字 
@File    ：6.4黑帽+腐蚀py
@IDE     ：PyCharm 
@Author  ：咋
@Date    ：2023/1/14 20:12 
"""
import cv2
import numpy as np
# 读取图片
image = cv2.imread("bank_card41.jpg")
# 转化为灰度图
image = cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)
# 调整图片大小
image = cv2.resize(image,(4*image.shape[1],4*image.shape[0]))
# 自适应阈值处理
threshold_img = cv2.adaptiveThreshold(image,255,cv2.ADAPTIVE_THRESH_MEAN_C,cv2.THRESH_BINARY,21,3)
# 取反操作
thresh = cv2.bitwise_not(threshold_img)
# 寻找合适的轮廓
contours,hierarchy = cv2.findContours(thresh,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
print(contours)
# 判断合适的轮廓
for i in range(len(contours)):
    # 根据轮廓的面积
    if cv2.contourArea(contours[i]) < 60:
        thresh = cv2.drawContours(thresh, contours, i, (0,0,0), -1)
# 黑帽操作
kernel = np.ones((15,15),dtype=np.uint8)
blackhat = cv2.morphologyEx(thresh, cv2.MORPH_BLACKHAT, kernel)
# 腐蚀操作
kernel = np.ones((3,3),dtype=np.uint8)
erosion = cv2.erode(blackhat,kernel,iterations = 1)
cv2.imshow("image",np.vstack((image,erosion)))
cv2.waitKey(0)
# 销毁窗口
cv2.destroyAllWindows()

在这里插入图片描述

6.5再次寻找轮廓+膨胀操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
"""
@Project ：OpenCV识别银行卡数字 
@File    ：再次寻找轮廓+膨胀操作.py
@IDE     ：PyCharm 
@Author  ：咋
@Date    ：2023/1/14 20:21 
"""
import cv2
import numpy as np
# 读取图片
image = cv2.imread("bank_card41.jpg")
# 转化为灰度图
image = cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)
# 调整图片大小
image = cv2.resize(image,(4*image.shape[1],4*image.shape[0]))
# 自适应阈值处理
threshold_img = cv2.adaptiveThreshold(image,255,cv2.ADAPTIVE_THRESH_MEAN_C,cv2.THRESH_BINARY,9,3)
# 取反操作
thresh = cv2.bitwise_not(threshold_img)
# 寻找合适的轮廓
contours,hierarchy = cv2.findContours(thresh,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
print(contours)
# 判断合适的轮廓
for i in range(len(contours)):
    # 根据轮廓的面积
    if cv2.contourArea(contours[i]) < 60:
        thresh = cv2.drawContours(thresh, contours, i, (0,0,0), -1)
# 黑帽操作
kernel = np.ones((15,15),dtype=np.uint8)
blackhat = cv2.morphologyEx(thresh, cv2.MORPH_BLACKHAT, kernel)
# 腐蚀操作
kernel = np.ones((3,3),dtype=np.uint8)
erosion = cv2.erode(blackhat,kernel,iterations = 1)

contours, hierarchy = cv2.findContours(erosion,cv2.RETR_TREE,cv2.CHAIN_APPROX_NONE)
for i in range(len(contours)):
    x,y,w,h = cv2.boundingRect(contours[i])
    aspect_ratio = float(w)/h
    A = float(w)*h
    if A < 1800:
        erosion = cv2.drawContours(erosion, contours, i, (0,0,0), -1)
    else:
        if aspect_ratio > 0.6 or aspect_ratio < 0.57:
            erosion = cv2.drawContours(erosion, contours, i, (0,0,0), -1)
cv2.imshow('erosion2',erosion)

kernel = np.ones((7,7),dtype=np.uint8)
dilation = cv2.dilate(erosion,kernel,iterations = 1)
# cv2.imshow('dilation',)
cv2.imshow("image",np.vstack((image,dilation)))
cv2.waitKey(0)
# 销毁窗口
cv2.destroyAllWindows()

在这里插入图片描述

6.6 模板匹配

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
numTemplate = cv2.imread('bankCardNumTemplate.jpg')
numTemplate_GRAY = cv2.cvtColor(numTemplate, cv2.COLOR_BGR2GRAY)
ret, numTemplate_GRAY = cv2.threshold(numTemplate_GRAY, 200, 255, cv2.THRESH_BINARY)
# cv2.imshow('thresh',thresh)
# cv2.imshow('numTemplate_GRAY', numTemplate_GRAY)
contours, hierarchy = cv2.findContours(numTemplate_GRAY, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
# print(np.size(contours))


def sequence_contours(dst_Binary, method, Rect_width, Rect_height):
    if method == "Left_to_Right" or method == 2:
        contours, hierarchy = cv2.findContours(dst_Binary, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
        n = np.size(contours)
        RectBoxes0 = np.ones((n, 4), dtype=int)
        # print(n)
        for i in range(0, n):
            RectBoxes0[i] = cv2.boundingRect(contours[i])
            # print(RectBoxes0)

        RectBoxes = np.ones((n, 4), dtype=int)

        for i in range(0, n):
            sequence = 0
            for j in range(0, n):
                if RectBoxes0[i][0] > RectBoxes0[j][0]:
                    sequence = sequence + 1
            RectBoxes[sequence] = RectBoxes0[i]

        RectImgBoxes = [[] for i in range(n)]
        for i in range(0, n):
            img = dst_Binary[RectBoxes[i, 1]:(RectBoxes[i, 1] + RectBoxes[i, 3]),
                  RectBoxes[i, 0]:(RectBoxes[i, 0] + RectBoxes[i, 2])]
            # cv2.imshow('number'+ str(i), img)
            img = cv2.resize(img, (Rect_width, Rect_height))
            ret, img = cv2.threshold(img, 200, 255, cv2.THRESH_BINARY)
            RectImgBoxes[i] = img
        # print(RectBoxes)
        # print(np.size(RectImgBoxes))

    return RectBoxes, RectImgBoxes


RectBoxes_Temp, RectImgBoxes_Temp = sequence_contours(numTemplate_GRAY, method="Left_to_Right", Rect_width=50,
                                                      Rect_height=80)
# print(RectBoxes)
# cv2.imshow('numberTemp', RectImgBoxes_Temp[3])

RectBoxes, RectImgBoxes = sequence_contours(dilation, method="Left_to_Right", Rect_width=50, Rect_height=80)
# cv2.imshow('numberfin', RectImgBoxes[3])

# print(len(RectImgBoxes))
result = []
for i in range(len(RectImgBoxes)):
    score = np.zeros(len(RectImgBoxes_Temp), dtype=int)
    for j in range(len(RectImgBoxes_Temp)):
        score[j] = cv2.matchTemplate(RectImgBoxes[i], RectImgBoxes_Temp[j], cv2.TM_CCOEFF)
    # print(score)
    min_val, max_val, min_indx, max_indx = cv2.minMaxLoc(score)
    result.append(max_indx[1])

# 定义添加数字到图片的函数
def add_num(image,num_list):
    text = ""
    for i in num_list:
        text += str(i)
    font = ImageFont.truetype("msyh.ttc",50)
    # 创建一个pillow的图片
    pil_img = Image.fromarray(image)
    # 绘制图片
    draw = ImageDraw.Draw(pil_img)
    # 利用draw去绘制中文
    draw.text((0, 0), text , font=font, fill=0)  # 后面的fill即颜色，RGBA
    # 重新变为ndarray
    image = np.array(pil_img)
    return image
print(result)
image = add_num(image,result)
cv2.imshow("image",image)
# cv2.imshow("image",np.vstack((image,dilation)))
cv2.waitKey(0)

在这里插入图片描述

7.完整代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
"""
@Project ：OpenCV识别银行卡数字 
@File    ：模板匹配.py
@IDE     ：PyCharm
@Author  ：咋
@Date    ：2023/1/14 20:29
"""
import cv2
import numpy as np
from PIL import ImageFont,ImageDraw,Image
# 读取图片
image = cv2.imread("bank_card41.jpg")
true_img = cv2.imread("bank_card4.jpg")
# 转化为灰度图
image = cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)
# 调整图片大小
image = cv2.resize(image,(4*image.shape[1],4*image.shape[0]))
# 自适应阈值处理
threshold_img = cv2.adaptiveThreshold(image,255,cv2.ADAPTIVE_THRESH_MEAN_C,cv2.THRESH_BINARY,9,3)
# 取反操作
thresh = cv2.bitwise_not(threshold_img)
# 寻找合适的轮廓
contours,hierarchy = cv2.findContours(thresh,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
# print(contours)
# 判断合适的轮廓
for i in range(len(contours)):
    # 根据轮廓的面积
    if cv2.contourArea(contours[i]) < 60:
        thresh = cv2.drawContours(thresh, contours, i, (0,0,0), -1)
# 黑帽操作
kernel = np.ones((15,15),dtype=np.uint8)
blackhat = cv2.morphologyEx(thresh, cv2.MORPH_BLACKHAT, kernel)
# 腐蚀操作
kernel = np.ones((3,3),dtype=np.uint8)
erosion = cv2.erode(blackhat,kernel,iterations = 1)

contours, hierarchy = cv2.findContours(erosion,cv2.RETR_TREE,cv2.CHAIN_APPROX_NONE)
for i in range(len(contours)):
    x,y,w,h = cv2.boundingRect(contours[i])
    aspect_ratio = float(w)/h
    A = float(w)*h
    if A < 1800:
        erosion = cv2.drawContours(erosion, contours, i, (0,0,0), -1)
    else:
        if aspect_ratio > 0.6 or aspect_ratio < 0.57:
            erosion = cv2.drawContours(erosion, contours, i, (0,0,0), -1)
# cv2.imshow('erosion2',erosion)

kernel = np.ones((7,7),dtype=np.uint8)
dilation = cv2.dilate(erosion,kernel,iterations = 1)
# 模板匹配
numTemplate = cv2.imread('bankCardNumTemplate.jpg')
numTemplate_GRAY = cv2.cvtColor(numTemplate, cv2.COLOR_BGR2GRAY)
ret, numTemplate_GRAY = cv2.threshold(numTemplate_GRAY, 200, 255, cv2.THRESH_BINARY)
# cv2.imshow('thresh',thresh)
# cv2.imshow('numTemplate_GRAY', numTemplate_GRAY)
contours, hierarchy = cv2.findContours(numTemplate_GRAY, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
# print(np.size(contours))


def sequence_contours(dst_Binary, method, Rect_width, Rect_height):
    if method == "Left_to_Right" or method == 2:
        contours, hierarchy = cv2.findContours(dst_Binary, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
        n = np.size(contours)
        RectBoxes0 = np.ones((n, 4), dtype=int)
        # print(n)
        for i in range(0, n):
            RectBoxes0[i] = cv2.boundingRect(contours[i])
            # print(RectBoxes0)

        RectBoxes = np.ones((n, 4), dtype=int)

        for i in range(0, n):
            sequence = 0
            for j in range(0, n):
                if RectBoxes0[i][0] > RectBoxes0[j][0]:
                    sequence = sequence + 1
            RectBoxes[sequence] = RectBoxes0[i]

        RectImgBoxes = [[] for i in range(n)]
        for i in range(0, n):
            img = dst_Binary[RectBoxes[i, 1]:(RectBoxes[i, 1] + RectBoxes[i, 3]),
                  RectBoxes[i, 0]:(RectBoxes[i, 0] + RectBoxes[i, 2])]
            # cv2.imshow('number'+ str(i), img)
            img = cv2.resize(img, (Rect_width, Rect_height))
            ret, img = cv2.threshold(img, 200, 255, cv2.THRESH_BINARY)
            RectImgBoxes[i] = img
        # print(RectBoxes)
        # print(np.size(RectImgBoxes))

    return RectBoxes, RectImgBoxes


RectBoxes_Temp, RectImgBoxes_Temp = sequence_contours(numTemplate_GRAY, method="Left_to_Right", Rect_width=50,
                                                      Rect_height=80)
# print(RectBoxes)
# cv2.imshow('numberTemp', RectImgBoxes_Temp[3])

RectBoxes, RectImgBoxes = sequence_contours(dilation, method="Left_to_Right", Rect_width=50, Rect_height=80)
# cv2.imshow('numberfin', RectImgBoxes[3])

# print(len(RectImgBoxes))
result = []
for i in range(len(RectImgBoxes)):
    score = np.zeros(len(RectImgBoxes_Temp), dtype=int)
    for j in range(len(RectImgBoxes_Temp)):
        score[j] = cv2.matchTemplate(RectImgBoxes[i], RectImgBoxes_Temp[j], cv2.TM_CCOEFF)
    # print(score)
    min_val, max_val, min_indx, max_indx = cv2.minMaxLoc(score)
    result.append(max_indx[1])

# 定义添加数字到图片的函数
def add_num(image,num_list):
    text = ""
    for i in num_list:
        text += str(i)
    font = ImageFont.truetype("msyh.ttc",40)
    # 创建一个pillow的图片
    pil_img = Image.fromarray(image)
    # 绘制图片
    draw = ImageDraw.Draw(pil_img)
    # 利用draw去绘制中文
    draw.text((15, 80), text , font=font, fill=0)  # 后面的fill即颜色，RGBA
    # 重新变为ndarray
    image = np.array(pil_img)
    return image
print(result)
true_img = add_num(true_img,result)
cv2.imshow("image",true_img)
# cv2.imshow("image",np.vstack((image,dilation)))
cv2.waitKey(0)

附上图片和代码链接：欢迎需要的小伙伴自取链接https://pan.baidu.com/s/1UeXrFjLXn3LWiDoUudW13w?pwd=3hye
提取码：3hye

8.总结

识别银行卡可算是Opencv的经典项目了，尤其是模板匹配，算得上是计算机视觉的精髓所在了。通过这个案例对二值化、轮廓检测、形态学变化腐蚀膨胀、开运算闭运算、礼帽黑帽有所了解，并能够组合在一起运算，算得上有所进步。
以此类推，模板匹配可以应用在很多项目中，关键的难点就在于怎么把图片和模板调整好，通过上述的方法以及参数的调整，可以达到这样的效果，还是需要多练习，才能真正掌握Opencv’的精髓。

✨$\textcolor{blue}{原创不易，还希望各位大佬支持一下}$

👍 $\textcolor{green}{点赞，你的认可是我创作的动力！}$

⭐️ $\textcolor{green}{收藏，你的青睐是我努力的方向！}$

✏️ $\textcolor{green}{评论，你的意见是我进步的财富！}$

在这里插入图片描述