O3.4 opencv图形拼接+答题卡识别

一·图形拼接

逻辑

1. 导入必要的库

python

import cv2
import numpy as np
import sys

导入cv2库用于图像处理，numpy库用于数值计算，sys库用于与 Python 解释器进行交互，例如退出程序。

1. 定义图像显示函数

def cv_show(name, img):cv2.imshow(name, img)cv2.waitKey(0)

cv_show函数用于在窗口中显示图像，并等待用户按键关闭窗口。它接受两个参数，name是窗口名称，img是要显示的图像。

1. 定义特征检测与描述函数

python

def detectAndDescribe(image):gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)  descriptor = cv2.SIFT_create()  (kps, des) = descriptor.detectAndCompute(gray, None)kps_float = np.float32([kp.pt for kp in kps])return (kps, kps_float, des)  

• 函数detectAndDescribe接受一个图像作为输入。
• 首先将彩色图像转换为灰度图像，因为 SIFT 算法通常在灰度图像上进行操作。
• 创建 SIFT 特征提取器对象descriptor。
• 使用descriptor.detectAndCompute方法同时检测图像中的关键点并计算这些关键点的描述符。kps是关键点列表，des是描述符。
• 将关键点的坐标转换为numpy的float32类型数组kps_float，方便后续计算。
• 最后返回关键点集kps、关键点坐标数组kps_float以及描述符des。

1. 读取并显示拼接图片

imageA = cv2.imread("1.jpg")
cv_show('imageA', imageA)
imageB = cv2.imread("2.jpg")
cv_show('imageB', imageB)

使用cv2.imread分别读取两张要拼接的图像1.jpg和2.jpg，并通过cv_show函数在不同窗口中显示原始图像，让用户可以直观查看。

1. 计算图片特征点及描述符

python

(kpsA, kps_floatA, desA) = detectAndDescribe(imageA)
(kpsB, kps_floatB, desB) = detectAndDescribe(imageB)

对图像imageA和imageB分别调用detectAndDescribe函数，获取它们的关键点集、关键点坐标数组以及描述符。

1. 建立匹配器并进行特征匹配

python

matcher = cv2.BFMatcher()
rawMatches = matcher.knnMatch(desB, desA, 2)
good = []
matches = []
for m in rawMatches:if len(m) == 2 and m[0].distance < 0.65 * m[1].distance:good.append(m)matches.append((m[0].queryIdx, m[0].trainIdx))

• 创建cv2.BFMatcher对象matcher，这是一个暴力匹配器，用于匹配两个图像的特征描述符。虽然代码注释提到在匹配大型训练集合时FlannBasedMatcher速度更快，但这里使用了BFMatcher。
• 使用matcher.knnMatch方法对图像imageB和imageA的描述符进行 K 近邻匹配，k = 2表示为图像imageB的每个描述符在图像imageA的描述符中寻找最近的两个匹配。
• 遍历所有匹配结果rawMatches，通过比率测试筛选出较好的匹配点。当最近距离与次近距离的比值小于 0.65 时，认为该匹配是一个好的匹配，将其添加到good列表中，并将匹配点在两个图像中的索引添加到matches列表中。

1. 绘制匹配点连线并显示

python

vis = cv2.drawMatchesKnn(imageB, kpsB, imageA, kpsA, good, None,flags=cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS)
cv_show("Keypoint Matches", vis)

使用cv2.drawMatchesKnn函数绘制匹配点之间的连线。该函数接受图像imageB及其关键点kpsB、图像imageA及其关键点kpsA、筛选后的匹配对good等参数。flags=cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS参数表示绘制更丰富的关键点信息。绘制结果保存在vis中，然后通过cv_show函数在名为Keypoint Matches的窗口中显示绘制了匹配连线的图像。

1. 透视变换与图像拼接

python

if len(matches) > 4:  ptsB = np.float32([kps_floatB[i] for (i, _) in matches])  ptsA = np.float32([kps_floatA[i] for (_, i) in matches])  (H, mask) = cv2.findHomography(ptsB, ptsA, cv2.RANSAC, 10)
else:print('图片未找到4个以上的匹配点')sys.exit()result = cv2.warpPerspective(imageB, H, (imageB.shape[1] + imageA.shape[1], imageB.shape[0]))
cv_show('resultB', result)
result[0:imageA.shape[0], 0:imageA.shape[1]] = imageA
cv_show('result', result)

