Opencv实战:答题卡自动识别与评分系统(含完整代码解析)

Opencv实战:答题卡自动识别与评分系统(附完整代码解析) 本文详细介绍了如何使用OpenCV实现答题卡自动识别与评分系统,包含完整的代码解析。通过图像预处理、边缘检测、透视变换和答案识别等关键技术,系统能够快速准确地完成阅卷工作,适用于学校考试、资格认证等多种场景,大幅提升工作效率。 阅读详情

1. 从零开始:为什么你需要一个自己的答题卡识别系统?

我猜点开这篇文章的你,可能是一位正在做课程设计的计算机专业学生,也可能是一位想给学校或培训机构开发个小工具的开发者,甚至可能是一位对图像处理感兴趣的编程爱好者。不管你是谁,当你面对一沓厚厚的答题卡,需要手动批改、统计分数时,心里一定想过:“这活儿能不能让电脑来干?”

答案是肯定的,而且实现起来比你想象的要简单。今天,我就带你用 OpenCV 这个强大的计算机视觉库,从零开始手把手搭建一个答题卡自动识别与评分系统。这个系统能做什么呢?简单来说,你只需要用手机或扫描仪拍一张填涂好的答题卡照片,程序就能自动识别出每道题学生选了哪个选项,然后对照标准答案一键算出分数,最后还能把结果和批改痕迹可视化地展示出来。整个过程完全自动化,准确率还很高。

你可能在网上看过一些类似的教程,但很多要么讲得太理论,一堆数学公式让人头大;要么代码写得像天书,缺胳膊少腿,根本跑不起来。我当年自己摸索的时候也踩过不少坑,比如透视变换总是不准、圆圈轮廓找不全、答案匹配老是出错等等。所以这次,我决定写一篇真正“小白友好”的实战指南,不仅会把完整的、可运行的代码给你,还会把每一步的原理、为什么要这么做、以及我踩过的那些坑都讲清楚。我们的目标是:让你看完就能动手,跑通代码,理解原理,甚至能根据自己的答题卡样式进行修改和优化。

这个项目特别适合作为OpenCV的入门实战。它几乎涵盖了图像处理最核心的几个步骤:灰度化、滤波、边缘检测、轮廓查找、透视变换、阈值分割、轮廓分析。通过这一个项目,你能把OpenCV里最常用的函数和技巧串起来用一遍,效果立竿见影。好了,废话不多说,我们直接进入正题,先从准备工作开始。

2. 环境搭建与项目初始化:五分钟搞定开发环境

工欲善其事,必先利其器。第一步,我们得把“厨房”收拾好,把需要的“食材”和“工具”备齐。别担心,整个过程非常简单,我保证即使你是刚接触Python的新手,也能跟着一步步完成。

2.1 安装Python与必备库

首先,你需要一个Python环境。我强烈推荐使用 Python 3.7 或更高的版本,太老的版本可能会遇到一些库的兼容性问题。如果你还没有安装Python,可以去官网下载安装包,记得安装时勾选“Add Python to PATH”这个选项,这样以后在命令行里用起来就方便了。

安装好Python之后,我们打开命令行工具(Windows上是CMD或PowerShell,Mac或Linux上是终端)。接下来,我们需要安装这个项目最核心的两个库:OpenCV 和 NumPy。

在命令行里,输入下面这行命令并回车:

pip install opencv-python numpy

pip 是Python的包管理工具,这行命令的意思就是让pip去帮我们把opencv-python(这是OpenCV的Python版本)和numpy(这是Python里做科学计算的基础库,OpenCV处理图像数据离不开它)下载并安装好。

安装过程可能会持续一两分钟,取决于你的网速。安装成功后,你可以验证一下。在命令行里输入python进入Python交互环境,然后分别输入import cv2和import numpy,如果不报错,就说明安装成功了。

2.2 准备你的第一张答题卡图片

库装好了,我们还需要一张用来“练手”的答题卡图片。你可以自己用Word或PS做一个简单的模板,打印出来,用笔涂黑几个选项,再用手机拍张照。为了达到最好的识别效果,拍照时请注意这几点:

  1. 尽量正对着拍:手机镜头尽量垂直于答题卡平面,减少畸变。如果拍歪了也没关系,我们的程序里有透视变换步骤可以纠正,但正拍能减轻它的负担。
  2. 光线要均匀:避免在强光或阴影下拍摄,确保整个答题卡受光均匀,不要有反光点。光照不均会导致二值化效果很差。
  3. 背景要干净:最好把答题卡放在一个纯色(比如白色或黑色)的桌面上拍,避免背景中有复杂的纹理干扰轮廓查找。

我为你准备了一张标准的测试图片,它包含5道选择题,每道题有A、B、C、D、E五个选项。你可以先用这张图来测试,确保核心流程跑通后,再替换成自己的图片。把图片下载下来,放在你的项目文件夹里,我假设你把它命名为 test_answer_sheet.jpg。

2.3 创建项目文件与目录结构

现在,在你电脑上找一个合适的位置,新建一个文件夹,名字就叫 AnswerSheetScanner。然后在这个文件夹里,创建一个Python脚本文件,比如叫 scanner.py。我们所有的代码都将写在这个文件里。

为了管理方便,我建议你的文件夹结构是这样的:

AnswerSheetScanner/
├── scanner.py          # 主程序文件
├── test_answer_sheet.jpg # 测试用的答题卡图片
└── utils.py            # (可选)后期可以放一些自定义的函数,比如排序函数

