当先锋百科网

首页 1 2 3 4 5 6 7

笔记：OpenCV进行信用卡数字识别

1. 前言

本文对利用OpenCV进行信用卡数字识别的流程进行复习，也复习一下里面的一些函数的用法，学得快忘得也很快，不复习不写个博客笔记真的很快就忘记了哈哈哈哈。

2. 先做好数字匹配的模板

  • （1）我们的模板是这个样子的数字序列，接下来对一个一个数字做好分割和建立一个字典dict方便做匹配。

  • （2）读入图像并二值化
  • # 导入工具包
from imutils import contours
import numpy as np
import cv2

# 读取一个模板图像
img = cv2.imread(r'ocr_a_reference.png')
cv_show('img',img)
# 灰度图
ref = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
cv_show('ref',ref)
# 二值图像
#阈值是10，#cv2.THRESH_BINARY_INV  大于阈值部分被置为0，小于部分被置为255
ref = cv2.threshold(ref, 10, 255, cv2.THRESH_BINARY_INV)[1] #返回值第二个是图像，只取第二个
cv_show('ref',ref)

  • （3）寻找外轮廓并绘制

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

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

#cv2.drawContours(image, contours, contourIdx, color, thickness=None, lineType=None, hierarchy=None, maxLevel=None, offset=None)
#参数分别是3维色彩的原图，轮廓列表，画第几个轮廓，画的颜色（BGR 0，0，225）表示红色画
#线宽3（如果是-1（cv2.FILLED），则为填充模式），线型
cv2.drawContours(img,refCnts,-1,(0,0,255),3) #-1就是画全部轮廓
cv_show('img',img)

     

  •  （4）轮廓排序，使从左到右与0-9这个序列匹配 
    # 轮廓排序，轮廓可能不顺序的，需要从左到右进行排序，轮廓
refCnts = myutils.sort_contours(refCnts, method="left-to-right")[0] #排序，从左到右，从上到下
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))# resize成合适的大小
	# 每一个数字对应每一个模板
	digits[i] = roi

     其中排序函数是这样子的，先用最小的外界矩形包起数字，然后根据轮廓的左上角的x坐标的大小进行排序

    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

    3. 读入信用卡图像进行预处理

  • （1）初始化卷积核，矩形卷积核9*3和方形卷积核5*5 
    # 初始化卷积核,取得
rectKernel = cv2.getStructuringElement(cv2.MORPH_RECT, (9, 3))
sqKernel = cv2.getStructuringElement(cv2.MORPH_RECT, (5, 5))

     

  • （2）读入信用卡图像并resize和灰度化 
    
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

#读取输入图像，预处理
image = cv2.imread(r'credit_card_01.png')
cv_show('image',image)
image = myutils.resize(image, width=300)
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
cv_show('gray',gray)

     

  •  （3）礼貌操作，可以使数字更为突出明亮 
    #礼帽操作，突出更明亮的区域，突出数字的轮廓
tophat = cv2.morphologyEx(gray, cv2.MORPH_TOPHAT, rectKernel) 
cv_show('tophat',tophat)

  • （4）X方向上的边缘检测，然后将每个像素进行归一化成0-255的值，这方便我们进行理解，因为边缘检测后的gradX可能的像素点有正有负，也不是典型的二值图（0-255） 
    # 用Sobel算子进行水平边缘提取，再将每个像素归一化
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)
     

  • （5）进行闭操作，然后用大津法函数进行二值化图像，目的是将数字连在一个块
#通过闭操作（先膨胀，再腐蚀）将数字连在一起
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)

  •  （6）因为还有一些黑色的小块，然后就再来一次闭操作，这次用sqKernel这个核，大概是因为小块比较小，不过好像对我们的目标变化不大
#再来一个闭操作

thresh = cv2.morphologyEx(thresh, cv2.MORPH_CLOSE, sqKernel) #再来一个闭操作，因为中间有些黑色的小方块
cv_show('thresh',thresh)

  •  （7）计算轮廓并画出 
    # 计算轮廓并且将它画出来

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 = []

    （8）根据矩形的大小，筛选属于数字的矩形

    # 遍历轮廓，提取一下属于信用卡数字的区域
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. 对每一个矩形中的数字进行轮廓检测和匹配

  • （1）用for循环对每一个矩形进行提取，里面的数字进行二值化、轮廓检测，然后将它与模板中的十个数一一对比获得十个分数，然后取最大分数所在的位置就是这个数字所在的位置 
    # 计算每一组中的每一个数值
	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个数字，与roi中进行比较
		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)

     

     

    （2）显示结果