| """Route-A production engine, shard 3/4. |
| Copied verbatim from routeA_pilot/ncc_engine.py + inkbox.py, plus a |
| multi-peak extractor needed for the column-wise monotone DP (recipe #5). |
| """ |
| import numpy as np |
| from PIL import Image |
|
|
|
|
| def _fast_len(n): |
| best = 2 * n |
| p5 = 1 |
| while p5 < best: |
| p3 = p5 |
| while p3 < best: |
| p2 = p3 |
| while p2 < n: |
| p2 *= 2 |
| if p2 < best: |
| best = p2 |
| p3 *= 3 |
| p5 *= 5 |
| return best |
|
|
|
|
| class ImgCtx: |
| """FFT numerator + integral-image denominator, image transform cached.""" |
|
|
| def __init__(self, img): |
| img = np.asarray(img, dtype=np.float64) |
| self.H, self.W = img.shape |
| self.Hf, self.Wf = _fast_len(self.H), _fast_len(self.W) |
| pad = np.zeros((self.Hf, self.Wf)) |
| pad[:self.H, :self.W] = img |
| |
| |
| self.F = np.fft.rfft2(pad.astype(np.float32)) |
| ii = np.zeros((self.H + 1, self.W + 1)) |
| ii2 = np.zeros((self.H + 1, self.W + 1)) |
| np.cumsum(np.cumsum(img, 0), 1, out=ii[1:, 1:]) |
| np.cumsum(np.cumsum(img * img, 0), 1, out=ii2[1:, 1:]) |
| self.ii, self.ii2 = ii, ii2 |
| del pad |
|
|
| def ncc(self, tpl): |
| """valid-mode NCC map. Bit-identical to the pilot's ncc() (verified |
| max|diff| = 0); the template transform is done in two stages so only |
| the h non-zero rows are row-transformed, and the denominator is built |
| in place -- 1.4x faster, same numbers.""" |
| h, w = tpl.shape |
| if h > self.H or w > self.W: |
| return None |
| tz = tpl - tpl.mean() |
| tnorm = float(np.sqrt((tz * tz).sum())) |
| if tnorm < 1e-8: |
| return None |
| T1 = np.fft.rfft(tz.astype(np.float32), n=self.Wf, axis=1) |
| Tp = np.zeros((self.Hf, T1.shape[1]), dtype=np.complex64) |
| Tp[:h] = T1 |
| G = np.fft.fft(Tp, axis=0) |
| np.conj(G, out=G) |
| G *= self.F |
| corr = np.fft.irfft2(G, s=(self.Hf, self.Wf)) |
| ny, nx = self.H - h + 1, self.W - w + 1 |
| num = corr[:ny, :nx] |
| ii, ii2 = self.ii, self.ii2 |
| s1 = ii[h:h + ny, w:w + nx] - ii[0:ny, w:w + nx] - ii[h:h + ny, 0:nx] + ii[0:ny, 0:nx] |
| var = ii2[h:h + ny, w:w + nx] - ii2[0:ny, w:w + nx] - ii2[h:h + ny, 0:nx] + ii2[0:ny, 0:nx] |
| n = h * w |
| s1 *= s1 |
| s1 /= n |
| var -= s1 |
| np.clip(var, 0, None, out=var) |
| |
| |
| |
| |
| |
| |
| ok = var > max(0.25 * n, 1e-4 * tnorm * tnorm) |
| np.sqrt(var, out=var) |
| var *= tnorm |
| var = var.astype(np.float32) |
| out = np.zeros_like(num) |
| np.divide(num, var, out=out, where=ok) |
| np.clip(out, -1.0, 1.0, out=out) |
| return out |
|
|
|
|
| def load_gray(path): |
| return np.asarray(Image.open(path).convert('L'), dtype=np.float64) |
|
|
|
|
| def resize_tpl(pil_gray, s): |
| w, h = pil_gray.size |
| nw, nh = max(4, int(round(w * s))), max(4, int(round(h * s))) |
| return np.asarray(pil_gray.resize((nw, nh), Image.LANCZOS), dtype=np.float64) |
|
|
|
|
| def top_peaks(m, th, tw, k=6): |
| """Top-k spatially separated peaks of a valid-mode NCC map. |
| Block-max NMS on cells of half template size, then refine inside the cell.""" |
| H, W = m.shape |
| by = max(4, th // 2) |
| bx = max(4, tw // 2) |
| ny = (H + by - 1) // by |
| nx = (W + bx - 1) // bx |
| pad = np.full((ny * by, nx * bx), -2.0, dtype=m.dtype) |
| pad[:H, :W] = m |
| blocks = pad.reshape(ny, by, nx, bx).max(axis=(1, 3)) |
| flat = blocks.ravel() |
| cand = np.argsort(flat)[::-1][:60] |
| used = np.zeros((ny, nx), bool) |
| out = [] |
| for idx in cand: |
| cy, cx = divmod(int(idx), nx) |
| if used[max(0, cy - 1):cy + 2, max(0, cx - 1):cx + 2].any(): |
| continue |
| sub = m[cy * by:min(H, (cy + 1) * by), cx * bx:min(W, (cx + 1) * bx)] |
| if sub.size == 0: |
| continue |
| j = int(np.argmax(sub)) |
| yy, xx = divmod(j, sub.shape[1]) |
| out.append((float(sub[yy, xx]), int(cx * bx + xx), int(cy * by + yy))) |
| used[cy, cx] = True |
| if len(out) >= k: |
| break |
| return out |
|
|
|
|
| def ink_bbox_arr(g, frac=0.03): |
| """verbatim from routeA_pilot/inkbox.py""" |
| h, w = g.shape |
| bg = np.percentile(g, 85) |
| thr = bg - 0.45 * (bg - np.percentile(g, 2)) |
| m = g < thr |
| cs = m.sum(0).astype(float) |
| rs = m.sum(1).astype(float) |
| if cs.max() < 1 or rs.max() < 1: |
| return (0, 0, w, h), 0 |
| def span(p): |
| t = max(1.0, frac * p.max()) |
| idx = np.where(p >= t)[0] |
| return int(idx[0]), int(idx[-1]) + 1 |
| x0, x1 = span(cs) |
| y0, y1 = span(rs) |
| if x1 - x0 < 4: x0, x1 = 0, w |
| if y1 - y0 < 4: y0, y1 = 0, h |
| return (x0, y0, x1, y1), int(m[y0:y1, x0:x1].sum()) |
|
|
|
|
| def iou(a, b): |
| ax, ay, aw, ah = a[0], a[1], a[2] - a[0], a[3] - a[1] |
| bx, by, bw, bh = b[0], b[1], b[2] - b[0], b[3] - b[1] |
| ix = max(0.0, min(ax + aw, bx + bw) - max(ax, bx)) |
| iy = max(0.0, min(ay + ah, by + bh) - max(ay, by)) |
| it = ix * iy |
| return it / (aw * ah + bw * bh - it + 1e-9) |
|
|