好了,环境已经就绪,图片也已备好,我们的“厨房”可以开火了。接下来,我们就进入最核心的图像处理环节。

3. 图像预处理:把“歪歪扭扭”的图片变成“规规矩矩”的扫描件

拿到一张用手机拍摄的答题卡图片,它很可能是不规则的——有透视畸变(看起来是梯形)、有阴影、有噪点。预处理的目的,就是把这些“不合格”的原始图像,转换成一张干净、方正、只包含黑白信息的“标准扫描件”,为后续的精确识别打下坚实基础。这个过程就像在洗菜、切菜,是做出好菜的关键前提。

3.1 灰度化与降噪:剥离颜色,突出轮廓

我们首先读取图片。在 scanner.py 文件的开头,写入以下代码:

import cv2
import numpy as np

# 读取图像
image = cv2.imread('test_answer_sheet.jpg')
# 复制一份原图,用于最后绘制结果
original = image.copy()

cv2.imread 函数读进来的图片,在OpenCV里是以BGR(蓝-绿-红)通道顺序存储的,这是一个需要注意的小细节。彩色图片包含的信息太多,对于识别轮廓来说,颜色信息反而是干扰。所以第一步,我们把它转换成灰度图:

gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

cv2.cvtColor 是颜色空间转换函数,这里我们把BGR图转成了灰度图。灰度图只有一个通道,每个像素的值在0(黑)到255(白)之间,处理起来计算量小得多。

接下来是降噪。手机拍照难免会有噪点,这些随机的小白点或小黑点会在后续的边缘检测中产生大量虚假的边缘。我们用高斯模糊来平滑图像:

blurred = cv2.GaussianBlur(gray, (5, 5), 0)

cv2.GaussianBlur 是高斯滤波函数。第二个参数 (5, 5) 是卷积核的大小,必须是正奇数。数字越大,模糊效果越强。第三个参数 0 是标准差,设为0表示让OpenCV根据核大小自动计算。这一步能有效抑制噪点,让图像整体更平滑。你可以想象成给图片稍微加了一点“磨皮”效果。

3.2 边缘检测与答题卡轮廓提取:找到试卷的“边界”

降噪之后,我们就可以来寻找答题卡本身的轮廓了。我们的目标是找到那个最大的、代表整张答题卡边缘的矩形。这里用到的是经典的 Canny边缘检测 算法。

edged = cv2.Canny(blurred, 75, 200)

cv2.Canny 需要两个阈值参数:75 和 200。算法会找出梯度强度大于200的强边缘,和梯度强度在75到200之间的弱边缘,并且弱边缘只有在连接到强边缘时才会被保留。这两个值需要根据你的图片实际情况微调。如果图片对比度低,可以适当降低;如果背景杂乱,可以适当提高。执行完这一步,你会得到一张黑白图,白色线条就是检测到的边缘。

现在,我们从这些边缘中找出轮廓。轮廓可以理解为将边缘上连续的像素点连起来形成的曲线。

cnts, _ = cv2.findContours(edged.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

cv2.findContours 会在二值图像中查找轮廓。参数 cv2.RETR_EXTERNAL 表示只检测最外层的轮廓(我们只关心答题卡最外面的框)。cv2.CHAIN_APPROX_SIMPLE 是一种压缩存储方式,它只保留轮廓拐点的坐标,节省内存。函数返回一个轮廓列表 cnts。

我们需要从找到的所有轮廓中,筛选出那个面积最大的、并且有四个顶点的轮廓(我们假设答题卡是矩形的)。下面这个循环就是干这个的:

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)
        # 如果逼近后有4个顶点,就认为是我们要找的答题卡轮廓
        if len(approx) == 4:
            docCnt = approx
            break

这里用到了 cv2.approxPolyDP 函数,它用一条顶点更少的多边形来逼近轮廓。0.02 * peri 是一个精度参数,表示允许的最大误差,这里是周长的2%。这个值越小,逼近的多边形越接近原始轮廓。当我们找到一个有4个顶点的多边形时,就假定它是答题卡的四个角。如果没找到,那可能是图片太歪或者背景干扰太大,需要回头检查前面的步骤。

4. 透视变换与答案区域定位:把倾斜视图“掰正”

找到了答题卡的四个角点 docCnt,但它现在在图像中的位置可能是倾斜的、带透视效果的。想象一下你从侧面拍一本书,书在照片里是梯形的。透视变换就是把这个梯形“掰”回长方形的过程,得到一张标准的、正对着的俯视图。这一步至关重要,因为它保证了后续每个选项圆圈的位置是固定且可预测的。

4.1 实现四点透视变换

我们需要一个函数来实现这个变换。这个函数接收原始图像和四个角点坐标,返回校正后的图像。

def four_point_transform(image, pts):
    # 将四个点按照 左上、右上、右下、左下 的顺序排列
    rect = order_points(pts)
    (tl, tr, br, bl) = rect

    # 计算新图像的宽度:取底边和顶边的最大长度
    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

这里用到了一个辅助函数 order_points,它的作用是将乱序的四个点按照 左上、右上、右下、左下 的顺时针顺序排列。这是透视变换矩阵计算所要求的。这个函数的实现也很有意思,它利用了点的坐标和与差:

def order_points(pts):
    # 初始化一个4x2的坐标矩阵
    rect = np.zeros((4, 2), dtype="float32")
    # 求和:最左上角的点x+y最小,最右下角的点x+y最大
    s = pts.sum(axis=1)
    rect[0] = pts[np.argmin(s)]  # 左上
    rect[2] = pts[np.argmax(s)]  # 右下
    # 求差:右上角的点y-x最小,左下角的点y-x最大
    diff = np.diff(pts, axis=1)
    rect[1] = pts[np.argmin(diff)] # 右上
    rect[3] = pts[np.argmax(diff)] # 左下
    return rect

有了这两个函数,我们就可以对之前找到的灰度图 gray 进行变换了:

warped_gray = four_point_transform(gray, docCnt.reshape(4, 2))

现在,warped_gray 就是一张“摆正”了的灰度答题卡图像。你可以把它显示出来看看,是不是像一个扫描仪扫出来的效果。

4.2 二值化与二次轮廓检测:锁定每一个选项圆圈

图像摆正后,我们进入识别最核心的一步:找到每一个填涂答案的圆圈。首先,我们需要把灰度图转换成纯粹的黑白图(二值图),让前景(笔迹)和背景(纸张)彻底分开。

_, thresh = cv2.threshold(warped_gray, 0, 255, cv2.THRESH_BINARY_INV | cv2.THRESH_OTSU)

这里用了 cv2.threshold 进行阈值分割。THRESH_BINARY_INV 表示反向二值化,即把灰度值低于阈值的像素设为255(白色),高于阈值的设为0(黑色)。因为我们涂黑的选项在灰度图里颜色深(值小),我们希望它变成前景(白色)。THRESH_OTSU 是一种自动计算最佳阈值的方法,非常方便,尤其适用于前景和背景对比明显的图像。经过这一步,答题卡应该变成了白底黑字,但被涂黑的选项变成了白色块。

接下来,我们再次使用轮廓检测,这次的目标是图像中所有白色的连通区域,也就是所有可能的“圆圈”。

cnts, _ = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

这次我们会找到很多轮廓,包括题号、选项字母的轮廓,当然也包括我们想要的填涂圆圈轮廓。所以我们需要进行筛选。一个填涂的圆圈轮廓,通常具有以下特征:它近似于一个圆形(宽高比接近1),并且面积不能太小(排除噪点)。

注意:这里为什么不用霍夫圆检测?很多教程会提到霍夫变换找圆。但在实际答题卡识别中,学生涂卡可能超出圆圈范围,或者涂得不均匀,导致它不是一个完美的“圆”。霍夫变换对完美圆形敏感,对这种不规则形状反而不如轮廓检测灵活可靠。这是我踩过的一个坑,用轮廓检测加宽高比、面积筛选,鲁棒性要好得多。

筛选代码如下:

questionCnts = [] # 用来存放筛选出的圆圈轮廓
for c in cnts:
    # 获取轮廓的外接矩形
    (x, y, w, h) = cv2.boundingRect(c)
    ar = w / float(h) # 宽高比

    # 设定筛选条件:宽度和高度大于20像素(排除小噪点),宽高比在0.9到1.1之间(接近圆形)
    if w >= 20 and h >= 20 and ar >= 0.9 and ar <= 1.1:
        questionCnts.append(c)

经过这番筛选,questionCnts 列表里应该就只剩下代表选项圆圈的轮廓了。你可以把轮廓画在图像上看看,是不是每个涂黑的选项都被一个红圈圈出来了。

5. 答案匹配与自动评分:让程序当一回“阅卷老师”

找到了所有选项圆圈,现在我们需要做三件事:第一,把这些圆圈按照题目顺序(从上到下,从左到右)排好队;第二,判断每道题学生涂的是哪个选项;第三,和标准答案对比,计算分数。这是整个系统的“大脑”,逻辑性最强。

5.1 轮廓排序:把乱序的圆圈排成整齐的队列

轮廓检测找到的轮廓顺序是随机的,可能是先找到中间一个,再找到边上一个。我们必须把它们按照答题卡的实际布局排序。假设我们的答题卡有5行(5道题),每行5列(A, B, C, D, E五个选项)。那么排序规则是:先按纵坐标y从上到下排序(确定是哪道题),再在每一行内按横坐标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 # 如果按y轴排序,则用索引1

    # 为每个轮廓计算外接矩形
    boundingBoxes = [cv2.boundingRect(c) for c in cnts]
    # 使用lambda函数根据外接矩形的x或y坐标进行排序
    (cnts, boundingBoxes) = zip(*sorted(zip(cnts, boundingBoxes),
                                        key=lambda b: b[1][i], reverse=reverse))
    return cnts, boundingBoxes

这个函数非常灵活,可以指定按“从左到右”、“从上到下”等方式排序。我们首先对所有圆圈轮廓进行“从上到下”排序,把5道题分开。然后,对每一道题的5个选项轮廓,再进行“从左到右”排序,对应A, B, C, D, E。

5.2 判断填涂选项:用“掩膜”计算谁被涂黑了

排序之后,我们就可以按行遍历了。对于每一行(即每一道题),我们有5个排好序的轮廓,分别对应A到E。怎么判断学生涂了哪一个呢?这里用到了一个巧妙的图像处理技巧:掩膜(Mask)。

思路是这样的:对于当前题目的每一个选项轮廓,我们生成一个和答题卡二值图一样大小的全黑图像,然后只在这个轮廓内部填充白色,生成一个“面具”。把这个面具盖到二值图 thresh 上,由于二值图中被涂黑的选项区域是白色的,其他地方是黑色的,那么“面具”区域内在二值图上对应的白色像素点(即非零点)的数量,就代表了该选项被涂黑的“程度”。涂得越满,非零像素点就越多。

