OpenCV视频学习笔记（15）-项目实战-答题卡识别判卷_cv2.drawcontours(mask, [c], -1, 255, -1) #-1表示填充

十五、项目实战-答题卡识别判卷

步骤：
（1）对图像进行滤波操作；
（2）边缘检测；
（3）透视变换；
（4）看一下选择的是哪个答案，进行二值处理；
（5）判断选择的答案，通过计算圆圈里面非0点的个数，也就是黑白比例来看；
#导入工具包
import numpy as np
import argparse
import imutils
import cv2

//设置参数
ap = argparse.ArgumentParser()
ap.add_argument("-i", “–image”, required=True,
help=“path to the input image”)
args = vars(ap.parse_args())

//正确答案
ANSWER_KEY = {0: 1, 1: 4, 2: 0, 3: 3, 4: 1}#指定了一个字典结构，里面是正确答案

def order_points(pts):
// 一共4个坐标点
rect = np.zeros((4, 2), dtype = “float32”)

//按顺序找到对应坐标0123分别是 左上，右上，右下，左下
// 计算左上，右下
s = pts.sum(axis = 1)
rect[0] = pts[np.argmin(s)]
rect[2] = pts[np.argmax(s)]

// 计算右上和左下
diff = np.diff(pts, axis = 1)
rect[1] = pts[np.argmin(diff)]
rect[3] = pts[np.argmax(diff)]

return rect

def four_point_transform(image, pts):#透视变换
// 获取输入坐标点
rect = order_points(pts)
(tl, tr, br, bl) = rect

// 计算输入的w和h值
widthA = np.sqrt(((br[0] - bl[0]) ** 2) + ((br[1] - bl[1]) ** 2))
widthB = np.sqrt(((tr[0] - tl[0]) ** 2) + ((tr[1] - tl[1]) ** 2))
maxWidth = max(int(widthA), int(widthB))

heightA = np.sqrt(((tr[0] - br[0]) ** 2) + ((tr[1] - br[1]) ** 2))
heightB = np.sqrt(((tl[0] - bl[0]) ** 2) + ((tl[1] - bl[1]) ** 2))
maxHeight = max(int(heightA), int(heightB))

// 变换后对应坐标位置
dst = np.array([
[0, 0],
[maxWidth - 1, 0],
[maxWidth - 1, maxHeight - 1],
[0, maxHeight - 1]], dtype = “float32”)

// 计算变换矩阵
M = cv2.getPerspectiveTransform(rect, dst)
warped = cv2.warpPerspective(image, M, (maxWidth, maxHeight))

// 返回变换后结果
return warped
def sort_contours(cnts, method=“left-to-right”):
#因为每题的选项，他们的y轴不一样，y的坐标越来越往下，所以从上往下排序
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© for c in cnts]
(cnts, boundingBoxes) = zip(*sorted(zip(cnts, boundingBoxes),
key=lambda b: b[1][i], reverse=reverse))
return cnts, boundingBoxes
def cv_show(name,img):
cv2.imshow(name, img)
cv2.waitKey(0)
cv2.destroyAllWindows()

//预处理
image = cv2.imread(args[“image”])#读取图像
contours_img = image.copy()#复制图像，方便后面进行轮廓的检测
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)#转换成灰度图
blurred = cv2.GaussianBlur(gray, (5, 5), 0)#通过高斯滤波去掉噪音点
cv_show(‘blurred’,blurred)

edged = cv2.Canny(blurred, 75, 200)#边缘检测
cv_show(‘edged’,edged)

#做透视变换
// 先轮廓检测
cnts = cv2.findContours(edged.copy(), cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)[1]
cv2.drawContours(contours_img,cnts,-1,(0,0,255),3)
cv_show(‘contours_img’,contours_img)

docCnt = None

// 确保检测到了
if len(cnts) > 0:

根据轮廓大小进行排序，根据面积

cnts = sorted(cnts, key=cv2.contourArea, reverse=True)

遍历每一个轮廓

for c in cnts:
# 近似
peri = cv2.arcLength(c, True)
approx = cv2.approxPolyDP(c, 0.02 * peri, True)

  # 准备做透视变换
  if len(approx) == 4:#如果有4个顶点，那就是最外层的框
     docCnt = approx
     break
1
2
3
4

//执行透视变换

warped = four_point_transform(gray, docCnt.reshape(4, 2))
cv_show(‘warped’,warped)

thresh = cv2.threshold(warped, 0, 255,
cv2.THRESH_BINARY_INV | cv2.THRESH_OTSU)[1] #自适应
#两种主体，一种被填充了，一种没被填充，这里进行二值处理，0表示自动判断，用自适应阈值去判断
cv_show(‘thresh’,thresh)

#被填充的为白色，没被填充的为黑色

#轮廓检测
thresh_Contours = thresh.copy()
//找到每一个圆圈轮廓
#因为答题卡可能图的不规范，用霍夫检测效果不好，所以就使用轮廓检测即可
cnts = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)[1]
cv2.drawContours(thresh_Contours,cnts,-1,(0,0,255),3)
cv_show(‘thresh_Contours’,thresh_Contours)

questionCnts = []
#可能会检测到很多轮廓
//遍历
for c in cnts:

计算比例和大小

(x, y, w, h) = cv2.boundingRect©
ar = w / float(h)
if w >= 20 and h >= 20 and ar >= 0.9 and ar <= 1.1:
#指定比例，判断该区域是不是一个选项

questionCnts.append©
#已经找到所有的圆，但可能没有按顺序排列
//按照从上到下进行排序
#同一题的5个选项中，纵坐标（y）是相同的
questionCnts = sort_contours(questionCnts,
method=“top-to-bottom”)[0]#从上到下
correct = 0
//每排有5个选项
for (q, i) in enumerate(np.arange(0, len(questionCnts), 5)):
//排序，又进行了从左到右排序A、B、C、D、E
cnts = sort_contours(questionCnts[i:i + 5])[0]
bubbled = None

// 遍历每一个结果
for (j, c) in enumerate(cnts):
# 使用mask来判断结果（掩码）
mask = np.zeros(thresh.shape, dtype=“uint8”)
cv2.drawContours(mask, [c], -1, 255, -1) #-1表示填充
cv_show(‘mask’,mask)

#通过掩码操作保留白色的，其他的过滤掉
# 通过计算非零点数量来算是否选择这个答案
mask = cv2.bitwise_and(thresh, thresh, mask=mask)#与操作
total = cv2.countNonZero(mask)

  # 通过阈值判断，判断五个选项的像素点中哪一个是非0值最大的
  if bubbled is None or total > bubbled[0]:
     bubbled = (total, j)#找到之后返回j，j为选的那个答案
1
2
3

//对比正确答案
color = (0, 0, 255)
k = ANSWER_KEY[q]#q表示的是第几排

//判断正确
if k == bubbled[1]:
color = (0, 255, 0)
correct += 1

//绘图
cv2.drawContours(warped, [cnts[k]], -1, color, 3)

//打印操作
score = (correct / 5.0) * 100
print("[INFO] score: {:.2f}%".format(score))
cv2.putText(warped, “{:.2f}%”.format(score), (10, 30),
cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 0, 255), 2)
cv2.imshow(“Original”, image)
cv2.imshow(“Exam”, warped)
cv2.waitKey(0)