perf: Fase 2 speed (3x baseline) - fuse JIT + LRU + sub-pixel lazy
Ottimizzazioni cumulative (225s -> 73s sul bench suite, 3.07x): pm2d/line_matcher.py: - Sub-pixel + plateau centroid spostati DOPO il pre-NMS (prima: 58k chiamate per clip_preciso anche su candidati poi scartati dalla NMS; ora solo sui ~75 preliminary sopravvissuti). Coordinate intere OK per la decisione reject, dato che nms_radius >= 8 px. - Usa nuovo kernel fuso score+rescore (no allocazione intermedia). - Adaptive plateau_radius + propagazione train_mask per NCC coerente. - Local crop NCC (diag template invece di intera scena). - Fallback adattivo se bg_rescore azzera tutti gli score top-level. pm2d/_jit_kernels.py: - Nuovo kernel _jit_score_bitmap_rescored: fonde scoring bitmap e rescore (score - bg) / (1 - bg) in un singolo pass parallelo. Evita allocazione e passata aggiuntiva (era ~15% del tempo find sul preciso). pm2d/auto_tune.py: - LRU cache in-memory sui risultati auto_tune (chiave md5 ROI + mask): richiamate successive con stessa ROI sono O(1). - Downsample a 128px prima della correlazione rotazionale (O(n_angles * H * W) -> insensibile su sample moderati). - Soglie weak/strong da percentili reali (p55/p85) senza clamp a 100, con clamp massimo 400 per evitare saturazione su template ad alto contrasto. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
This commit is contained in:
root
+90
-31
@@ -39,6 +39,7 @@ _GOLDEN = (math.sqrt(5.0) - 1.0) / 2.0 # ≈ 0.618
|
||||
from pm2d._jit_kernels import (
|
||||
score_by_shift as _jit_score_by_shift,
|
||||
score_bitmap as _jit_score_bitmap,
|
||||
score_bitmap_rescored as _jit_score_bitmap_rescored,
|
||||
popcount_density as _jit_popcount,
|
||||
HAS_NUMBA,
|
||||
)
|
||||
@@ -136,6 +137,8 @@ class LineShapeMatcher:
|
||||
self.variants: list[_Variant] = []
|
||||
self.template_size: tuple[int, int] = (0, 0)
|
||||
self.template_gray: np.ndarray | None = None
|
||||
# Maschera usata in training (propagata al refine per coerenza).
|
||||
self._train_mask: np.ndarray | None = None
|
||||
|
||||
# --- Helpers -------------------------------------------------------
|
||||
|
||||
@@ -233,6 +236,7 @@ class LineShapeMatcher:
|
||||
mask_full = np.full((h, w), 255, dtype=np.uint8)
|
||||
else:
|
||||
mask_full = (mask > 0).astype(np.uint8) * 255
|
||||
self._train_mask = mask_full.copy()
|
||||
|
||||
self.variants.clear()
|
||||
for s in self._scale_list():
|
||||
@@ -505,6 +509,10 @@ class LineShapeMatcher:
|
||||
) -> float:
|
||||
"""NCC tra template warpato alla pose e scena sottostante.
|
||||
|
||||
Lavora su un **crop locale** della scena di lato = diagonale del
|
||||
template ruotato+scalato, non sull'intera scena. Su scene grandi
|
||||
(1920×1080) taglia drasticamente il costo del warp per ogni match.
|
||||
|
||||
Ritorna score [-1, 1]. Usato come filtro anti-falso-positivo:
|
||||
il matcher linemod può dare score alto su texture generiche ma
|
||||
sovrapponendo il template gray i pixel non corrispondono.
|
||||
@@ -515,23 +523,40 @@ class LineShapeMatcher:
|
||||
h, w = t.shape
|
||||
cx_t = (w - 1) / 2.0
|
||||
cy_t = (h - 1) / 2.0
|
||||
M = cv2.getRotationMatrix2D((cx_t, cy_t), angle_deg, scale)
|
||||
M[0, 2] += cx - cx_t
|
||||
M[1, 2] += cy - cy_t
|
||||
|
||||
# Bounding box del template ruotato/scalato attorno a (cx, cy)
|
||||
diag = int(np.ceil(np.hypot(w, h) * scale)) + 8
|
||||
H, W = scene_gray.shape
|
||||
x0 = int(round(cx)) - diag // 2
|
||||
y0 = int(round(cy)) - diag // 2
|
||||
cx0 = max(0, x0); cy0 = max(0, y0)
|
||||
cx1 = min(W, x0 + diag); cy1 = min(H, y0 + diag)
|
||||
if cx1 - cx0 < 10 or cy1 - cy0 < 10:
|
||||
return 0.0
|
||||
scn_crop = scene_gray[cy0:cy1, cx0:cx1]
|
||||
ch, cw = scn_crop.shape
|
||||
|
||||
M = cv2.getRotationMatrix2D((cx_t, cy_t), angle_deg, scale)
|
||||
# Porta il centro del template a (cx - cx0, cy - cy0) del crop
|
||||
M[0, 2] += (cx - cx0) - cx_t
|
||||
M[1, 2] += (cy - cy0) - cy_t
|
||||
warped = cv2.warpAffine(
|
||||
t, M, (W, H),
|
||||
t, M, (cw, ch),
|
||||
flags=cv2.INTER_LINEAR, borderValue=0,
|
||||
)
|
||||
mask = cv2.warpAffine(
|
||||
np.full_like(t, 255), M, (W, H),
|
||||
if self._train_mask is not None:
|
||||
mask_src = self._train_mask
|
||||
else:
|
||||
mask_src = np.full_like(t, 255)
|
||||
mask_w = cv2.warpAffine(
|
||||
mask_src, M, (cw, ch),
|
||||
flags=cv2.INTER_NEAREST, borderValue=0,
|
||||
)
|
||||
valid = mask > 0
|
||||
valid = mask_w > 0
|
||||
if valid.sum() < 20:
|
||||
return 0.0
|
||||
tpl = warped[valid].astype(np.float32)
|
||||
scn = scene_gray[valid].astype(np.float32)
|
||||
scn = scn_crop[valid].astype(np.float32)
|
||||
tm = tpl - tpl.mean()
|
||||
sm = scn - scn.mean()
|
||||
denom = np.sqrt((tm * tm).sum() * (sm * sm).sum()) + 1e-9
|
||||
@@ -624,24 +649,37 @@ class LineShapeMatcher:
|
||||
def _top_score(vi: int) -> tuple[int, float]:
|
||||
var = self.variants[vi]
|
||||
lvl = var.levels[min(top, len(var.levels) - 1)]
|
||||
score = _jit_score_bitmap(
|
||||
score = _jit_score_bitmap_rescored(
|
||||
spread_top, lvl.dx, lvl.dy, lvl.bin, bit_active_top,
|
||||
bg_cache_top[var.scale],
|
||||
)
|
||||
score = _rescore(score, bg_cache_top[var.scale])
|
||||
return vi, float(score.max()) if score.size else -1.0
|
||||
|
||||
kept_coarse: list[tuple[int, float]] = []
|
||||
all_top_scores: list[tuple[int, float]] = []
|
||||
if self.n_threads > 1 and len(coarse_idx_list) > 1:
|
||||
with ThreadPoolExecutor(max_workers=self.n_threads) as ex:
|
||||
for vi, best in ex.map(_top_score, coarse_idx_list):
|
||||
all_top_scores.append((vi, best))
|
||||
if best >= top_thresh:
|
||||
kept_coarse.append((vi, best))
|
||||
else:
|
||||
for vi in coarse_idx_list:
|
||||
vi2, best = _top_score(vi)
|
||||
all_top_scores.append((vi2, best))
|
||||
if best >= top_thresh:
|
||||
kept_coarse.append((vi2, best))
|
||||
|
||||
# Fallback adattivo: se il rescore background ha abbattuto tutti
|
||||
# gli score sotto top_thresh (scene texturate pesanti), ripesca
|
||||
# le varianti migliori al top level per dare comunque una chance
|
||||
# alla fase full-res invece di ritornare 0 match.
|
||||
if not kept_coarse and all_top_scores:
|
||||
all_top_scores.sort(key=lambda t: -t[1])
|
||||
n_keep = max(4, len(all_top_scores) // 10)
|
||||
# Limita a varianti con score top > 0 (non completamente a zero)
|
||||
kept_coarse = [(vi, s) for vi, s in all_top_scores[:n_keep] if s > 0]
|
||||
|
||||
# Espandi ogni coarse promosso con i suoi vicini (stessa scala,
|
||||
# angoli intermedi non valutati al top)
|
||||
expanded: set[int] = set()
|
||||
@@ -678,10 +716,10 @@ class LineShapeMatcher:
|
||||
def _full_score(vi: int) -> tuple[int, np.ndarray]:
|
||||
var = self.variants[vi]
|
||||
lvl0 = var.levels[0]
|
||||
score = _jit_score_bitmap(
|
||||
score = _jit_score_bitmap_rescored(
|
||||
spread0, lvl0.dx, lvl0.dy, lvl0.bin, bit_active_full,
|
||||
bg_cache_full[var.scale],
|
||||
)
|
||||
score = _rescore(score, bg_cache_full[var.scale])
|
||||
return vi, score
|
||||
|
||||
candidates_per_var: list[tuple[int, np.ndarray]] = []
|
||||
@@ -693,14 +731,24 @@ class LineShapeMatcher:
|
||||
else:
|
||||
results = [_full_score(vi) for vi in var_indices]
|
||||
|
||||
def _scale_factor(s: float) -> float:
|
||||
"""Penalità moltiplicativa per scala diversa da 1.0."""
|
||||
if scale_penalty > 0.0 and s != 1.0:
|
||||
return max(0.0, 1.0 - scale_penalty * abs(s - 1.0))
|
||||
return 1.0
|
||||
|
||||
for vi, score in results:
|
||||
ys, xs = np.where(score >= min_score)
|
||||
pen = _scale_factor(self.variants[vi].scale)
|
||||
# Ordinare/sogliare su score penalizzato: un match a scala 1.5 con
|
||||
# score 0.8 e penalty=0.3 effettivamente vale 0.56, non 0.8.
|
||||
score_for_sort = score if pen == 1.0 else score * pen
|
||||
ys, xs = np.where(score_for_sort >= min_score)
|
||||
if len(ys) == 0:
|
||||
continue
|
||||
vals = score[ys, xs]
|
||||
vals = score_for_sort[ys, xs]
|
||||
K = min(len(vals), max_matches * 5)
|
||||
ord_idx = np.argpartition(-vals, K - 1)[:K]
|
||||
candidates_per_var.append((vi, score))
|
||||
candidates_per_var.append((vi, score)) # score_map originale
|
||||
for i in ord_idx:
|
||||
raw.append((float(vals[i]), int(xs[i]), int(ys[i]), vi))
|
||||
|
||||
@@ -710,32 +758,43 @@ class LineShapeMatcher:
|
||||
score_maps = dict(candidates_per_var)
|
||||
|
||||
# NMS + subpixel + refinement angolare
|
||||
# Mask template per refinement (non disponibile qui: usa full)
|
||||
# Usa mask salvata in train() per coerenza (se ROI poligonale).
|
||||
h, w = self.template_gray.shape if self.template_gray is not None else (0, 0)
|
||||
mask_full = np.full((h, w), 255, dtype=np.uint8)
|
||||
mask_full = (
|
||||
self._train_mask if self._train_mask is not None
|
||||
else np.full((h, w), 255, dtype=np.uint8)
|
||||
)
|
||||
# Plateau radius adattivo al template (evita plateau troppo ampi su
|
||||
# template piccoli: 8% del lato minimo, clampato [3, 10]).
|
||||
plateau_r = max(3, min(10, int(min(self.template_size) * 0.08)))
|
||||
|
||||
# Pre-NMS rapido su raw (solo subpixel, no refine/verify): riduce
|
||||
# i candidati a ~max_matches*3 prima di operazioni costose (refine,
|
||||
# verify) che erano chiamate per ogni raw causando lentezze 100x.
|
||||
# Pre-NMS rapido su raw con coordinate intere (nms_radius ≥ 8,
|
||||
# la precisione sub-pixel non cambia la decisione di reject).
|
||||
# Subpixel viene calcolato DOPO il pre-NMS solo sui ~pre_cap
|
||||
# preliminary sopravvissuti: prima era chiamato su ogni raw (~58k
|
||||
# chiamate su clip_preciso) anche se la maggior parte veniva poi
|
||||
# scartata dalla NMS, sprecando la parte più costosa del loop.
|
||||
r2 = nms_radius * nms_radius
|
||||
preliminary: list[tuple[float, float, float, int]] = []
|
||||
pre_cap = max(max_matches * 3, max_matches + 10)
|
||||
preliminary_int: list[tuple[float, int, int, int]] = []
|
||||
for score, xi, yi, vi in raw:
|
||||
if subpixel and vi in score_maps:
|
||||
cx_f, cy_f = self._subpixel_peak(score_maps[vi], xi, yi)
|
||||
else:
|
||||
cx_f, cy_f = float(xi), float(yi)
|
||||
if any((k[1] - cx_f) ** 2 + (k[2] - cy_f) ** 2 < r2
|
||||
for k in preliminary):
|
||||
if any((k[1] - xi) ** 2 + (k[2] - yi) ** 2 < r2
|
||||
for k in preliminary_int):
|
||||
continue
|
||||
preliminary.append((score, cx_f, cy_f, vi))
|
||||
if len(preliminary) >= pre_cap:
|
||||
preliminary_int.append((score, xi, yi, vi))
|
||||
if len(preliminary_int) >= pre_cap:
|
||||
break
|
||||
|
||||
# Ora refine + verify solo sui candidati pre-NMS
|
||||
# Subpixel + refine + verify solo sui candidati pre-NMS (max pre_cap)
|
||||
kept: list[Match] = []
|
||||
tw, th = self.template_size
|
||||
for score, cx_f, cy_f, vi in preliminary:
|
||||
for score, xi, yi, vi in preliminary_int:
|
||||
if subpixel and vi in score_maps:
|
||||
cx_f, cy_f = self._subpixel_peak(
|
||||
score_maps[vi], xi, yi, plateau_radius=plateau_r,
|
||||
)
|
||||
else:
|
||||
cx_f, cy_f = float(xi), float(yi)
|
||||
var = self.variants[vi]
|
||||
ang_f = var.angle_deg
|
||||
score_f = score
|
||||
|
||||
Reference in New Issue
Block a user