• 当筛选后的匹配对数量大于 4 时，可以计算视角变换矩阵。
• 从matches列表中提取图像imageB和imageA的匹配点坐标，分别存储在ptsB和ptsA中。
• 使用cv2.findHomography函数计算透视变换矩阵H，这里使用cv2.RANSAC方法，并设置最大允许重投影错误阈值为 10。RANSAC方法可以有效剔除误匹配点，提高变换矩阵的准确性。
• 如果匹配点数量小于 4，则打印提示信息并退出程序。
• 使用计算得到的透视变换矩阵H，对图像imageB进行透视变换，得到变换后的图像result。变换后的图像宽度是两张原始图像宽度之和，高度与图像imageB相同。
• 将图像imageA放置在result图像的最左端，完成图像拼接。
• 最后通过cv_show函数分别显示变换后的图像resultB和拼接后的最终图像result。

代码

import cv2
import numpy as np
import sys
def cv_show(name, img):cv2.imshow(name, img)cv2.waitKey(0)
def detectAndDescribe(image):gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)  # 将彩色图片转换成灰度图descriptor = cv2.SIFT_create()  # 建立SIFT生成器# 检测SIFT特征点，并计算描述符，第二个参数为掩膜(kps, des) = descriptor.detectAndCompute(gray, None)# 将结果转换成NumPy数组kps_float = np.float32([kp.pt for kp in kps])# kp.pt 包含两个值，分别是关键点在图像中的 x 和 y 坐标。这些坐标通常是浮点数，可以精确地描述关键点在图像中的位置。return (kps, kps_float, des)  # 返回特征点集，及对应的描述特征
'''读取拼接图片'''
imageA = cv2.imread("1.jpg")
cv_show('imageA', imageA)
imageB = cv2.imread("2.jpg")
cv_show('imageB', imageB)
'''计算图片特征点及描述符'''
(kpsA, kps_floatA, desA) = detectAndDescribe(imageA)
(kpsB, kps_floatB, desB) = detectAndDescribe(imageB)
'''建立暴力匹配器BFMatcher，在匹配大型训练集合时使用FlannBasedMatcher速度更快。'''
matcher = cv2.BFMatcher()
# knnMatch(queryDescriptors, trainDescriptors, k, mask=None, compactResult=None)
# 使用KNN检测来自A、B图的SIFT特征匹配对，参数说明：
# queryDescriptors：匹配图像A的描述符
# trainDescriptors：匹配图像B的描述符
# k：最佳匹配的描述符个数。一般K=2。
# 返回的数据结构描述：
# distance：匹配的特征点描述符的欧式距离，数值越小也就说明俩个特征点越相近。
# queryIdx：测试图像的特征点描述符的下标（第几个特征点描述符），同时也是描述符对应特征点的下标。
# trainIdx：样本图像的特征点描述符下标, 同时也是描述符对应特征点的下标。
rawMatches = matcher.knnMatch(desB, desA, 2)
good = []
matches = []
for m in rawMatches:# 当最近距离跟次近距离的比值小于0.65值时，保留此匹配对if len(m) == 2 and m[0].distance < 0.65 * m[1].distance:good.append(m)# 存储两个点在featuresA, featuresB中的索引值matches.append((m[0].queryIdx, m[0].trainIdx))
# print(len(good))
# print(matches)# drawMatchesKnn(img1, keypoints1, img2, keypoints2, matches1to2, outImg, matchColor=None, singlePointColor=None, matchesMask=None, flags=None)绘制匹配图片
# 参数：img1：第一张原始图像。
# keypoints1：第一张原始图像的关键点。
# img2：第二张原始图像。
# keypoints2：第二张原始图像的关键点。
# matches1to2：从第一个图像到第二个图像的匹配，这意味着keypoints1[i]在keypoints2[Matches[i]中有一个对应的点。
# outImg：绘制结果图像。
# matchColor：匹配连线与关键点点的颜色，当matchColor == Scalar::all(-1)时，代表取随机颜色。
# singlePointColor：没有匹配项的关键点的颜色，当singlePointColor == Scalar::all(-1)时，代表取随机颜色。
# matchesMask：确定绘制哪些匹配项的掩码。如果掩码为空，则绘制所有匹配项。
# flags：绘图功能的一些标志。具体有：
#   cv.DRAW_MATCHES_FLAGS_DEFAULT
#   cv.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS
#   cv.DRAW_MATCHES_FLAGS_DRAW_OVER_OUTIMG
#   cv.DRAW_MATCHES_FLAGS_NOT_DRAW_SINGLE_POINTS
vis = cv2.drawMatchesKnn(imageB, kpsB, imageA, kpsA, good, None,flags=cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS)
cv_show("Keypoint Matches", vis)'''透视变换'''
if len(matches) > 4:  # 当筛选后的匹配对大于4时，计算视角变换矩阵。# 获取匹配对的点坐标ptsB = np.float32([kps_floatB[i] for (i, _) in matches])  # matches是通过阈值筛选之后的特征点对象，ptsA = np.float32([kps_floatA[i] for (_, i) in matches])  # kps_floatA是图片A中的全部特征点坐标# 计算透视变换矩阵# findHomography(srcPoints, dstPoints, method=None, ransacReprojThreshold=None, mask=None, maxIters=None,confidence=None)# 计算视角变换矩阵，透视变换函数，与cv2.getPerspectiveTransform()的区别在与可多个数据点变换# 参数srcPoints：图片A的匹配点坐标# 参数dstPoints：图片B的匹配点坐标# 参数method：计算变换矩阵的方法。#   0 – 使用所有的点，最小二乘#   RANSAC – 基于随机样本一致性，见 https://zhuanlan.zhihu.com/p/402727549#   LMEDS – 最小中值#   RHO –基于渐近样本一致性# ransacReprojThreshold：最大允许重投影错误阈值。该参数只有在method参数为RANSAC与RHO的时启用，默认为3# 返回值：中H为变换矩阵，mask是掩模标志,指示哪些点对是内点，哪些是外点。 内点：指那些与估计的模型非常接近的数据点，通常是正确匹配或真实数据。  外点：指那些与估计的模型不一致的数据点，通常是噪声、错误匹配或其他异常值。(H, mask) = cv2.findHomography(ptsB, ptsA, cv2.RANSAC, 10)
else:print('图片未找到4个以上的匹配点')sys.exit()result = cv2.warpPerspective(imageB, H, (imageB.shape[1] + imageA.shape[1], imageB.shape[0]))
cv_show('resultB', result)
# 将图片A传入result图片最左端
result[0:imageA.shape[0], 0:imageA.shape[1]] = imageA
cv_show('result', result)