我们遍历5个选项,找到非零像素点最多的那个,就认为是学生选择的答案。

# 假设我们有一个标准答案字典,例如:第一题答案是B(索引1),第二题答案是E(索引4)...
ANSWER_KEY = {0: 1, 1: 4, 2: 0, 3: 3, 4: 1} # 格式:{题目索引: 正确答案索引}

correct = 0 # 初始化正确答案计数器
# 每道题有5个选项,所以步长为5
for (q, i) in enumerate(np.arange(0, len(questionCnts), 5)):
    # 取出当前题的5个选项轮廓,并从左到右排序
    cnts = sort_contours(questionCnts[i:i + 5], method="left-to-right")[0]

    bubbled = None # 用于记录当前题学生选择的答案(索引和像素数)

    # 遍历当前题的每一个选项(A, B, C, D, E)
    for (j, c) in enumerate(cnts):
        # 创建掩膜
        mask = np.zeros(thresh.shape, dtype="uint8")
        cv2.drawContours(mask, [c], -1, 255, -1) # -1表示填充轮廓内部为白色

        # 应用掩膜,并计算非零像素数量
        mask = cv2.bitwise_and(thresh, thresh, mask=mask)
        total = cv2.countNonZero(mask)

        # 如果这是第一个选项,或者当前选项的非零像素数比之前记录的最大值还大
        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 += 1 # 正确题数加1

    # 在图像上绘制轮廓,正确的画绿圈,错误的画红圈
    cv2.drawContours(warped, [cnts[k]], -1, color, 3)

这段代码是核心中的核心。它通过双层循环,精准地定位了每一道题、每一个选项,并通过计算像素点的方式做出了客观判断。你可能会问,如果学生没涂或者涂了两个怎么办?我们这个简单的逻辑会选择涂得最满的那个。在实际应用中,你可以增加一个阈值判断,比如 total 必须大于某个值(如500)才认为有涂卡,否则视为未作答;或者判断两个选项的 total 值是否非常接近,如果接近则标记为“疑似多选”。

5.3 计算分数与可视化输出

所有题目都判断完毕后,计算分数就很简单了:

# 计算得分
score = (correct / 5.0) * 100 # 假设总共5题
print(f"[INFO] 得分: {score:.2f}%")

# 将分数写在图片上
cv2.putText(warped, f"{score:.2f}%", (10, 30),
            cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 0, 255), 2)

# 显示最终结果
cv2.imshow("答题卡识别结果", warped)
cv2.waitKey(0)
cv2.destroyAllWindows()

cv2.putText 函数可以在图像上添加文字。这里我们把分数显示在图像的左上角。最后,cv2.imshow 会弹出一个窗口,展示最终的结果图。你会看到一张被“掰正”的答题卡,每道题的正确选项被绿色圆圈圈出,错误选项被红色圆圈圈出,左上角显示着本次考试的得分。

6. 完整代码整合与实战调优指南

前面我们分模块讲解了所有步骤,现在是时候把代码整合成一个完整的、可以运行的脚本了。同时,我也会分享一些在实际应用中可能遇到的问题和调优技巧,这些可是踩过坑才得来的经验。

6.1 完整的可运行代码

把前面所有的代码段按逻辑顺序组合起来,并加上必要的导入和函数定义,就得到了我们的完整识别脚本。为了清晰,我在这里再完整列出一遍,并加上详细的注释:

# scanner.py
import cv2
import numpy as np

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

def four_point_transform(image, pts):
    """执行四点透视变换"""
    rect = order_points(pts)
    (tl, tr, br, bl) = rect

    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 = 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]
    (cnts, boundingBoxes) = zip(*sorted(zip(cnts, boundingBoxes),
                                        key=lambda b: b[1][i], reverse=reverse))
    return cnts, boundingBoxes

# 主程序开始
# 1. 读取图像
image = cv2.imread('test_answer_sheet.jpg')
orig = image.copy()
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# 2. 预处理:高斯模糊和边缘检测
blurred = cv2.GaussianBlur(gray, (5, 5), 0)
edged = cv2.Canny(blurred, 75, 200)

# 3. 查找答题卡轮廓
cnts, _ = cv2.findContours(edged.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
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:
            docCnt = approx
            break

if docCnt is None:
    print("未找到答题卡轮廓!")
    exit()

# 4. 透视变换
warped = four_point_transform(gray, docCnt.reshape(4, 2))

# 5. 二值化
_, thresh = cv2.threshold(warped, 0, 255, cv2.THRESH_BINARY_INV | cv2.THRESH_OTSU)

# 6. 查找所有轮廓(选项圆圈)
cnts, _ = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
questionCnts = []
for c in cnts:
    (x, y, w, h) = cv2.boundingRect(c)
    ar = w / float(h)
    if w >= 20 and h >= 20 and ar >= 0.9 and ar <= 1.1:
        questionCnts.append(c)

if len(questionCnts) == 0:
    print("未找到任何选项圆圈!")
    exit()

# 7. 按从上到下排序所有圆圈轮廓
questionCnts = sort_contours(questionCnts, method="top-to-bottom")[0]

# 8. 定义标准答案 (题目索引: 正确答案索引,0=A, 1=B, 2=C, 3=D, 4=E)
ANSWER_KEY = {0: 1, 1: 4, 2: 0, 3: 3, 4: 1}

correct = 0
# 9. 遍历每一道题(每5个轮廓为一题)
for (q, i) in enumerate(np.arange(0, len(questionCnts), 5)):
    cnts = sort_contours(questionCnts[i:i + 5], method="left-to-right")[0]
    bubbled = None

    # 遍历当前题的每个选项
    for (j, c) in enumerate(cnts):
        mask = np.zeros(thresh.shape, dtype="uint8")
        cv2.drawContours(mask, [c], -1, 255, -1)
        mask = cv2.bitwise_and(thresh, thresh, mask=mask)
        total = cv2.countNonZero(mask)

        if bubbled is None or total > bubbled[0]:
            bubbled = (total, j)

    # 判断对错
    color = (0, 0, 255)
    k = ANSWER_KEY.get(q, -1)
    if k >= 0 and k == bubbled[1]:
        color = (0, 255, 0)
        correct += 1
    cv2.drawContours(warped, [cnts[k]], -1, color, 3)

# 10. 计算并显示分数
score = (correct / 5.0) * 100
print(f"[INFO] 得分: {score:.2f}%")
cv2.putText(warped, f"Score: {score:.2f}%", (10, 30),
            cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 0, 255), 2)

