1461 lines
72 KiB
Python
1461 lines
72 KiB
Python
#!/usr/bin/env python3
|
|
"""
|
|
cdcrop.py - split a flatbed scan holding CD covers into individually
|
|
straightened, tightly cropped PNG files.
|
|
|
|
For each cover it:
|
|
1. finds the cover against the scanner background by its outline,
|
|
2. measures all four edges to sub-pixel accuracy; edges with no crisp line
|
|
(folds, lifted or worn paper) are cropped where in-focus art begins,
|
|
3. chooses the rotation (auto mode) the way you would by eye:
|
|
- vertical lines in the art (boxes, text, borders) come out vertical,
|
|
- horizontal lines running along the top/bottom edge come out level,
|
|
- the thin wedges any rotation trims cost as little bold art as possible,
|
|
- otherwise it leans toward the left edge,
|
|
and flags close calls with an A/B sheet in _review/,
|
|
4. crops to the largest rectangle inside all four edges (no background),
|
|
5. rotates + crops in ONE Lanczos resample in floating point (no
|
|
intermediate rounding, no second interpolation pass),
|
|
6. writes a lossless PNG in the original colour mode with the original DPI.
|
|
|
|
Nothing else is changed: no colour correction, sharpening, or resizing.
|
|
|
|
Usage:
|
|
python cdcrop.py SCAN.bmp [SCAN2.bmp ...] -o OUTDIR
|
|
python cdcrop.py INPUT_FOLDER -o OUTDIR
|
|
Options:
|
|
--align auto|left|right|top|bottom default auto
|
|
--align-override "file.bmp:2=top" per cover: an edge, auto, or an angle like +0.15
|
|
--count N covers per scan (default 2)
|
|
--inset PX minimum px trimmed inside each edge (default 1.0); soft or
|
|
highlighted edges are trimmed further automatically
|
|
--no-preview skip preview images
|
|
Every run appends to OUTDIR/cdcrop_log.csv (angles considered, what was chosen).
|
|
Requires: pip install opencv-python numpy pillow scipy
|
|
"""
|
|
import argparse
|
|
import json
|
|
import math
|
|
import os
|
|
import sys
|
|
|
|
import cv2
|
|
from scipy.ndimage import median_filter
|
|
import numpy as np
|
|
from PIL import Image
|
|
|
|
# ----------------------------------------------------------------- loading
|
|
|
|
def load_scan(path):
|
|
im = Image.open(path)
|
|
dpi = im.info.get("dpi")
|
|
mode = im.mode
|
|
if mode == "P":
|
|
# palette BMPs: work in RGB, write back as RGB (lossless widening)
|
|
im = im.convert("RGB")
|
|
mode = "RGB"
|
|
if mode not in ("RGB", "L", "RGBA"):
|
|
raise ValueError(f"{path}: unsupported image mode {mode}")
|
|
arr = np.asarray(im)
|
|
return arr, mode, dpi
|
|
|
|
|
|
def save_png(arr, mode, dpi, path):
|
|
im = Image.fromarray(arr, mode=mode)
|
|
kw = {}
|
|
if dpi:
|
|
kw["dpi"] = tuple(round(float(d)) for d in dpi)
|
|
im.save(path, format="PNG", **kw)
|
|
|
|
# -------------------------------------------------------------- detection
|
|
#
|
|
# Covers are found by their outlines, not their colour: a cover's edge is a
|
|
# crisp transition (paper on glass), while the lid is smooth. This works for
|
|
# white covers on a white lid and copes with uneven lid shading.
|
|
|
|
def coarse_rects(arr, count, scale=3, grad_thr=2.0, return_shape=False):
|
|
"""Rough cover rectangles: flood-fill the smooth lid from the scan border;
|
|
whatever the flood can't reach (enclosed by sharp outlines) is a cover.
|
|
Edges are measured per colour channel (strongest wins), so a cream or
|
|
tinted cover on a white lid is found by its colour step even when its
|
|
brightness barely differs."""
|
|
chans = [arr[..., c] for c in range(min(3, arr.shape[2]))] if arr.ndim == 3 else [arr]
|
|
g = None
|
|
for ch_ in chans:
|
|
ch_ = ch_.astype(np.float32)
|
|
h, w = ch_.shape
|
|
s = cv2.resize(ch_, (w // scale, h // scale), interpolation=cv2.INTER_AREA)
|
|
s = cv2.GaussianBlur(s, (0, 0), 1.0)
|
|
gc = np.hypot(cv2.Sobel(s, cv2.CV_32F, 1, 0, ksize=3),
|
|
cv2.Sobel(s, cv2.CV_32F, 0, 1, ksize=3)) / 8
|
|
g = gc if g is None else np.maximum(g, gc)
|
|
edges = cv2.dilate((g > grad_thr).astype(np.uint8), np.ones((3, 3), np.uint8))
|
|
n, lab = cv2.connectedComponents(1 - edges)
|
|
border = set(np.unique(np.concatenate([lab[0], lab[-1], lab[:, 0], lab[:, -1]]))) - {0}
|
|
obj = (~np.isin(lab, list(border))).astype(np.uint8)
|
|
obj = cv2.morphologyEx(obj, cv2.MORPH_OPEN, np.ones((15, 15), np.uint8))
|
|
cnts, _ = cv2.findContours(obj, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
|
|
cnts = sorted(cnts, key=cv2.contourArea, reverse=True)[:count]
|
|
cnts = [c for c in cnts if cv2.contourArea(c) > 0.02 * obj.size]
|
|
rects = [cv2.minAreaRect(cv2.convexHull(c).astype(np.float32) * scale + (scale - 1) / 2.0)
|
|
for c in cnts]
|
|
if not return_shape:
|
|
return rects
|
|
circ = []
|
|
for c in cnts:
|
|
hull = cv2.convexHull(c)
|
|
A, P = cv2.contourArea(hull), cv2.arcLength(hull, True)
|
|
circ.append(4 * math.pi * A / (P * P)) # 1.0 circle, 0.785 square
|
|
return rects, circ
|
|
|
|
|
|
def rect_sides(rect):
|
|
"""Return the 4 sides of a cv2 rect as (p0, p1, outward_normal), named
|
|
left/right/top/bottom in image orientation."""
|
|
pts = cv2.boxPoints(rect)
|
|
c = pts.mean(axis=0)
|
|
named = {}
|
|
for i in range(4):
|
|
p0, p1 = pts[i], pts[(i + 1) % 4]
|
|
n = (p0 + p1) / 2 - c
|
|
n /= np.linalg.norm(n)
|
|
ang = math.degrees(math.atan2(n[1], n[0])) # 0 = right, 90 = down
|
|
key = ("right" if -45 <= ang < 45 else "bottom" if 45 <= ang < 135
|
|
else "top" if -135 <= ang < -45 else "left")
|
|
named[key] = (p0, p1, n)
|
|
if len(named) != 4:
|
|
raise RuntimeError("could not name cover sides")
|
|
return named
|
|
|
|
|
|
def _band(arr, p0, td, n, ts, offs):
|
|
base = p0[None, :] + ts[:, None] * td[None, :]
|
|
xs = (base[:, 0:1] + offs[None, :] * n[0]).astype(np.float32)
|
|
ys = (base[:, 1:2] + offs[None, :] * n[1]).astype(np.float32)
|
|
b = cv2.remap(arr, xs, ys, cv2.INTER_LINEAR, borderMode=cv2.BORDER_REPLICATE)
|
|
return b if b.ndim == 3 else b[..., None]
|
|
|
|
|
|
def fit_edge(arr, p0, p1, n, inner=130, outer=60, trim=0.08, max_ang=1.5):
|
|
"""Locate one cover edge near the coarse side p0-p1 (n = outward normal).
|
|
|
|
1. Sample a band across the side (inner px inside, outer px outside).
|
|
2. Search angles/offsets for straight lines along which a sharp transition
|
|
runs for most of the side (30th-percentile edge strength, so short art
|
|
features don't count), measured against the local level so busy
|
|
halftone print doesn't masquerade as an edge.
|
|
3. Of the strong candidates near the outline, take the INNERMOST one: the
|
|
paper's own edge, not its thickness shadow, a cut-edge line, or a page
|
|
sticking out from underneath.
|
|
4. Refine to sub-pixel per sample and fit a robust line.
|
|
Returns (point, unit direction, stats) or None."""
|
|
Ls = float(np.linalg.norm(p1 - p0)); td = (p1 - p0) / Ls
|
|
offs = np.arange(-inner, outer + 1, 1.0, dtype=np.float32)
|
|
ts = np.arange(trim * Ls, (1 - trim) * Ls, 4.0)
|
|
band = _band(arr, p0, td, n, ts, offs)
|
|
d = (cv2.Sobel(band, cv2.CV_32F, 1, 0, ksize=3) / 4)
|
|
dabs = np.abs(d).sum(axis=2) if d.ndim == 3 else np.abs(d)
|
|
tc = ts.mean()
|
|
best_prof, best_ang = None, None
|
|
angs = np.arange(-max_ang, max_ang + 1e-9, 0.05)
|
|
S = np.empty((len(angs), len(offs)), np.float32)
|
|
for k, ang in enumerate(angs):
|
|
sh = (ts - tc) * math.tan(math.radians(ang))
|
|
M = np.empty_like(dabs)
|
|
for i in range(len(ts)):
|
|
M[i] = np.interp(offs + sh[i], offs, dabs[i], left=0, right=0)
|
|
S[k] = np.percentile(M, 30, axis=0)
|
|
raw = S.max(axis=0)
|
|
# subtract the local level: textured art has a high, flat floor of
|
|
# gradient everywhere; a real edge stands up out of it.
|
|
prof = raw - median_filter(raw, size=31, mode="nearest")
|
|
pk = [j for j in range(1, len(offs) - 1)
|
|
if prof[j] >= prof[j - 1] and prof[j] > prof[j + 1] and prof[j] >= 0.5 * prof.max()]
|
|
if not pk:
|
|
return None
|
|
# Group candidate lines that lie within 30 px of each other. A narrow
|
|
# group is one edge plus its junk (shadow, cut-edge line, a page peeking
|
|
# out); a gap wider than that means a printed border or frame INSIDE the
|
|
# cover. So: take the outermost group with a strong line, and within it
|
|
# the innermost line - the paper's own edge.
|
|
pk_sorted = sorted(pk, key=lambda j: -offs[j]) # outermost first
|
|
groups, cur = [], [pk_sorted[0]]
|
|
for j in pk_sorted[1:]:
|
|
if offs[cur[-1]] - offs[j] <= 30:
|
|
cur.append(j)
|
|
else:
|
|
groups.append(cur); cur = [j]
|
|
groups.append(cur)
|
|
top_ = max(prof[j] for j in pk)
|
|
grp = next(g_ for g_ in groups if max(prof[j] for j in g_) >= 0.5 * top_)
|
|
j0 = min(grp, key=lambda j: offs[j]) # innermost of that group
|
|
ang0 = math.radians(angs[S[:, j0].argmax()])
|
|
strength = float(prof[j0])
|
|
|
|
# A cover edge is often a thin dark line (the paper's cut edge) or a step
|
|
# into a shadow: two transitions a few px apart. Average the SIGNED
|
|
# profile along the line and take the innermost transition, so the crop
|
|
# starts at the paper, never on the line itself or the lid beyond it.
|
|
dsig = d.sum(axis=2) if d.ndim == 3 else d
|
|
sh = (ts - tc) * math.tan(ang0)
|
|
Msig = np.empty_like(dsig)
|
|
for i in range(len(ts)):
|
|
Msig[i] = np.interp(offs + sh[i], offs, dsig[i], left=0, right=0)
|
|
ps = np.median(Msig, axis=0)
|
|
o0 = offs[j0]
|
|
w = [j for j in range(1, len(offs) - 1) if abs(offs[j] - o0) <= 6]
|
|
amax = max(abs(ps[j]) for j in w)
|
|
flank = [j for j in w if abs(ps[j]) >= abs(ps[j - 1]) and abs(ps[j]) > abs(ps[j + 1])
|
|
and abs(ps[j]) >= 0.35 * amax]
|
|
jf = min(flank, key=lambda j: offs[j]) if flank else j0
|
|
pol = 1.0 if ps[jf] >= 0 else -1.0
|
|
o_sel = float(offs[jf])
|
|
|
|
# How far inward does the transition reach? (blurry folds, edge highlights)
|
|
# Measured on the median luminance profile along the line; the crop is
|
|
# moved in past it so no blended edge pixels survive.
|
|
lumb = band.sum(axis=2) if band.ndim == 3 else band[..., 0]
|
|
Ml = np.empty_like(lumb)
|
|
for i in range(len(ts)):
|
|
Ml[i] = np.interp(offs + sh[i], offs, lumb[i])
|
|
pl = np.median(Ml, axis=0)
|
|
io = lambda o: int(np.clip(np.searchsorted(offs, o), 0, len(offs) - 1))
|
|
seg_i = pl[io(o_sel - 16):io(o_sel - 9)]
|
|
interior = float(np.median(seg_i)) if len(seg_i) else float(pl[0])
|
|
A = float(np.max(np.abs(pl[io(o_sel):io(o_sel + 4) + 1] - interior)))
|
|
reach = 0.0
|
|
for r_ in range(0, 9):
|
|
seg = pl[io(o_sel - 9):io(o_sel - r_) + 1]
|
|
if np.all(np.abs(seg - interior) <= 0.12 * A + 1.0):
|
|
reach = float(r_)
|
|
break
|
|
else:
|
|
reach = 8.0
|
|
edge_inset = reach + 0.5
|
|
|
|
# sub-pixel refinement around the chosen line, 1 px sampling along the side
|
|
ts2 = np.arange(trim * Ls, (1 - trim) * Ls, 2.0)
|
|
loc = np.arange(-3, 3.01, 0.25, dtype=np.float32)
|
|
o_line = o_sel + (ts2 - tc) * math.tan(ang0)
|
|
base = p0[None, :] + ts2[:, None] * td[None, :]
|
|
O = o_line[:, None] + loc[None, :]
|
|
xs = (base[:, 0:1] + O * n[0]).astype(np.float32)
|
|
ys = (base[:, 1:2] + O * n[1]).astype(np.float32)
|
|
b = cv2.remap(arr, xs, ys, cv2.INTER_CUBIC, borderMode=cv2.BORDER_REPLICATE)
|
|
lum = b.sum(axis=2) if b.ndim == 3 else b
|
|
sd = pol * np.gradient(lum, 0.25, axis=1)
|
|
mid = len(loc) // 2
|
|
lo, hi = mid - 5, mid + 6 # +/-1.25 px
|
|
k = np.argmax(sd[:, lo:hi], axis=1) + lo
|
|
r = np.arange(len(ts2))
|
|
ok = (sd[r, k] > 0) & (k > 0) & (k < len(loc) - 1)
|
|
y0, y1, y2 = sd[r, k - 1], sd[r, k], sd[r, np.minimum(k + 1, len(loc) - 1)]
|
|
den = y0 - 2 * y1 + y2
|
|
frac = np.where(den != 0, 0.5 * (y0 - y2) / np.where(den != 0, den, 1), 0.0)
|
|
oo = o_line + loc[k] + np.clip(frac, -0.5, 0.5) * 0.25
|
|
P = (base + oo[:, None] * n[None, :])[ok].astype(np.float32)
|
|
if len(P) < 30:
|
|
return None
|
|
keep = np.ones(len(P), bool)
|
|
for _ in range(4):
|
|
vx, vy, x0, y0 = cv2.fitLine(P[keep], cv2.DIST_HUBER, 0, 0.01, 0.01).ravel()
|
|
dvec = np.array([vx, vy]); pp = np.array([x0, y0])
|
|
resid = np.abs((P - pp) @ np.array([-vy, vx]))
|
|
new = resid < max(0.75, 3.0 * np.median(resid[keep]))
|
|
if (new == keep).all():
|
|
break
|
|
keep = new
|
|
if dvec @ td < 0:
|
|
dvec = -dvec
|
|
return pp, dvec, {"n": int(keep.sum()), "rms": float(np.sqrt(np.mean(resid[keep] ** 2))),
|
|
"strength": strength, "inset": edge_inset, "o_sel": o_sel,
|
|
"peaks": [(int(offs[j]), round(float(prof[j]), 1)) for j in pk]}
|
|
|
|
|
|
SOFT_STRENGTH = 6.0 # below this, a side has no crisp line to measure
|
|
|
|
|
|
def locate_soft_edge(arr, p0, p1, n, dvec, inner=150, outer=60, trim=0.08, tol=4.0):
|
|
"""Place a soft side (fold, lifted or curled paper, worn edge) whose angle
|
|
is taken from another edge (dvec). Walking inward from the lid, skip the
|
|
lid and the blurred transition, and stop at the first stretch where the
|
|
cover's content is steady along the whole side. Everything outside that
|
|
point is lid, shadow or out-of-focus paper."""
|
|
Ls = float(np.linalg.norm(p1 - p0)); td = (p1 - p0) / Ls
|
|
ts = np.arange(trim * Ls, (1 - trim) * Ls, 4.0); tc = ts.mean()
|
|
offs = np.arange(-inner, outer + 1, 1.0, dtype=np.float32)
|
|
tan_a = float(dvec @ n) / float(dvec @ td)
|
|
band = _band(arr, p0, td, n, ts, offs) # (T, O, C)
|
|
sh = (ts - tc) * tan_a
|
|
al = np.empty_like(band)
|
|
for i in range(len(ts)):
|
|
for c in range(band.shape[2]):
|
|
al[i, :, c] = np.interp(offs + sh[i], offs, band[i, :, c])
|
|
C = np.median(al, axis=0) # (O, C)
|
|
lum = al.mean(axis=2)
|
|
T = np.median(np.abs(lum - cv2.GaussianBlur(lum, (0, 0), sigmaX=0.01, sigmaY=2.0)), axis=0)
|
|
# core of the soft transition: steepest smoothed change near the outline
|
|
g = np.abs(np.gradient(C, axis=0)).max(axis=1)
|
|
g = np.convolve(g, np.ones(7) / 7, mode="same")
|
|
io = lambda o: int(np.clip(np.searchsorted(offs, o), 0, len(offs) - 1))
|
|
lo, hi = io(-75), io(25)
|
|
core = lo + int(np.argmax(g[lo:hi]))
|
|
# walk inward from the core until (a) the steep part of the blur is over
|
|
# (change per px below half its peak) and (b) on printed art, the fine
|
|
# halftone detail is back to full sharpness, i.e. the paper is on the glass.
|
|
Tm = np.convolve(T, np.ones(5) / 5, mode="same")
|
|
i0, i1 = max(0, core - 90), max(1, core - 45)
|
|
t_int = float(np.median(Tm[i0:i1]))
|
|
t_lid = float(np.median(Tm[io(outer - 25):]))
|
|
use_t = t_int > 3.0 * t_lid + 1.0
|
|
g_lim = 0.5 * float(g[core])
|
|
run, need = 0, 3
|
|
o_clean = float(offs[i1])
|
|
for k in range(core, i1, -1):
|
|
ok = (Tm[k] >= 0.75 * t_int) if use_t else (g[k] <= g_lim)
|
|
run = run + 1 if ok else 0
|
|
if run >= need:
|
|
o_clean = float(offs[k + need - 1]) - 1.0
|
|
break
|
|
pp = p0 + tc * td + o_clean * n
|
|
d = dvec if dvec @ td > 0 else -dvec
|
|
return pp, d, {"n": 0, "rms": float("nan"), "strength": 0.0, "inset": 0.5,
|
|
"o_sel": o_clean, "soft": True}
|
|
|
|
|
|
def intersect(pa, da, pb, db):
|
|
A = np.array([[da[0], -db[0]], [da[1], -db[1]]])
|
|
t = np.linalg.solve(A, pb - pa)
|
|
return pa + t[0] * da
|
|
|
|
# ------------------------------------------------------------- extraction
|
|
|
|
OPP = {"left": "right", "right": "left", "top": "bottom", "bottom": "top"}
|
|
ADJ = {"left": ("top", "bottom"), "right": ("top", "bottom"),
|
|
"top": ("left", "right"), "bottom": ("left", "right")}
|
|
|
|
|
|
def analyze_cover(arr, rect):
|
|
"""Fit all four edges of one cover (done once per cover)."""
|
|
sides = rect_sides(rect)
|
|
edges, soft = {}, []
|
|
for name, (p0, p1, n) in sides.items():
|
|
f = fit_edge(arr, p0, p1, n)
|
|
if f is None or f[2]["strength"] < SOFT_STRENGTH:
|
|
soft.append(name)
|
|
else:
|
|
edges[name] = f
|
|
borrowed = {}
|
|
for name in soft:
|
|
p0, p1, n = sides[name]
|
|
td = (p1 - p0) / np.linalg.norm(p1 - p0)
|
|
if OPP[name] in edges:
|
|
dv = edges[OPP[name]][1].copy(); src = OPP[name]
|
|
else:
|
|
adj = [edges[k][1] for k in ADJ[name] if k in edges]
|
|
if adj:
|
|
dv = np.mean([np.array([-v[1], v[0]]) * (1 if np.array([-v[1], v[0]]) @ td > 0 else -1)
|
|
for v in adj], axis=0)
|
|
src = "/".join(k for k in ADJ[name] if k in edges)
|
|
else:
|
|
dv = td.copy(); src = "outline"
|
|
dv = dv / np.linalg.norm(dv)
|
|
edges[name] = locate_soft_edge(arr, p0, p1, n, dv)
|
|
borrowed[name] = src
|
|
for k in ("left", "right"): # left/right point down
|
|
p, d, st = edges[k]; edges[k] = (p, d if d[1] > 0 else -d, st)
|
|
for k in ("top", "bottom"): # top/bottom point right
|
|
p, d, st = edges[k]; edges[k] = (p, d if d[0] > 0 else -d, st)
|
|
return {"edges": edges, "soft": soft, "borrowed": borrowed}
|
|
|
|
|
|
def axes(theta):
|
|
"""Output frame for a rotation of theta degrees (+ = clockwise lean corrected)."""
|
|
t = math.radians(theta)
|
|
ey = np.array([math.sin(t), math.cos(t)])
|
|
ex = np.array([math.cos(t), -math.sin(t)])
|
|
return ex, ey
|
|
|
|
|
|
def edge_theta(name, d):
|
|
"""Rotation (deg) that would make this edge exactly vertical/horizontal."""
|
|
if name in ("left", "right"):
|
|
return math.degrees(math.atan2(d[0], d[1]))
|
|
return math.degrees(math.atan2(-d[1], d[0]))
|
|
|
|
|
|
CORNER_LENIENCY = 0.0 # 0..1 (or a {"left":.., "right":.., "top":.., "bottom":..} dict of
|
|
# those): how far each side's bound relaxes from the conservative
|
|
# (most-trimmed) corner toward the other one, recovering art on
|
|
# non-square inserts without a manual push. Fit by cdcrop_tune_crop.py.
|
|
|
|
|
|
def frame_at(cov, theta, inset, edge_adj=None):
|
|
"""Largest crop rectangle at rotation theta that stays inside all edges.
|
|
Soft edges have no measurable angle, so they are taken as square to the
|
|
frame, anchored where their in-focus art begins.
|
|
|
|
edge_adj (optional, px): a manual push on one or more sides beyond that
|
|
automatic boundary - positive lets some lid back in to recover art an
|
|
automatic fit had to trim because the insert itself isn't quite square
|
|
(the fit is conservative: it sizes every side off whichever corner needs
|
|
the most trim, which can cost real art at the other corner - CORNER_LENIENCY
|
|
relaxes that by a fraction automatically); negative trims further in.
|
|
Keys: "left", "right", "top", "bottom"."""
|
|
ex, ey = axes(theta)
|
|
E = dict(cov["edges"])
|
|
for k in cov["soft"]:
|
|
p, d, st = E[k]
|
|
E[k] = (p, ey.copy() if k in ("left", "right") else ex.copy(), st)
|
|
tl = intersect(E["top"][0], E["top"][1], E["left"][0], E["left"][1])
|
|
tr = intersect(E["top"][0], E["top"][1], E["right"][0], E["right"][1])
|
|
bl = intersect(E["bottom"][0], E["bottom"][1], E["left"][0], E["left"][1])
|
|
br = intersect(E["bottom"][0], E["bottom"][1], E["right"][0], E["right"][1])
|
|
c = (tl + tr + bl + br) / 4
|
|
uv = lambda p: ((p - c) @ ex, (p - c) @ ey)
|
|
(utl, vtl), (utr, vtr), (ubl, vbl), (ubr, vbr) = map(uv, (tl, tr, bl, br))
|
|
ins = {k: max(inset, E[k][2]["inset"]) for k in E}
|
|
cl = CORNER_LENIENCY
|
|
beta = (lambda k: cl) if not isinstance(cl, dict) else (lambda k: cl.get(k, 0.0))
|
|
gaps = {"left": abs(utl - ubl), "right": abs(utr - ubr),
|
|
"top": abs(vtl - vtr), "bottom": abs(vbl - vbr)}
|
|
u0 = max(utl, ubl) - beta("left") * gaps["left"] + ins["left"]
|
|
u1 = min(utr, ubr) + beta("right") * gaps["right"] - ins["right"]
|
|
v0 = max(vtl, vtr) - beta("top") * gaps["top"] + ins["top"]
|
|
v1 = min(vbl, vbr) + beta("bottom") * gaps["bottom"] - ins["bottom"]
|
|
adj = edge_adj or {}
|
|
u0 -= adj.get("left", 0.0); u1 += adj.get("right", 0.0)
|
|
v0 -= adj.get("top", 0.0); v1 += adj.get("bottom", 0.0)
|
|
W = max(1, int(math.floor(u1 - u0))); H = max(1, int(math.floor(v1 - v0)))
|
|
u0 += ((u1 - u0) - W) / 2; v0 += ((v1 - v0) - H) / 2
|
|
origin = c + u0 * ex + v0 * ey
|
|
def dev(k):
|
|
return edge_theta(k, E[k][1]) - theta
|
|
return {"theta": theta, "ex": ex, "ey": ey, "origin": origin, "W": W, "H": H,
|
|
"ins": ins, "corners": (tl, tr, br, bl), "corner_gaps": gaps,
|
|
"crop_poly": [origin, origin + W * ex, origin + W * ex + H * ey, origin + H * ey],
|
|
"edge_dev_deg": {k: dev(k) for k in E}, "edge_adj": dict(adj)}
|
|
|
|
|
|
def render(arr, fr):
|
|
"""Rotate + crop in a single Lanczos resample, rounding once at the end."""
|
|
ex, ey, o = fr["ex"], fr["ey"], fr["origin"]
|
|
M = np.array([[ex[0], ey[0], o[0]], [ex[1], ey[1], o[1]]], dtype=np.float64)
|
|
out = cv2.warpAffine(arr, M, (fr["W"], fr["H"]),
|
|
flags=cv2.INTER_LANCZOS4 | cv2.WARP_INVERSE_MAP,
|
|
borderMode=cv2.BORDER_REPLICATE)
|
|
return np.clip(np.rint(out), 0, 255).astype(np.uint8)
|
|
|
|
|
|
def extract(arr, rect, align, inset, raw_inset=None):
|
|
"""Fixed-edge crop (used for --align-override and diagnostics)."""
|
|
cov = analyze_cover(arr, rect)
|
|
src = cov["borrowed"].get(align, align)
|
|
theta = edge_theta(src, cov["edges"][src][1])
|
|
if align in cov["soft"] and src not in ("left", "right", "top", "bottom"):
|
|
theta = 0.0
|
|
fr = frame_at(cov, theta, inset)
|
|
if raw_inset is not None:
|
|
cov2 = {**cov, "edges": {k: (p, d, {**st, "inset": raw_inset}) for k, (p, d, st) in cov["edges"].items()}}
|
|
fr = frame_at(cov2, theta, raw_inset)
|
|
info = {"rotation_deg": theta, "size": (fr["W"], fr["H"]), "edge_dev_deg": fr["edge_dev_deg"],
|
|
"edge_fit": {k: v[2] for k, v in cov["edges"].items()}, "insets": fr["ins"],
|
|
"soft": cov["soft"], "borrowed": cov["borrowed"], "used": src,
|
|
"corners": fr["corners"], "crop_poly": fr["crop_poly"]}
|
|
return render(arr, fr), info
|
|
|
|
# ----------------------------------------------------- art-aware angle choice
|
|
#
|
|
# Two things decide the rotation, the same two you'd judge by eye:
|
|
# * lines in the art that are meant to be square to the cover (boxes, text
|
|
# baselines, borders) should come out exactly horizontal/vertical;
|
|
# * the thin wedges every rotation trims off should cost as little
|
|
# *interesting* art as possible (plain paper is cheap, drawing/text is not).
|
|
|
|
LINE_MIN_LEN = 120 # px at full res; shorter segments are too imprecise
|
|
LINE_MAX_DEV = 0.8 # deg; lines tilted more than this are deliberate
|
|
TAPER_CAP = 3.0 # px; a line off by more than this is treated as deliberate
|
|
H_NEAR = 0.03 # horizontal lines count only this close (fraction of height)
|
|
# to the top/bottom edge, e.g. a border or strip
|
|
W_V = 2.5 # 1 px of lean on vertical art lines = this many px-strips of art
|
|
# Calibration (Alex's picks), all reproduced for W_V 2.0-2.75 with DEEP_BLEND 0.5:
|
|
# 447_1 Dirty Pretty Things ~0.00 (box sides square + top-right sketch kept)
|
|
# 447_2 Jesus Jones +0.41 left edge (lettering at top > blurry photo)
|
|
# 448_2 DJ C ~+1.65 right/bottom edges (not the torn top-right corner)
|
|
# 449_2 DFC left edge by a slim margin (treated as either)
|
|
# 451_1 Simple Minds no preference
|
|
W_H = 1.25 # ... on horizontal lines along the top/bottom edge
|
|
SAL_FLOOR = 60 # percentile of cover detail treated as "plain"
|
|
PROBE_DEPTHS = (30, 70) # px inside the edge where a wedge's art is judged
|
|
DEEP_BLEND = 0.5 # how much the deeper probe can veto edge-only detail (wear, tears)
|
|
ART_BASE = 0.0 # value of plain art relative to average detail
|
|
SAL_POWER = 2.0 # >1 makes bold detail count much more than faint marks
|
|
W_LEFT = 0.1 # ... and of straying from the left edge (your default)
|
|
W_EDGE = 0.0 # ... and of straying from the edges' consensus (their median angle)
|
|
W_BLUR = 0.0 # ... and of keeping out-of-focus art along an edge (lifted paper)
|
|
BLUR_PROBE = 60 # px further in where the art's normal sharpness is measured
|
|
BLUR_SLACK = 0.15 # sharpness dips smaller than this are ignored
|
|
REVIEW_MARGIN = 1.0 # score gap under which a distinct alternative is flagged for review
|
|
ALT_MIN_SEP = 0.1 # deg; alternatives closer than this look the same
|
|
LEFT_REVIEW = 0.15 # deg; straying further than this from the left edge gets a review
|
|
|
|
|
|
def _inside(quad, pts, margin):
|
|
q = np.array(quad, np.float32)
|
|
return np.array([cv2.pointPolygonTest(q, (float(x), float(y)), True) >= margin for x, y in pts])
|
|
|
|
|
|
def art_lines(gray, quad, theta0, side):
|
|
"""Straight, near-axis lines inside the art. Returns (theta_i, weight_i, segs)."""
|
|
q = np.array(quad, np.float32)
|
|
x0, y0 = np.floor(q.min(axis=0)).astype(int); x1, y1 = np.ceil(q.max(axis=0)).astype(int)
|
|
x0, y0 = max(x0, 0), max(y0, 0)
|
|
sub = gray[y0:y1, x0:x1]
|
|
half = cv2.resize(sub, (sub.shape[1] // 2, sub.shape[0] // 2), interpolation=cv2.INTER_AREA)
|
|
lsd = cv2.createLineSegmentDetector(cv2.LSD_REFINE_STD)
|
|
segs = lsd.detect(np.clip(half, 0, 255).astype(np.uint8))[0]
|
|
if segs is None:
|
|
return np.zeros(0), np.zeros(0), []
|
|
segs = segs.reshape(-1, 4) * 2 + [x0, y0, x0, y0]
|
|
blur = cv2.GaussianBlur(gray, (0, 0), 1.2)
|
|
th, wt, kept = [], [], []
|
|
loc = np.arange(-4, 4.01, 0.25, dtype=np.float32)
|
|
for xa, ya, xb, yb in segs:
|
|
P, Q = np.array([xa, ya]), np.array([xb, yb])
|
|
L = float(np.linalg.norm(Q - P))
|
|
if L < LINE_MIN_LEN:
|
|
continue
|
|
d = (Q - P) / L
|
|
vert = abs(d[1]) > abs(d[0])
|
|
if vert and d[1] < 0: d = -d
|
|
if not vert and d[0] < 0: d = -d
|
|
t_s = math.degrees(math.atan2(d[0], d[1])) if vert else math.degrees(math.atan2(-d[1], d[0]))
|
|
if abs(t_s - theta0) > LINE_MAX_DEV:
|
|
continue
|
|
if not _inside(quad, [P, Q], 40).all():
|
|
continue
|
|
# sub-pixel refinement at full resolution
|
|
nrm = np.array([-d[1], d[0]])
|
|
ts = np.arange(0.05 * L, 0.95 * L, 2.0)
|
|
base = P[None, :] + ts[:, None] * d[None, :]
|
|
xs = (base[:, 0:1] + loc[None, :] * nrm[0]).astype(np.float32)
|
|
ys = (base[:, 1:2] + loc[None, :] * nrm[1]).astype(np.float32)
|
|
prof = cv2.remap(blur, xs, ys, cv2.INTER_CUBIC, borderMode=cv2.BORDER_REPLICATE)
|
|
g = np.gradient(prof, 0.25, axis=1)
|
|
sgn = 1.0 if np.median(g[:, len(loc) // 2]) >= 0 else -1.0
|
|
g = g * sgn
|
|
k = np.argmax(g[:, 4:-4], axis=1) + 4
|
|
r = np.arange(len(ts))
|
|
ok = g[r, k] > 0
|
|
y_0, y_1, y_2 = g[r, k - 1], g[r, k], g[r, k + 1]
|
|
den = y_0 - 2 * y_1 + y_2
|
|
fr = np.where(den != 0, 0.5 * (y_0 - y_2) / np.where(den != 0, den, 1), 0)
|
|
off = loc[k] + np.clip(fr, -0.5, 0.5) * 0.25
|
|
pts = (base + off[:, None] * nrm[None, :])[ok].astype(np.float32)
|
|
if len(pts) < 0.6 * len(ts) or len(pts) < 20:
|
|
continue
|
|
vx, vy, px, py = cv2.fitLine(pts, cv2.DIST_HUBER, 0, 0.01, 0.01).ravel()
|
|
res = np.abs((pts - [px, py]) @ np.array([-vy, vx]))
|
|
rms = float(np.sqrt(np.mean(np.minimum(res, 3) ** 2)))
|
|
if rms > 1.0:
|
|
continue # wobbly (hand-drawn) - not a reference line
|
|
dd = np.array([vx, vy])
|
|
if vert and dd[1] < 0: dd = -dd
|
|
if not vert and dd[0] < 0: dd = -dd
|
|
t_f = math.degrees(math.atan2(dd[0], dd[1])) if vert else math.degrees(math.atan2(-dd[1], dd[0]))
|
|
if abs(t_f - theta0) > LINE_MAX_DEV:
|
|
continue
|
|
contrast = float(np.median(g[r, k][ok]))
|
|
C = np.array([px, py]) + (((P + Q) / 2 - [px, py]) @ dd) * dd # refined centre
|
|
th.append(t_f); wt.append(L * min(1.0, contrast / 20.0))
|
|
kept.append((P, Q, vert, L, C, dd))
|
|
return merge_lines(np.array(th), np.array(wt), kept)
|
|
|
|
|
|
def merge_lines(th, wt, segs, max_dang=0.2, max_off=2.5):
|
|
"""Join pieces of the same printed line (a divider or border broken up by
|
|
detail) into one line, so its lean is judged over its full length - the
|
|
way the eye sees it - rather than piece by piece."""
|
|
if len(th) == 0:
|
|
return th, wt, segs
|
|
used = np.zeros(len(th), bool)
|
|
out_t, out_w, out_s = [], [], []
|
|
order = np.argsort(-wt)
|
|
for i in order:
|
|
if used[i]:
|
|
continue
|
|
Pi, Qi, vi, Li, Ci, di = segs[i]
|
|
ni = np.array([-di[1], di[0]])
|
|
grp = [i]; used[i] = True
|
|
for j in order:
|
|
if used[j] or segs[j][2] != vi or abs(th[j] - th[i]) > max_dang:
|
|
continue
|
|
if abs((segs[j][4] - Ci) @ ni) <= max_off:
|
|
grp.append(j); used[j] = True
|
|
if len(grp) == 1:
|
|
out_t.append(th[i]); out_w.append(wt[i]); out_s.append((Pi, Qi, vi, Li)); continue
|
|
pts = []
|
|
for j in grp:
|
|
_, _, _, Lj, Cj, dj = segs[j]
|
|
pts += [Cj - dj * Lj / 2, Cj, Cj + dj * Lj / 2]
|
|
pts = np.array(pts, np.float32)
|
|
vx, vy, x0, y0 = cv2.fitLine(pts, cv2.DIST_L2, 0, 0.01, 0.01).ravel()
|
|
d = np.array([vx, vy])
|
|
if vi and d[1] < 0: d = -d
|
|
if not vi and d[0] < 0: d = -d
|
|
t = math.degrees(math.atan2(d[0], d[1])) if vi else math.degrees(math.atan2(-d[1], d[0]))
|
|
proj = (pts - [x0, y0]) @ d
|
|
ext = float(proj.max() - proj.min())
|
|
P = np.array([x0, y0]) + proj.min() * d; Q = np.array([x0, y0]) + proj.max() * d
|
|
out_t.append(t); out_w.append(float(sum(wt[j] for j in grp))); out_s.append((P, Q, vi, ext))
|
|
return np.array(out_t), np.array(out_w), out_s
|
|
|
|
|
|
def _family_cost(thetas, th, w, L):
|
|
"""Consensus within one family of lines: find the angle most of the line
|
|
length agrees on, drop lines that disagree with it (deliberately tilted
|
|
elements), then score every angle by the RMS taper (px) of the rest."""
|
|
if len(th) == 0:
|
|
return np.zeros(len(thetas)), 0.0, None
|
|
taper = np.abs(th[None, :] - thetas[:, None]) * math.pi / 180 * L[None, :]
|
|
K = (w[None, :] * np.exp(-taper ** 2)).sum(axis=1)
|
|
i = int(np.argmax(K))
|
|
agree = taper[i] <= TAPER_CAP / 2
|
|
wa = w[agree]
|
|
cost = np.sqrt((wa[None, :] * np.minimum(taper[:, agree], 8.0) ** 2).sum(axis=1) / wa.sum())
|
|
conf = min(1.0, float(wa.sum()) / 300.0) * math.sqrt(float(wa.sum()) / float(w.sum()))
|
|
return cost, conf, float(thetas[i])
|
|
|
|
|
|
def line_profile(thetas, th, wt, segs, fr0):
|
|
"""Line-straightness cost per candidate angle, following your priorities:
|
|
vertical lines in the art come first (judged against the sides, like your
|
|
left-edge default); horizontal lines only matter when they run along the
|
|
top or bottom edge. Returns (cost, conf_v, art_theta_v, cost_h, conf_h, art_theta_h)."""
|
|
H = float(fr0["H"]); ey, o = fr0["ey"], fr0["origin"]
|
|
vert = np.array([s_[2] for s_ in segs], bool) if segs else np.zeros(0, bool)
|
|
L = np.array([s_[3] for s_ in segs]) if segs else np.zeros(0)
|
|
near = np.zeros(len(segs), bool)
|
|
for i, (P, Q, v, _) in enumerate(segs):
|
|
if not v:
|
|
m = float(((P + Q) / 2 - o) @ ey)
|
|
near[i] = min(m, H - m) / H <= H_NEAR
|
|
# Lines confirmed by a perpendicular partner at the same angle form a
|
|
# frame, box or border - far stronger evidence than lone strokes, which
|
|
# are often lettering or collage set at deliberately varied angles.
|
|
wt = wt.copy()
|
|
if len(th):
|
|
base_w = wt.copy()
|
|
for i in range(len(th)):
|
|
other = (vert != vert[i]) & (np.abs(th - th[i]) <= 0.1)
|
|
wt[i] = base_w[i] * (1.0 + 2.0 * min(1.0, float(base_w[other].sum()) / 300.0))
|
|
cv, conf_v, tv = _family_cost(thetas, th[vert], wt[vert], L[vert]) if len(th) else (np.zeros(len(thetas)), 0.0, None)
|
|
hs = (~vert) & near
|
|
ch, conf_h, thh = _family_cost(thetas, th[hs], wt[hs], L[hs]) if len(th) else (np.zeros(len(thetas)), 0.0, None)
|
|
return cv, conf_v, tv, ch, conf_h, thh
|
|
|
|
|
|
def detail_samples(gray, quad, band=45, probe=30, step=2):
|
|
"""Sample points in the strip along the cover's outline (where different
|
|
rotations crop differently), each valued by how interesting the art is
|
|
just inside it. Probing ~30 px inward skips the cut edge, creases and
|
|
shadows, and tells plain background (cheap to lose) from drawing or
|
|
text (expensive). Detail is measured at ~75 dpi so halftone dots and
|
|
paper grain don't count as detail."""
|
|
q = np.array(quad, np.float32)
|
|
x0, y0 = np.floor(q.min(axis=0)).astype(int) - 8; x1, y1 = np.ceil(q.max(axis=0)).astype(int) + 8
|
|
x0, y0 = max(x0, 0), max(y0, 0)
|
|
sub = gray[y0:y1, x0:x1]
|
|
f = 8
|
|
sm = cv2.resize(sub, (sub.shape[1] // f, sub.shape[0] // f), interpolation=cv2.INTER_AREA)
|
|
gm = np.hypot(cv2.Sobel(sm, cv2.CV_32F, 1, 0, ksize=3), cv2.Sobel(sm, cv2.CV_32F, 0, 1, ksize=3)) / 8
|
|
I = cv2.blur(gm, (3, 3))
|
|
mask = np.zeros(sm.shape, np.uint8)
|
|
cv2.fillConvexPoly(mask, ((q - [x0, y0]) / f).astype(np.int32), 1)
|
|
mask = cv2.erode(mask, np.ones((5, 5), np.uint8))
|
|
# salience: faint smudges and grain count little, bold strokes/text a lot
|
|
floor = float(np.percentile(I[mask > 0], SAL_FLOOR))
|
|
I = np.maximum(I - floor, 0) ** SAL_POWER
|
|
mean_I = float(I[mask > 0].mean()) + 1e-3
|
|
# fine grid of points in the outline strip
|
|
yy, xx = np.mgrid[y0:y1:step, x0:x1:step].astype(np.float32)
|
|
P = np.stack([xx.ravel(), yy.ravel()], 1)
|
|
c = q.mean(axis=0)
|
|
dist = np.full(len(P), np.inf); nin = np.zeros_like(P)
|
|
for i in range(4):
|
|
a_, b_ = q[i], q[(i + 1) % 4]
|
|
t_ = (b_ - a_) / np.linalg.norm(b_ - a_); nn = np.array([-t_[1], t_[0]], np.float32)
|
|
if (c - a_) @ nn < 0: nn = -nn
|
|
d_ = (P - a_) @ nn
|
|
closer = d_ < dist
|
|
dist = np.where(closer, d_, dist); nin[closer] = nn
|
|
sel = (dist >= 0) & (dist <= band)
|
|
P, nin = P[sel], nin[sel]
|
|
# Probe at two depths and keep the lesser: real art (lettering, drawing,
|
|
# borders) carries on into the cover, while wear, tears and fibres at a
|
|
# damaged corner sit right at the edge and shouldn't be "saved".
|
|
from scipy.ndimage import map_coordinates
|
|
# out-of-focus art (paper lifted off the glass) counts as background: compare
|
|
# halftone-scale sharpness at each point with the art ~60 px further in
|
|
gs = gray[y0:y1, x0:x1].astype(np.float32)
|
|
g1 = cv2.GaussianBlur(gs, (0, 0), 1.0)
|
|
fine = cv2.blur(np.abs(gs - g1), (15, 15)) # halftone-scale detail
|
|
mid = cv2.blur(np.abs(g1 - cv2.GaussianBlur(gs, (0, 0), 4.0)), (15, 15))
|
|
ratio = fine / np.maximum(mid, 0.5) # drops where art is out of focus, whatever its contrast
|
|
at = lambda pts, im: map_coordinates(im, [pts[:, 1] - y0, pts[:, 0] - x0], order=1, mode="nearest")
|
|
inner = P + BLUR_PROBE * nin
|
|
r_here, r_in = at(P, ratio), at(inner, ratio)
|
|
structured = (at(inner, mid) > 1.5) & (at(P, mid) > 0.8)
|
|
blur = np.where(structured, np.clip(1 - r_here / np.maximum(r_in, 1e-3) - BLUR_SLACK, 0, 1), 0.0)
|
|
blur[dist[sel] < 4] = 0.0 # the cut edge itself isn't "art"
|
|
val = None
|
|
for depth in PROBE_DEPTHS:
|
|
pp_ = P + depth * nin
|
|
px = ((pp_[:, 0] - x0) - (f - 1) / 2) / f; py = ((pp_[:, 1] - y0) - (f - 1) / 2) / f
|
|
v_ = map_coordinates(I, [py, px], order=1, mode="constant", cval=0.0)
|
|
val = v_ if val is None else (1 - DEEP_BLEND) * val + DEEP_BLEND * np.minimum(val, v_)
|
|
val = val + ART_BASE * mean_I # any art is worth something, even flat colour
|
|
val = val * (1 - blur) # blurry art is no loss to trim
|
|
return P[:, 0], P[:, 1], val * step * step, mean_I, blur * step * step
|
|
|
|
|
|
def lost_art(fr, X, Y, Iw, mean_I, side):
|
|
"""Interesting art inside the cover but outside this crop, expressed as the
|
|
px-width of a strip of average art along one side."""
|
|
d = np.stack([X, Y], 1) - fr["origin"]
|
|
u = d @ fr["ex"]; v = d @ fr["ey"]
|
|
out = (u < 0) | (u > fr["W"]) | (v < 0) | (v > fr["H"])
|
|
return float(Iw[out].sum()) / (mean_I * side)
|
|
|
|
|
|
def angle_components(gray, cov, inset, step=0.002):
|
|
"""Everything the automatic angle choice weighs, on a fine grid of angles.
|
|
Computed once per cover; the weights are applied in combine_angle(), so a
|
|
tuning run can try hundreds of weightings in no time."""
|
|
E = cov["edges"]
|
|
named = {}
|
|
for k in ("left", "right", "top", "bottom"):
|
|
if k not in cov["soft"]:
|
|
named[k] = edge_theta(k, E[k][1])
|
|
if not named:
|
|
named["outline"] = 0.0
|
|
theta0 = float(np.median(list(named.values())))
|
|
fr0 = frame_at(cov, theta0, inset)
|
|
quad = fr0["corners"]
|
|
side = float(max(fr0["W"], fr0["H"]))
|
|
th, wt, segs = art_lines(gray, quad, theta0, side)
|
|
strong = list(th[wt > 0.1 * wt.max()]) if len(th) else []
|
|
lo = min(list(named.values()) + strong) - 0.15
|
|
hi = max(list(named.values()) + strong) + 0.15
|
|
lo, hi = max(lo, theta0 - 1.5), min(hi, theta0 + 1.5)
|
|
thetas = np.unique(np.concatenate([np.arange(lo, hi + 1e-9, step), np.array(list(named.values()))]))
|
|
cv, conf_v, tv, chh, conf_h, thh = line_profile(thetas, th, wt, segs, fr0)
|
|
frames = [frame_at(cov, t, inset) for t in thetas]
|
|
comp = {"thetas": thetas, "named": dict(named), "side": side, "quad": quad, "frames": frames,
|
|
"cv": cv, "conf_v": conf_v, "tv": tv, "chh": chh, "conf_h": conf_h, "thh": thh,
|
|
"segs": segs, "n_lines": int(len(th)),
|
|
"left_px": (np.abs(thetas - named["left"]) * math.pi / 180 * side) if "left" in named
|
|
else np.zeros_like(thetas),
|
|
"edge_px": np.abs(thetas - theta0) * math.pi / 180 * side}
|
|
comp["loss"] = component_loss(comp, gray)
|
|
return comp
|
|
|
|
|
|
def component_loss(comp, gray):
|
|
"""Lost-art term for every angle in comp (depends on the detail settings);
|
|
also stores comp["blur"]: out-of-focus edge art each angle would keep."""
|
|
X, Y, Iw, mean_I, Bw = detail_samples(gray, comp["quad"])
|
|
loss, kept = [], []
|
|
for f in comp["frames"]:
|
|
d = np.stack([X, Y], 1) - f["origin"]
|
|
u = d @ f["ex"]; v = d @ f["ey"]
|
|
out = (u < 0) | (u > f["W"]) | (v < 0) | (v > f["H"])
|
|
loss.append(float(Iw[out].sum()) / (mean_I * comp["side"]))
|
|
kept.append(float(Bw[~out].sum()) / comp["side"])
|
|
loss, kept = np.array(loss), np.array(kept)
|
|
comp["blur"] = kept - kept.min()
|
|
return loss - loss.min()
|
|
|
|
|
|
def combine_angle(comp, W=None):
|
|
"""Apply the weights: pick the best angle, a runner-up for review, and an
|
|
explanation table. W overrides the module's weights (used by tuning)."""
|
|
g = globals()
|
|
W = W or {}
|
|
wv, wh = W.get("W_V", g["W_V"]), W.get("W_H", g["W_H"])
|
|
wl, we = W.get("W_LEFT", g["W_LEFT"]), W.get("W_EDGE", g["W_EDGE"])
|
|
loss = W.get("loss", comp["loss"])
|
|
thetas, named = comp["thetas"], dict(comp["named"])
|
|
wb = W.get("W_BLUR", g["W_BLUR"])
|
|
blur = W.get("blur", comp.get("blur", np.zeros_like(loss)))
|
|
total = (loss + wv * comp["conf_v"] * comp["cv"] + wh * comp["conf_h"] * comp["chh"]
|
|
+ wl * comp["left_px"] + we * comp["edge_px"] + wb * blur)
|
|
i = int(np.argmin(total))
|
|
best = float(thetas[i])
|
|
if comp["tv"] is not None and comp["conf_v"] > 0.15:
|
|
named["art verticals"] = comp["tv"]
|
|
if comp["thh"] is not None and comp["conf_h"] > 0.15:
|
|
named["edge horizontals"] = comp["thh"]
|
|
at = lambda t: int(np.argmin(np.abs(thetas - t)))
|
|
table = {name: {"theta": t, "total": float(total[at(t)]) - float(total[i]),
|
|
"loss": float(loss[at(t)]), "line": float(comp["cv"][at(t)])}
|
|
for name, t in named.items()}
|
|
# runner-up: a genuinely different option - another local minimum at least
|
|
# ALT_MIN_SEP away that scores nearly as well
|
|
mins = [j for j in range(1, len(thetas) - 1) if total[j] <= total[j - 1] and total[j] <= total[j + 1]]
|
|
if len(thetas) > 1:
|
|
mins += [j for j in (0, len(thetas) - 1) if total[j] <= total[1 if j == 0 else len(thetas) - 2]]
|
|
cand = [j for j in mins if abs(thetas[j] - best) >= ALT_MIN_SEP and total[j] - total[i] < REVIEW_MARGIN]
|
|
alt, alt_why = None, None
|
|
if cand:
|
|
alt = float(thetas[min(cand, key=lambda j: total[j])]); alt_why = "close call"
|
|
elif "left" in named and abs(best - named["left"]) > LEFT_REVIEW:
|
|
alt = float(named["left"]); alt_why = "left edge" # overriding your usual habit
|
|
return {"theta": best, "alt": alt, "alt_why": alt_why, "conf": max(comp["conf_v"], comp["conf_h"]),
|
|
"art_theta": comp["tv"], "art_theta_h": comp["thh"], "named": table,
|
|
"n_lines": comp["n_lines"], "segs": comp["segs"], "best_loss": float(loss[i]),
|
|
"conf_v": comp["conf_v"], "conf_h": comp["conf_h"], "best_line": float(comp["cv"][i]),
|
|
"alt_gap": float(total[at(alt)] - total[i]) if alt is not None else None}
|
|
|
|
|
|
def choose_angle(arr, gray, cov, inset):
|
|
"""Automatic rotation for one cover (see angle_components / combine_angle)."""
|
|
return combine_angle(angle_components(gray, cov, inset))
|
|
|
|
|
|
# ------------------------------------------------------------------- tuning
|
|
#
|
|
# The weights above can be tuned to your own picks with cdcrop_tune.py, which
|
|
# writes cdcrop_tuning.json next to this script; it is loaded automatically.
|
|
|
|
TUNABLE = ("W_V", "W_H", "W_LEFT", "W_EDGE", "W_BLUR", "DEEP_BLEND", "SAL_POWER", "SAL_FLOOR",
|
|
"CORNER_LENIENCY")
|
|
TUNING_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), "cdcrop_tuning.json")
|
|
|
|
|
|
def load_tuning(path=TUNING_PATH):
|
|
if not os.path.exists(path):
|
|
return None
|
|
with open(path) as fh:
|
|
t = json.load(fh)
|
|
for k in TUNABLE:
|
|
if k in t.get("weights", {}):
|
|
v = t["weights"][k]
|
|
globals()[k] = v if isinstance(v, dict) else type(globals()[k])(v)
|
|
return t
|
|
|
|
|
|
# ------------------------------------------------------------------- discs
|
|
#
|
|
# A disc is found by its outline like a cover, recognised by being round, and
|
|
# then fitted as the circle that follows a sharp edge most consistently all
|
|
# the way round, sized near a CD's standard 120 mm (the clear plastic rim and
|
|
# a one-sided shadow can't fool that; the printed label isn't always centred).
|
|
# The output is a square centred on the disc; rotation trims nothing, so the
|
|
# only question is which way is up.
|
|
|
|
DISC_CIRC = 0.90 # outline circularity above which an object is a disc
|
|
DISC_MM = 120.0
|
|
DISC_MARGIN = 6 # px of lid kept around the disc edge
|
|
DISC_LINE_STRONG = 10.0 # straight-text evidence strong enough to level automatically
|
|
DISC_REVIEW_DEG = 15.0 # automatic turns bigger than this get a review
|
|
|
|
|
|
def fit_disc(arr, c0, dpi, coarse_d=None):
|
|
"""Centre and radius of a disc's physical edge (sub-pixel)."""
|
|
from scipy.ndimage import map_coordinates
|
|
from scipy.optimize import minimize
|
|
R0 = DISC_MM / 2 / 25.4 * dpi
|
|
if coarse_d is not None and abs(coarse_d / 2 / R0 - 1) > 0.06: # mini CD or other size
|
|
R0 = coarse_d / 2 * 0.99
|
|
x0, y0 = max(int(c0[0] - R0 - 80), 0), max(int(c0[1] - R0 - 80), 0)
|
|
sub = arr[y0:int(c0[1] + R0 + 80), x0:int(c0[0] + R0 + 80)]
|
|
G = None
|
|
for c in range(min(3, sub.shape[2]) if sub.ndim == 3 else 1):
|
|
ch = cv2.GaussianBlur((sub[..., c] if sub.ndim == 3 else sub).astype(np.float32), (0, 0), 0.8)
|
|
gm = np.hypot(cv2.Sobel(ch, cv2.CV_32F, 1, 0, ksize=3), cv2.Sobel(ch, cv2.CV_32F, 0, 1, ksize=3)) / 8
|
|
G = gm if G is None else np.maximum(G, gm)
|
|
G = cv2.GaussianBlur(G, (0, 0), 1.2)
|
|
th = np.radians(np.arange(0, 360, 0.25)); ct, st = np.cos(th), np.sin(th)
|
|
Rlo, Rhi = R0 - 8, R0 + 6
|
|
|
|
def coverage(p):
|
|
cx, cy, R = p
|
|
if R < Rlo or R > Rhi:
|
|
return -1.0
|
|
v = map_coordinates(G, [cy - y0 + R * st, cx - x0 + R * ct], order=1, mode="nearest")
|
|
return float(np.mean(np.sqrt(np.minimum(v, 40.0))))
|
|
best = None
|
|
for R in np.arange(Rlo, Rhi + 0.01, 1.0):
|
|
for dx in range(-14, 15, 2):
|
|
for dy in range(-14, 15, 2):
|
|
sc = coverage((c0[0] + dx, c0[1] + dy, R))
|
|
if best is None or sc > best[0]:
|
|
best = (sc, (c0[0] + dx, c0[1] + dy, R))
|
|
res = minimize(lambda p: -coverage(p), best[1], method="Nelder-Mead", options={"xatol": 0.05, "fatol": 1e-5})
|
|
cx, cy, R = res.x
|
|
return np.array([cx, cy]), float(R)
|
|
|
|
|
|
def disc_frame(center, R, theta, margin=DISC_MARGIN):
|
|
"""Square output centred on the disc, rotated by theta."""
|
|
S = int(math.ceil(2 * (R + margin)))
|
|
ex, ey = axes(theta)
|
|
origin = np.asarray(center, float) - (S - 1) / 2 * (ex + ey)
|
|
poly = [origin, origin + S * ex, origin + S * ex + S * ey, origin + S * ey]
|
|
return {"theta": theta, "ex": ex, "ey": ey, "origin": origin, "W": S, "H": S, "ins": {},
|
|
"corners": poly, "crop_poly": poly, "edge_dev_deg": {}, "disc": True,
|
|
"center": np.asarray(center, float), "R": R}
|
|
|
|
|
|
def _wrap(t):
|
|
return (t + 180) % 360 - 180
|
|
|
|
|
|
def disc_orientation(gray, center, R):
|
|
"""Rotation candidates for a disc and an automatic pick.
|
|
- level: straight text/graphics made level (quarter-turn nearest as scanned)
|
|
- text arc at top: the biggest arc of text around the rim, centred at the top
|
|
The automatic pick levels strong straight text, else centres a text arc
|
|
that is already near the top, else leaves the disc as scanned - and flags
|
|
anything that isn't clear-cut."""
|
|
c = np.asarray(center, float)
|
|
cand, notes = {"as scanned": 0.0}, []
|
|
# straight lines on the label
|
|
x0, y0 = max(int(c[0] - R), 0), max(int(c[1] - R), 0)
|
|
sub = gray[y0:int(c[1] + R), x0:int(c[0] + R)]
|
|
half = cv2.resize(sub, (sub.shape[1] // 2, sub.shape[0] // 2), interpolation=cv2.INTER_AREA)
|
|
segs = cv2.createLineSegmentDetector(cv2.LSD_REFINE_STD).detect(np.clip(half, 0, 255).astype(np.uint8))[0]
|
|
strength = 0.0
|
|
if segs is not None:
|
|
segs = segs.reshape(-1, 4) * 2 + [x0, y0, x0, y0]
|
|
mid = (segs[:, :2] + segs[:, 2:]) / 2
|
|
rad = np.hypot(mid[:, 0] - c[0], mid[:, 1] - c[1])
|
|
L = np.hypot(segs[:, 2] - segs[:, 0], segs[:, 3] - segs[:, 1])
|
|
ok = (rad > 0.30 * R) & (rad < 0.93 * R) & (L > 25)
|
|
d = segs[ok, 2:] - segs[ok, :2]
|
|
ang = np.degrees(np.arctan2(d[:, 1], d[:, 0])) % 90
|
|
hist = np.zeros(360)
|
|
for a_, w in zip(ang, L[ok]):
|
|
hist[int(a_ * 4) % 360] += w
|
|
hist = np.convolve(np.r_[hist[-6:], hist, hist[:6]], np.hanning(9), "same")[6:-6]
|
|
k = int(np.argmax(hist))
|
|
strength = float(hist[k] / (np.median(hist) + 1e-6))
|
|
# refine: length-weighted mean of nearby segment angles
|
|
sel = np.abs(((ang - k / 4.0) + 45) % 90 - 45) < 1.0
|
|
if sel.any():
|
|
w = L[ok][sel]
|
|
dev = ((ang[sel] - k / 4.0) + 45) % 90 - 45
|
|
peak = k / 4.0 + float((dev * w).sum() / w.sum())
|
|
else:
|
|
peak = k / 4.0
|
|
lev = _wrap(-peak)
|
|
lev = ((lev + 45) % 90) - 45 # the quarter turn nearest "as scanned"
|
|
if strength >= 4:
|
|
cand["level text"] = lev
|
|
# text arc around the rim
|
|
th = np.radians(np.arange(0, 360, 0.25)); rr = np.arange(0.80 * R, 0.965 * R, 1.0, dtype=np.float32)
|
|
xs = (c[0] + np.cos(th)[:, None] * rr).astype(np.float32); ys = (c[1] + np.sin(th)[:, None] * rr).astype(np.float32)
|
|
P = cv2.remap(gray.astype(np.float32), xs, ys, cv2.INTER_LINEAR)
|
|
hp = np.abs(P - cv2.GaussianBlur(P, (0, 0), sigmaX=6, sigmaY=6))
|
|
e = hp.mean(axis=1)
|
|
e = np.convolve(np.r_[e[-40:], e, e[:40]], np.ones(41) / 41, "same")[40:-40]
|
|
on = e > np.median(e) + 2.5 * np.median(np.abs(e - np.median(e)))
|
|
arc = None
|
|
if on.any() and not on.all():
|
|
s2 = np.r_[on, on]; best = (0, 0); i = 0
|
|
while i < len(on):
|
|
if s2[i]:
|
|
j = i
|
|
while j < i + len(on) and s2[j]:
|
|
j += 1
|
|
if j - i > best[1] - best[0]:
|
|
best = (i, j)
|
|
i = j
|
|
else:
|
|
i += 1
|
|
span = (best[1] - best[0]) * 0.25
|
|
if span >= 20:
|
|
mid = ((best[0] + best[1]) / 2 * 0.25) % 360 # image angle of the arc centre
|
|
arc = (mid, span)
|
|
cand["rim text at top"] = _wrap(-90 - mid)
|
|
# automatic pick
|
|
if "level text" in cand and strength >= DISC_LINE_STRONG:
|
|
auto, why = cand["level text"], "straight text levelled"
|
|
elif arc and abs(cand["rim text at top"]) <= 30:
|
|
auto, why = cand["rim text at top"], "text arc centred at the top"
|
|
else:
|
|
auto, why = 0.0, "left as scanned (no clear straight text)"
|
|
flagged = (why.startswith("left") or abs(auto) > DISC_REVIEW_DEG)
|
|
return {"candidates": cand, "auto": float(auto), "why": why, "flagged": bool(flagged),
|
|
"line_strength": strength}
|
|
|
|
|
|
def find_objects(arr, count, dpi):
|
|
"""Covers and discs in one scan: [(kind, rect, circularity)], in reading order."""
|
|
rects, circ = coarse_rects(arr, count, return_shape=True)
|
|
objs = [("disc" if c >= DISC_CIRC else "cover", r, c) for r, c in zip(rects, circ)]
|
|
cents = np.array([o[1][0] for o in objs]) if objs else np.zeros((0, 2))
|
|
axis = 0 if len(cents) < 2 or np.ptp(cents[:, 0]) >= np.ptp(cents[:, 1]) else 1
|
|
order = np.argsort(cents[:, axis]) if len(cents) else []
|
|
return [objs[i] for i in order]
|
|
|
|
# ------------------------------------------------------- scanner calibration
|
|
#
|
|
# A flatbed's carriage may not travel exactly perpendicular to its sensor, and
|
|
# its step size along the travel may be slightly off, so a scan is the true
|
|
# object seen through scan = M . true, M = [[1, k], [0, sy]]
|
|
# (x = along the sensor, assumed exact; y = carriage travel). Squares come out
|
|
# as slightly skewed rectangles. Measure M once with --calibrate (two scans of
|
|
# the same flat cover, turned roughly a quarter turn between them); after that
|
|
# every crop is computed in true geometry and the correction is folded into
|
|
# the single final resample, so it costs no extra interpolation.
|
|
|
|
CAL = None # {"sy": .., "k": ..} when a calibration is loaded
|
|
|
|
|
|
def load_calibration(path):
|
|
global CAL
|
|
with open(path) as fh:
|
|
CAL = json.load(fh)
|
|
return CAL
|
|
|
|
|
|
def true_space(arr, cal):
|
|
"""(arr_true, A): arr resampled into true geometry for *analysis only*, and
|
|
A (2x3) mapping true coords -> scan coords, used for the final render."""
|
|
if not cal:
|
|
return arr, None
|
|
sy, k = float(cal["sy"]), float(cal["k"])
|
|
M = np.array([[1.0, k], [0.0, sy]])
|
|
Mi = np.linalg.inv(M)
|
|
h, w = arr.shape[:2]
|
|
corners = np.array([[0, 0], [w, 0], [0, h], [w, h]], float)
|
|
tc = corners @ Mi.T
|
|
lo = tc.min(axis=0)
|
|
Wt, Ht = int(math.ceil(tc[:, 0].max() - lo[0])), int(math.ceil(tc[:, 1].max() - lo[1]))
|
|
A = np.hstack([M, (M @ lo).reshape(2, 1)]) # scan = M (t + lo)
|
|
arr_t = cv2.warpAffine(arr, A, (Wt, Ht), flags=cv2.INTER_LINEAR | cv2.WARP_INVERSE_MAP,
|
|
borderMode=cv2.BORDER_REPLICATE)
|
|
return arr_t, A
|
|
|
|
|
|
def frame_to_scan(fr, A):
|
|
"""Express an output frame defined in true geometry in scan coordinates."""
|
|
if A is None:
|
|
return fr
|
|
L, t = A[:, :2], A[:, 2]
|
|
f2 = dict(fr)
|
|
f2["origin"] = L @ np.asarray(fr["origin"], float) + t
|
|
f2["ex"] = L @ np.asarray(fr["ex"], float)
|
|
f2["ey"] = L @ np.asarray(fr["ey"], float)
|
|
return f2
|
|
|
|
|
|
def calibrate_pair(path1, path2, verbose=True):
|
|
"""Measure the scanner's stretch and shear from two scans of the same flat,
|
|
detailed item (a cover), turned roughly 90 degrees between scans."""
|
|
from scipy.optimize import least_squares
|
|
imgs = []
|
|
for p in (path1, path2):
|
|
a8, _, _ = load_scan(p)
|
|
g = a8[..., :3].mean(axis=2).astype(np.float32) if a8.ndim == 3 else a8.astype(np.float32)
|
|
imgs.append(g)
|
|
# 1. match features on the cover at 1/2 scale, 2. fit a full affine to all
|
|
# inliers (thousands of matches pin it to ~1e-6)
|
|
h = 2
|
|
sm = [cv2.resize(g, (g.shape[1] // h, g.shape[0] // h), interpolation=cv2.INTER_AREA) for g in imgs]
|
|
sm = [np.clip(g, 0, 255).astype(np.uint8) for g in sm]
|
|
masks = []
|
|
for g in imgs:
|
|
rect = coarse_rects(np.dstack([g] * 3), 1)[0]
|
|
m = np.zeros(sm[0].shape[:2] if g is imgs[0] else sm[1].shape[:2], np.uint8)
|
|
box = cv2.boxPoints(((rect[0][0] / h, rect[0][1] / h), (rect[1][0] / h * 0.97, rect[1][1] / h * 0.97), rect[2]))
|
|
cv2.fillConvexPoly(m, box.astype(np.int32), 255)
|
|
masks.append(m)
|
|
det = cv2.SIFT_create(nfeatures=20000)
|
|
k1, d1 = det.detectAndCompute(sm[0], masks[0]); k2, d2 = det.detectAndCompute(sm[1], masks[1])
|
|
mt = cv2.BFMatcher(cv2.NORM_L2).knnMatch(d1, d2, k=2)
|
|
good = [m for m, n in (x for x in mt if len(x) == 2) if m.distance < 0.75 * n.distance]
|
|
if len(good) < 50:
|
|
raise RuntimeError("couldn't match the two scans - use the same flat, detailed cover in both")
|
|
P1 = np.float64([k1[m.queryIdx].pt for m in good]) * h
|
|
P2 = np.float64([k2[m.trainIdx].pt for m in good]) * h
|
|
A0, inl = cv2.estimateAffine2D(P1, P2, method=cv2.RANSAC, ransacReprojThreshold=3.0, maxIters=5000)
|
|
inl = inl.ravel().astype(bool)
|
|
for _ in range(3): # least squares on inliers, then tighten
|
|
X = np.hstack([P1[inl], np.ones((inl.sum(), 1))])
|
|
sol_, *_ = np.linalg.lstsq(X, P2[inl], rcond=None)
|
|
A0 = sol_.T
|
|
err = np.linalg.norm(P2 - (P1 @ A0[:, :2].T + A0[:, 2]), axis=1)
|
|
inl = err < max(1.0, 2.5 * np.median(err[inl]))
|
|
Al = A0[:, :2]
|
|
cc = float(inl.sum()); rms_px = float(np.sqrt(np.mean(err[inl] ** 2)))
|
|
# 3. solve Al M = M R(phi) for M = [[1,k],[0,sy]]
|
|
def resid(p):
|
|
k, sy, phi = p
|
|
M = np.array([[1, k], [0, sy]]); Rm = np.array([[math.cos(phi), -math.sin(phi)], [math.sin(phi), math.cos(phi)]])
|
|
return (Al @ M - M @ Rm).ravel()
|
|
phi0 = math.atan2(Al[1, 0] - Al[0, 1], Al[0, 0] + Al[1, 1])
|
|
sol = least_squares(resid, [0.0, 1.0, phi0])
|
|
k, sy, phi = sol.x
|
|
turn = math.degrees(phi)
|
|
out = {"sy": float(sy), "k": float(k), "shear_deg": math.degrees(math.atan2(k, sy)),
|
|
"y_stretch_pct": (sy - 1) * 100, "turn_deg": turn, "matches": int(cc), "match_rms_px": rms_px,
|
|
"fit_residual": float(np.abs(sol.fun).max()), "scans": [os.path.basename(path1), os.path.basename(path2)]}
|
|
if abs(abs(turn) - 90) > 45:
|
|
out["warning"] = (f"the cover was turned {turn:.0f} deg between scans; turn it roughly a quarter "
|
|
f"turn for a reliable measurement")
|
|
if verbose:
|
|
print(f"scanner calibration from {out['scans'][0]} + {out['scans'][1]} (turned {turn:+.1f} deg):")
|
|
print(f" carriage-direction stretch {out['y_stretch_pct']:+.3f}% shear {out['shear_deg']:+.4f} deg"
|
|
f" ({int(cc)} matched points, {rms_px:.2f} px rms, model residual {out['fit_residual']:.1e})")
|
|
if "warning" in out:
|
|
print(" !! " + out["warning"])
|
|
return out
|
|
|
|
|
|
def add_calibration(path, res, reset=False):
|
|
"""Add one measured pair to the calibration file and store the average of
|
|
all pairs measured so far (each new pair refines it)."""
|
|
hist = []
|
|
if not reset and os.path.exists(path):
|
|
with open(path) as fh:
|
|
old = json.load(fh)
|
|
hist = old.get("history") or [{k: old[k] for k in ("sy", "k", "shear_deg", "y_stretch_pct", "scans") if k in old}]
|
|
hist.append({k: res[k] for k in ("sy", "k", "shear_deg", "y_stretch_pct", "scans", "turn_deg") if k in res})
|
|
sy = float(np.mean([h["sy"] for h in hist])); k = float(np.mean([h["k"] for h in hist]))
|
|
out = {"sy": sy, "k": k, "shear_deg": math.degrees(math.atan2(k, sy)), "y_stretch_pct": (sy - 1) * 100,
|
|
"scans": [f"average of {len(hist)} pair(s)"] if len(hist) > 1 else hist[0]["scans"],
|
|
"pairs": len(hist), "history": hist}
|
|
if len(hist) > 1:
|
|
out["spread_shear_deg"] = float(np.ptp([h["shear_deg"] for h in hist]))
|
|
out["spread_stretch_pct"] = float(np.ptp([h["y_stretch_pct"] for h in hist]))
|
|
with open(path, "w") as fh:
|
|
json.dump(out, fh, indent=2)
|
|
return out
|
|
|
|
|
|
# ---------------------------------------------------------------- preview
|
|
|
|
def make_preview(arr8, infos, outs, path):
|
|
rgb = arr8 if arr8.ndim == 3 else np.stack([arr8] * 3, axis=2)
|
|
rgb = np.ascontiguousarray(rgb[..., :3])
|
|
h, w = rgb.shape[:2]
|
|
s = 1000 / max(h, w)
|
|
small = cv2.resize(rgb, (int(w * s), int(h * s)), interpolation=cv2.INTER_AREA)
|
|
small = cv2.cvtColor(small, cv2.COLOR_RGB2BGR)
|
|
for i, inf in enumerate(infos):
|
|
poly = (np.array(inf["corners"]) * s).astype(np.int32)
|
|
cv2.polylines(small, [poly], True, (0, 0, 255), 1, cv2.LINE_AA)
|
|
crop = (np.array(inf["crop_poly"]) * s).astype(np.int32)
|
|
cv2.polylines(small, [crop], True, (0, 200, 0), 1, cv2.LINE_AA)
|
|
cx, cy = crop.mean(axis=0).astype(int)
|
|
cv2.putText(small, str(i + 1), (cx - 10, cy + 10), cv2.FONT_HERSHEY_SIMPLEX,
|
|
1.2, (0, 0, 255), 3, cv2.LINE_AA)
|
|
# corner zooms: 4x of each crop's corners
|
|
tiles = []
|
|
for o in outs:
|
|
o3 = o if o.ndim == 3 else np.stack([o] * 3, axis=2)
|
|
o3 = cv2.cvtColor(np.ascontiguousarray(o3[..., :3]), cv2.COLOR_RGB2BGR)
|
|
z = 40
|
|
cs = [o3[:z, :z], o3[:z, -z:], o3[-z:, :z], o3[-z:, -z:]]
|
|
cs = [np.pad(cv2.resize(c, (z * 4, z * 4), interpolation=cv2.INTER_NEAREST),
|
|
((3, 3), (3, 3), (0, 0)), constant_values=255) for c in cs]
|
|
tiles.append(np.vstack([np.hstack(cs[:2]), np.hstack(cs[2:])]))
|
|
if tiles:
|
|
zoom = np.hstack([np.pad(t, ((4, 4), (4, 4), (0, 0)), constant_values=128) for t in tiles])
|
|
if zoom.shape[1] > small.shape[1]:
|
|
f = small.shape[1] / zoom.shape[1]
|
|
zoom = cv2.resize(zoom, (small.shape[1], int(zoom.shape[0] * f)), interpolation=cv2.INTER_NEAREST)
|
|
pad = small.shape[1] - zoom.shape[1]
|
|
zoom = np.pad(zoom, ((0, 0), (0, pad), (0, 0)), constant_values=255)
|
|
small = np.vstack([small, zoom])
|
|
cv2.imwrite(path, small, [cv2.IMWRITE_JPEG_QUALITY, 90])
|
|
|
|
# ------------------------------------------------------------------- main
|
|
|
|
def describe_frame(fr, cov):
|
|
return {"rotation_deg": fr["theta"], "size": (fr["W"], fr["H"]), "edge_dev_deg": fr["edge_dev_deg"],
|
|
"edge_fit": {k: v[2] for k, v in cov["edges"].items()}, "insets": fr["ins"],
|
|
"soft": cov["soft"], "borrowed": cov["borrowed"],
|
|
"corners": fr["corners"], "crop_poly": fr["crop_poly"]}
|
|
|
|
|
|
def review_sheet(arr8, frs, labels, segs, path):
|
|
"""A/B sheet for a close call. For each candidate: a small overview, the
|
|
key art line at 2x with an exactly vertical/horizontal guide (cyan) so any
|
|
tilt is obvious, and the four corners at 1:1 - the places where the two
|
|
crops actually differ."""
|
|
a = arr8.astype(np.float32)
|
|
key = None
|
|
if segs:
|
|
vs = [s_ for s_ in segs if s_[2]] or list(segs)
|
|
key = max(vs, key=lambda s_: s_[3])
|
|
cols = []
|
|
for fr, lab in zip(frs, labels):
|
|
o = render(a, fr)
|
|
bgr = lambda im: cv2.cvtColor(np.ascontiguousarray(im), cv2.COLOR_RGB2BGR)
|
|
ov = bgr(cv2.resize(o, (520, int(520 * fr["H"] / fr["W"])), interpolation=cv2.INTER_AREA))
|
|
parts = [ov]
|
|
if key is not None:
|
|
P, Q, vert, L = key
|
|
uv = lambda p_: np.array([(p_ - fr["origin"]) @ fr["ex"], (p_ - fr["origin"]) @ fr["ey"]])
|
|
p_, q_ = uv(P), uv(Q)
|
|
if vert:
|
|
e0, e1 = (p_, q_) if p_[1] < q_[1] else (q_, p_)
|
|
lean = e1[0] - e0[0]
|
|
else:
|
|
e0, e1 = (p_, q_) if p_[0] < q_[0] else (q_, p_)
|
|
lean = e1[1] - e0[1]
|
|
zs = []
|
|
for e in (e0, e1):
|
|
cx, cy = int(round(e[0])), int(round(e[1]))
|
|
x0, y0 = max(cx - 40, 0), max(cy - 40, 0)
|
|
z = bgr(np.ascontiguousarray(o[y0:y0 + 80, x0:x0 + 80]))
|
|
z = cv2.resize(z, (240, 240), interpolation=cv2.INTER_NEAREST)
|
|
if vert:
|
|
gx = int(round((e0[0] - x0 + 0.5) * 3)); cv2.line(z, (gx, 0), (gx, 239), (255, 255, 0), 1)
|
|
else:
|
|
gy = int(round((e0[1] - y0 + 0.5) * 3)); cv2.line(z, (0, gy), (239, gy), (255, 255, 0), 1)
|
|
zs.append(np.pad(z, ((2, 2), (2, 2), (0, 0)), constant_values=255))
|
|
z = np.hstack(zs); z = np.pad(z, ((0, 0), (0, 520 - z.shape[1]), (0, 0)), constant_values=255)
|
|
cap = np.full((26, 520, 3), 255, np.uint8)
|
|
what = "top / bottom" if vert else "left / right"
|
|
cv2.putText(cap, f"key art line, {what} ends 3x: leans {abs(lean):.1f} px over {L:.0f} px",
|
|
(6, 18), cv2.FONT_HERSHEY_SIMPLEX, 0.47, (0, 0, 0), 1, cv2.LINE_AA)
|
|
parts += [cap, z]
|
|
n = 256
|
|
cs = [o[:n, :n], o[:n, -n:], o[-n:, :n], o[-n:, -n:]]
|
|
cs = [np.pad(bgr(c), ((2, 2), (2, 2), (0, 0)), constant_values=255) for c in cs]
|
|
grid = np.vstack([np.hstack(cs[:2]), np.hstack(cs[2:])])
|
|
grid = cv2.resize(grid, (520, 520), interpolation=cv2.INTER_AREA)
|
|
cap = np.full((26, 520, 3), 255, np.uint8)
|
|
cv2.putText(cap, "corners, 1:1 (top-left, top-right / bottom-left, bottom-right)", (6, 18),
|
|
cv2.FONT_HERSHEY_SIMPLEX, 0.45, (0, 0, 0), 1, cv2.LINE_AA)
|
|
parts += [cap, grid]
|
|
head = np.full((40, 520, 3), 255, np.uint8)
|
|
cv2.putText(head, lab, (6, 28), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 0), 2, cv2.LINE_AA)
|
|
cols.append(np.vstack([head] + parts))
|
|
h = max(c.shape[0] for c in cols)
|
|
cols = [np.pad(c, ((0, h - c.shape[0]), (10, 10), (0, 0)), constant_values=255) for c in cols]
|
|
cv2.imwrite(path, np.hstack(cols), [cv2.IMWRITE_JPEG_QUALITY, 92])
|
|
|
|
|
|
LOG_FIELDS = ["file", "cover", "chosen_deg", "mode", "alt_deg", "flagged", "line_conf_v", "line_conf_h",
|
|
"art_vertical_deg", "edge_horizontal_deg", "left_deg", "right_deg", "top_deg", "bottom_deg",
|
|
"soft_edges", "width", "height"]
|
|
|
|
|
|
def process(path, outdir, align, overrides, count, inset, preview, log_rows):
|
|
arr8, mode, dpi = load_scan(path)
|
|
scan_px = arr8.astype(np.float32)
|
|
# all measuring happens in true geometry; the final render maps back to the
|
|
# original scan pixels, so the calibration costs no extra resample
|
|
arr, CALA = true_space(scan_px, CAL)
|
|
arr8v = np.clip(np.rint(arr), 0, 255).astype(np.uint8) if CALA is not None else arr8
|
|
gray = arr[..., :3].mean(axis=2) if arr.ndim == 3 else arr
|
|
rects = coarse_rects(arr, count)
|
|
base = os.path.splitext(os.path.basename(path))[0]
|
|
if len(rects) < count:
|
|
print(f"!! {base}: found {len(rects)} cover(s), expected {count}")
|
|
cents = np.array([r[0] for r in rects]) if rects else np.zeros((0, 2))
|
|
axis = 0 if len(cents) < 2 or np.ptp(cents[:, 0]) >= np.ptp(cents[:, 1]) else 1
|
|
order = np.argsort(cents[:, axis]) if len(cents) else []
|
|
infos, outs = [], []
|
|
kinds = {i: "cover" for i in range(len(rects))}
|
|
if rects:
|
|
_, circ = coarse_rects(arr, count, return_shape=True)
|
|
kinds = {i: ("disc" if c >= DISC_CIRC else "cover") for i, c in enumerate(circ)}
|
|
for idx, ri in enumerate(order, start=1):
|
|
if kinds.get(ri) == "disc":
|
|
(cx0, cy0), (w0, h0), _ = rects[ri]
|
|
center, R = fit_disc(arr, (cx0, cy0), (dpi or (600, 600))[0], (w0 + h0) / 2)
|
|
ori = disc_orientation(gray, center, R)
|
|
ov = overrides.get((os.path.basename(path), idx))
|
|
theta = float(ov) if ov not in (None, "auto") and ov not in ("left", "right", "top", "bottom") else ori["auto"]
|
|
fr = disc_frame(center, R, theta)
|
|
out = render(scan_px, frame_to_scan(fr, CALA))
|
|
save_png(out, mode, dpi, os.path.join(outdir, f"{base}_{idx}.png"))
|
|
infos.append({"corners": fr["corners"], "crop_poly": fr["crop_poly"]}); outs.append(out)
|
|
print(f" {base}_{idx}.png disc {2 * R / (dpi or (600,))[0] * 25.4:.1f} mm {fr['W']}x{fr['H']} "
|
|
f"rotated {theta:+.2f}° ({ori['why']})")
|
|
if ori["flagged"]:
|
|
print(" ^ orientation needs a look: candidates " +
|
|
", ".join(f"{k} {v:+.1f}°" for k, v in ori["candidates"].items()))
|
|
log_rows.append({"file": os.path.basename(path), "cover": idx, "chosen_deg": f"{theta:.4f}",
|
|
"mode": "disc: " + ori["why"], "alt_deg": "", "flagged": int(ori["flagged"]),
|
|
"line_conf_v": "", "line_conf_h": "", "art_vertical_deg": "", "edge_horizontal_deg": "",
|
|
"left_deg": "", "right_deg": "", "top_deg": "", "bottom_deg": "", "soft_edges": "",
|
|
"width": fr["W"], "height": fr["H"]})
|
|
continue
|
|
cov = analyze_cover(arr, rects[ri])
|
|
ov = overrides.get((os.path.basename(path), idx), align)
|
|
ch = None
|
|
if ov == "auto":
|
|
ch = choose_angle(arr, gray, cov, inset)
|
|
theta, how = ch["theta"], "auto"
|
|
elif ov in ("left", "right", "top", "bottom"):
|
|
src = cov["borrowed"].get(ov, ov)
|
|
theta = edge_theta(src, cov["edges"][src][1]) if src in cov["edges"] else 0.0
|
|
how = f"{ov} edge" + (f" (soft, used {src})" if ov in cov["soft"] else "")
|
|
else:
|
|
theta, how = float(ov), "fixed angle"
|
|
fr = frame_at(cov, theta, inset)
|
|
out = render(scan_px, frame_to_scan(fr, CALA))
|
|
out_path = os.path.join(outdir, f"{base}_{idx}.png")
|
|
save_png(out, mode, dpi, out_path)
|
|
info = describe_frame(fr, cov)
|
|
infos.append(info); outs.append(out)
|
|
|
|
named = {k: edge_theta(k, cov["edges"][k][1]) for k in ("left", "right", "top", "bottom")
|
|
if k not in cov["soft"]}
|
|
print(f" {base}_{idx}.png {fr['W']}x{fr['H']} rotated {theta:+.3f}° ({how})")
|
|
print(" edge angles: " + ", ".join(
|
|
f"{k} {'soft' if k in cov['soft'] else f'{named[k]:+.3f}°'}" for k in ("left", "right", "top", "bottom")))
|
|
flagged = False
|
|
if ch is not None:
|
|
bits = []
|
|
if ch["art_theta"] is not None and ch["conf_v"] > 0.15:
|
|
bits.append(f"art verticals {ch['art_theta']:+.3f}° (confidence {ch['conf_v']:.0%})")
|
|
if ch["art_theta_h"] is not None and ch["conf_h"] > 0.15:
|
|
bits.append(f"edge horizontals {ch['art_theta_h']:+.3f}° (confidence {ch['conf_h']:.0%})")
|
|
print(" art lines: " + ("; ".join(bits) if bits else "none usable - chose by edges and art kept"))
|
|
if ch["alt"] is not None:
|
|
flagged = True
|
|
rdir = os.path.join(outdir, "_review"); os.makedirs(rdir, exist_ok=True)
|
|
fa = frame_at(cov, ch["alt"], inset)
|
|
save_png(render(arr, fa), mode, dpi, os.path.join(rdir, f"{base}_{idx}_alt.png"))
|
|
bl = "left edge" if ch["alt_why"] == "left edge" else "runner-up"
|
|
review_sheet(arr8, [fr, fa],
|
|
[f"A (used): {theta:+.3f} deg", f"B ({bl}): {ch['alt']:+.3f} deg"],
|
|
ch["segs"], os.path.join(rdir, f"{base}_{idx}_A-vs-B.jpg"))
|
|
if ch["alt_why"] == "left edge":
|
|
driver = ("art lines" if ch["best_line"] * W_V * ch["conf_v"] >
|
|
ch["named"].get("left", {}).get("loss", 0) else "art kept near the edges")
|
|
why = f"turned {theta - ch['alt']:+.2f}° from the left edge ({driver})"
|
|
else:
|
|
why = "close call"
|
|
print(f" ^ {why} - B = {ch['alt']:+.3f}°: see _review/{base}_{idx}_A-vs-B.jpg; "
|
|
f"if B looks better, use _review/{base}_{idx}_alt.png")
|
|
for k in cov["soft"]:
|
|
print(f" ^ {k} edge has no crisp line (fold, lifted or worn paper); "
|
|
f"cropped where the in-focus art begins.")
|
|
W, H = fr["W"], fr["H"]
|
|
if abs(W / H - 1) > 0.02:
|
|
print(f" ^ not square ({W/H:.3f}). Fine for a back inlay or digipak; on a jewel-case "
|
|
f"front it usually means art blends into the lid along one edge - check the preview.")
|
|
log_rows.append({
|
|
"file": os.path.basename(path), "cover": idx, "chosen_deg": f"{theta:.4f}", "mode": how,
|
|
"alt_deg": "" if not ch or ch["alt"] is None else f"{ch['alt']:.4f}", "flagged": int(flagged),
|
|
"line_conf_v": "" if not ch else f"{ch['conf_v']:.2f}", "line_conf_h": "" if not ch else f"{ch['conf_h']:.2f}",
|
|
"art_vertical_deg": "" if not ch or ch["art_theta"] is None else f"{ch['art_theta']:.4f}",
|
|
"edge_horizontal_deg": "" if not ch or ch["art_theta_h"] is None else f"{ch['art_theta_h']:.4f}",
|
|
**{f"{k}_deg": (f"{named[k]:.4f}" if k in named else "soft") for k in ("left", "right", "top", "bottom")},
|
|
"soft_edges": "/".join(cov["soft"]), "width": W, "height": H})
|
|
if preview and infos:
|
|
pdir = os.path.join(outdir, "_previews")
|
|
os.makedirs(pdir, exist_ok=True)
|
|
make_preview(arr8v, infos, outs, os.path.join(pdir, f"{base}_preview.jpg"))
|
|
|
|
|
|
def _run_one(job):
|
|
"""Process one scan, capturing its report so parallel runs print cleanly."""
|
|
import io, contextlib, warnings
|
|
global CAL
|
|
CAL = job[7]
|
|
job = job[:7]
|
|
f = job[0]
|
|
buf, rows = io.StringIO(), []
|
|
with contextlib.redirect_stdout(buf), warnings.catch_warnings():
|
|
warnings.simplefilter("ignore")
|
|
print(os.path.basename(f))
|
|
try:
|
|
process(*job, rows)
|
|
except Exception as e:
|
|
print(f"!! {f}: {e}")
|
|
return buf.getvalue(), rows
|
|
|
|
|
|
def main():
|
|
ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
|
|
ap.add_argument("inputs", nargs="*")
|
|
ap.add_argument("-o", "--outdir", default="cropped")
|
|
ap.add_argument("--align", default="auto", choices=["auto", "left", "right", "top", "bottom"],
|
|
help="auto (default) weighs art lines, art kept and the left edge; "
|
|
"or force one edge for every cover")
|
|
ap.add_argument("--align-override", action="append", default=[],
|
|
help='per cover: "scan012.bmp:2=top", "=left", "=auto" or an angle "=+0.15"')
|
|
ap.add_argument("--count", type=int, default=2)
|
|
ap.add_argument("--inset", type=float, default=1.0,
|
|
help="minimum px trimmed inside each edge; soft edges get more automatically")
|
|
ap.add_argument("--no-preview", action="store_true")
|
|
ap.add_argument("--calibrate", nargs=2, metavar=("SCAN_A", "SCAN_B"),
|
|
help="measure the scanner from two scans of the same flat cover turned ~90 deg, save, and exit")
|
|
ap.add_argument("--calibration", default=os.path.join(os.path.dirname(os.path.abspath(__file__)),
|
|
"scanner_calibration.json"),
|
|
help="scanner calibration file (default: scanner_calibration.json next to this script, if present)")
|
|
ap.add_argument("--no-calibration", action="store_true", help="ignore any scanner calibration")
|
|
ap.add_argument("--calibrate-reset", action="store_true",
|
|
help="with --calibrate: discard earlier pairs instead of averaging with them")
|
|
ap.add_argument("--jobs", type=int, default=1,
|
|
help="scans processed in parallel (each needs ~1.5 GB RAM at 600 dpi)")
|
|
a = ap.parse_args()
|
|
|
|
if a.calibrate:
|
|
res = calibrate_pair(*a.calibrate)
|
|
out = add_calibration(a.calibration, res, reset=a.calibrate_reset)
|
|
if out["pairs"] > 1:
|
|
print(f"average of {out['pairs']} pairs: stretch {out['y_stretch_pct']:+.3f}%, shear {out['shear_deg']:+.4f} deg "
|
|
f"(pairs differ by up to {out['spread_stretch_pct']:.3f}% / {out['spread_shear_deg']:.4f} deg)")
|
|
print(f"saved to {a.calibration} - it will be applied to every crop from now on")
|
|
return
|
|
if not a.no_calibration and os.path.exists(a.calibration):
|
|
cal = load_calibration(a.calibration)
|
|
print(f"scanner calibration: stretch {cal['y_stretch_pct']:+.3f}%, shear {cal['shear_deg']:+.4f} deg "
|
|
f"(from {os.path.basename(a.calibration)})")
|
|
|
|
if not a.inputs:
|
|
ap.error("give scan files or a folder (or --calibrate SCAN_A SCAN_B)")
|
|
overrides = {}
|
|
for o in a.align_override:
|
|
lhs, side = o.split("=", 1)
|
|
f, n = lhs.rsplit(":", 1)
|
|
overrides[(f, int(n))] = side.strip()
|
|
|
|
files = []
|
|
for p in a.inputs:
|
|
if os.path.isdir(p):
|
|
files += sorted(os.path.join(p, f) for f in os.listdir(p) if f.lower().endswith(".bmp"))
|
|
else:
|
|
files.append(p)
|
|
os.makedirs(a.outdir, exist_ok=True)
|
|
log_rows = []
|
|
jobs = [(f, a.outdir, a.align, overrides, a.count, a.inset, not a.no_preview, CAL) for f in files]
|
|
if a.jobs > 1 and len(files) > 1:
|
|
from multiprocessing import Pool
|
|
with Pool(a.jobs) as pool:
|
|
for text, rows in pool.imap(_run_one, jobs):
|
|
print(text, end=""); log_rows += rows
|
|
else:
|
|
for j in jobs:
|
|
text, rows = _run_one(j)
|
|
print(text, end=""); log_rows += rows
|
|
if log_rows:
|
|
import csv
|
|
lp = os.path.join(a.outdir, "cdcrop_log.csv")
|
|
new = not os.path.exists(lp)
|
|
with open(lp, "a", newline="") as fh:
|
|
w = csv.DictWriter(fh, fieldnames=LOG_FIELDS)
|
|
if new:
|
|
w.writeheader()
|
|
w.writerows(log_rows)
|
|
n_flag = sum(r["flagged"] for r in log_rows)
|
|
print(f"\n{len(log_rows)} covers cropped, {n_flag} close call(s) in _review/. Log: {lp}")
|
|
|
|
|
|
TUNING = load_tuning()
|
|
|
|
if __name__ == "__main__":
|
|
main()
|