二·答题卡识别

逻辑

1. 导入必要的库和定义全局变量

python

import numpy as np
import cv2
ANSWER_KEY = {0: 1, 1: 4, 2: 0, 3: 3, 4: 1}  

导入numpy和cv2库，分别用于数值计算和图像处理。定义ANSWER_KEY字典，存储正确答案。

2. 定义辅助函数

order_points函数

python

def order_points(pts):  rect = np.zeros((4, 2), dtype="float32")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

该函数对输入的四个点进行排序，确定它们分别是左上角、右上角、右下角和左下角的点。通过计算点坐标的和与差来找到对应的位置。

four_point_transform函数

python

def four_point_transform(image, pts):  rect = order_points(pts)  (tl, tr, br, bl) = rectwidthA = 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  

该函数对输入图像进行透视变换。首先调用order_points函数对四个点进行排序，然后计算变换后图像的宽度和高度，定义目标点的坐标，计算透视变换矩阵M，并应用该矩阵对图像进行变换，返回变换后的图像。

sort_contours函数

python

def sort_contours(cnts, method="left-to-right"):  reverse = Falsei = 0if method == "right-to-left" or method == "bottom-to-top":reverse = Trueif method == "top-to-bottom" or method == "bottom-to-top":i = 1boundingBoxes = [cv2.boundingRect(c) for c in cnts](cnts, boundingBoxes) = zip(*sorted(zip(cnts, boundingBoxes),key=lambda b: b[1][i], reverse=reverse))return cnts, boundingBoxes

该函数根据指定的方法（如从左到右、从上到下等）对轮廓进行排序。通过计算轮廓的外接矩形，并根据外接矩形的指定维度（x或y坐标）进行排序。

cv_show函数

python

