首页
学习
活动
专区
圈层
工具
发布
社区首页 >专栏 >工程图纸识别的分块检测与多尺度策略

工程图纸识别的分块检测与多尺度策略

原创
作者头像
融新AI气泡图大师
发布于 2026-11-16 14:45:51
发布于 2026-11-16 14:45:51
120
举报

做文档 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 和 Ø、分辨小数点的位置。

二、解法:检测与识别的分辨率解耦

思路是把流水线拆开,两个阶段各用各的分辨率。

  1. 整图缩放到一个较低分辨率,在上面跑检测,拿到所有目标的框
  2. 把框坐标映射回原始分辨率
  3. 从原始分辨率图上裁剪出对应区域,送给识别模型

这样检测阶段享受小图的内存和速度优势,识别阶段拿到的是无损的原始像素。

我在看的融新 AI 气泡图大师的更新说明里提到了这个思路:超大页面先缩放检测、识别仍用原始分辨率。这是大幅面图纸减少漏检比较对路的做法,比自己训练一个高分辨率大模型划算得多——后者成本高一个量级,收益还不一定更好。

参考实现:

python

代码语言:javascript
复制
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 下误差不同。如果后续要做尺寸界线与几何图元的交点计算,这几个像素的偏差会传导过去。建议映射时用浮点保留,只在最终裁剪时取整。

三、分块检测:overlap 与 NMS 的取舍

当图纸幅面更大、或者目标密度更高时,单纯缩放检测也不够了——缩放比太大,小目标还是会丢。这时候要在原始分辨率(或接近原始分辨率)上做分块检测。

3.1 切片与 overlap

python

代码语言:javascript
复制
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 tiles

overlap 的取值是个权衡:

  • 太小(比如 0~32 像素):跨块的目标会被切断。一个尺寸标注如果正好横跨两块边界,两边都只看到一半,检测置信度都不够,结果就是漏检。
  • 太大(比如 512 像素):同一个目标在多个块里重复检出,后处理压力大;更重要的是算力浪费严重——overlap 512、tile 1280 时,重叠面积占比接近 30%。

经验值:overlap 设为你最小目标最长边的 1.5~2 倍。工程图纸上最小的有效目标通常是公差文字,宽度几十像素,所以 128~256 的 overlap 一般够用。

另外注意上面代码里的边界处理:最后一个块如果不足 tile 尺寸,不要 pad 黑边,直接用实际尺寸——pad 会在边缘引入假的梯度,检测模型可能在那里产生误报。

3.2 细长目标的 NMS 要单独调

跨块重复检出要靠 NMS 合并,但这里有个陷阱。

标准 NMS 用一个统一的 IoU 阈值(常见 0.45~0.5)。问题是工程图纸上大量目标是细长的——尺寸线、尺寸界线、引线,长宽比可能到 20:1 甚至更高。两个平行的尺寸界线,间距只有几个像素,它们的 IoU 可能高达 0.6,标准 NMS 会把其中一条当重复框抑制掉。

反过来,两个真正重复的检出(同一目标在相邻块里各检出一次),因为框的位置略有偏移,IoU 可能只有 0.3,逃过了抑制,造成重复。

所以要按长宽比分别设阈值:

python

代码语言:javascript
复制
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 keep

aspect_thr=6 是个起点。如果你的图纸上密集剖面线很多,可能需要降到 4,同时把 iou_thr_thin 提到 0.2 左右,否则剖面线会被大量误抑制。

3.3 跨块目标的合并策略

NMS 解决的是"同一个目标被检出多次",但解决不了"同一个目标被切成两半,两半都没检出"。

对后者,实践中有效的做法是错相位二次切片:第一轮切片后,把整个网格平移 tile/2,再切一轮。这样第一轮里位于块边界的目标,在第二轮里大概率落在块中心。两轮结果合并后做一次 NMS。

代价是推理量翻倍。所以这是个可选优化,只在漏检集中在图幅边缘区域时才值得开。判断方法:把漏检目标的坐标画成散点图,如果明显聚集在 x % tile < overlap 的条带上,说明是边界切割导致的,该上错相位切片。

四、语义层:从字符到工程含义

检测和识别都对了,输出仍然可能不能用。因为图纸上的字符串需要被解析成工程语义。

4.1 公差的多种表达

同样是"±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 上对应具体的上下偏差值。如果产品内置了国标公差表,这一步可以自动化;否则要人工查表录入,很容易出错。

4.2 连字符歧义:一个经典陷阱

图纸上这两种写法长得几乎一样:

代码语言:javascript
复制
2-⌀10        表示 2 个直径 10 的孔(数量前缀)
⌀25-0.02     表示直径 25,下偏差 -0.02(有些图纸省略上偏差的 +0)

那个连字符,在第一种里是数量分隔符,在第二种里是负号。如果一律当成负号解析,2-⌀10 会被读成"2 减 直径10"或者更糟的结果;如果一律当成分隔符,单向负偏差就丢了。

消解只能靠上下文规则:

python

代码语言:javascript
复制
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,需要统一归一化后再进入解析,否则下游的正则全都要写好几个变体。

4.3 文字方向

工程图纸上的文字不总是水平的。竖直方向的尺寸,文字可能是竖排;某些 CAD 模板下会出现 180° 倒置的文字(这是 CAD 标注样式为了"文字始终在尺寸线上方"而做的翻转);形位公差框格如果引线很长,框格文字可能被拉长排列。

识别前需要一个方向分类器。常见的做法是训练一个四分类(0°/90°/180°/270°)的轻量模型,或者对文本检测框做几何判断——如果框的长边是竖直的,先转 90° 再试识别,比较置信度。

倒置文字是个高频错误来源:0 转 180° 还是 0,6 转 180° 变成 9,+ 和 - 在某些字体下也难以区分。这类错误识别端给出的置信度往往还挺高,因为字形本身是合法的,只是值错了。

五、CPU-only 环境下的性能工程

制造业现场的部署环境和互联网后端差别很大。很多工厂的服务器就是普通 PC,没有独立显卡,也不允许随便加装。所以纯 CPU 推理不是退路,是常态。

5.1 并行策略:别盲目开线程池

一个直觉的错误做法是用线程池并行跑多个块的推理:

python

代码语言:javascript
复制
# 反例:CPU 上这样做通常更慢
with ThreadPoolExecutor(max_workers=8) as pool:
    dets = list(pool.map(detector, tiles))

问题在于 ONNX Runtime、OpenVINO 这类 CPU 推理框架,内部已经做了算子级并行(intra-op parallelism),默认会占满所有核心。外层再开线程池,多个推理实例争抢同一批核心,结果是频繁的上下文切换和缓存失效,总吞吐反而下降。

正确的分工是:预处理并行,推理串行。

python

代码语言:javascript
复制
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

代码语言:javascript
复制
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(由框架决定),有时会开出一个额外的调度线程池,在推理请求密集时造成不必要的抖动。

5.2 模型预热

冷启动的代价经常被忽略。第一次推理要做内存分配、图优化、算子内核选择(某些框架会做运行时 autotune),耗时可能是稳定状态的十几倍。

对于交互式应用,这意味着用户的第一次操作会卡住几秒钟,体验上会被认为"很慢",尽管后续都很快。

python

代码语言:javascript
复制
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 通常够了,主要目的是让内存分配器和算子内核缓存进入稳定状态。

5.3 内存峰值控制

分块检测看似降低了单次内存占用,但如果所有块的预处理结果都攒在内存里(像上面 run_pipeline 那样),峰值反而会更高。

A0 幅面、300 DPI、切成 1280×1280 的块,大约会有 50~80 块。每块预处理成 float32 的 NCHW 张量约 20MB,全存下来就是 1~1.6GB。加上原始图像本身,32 位进程直接 OOM,64 位也会很吃紧。

改成生成器流水线可以显著降低峰值:

python

代码语言:javascript
复制
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 块的预处理缓冲,既能让预处理和推理重叠,又不会让内存无上限增长。

5.4 检测模型的输入尺寸选择

CPU 上跑检测,输入尺寸对耗时的影响是平方级的。1280×1280 的输入相比 640×640,计算量约 4 倍。

所以 det_scale 不是越小越好。合理的做法是:先估算目标在缩放后的像素尺寸,确保最小目标仍有 12~16 像素以上,再反推 det_scale。

比如公差文字原图字高 8 像素、图纸长边 9600 像素,用 det_scale=0.25 后字高只剩 2 像素,检测端根本响应不了。这种情况就必须上分块检测,而不是继续缩放。

这也解释了为什么"先缩放检测 + 原始分辨率识别"和"分块检测"是互补而非替代关系:前者适合中等幅面、目标不太小的图;后者适合超大图幅或高密度标注。

六、离线部署与模型保护

这块不是纯技术问题,但绕不开。

工程图纸经常带客户保密要求,有些合同明确禁止图纸离开内网。这种约束下,SaaS 形态的方案直接出局,本地离线部署是硬要求,不是加分项。

