基于计算机视觉的试卷答题区表格识别与提取技术

基于计算机视觉的试卷答题区表格识别与提取技术

摘要

本文先容了一种基于计算机视觉技术的试卷答题区表格识别与提取算法。该算法能够自动从试卷图像中定位答题区表格，执行图像方向矫正，准确识别表格网格线，并提取每个答案单位格。本技术可广泛应用于教育测评、测验管理系统等场景，极大提高答卷处置惩罚效率。
关键技术

• 表格地区提取与分割
  
• 图像二值化预处置惩罚
  
• 多标准形态学利用
  
• 水平线与竖线准确检测
  
• 单位格定位与提取
  

1. 系统架构

我们设计的试卷答题区表格处置惩罚工具由以下重要模块组成：

• 答题区定位：从整张试卷图像中提取右上角的答题区表格
  
• 图像预处置惩罚：举行二值化、去噪等利用以增强表格线条
  
• 表格网格识别：准确检测水平线和竖线位置
  
• 单位格提取：根据网格线交点切割并生存各个答案单位格
  

处置惩罚流程：

1. 输入图像 -> 答题区定位 -> 方向矫正 -> 图像预处理 ->
2. 网格线检测 -> 单元格提取 -> 输出结果

复制代码

2. 焦点功能实现

2.1 答题区表格定位

我们假设答题区通常位于试卷右上角，起首提取该地区并应用表面检测算法：

1. # 提取右上角区域（答题区域通常在试卷右上角）
2. x_start = int(width * 0.6)
3. y_start = 0
4. w = width - x_start
5. h = int(height * 0.5)
7. # 提取区域
8. region = img[y_start:y_start + h, x_start:x_start + w]

复制代码

接着使用形态学利用提取线条并查找表格表面：

1. # 转为灰度图并二值化
2. gray = cv2.cvtColor(region, cv2.COLOR_BGR2GRAY)
3. binary = cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
4.                                cv2.THRESH_BINARY_INV, 11, 2)
6. # 使用形态学操作检测线条
7. horizontal_lines = cv2.morphologyEx(binary, cv2.MORPH_OPEN, kernel_h, iterations=2)
8. vertical_lines = cv2.morphologyEx(binary, cv2.MORPH_OPEN, kernel_v, iterations=2)

复制代码

2.2 图像预处置惩罚

为了增强表格线条特性，我们执行以下预处置惩罚步调：

1. # 高斯平滑去噪
2. blurred = cv2.GaussianBlur(gray, (5, 5), 0)
4. # 自适应阈值二值化
5. binary = cv2.adaptiveThreshold(
6.     blurred, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY_INV, 21, 5)
8. # 形态学操作填充小空隙
9. kernel = np.ones((3, 3), np.uint8)
10. binary = cv2.morphologyEx(binary, cv2.MORPH_CLOSE, kernel)

复制代码

2.3 表格网格线识别

这是本算法的焦点部门，我们分别检测水平线和竖线：
2.3.1 水平线检测

使用形态学开运算提取水平线，然后计算投影找到线条位置：

1. horizontal_kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (horizontal_size, 1))
2. horizontal_lines = cv2.morphologyEx(binary_image, cv2.MORPH_OPEN, horizontal_kernel, iterations=2)
4. # 提取水平线坐标 - 基于行投影
5. h_coords = []
6. h_projection = np.sum(horizontal_lines, axis=1)
7. for i in range(1, len(h_projection) - 1):
8.     if h_projection[i] > h_projection[i - 1] and h_projection[i] > h_projection[i + 1] and h_projection[i] > width // 5:
9.         h_coords.append(i)

复制代码

2.3.2 竖线检测

竖线检测采用多标准计谋，使用不同大小的结构元素，提高检测的鲁棒性：