def cv_show(name, img):cv2.imshow(name, img)cv2.waitKey(0)

用于显示图像，接受窗口名称name和要显示的图像img，并等待用户按键关闭窗口。

3. 图像预处理

python

image = cv2.imread(r'./images/test_01.png')
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)

• 读取图像，并复制一份用于绘制轮廓。
• 将彩色图像转换为灰度图像。
• 使用高斯模糊平滑图像，以减少噪声。
• 使用 Canny 边缘检测算法检测图像边缘。

4. 轮廓检测与答题卡定位

python

cnts = cv2.findContours(edged.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)[-2]
cv2.drawContours(contours_img, cnts, -1, (0, 0, 255), 3)
cv_show('contours_img', contours_img)
docCnt = Nonecnts = 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:docCnt = approxbreak

• 查找图像中的所有轮廓，并在复制的图像上绘制轮廓。
• 根据轮廓面积对轮廓进行排序，从大到小遍历轮廓。
• 对每个轮廓进行近似，当近似轮廓的顶点数为 4 时，认为找到了答题卡的轮廓。

5. 透视变换与阈值处理

python

warped_t = four_point_transform(image, docCnt.reshape(4, 2))
warped_new=warped_t.copy()
cv_show('warped', warped_t)warped = cv2.cvtColor(warped_t, cv2.COLOR_BGR2GRAY)thresh = cv2.threshold(warped, 0, 255,cv2.THRESH_BINARY_INV | cv2.THRESH_OTSU)[1]
cv_show('thresh', thresh)

• 对原图像进行透视变换，得到校正后的图像。
• 将校正后的图像转换为灰度图像，并进行阈值处理，使用cv2.THRESH_BINARY_INV | cv2.THRESH_OTSU自动确定阈值并进行反向二值化。

6. 答案区域检测与判断

python

thresh_Contours = thresh.copy()
cnts = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)[1]
warped_Contours = cv2.drawContours(warped_t, cnts, -1, (0, 255, 0), 1)
cv_show('warped_Contours', warped_Contours)
questionCnts = []for c in cnts:  (x, y, w, h) = cv2.boundingRect(c)ar = w / float(h)if w >= 20 and h >= 20 and 0.9<= ar <= 1.1:questionCnts.append(c)
print(len(questionCnts))
questionCnts = sort_contours(questionCnts, method="top-to-bottom")[0]
correct = 0
for (q, i) in enumerate(np.arange(0, len(questionCnts), 5)):cnts = sort_contours(questionCnts[i:i + 5])[0]  bubbled = Nonefor (j, c) in enumerate(cnts):mask = np.zeros(thresh.shape, dtype="uint8")cv2.drawContours(mask, [c], -1, 255, -1)  cv_show('mask', mask)thresh_mask_and = cv2.bitwise_and(thresh, thresh, mask=mask)cv_show('thresh_mask_and', thresh_mask_and)total = cv2.countNonZero(thresh_mask_and)  if bubbled is None or total > bubbled[0]:  bubbled = (total, j)color = (0, 0, 255)k = ANSWER_KEY[q]if k == bubbled[1]:  color = (0, 255, 0)correct += 1cv2.drawContours(warped_new, [cnts[k]], -1, color, 3)  cv_show('warpeding', warped_new)
score = (correct / 5.0) * 100
print("[INFO] score: {:.2f}%".format(score))
cv2.putText(warped_new, "{:.2f}%".format(score), (10, 30),cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 0, 255), 2)

• 查找阈值图像中的轮廓，筛选出符合条件（面积和宽高比）的轮廓，认为是答案选项的轮廓。
• 对答案选项轮廓按从上到下排序，每 5 个轮廓为一组，对应一道题目。
• 对于每组轮廓，通过创建掩膜并与阈值图像进行与运算，统计非零像素数来确定被选中的答案选项。
• 将选中的答案与正确答案对比，统计正确数量，并在图像上绘制结果（正确为绿色，错误为红色）。
• 计算得分并在图像上显示。

7. 结果显示

python

cv2.imshow("Original", image)
cv2.imshow("Exam", warped_new)
cv2.waitKey(0)

显示原始图像和批改后的图像。

作业提示分析

作业要求实现抠图，例如抠出图片中的手机、猫、狗等物体。可以按照以下步骤：