离线部署要解决的几件事:

  • 依赖自包含:不能依赖运行时的 pip 安装或在线模型下载。Windows 原生安装包比 Docker 在工厂环境里更容易被接受——很多企业的 IT 策略不允许在生产网段跑容器,或者根本没有容器运行时。
  • 离线语言资源:如果流程里包含备注翻译之类的功能,翻译模型也得本地化,不能回落到在线 API。
  • 模型文件保护:模型是核心资产,明文放在安装目录里等于公开。常见做法是模型文件加密,配合硬件授权锁或软件许可做运行时解密。

模型加密这件事有个工程取舍值得说清楚:加密会带来解密开销(通常是启动时一次性解密到内存,运行时不再解密,所以影响可控),但会显著提高二次开发和调试的难度——你没法直接用 Netron 之类的工具查看模型结构,也没法方便地做量化或算子替换。如果你的场景需要深度定制模型,这一点要在选型阶段问清楚。

支持 Windows Server 2016 这种较老系统也值得一提。工厂的服务器更新周期很长,跑着七八年前的系统很常见,要求"必须是最新的 Windows Server"会直接把一批客户挡在门外。

七、这套架构的边界

前面讲的都是能自动化的部分。有几类问题,架构再优化也解决不了,得说清楚。

手写字迹和涂改标注。 现场图纸经常有红笔修改、手写补充尺寸。手写体的识别率和印刷体差一个档次,而且涂改区域的原始标注可能还残留着,检测会同时框出新旧两个值。这类图纸建议直接走人工流程。

严重劣化的扫描件。 二次翻扫、碳粉不均、折痕穿过标注区——预处理能改善一部分,但信息物理上已经丢失了。这种情况下该做的是推动上游改用 CAD 原生 PDF 交付,而不是在识别端堆算力。源头改一次,比在下游优化十次都有效。

尺寸与几何要素的关联正确性。 这是最难的一环,也是最容易被忽略的。数字识别对了、公差解析对了、编号排好了,但那个公差可能挂在了错误的要素上——因为引线穿过密集标注区,追踪到了错误的位置。

这个错误的危险之处在于输出看起来完全正常。检测计划表里数字齐全、格式规范,只有回到图纸上逐项核对位置才能发现。所以复核流程里必须包含"抽查 10%~20% 的尺寸,回到原图确认它量的是哪个要素"这一步,不能只对着表格核数字。

主视图与剖视图的重复标注。 同一尺寸在多个视图上标出是制图常规。自动去重需要判断两处标注指向的是否同一特征,涉及跨视图的几何对应关系。实践中比较稳的做法是把去重边界交给用户操作——框选单个视图识别,而不是一次框整张图。

小结

工程图纸识别的工程难点,集中在三个地方:

尺度。 检测要视野、识别要精度,两者对分辨率的需求相反,必须解耦,靠坐标映射把两个阶段串起来。

密度。 目标密集且大量细长,标准 NMS 参数不适用;分块的 overlap 和边界切割问题需要错相位切片来兜底。

语义。 字符读对了不等于含义解析对了。公差书写顺序、连字符歧义、文字方向、配合代号展开,每一项都是显式的规则工程,漏掉任何一项都会在下游产生难以察觉的错误。

至于性能,CPU-only 环境下的关键不是堆线程,而是把并行度放在正确的位置——预处理并行、推理串行、显式配置框架的 intra/inter-op 线程数、启动时预热、控制内存峰值。这几件事做对,纯 CPU 也能到可用的响应速度。

最后强调一遍那个最容易被跳过的点:识别输出必须有回图核对的环节。自动化能接走的是信息搬运,接不走的是工程判断——而判断出错的成本,比省下的人工时间高得多。

原创声明:本文系作者授权腾讯云开发者社区发表,未经许可,不得转载。

如有侵权,请联系 cloudcommunity@tencent.com 删除。

目录
  • 一、尺度困境:缩放丢细节,原图爆内存
  • 二、解法:检测与识别的分辨率解耦
  • 三、分块检测:overlap 与 NMS 的取舍
    • 3.1 切片与 overlap
    • 3.2 细长目标的 NMS 要单独调
    • 3.3 跨块目标的合并策略
  • 四、语义层:从字符到工程含义
    • 4.1 公差的多种表达
    • 4.2 连字符歧义:一个经典陷阱
    • 4.3 文字方向
  • 五、CPU-only 环境下的性能工程
    • 5.1 并行策略:别盲目开线程池
    • 5.2 模型预热
    • 5.3 内存峰值控制
    • 5.4 检测模型的输入尺寸选择
  • 六、离线部署与模型保护
  • 七、这套架构的边界
  • 小结
问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档