1. # 使用不同大小的结构元素进行竖线检测
2. vertical_kernels = [
3.     cv2.getStructuringElement(cv2.MORPH_RECT, (1, (table_bottom - table_top) // 12)),  # 细线
4.     cv2.getStructuringElement(cv2.MORPH_RECT, (1, (table_bottom - table_top) // 8)),  # 中等
5.     cv2.getStructuringElement(cv2.MORPH_RECT, (1, (table_bottom - table_top) // 4))  # 粗线
6. ]
8. # 合并不同尺度的检测结果
9. vertical_lines = np.zeros_like(binary_image)
10. for kernel in vertical_kernels:
11.     v_lines = cv2.morphologyEx(binary_image, cv2.MORPH_OPEN, kernel, iterations=1)
12.     vertical_lines = cv2.bitwise_or(vertical_lines, v_lines)

复制代码

2.4 表格竖线位置准确校正

由于竖线检测大概存在偏左问题，我们实现了复杂的位置校正算法：

1. # 竖线位置修正：解决偏左问题 - 检测实际线条中心位置
2. v_coords_corrected = []
3. for idx, v_coord in enumerate(v_coords_detected):
4.     # 第2-11根竖线特殊处理
5.     if 1 <= idx <= 10:  # 第2-11根竖线
6.         search_range_left = 2  # 左侧搜索范围更小
7.         search_range_right = 12  # 右侧搜索范围大幅增大
8.     else:
9.         search_range_left = 5
10.         search_range_right = 5
11.    
12.     # 在搜索范围内找到峰值中心位置
13.     # 对于特定竖线，使用加权平均来偏向右侧
14.     if 1 <= idx <= 10:
15.         window = col_sum[left_bound:right_bound+1]
16.         weights = np.linspace(0.3, 2.0, len(window))  # 更强的右侧权重
17.         weighted_window = window * weights
18.         max_pos = left_bound + np.argmax(weighted_window)
19.         # 强制向右偏移
20.         max_pos += 3
21.     else:
22.         max_pos = left_bound + np.argmax(col_sum[left_bound:right_bound+1])

复制代码

2.4.1 不等间距网格处置惩罚

我们根据实际表格特点，处置惩罚了第一列宽度与其他列不同的环境：

1. # 设置第一列的宽度为其他列的1.3倍
2. first_column_width_ratio = 1.3
4. # 计算除第一列外每列的宽度
5. remaining_width = right_bound - left_bound
6. regular_column_width = remaining_width / (expected_vlines - 1 + (first_column_width_ratio - 1))

复制代码

2.5 单位格提取与生存

根据检测到的网格线，我们提取出每个单位格：

1. # 提取单元格的过程
2. cell_img = image[y1_m:y2_m, x1_m:x2_m].copy()
4. # 保存单元格图片
5. cell_filename = f'cell_0{q_num:02d}.png'
6. cell_path = os.path.join(output_dir, cell_filename)
7. cv2.imwrite(cell_path, cell_img)

复制代码

3. 技术创新点

• 多标准形态学利用：使用不同尺寸的结构元素检测竖线，提高了检测的鲁棒性
  
• 表格线位置动态校正：针对不同位置的竖线采用不同的校正计谋，解决了竖线偏左问题
  
• 不等间距网格处置惩罚：通过特殊计算处置惩罚第一列宽度不同的环境，更好地适应实际试卷样式
  
• 加权峰值搜索：使用加权计谋举行峰值搜索，提高了线条中心位置的准确性
  

4. 使用示例

4.1 根本用法

1. from image_processing import process_image
3. # 处理单张图像
4. input_image = "./images/1.jpg"
5. output_dir = "./output"
6. image_paths = process_image(input_image, output_dir)
8. print(f"处理成功: 共生成{len(image_paths)}个单元格图片")

复制代码

4.2 批量处置惩罚

我们还提供了批量处置惩罚多张试卷图像的功能：

1. # 批量处理目录中的所有图像
2. for img_file in image_files:
3.     img_path = os.path.join(images_dir, img_file)
4.     output_dir = os.path.join(output_base_dir, f"result_{img_name}")
5.     image_paths = process_image(img_path, output_dir)

复制代码

4.3 完整代码

1. """
2. 试卷答题区表格处理工具
3. 1. 从试卷提取答题区表格
4. 2. 对表格进行方向矫正
5. 3. 切割表格单元格并保存所有25道题的答案单元格
6. """
7. import os
8. import cv2
9. import numpy as np
10. import argparse
11. import sys
12. import time
13. import shutil
16. class AnswerSheetProcessor:
17.     """试卷答题区表格处理工具类"""
19.     def __init__(self):
20.         """初始化处理器"""
21.         pass
23.     def process(self, input_image_path, output_dir):
24.         """
25.         处理试卷答题区，提取表格并保存单元格
27.         Args:
28.             input_image_path: 输入图像路径
29.             output_dir: 输出单元格图像的目录
31.         Returns:
32.             处理后的图片路径列表，失败时返回空列表
33.         """
34.         os.makedirs(output_dir, exist_ok=True)
35.         temp_dir = os.path.join(os.path.dirname(output_dir), f"temp_{time.strftime('%Y%m%d_%H%M%S')}")
36.         os.makedirs(temp_dir, exist_ok=True)
38.         try:
39.             # 1. 提取答题区表格
40.             table_img, _ = self._extract_answer_table(input_image_path, temp_dir)
41.             if table_img is None:
42.                 print("无法提取答题区表格")
43.                 return []
45.             # 保存提取的原始表格图像
46.             # original_table_path = os.path.join(output_dir, "original_table.png")
47.             # cv2.imwrite(original_table_path, table_img)
49.             # 2. 矫正表格方向
50.             corrected_table = self._correct_table_orientation(table_img)
51.             # cv2.imwrite(os.path.join(output_dir, "corrected_table.png"), corrected_table)
53.             # 3. 提取表格单元格
54.             image_paths = self._process_and_save_cells(corrected_table, temp_dir, output_dir)
56.             # 4. 清理临时目录
57.             shutil.rmtree(temp_dir, ignore_errors=True)
58.             return image_paths
60.         except Exception as e:
61.             print(f"处理失败: {str(e)}")
62.             shutil.rmtree(temp_dir, ignore_errors=True)
63.             return []
65.     def _extract_answer_table(self, image, output_dir):
66.         """提取试卷答题区表格"""
67.         # 读取图像
68.         if isinstance(image, str):
69.             img = cv2.imread(image)
70.             if img is None:
71.                 return None, None
72.         else:
73.             img = image
75.         # 调整图像大小以提高处理速度
76.         max_width = 1500
77.         if img.shape[1] > max_width:
78.             scale = max_width / img.shape[1]
79.             img = cv2.resize(img, None, fx=scale, fy=scale)
81.         # 获取图像尺寸
82.         height, width = img.shape[:2]
84.         # 提取右上角区域（答题区域通常在试卷右上角）
85.         x_start = int(width * 0.6)
86.         y_start = 0
87.         w = width - x_start
88.         h = int(height * 0.5)
90.         # 提取区域
91.         region = img[y_start:y_start + h, x_start:x_start + w]
93.         # 转为灰度图并二值化
94.         gray = cv2.cvtColor(region, cv2.COLOR_BGR2GRAY)
95.         binary = cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
96.                                        cv2.THRESH_BINARY_INV, 11, 2)
98.         # 检测表格线
99.         kernel_h = cv2.getStructuringElement(cv2.MORPH_RECT, (max(25, w // 20), 1))
100.         kernel_v = cv2.getStructuringElement(cv2.MORPH_RECT, (1, max(25, h // 20)))
102.         horizontal_lines = cv2.morphologyEx(binary, cv2.MORPH_OPEN, kernel_h, iterations=2)
103.         vertical_lines = cv2.morphologyEx(binary, cv2.MORPH_OPEN, kernel_v, iterations=2)
105.         # 合并线条
106.         grid_lines = cv2.add(horizontal_lines, vertical_lines)
108.         # 膨胀线条
109.         kernel = np.ones((3, 3), np.uint8)
110.         dilated_lines = cv2.dilate(grid_lines, kernel, iterations=1)
112.         # 查找轮廓
113.         contours, _ = cv2.findContours(dilated_lines, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
115.         # 筛选可能的表格轮廓
116.         valid_contours = []
117.         for contour in contours:
118.             x, y, w, h = cv2.boundingRect(contour)
119.             area = cv2.contourArea(contour)
121.             if area < 1000:
122.                 continue
124.             aspect_ratio = float(w) / h if h > 0 else 0
125.             if 0.1 <= aspect_ratio <= 3.0:
126.                 valid_contours.append((x, y, w, h, area))
128.         if valid_contours:
129.             # 选择面积最大的轮廓
130.             valid_contours.sort(key=lambda c: c[4], reverse=True)
131.             x, y, w, h, _ = valid_contours[0]
133.             # 调整回原图坐标
134.             x_abs = x_start + x
135.             y_abs = y_start + y
137.             # 提取表格区域并加一些padding确保完整
138.             padding = 10
139.             x_abs = max(0, x_abs - padding)
140.             y_abs = max(0, y_abs - padding)
141.             w_padded = min(width - x_abs, w + 2 * padding)
142.             h_padded = min(height - y_abs, h + 2 * padding)
144.             table_region = img[y_abs:y_abs + h_padded, x_abs:x_abs + w_padded]
145.             return table_region, (x_abs, y_abs, w_padded, h_padded)
147.         # 如果未找到有效轮廓，返回预估区域
148.         x_start = int(width * 0.75)
149.         y_start = int(height * 0.15)
150.         w = int(width * 0.2)
151.         h = int(height * 0.4)
153.         x_start = max(0, min(x_start, width - 1))
154.         y_start = max(0, min(y_start, height - 1))
155.         w = min(width - x_start, w)
156.         h = min(height - y_start, h)
158.         return img[y_start:y_start + h, x_start:x_start + w], (x_start, y_start, w, h)
160.     def _correct_table_orientation(self, table_img):
161.         """矫正表格方向（逆时针旋转90度）"""
162.         if table_img is None:
163.             return None
164.         try:
165.             return cv2.rotate(table_img, cv2.ROTATE_90_COUNTERCLOCKWISE)
166.         except Exception as e:
167.             print(f"表格方向矫正失败: {str(e)}")
168.             return table_img
170.     def _process_and_save_cells(self, table_img, temp_dir, output_dir):
171.         """处理表格并保存单元格"""
172.         try:
173.             # 预处理图像
174.             binary = self._preprocess_image(table_img)
175.             # cv2.imwrite(os.path.join(output_dir, "binary_table.png"), binary)
177.             # 检测表格网格
178.             h_lines, v_lines = self._detect_table_cells(binary, table_img.shape, output_dir)
180.             # 如果未检测到足够的网格线
181.             if len(h_lines) < 2 or len(v_lines) < 2:
182.                 print("未检测到足够的表格线")
183.                 return []
185.             # 可视化并保存表格网格
186.             self._visualize_grid(table_img, h_lines, v_lines, output_dir)
188.             # 提取并直接保存单元格
189.             image_paths = self._extract_and_save_cells(table_img, h_lines, v_lines, output_dir)
190.             return image_paths
192.         except Exception as e:
193.             print(f"表格处理错误: {str(e)}")
194.             return []
196.     def _preprocess_image(self, image):
197.         """表格图像预处理"""
198.         if image is None:
199.             return None
201.         # 转为灰度图
202.         if len(image.shape) == 3:
203.             gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
204.         else:
205.             gray = image.copy()
207.         # 高斯平滑
208.         blurred = cv2.GaussianBlur(gray, (5, 5), 0)
210.         # 自适应阈值二值化
211.         binary = cv2.adaptiveThreshold(
212.             blurred, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY_INV, 21, 5)
214.         # 进行形态学操作，填充小空隙
215.         kernel = np.ones((3, 3), np.uint8)
216.         binary = cv2.morphologyEx(binary, cv2.MORPH_CLOSE, kernel)
218.         return binary
220.     def _detect_table_cells(self, binary_image, image_shape, output_dir):
221.         """检测表格网格，基于图像真实表格线精确定位"""
222.         height, width = image_shape[:2]
224.         # 1. 先检测水平线
225.         horizontal_size = width // 10
226.         horizontal_kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (horizontal_size, 1))
227.         horizontal_lines = cv2.morphologyEx(binary_image, cv2.MORPH_OPEN, horizontal_kernel, iterations=2)
228.         
229.         # 提取水平线坐标
230.         h_coords = []
231.         h_projection = np.sum(horizontal_lines, axis=1)
232.         for i in range(1, len(h_projection) - 1):
233.             if h_projection[i] > h_projection[i - 1] and h_projection[i] > h_projection[i + 1] and h_projection[
234.                 i] > width // 5:
235.                 h_coords.append(i)
237.         # 使用聚类合并相近的水平线
238.         h_coords = self._cluster_coordinates(h_coords, eps=height // 30)
240.         # 2. 确保我们至少有足够的水平线定义表格区域
241.         if len(h_coords) < 2:
242.             print("警告: 水平线检测不足，无法确定表格范围")
243.             h_lines = [(0, int(y), width, int(y)) for y in h_coords]
244.             v_lines = []
245.             return h_lines, v_lines
247.         # 获取表格垂直范围
248.         h_coords.sort()
249.         table_top = int(h_coords[0])
250.         table_bottom = int(h_coords[-1])
252.         # 3. 增强竖线检测 - 使用多尺度检测策略
253.         # 使用不同大小的结构元素进行竖线检测
254.         vertical_kernels = [
255.             cv2.getStructuringElement(cv2.MORPH_RECT, (1, (table_bottom - table_top) // 12)),  # 细线
256.             cv2.getStructuringElement(cv2.MORPH_RECT, (1, (table_bottom - table_top) // 8)),  # 中等
257.             cv2.getStructuringElement(cv2.MORPH_RECT, (1, (table_bottom - table_top) // 4))  # 粗线
258.         ]
260.         # 合并不同尺度的检测结果
261.         vertical_lines = np.zeros_like(binary_image)
262.         for kernel in vertical_kernels:
263.             v_lines = cv2.morphologyEx(binary_image, cv2.MORPH_OPEN, kernel, iterations=1)
264.             vertical_lines = cv2.bitwise_or(vertical_lines, v_lines)
266.         # 只关注表格区域内的竖线
267.         table_region_v = vertical_lines[table_top:table_bottom, :]
269.         # 计算列投影
270.         col_sum = np.sum(table_region_v, axis=0)
272.         # 4. 更精准地寻找竖线位置
273.         # 使用自适应阈值计算
274.         local_max_width = width // 25  # 更精细的局部最大值搜索窗口
275.         threshold_ratio = 0.15  # 降低阈值以捕获更多可能的竖线
277.         # 自适应阈值计算
278.         threshold = np.max(col_sum) * threshold_ratio
280.         # 扫描所有列查找峰值
281.         v_coords_raw = []
282.         i = 0
283.         while i < len(col_sum):
284.             # 查找局部范围内的峰值
285.             local_end = min(i + local_max_width, len(col_sum))
286.             local_peak = i
288.             # 找到局部最大值
289.             for j in range(i, local_end):
290.                 if col_sum[j] > col_sum[local_peak]:
291.                     local_peak = j
293.             # 如果局部最大值大于阈值，认为是竖线
294.             if col_sum[local_peak] > threshold:
295.                 v_coords_raw.append(local_peak)
296.                 # 跳过已处理的区域
297.                 i = local_peak + local_max_width // 2
298.             else:
299.                 i += 1
301.         # 5. 去除过于接近的竖线（可能是同一条线被重复检测）
302.         v_coords_detected = self._cluster_coordinates(v_coords_raw, eps=width // 50)  # 使用更小的合并阈值
304.         # 6. 检查找到的竖线数量
305.         expected_vlines = 15  # 预期应有15条竖线
306.         print(f"初步检测到竖线数量: {len(v_coords_detected)}")
308.         # 7. 处理识别结果
309.         if len(v_coords_detected) > 0:
310.             # 7.1 获取表格的左右边界
311.             v_coords_detected.sort()  # 确保按位置排序
312.             
313.             # 竖线位置修正：解决偏左问题 - 检测实际线条中心位置
314.             v_coords_corrected = []
315.             for idx, v_coord in enumerate(v_coords_detected):
316.                 # 在竖线坐标附近寻找准确的线条中心
317.                 # 对于第2-11根竖线，使用更大的搜索范围向右偏移
318.                 if 1 <= idx <= 10:  # 第2-11根竖线
319.                     search_range_left = 2  # 左侧搜索范围更小
320.                     search_range_right = 12  # 右侧搜索范围大幅增大
321.                 else:
322.                     search_range_left = 5
323.                     search_range_right = 5
324.                
325.                 left_bound = max(0, v_coord - search_range_left)
326.                 right_bound = min(width - 1, v_coord + search_range_right)
327.                
328.                 if left_bound < right_bound and left_bound < len(col_sum) and right_bound < len(col_sum):
329.                     # 在搜索范围内找到峰值中心位置
330.                     # 对于第2-11根竖线，使用加权平均来偏向右侧
331.                     if 1 <= idx <= 10:
332.                         # 计算加权平均，右侧权重更大
333.                         window = col_sum[left_bound:right_bound+1]
334.                         weights = np.linspace(0.3, 2.0, len(window))  # 更强的右侧权重
335.                         weighted_window = window * weights
336.                         max_pos = left_bound + np.argmax(weighted_window)
337.                         # 强制向右偏移2-3像素
338.                         max_pos += 3
339.                         max_pos = min(right_bound, max_pos)
340.                     else:
341.                         max_pos = left_bound + np.argmax(col_sum[left_bound:right_bound+1])
342.                     
343.                     v_coords_corrected.append(max_pos)
344.                 else:
345.                     v_coords_corrected.append(v_coord)
346.             
347.             # 使用修正后的坐标
348.             v_coords_detected = v_coords_corrected
349.             
350.             left_bound = v_coords_detected[0]  # 最左边的竖线
351.             right_bound = v_coords_detected[-1]  # 最右边的竖线
353.             # 7.2 计算理想的等距离竖线位置，但使第一列宽度比其他列宽
354.             ideal_vlines = []
355.             
356.             # 设置第一列的宽度为其他列的1.5倍
357.             first_column_width_ratio = 1.3
358.             
359.             # 计算除第一列外每列的宽度
360.             remaining_width = right_bound - left_bound
361.             regular_column_width = remaining_width / (expected_vlines - 1 + (first_column_width_ratio - 1))
362.             
363.             # 设置第一列
364.             ideal_vlines.append(int(left_bound))
365.             
366.             # 设置第二列位置
367.             ideal_vlines.append(int(left_bound + regular_column_width * first_column_width_ratio))
368.             
369.             # 设置剩余列
370.             for i in range(2, expected_vlines):
371.                 ideal_vlines.append(int(left_bound + regular_column_width * (i + (first_column_width_ratio - 1))))
373.             # 7.3 使用修正后的列位置
374.             v_coords = ideal_vlines
375.             
376.             # 进一步向右偏移第2-11根竖线（总共15根）
377.             for i in range(1, 11):
378.                 if i < len(v_coords):
379.                     v_coords[i] += 3  # 向右偏移3像素
380.         else:
381.             # 如果没有检测到竖线，使用预估等距离
382.             print("未检测到任何竖线，使用预估等距离")
383.             left_bound = width // 10
384.             right_bound = width * 9 // 10
386.             # 计算除第一列外每列的宽度
387.             first_column_width_ratio = 1.5
388.             remaining_width = right_bound - left_bound
389.             regular_column_width = remaining_width / (expected_vlines - 1 + (first_column_width_ratio - 1))
390.             
391.             # 设置列位置
392.             v_coords = []
393.             v_coords.append(int(left_bound))
394.             v_coords.append(int(left_bound + regular_column_width * first_column_width_ratio))
395.             
396.             for i in range(2, expected_vlines):
397.                 v_coords.append(int(left_bound + regular_column_width * (i + (first_column_width_ratio - 1))))
399.         # 8. 检验最终的竖线位置是否合理
400.         if len(v_coords) == expected_vlines:
401.             # 计算相邻竖线间距
402.             spacings = [v_coords[i + 1] - v_coords[i] for i in range(len(v_coords) - 1)]
403.             avg_spacing = sum(spacings[1:]) / len(spacings[1:])  # 不计入第一列的宽度
405.             # 检查是否有间距异常的竖线（除第一列外）
406.             for i in range(1, len(spacings)):
407.                 if abs(spacings[i] - avg_spacing) > avg_spacing * 0.2:  # 如果间距偏差超过20%
408.                     print(f"警告: 第{i + 1}和第{i + 2}竖线之间间距异常, 实际:{spacings[i]}, 平均:{avg_spacing}")
409.                     # 如果是最后一个间距异常，可能是最后一条竖线位置不准
410.                     if i == len(spacings) - 1:
411.                         v_coords[-1] = v_coords[-2] + int(avg_spacing)
412.                         print(f"修正最后一条竖线位置: {v_coords[-1]}")
414.         # 9. 转换为线段表示
415.         h_lines = [(0, int(y), width, int(y)) for y in h_coords]
416.         v_lines = [(int(x), int(table_top), int(x), int(table_bottom)) for x in v_coords]
418.         # 10. 强制补充缺失的水平线 - 期望有5条水平线（4行表格）
419.         if len(h_lines) < 5 and len(h_lines) >= 2:
420.             h_lines.sort(key=lambda x: x[1])
421.             top_y = int(h_lines[0][1])
422.             bottom_y = int(h_lines[-1][1])
423.             height_range = bottom_y - top_y
425.             # 计算应有的4等分位置
426.             expected_y_positions = [top_y + int(height_range * i / 4) for i in range(1, 4)]
428.             # 添加缺失的水平线
429.             new_h_lines = list(h_lines)
430.             for y_pos in expected_y_positions:
431.                 # 检查是否已存在接近该位置的线
432.                 exist = False
433.                 for line in h_lines:
434.                     if abs(line[1] - y_pos) < height // 20:
435.                         exist = True
436.                         break
438.                 if not exist:
439.                     new_h_lines.append((0, int(y_pos), width, int(y_pos)))
441.             h_lines = new_h_lines
443.         # 11. 最终排序
444.         h_lines = sorted(h_lines, key=lambda x: x[1])
445.         v_lines = sorted(v_lines, key=lambda x: x[0])
447.         print(f"最终水平线数量: {len(h_lines)}")
448.         print(f"最终竖线数量: {len(v_lines)}")
450.         # 12. 计算并打印竖线间距，用于检验均匀性
451.         if len(v_lines) > 1:
452.             spacings = []
453.             for i in range(len(v_lines) - 1):
454.                 spacing = v_lines[i + 1][0] - v_lines[i][0]
455.                 spacings.append(spacing)
457.             avg_spacing = sum(spacings[1:]) / len(spacings[1:])  # 不计入第一列的宽度
458.             print(f"竖线平均间距: {avg_spacing:.2f}像素")
459.             print(f"竖线间距: {spacings}")
461.         return h_lines, v_lines
463.     def _cluster_coordinates(self, coords, eps=10):
464.         """合并相近的坐标"""
465.         if not coords:
466.             return []
468.         coords = sorted(coords)
469.         clusters = []
470.         current_cluster = [coords[0]]
472.         for i in range(1, len(coords)):
473.             if coords[i] - coords[i - 1] <= eps:
474.                 current_cluster.append(coords[i])
475.             else:
476.                 clusters.append(int(sum(current_cluster) / len(current_cluster)))
477.                 current_cluster = [coords[i]]
479.         if current_cluster:
480.             clusters.append(int(sum(current_cluster) / len(current_cluster)))
481.         return clusters
483.     def _visualize_grid(self, image, h_lines, v_lines, output_dir):
484.         """可视化检测到的网格线并保存结果图像"""
485.         # 复制原图用于绘制
486.         result = image.copy()
487.         if len(result.shape) == 2:
488.             result = cv2.cvtColor(result, cv2.COLOR_GRAY2BGR)
490.         # 绘制水平线
491.         for line in h_lines:
492.             x1, y1, x2, y2 = line
493.             cv2.line(result, (int(x1), int(y1)), (int(x2), int(y2)), (0, 0, 255), 2)
495.         # 绘制垂直线
496.         for line in v_lines:
497.             x1, y1, x2, y2 = line
498.             cv2.line(result, (int(x1), int(y1)), (int(x2), int(y2)), (255, 0, 0), 2)
500.         # 绘制交点
501.         for h_line in h_lines:
502.             for v_line in v_lines:
503.                 y = h_line[1]
504.                 x = v_line[0]
505.                 cv2.circle(result, (int(x), int(y)), 3, (0, 255, 0), -1)
506.         
507.         # 只保存grid_on_image.png
508.         if output_dir:
509.             cv2.imwrite(os.path.join(output_dir, "grid_on_image.png"), result)
511.     def _extract_and_save_cells(self, image, h_lines, v_lines, output_dir, margin=3):
512.         """提取单元格并保存到输出目录"""
513.         height, width = image.shape[:2]
515.         # 确保线条按坐标排序
516.         h_lines = sorted(h_lines, key=lambda x: x[1])
517.         v_lines = sorted(v_lines, key=lambda x: x[0])
518.         # 保存图片路径
519.         image_paths = []
520.         # 检查线条数量是否足够
521.         if len(h_lines) < 4 or len(v_lines) < 10:
522.             print(f"警告: 线条数量不足(水平线={len(h_lines)}, 垂直线={len(v_lines)})")
523.             if len(h_lines) < 2 or len(v_lines) < 2:
524.                 print("错误: 线条数量太少，无法提取任何单元格")
525.                 return image_paths
527.         # 记录表格结构
528.         print(f"表格结构: {len(h_lines)}行, {len(v_lines) - 1}列")
530.         # 创建题号到行列索引的映射
531.         question_mapping = {}
533.         # 第2行是1-13题（列索引从1开始，0列是题号列）
534.         for i in range(1, 14):
535.             if i < len(v_lines):
536.                 question_mapping[i] = (1, i)
538.         # 第4行是14-25题（列索引从1开始，0列是题号列）
539.         for i in range(14, 26):
540.             col_idx = i - 13  # 14题对应第1列，15题对应第2列，...
541.             if col_idx < len(v_lines) and 3 < len(h_lines):
542.                 question_mapping[i] = (3, col_idx)
544.         # 提取每道题的单元格
545.         saved_questions = []
546.         for q_num in range(1, 26):
547.             if q_num not in question_mapping:
548.                 print(f"题号 {q_num} 没有对应的行列索引映射")
549.                 continue
551.             row_idx, col_idx = question_mapping[q_num]
553.             if row_idx >= len(h_lines) - 1 or col_idx >= len(v_lines) - 1:
554.                 print(f"题号 {q_num} 的行列索引 ({row_idx}, {col_idx}) 超出表格范围")
555.                 continue
557.             try:
558.                 # 获取单元格边界
559.                 x1 = int(v_lines[col_idx][0])
560.                 y1 = int(h_lines[row_idx][1])
561.                 x2 = int(v_lines[col_idx + 1][0])
562.                 y2 = int(h_lines[row_idx + 1][1])
564.                 # 打印单元格信息用于调试
565.                 if q_num in [1, 4, 13, 14, 25]:  # 打印关键单元格的位置信息
566.                     print(f"题号 {q_num} 单元格: x1={x1}, y1={y1}, x2={x2}, y2={y2}, 宽={x2 - x1}, 高={y2 - y1}")
568.                 # 添加边距，避免包含边框线
569.                 x1_m = min(width - 1, max(0, x1 + margin))
570.                 y1_m = min(height - 1, max(0, y1 + margin))
571.                 x2_m = max(0, min(width, x2 - margin))
572.                 y2_m = max(0, min(height, y2 - margin))
574.                 # 检查单元格尺寸
575.                 if x2_m <= x1_m or y2_m <= y1_m or (x2_m - x1_m) < 5 or (y2_m - y1_m) < 5:
576.                     print(f"跳过无效单元格: 题号 {q_num}, 尺寸过小")
577.                     continue
579.                 # 提取单元格
580.                 cell_img = image[y1_m:y2_m, x1_m:x2_m].copy()
582.                 # 检查单元格是否为空图像
583.                 if cell_img.size == 0 or cell_img.shape[0] == 0 or cell_img.shape[1] == 0:
584.                     print(f"跳过空单元格: 题号 {q_num}")
585.                     continue
587.                 # 保存单元格图片
588.                 cell_filename = f'cell_0{q_num:02d}.png'
589.                 cell_path = os.path.join(output_dir, cell_filename)
590.                 cv2.imwrite(cell_path, cell_img)
592.                 # 添加到路径列表和已保存题号列表
593.                 image_paths.append(cell_path)
594.                 saved_questions.append(q_num)
596.             except Exception as e:
597.                 print(f"提取题号 {q_num} 时出错: {str(e)}")
599.         print(f"已保存 {len(saved_questions)} 个单元格，题号: {sorted(saved_questions)}")
600.         return image_paths
603. def process_image(input_image_path, output_dir):
604.     """处理试卷答题区，提取表格并保存单元格"""
605.     processor = AnswerSheetProcessor()
606.     return processor.process(input_image_path, output_dir)
609. def main():
610.     """主函数：解析命令行参数并执行处理流程"""
611.     # 解析命令行参数
612.     parser = argparse.ArgumentParser(description='试卷答题区表格处理工具')
613.     parser.add_argument('--image', type=str, default="./images/12.jpg", help='输入图像路径')
614.     parser.add_argument('--output', type=str, default="./output", help='输出目录')
616.     args = parser.parse_args()
618.     # 检查图像是否存在
619.     if not os.path.exists(args.image):
620.         print(f"图像文件不存在: {args.image}")
621.         return 1
623.     # 确保输出目录存在
624.     os.makedirs(args.output, exist_ok=True)
626.     print(f"开始处理图像: {args.image}")
627.     print(f"输出目录: {args.output}")
629.     # 处理图像
630.     try:
631.         image_paths = process_image(args.image, args.output)
633.         if image_paths:
634.             print(f"处理成功: 共生成{len(image_paths)}个单元格图片")
635.             print(f"所有结果已保存到: {args.output}")
636.             return 0
637.         else:
638.             print("处理失败")
639.             return 1
640.     except Exception as e:
641.         print(f"处理过程中发生错误: {str(e)}")
642.         return 1
645. if __name__ == "__main__":
646.     sys.exit(main())

复制代码

5. 应用场景

• 测验批阅系统：大规模测验的答题卡批阅
  
• 教育测评平台：智能化教育测评系统
  
• 试卷数字化处置惩罚：将纸质试卷转换为电子数据
  
• 教学检测系统：快速评估学生答题环境
  

6. 算法结果展示

上图是测试的试卷图片，要求提取出填写的答题区。

上图展示了表格网格识别的结果，蓝色线条表现竖线，红色线条表现水平线，绿色点表现线条交点。

上图是从试卷中提取出的答案单位格。
7. 总结与展望

本文先容的试卷答题区表格识别技术，通过计算机视觉算法实现了高效准确的表格定位和单位格提取。该技术有以下优势：

• 高精度：采用多标准计谋和位置校正算法，提高了表格线识别的精度
  
• 高适应性：能够处置惩罚不同样式的试卷答题区
  
• 高效率：自动化处置惩罚流程大幅提高了试卷处置惩罚效率
  

将来我们将继承优化算法，提高对更复杂表格的识别本领，并连合OCR技术实现答案内容的自动识别。
参考资料

• OpenCV官方文档: https://docs.opencv.org/
  
• 数字图像处置惩罚 - 冈萨雷斯
  
• 计算机视觉：算法与应用 - Richard Szeliski
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

继续阅读请点击广告