机器学习进阶-案例实战-答题卡识别判 1.cv2.getPerspectiveTransform(获得投射变化后的H矩阵) 2.cv2.warpPerspective(H获得变化后的图像) 3.cv2.approxPolyDP(近似轮廓) 4.cv2.threshold(二值变化) 7.cv2.countNonezeros(非零像素点个数)6.cv2.bitwise_and(与判断)

1.H = cv2.getPerspectiveTransform(rect, transform_axes) 获得投射变化后的H矩阵

参数说明：rect表示原始的位置左上，右上，右下，左下， transform_axes表示变换后四个角的位置

2.cv2.warpPerspective(gray, H, (width, height)) 根据H获得变化后的图像

参数说明: gray表示输入的灰度图像， H表示变化矩阵，(width, height)表示变换后的图像大小
3. cv2.approxPloyDP(contour, length*0.02, True) # 计算轮廓的近似值

参数说明：contour表示输入的轮廓值, length表示轮廓的大小, True表示是否闭合

4. cv2.threshold(wrap, 0, 255, cv2.THRESH_BINARY_INV | cv2.THRESH_AUTO) # 进行图像的二值化操作
参数说明: wrap表示输入图片，0表示最小值，255表示最大值，THRESH_BINARY_INV | cv2.THRESH_AUTO表示方法，即大于最小阈值的为0， 小于最小阈值的为255

5. cv2.draw_contours(image, [contour], -1, 255, -1) # 对轮廓进行画图

参数说明：image表示输入图片. [contour] 表示单个轮廓， -1表示轮廓的index， 255表示颜色，-1表示对轮廓进行填充

6. cv2.bitwise(image, image, mask=mask)  # 与判断，如果两个都大于1才为1，否则都为0

参数说明：image表示输入图片，image表示输出图片， mask=mask表示掩膜

7. cv2.countNoneZeros(mask) # 用于计算图像中不等于0的像素点

参数说明：mask表示经过图像与掩膜的与操作以后的图像

8.cv2.putText(image, text, org, font, font_scale, color, ticking) # 在图像上加上文字

参数说明：image表示输入图片，text表示文字，org表示文字位置，font表示字体的格式，font_scale表示字体的胖瘦，color表示颜色，ticking表示粗细

答题卡识别判卷， 需要做的就是将画圈圈的地方识别出来。

    

原始图像                             涂了铅笔的比没涂白色部分要多，使用掩膜进行逐个遍历

第一部分：对图片进行透视变化，使得图片中的答题卡可以凸显出来

第一步：读入图片

第二步：使用cv2.gray() 进行灰度值的变化
第三步：使用cv2.GuassianBlur() 进行高斯滤波操作

第四步：使用cv2.Canny找出图片的边缘信息，为了下一步找出轮廓值做准备

第五步：使用cv2.findCountor() 找出图片的轮廓值，使用key = cv2.ContourArea对轮廓值进行排序

第六步：对轮廓值进行遍历，使用cv2.approxPolyDP(c, 0.02*lenght, True) 获得轮廓的近似值，如果近似值的维度为4，即为最外层答题卡的四个角的维度，则跳出循环

第七步：构造函数，对求得的轮廓值，根据其位置信息，将其变成左上，右上，右下，左上的形式的rect

第八步：计算width，height，计算出变换后的四个角的位置(transform_axes)

第九步：使用H = cv2.getPerspectiveTransform(rect, transform_axes) rect为变化前的位置，transform_axes为变化后的位置，以x,y表示,获得变化矩阵H

第十步：使用cv2.warpPerspective(thresh, H, (width, height)) 获得最终的变化结果

第二步：根据正确答案和图卡的答案来判断正确率

第一步：根据上述获得的wrapped，进行二值化操作, 使用cv2.COLOR_BINARY_INV将图了颜色的地方变成白色

第二步：使用cv2.findContours进行轮廓检测

第三步：对获得的轮廓，使用外接矩形cv2.boundingRect的(x, y, w, h)对轮廓进行筛选，找出答案的轮廓
第四步：对轮廓进行从上到下的排序

