opencv实际案例(一)银行卡号的识别
一、目标：
识别银行卡上的卡号
二、思路：
一 、准备模板，能够与卡号数字样式进行模型匹配
二、处理模板图片：将其分割成为单个数字的图片，和所对应的数字相匹配存储可迭代的数据类型中。
- 读入模板图片，并对模板图片进行灰度化，最后转换为二值图像
- 计算模板的轮廓，给轮廓排序（按照在银行卡上的位置），这里选择检索外轮廓，压缩水平的，垂直的和斜的部分
- 按照数字的顺序将每个数字的小图片存入列表
def cv_show(name,img):
cv2.imshow(name, img)
cv2.waitKey(0)
cv2.destroyAllWindows()
img = cv2.imread(args["template"]) #读入图片
# cv_show('img',img)
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)
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)
print(np.array(refCnts).shape)
refCnts = myutils.sort_contours(refCnts,method="left-to-right")[0] #给轮廓排序
digits = {}
for (i,c) in enumerate(refCnts):
(x,y,w,h) = cv2.boundingRect(c)
roi = ref[y:y+h,x:x+w]
roi = cv2.resize(roi,(57,88))
digits[i] = roi
#模板处理完成
如何给轮廓排序
1 先将轮廓的外接矩形画出
2 外接矩形会返回左上角点的坐标以及长和宽，利用横坐标进行排序
import cv2
#给轮廓排序的函数
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))
# 这里的b:b[1][i]就是按照列表中的1号元素（也就是boundingBoxes）的第0号元素（坐标x）来进行排序
return cnts, boundingBoxes
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
sorted函数
zip函数
zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表
>>>a = [1,2,3]
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b) # 打包为元组的列表
[(1, 4), (2, 5), (3, 6)]
>>> zip(a,c) # 元素个数与最短的列表一致
[(1, 4), (2, 5), (3, 6)]
>>> zip(*zipped) # 与 zip 相反，*zipped 可理解为解压，返回二维矩阵式
[(1, 2, 3), (4, 5, 6)]
至此，所有的模板图片处理完毕
三、处理输出图片
第一步：读入图像，进行灰度化、二值化处理，调整图片的大小
第二步：为了突出比原轮廓亮的部分，使用顶帽操作处理图像，求图片的梯度，并进行求绝对值，归一化处理
第三步：我们需要找到包含银行卡号的小矩形，需要提取银行卡号所在小块的轮廓
- 闭运算（使文字，数字等融合成一块一块的）
- 二值转换（自适应阈值）
- 闭运算（消除白色块中的杂质）
到现在，图中有字的部分应该就是一块一块的了，我们现在要提取我们需要的块 - 求轮廓，在图像中画出轮廓
- 画出每个轮廓的外接矩形，返回左上角的坐标以及长与宽
- 根据长宽比与坐标值，筛选出我们需要的矩形框
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)
rectKernel = cv2.getStructuringElement(cv2.MORPH_RECT, (9, 3))
sqKernel = cv2.getStructuringElement(cv2.MORPH_RECT, (5, 5))
#--------------------------------------------------------------------------
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) #求梯度
gradx = np.absolute(gradx) #求绝对值
(min_val,max_val) = (np.min(gradx),np.max(gradx)) #归一化
gradx = 255*((gradx-min_val) / (max_val-min_val))
gradx = gradx.astype("uint8")
# print (np.array(gradx).shape)
cv_show('gradX_norm',gradx)
gradx = cv2.morphologyEx(gradx,cv2.MORPH_CLOSE,rectKernel)#闭操作，将数字融合在一起,所以这里要用比较大的核
cv_show('gradx',gradx)
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]) #这里的x:x[0]就是按照列表中的0号元素来排序
#至此，银行卡号四部分的轮廓已经被提取出来了
thresh = cv2.threshold
thresh = cv2.threshold(gradX, 0, 255,cv2.THRESH_BINARY | cv2.THRESH_OTSU)[1]
参数说明， src表示输入的图片， thresh表示阈值， maxval表示最大值， type表示阈值的类型 type的类型
1.cv2.THRESH_BINARY 表示阈值的二值化操作，大于阈值使用maxval表示，小于阈值使用0表示
2. cv2.THRESH_BINARY_INV 表示阈值的二值化翻转操作，大于阈值的使用0表示，小于阈值的使用最大值表示
3. cv2.THRESH_TRUNC 表示进行截断操作，大于阈值的使用阈值表示，小于阈值的不变
4. cv2.THRESH_TOZERO 表示进行化零操作，大于阈值的不变，小于阈值的使用0表示
5. cv2.THRESH_TOZERO_INV 表示进行化零操作的翻转，大于阈值的使用0表示，小于阈值的不变
那么为什么这里的阈值为0呢？ 因为我们进行二值处理时习惯于将阈值确定为127，但这个数值在有时候是不适用的，所以我们要用一种自适应的方法来确定阈值。 而Otsu就可以自己找到一个认为最好的阈值。并且Otsu非常适合于图像灰度直方图具有双峰的情况，他会在双峰之间找到一个值作为阈值，对于非双峰图像，可能并不是很好用。那么经过Otsu得到的那个阈值就是函数cv2.threshold的第一个参数了。因为Otsu方法会产生一个阈值，那么函数cv2.threshold的的第二个参数（设置阈值）就是0了，并且在cv2.threshold的方法参数中还得加上语句cv2.THRESH_OTSU。 什么是图像灰度直方图具有双峰的情况？
至此，我们得到了银行卡上所有卡号所在的小块
四、我们要将所有小块中的每个数字取出，与模板进行匹配，得到银行卡号
- 我们将得到的4个小块（对应四块银行卡号）分别遍历，用每个块的位置信息得到原图像的灰度图中的相关区域图像（稍微扩大一些 ）
- 对这些区域进行二值化处理，计算轮廓，并进行排序，得到每一个数字的图像
- 将单个数字与模板中的每一个数字进行匹配，得到最相似的模板图像所对应的索引就是该数字所对应的数字。
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) #显示第i个外接矩阵的图像
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)))#返回这个数字与模板中所有数字匹配的10个得分的最大值的索引
cv2.rectangle(image,(gX-5,gY-5),(gX+gW+5,gY+gH+5),(0,0,255),2)
cv2.putText(image,"".join(groupOutput),(gX,gY-15),cv2.FONT_HERSHEY_SIMPLEX,0.65,(0,0,255),2)
output.extend(groupOutput)
cv2.putText函数
cv2.putText(img, str(i), (123,456), font, 2, (0,255,0), 3)
- 各参数依次是：图片、添加的文字，左上角的坐标、字体、字体大小、颜色、字体粗细。
- img – 想要打印上文字的图像
- text – 想要打印的文字
- org – 文字的左下角坐标
- fontFace – 字体，可选的有：FONT_HERSHEY_SIMPLEX
.join函数
string.join() 具体作用如下： join()： 连接字符串数组。将字符串、元组、列表中的元素以指定的字符(分隔符)连接生成一个新的字符串.对字典进行连接，只能将字典的键连接起来。
.extend()函数
.entend()与.append()都是给列表中添加元素，二者的区别：
lis.append(a)添加的是a这个整体，而lis.extend(a)会把a中的各个元素分开，a中的内容不再是一个整体
三、完整代码
import cv2
import numpy as np
from imutils import contours
import myutils
import argparse #argparse是一个Python模块：命令行选项、参数和子命令解析器。
np.set_printoptions(threshold=np.inf)
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)
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)
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)
print(np.array(refCnts).shape)
refCnts = myutils.sort_contours(refCnts,method="left-to-right")[0] #给轮廓排序
digits = {}
for (i, c) in enumerate(refCnts): #i为数值，c为数值i对应得到轮廓
# 计算外接矩形并且resize成合适大小
(x, y, w, h) = cv2.boundingRect(c) #得到外接矩形
roi = ref[y:y + h, x:x + w] #将外接矩形这一块抠出来
cv_show('roi', roi)
roi = cv2.resize(roi, (57, 88))
# 每一个数字对应每一个数字的模板
digits[i] = roi
#模板处理完成
'''
对输入图像进行处理
第一步：读入图像，进行灰度化、二值化处理
第二步：为了突出比原轮廓亮的部分，使用礼帽操作处理图像
第三步：我们需要找到包含银行卡号的小矩形，需要提取银行卡号所在小块的轮廓
闭运算（使文字，数字等融合成块）
二值操作
闭运算（消除白色块中的杂质）
'''
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)
rectKernel = cv2.getStructuringElement(cv2.MORPH_RECT, (9, 3))
sqKernel = cv2.getStructuringElement(cv2.MORPH_RECT, (5, 5))
#--------------------------------------------------------------------------
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) #求梯度
gradx = np.absolute(gradx) #求绝对值
(min_val,max_val) = (np.min(gradx),np.max(gradx)) #归一化
gradx = 255*((gradx-min_val) / (max_val-min_val))
gradx = gradx.astype("uint8")
# print (np.array(gradx).shape)
cv_show('gradX_norm',gradx)
#---------------------------------------------------------------------------------
gradx = cv2.morphologyEx(gradx,cv2.MORPH_CLOSE,rectKernel)#闭操作，将数字融合在一起,所以这里要用比较大的核
cv_show('gradx',gradx)
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]) #这里的x:x[0]就是按照列表中的0号元素来排序
#至此，银行卡号四部分的轮廓已经被提取出来了
'''
遍历4个轮廓块
提取出每一块轮廓中的每个数字
'''
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) #显示第i个外接矩阵的图像
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)))#返回这个数字与模板中所有数字匹配的10个得分的最大值的索引
cv2.rectangle(image,(gX-5,gY-5),(gX+gW+5,gY+gH+5),(0,0,255),2)
cv2.putText(image,"".join(groupOutput),(gX,gY-15),cv2.FONT_HERSHEY_SIMPLEX,0.65,(0,0,255),2)
output.extend(groupOutput)
print("银行卡的账号是：{}".format("".join(output)))
cv_show("image",image)
import cv2
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
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
四、收获
在对图像进行截取的时候很疑惑，为什么要扩大一点用减法呢？原来是因为图像中的坐标系和我想的不一样
顶帽操作有突出轮廓较亮部分的作用。
闭运算可以将文字啊数字啊什么的与背景不同颜色的东西融合，也可以消除白色块（背景是黑色）中的杂质。
二值转换并不是所有的阈值都是127，有时候要进行自适应的阈值设定。