# 显示原图和结果图
cv2.imshow("Original", orig)
cv2.imshow("Processed", warped)
cv2.waitKey(0)

将这段代码保存为 scanner.py,把测试图片放在同目录下,运行它。如果一切顺利,你应该能看到两个窗口,一个显示原图,另一个显示批改后的结果图,并在控制台看到得分。

6.2 参数调优与常见问题解决

第一次运行很可能不会那么完美。别急,图像处理项目就是这样,需要根据你的具体图片进行“微调”。下面是我总结的几个关键调优点和常见问题:

  1. Canny边缘检测阈值(第2步):cv2.Canny(blurred, 75, 200) 中的 75 和 200。如果答题卡边框没被完整检测出来(边缘断开),尝试降低这两个值,比如 (50, 150)。如果背景噪声太多导致很多杂乱边缘,尝试提高这两个值。

  2. 轮廓近似精度(第3步):cv2.approxPolyDP(c, 0.02 * peri, True) 中的 0.02。这个值决定了多边形逼近的精度。如果因为答题卡边缘有破损或阴影导致找不到4个顶点的轮廓,可以适当放宽这个比例,比如调到 0.03 或 0.04。但注意,太大会把不规则图形也近似成四边形。

  3. 二值化阈值(第5步):我们使用了 THRESH_OTSU 自动阈值,在大多数光照均匀的情况下效果很好。但如果拍摄时光线很差,导致自动阈值不准,可以尝试手动指定一个阈值,比如 cv2.threshold(warped, 160, 255, cv2.THRESH_BINARY_INV),这里的 160 就是手动阈值,需要你根据图片反复试验。

  4. 圆圈轮廓筛选条件(第6步):if w >= 20 and h >= 20 and ar >= 0.9 and ar <= 1.1:。这里的 20 是像素大小,0.9 和 1.1 是宽高比范围。如果你的答题卡图片分辨率很高或很低,圆圈的实际像素大小会变,需要调整 20 这个值。如果学生涂卡严重超出圆形,导致轮廓变得不“圆”,可以适当放宽宽高比范围,比如 ar >= 0.8 and ar <= 1.2。

  5. 未找到答题卡轮廓:检查原图是否过于复杂,背景是否有其他矩形物体干扰。可以尝试在边缘检测前,先使用一个较大的高斯核(如(7,7))进行更强烈的模糊,或者使用形态学操作(如闭运算)连接断开的边缘。

  6. 选项识别错误:最常见的原因是二值化效果不好,导致涂卡区域没有被完整地变成白色。除了调整阈值,还可以在二值化后使用形态学操作,比如 cv2.dilate(膨胀)来填充涂卡区域内部的小空洞,让白色区域更连贯。

调试时,我强烈建议你在每个关键步骤后,都用 cv2.imshow() 把中间图像显示出来看看。比如显示 edged 看边缘检测效果,显示 thresh 看二值化效果,显示画了轮廓的图看圆圈是否被正确找到。眼见为实,这是定位问题最快的方法。

7. 扩展思路:让你的系统更健壮、更实用

一个能在理想条件下跑通的Demo只是第一步。要想把它变成一个真正实用的工具,还需要考虑更多现实因素。这里我分享几个扩展方向,你可以根据自己的需求进行尝试。

处理多张答题卡批量扫描:现在的程序一次只能处理一张图片。你可以很容易地把它改造成一个批量处理器。写一个循环,遍历某个文件夹下的所有答题卡图片,对每一张执行识别流程,然后把学号(可以从图片文件名提取)和得分保存到一个CSV文件或数据库里。这样就能一次性批改一个班的试卷了。

增加学号识别功能:真正的答题卡除了选项,还有考号填涂区。你可以用同样的思路,先定位到考号区域(通常是答题卡顶部或侧边的一排小格子),然后对每个数字位进行轮廓查找和排序。判断每个数字位下0-9哪个数字被涂黑,就能识别出考号。这相当于把一道“选择题”变成了很多道,逻辑是完全一样的。

支持不同样式的答题卡:我们的代码假设答题卡是5行5列。如果你的答题卡是20道题,每道题4个选项怎么办?很简单,修改两个地方:一是 ANSWER_KEY 字典的长度和内容;二是在遍历轮廓的循环中,把步长 5 改成每道题的选项数 4。更通用的做法是,在排序后,根据轮廓的总数动态计算出行数和列数。