第五步：分别对每一行进行遍历，np.arange(0, len(question_cnts, 5)), 遍历每一行的轮廓值，根据图像构造掩膜mask图像，使用cv2.draw_contours在掩膜上画出对应位置的白色轮廓, 使用cv2.bitwise_and 获得原始图像当前位置等于1的点，使用cv2.countNoneZero计算出不是零的点，我们发现涂了颜色的要比没涂颜色的要大

第六步：计算出颜色值最大的位置和Nonezeros的值，correct+= 1

第七步：使用cv2.draw_contours在正确位置上进行画图操作

第八步：使用cv2.putText将正确率打印在图像上

代码：

# 第一部分代码：

import cv2
import numpy as np
import matplotlib.pyplot as plt
 
# 正确答案
ANSWER_KEY = {0: 1, 1: 4, 2: 0, 3: 3, 4: 1}
def cv_show(name, image):
    cv2.imshow(name, image)
    cv2.waitKey(0)
    cv2.destroyAllWindows()
 
def four_point_transform(image, dotCnt):
    # 第七步：按照轮廓近似的位置，将结果变成左上，右上，右下，左下的位置
    rect = sort_dotCnt(dotCnt)
    (tl, tr, br, bl) = rect
    # 第八步：计算轮廓的宽和长，构造出变化后四个角的位置
    widthA = np.sqrt(((tl[0]-tr[0])**2) + ((tl[1]-tr[1])**2))
    widthB = np.sqrt(((bl[0]-br[0])**2) + ((bl[1] - br[1])**2))
    widthMax = max(int(widthB), int(widthA))
 
    heightA = np.sqrt(((tl[0]-bl[0])**2) + ((tl[1]-bl[1])**2))
    heightB = np.sqrt(((tr[0]-br[0])**2) + ((tr[1] - br[1])**2))
    heightMax = max(int(heightA), int(heightB))
    # 四个角的位置信息
    transform_axis = np.array([
        [0, 0],
        [widthMax-1, 0],
        [widthMax-1, heightMax-1],
        [0, heightMax-1],
    ], dtype='float32')
 
    # 第九步：使用cv2.getPerspectiveTransform构造变化矩阵H
    H = cv2.getPerspectiveTransform(rect, transform_axis)
    # 第十步：使用cv2.warpPerspective()获得变化后的矩阵
    wrapped = cv2.warpPerspective(image, H, (widthMax, heightMax))
 
    cv_show('wrapped', wrapped)
 
    return wrapped
 
def sort_dotCnt(kps):
 
    rect = np.zeros((4, 2), dtype='float32')
    s = kps.sum(axis=1)
    # 找出左上和右下
    rect[0] = kps[np.argmin(s)]
    rect[2] = kps[np.argmax(s)]
    # 找出右上和左下
    diff = np.diff(kps, axis=1)
    rect[1] = kps[np.argmin(diff)]
    rect[3] = kps[np.argmax(diff)]
 
    return rect
 
def sorted_contours(cnt, model='left-to-right'):
 
    if model == 'top-to-bottom':
        cnt = sorted(cnt, key=lambda x:cv2.boundingRect(x)[1])
 
    elif model == 'left-to-right':
        cnt = sorted(cnt, key=lambda x:cv2.boundingRect(x)[0])
 
    return cnt
 
# 第一部分：使用投射变化进行图像的转换, 将答题卡放在图片的正中央
# 第一步：读入图片
image = cv2.imread('images/test_01.png')
# 第二步：进行灰度化操作
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
cv_show('gray', gray)
 
# 第三步： 进行高斯变化
Guass = cv2.GaussianBlur(gray, (5, 5), 0)
# 第四步：使用cv2.Canny 找出图像的边缘部分
edges = cv2.Canny(Guass, 50, 200)
cv_show('edges', edges)
# 第五步：使用cv2.findCountours找出图像的轮廓， 并对轮廓进行排序
cnt = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)[1]
ret = cv2.drawContours(image.copy(), cnt, -1, (0, 0, 255), 2)
cv_show('ret', ret)
 
