做文档 OCR 的人第一次接触工程图纸,通常会低估难度。
身份证、发票、合同这类文档,信息载体就是字符本身,OCR 把字符读出来,任务基本完成。工程图纸不一样:一个 ⌀25±0.02,读出字符串只是第一步,真正有用的是知道它标注的是哪个几何要素、公差带多少、是基准还是被测项、和旁边哪个形位公差框格关联。这些信息一个都不在字符里,全在位置和几何关系里。
加上图纸本身的图像特性——线条细密、标注互相穿插、幅面从 A4 到 A0、来源可能是 CAD 原生 PDF 也可能是二次扫描件——直接套用文档 OCR 的流水线,效果往往不能看。
这篇聊聊这类场景下几个关键的工程权衡:高分辨率输入怎么处理、分块检测的 overlap 和 NMS 怎么调、检测和识别为什么应该用不同分辨率、以及在无 GPU 环境下怎么把吞吐做上去。文中代码是参考实现,用来讲清思路,不是某个产品的实际源码。
先看最直接的矛盾。
工程图纸上的公差字号通常远小于主尺寸。⌀25 可能字高 20 像素,紧跟其后的 ±0.02 可能只有 8 像素。A0 幅面扫描到 300 DPI,长边接近一万像素。
两个朴素方案都有问题:
整图缩放到模型输入尺寸(比如 1280×1280)。缩放比接近 8:1,那个 8 像素高的公差字直接糊成一团。检测框还能框出个大概,识别端拿到的是无法辨认的像素。这是大幅面图纸漏检小字号公差的主要原因——不是模型不行,是输入端信息就已经丢了。
整图按原始分辨率送入。显存或内存直接爆掉,即便勉强跑通,检测模型的有效感受野是固定的,在一张一万像素的图上,一个 8 像素的目标占比太小,特征金字塔的最低层也未必能有效响应。而且单图推理耗时会到不可接受的程度。
结论很明确:这两个需求本质上是冲突的,不能用同一个分辨率同时满足。
检测需要的是视野——看到整张图的布局,知道哪里有一组标注。识别需要的是精度——拿到足够多的像素来分辨 0 和 Ø、分辨小数点的位置。
思路是把流水线拆开,两个阶段各用各的分辨率。
这样检测阶段享受小图的内存和速度优势,识别阶段拿到的是无损的原始像素。
我在看的融新 AI 气泡图大师的更新说明里提到了这个思路:超大页面先缩放检测、识别仍用原始分辨率。这是大幅面图纸减少漏检比较对路的做法,比自己训练一个高分辨率大模型划算得多——后者成本高一个量级,收益还不一定更好。
参考实现:
python
import cv2
import numpy as np
def detect_lowres_recog_hires(img, det_scale=0.25, pad=8):
"""检测用缩放图,识别用原始分辨率裁剪"""
h, w = img.shape[:2]
# 缩小必须用 INTER_AREA,默认的 INTER_LINEAR 在小字号上会引入混叠
small = cv2.resize(img, None, fx=det_scale, fy=det_scale,
interpolation=cv2.INTER_AREA)
dets = detector(small) # 检测阶段:要视野
results = []
for box, cls, score in dets:
x1, y1, x2, y2 = [int(v / det_scale) for v in box]
# 外扩几个像素:检测框通常偏紧,识别端需要字符的完整笔画和留白
x1, y1 = max(x1 - pad, 0), max(y1 - pad, 0)
x2, y2 = min(x2 + pad, w), min(y2 + pad, h)
crop = img[y1:y2, x1:x2] # 识别阶段:要精度
text = recognizer(crop)
results.append({
"box": (x1, y1, x2, y2),
"cls": cls, "score": score, "text": text,
})
return results三个容易踩的细节:
缩放插值方式。 INTER_AREA 是区域平均,缩小图像时抗混叠效果最好。用默认的 INTER_LINEAR 或 INTER_NEAREST,细线条和小字号会出现明显混叠,检测召回率会掉。
pad 不能省。 检测框往往贴着字符边缘,识别模型(尤其是 CRNN 类)需要字符两侧有一定留白才能正确切分。8 像素是个常见起点,实际要按你的检测框松紧程度调。
坐标映射的取整误差会累积。 int(v / det_scale) 在不同 det_scale 下误差不同。如果后续要做尺寸界线与几何图元的交点计算,这几个像素的偏差会传导过去。建议映射时用浮点保留,只在最终裁剪时取整。
当图纸幅面更大、或者目标密度更高时,单纯缩放检测也不够了——缩放比太大,小目标还是会丢。这时候要在原始分辨率(或接近原始分辨率)上做分块检测。
python
def slice_image(img, tile=1280, overlap=128):
"""滑窗切片,返回 (裁剪图, 原图坐标偏移) 列表"""
h, w = img.shape[:2]
step = tile - overlap
tiles = []
for y in range(0, h, step):
for x in range(0, w, step):
x2, y2 = min(x + tile, w), min(y + tile, h)
tiles.append((img[y:y2, x:x2], (x, y)))
if x2 == w:
break
if y2 == h:
break
return tilesoverlap 的取值是个权衡:
经验值:overlap 设为你最小目标最长边的 1.5~2 倍。工程图纸上最小的有效目标通常是公差文字,宽度几十像素,所以 128~256 的 overlap 一般够用。
另外注意上面代码里的边界处理:最后一个块如果不足 tile 尺寸,不要 pad 黑边,直接用实际尺寸——pad 会在边缘引入假的梯度,检测模型可能在那里产生误报。
跨块重复检出要靠 NMS 合并,但这里有个陷阱。
标准 NMS 用一个统一的 IoU 阈值(常见 0.45~0.5)。问题是工程图纸上大量目标是细长的——尺寸线、尺寸界线、引线,长宽比可能到 20:1 甚至更高。两个平行的尺寸界线,间距只有几个像素,它们的 IoU 可能高达 0.6,标准 NMS 会把其中一条当重复框抑制掉。
反过来,两个真正重复的检出(同一目标在相邻块里各检出一次),因为框的位置略有偏移,IoU 可能只有 0.3,逃过了抑制,造成重复。
所以要按长宽比分别设阈值:
python
import numpy as np
def nms_by_aspect(boxes, scores,
iou_thr_normal=0.45, iou_thr_thin=0.15,
aspect_thr=6.0):
"""细长目标用更低的 IoU 阈值,避免相邻平行线被误合并"""
boxes = np.asarray(boxes, dtype=np.float32)
scores = np.asarray(scores, dtype=np.float32)
keep = []
order = scores.argsort()[::-1]
while order.size > 0:
i = order[0]
keep.append(i)
if order.size == 1:
break
x1 = np.maximum(boxes[i, 0], boxes[order[1:], 0])
y1 = np.maximum(boxes[i, 1], boxes[order[1:], 1])
x2 = np.minimum(boxes[i, 2], boxes[order[1:], 2])
y2 = np.minimum(boxes[i, 3], boxes[order[1:], 3])
inter = np.maximum(0, x2 - x1) * np.maximum(0, y2 - y1)
area_i = ((boxes[i, 2] - boxes[i, 0]) *
(boxes[i, 3] - boxes[i, 1]))
area_o = ((boxes[order[1:], 2] - boxes[order[1:], 0]) *
(boxes[order[1:], 3] - boxes[order[1:], 1]))
ious = inter / np.maximum(area_i + area_o - inter, 1e-6)
bw = boxes[i, 2] - boxes[i, 0]
bh = max(boxes[i, 3] - boxes[i, 1], 1e-6)
aspect = max(bw / bh, bh / bw)
thr = iou_thr_thin if aspect > aspect_thr else iou_thr_normal
order = order[1:][ious < thr]
return keepaspect_thr=6 是个起点。如果你的图纸上密集剖面线很多,可能需要降到 4,同时把 iou_thr_thin 提到 0.2 左右,否则剖面线会被大量误抑制。
NMS 解决的是"同一个目标被检出多次",但解决不了"同一个目标被切成两半,两半都没检出"。
对后者,实践中有效的做法是错相位二次切片:第一轮切片后,把整个网格平移 tile/2,再切一轮。这样第一轮里位于块边界的目标,在第二轮里大概率落在块中心。两轮结果合并后做一次 NMS。
代价是推理量翻倍。所以这是个可选优化,只在漏检集中在图幅边缘区域时才值得开。判断方法:把漏检目标的坐标画成散点图,如果明显聚集在 x % tile < overlap 的条带上,说明是边界切割导致的,该上错相位切片。
检测和识别都对了,输出仍然可能不能用。因为图纸上的字符串需要被解析成工程语义。
同样是"±0.02"的意思,图纸上的写法有很多种:
写法 | 含义 | 解析要点 |
|---|---|---|
⌀25±0.02 | 对称公差 | 上下偏差相同 |
⌀25 +0.02/-0.01 | 叠加公差 | 上下不同,顺序不能颠倒 |
⌀25H7 | 配合代号 | 需查国标公差表展开成具体数值 |
⌀25 (⌀24.98) | 括号内换算尺寸 | 括号值不是主尺寸 |
50 MAX / 50 MIN | 单向极限 | 只有一侧有约束 |
⌀25 REF | 参考尺寸 | 通常不作为检验项 |
4×⌀10 | 数量前缀 | 一处标注对应多个特征 |
叠加公差的顺序问题值得单独说。+0.02/-0.01 如果解析时把上下偏差存反了,输出的检测计划表里上下限就是错的。这个错误在表格上看不出来——两个数字都在,格式也对——只有回到图纸比对才能发现。而检验员按错误的上下限判定,会把合格件判成不合格,或者反过来。
所以上下偏差必须按图纸上的书写顺序保留,而不是按数值大小排序。这是个看起来很小、实际影响很大的实现细节。
配合代号展开需要查表。GB/T 1800.2-2020 定义了标准公差等级和基本偏差,H7 在 ⌀25 上对应具体的上下偏差值。如果产品内置了国标公差表,这一步可以自动化;否则要人工查表录入,很容易出错。
图纸上这两种写法长得几乎一样:
2-⌀10 表示 2 个直径 10 的孔(数量前缀)
⌀25-0.02 表示直径 25,下偏差 -0.02(有些图纸省略上偏差的 +0)那个连字符,在第一种里是数量分隔符,在第二种里是负号。如果一律当成负号解析,2-⌀10 会被读成"2 减 直径10"或者更糟的结果;如果一律当成分隔符,单向负偏差就丢了。
消解只能靠上下文规则:
python
import re
# 数量前缀:开头是数字,紧跟 - 或 ×,后面是几何符号+数值
QTY_PREFIX = re.compile(r'^(\d+)\s*[-×xX]\s*(.*)$')
# 几何符号集合
GEO_SYM = r'[⌀Ø∅R▁]'
def resolve_hyphen(raw: str) -> dict:
"""判定连字符是数量分隔符还是负偏差符号"""
s = raw.strip().replace(' ', '')
m = QTY_PREFIX.match(s)
if m:
qty, rest = int(m.group(1)), m.group(2)
# 连字符后面紧跟几何符号或数值 → 数量前缀
# 例如 "2-⌀10"、"6-R0.5"
if re.match(rf'^{GEO_SYM}?[\d.]', rest):
return {"qty": qty, "value_text": rest, "minus": False}
# 连字符出现在数值之后 → 更可能是下偏差
return {"qty": 1, "value_text": s, "minus": True}规则不算复杂,但必须显式处理。我见过的实现里,漏掉这一步会导致批量件的数量类标注全部解析异常——一张图上 4×⌀8、2-⌀12 这类写法可能有十几处,全错的话清单基本没法用。
顺带一提,直径符号也有类似问题:CAD 字体里的 %%C、Unicode 的 ⌀(U+2300)、Ø(U+00D8)、还有 OCR 容易混淆的 0 和 O,需要统一归一化后再进入解析,否则下游的正则全都要写好几个变体。
工程图纸上的文字不总是水平的。竖直方向的尺寸,文字可能是竖排;某些 CAD 模板下会出现 180° 倒置的文字(这是 CAD 标注样式为了"文字始终在尺寸线上方"而做的翻转);形位公差框格如果引线很长,框格文字可能被拉长排列。
识别前需要一个方向分类器。常见的做法是训练一个四分类(0°/90°/180°/270°)的轻量模型,或者对文本检测框做几何判断——如果框的长边是竖直的,先转 90° 再试识别,比较置信度。
倒置文字是个高频错误来源:0 转 180° 还是 0,6 转 180° 变成 9,+ 和 - 在某些字体下也难以区分。这类错误识别端给出的置信度往往还挺高,因为字形本身是合法的,只是值错了。
制造业现场的部署环境和互联网后端差别很大。很多工厂的服务器就是普通 PC,没有独立显卡,也不允许随便加装。所以纯 CPU 推理不是退路,是常态。
一个直觉的错误做法是用线程池并行跑多个块的推理:
python
# 反例:CPU 上这样做通常更慢
with ThreadPoolExecutor(max_workers=8) as pool:
dets = list(pool.map(detector, tiles))问题在于 ONNX Runtime、OpenVINO 这类 CPU 推理框架,内部已经做了算子级并行(intra-op parallelism),默认会占满所有核心。外层再开线程池,多个推理实例争抢同一批核心,结果是频繁的上下文切换和缓存失效,总吞吐反而下降。
正确的分工是:预处理并行,推理串行。
python
from concurrent.futures import ThreadPoolExecutor
import os
def run_pipeline(img, tile=1280, overlap=128, workers=4):
tiles = slice_image(img, tile, overlap)
# 预处理是内存密集+可并行的(resize/normalize/transpose)
with ThreadPoolExecutor(max_workers=workers) as pool:
preprocessed = list(pool.map(preprocess, [t for t, _ in tiles]))
# 推理串行,把全部核心让给框架内部的算子并行
dets = [detector(p) for p in preprocessed]
return merge_blocks(dets, [off for _, off in tiles])推理框架的线程配置也要显式设定,不要用默认值:
python
import onnxruntime as ort
so = ort.SessionOptions()
so.intra_op_num_threads = os.cpu_count() # 单模型内部算子并行
so.inter_op_num_threads = 1 # 模型间并行关掉,避免与外层争抢
so.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
so.enable_mem_pattern = True # 固定输入尺寸时开启,减少分配开销
session = ort.InferenceSession("model.onnx", sess_options=so,
providers=["CPUExecutionProvider"])inter_op_num_threads=1 这一项在串行推理场景下很重要。它的默认值是 0(由框架决定),有时会开出一个额外的调度线程池,在推理请求密集时造成不必要的抖动。
冷启动的代价经常被忽略。第一次推理要做内存分配、图优化、算子内核选择(某些框架会做运行时 autotune),耗时可能是稳定状态的十几倍。
对于交互式应用,这意味着用户的第一次操作会卡住几秒钟,体验上会被认为"很慢",尽管后续都很快。
python
import numpy as np
def warmup(session, input_shape, rounds=3):
"""服务启动时预热,避免首个请求承担冷启动开销"""
name = session.get_inputs()[0].name
dummy = np.zeros(input_shape, dtype=np.float32)
for _ in range(rounds):
session.run(None, {name: dummy})预热要放在服务初始化阶段,不要放在第一个请求的处理路径里。rounds=3 通常够了,主要目的是让内存分配器和算子内核缓存进入稳定状态。
分块检测看似降低了单次内存占用,但如果所有块的预处理结果都攒在内存里(像上面 run_pipeline 那样),峰值反而会更高。
A0 幅面、300 DPI、切成 1280×1280 的块,大约会有 50~80 块。每块预处理成 float32 的 NCHW 张量约 20MB,全存下来就是 1~1.6GB。加上原始图像本身,32 位进程直接 OOM,64 位也会很吃紧。
改成生成器流水线可以显著降低峰值:
python
def iter_tiles(img, tile=1280, overlap=128):
for crop, offset in slice_image(img, tile, overlap):
yield preprocess(crop), offset
def run_pipeline_streaming(img, **kw):
dets, offsets = [], []
for pre, offset in iter_tiles(img, **kw):
dets.append(detector(pre))
offsets.append(offset)
del pre # 显式释放,及时归还内存
return merge_blocks(dets, offsets)代价是失去了预处理的并行度。如果内存充足,用有界队列在两者之间取平衡更好——保持 2~4 块的预处理缓冲,既能让预处理和推理重叠,又不会让内存无上限增长。
CPU 上跑检测,输入尺寸对耗时的影响是平方级的。1280×1280 的输入相比 640×640,计算量约 4 倍。
所以 det_scale 不是越小越好。合理的做法是:先估算目标在缩放后的像素尺寸,确保最小目标仍有 12~16 像素以上,再反推 det_scale。
比如公差文字原图字高 8 像素、图纸长边 9600 像素,用 det_scale=0.25 后字高只剩 2 像素,检测端根本响应不了。这种情况就必须上分块检测,而不是继续缩放。
这也解释了为什么"先缩放检测 + 原始分辨率识别"和"分块检测"是互补而非替代关系:前者适合中等幅面、目标不太小的图;后者适合超大图幅或高密度标注。
这块不是纯技术问题,但绕不开。
工程图纸经常带客户保密要求,有些合同明确禁止图纸离开内网。这种约束下,SaaS 形态的方案直接出局,本地离线部署是硬要求,不是加分项。
离线部署要解决的几件事:
模型加密这件事有个工程取舍值得说清楚:加密会带来解密开销(通常是启动时一次性解密到内存,运行时不再解密,所以影响可控),但会显著提高二次开发和调试的难度——你没法直接用 Netron 之类的工具查看模型结构,也没法方便地做量化或算子替换。如果你的场景需要深度定制模型,这一点要在选型阶段问清楚。
支持 Windows Server 2016 这种较老系统也值得一提。工厂的服务器更新周期很长,跑着七八年前的系统很常见,要求"必须是最新的 Windows Server"会直接把一批客户挡在门外。
前面讲的都是能自动化的部分。有几类问题,架构再优化也解决不了,得说清楚。
手写字迹和涂改标注。 现场图纸经常有红笔修改、手写补充尺寸。手写体的识别率和印刷体差一个档次,而且涂改区域的原始标注可能还残留着,检测会同时框出新旧两个值。这类图纸建议直接走人工流程。
严重劣化的扫描件。 二次翻扫、碳粉不均、折痕穿过标注区——预处理能改善一部分,但信息物理上已经丢失了。这种情况下该做的是推动上游改用 CAD 原生 PDF 交付,而不是在识别端堆算力。源头改一次,比在下游优化十次都有效。
尺寸与几何要素的关联正确性。 这是最难的一环,也是最容易被忽略的。数字识别对了、公差解析对了、编号排好了,但那个公差可能挂在了错误的要素上——因为引线穿过密集标注区,追踪到了错误的位置。
这个错误的危险之处在于输出看起来完全正常。检测计划表里数字齐全、格式规范,只有回到图纸上逐项核对位置才能发现。所以复核流程里必须包含"抽查 10%~20% 的尺寸,回到原图确认它量的是哪个要素"这一步,不能只对着表格核数字。
主视图与剖视图的重复标注。 同一尺寸在多个视图上标出是制图常规。自动去重需要判断两处标注指向的是否同一特征,涉及跨视图的几何对应关系。实践中比较稳的做法是把去重边界交给用户操作——框选单个视图识别,而不是一次框整张图。
工程图纸识别的工程难点,集中在三个地方:
尺度。 检测要视野、识别要精度,两者对分辨率的需求相反,必须解耦,靠坐标映射把两个阶段串起来。
密度。 目标密集且大量细长,标准 NMS 参数不适用;分块的 overlap 和边界切割问题需要错相位切片来兜底。
语义。 字符读对了不等于含义解析对了。公差书写顺序、连字符歧义、文字方向、配合代号展开,每一项都是显式的规则工程,漏掉任何一项都会在下游产生难以察觉的错误。
至于性能,CPU-only 环境下的关键不是堆线程,而是把并行度放在正确的位置——预处理并行、推理串行、显式配置框架的 intra/inter-op 线程数、启动时预热、控制内存峰值。这几件事做对,纯 CPU 也能到可用的响应速度。
最后强调一遍那个最容易被跳过的点:识别输出必须有回图核对的环节。自动化能接走的是信息搬运,接不走的是工程判断——而判断出错的成本,比省下的人工时间高得多。
原创声明:本文系作者授权腾讯云开发者社区发表,未经许可,不得转载。
如有侵权,请联系 cloudcommunity@tencent.com 删除。