1. 轮廓检测：使用类似代码中的轮廓检测方法，如cv2.findContours，检测出目标物体的轮廓。
2. 创建轮廓 mask：根据检测到的轮廓，使用cv2.drawContours创建一个掩膜图像，将目标物体区域填充为白色（255），其余区域为黑色（0）。
3. 与运算实现抠图：将原始图像与掩膜图像进行cv2.bitwise_and运算，这样就可以只保留目标物体区域的图像，实现抠图效果。例如：

python

# 假设已经检测到目标轮廓并创建了mask
mask = np.zeros(image.shape[:2], dtype='uint8')
cv2.drawContours(mask, [target_contour], -1, 255, -1)
cropped = cv2.bitwise_and(image, image, mask=mask)
cv_show('Cropped', cropped)

整体来看，这段代码结构清晰，逐步实现了答题卡图像的处理和答案批改功能。通过对代码的理解，可以按照作业提示进一步实现抠图功能

代码

# 导入工具包
import numpy as np
import cv2
ANSWER_KEY = {0: 1, 1: 4, 2: 0, 3: 3, 4: 1}  # 正确答案
def order_points(pts):  # 找出4个坐标位置rect = np.zeros((4, 2), dtype="float32")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)  # 找出4个坐标位置(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"):  # 对轮廓进行排序reverse = Falsei = 0if method == "right-to-left" or method == "bottom-to-top":reverse = Trueif method == "top-to-bottom" or method == "bottom-to-top":i = 1boundingBoxes = [cv2.boundingRect(c) 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)# 预处理
image = cv2.imread(r'./images/test_01.png')
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)[-2]
cv2.drawContours(contours_img, cnts, -1, (0, 0, 255), 3)
cv_show('contours_img', contours_img)
docCnt = None# 根据轮廓大小进行排序，准备透视变换
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:docCnt = approxbreak
# 执行透视变换
warped_t = four_point_transform(image, docCnt.reshape(4, 2))
warped_new=warped_t.copy()
cv_show('warped', warped_t)warped = cv2.cvtColor(warped_t, cv2.COLOR_BGR2GRAY)# 阈值处理
thresh = cv2.threshold(warped, 0, 255,cv2.THRESH_BINARY_INV | cv2.THRESH_OTSU)[1]
cv_show('thresh', thresh)
thresh_Contours = thresh.copy()
# 找到每一个圆圈轮廓
cnts = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)[1]
warped_Contours = cv2.drawContours(warped_t, cnts, -1, (0, 255, 0), 1)
cv_show('warped_Contours', warped_Contours)
questionCnts = []for c in cnts:  # 遍历轮廓并计算比例和大小(x, y, w, h) = cv2.boundingRect(c)ar = w / float(h)# 根据实际情况指定标准if w >= 20 and h >= 20 and 0.9<= ar <= 1.1:questionCnts.append(c)
print(len(questionCnts))
# 按照从上到下进行排序
questionCnts = sort_contours(questionCnts, method="top-to-bottom")[0]
correct = 0
# 每排有5个选项
for (q, i) in enumerate(np.arange(0, len(questionCnts), 5)):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）进行“与”操作，只保留mask位置中的内容thresh_mask_and = cv2.bitwise_and(thresh, thresh, mask=mask)cv_show('thresh_mask_and', thresh_mask_and)total = cv2.countNonZero(thresh_mask_and)  # 统计灰度值不为0的像素数if bubbled is None or total > bubbled[0]:  # 通过阈值判断，保存灰度值最大的序号bubbled = (total, j)# 对比正确答案color = (0, 0, 255)k = ANSWER_KEY[q]if k == bubbled[1]:  # 判断正确color = (0, 255, 0)correct += 1cv2.drawContours(warped_new, [cnts[k]], -1, color, 3)  # 绘图cv_show('warpeding', warped_new)
score = (correct / 5.0) * 100
print("[INFO] score: {:.2f}%".format(score))
cv2.putText(warped_new, "{:.2f}%".format(score), (10, 30),cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 0, 255), 2)
cv2.imshow("Original", image)
cv2.imshow("Exam", warped_new)
cv2.waitKey(0)# 作业：实现抠图，比如抠出图片中的手机、猫、狗.....  创建一个轮廓mask，通过与运算实现抠图