dotCnt = None
 
if len(cnt) > 0:
 
    cnt = sorted(cnt, key=cv2.contourArea, reverse=True)
    # 第六步： 遍历轮廓，获得cv2.approxPolyDP获得轮廓的近似值, 如果approx=4，即为填图卡的轮廓近似
    for c in cnt:
 
        length = cv2.arcLength(c, True)
        # 获得轮廓的近似值
        approx = cv2.approxPolyDP(c, 0.02*length, True)
        # 如果轮廓的维度是4，即由4个点组成，就是一个方框，那就是外面的方框
        if len(approx) == 4:
 
            dotCnt = approx
            break
 
wrapped = four_point_transform(gray, dotCnt.reshape(4, 2))
cv_show('wrapped', wrapped)

            

原始图片                            灰度变化后图片         边缘检测的图片                 检测到的轮廓图            最终透射变化结果

# 第二部分代码：

# 第二部分：对变化后的wrapped进行操作，构造mask根据有无填涂的特性，进行位置的计算
 
#第一步：对图像进行二值化操作
thresh = cv2.threshold(wrapped, 0, 255, cv2.THRESH_BINARY_INV | cv2.THRESH_OTSU)[1]
cv_show('thresh', thresh)
 
# 第二步：对图像进行轮廓检测
cnts = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)[1]
 
# 第三步：使用cv2.boudingRect将答案信息的轮廓进行筛选
 
questionCnts = []
for c in cnts:
 
    (x, y, w, h) = cv2.boundingRect(c)
    arc = w / float(h)
 
    # 根据实际情况找出合适的轮廓
    if w > 20 and h > 20 and arc >= 0.9 and arc<=1.1:
        questionCnts.append(c)
 
# 第四步：将轮廓进行从上到下的排序
questionCnts = sorted_contours(questionCnts, model='top-to-bottom')
 
# 第五步：对每一行的轮廓进行遍历，构造掩码，对每一行答案的轮廓进行遍历，使用cv2.countNoneZeros()计算出涂了颜色的答案，并计算最终的结果
correct = 0
for j, qC in enumerate(np.arange(0, len(questionCnts), 5)):
 
    questionCnt = questionCnts[qC:qC+5]
    # 进行排序
    questionCnt = sorted_contours(questionCnt)
    questionCnt = np.array(questionCnt)
    # 每个问题的答案
    bubbled = None
    for k, c in enumerate(questionCnt):
        # 根据轮廓值构造掩膜， 因为有涂答案的地方是白色的
        mask = np.zeros(thresh.shape, np.uint8)
        # 使用cv2.drawContours画出轮廓值
        cv2.drawContours(mask, [c], -1, 255, -1)
        cv_show('mask', mask)
        mask = cv2.bitwise_and(thresh, thresh, mask=mask)
        # 第六步：使用cv2.countNoneZero计算出白色最多的位置
        Nonezero = cv2.countNonZero(mask)
        if bubbled == None or Nonezero > bubbled[0]:
            bubbled = (Nonezero, k)
 
    question_answer = int(bubbled[1])
    answer_True = ANSWER_KEY[j]
 
    # 如果结果和正确结果相同，就+1
    if question_answer == answer_True:
        correct += 1
    # 第七步：对正确答案的轮廓进行画图操作
    cv2.drawContours(wrapped, [questionCnt[answer_True]], -1, 0, 2)
 
cv_show('wrapped', wrapped)
 
score = (correct / 5) * 100
# 第八步：使用cv2.putText将正确率打印在图上
cv2.putText(wrapped, 'correct_score:%d' %score, (10, 30), cv2.FONT_HERSHEY_SIMPLEX,
            0.8, 0, 2)
cv2.imshow('orginal', image)
cv2.imshow('wrapped', wrapped)
 
cv2.waitKey(0)
cv2.destroyAllWindows()

               

Binary_Inv二值化的结果         draw_contours画出掩膜轮廓                      最终的结果图