部署为Web服务或桌面应用:用Flask或FastAPI可以快速将核心识别函数包装成一个HTTP API,前端上传图片,后端返回识别结果和批改后的图片。或者,你也可以用PyQt、Tkinter做一个带图形界面的桌面小工具,方便非技术人员使用。

提高识别鲁棒性:这是最考验功夫的地方。比如,如何处理折叠、污损的答题卡?可以尝试更先进的图像修复算法。如何应对各种奇怪的涂卡方式(打钩、打叉、涂一半)?可能需要引入机器学习模型来判断涂卡区域的特征,而不是简单的像素计数。如何从一堆纸中自动分割出单张答题卡?这可能需要用到更复杂的文档检测和分割技术。

这个项目就像一棵技能树的起点,从这里出发,你可以深入到计算机视觉的各个领域。图像预处理、特征提取、对象检测、甚至深度学习,都能在这里找到应用的场景。我最开始做这个项目时,只是为了省去手动批改的麻烦,但后来不断优化、扩展它的过程,让我对OpenCV和图像处理的理解加深了不止一个层次。希望它也能成为你探索视觉世界的一块有趣的敲门砖。代码就在那里,运行它,修改它,打破它,再修复它,这才是学习技术最有效的方式。

Python答题卡识别系统:从图像处理到自动评分 计算机视觉技术通过图像处理算法实现自动化识别,其核心原理包括边缘检测、轮廓分析和模式识别等。在教育信息化场景中,基于Python的OpenCV和NumPy等库开发的答题卡识别系统,能够有效解决传统人工阅卷效率低、易出错的问题。这类系统通常采用图像预处理、定位检测、选项识别和评分统计的流水线架构,结合自适应阈值和K-means聚类等算法,在保证处理速度的同时实现高准确率。典型应用覆盖学校考试、培训机构测验等场景,其中关键技术如霍夫变换和ROI缓存等工程实践方案,对开发类似自动化识别系统具有重要参考价值。 阅读详情

相关推荐

答题卡识别判卷——用Python和OpenCV实现(含完整代码)

答题卡识别判卷(Optical Mark Recognition, OMR)是一种在教育、调查等领域广泛应用的技术手段。它借助计算机视觉技术,能够自动且高效地读取答题卡上的答案信息,然后进行精准的判断和评分操作。

专注于人工智能、软件开发、工控自动化、工厂数字化及智能化等领域,希望和大家共同进步! 2839

从零开始的OpenCV实战-答题卡识别

答题卡识别是一个典型的“机器视觉”应用。其中,答题卡的样式可以是由自己来设置的,图片的获取方式提到了可以是“手机拍照、相机拍照”这种比较方便的方式;本例的一个特殊的要求是:你可以识别不出来,但是你不能识别错误,这是项目的特殊要求。本课程将围绕此进行全面展开。

基于OpenCV的答题卡识别系统:从图像预处理到自动评分

图像处理技术在现代文档数字化中扮演着关键角色,其中答题卡识别是计算机视觉领域的典型应用。传统方案依赖深度学习模型,但面对结构高度标准的答题卡,基于OpenCV的几何特征检测反而更具优势。核心流程包括图像预处理、透视矫正、轮廓检测与填涂区域定位。通过灰度化、高斯模糊、自适应阈值等操作去除干扰,利用透视变换解决拍摄角度倾斜问题,再借助轮廓提取锁定答案区域,最后基于像素统计完成填涂判定与评分。该方案无需GPU,在普通笔记本上即可流畅运行,准确率可满足商用需求,广泛适用于考试阅卷、问卷统计和表单识别等场景。本文详细

weixin_31458015的博客 330

opencv答题卡识别

基于opencv的答题卡识别,支持批量识别与注册登录功能。博客最后附有下载地址。 观看视频: 注册登录界面: 主界面: 答题卡图片: 识别结果: 代码部分: 主程序main.py import sys, cv2 from PyQt5.QtGui import * from PyQt5.QtWidgets import * from PyQt5.QtCore import * from untitled import Ui_Dialog from untitled2 import Ui_Dialog2

qq_45087786的博客 4181

基于OpenCV的答题卡识别判卷实战:透视矫正与轮廓检测全解析

图像处理技术在自动化考试阅卷中的应用日益广泛,OpenCV作为计算机视觉领域的经典工具库,提供了从图像预处理到目标识别的完整解决方案。通过灰度化、高斯滤波、Canny边缘检测等基础操作,可以清晰提取答题卡的外形轮廓;利用透视变换矫正扫描件的几何畸变,再结合轮廓过滤与像素统计,即可准确定位气泡填涂区域并完成自动判卷。这类技术不依赖OCR或深度学习模型,纯靠几何分析与图像阈值判断即可实现高效识别,适用于标准化考试、问卷统计等场景。本文以实际判卷项目为线索,深入解析轮廓检测、透视变换、二值化反相等核心技术,并讨论

weixin_29057065的博客 32

Python+OpenCV智能答题卡识别:从图像处理到自动阅卷的完整实现

计算机视觉作为人工智能的重要分支,通过模拟人类视觉系统,赋予计算机理解和处理图像信息的能力。其核心原理涉及图像采集、预处理、特征提取与模式识别等多个环节,在自动化、智能化领域具有极高的技术价值。典型的应用场景包括工业质检、安防监控、医疗影像分析以及文档自动化处理等。本文聚焦于文档自动化处理中的经典问题——答题卡识别,深入探讨如何利用OpenCV进行图像预处理、轮廓检测和透视变换等关键操作。通过自适应阈值分割和Canny边缘检测等技术,系统能够有效应对光照不均、图像倾斜等现实挑战,实现高精度的选项定位与填涂识

