自动识别边框

This commit is contained in:
2026-10-22 22:11:33 +08:00
parent 61245b1c65
commit deb622095f
6 changed files with 682 additions and 33 deletions
+17 -9
View File
@@ -25,11 +25,10 @@ python3 /workspace/skills/document-photo-to-pdf/doc_deskew/pipeline.py <子命
1. **先说再做。** 每次调脚本前用一句话说明这次干什么(要标注步骤编号)。
2. **坐标只能靠眼睛读,禁止一切自建脚本。** 不另造任何纸张处理的辅助的代码,一次性脚本也不行。确实无法达成目的需要新能力=先停下问用户,不许自己造。
3. **不裁切、不放大、不逐角看。** 四个角在同一张网格图上一次读全,直接报 4 组数字。不为了"读准一点"造局部图、加刻度、逐个角反复看。
4. **每张图读 2 次,且每次都要有目的。** 网格 1 次 + 角标 1 次,看完就交付。
4. **每张源图对应1网格图、1角标图。** 每轮读网格图 1 次 + 角标 1 次,看完就交付。
- **读之前先说清这次要确认什么。** 说不出目的就不读。"再看一眼确认一下"不算目的。
- **不为读而读。** 允许重读,但必须是被动的、有明确对象的:图没送达/像素没收到、要核对某个具体数字或某条边。没有新对象就直接用手上已有的数字。
- **只读这两类图。** 网格、角标。原图、局部放大图、成品图、自己另造的辅助图都不读。
- 没把握就按"宁可外扩"给保守值,交给角标图验证,不在读图阶段磨。
5. **一次成件,禁止试错。** 一条 `build` 出件 + 检验。一轮里每页最多跑 1 次 `build`;不调参、不重取角点、不换方法、不"先出一版看看"。不通过就报诊断,停下等确认。
6. **只有用户明确说"再改"才允许修复。** 完整一轮 = `prepare` → `set`(每页一次)→ `build`(一次)→ 看角标 → 交付。这一轮内发现的任何偏差(框偏了、裁到内容、比例不对),一律只报诊断和坐标建议,**不自行改、不重跑、不补做**。用户在本轮交付后明确说"再改/重做"时才能动手,且还是只跑一轮,改完重新过角标关。
7. **指标 ≠ 成品。** 校验只查"框内"像素,框漏掉的内容查不出来。角标图必须亲眼看。
@@ -45,13 +44,16 @@ python3 /workspace/skills/document-photo-to-pdf/doc_deskew/pipeline.py <子命
## 流程
### 1 · 出网格图
### 1 · 出网格图,并输出候选的角点坐标
```sh
python3 /workspace/skills/document-photo-to-pdf/doc_deskew/pipeline.py prepare 图1.jpg 图2.jpg
```
不传图片名 = 取当前目录所有图片。输出 `out/N-网格-<名称>.png`(100px 红色主线带坐标刻度、50px 蓝色辅助线,两者同宽)。
输出 `out/N-网格-<名称>.png`(100px 红色主线带坐标刻度、50px 蓝色辅助线,两者同宽)。
必须显式传入图片名,合并成PDF时即按此传入顺序。
网格图上会叠加一组**候选角点**:品红实心圆 = 候选角点。同时按文件名打印 markdown 表格(`图片|左上|右上|右下|左下`,单元格为 `x,y`),可直接对照读数。品红虚线是检出的边线,用来辅助判断线是否贴边。
### 2 · 从网格图中读出角点,一张图一条命令
@@ -64,6 +66,11 @@ python3 /workspace/skills/document-photo-to-pdf/doc_deskew/pipeline.py prepare
2. 再识别目标点相对相邻蓝线(50px)的偏移;
3. 把目的坐标复述成一句话,例如“右下:x 在 1000 红线右 52px,y 在 1700 红线下 22px → 1052,1722”。
候选角点怎么用:
- 图上品红圆就是候选值,可直接拿来作参照对照,省去从零找角点;
- 但**必须逐角核一遍**:圆是否在纸角上、品红虚线是否全程贴着纸边(线跑偏比角点偏更容易看出来);
- 候选与自己的判读不一致时,以自己读图的值为准;
读数要求:
- 读之前先定好这一张要报的 4 组数字,看完立刻 `set` 落盘到 `out/corners.json`。
- 角被遮挡:沿两条可见纸边延长交会出顶点。
@@ -104,9 +111,9 @@ python3 /workspace/skills/document-photo-to-pdf/doc_deskew/pipeline.py build \
**只看不改:** 发现问题只记进报告,记录修正前后角标坐标的表格、不重跑 `build`、不补造辅助图。
| 页码 | 实际使用的角点坐标 | 修正后的角点坐标 |
|---|---|---|
| 1 | x1,y1;x2,y2;x3,y3;x4,y4 | x1',y1';x2',y2';x3',y3';x4',y4' |
| 页码 | 候选的角点坐标 | 实际使用的角点坐标 | 建议修正的角点坐标 |
|---|---|---|---|
| 1 | <prepare估算出坐标> | x1,y1;x2,y2;x3,y3;x4,y4 | <事后评估后的坐标> |
## 判定与报告
@@ -119,13 +126,12 @@ python3 /workspace/skills/document-photo-to-pdf/doc_deskew/pipeline.py build \
| 内容贴边 | 页边无成片文字级暗像素 | 内容被切,外扩 5px |
- **全部通过**:给产物路径、大小、页数、指标,加一句角标图上确认的结果。
- **"外侧纸面占比 100%"一律当角点错误**,误差是几十到上百 px,回第 2 步重读,不是微调。
- **不达标**:只报诊断+ 建议,**不自行改、不重跑、不换方法**。用户明确说"再改"后,才改动后重跑一轮,然后交用户决策。
- **用户没发话就交付**:即使只差 1px、即使一眼看出能更好,也不许动。报告里可写建议,手不能动。
## 内容安全
**禁止用生成式模型处理这类图片。** 生成模型是重绘而非变换,会改写文档内容,且结果看起来完全正常。本流程只做纯几何变换 + 全局等比提亮,文字、金额、印章保持原始像素。
**禁止用生成式模型处理这类图片。** 生成模型是重绘而非变换,即使只做几何变换,也可能引入伪影或改写文字。本流程只做纯几何变换 + 全局等比提亮,文字信息保持原始像素。
## 命令速查
@@ -145,6 +151,8 @@ python3 /workspace/skills/document-photo-to-pdf/doc_deskew/pipeline.py build \
| 模块 | 职责 |
|---|---|
| `grid.py` | 画带坐标的网格图 |
| `auto_quad.py` | 算候选角点 |
| `prepare.py` | 出网格图:叠候选角点与检出边线 |
| `preview_quad.py` | 画角标图(叠网格) |
| `verify_quad.py` | 角点几何校验 |
| `homography.py` | 透视变换 + 提亮 |
@@ -0,0 +1,500 @@
# -*- coding: utf-8 -*-
"""边线检测 + 纸角候选提取(从 edge_clean_c.py v3 抽取的精简模块)。
对外只暴露一个函数:
detect(image_path, max_side=1600) -> (corners, info)
corners:原图像素坐标系下的四角 [(x, y)],顺序 左上、右上、右下、左下;
info :附加信息(处理尺寸、缩放比、各边覆盖率、边线掩膜),供出图与诊断用。
注意:本模块只产出**候选**坐标。它不写 corners.json,也不参与出件判定——
最终角点必须以人工读角标图的结果为准。
"""
import numpy as np
from PIL import Image, ImageOps, ImageFilter
from collections import deque
# ---------------- 基础工具 ----------------
def load_and_scale(path, max_side=1600):
pil = ImageOps.exif_transpose(Image.open(path)).convert("RGB")
w, h = pil.size
s = max_side / max(w, h)
if s < 1:
pil = pil.resize((int(round(w * s)), int(round(h * s))), Image.LANCZOS)
return pil, np.asarray(pil).astype(np.float32) / 255.0
def rgb_to_sv(arr):
maxc = arr.max(axis=-1)
minc = arr.min(axis=-1)
delta = maxc - minc
S = np.zeros_like(maxc, dtype=np.float32)
np.divide(delta, maxc, out=S, where=maxc > 1e-6)
return S.astype(np.float32), maxc.astype(np.float32)
def luminance(arr):
return (0.299 * arr[..., 0] + 0.587 * arr[..., 1] + 0.114 * arr[..., 2]).astype(np.float32)
def box_mean(img, r):
"""O(1)/像素的方框均值(积分图),r 为半径。"""
img = np.asarray(img, dtype=np.float32)
H, W = img.shape
pad = np.zeros((H + 1, W + 1), dtype=np.float32)
pad[1:, 1:] = img
ii = pad.cumsum(0).cumsum(1)
ys = np.arange(H)
xs = np.arange(W)
y0 = np.clip(ys - r, 0, H)
y1 = np.clip(ys + r + 1, 0, H)
x0 = np.clip(xs - r, 0, W)
x1 = np.clip(xs + r + 1, 0, W)
S = (ii[np.ix_(y1, x1)] - ii[np.ix_(y0, x1)]
- ii[np.ix_(y1, x0)] + ii[np.ix_(y0, x0)])
cnt = (y1 - y0)[:, None] * (x1 - x0)[None, :]
return S / np.maximum(cnt, 1).astype(np.float32)
def gaussian_blur_np(img, sigma):
radius = int(np.ceil(sigma * 3))
if radius < 1:
return img.astype(np.float32)
x = np.arange(-radius, radius + 1, dtype=np.float32)
k = np.exp(-x * x / (2 * sigma * sigma))
k /= k.sum()
H, W = img.shape
p = np.pad(img, radius, mode="edge")
tmp = np.zeros((H, W), dtype=np.float32)
for i, kv in enumerate(k):
tmp += kv * p[radius:radius + H, i:i + W]
p = np.pad(tmp, ((radius, radius), (0, 0)), mode="edge")
out = np.zeros((H, W), dtype=np.float32)
for i, kv in enumerate(k):
out += kv * p[i:i + H, :]
return out
def convolve3x3(img, kernel):
H, W = img.shape
p = np.pad(img, 1, mode="edge")
out = np.zeros((H, W), dtype=np.float32)
for i in range(3):
for j in range(3):
kv = kernel[i, j]
if kv != 0:
out += kv * p[i:i + H, j:j + W]
return out
def sobel_magnitude(gray):
kx = np.array([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]], dtype=np.float32)
ky = np.array([[-1, -2, -1], [0, 0, 0], [1, 2, 1]], dtype=np.float32)
gx = convolve3x3(gray, kx)
gy = convolve3x3(gray, ky)
return np.sqrt(gx * gx + gy * gy)
# ---------------- 形态学(Pillow Max/MinFilter)----------------
def _odd(size):
size = int(size)
if size < 3:
size = 3
if size % 2 == 0:
size += 1
return size
def dilate(mask, size):
pil = Image.fromarray((mask.astype(np.uint8) * 255))
return np.asarray(pil.filter(ImageFilter.MaxFilter(_odd(size)))) > 127
def erode(mask, size):
pil = Image.fromarray((mask.astype(np.uint8) * 255))
return np.asarray(pil.filter(ImageFilter.MinFilter(_odd(size)))) > 127
def closing(mask, size):
return erode(dilate(mask, size), size)
def opening(mask, size):
return dilate(erode(mask, size), size)
# ---------------- 连通域 & 填孔(降采样图上做)----------------
def downsample_any(mask, factor):
if factor <= 1:
return mask
H, W = mask.shape
H2, W2 = H // factor, W // factor
return mask[:H2 * factor, :W2 * factor].reshape(
H2, factor, W2, factor).any(axis=(1, 3))
def upsample_nearest(mask_small, target_h, target_w):
h, w = mask_small.shape
yi = np.linspace(0, h - 1, target_h).astype(np.int32)
xi = np.linspace(0, w - 1, target_w).astype(np.int32)
return mask_small[np.ix_(yi, xi)]
def fill_holes(mask_small):
H, W = mask_small.shape
bg = ~mask_small
visited = np.zeros((H, W), dtype=bool)
q = deque()
for x in range(W):
if bg[0, x] and not visited[0, x]:
visited[0, x] = True
q.append((0, x))
if bg[H - 1, x] and not visited[H - 1, x]:
visited[H - 1, x] = True
q.append((H - 1, x))
for y in range(H):
if bg[y, 0] and not visited[y, 0]:
visited[y, 0] = True
q.append((y, 0))
if bg[y, W - 1] and not visited[y, W - 1]:
visited[y, W - 1] = True
q.append((y, W - 1))
while q:
y, x = q.popleft()
if y > 0 and bg[y - 1, x] and not visited[y - 1, x]:
visited[y - 1, x] = True
q.append((y - 1, x))
if y < H - 1 and bg[y + 1, x] and not visited[y + 1, x]:
visited[y + 1, x] = True
q.append((y + 1, x))
if x > 0 and bg[y, x - 1] and not visited[y, x - 1]:
visited[y, x - 1] = True
q.append((y, x - 1))
if x < W - 1 and bg[y, x + 1] and not visited[y, x + 1]:
visited[y, x + 1] = True
q.append((y, x + 1))
return mask_small | (bg & ~visited)
def largest_connected(mask_small):
H, W = mask_small.shape
visited = np.zeros((H, W), dtype=bool)
best = np.zeros_like(mask_small)
best_n = 0
ys, xs = np.where(mask_small)
for y0, x0 in zip(ys, xs):
if visited[y0, x0]:
continue
stack = [(y0, x0)]
visited[y0, x0] = True
comp = []
while stack:
y, x = stack.pop()
comp.append((y, x))
for dy, dx in ((-1, -1), (-1, 0), (-1, 1), (0, -1),
(0, 1), (1, -1), (1, 0), (1, 1)):
ny, nx = y + dy, x + dx
if 0 <= ny < H and 0 <= nx < W and mask_small[ny, nx] and not visited[ny, nx]:
visited[ny, nx] = True
stack.append((ny, nx))
if len(comp) > best_n:
best_n = len(comp)
best = np.zeros_like(mask_small)
for y, x in comp:
best[y, x] = True
return best
# ---------------- 纸面掩膜(整形后只用于限定搜索区域)----------------
def otsu_threshold(score):
"""一维 Otsu:返回使类间方差最大的阈值"""
hist, bin_edges = np.histogram(score, bins=256, range=(0.0, 1.0))
hist = hist.astype(np.float64)
total = hist.sum()
if total <= 0:
return 0.5
p = hist / total
centers = (bin_edges[:-1] + bin_edges[1:]) * 0.5
w0 = np.cumsum(p)
w1 = 1.0 - w0
m0 = np.cumsum(p * centers)
mt = m0[-1]
with np.errstate(divide="ignore", invalid="ignore"):
mu0 = m0 / np.maximum(w0, 1e-12)
mu1 = (mt - m0) / np.maximum(w1, 1e-12)
between = w0 * w1 * (mu0 - mu1) ** 2
between = np.nan_to_num(between, nan=-1.0)
return float(centers[int(np.argmax(between))])
def paper_mask(arr, debug=False):
H, W = arr.shape[:2]
S, V = rgb_to_sv(arr)
# 纸面近白:亮度高、饱和低;木桌面偏色暗。用 Otsu 自动定阈值,
# 再叠加硬约束 V>0.50 防止桌面亮反射被并入。
score = (V * (1.0 - S)).astype(np.float32)
th = otsu_threshold(score)
th = max(th, 0.50)
bright = (score > th) & (V > 0.50) & (S < 0.45)
if debug:
print(f"[paper_mask] otsu={th:.3f} bright frac={bright.mean():.3f}")
factor = max(1, min(H, W) // 400)
bs = downsample_any(bright, factor)
size = _odd(max(5, min(bs.shape) // 60))
m = closing(bs, size)
m = fill_holes(m)
m = largest_connected(m)
m = closing(m, _odd(max(5, min(bs.shape) // 80))) # 抹掉内凹缺口/阶梯
m = fill_holes(m)
# 掩膜轻微内收:纸边最外侧 1~2px 常被阴影/暗边吃掉,内收后环带更贴合真实纸边
m = erode(m, 3)
paper = upsample_nearest(m, H, W) if factor > 1 else m
if debug:
Image.fromarray((paper * 255).astype(np.uint8)).save("dbg_v3_paper.png")
return paper
def boundary_band(paper, k):
"""纸面掩膜边界两侧各 k 像素的环带。"""
k = _odd(k)
return dilate(paper, k) & ~erode(paper, k)
# ---------------- 边缘图(局部自适应阈值)----------------
def edge_map(arr, local_gain=1.55, low=0.035):
H = arr.shape[0]
gray = luminance(arr)
sigma = max(1.0, H / 800.0)
blurred = gaussian_blur_np(gray, sigma)
mag = sobel_magnitude(blurred)
local = box_mean(mag, max(3, H // 50))
th = np.maximum(low, local * local_gain)
return mag > th
def boundary_step_filter(arr, paper, r_small=10, r_big=24, step_th=0.055):
"""跨纸边亮度阶跃检测:比较掩膜内侧/外侧小窗的 V 均值。
纸边是真实的明暗台阶(阶跃大),木纹/阴影纹理阶跃小。相比固定亮度
阈值(V>0.60 / V<0.45),不受整体曝影响。两级窗口:掩膜准确的
位置用 r_small,掩膜略有内收/偏移处依靠 r_big 补上。
"""
_, V = rgb_to_sv(arr)
p = paper.astype(np.float32)
q = 1.0 - p
def side_means(r):
din = box_mean(p, r)
dout = box_mean(q, r)
vin = box_mean(V * p, r) / np.maximum(din, 1e-6)
vout = box_mean(V * q, r) / np.maximum(dout, 1e-6)
ok = (din > 0.08) & (dout > 0.08)
return np.where(ok, np.abs(vin - vout), 0.0)
step = np.maximum(side_means(r_small), side_means(r_big))
return step > step_th
# ---------------- 四角提取(掩膜 -> 四边拟合 -> 交点) ----------------
def mask_boundary_points(mask):
"""掩膜边界像素坐标 (N,2) float32,顺序为 (x, y)"""
inner = erode(mask, 3)
ys, xs = np.where(mask & ~inner)
return np.stack([xs, ys], axis=1).astype(np.float32)
def _fit_line(pts):
"""总体最小二乘拟直线,返回法向量 n 与 n·p = c"""
c0 = pts.mean(axis=0)
q = pts - c0
cov = (q.T @ q) / max(len(pts) - 1, 1)
w, v = np.linalg.eigh(cov)
d = v[:, int(np.argmax(w))] # 主方向
n = np.array([-d[1], d[0]], dtype=np.float64)
nn = np.linalg.norm(n)
if nn < 1e-9:
return np.array([0.0, 1.0]), float(c0[1])
n = n / nn
return n, float(n @ c0)
def _intersect(n1, c1, n2, c2):
A = np.vstack([n1, n2])
b = np.array([c1, c2], dtype=np.float64)
try:
return np.linalg.solve(A, b)
except np.linalg.LinAlgError:
return None
def detect_quad_corners(paper, points=None, robust_px=2.0, group_tol=22.0):
"""提取四个纸角,返回 [(x,y)],顺序 左上、右上、右下、左下。
锚点一律取自纸面掩膜边界(稳定,不受噪声小刺影响);points 传入纸边黑线
像素时,按到四条基准边的距离分组后重新拟合,得到更贴真实纸边的角点。
每个角都有退化与越界检查,不通过就回退到掩膜基准边交点。
"""
base = mask_boundary_points(paper)
if len(base) < 40:
return []
bx, by = base[:, 0], base[:, 1]
a_s = bx + by
a_d = bx - by
anchors = np.array([
base[int(np.argmin(a_s))], # 左上
base[int(np.argmax(a_d))], # 右上
base[int(np.argmax(a_s))], # 右下
base[int(np.argmin(a_d))], # 左下
], dtype=np.float64)
base_lines = []
for a, b in ((0, 1), (1, 2), (2, 3), (3, 0)):
p0, p1 = anchors[a], anchors[b]
dv = p1 - p0
L = float(np.linalg.norm(dv))
if L < 1e-6:
base_lines.append(None)
continue
dv = dv / L
n0 = np.array([-dv[1], dv[0]])
base_lines.append((n0, float(n0 @ p0)))
corners = []
for i in range(4):
l1, l2 = base_lines[i - 1], base_lines[i]
if l1 is None or l2 is None:
corners.append(anchors[i].copy())
continue
p = _intersect(l1[0], l1[1], l2[0], l2[1])
corners.append(anchors[i].copy() if p is None else p)
if points is None:
return [(float(p[0]), float(p[1])) for p in corners]
pts = np.asarray(points, dtype=np.float64)
if len(pts) < 40:
return [(float(p[0]), float(p[1])) for p in corners]
dd = []
for l in base_lines:
if l is None:
dd.append(np.full(len(pts), 1e9))
else:
dd.append(np.abs(pts @ l[0] - l[1]))
D = np.stack(dd, axis=1)
idx = np.argmin(D, axis=1)
dmin = D[np.arange(len(pts)), idx]
lines = []
for i in range(4):
sel = pts[(idx == i) & (dmin <= group_tol)]
if len(sel) < 40:
lines.append(base_lines[i])
continue
n, c = _fit_line(sel)
for _ in range(2):
res = np.abs(sel @ n - c)
keep = sel[res <= max(robust_px, 1.0) * 2.5]
if len(keep) < 40:
break
n, c = _fit_line(keep)
sel = keep
lines.append((n, c))
H, W = paper.shape
for i in range(4):
l1, l2 = lines[i - 1], lines[i]
if l1 is None or l2 is None:
continue
det = l1[0][0] * l2[0][1] - l2[0][0] * l1[0][1]
if abs(det) < 1e-3: # 两边近共线,交点发散
continue
p = _intersect(l1[0], l1[1], l2[0], l2[1])
if p is None:
continue
if not (-0.15 * W <= p[0] <= 1.15 * W and -0.15 * H <= p[1] <= 1.15 * H):
continue
corners[i] = p
return [(float(p[0]), float(p[1])) for p in corners]
# ---------------- 覆盖率指标 ----------------
def border_coverage_exact(edges, paper, tol=14):
"""沿掩膜逐行/逐列的真实边界测覆盖率(适配斜边,不受 bbox 影响)。
对每一列取掩膜的上/下边界,对每一行取左/右边界,检查 ±tol 内是否有边缘像素。
"""
H, W = paper.shape
col_has = paper.any(axis=0)
row_has = paper.any(axis=1)
top_hit = top_n = 0
bot_hit = bot_n = 0
for x in np.where(col_has)[0]:
ys = np.where(paper[:, x])[0]
y0, y1 = ys.min(), ys.max()
if edges[max(0, y0 - tol):min(H, y0 + tol + 1), x].any():
top_hit += 1
top_n += 1
if edges[max(0, y1 - tol):min(H, y1 + tol + 1), x].any():
bot_hit += 1
bot_n += 1
left_hit = left_n = 0
right_hit = right_n = 0
for y in np.where(row_has)[0]:
xs = np.where(paper[y, :])[0]
x0, x1 = xs.min(), xs.max()
if edges[y, max(0, x0 - tol):min(W, x0 + tol + 1)].any():
left_hit += 1
left_n += 1
if edges[y, max(0, x1 - tol):min(W, x1 + tol + 1)].any():
right_hit += 1
right_n += 1
return {
"top": top_hit / max(top_n, 1),
"bottom": bot_hit / max(bot_n, 1),
"left": left_hit / max(left_n, 1),
"right": right_hit / max(right_n, 1),
}
# ---------------- 对外接口 ----------------
def detect(image_path, max_side=1600):
"""检测纸张四角,返回 (corners_原图坐标, info)。失败返回 ([], info)。"""
src = ImageOps.exif_transpose(Image.open(image_path)).convert('RGB')
src_w, src_h = src.size
pil, arr = load_and_scale(image_path, max_side=max_side)
H, W = arr.shape[:2]
paper = paper_mask(arr)
frac = float(paper.sum()) / (H * W)
band = boundary_band(paper, _odd(max(15, H // 45)))
edges = edge_map(arr)
step = boundary_step_filter(arr, paper)
cand = closing(edges & band & step, _odd(max(5, H // 160)))
cand = opening(cand, _odd(max(3, H // 500)))
ey, ex = np.nonzero(cand)
pts = np.stack([ex, ey], axis=1).astype(np.float32) if len(ex) > 40 else None
corners = detect_quad_corners(paper, points=pts)
scale = min(1.0, float(max_side) / max(src_w, src_h))
src_pts = [(x / scale, y / scale) for x, y in corners] if corners else []
info = {
'source_size': [src_w, src_h],
'processed_size': [W, H],
'scale': round(scale, 6),
'paper_frac': round(frac, 4),
'edge_pixels': int(cand.sum()),
'coverage': border_coverage_exact(cand, paper, tol=max(10, H // 110)) if corners else {},
'processed_pts': corners,
'edge_mask_small': cand, # 处理尺寸上的边线掩膜(供叠加出图)
}
return src_pts, info
@@ -11,9 +11,14 @@ LINE_WIDTH = 2
def draw_grid_on(im, step=50, major=100):
"""在原图上叠加坐标网格,返回同一个 Image 对象(不落盘)。"""
"""在原图上叠加坐标网格,返回叠加后的图像(不落盘)。
先画到独立的 RGBA 图层再合成:RGBA 底图直接画会被 ImageDraw 覆盖,
半透明线变成实心色,跟角标图上的网格对不上。
"""
W, H = im.size
d = ImageDraw.Draw(im, 'RGBA')
layer = Image.new('RGBA', im.size, (0, 0, 0, 0))
d = ImageDraw.Draw(layer)
try:
f = ImageFont.truetype(FONT, 18)
except Exception:
@@ -33,7 +38,7 @@ def draw_grid_on(im, step=50, major=100):
for y in range(0, H, major):
d.rectangle([1, y + 1, 46, y + 21], fill=(255, 255, 255, 220))
d.text((2, y + 1), str(y), fill=(0, 0, 200), font=f)
return im
return Image.alpha_composite(im.convert('RGBA'), layer).convert(im.mode)
def draw_grid(src, dst, step=50, major=100):
@@ -54,8 +54,6 @@ OUT_DIR = 'out'
CORNERS = os.path.join(OUT_DIR, 'corners.json')
LABELS = ('左上', '右上', '右下', '左下')
IMG_EXT = ('.jpg', '.jpeg', '.png', '.webp', '.bmp', '.tif', '.tiff')
# ---------------------------------------------------------------- 基础工具
@@ -113,18 +111,15 @@ def parse_quad(text):
def collect_images(args):
"""参数里的图片 + 当前目录全部图片(去重、按自然序)。"""
names = list(args)
"""只接受显式传入的图片(去重、按自然序);不再扫描当前目录。"""
names = [n for n in args if n]
if not names:
names = [f for f in os.listdir('.')
if f.lower().endswith(IMG_EXT) and os.path.isfile(f)]
raise SystemExit('必须显式指定图片,例如:prepare 图1.jpg 图2.jpg')
seen, out = set(), []
for n in names:
if n not in seen:
seen.add(n)
out.append(n)
if not out:
raise SystemExit('没有找到图片:可在命令后面直接列文件名')
missing = [n for n in out if not os.path.exists(n)]
if missing:
raise SystemExit('图片不存在:%s' % ', '.join(missing))
@@ -142,15 +137,38 @@ def out_path(prefix, i, name, ext='.png'):
# ---------------------------------------------------------------- prepare
def cmd_prepare(images):
def cmd_prepare(images, auto_quad=True):
os.makedirs(OUT_DIR, exist_ok=True)
from grid import draw_grid
import prepare as prep
data = load_corners()
cand = {}
for i, name in enumerate(images, 1):
dst = out_path('网格', i, name)
draw_grid(name, dst)
if auto_quad:
corners, info = prep.detect_corners(name)
if corners:
prep.render(name, dst, corners=corners,
edge_mask=info.get('edge_mask_small'),
scale=info.get('scale', 1.0))
cand[name] = corners
else:
prep.render(name, dst)
else:
prep.render(name, dst)
data.setdefault(name, None)
save_corners({k: v for k, v in data.items() if v})
if cand:
print('[候选角点] 已叠加到网格图(品红实心圆 = 候选角点,品红虚线 = 候选四边形,黑 = 检出边线)')
print('')
print('| 图片 | 左上 | 右上 | 右下 | 左下 |')
print('|---|---|---|---|---|')
for name, pts in cand.items():
cells = ['%d,%d' % (round(p[0]), round(p[1])) for p in pts]
print('| %s | %s |' % (name, ' | '.join(cells)))
print('')
print('[仅供参考] 候选值不得直接写入 corners.json,一律以角标图人工判读为准')
print('\n网格图已写入 %s/' % OUT_DIR)
print('下一步:照着网格图读数,把角点写进 %s:' % CORNERS)
for i, name in enumerate(images, 1):
@@ -201,12 +219,29 @@ def cmd_show():
return 0
# ---------------------------------------------------------------- 角标图
def grid_path(name):
"""找 prepare 生成的网格图(out/N-网格-<图名>.png);没有返回 None。"""
base = os.path.splitext(os.path.basename(name))[0]
if not os.path.isdir(OUT_DIR):
return None
# 用完整的 "-网格-<basename>.png" 后缀精确匹配,避免 a.jpg / 合同a.jpg 这类包含关系串图
want = '-网格-%s.png' % base
hits = [fn for fn in os.listdir(OUT_DIR)
if fn[:1].isdigit() and fn.endswith(want)]
if not hits:
return None
# 同名网格图有多份时取最新的一份(防止旧轮次的残留文件)
fn = max(hits, key=lambda f: os.path.getmtime(os.path.join(OUT_DIR, f)))
return os.path.join(OUT_DIR, fn)
def draw_marks(name, pts, dst):
"""把四角画回原图(底图叠加与网格图相同的网格),供人工核查。"""
"""把四角叠加到已生成的网格图上(找不到网格图时退回原图并即时叠网格)。"""
from preview_quad import draw_quad
im = draw_quad(name, pts, with_grid=True)
im = draw_quad(name, pts, base_path=grid_path(name), with_grid=True)
im.save(dst)
return dst
@@ -353,8 +388,10 @@ def main():
epilog=__doc__)
sub = ap.add_subparsers(dest='cmd', required=True)
p = sub.add_parser('prepare', help='出网格图(out/1-网格-*.png)')
p.add_argument('images', nargs='*', help='图片名,省略则取当前目录所有图片')
p = sub.add_parser('prepare', help='出网格图(out/1-网格-*.png),叠加候选角点')
p.add_argument('images', nargs='*', help='图片名(必填,可多个)')
p.add_argument('--no-auto-quad', action='store_true',
help='不跑候选角点检测,只出纯网格图')
p = sub.add_parser('set', help='把一张图的角点写进 out/corners.json')
p.add_argument('image', metavar='IMG', help='图片名(一次一张)')
@@ -380,7 +417,7 @@ def main():
help='另存边角放大块,便于细看')
p = sub.add_parser('all', help='prepare + build 一步到位')
p.add_argument('images', nargs='*')
p.add_argument('images', nargs='*', help='图片名(必填,可多个)')
p.add_argument('--out', default='文档_校正.pdf')
p.add_argument('--paper', default=None)
p.add_argument('--dpi', type=int, default=100)
@@ -390,7 +427,8 @@ def main():
args = ap.parse_args()
if args.cmd == 'prepare':
return cmd_prepare(collect_images(args.images))
return cmd_prepare(collect_images(args.images),
auto_quad=not args.no_auto_quad)
if args.cmd == 'set':
return cmd_set(args)
if args.cmd == 'show':
@@ -0,0 +1,94 @@
# -*- coding: utf-8 -*-
"""prepare 阶段的出图逻辑:坐标网格图 + 脚本候选角点/边线叠加。
产物
out/N-网格-<图名>.png 网格 + 候选角点(人工读数的主依据)
约定
- 候选角点只做**参考**:不落盘、不写 corners.json、不参与出件,
由 pipeline 直接在终端打成 markdown 表格供对照;
- 图上不写字,避免遮挡纸面内容。
"""
import math
import os
import sys
from PIL import Image, ImageDraw
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
from grid import draw_grid_on
COLOR_EDGE = (0, 0, 0) # 黑:脚本检出的边线像素
COLOR_CAND = (255, 0, 180) # 品红:候选四边形与角点
LABELS = ('左上', '右上', '右下', '左下')
def _dashed(d, p0, p1, fill, width=2, dash=14, gap=9):
dx, dy = p1[0] - p0[0], p1[1] - p0[1]
L = math.hypot(dx, dy)
if L < 1e-6:
return
ux, uy = dx / L, dy / L
t = 0.0
while t < L:
a, b = t, min(t + dash, L)
d.line([(p0[0] + ux * a, p0[1] + uy * a),
(p0[0] + ux * b, p0[1] + uy * b)], fill=fill, width=width)
t += dash + gap
def _extend(p0, p1, px):
dx, dy = p1[0] - p0[0], p1[1] - p0[1]
L = math.hypot(dx, dy)
if L < 1e-6:
return p0, p1
ux, uy = dx / L, dy / L
return (p0[0] - ux * px, p0[1] - uy * px), (p1[0] + ux * px, p1[1] + uy * px)
def render(src, dst, corners=None, edge_mask=None, scale=1.0, extend_px=None):
"""画网格图;corners 非空时叠加候选边线与角点。"""
im = Image.open(src).convert('RGBA')
if edge_mask is not None:
m = Image.fromarray((edge_mask * 255).astype('uint8'), 'L')
if m.size != im.size:
m = m.resize(im.size, Image.NEAREST)
lay = Image.new('RGBA', im.size, (0, 0, 0, 0))
lay.paste(COLOR_EDGE + (200,), (0, 0), m.point(lambda v: 255 if v > 127 else 0))
im = Image.alpha_composite(im, lay)
im = draw_grid_on(im)
if not corners:
im.convert('RGB').save(dst, quality=92)
return dst
d = ImageDraw.Draw(im, 'RGBA')
n = len(corners)
ext = extend_px if extend_px is not None else max(30, im.size[1] // 36)
for i in range(n):
a, b = _extend(corners[i], corners[(i + 1) % n], ext)
_dashed(d, a, b, COLOR_CAND + (240,), width=2)
for x, y in corners:
d.ellipse([x - 14, y - 14, x + 14, y + 14],
outline=(255, 255, 255, 255), width=4)
d.ellipse([x - 8, y - 8, x + 8, y + 8], fill=COLOR_CAND + (255,))
d.ellipse([x - 2, y - 2, x + 2, y + 2], fill=(255, 255, 255, 255))
im.convert('RGB').save(dst, quality=92)
return dst
def detect_corners(src, max_side=1600):
"""调用 auto_quad 取候选角点;失败返回 (None, None),不抛异常打断 prepare。"""
try:
import auto_quad
pts, info = auto_quad.detect(src, max_side=max_side)
return (pts or None), info
except Exception as e: # 检测失败不该阻塞流程
print('[提示] 候选角点检测跳过:%s' % e)
return None, None
@@ -63,10 +63,14 @@ def get_font(size=26):
return ImageFont.load_default()
def draw_quad(img_path, pts, scale=1.0, with_grid=False):
im = Image.open(img_path).convert('RGB')
# 角标图默认叠上与网格图同一套网格:坐标读数与框边可以对着看
if with_grid:
def draw_quad(img_path, pts, scale=1.0, base_path=None, with_grid=False):
"""在底图上叠加四角标注。
base_path 非空时直接用该图当底图(通常是 prepare 生成的网格图,连同候选标记一起继承);
为空时退回原图,with_grid=True 则即时叠一层网格。
"""
im = Image.open(base_path or img_path).convert('RGB')
if with_grid and base_path is None:
from grid import draw_grid_on
im = draw_grid_on(im)
if scale != 1.0: