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）显示结果

•