weixin_32501329的博客 311

答题卡识别系统(基于OpenCv)

OpenCv,Python,答题卡,计算机视觉,识别

2501_91882515的博客 2003

基于OpenCV与Python的摄像头答题卡实时识别项目实战解析

在机器视觉与图像处理领域,从证件扫描到表格识别,边缘检测和透视变换是两项核心基础技术。边缘检测能从复杂背景中提取目标轮廓,而透视变换则能校正因拍摄角度产生的几何畸变,两者结合是许多文档数字化应用的关键。摄像头实时识别相比扫描件方案,具备部署成本低、反馈即时的优势,尤其适合课堂教学、作业批改等动态场景。本文从图像预处理、轮廓定位、透视校正到选项像素统计,系统梳理了基于OpenCV与Python构建答题卡识别系统的完整技术链路,并针对光照不均、铅笔浅涂等实际问题给出了调参方案。通过本项目,开发者可以快速掌握图像

weixin_42571738的博客 282

OpenCV(十二)--答题卡自动识别

【代码】OpenCV(十二)--答题卡自动识别。

weixin_43856668的博客 1501

OpenCV+Django答题卡识别判分系统实战与参数调优

计算机视觉技术在教育信息化领域正发挥重要作用,其中答题卡自动识别与判分是典型应用。透视校正作为核心预处理步骤,通过边缘检测与轮廓提取,消除图像倾斜与几何畸变,确保后续选项坐标定位准确。图像二值化与形态学膨胀则用于分割填涂区域,结合阈值判定实现精准识别。利用Python生态中的OpenCV库,可高效实现这些图像处理算法。当与Django等Web框架及MySQL数据库结合时,可构建完整的在线判分系统,支持试卷管理、成绩统计和明细查询。围绕这一技术栈,从图像采集到数据库写入的完整链路中,透视变换参数调优、轮廓过滤

weixin_42601547的博客 124

matlab答题卡识别程序.zip_图像处理_答题卡识别

答题卡的识别,亲测可用,大家可以下载使用

基于OpenCV的答题卡自动识别与评分系统

答题卡的四个角点需要按左上→右上→右下→左下的顺序排列,否则透视变换会出错。s = pts.sum(axis=1) # 计算(x+y),左上角点(x+y)最小,右下角点最大rect[0] = pts[np.argmin(s)] # 左上rect[2] = pts[np.argmax(s)] # 右下diff = np.diff(pts, axis=1) # 计算(y-x),右上角点(y-x)最小(接近0),左下角点最大rect[1] = pts[np.argmin(diff)] # 右上。

cpluspluszz的博客 1379

Python+OpenCV答题卡图像识别与分数自动计算代码包,含多张测试样图和扫描处理示例

一套开箱即用的答题卡识别与判卷工具,基于Python和OpenCV实现,支持从普通拍照或扫描图像中定位答题卡区域、校正倾斜、识别填涂选项(如A/B/C/D),并按预设答案比对得出各题对错及总分。资源包内含8张不同光照、角度、清晰度的实测答题卡图片(test01.jpg至test04.png等),以及两个功能分层的主程序:sheet_scan_example01.py侧重基础轮廓检测与透视变换,sheet_scan_example02.py增加二值化优化、噪点过滤和填涂强度判断逻辑,适合教学演示、小规模考试快速阅卷或二次开发参考。运行环境仅需Python 3.6+、OpenCV 4.x及常用科学计算库,无需额外硬件或云服务。

案例:答题卡识别评分

本项目的核心价值的是“将计算机视觉基础技术串联落地”:透视变换解决畸变问题,轮廓排序匹配实际场景逻辑,掩码像素统计实现精准识别,这些技术可迁移到票据识别、试卷批改等同类场景。

sunxuehai1的博客 1020

基于matlab的车牌识别(含子程序)

基于matlab的车牌识别系统一、对车辆图像进行预处理1.载入车牌图像:function [d]=main(jpg) [filename, pathname] = uigetfile({'*.jpg', 'JPEG 文件(*.jpg)'}); if(filename == 0), return, end global FILENAME %定义全局变量 FILENAME = [pathname f...

TuTu998的博客 4万+

跟着团子学SAP CO:揭秘结果分析码在项目结算中的实战应用(一)KKA2/CJ88

本文深入解析了SAP CO模块中结果分析码在项目结算中的核心作用。以KKA2(方法10)和事务代码CJ88为例,详细阐述了如何在项目完工后一次性确认收入的场景下,通过结果分析功能实现收入与成本的精准匹配,将项目成本暂估为在制品,确保各期利润的准确反映。

gamma的博客 687

计算机视觉(opencv)实战二十四——扫描答题卡打分

import cv2ANSWER_KEY = {0: 1, 1: 4, 2: 0, 3: 3, 4: 1} # 正确答案NumPy:用于数组和数学运算(特别是点坐标计算)。OpenCV:用于图像处理。ANSWER_KEY:字典,表示每道题的正确选项。例如{0: 1}表示第0题的正确答案是第1个选项。通用性强:可处理拍照角度不同、大小不同的答题卡。鲁棒性高:通过轮廓筛选和涂黑面积统计,能抵抗一定程度的噪声。易扩展:可以轻松修改ANSWER_KEY,支持更多题目和多种题型。

2302_78022640的博客 2079

kaggle项目:纽约出租车行程时间NYC Taxi Trip Duration

纽约出租车形成时间预测(NYC Taxi Trip Duration)是Kaggle中的一个Playground竞赛。比赛数据集基于2016年纽约市黄色出租车行程记录数据,需要建立一个模型,根据单个行程属性,预测测试集中每次行程的持续时间。Kaggle项目模型XGBoost,评价指标RMSLE。

weixin_42113929的博客 2791

【转载】项目实战—答题卡识别判卷(十四)

本次我们将进行另一个实战项目,从本质上来讲,其与之前的卡片的数字识别基本上原理是一样的。 本次我们将使用的实验图片: 实现答题卡识别的7步  Step #1: 检测到图片中的答题卡  Step #2: 应用****变换来提取图中的答题卡(以自上向下的鸟瞰视图)  Step #3: 从****变换后的答题卡中提取 the set of 气泡/圆点 (答案选项)  Step #4: 将题目/气泡排序成行  Step #5: 判断每行中被标记/涂的答案  Step #6: 在我们

weixin_44237705的博客 813

绕过限制?实测修改UA在PC端运行微信小程序的可行性及风险

本文探讨了通过修改User-Agent(UA)在PC端运行微信小程序的技术可行性及风险。分析了小程序设备限制的技术原理,包括`wx.getSystemInfo`API和UA检测机制,并提供了多种修改方案及其局限性。同时强调了潜在的安全和法律风险,推荐使用官方模拟器或安卓模拟器等更安全的替代方案。

weixin_30879169的博客 368

无人机蜂群联合指挥作战技术详解

随着人工智能、通信技术、新材料等领域的不断进步,无人机蜂群联合指挥作战技术将迎来更加广阔的发展前景。未来,无人机蜂群将更加智能化、自主化,能够执行更加复杂、精细的作战任务。同时,加强国际合作,共同制定国际规则和标准,将是推动无人机蜂群技术健康发展的重要方向。无人机蜂群技术,是指通过先进的通信技术、自主导航与决策算法,将大量小型、低成本、功能各异的无人机组织成一个高度协同的群体,执行复杂多样的军事任务。2. 通信与数据链:采用高速、低延迟、抗干扰的通信技术,保障群体内无人机间的信息交换。

专注多旋翼、复合翼无人机技术研究,从事低空经济行业。 1546

计算机视觉opencv之答题卡识别

four_point_transform(image, pts)透视变换(拉直),这个也在透视变换中使用过,就是取出矩形边最大距离作为输出图像的宽高,并对目标定位,左上为原点(0,0),右下为(maxwidth-1,maxheight-1),然后进行矩阵变换,用源坐标(rect)和目标坐标(dst)计算单应性矩阵,进行投影矫正,这一函数总的来说就是将任意四边形区域变换为正矩形图。边界框是(x,y,w,h),i=0的时候,是x。i=1的时候,是y。预处理是为边缘检测准备的,逐渐增强图像的特征。

2201_75573294的博客 1005

ros2 gazebo仿真阿克曼小车搭载livox mid360雷达流程

流程简介:仿真环境的搭建需要安装ROS2和Gazebo。使用的是Humble版本,需要确认是否已经正确安装。然后是阿克曼小车模型的URDF,需要包括底盘、转向机构、驱动轮等,需要参考现有的阿克曼模型,比如ClearPath的Husky,但需要调整参数。Livox Mid360雷达在Gazebo中的仿真可能没有现成的插件,需要使用通用3D LiDAR插件来模拟。IMU的仿真相对简单,但需要注意噪声模型,以接近真实数据。

weixin_43802726的博客 3212

Python+OpenCV实现答题卡自动识别与评分系统

计算机视觉技术通过图像处理和模式识别实现自动化阅卷,其核心原理包括图像预处理、轮廓检测和透视变换等OpenCV关键技术。在教育信息化场景中,这种基于传统图像处理的轻量级方案相比深度学习方案具有部署成本低、实时性好的优势。以答题卡识别为例,系统通过Canny边缘检测定位答题区域,结合Otsu阈值分割实现填涂识别,平均处理耗时仅300ms且准确率超95%。该项目展示了如何用Python+OpenCV构建实用的计算机视觉应用,特别适合课堂测验等小规模自动评分场景。

weixin_29039773的博客 152

PCL 点云八叉树射线相交

PCL 点云八叉树射线相交

dayuhaitang1的博客 852

C#实现OPC客户端与S7-1200 PLC通信:工控场景稳定通信的实战指南(附完整代码)

标准化优先:OPC UA是工业通信的标准,相比直接通信,更适合多设备集成的工控场景;稳定性第一:必须封装断线重连、异常处理、资源释放逻辑,满足7×24小时运行需求;效率优化:高频采集场景优先用批量读写,避免单个变量频繁请求;细节把控:节点ID、变量类型、端口配置等细节是新手最容易踩坑的地方,建议先用UA Expert验证。这套代码和方案已在多个工业项目中落地,从单台S7-1200到多台S7-1200/1500集群,都能稳定运行。

这里只有干货:从 Modbus 通信到 MES 对接,从 YOLO 训练到工控机部署,带你搞定工业软件开发全流程。 1042
上一篇: PostgreSQL WAL 日志保留策略与性能优化实战指南
下一篇: 达梦数据库核心配置文件解析与实战调优指南
珊珊333333
博客等级 码龄17年 83粉丝 1375原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值