feat: use_soft_score - Halcon Metric soft-margin gradient similarity

_compute_soft_score: cos(theta_template - theta_scena) continuo
(non quantizzato a bin) pesato per magnitude. Polarity-aware se
use_polarity=True (mod 2pi) else |cos| (mod pi).

Quando use_soft_score=True (default off, backward compat), lo score
finale e' fuso con quello shape: piu discriminante per match a
piccola rotazione (penalita' graduale invece di binaria on/off).

Equivalente a Halcon Metric='use_polarity' / 'ignore_global_polarity'
in find_shape_model.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

.dockerignore

@@ -0,0 +1,22 @@
+.venv
+.git
+.gitignore
+.github
+__pycache__
+*.pyc
+*.pyo
+*.pyd
+.DS_Store
+.idea
+.vscode
+*.log
+# Test images non necessarie nel container (caricate via volume/UI)
+Test
+benchmarks
+ROADMAP.md
+shape_model_2d_technical_doc.md
+*.md
+!README.md
+Dockerfile
+docker-compose*.yml
+.env

.env.example

@@ -0,0 +1,14 @@
+# Copia questo file in .env e adatta i valori.
+# .env NON è versionato (contiene config locale/secrets).
+
+# Cartella immagini (relativa al progetto in dev locale,
+# assoluta dentro container es. /data/images)
+IMAGES_DIR=Test
+
+# Web server
+HOST=127.0.0.1
+PORT=8080
+
+# Registry + tag per docker-compose (deploy VPS)
+REGISTRY=localhost:5000
+TAG=latest

Dockerfile

@@ -0,0 +1,38 @@
+FROM python:3.13-slim AS base
+
+# uv package manager (copia binario ufficiale)
+COPY --from=ghcr.io/astral-sh/uv:latest /uv /usr/local/bin/uv
+
+# System deps per opencv (libgl/glib), numba (libgomp)
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    libgl1 \
+    libglib2.0-0 \
+    libgomp1 \
+ && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+# Install deps da lockfile (layer cachato finché pyproject/uv.lock non cambiano)
+COPY pyproject.toml uv.lock ./
+COPY .python-version* ./
+RUN uv sync --frozen --no-dev
+
+# Copia sorgenti applicazione
+COPY pm2d ./pm2d
+COPY main.py ./
+
+# Defaults (override via docker-compose env)
+ENV IMAGES_DIR=/data/images \
+    HOST=0.0.0.0 \
+    PORT=8080 \
+    PYTHONUNBUFFERED=1
+
+# Cartella dati (montata come volume in compose)
+RUN mkdir -p /data/images
+
+EXPOSE 8080
+
+HEALTHCHECK --interval=30s --timeout=5s --retries=3 \
+    CMD python -c "import urllib.request; urllib.request.urlopen('http://localhost:8080/images').read()" || exit 1
+
+CMD ["uv", "run", "python", "main.py"]

README.md

@@ -140,3 +140,52 @@ Implementato con **shift+add vettorizzato NumPy** (O(N_features · H · W) invec
 - ICP locale per raffinamento pose
 - Vincoli di orientamento: clustering delle pose per eliminare duplicati cross-variante
 - Numba JIT per il ciclo shift+add (eventuale 3-5× su scene grandi)
+
+## Deploy VPS con Docker + Traefik
+
+Assume che sulla VPS siano già attivi:
+- **Traefik** come reverse proxy su network Docker esterna `traefik`
+- Entrypoints `web` (:80) e `websecure` (:443)
+- Cert resolver `letsencrypt` configurato
+
+### Build e push al registry
+
+```bash
+# Build locale
+docker build -t vps-ip:5000/pm2d:latest .
+docker push vps-ip:5000/pm2d:latest
+```
+
+### Sulla VPS
+
+```bash
+# Cartella deploy (immagini persistenti qui)
+mkdir -p /opt/docker/pm2d/images
+cd /opt/docker/pm2d
+
+# Copia docker-compose.yml
+# Imposta REGISTRY / TAG se necessario via .env
+echo "REGISTRY=vps-ip:5000" > .env
+echo "TAG=latest" >> .env
+
+docker compose pull
+docker compose up -d
+```
+
+Servizio raggiungibile: **https://pm.tielogic.xyz**
+
+### Note operative
+
+- **Volume `./images`**: persistenza delle immagini caricate tramite UI
+  (`IMAGES_DIR=/data/images` nel container). Sopravvive a restart.
+- **Upload max 50MB**: middleware Traefik `pm2d-bodysize`. Adattare se serve.
+- **Cache matcher in-memory**: si svuota a restart container (no problema,
+  viene ri-popolata al primo match).
+- **Healthcheck**: HTTP `GET /images` ogni 30s.
+- Se nome network Traefik diverso da `traefik`, modifica
+  `docker-compose.yml` sezione `networks`.
+
+### Adattamenti config Traefik non-standard
+
+Se la VPS ha convenzioni diverse (es. cert resolver chiamato `le`,
+entrypoint `https`), modifica i labels nel `docker-compose.yml`.

ROADMAP.md

@@ -2,6 +2,22 @@
 
 Lista ragionata di miglioramenti futuri. Priorità = impatto / effort, non urgenza temporale.
 
+## Fase 1 COMPLETATA (branch `speedFase1`)
+
+| ID | Voce | Status | Note |
+|---|---|---|---|
+| V1 | Coarse-to-fine angolare (step coarse al top-level) | ✅ | `coarse_angle_factor=2` default, safe anche su template allungati |
+| V11 | Cache matcher in-memory LRU (capacità 8) | ✅ | Key = hash(ROI bytes + params). Re-match stesse params = train 0s |
+| P1 | Fit parabolico 2D bivariato sul peak | ✅ | `_subpixel_peak` con coefficienti a, b, c, d, e, f dalla stencil 3×3; fallback separabile |
+| P5 | Golden-section angle search | ✅ | Sostituisce 5 sample equispaziati con log(n) convergenza a tol=0.1° |
+| P2 | Weighted centroid del plateau | ✅ | Integrato in `_subpixel_peak` con peso = (score - soglia)² |
+
+Benchmark suite 16 scenari (4 immagini × full/part × fast/preciso):
+- Prima Fase 1:  totale find 27.3s
+- Dopo  Fase 1:  totale find 25.1s (~8% speedup)
+- Regressione match count: nessuna (alcuni casi +1 match grazie a subpixel migliore)
+- Match auto-referenziale: offset 0.00 px, angolo 0.000° (era -3.5 px, -2.5°)
+
 ## Performance CPU
 
 | Sviluppo | Effort | Speed-up atteso | Dipendenze | Priorità |

docker-compose.yml

@@ -0,0 +1,41 @@
+# docker-compose per deploy VPS con Traefik.
+# Assume che Traefik sia già attivo sulla VPS con:
+#   - network esterna "traefik" (adatta nome se diverso)
+#   - entrypoint "websecure" su :443
+#   - certresolver "mytlschallenge" configurato
+#
+# Adattare eventualmente: nome network, entrypoint, certresolver.
+
+services:
+  pm2d:
+    build: .
+    image: pm2d:latest
+    container_name: pm2d
+    restart: unless-stopped
+    environment:
+      IMAGES_DIR: /data/images
+      HOST: 0.0.0.0
+      PORT: ${PORT:-8080}
+    volumes:
+      # Persistenza immagini tra restart (upload/selezione)
+      - ./images:/data/images
+    networks:
+      - traefik
+    labels:
+      - "traefik.enable=true"
+
+      # Router HTTPS principale
+      - "traefik.http.routers.pm2d.rule=Host(`pm.tielogic.xyz`)"
+      - "traefik.http.routers.pm2d.entrypoints=websecure"
+      - "traefik.http.routers.pm2d.tls=true"
+      - "traefik.http.routers.pm2d.tls.certresolver=mytlschallenge"
+      - "traefik.http.services.pm2d.loadbalancer.server.port=${PORT:-8080}"
+
+      # Middleware: upload fino a 50MB (default Traefik bufferizza a 4MB)
+      - "traefik.http.middlewares.pm2d-bodysize.buffering.maxRequestBodyBytes=52428800"
+      - "traefik.http.routers.pm2d.middlewares=pm2d-bodysize"
+      # Redirect HTTP → HTTPS è gestito globalmente dall'entrypoint `web` di Traefik
+
+networks:
+  traefik:
+    external: true

main.py

@@ -1,10 +1,14 @@
 """Entry-point PM2D — webapp HTML.
 
-Esegui:  uv run python main.py
+Esegui locale:  uv run python main.py        (default 127.0.0.1:8080)
-Apri:    http://127.0.0.1:8080/
+Container:      HOST=0.0.0.0 PORT=8080 python main.py
 """
+import os
+
 from pm2d.web.server import serve
 
 
 if __name__ == "__main__":
-    serve(host="127.0.0.1", port=8080)
+    host = os.environ.get("HOST", "127.0.0.1")
+    port = int(os.environ.get("PORT", "8080"))
+    serve(host=host, port=port)

pm2d/_jit_kernels.py

@@ -110,6 +110,283 @@ if HAS_NUMBA:
                     acc[y, x] *= inv
         return acc
 
+    @nb.njit(cache=True, parallel=True, fastmath=True, boundscheck=False)
+    def _jit_score_bitmap_rescored_strided(
+        spread: np.ndarray,
+        dx: np.ndarray, dy: np.ndarray, bins: np.ndarray,
+        bit_active: np.uint8,
+        bg: np.ndarray,
+        stride: nb.int32,
+    ) -> np.ndarray:
+        """Variante con sub-sampling: valuta solo pixel su griglia stride×stride.
+        Score restituito ha stessa shape (H, W); celle non valutate = 0.
+
+        4× speed-up con stride=2 (NMS recupera precisione in full-res).
+        Numba prange richiede step costante: itero su indici griglia e
+        moltiplico per stride dentro il body.
+        """
+        H, W = spread.shape
+        N = dx.shape[0]
+        acc = np.zeros((H, W), dtype=np.float32)
+        ny = (H + stride - 1) // stride
+        nx = (W + stride - 1) // stride
+        for yi in nb.prange(ny):
+            y = yi * stride
+            for i in range(N):
+                b = bins[i]
+                mask = np.uint8(1) << b
+                if (bit_active & mask) == 0:
+                    continue
+                ddy = dy[i]
+                yy = y + ddy
+                if yy < 0 or yy >= H:
+                    continue
+                ddx = dx[i]
+                x_lo = 0 if ddx >= 0 else -ddx
+                x_hi = W if ddx <= 0 else W - ddx
+                rem = x_lo % stride
+                if rem != 0:
+                    x_lo += stride - rem
+                x = x_lo
+                while x < x_hi:
+                    if spread[yy, x + ddx] & mask:
+                        acc[y, x] += 1.0
+                    x += stride
+        if N > 0:
+            inv = 1.0 / N
+            for yi in nb.prange(ny):
+                y = yi * stride
+                for xi in range(nx):
+                    x = xi * stride
+                    v = acc[y, x] * inv
+                    bgv = bg[y, x]
+                    if bgv < 1.0:
+                        r = (v - bgv) / (1.0 - bgv + 1e-6)
+                        acc[y, x] = r if r > 0.0 else 0.0
+                    else:
+                        acc[y, x] = 0.0
+        return acc
+
+    @nb.njit(cache=True, parallel=True, fastmath=True, boundscheck=False)
+    def _jit_score_bitmap_greedy(
+        spread: np.ndarray,
+        dx: np.ndarray, dy: np.ndarray, bins: np.ndarray,
+        bit_active: np.uint8,
+        min_score: nb.float32,
+        greediness: nb.float32,
+    ) -> np.ndarray:
+        """Score bitmap con early-exit greedy (no rescore background).
+
+        Per ogni pixel iteriamo le N feature; abortiamo non appena diventa
+        impossibile raggiungere `min_required` count anche aggiungendo
+        tutte le feature rimanenti. min_required = greediness * min_score * N.
+
+        greediness=0 → nessun early-exit (equivalente a kernel base).
+        greediness=1 → exit non appena hits + remaining < min_score * N.
+        Tipico: 0.7-0.9 → 2-4x speed-up senza perdere match.
+        """
+        H, W = spread.shape
+        N = dx.shape[0]
+        acc = np.zeros((H, W), dtype=np.float32)
+        if N == 0:
+            return acc
+        min_req = greediness * min_score * N
+        inv_N = nb.float32(1.0 / N)
+        for y in nb.prange(H):
+            for x in range(W):
+                hits = 0
+                for i in range(N):
+                    b = bins[i]
+                    mask = np.uint8(1) << b
+                    if (bit_active & mask) == 0:
+                        if hits + (N - i - 1) < min_req:
+                            break
+                        continue
+                    ddy = dy[i]
+                    yy = y + ddy
+                    if yy < 0 or yy >= H:
+                        if hits + (N - i - 1) < min_req:
+                            break
+                        continue
+                    ddx = dx[i]
+                    xx = x + ddx
+                    if xx < 0 or xx >= W:
+                        if hits + (N - i - 1) < min_req:
+                            break
+                        continue
+                    if spread[yy, xx] & mask:
+                        hits += 1
+                    else:
+                        if hits + (N - i - 1) < min_req:
+                            break
+                acc[y, x] = nb.float32(hits) * inv_N
+        return acc
+
+    @nb.njit(cache=True, parallel=True, fastmath=True, boundscheck=False)
+    def _jit_score_bitmap_rescored(
+        spread: np.ndarray,      # uint8 (H, W)
+        dx: np.ndarray,          # int32 (N,)
+        dy: np.ndarray,          # int32 (N,)
+        bins: np.ndarray,        # int8 (N,)
+        bit_active: np.uint8,
+        bg: np.ndarray,          # float32 (H, W) background density normalizzata
+    ) -> np.ndarray:
+        """score+rescore in un singolo pass: evita allocazione intermedia.
+
+        Equivalente a:
+            score = _jit_score_bitmap(...)
+            out   = max(0, (score - bg) / (1 - bg + 1e-6))
+        ma fonde la seconda passata dentro la normalizzazione finale
+        (cache-friendly, risparmia ~15% sul totale find).
+        """
+        H, W = spread.shape
+        N = dx.shape[0]
+        acc = np.zeros((H, W), dtype=np.float32)
+        for y in nb.prange(H):
+            for i in range(N):
+                b = bins[i]
+                mask = np.uint8(1) << b
+                if (bit_active & mask) == 0:
+                    continue
+                ddy = dy[i]
+                yy = y + ddy
+                if yy < 0 or yy >= H:
+                    continue
+                ddx = dx[i]
+                x_lo = 0 if ddx >= 0 else -ddx
+                x_hi = W if ddx <= 0 else W - ddx
+                for x in range(x_lo, x_hi):
+                    if spread[yy, x + ddx] & mask:
+                        acc[y, x] += 1.0
+        if N > 0:
+            inv = 1.0 / N
+            for y in nb.prange(H):
+                for x in range(W):
+                    v = acc[y, x] * inv
+                    bgv = bg[y, x]
+                    if bgv < 1.0:
+                        r = (v - bgv) / (1.0 - bgv + 1e-6)
+                        acc[y, x] = r if r > 0.0 else 0.0
+                    else:
+                        acc[y, x] = 0.0
+        return acc
+
+    @nb.njit(cache=True, parallel=True, fastmath=True, boundscheck=False)
+    def _jit_top_max_per_variant(
+        spread: np.ndarray,            # uint8 (H, W)
+        dx_flat: np.ndarray,           # int32 (sum_N,)
+        dy_flat: np.ndarray,           # int32 (sum_N,)
+        bins_flat: np.ndarray,         # int8 (sum_N,)
+        offsets: np.ndarray,           # int32 (n_vars+1,) prefix sum
+        bit_active: np.uint8,
+        bg_per_variant: np.ndarray,    # float32 (n_vars, H, W) - 1 per scala
+        scale_idx: np.ndarray,         # int32 (n_vars,) idx in bg_per_variant
+    ) -> np.ndarray:
+        """Batch: per ogni variante calcola max score (rescored bg), ritorna
+        array float32 (n_vars,). Parallelismo prange ESTERNO sulle varianti
+        elimina overhead di n_vars chiamate JIT separate (avg ~20us per
+        chiamata su template piccoli) + pool thread Python.
+
+        Pensato per fase TOP del pruning quando n_vars >> n_threads.
+        """
+        n_vars = offsets.shape[0] - 1
+        H, W = spread.shape
+        out = np.zeros(n_vars, dtype=np.float32)
+        for vi in nb.prange(n_vars):
+            i0 = offsets[vi]; i1 = offsets[vi + 1]
+            N = i1 - i0
+            if N == 0:
+                out[vi] = -1.0
+                continue
+            si = scale_idx[vi]
+            inv = nb.float32(1.0 / N)
+            best = nb.float32(-1.0)
+            for y in range(H):
+                for x in range(W):
+                    s = nb.float32(0.0)
+                    for k in range(N):
+                        b = bins_flat[i0 + k]
+                        mask = np.uint8(1) << b
+                        if (bit_active & mask) == 0:
+                            continue
+                        ddy = dy_flat[i0 + k]
+                        yy = y + ddy
+                        if yy < 0 or yy >= H:
+                            continue
+                        ddx = dx_flat[i0 + k]
+                        xx = x + ddx
+                        if xx < 0 or xx >= W:
+                            continue
+                        if spread[yy, xx] & mask:
+                            s += nb.float32(1.0)
+                    s *= inv
+                    bgv = bg_per_variant[si, y, x]
+                    if bgv < 1.0:
+                        r = (s - bgv) / (1.0 - bgv + 1e-6)
+                        if r > best:
+                            best = r
+            out[vi] = best if best > 0.0 else 0.0
+        return out
+
+    @nb.njit(cache=True, parallel=True, fastmath=True, boundscheck=False)
+    def _jit_score_bitmap_rescored_u16(
+        spread: np.ndarray,      # uint16 (H, W) - 16 bit di polarity-aware
+        dx: np.ndarray, dy: np.ndarray, bins: np.ndarray,
+        bit_active: np.uint16,
+        bg: np.ndarray,
+    ) -> np.ndarray:
+        """Versione uint16 di _jit_score_bitmap_rescored per polarity 16-bin.
+
+        Identica logica ma mask = uint16(1) << b dove b in [0..15]
+        (orientamento mod 2π invece di mod π).
+        """
+        H, W = spread.shape
+        N = dx.shape[0]
+        acc = np.zeros((H, W), dtype=np.float32)
+        for y in nb.prange(H):
+            for i in range(N):
+                b = bins[i]
+                mask = np.uint16(1) << b
+                if (bit_active & mask) == 0:
+                    continue
+                ddy = dy[i]
+                yy = y + ddy
+                if yy < 0 or yy >= H:
+                    continue
+                ddx = dx[i]
+                x_lo = 0 if ddx >= 0 else -ddx
+                x_hi = W if ddx <= 0 else W - ddx
+                for x in range(x_lo, x_hi):
+                    if spread[yy, x + ddx] & mask:
+                        acc[y, x] += 1.0
+        if N > 0:
+            inv = 1.0 / N
+            for y in nb.prange(H):
+                for x in range(W):
+                    v = acc[y, x] * inv
+                    bgv = bg[y, x]
+                    if bgv < 1.0:
+                        r = (v - bgv) / (1.0 - bgv + 1e-6)
+                        acc[y, x] = r if r > 0.0 else 0.0
+                    else:
+                        acc[y, x] = 0.0
+        return acc
+
+    @nb.njit(cache=True, parallel=True, fastmath=True, boundscheck=False)
+    def _jit_popcount_density_u16(spread: np.ndarray) -> np.ndarray:
+        """Popcount per uint16 (16 bin polarity)."""
+        H, W = spread.shape
+        out = np.zeros((H, W), dtype=np.float32)
+        for y in nb.prange(H):
+            for x in range(W):
+                v = spread[y, x]
+                cnt = 0
+                for b in range(16):
+                    if v & (np.uint16(1) << b):
+                        cnt += 1
+                out[y, x] = float(cnt)
+        return out
+
     @nb.njit(cache=True, parallel=True, fastmath=True, boundscheck=False)
     def _jit_popcount_density(spread: np.ndarray) -> np.ndarray:
         """Conta bit set per pixel: ritorna (H, W) float32 in [0..8]."""
@@ -134,7 +411,27 @@ if HAS_NUMBA:
         _jit_score_by_shift(resp, dx, dy, b, ba)
         spread = np.zeros((32, 32), dtype=np.uint8)
         _jit_score_bitmap(spread, dx, dy, b, np.uint8(0xFF))
+        bg = np.zeros((32, 32), dtype=np.float32)
+        _jit_score_bitmap_rescored(spread, dx, dy, b, np.uint8(0xFF), bg)
+        _jit_score_bitmap_rescored_strided(
+            spread, dx, dy, b, np.uint8(0xFF), bg, np.int32(2),
+        )
+        _jit_score_bitmap_greedy(
+            spread, dx, dy, b, np.uint8(0xFF),
+            np.float32(0.5), np.float32(0.8),
+        )
+        offsets = np.array([0, 1], dtype=np.int32)
+        scale_idx = np.zeros(1, dtype=np.int32)
+        bg_pv = np.zeros((1, 32, 32), dtype=np.float32)
+        _jit_top_max_per_variant(
+            spread, dx, dy, b, offsets, np.uint8(0xFF), bg_pv, scale_idx,
+        )
         _jit_popcount_density(spread)
+        spread16 = np.zeros((32, 32), dtype=np.uint16)
+        _jit_score_bitmap_rescored_u16(
+            spread16, dx, dy, b, np.uint16(0xFFFF), bg,
+        )
+        _jit_popcount_density_u16(spread16)
 
 else:  # pragma: no cover
 
@@ -144,6 +441,27 @@ else:  # pragma: no cover
     def _jit_score_bitmap(spread, dx, dy, bins, bit_active):
         raise RuntimeError("numba non disponibile")
 
+    def _jit_score_bitmap_rescored(spread, dx, dy, bins, bit_active, bg):
+        raise RuntimeError("numba non disponibile")
+
+    def _jit_score_bitmap_rescored_strided(spread, dx, dy, bins, bit_active, bg, stride):
+        raise RuntimeError("numba non disponibile")
+
+    def _jit_score_bitmap_greedy(spread, dx, dy, bins, bit_active, min_score, greediness):
+        raise RuntimeError("numba non disponibile")
+
+    def _jit_top_max_per_variant(
+        spread, dx_flat, dy_flat, bins_flat, offsets, bit_active,
+        bg_per_variant, scale_idx,
+    ):
+        raise RuntimeError("numba non disponibile")
+
+    def _jit_score_bitmap_rescored_u16(spread, dx, dy, bins, bit_active, bg):
+        raise RuntimeError("numba non disponibile")
+
+    def _jit_popcount_density_u16(spread):
+        raise RuntimeError("numba non disponibile")
+
     def _jit_popcount_density(spread):
         raise RuntimeError("numba non disponibile")
 
@@ -172,10 +490,134 @@ def score_bitmap(
     return _numpy_score_by_shift(resp, dx, dy, bins, None)
 
 
+def score_bitmap_rescored(
+    spread: np.ndarray, dx: np.ndarray, dy: np.ndarray, bins: np.ndarray,
+    bit_active: int, bg: np.ndarray, stride: int = 1,
+) -> np.ndarray:
+    """Score bitmap + rescore fusi in un solo pass (JIT).
+
+    Dispatch per dtype: uint16 → kernel polarity 16-bin, uint8 → kernel
+    standard 8-bin (con eventuale stride > 1 per coarse top-level).
+    """
+    if HAS_NUMBA and len(dx) > 0:
+        dx_c = np.ascontiguousarray(dx, dtype=np.int32)
+        dy_c = np.ascontiguousarray(dy, dtype=np.int32)
+        bins_c = np.ascontiguousarray(bins, dtype=np.int8)
+        bg_c = np.ascontiguousarray(bg, dtype=np.float32)
+        if spread.dtype == np.uint16:
+            spread_c = np.ascontiguousarray(spread, dtype=np.uint16)
+            return _jit_score_bitmap_rescored_u16(
+                spread_c, dx_c, dy_c, bins_c, np.uint16(bit_active), bg_c,
+            )
+        spread_c = np.ascontiguousarray(spread, dtype=np.uint8)
+        if stride > 1:
+            return _jit_score_bitmap_rescored_strided(
+                spread_c, dx_c, dy_c, bins_c, np.uint8(bit_active), bg_c,
+                np.int32(stride),
+            )
+        return _jit_score_bitmap_rescored(
+            spread_c, dx_c, dy_c, bins_c, np.uint8(bit_active), bg_c,
+        )
+    # Fallback: chiamate separate (stride ignorato in fallback)
+    score = score_bitmap(spread, dx, dy, bins, bit_active)
+    out = (score - bg) / (1.0 - bg + 1e-6)
+    return np.maximum(0.0, out).astype(np.float32)
+
+
+def score_bitmap_greedy(
+    spread: np.ndarray, dx: np.ndarray, dy: np.ndarray, bins: np.ndarray,
+    bit_active: int, min_score: float, greediness: float,
+) -> np.ndarray:
+    """Score bitmap con early-exit greedy. Per coarse-pass aggressivo.
+
+    Non applica rescore background: usare quando la scena ha basso clutter
+    o quando si vuole mass-prune varianti via top-level rapidamente.
+    """
+    if HAS_NUMBA and len(dx) > 0:
+        return _jit_score_bitmap_greedy(
+            np.ascontiguousarray(spread, dtype=np.uint8),
+            np.ascontiguousarray(dx, dtype=np.int32),
+            np.ascontiguousarray(dy, dtype=np.int32),
+            np.ascontiguousarray(bins, dtype=np.int8),
+            np.uint8(bit_active),
+            np.float32(min_score), np.float32(greediness),
+        )
+    # Fallback: kernel base senza early-exit
+    return score_bitmap(spread, dx, dy, bins, bit_active)
+
+
+def top_max_per_variant(
+    spread: np.ndarray,
+    dx_list: list, dy_list: list, bin_list: list,
+    bg_per_scale: dict,
+    variant_scales: list,
+    bit_active: int,
+) -> np.ndarray:
+    """Wrapper: prepara buffer flat e chiama kernel batch su tutte le varianti.
+
+    Parallelismo Numba prange-esterno sulle varianti (n_vars >> n_threads
+    tipicamente per top-pruning) → meglio del thread-pool Python che paga
+    overhead di n_vars chiamate JIT separate.
+    """
+    if not HAS_NUMBA or len(dx_list) == 0:
+        return np.array([], dtype=np.float32)
+    n_vars = len(dx_list)
+    sizes = [len(d) for d in dx_list]
+    offsets = np.zeros(n_vars + 1, dtype=np.int32)
+    offsets[1:] = np.cumsum(sizes)
+    total = int(offsets[-1])
+    dx_flat = np.empty(total, dtype=np.int32)
+    dy_flat = np.empty(total, dtype=np.int32)
+    bins_flat = np.empty(total, dtype=np.int8)
+    for vi, (dx, dy, bn) in enumerate(zip(dx_list, dy_list, bin_list)):
+        i0 = int(offsets[vi]); i1 = int(offsets[vi + 1])
+        dx_flat[i0:i1] = dx
+        dy_flat[i0:i1] = dy
+        bins_flat[i0:i1] = bn
+    # bg per variante: indicizzato per scala
+    scales_unique = sorted(bg_per_scale.keys())
+    scale_to_idx = {s: i for i, s in enumerate(scales_unique)}
+    H, W = spread.shape
+    bg_pv = np.empty((len(scales_unique), H, W), dtype=np.float32)
+    for s, idx in scale_to_idx.items():
+        bg_pv[idx] = bg_per_scale[s]
+    scale_idx = np.array(
+        [scale_to_idx[s] for s in variant_scales], dtype=np.int32,
+    )
+    return _jit_top_max_per_variant(
+        np.ascontiguousarray(spread, dtype=np.uint8),
+        dx_flat, dy_flat, bins_flat, offsets, np.uint8(bit_active),
+        bg_pv, scale_idx,
+    )
+
+
+_HAS_NP_BITCOUNT = hasattr(np, "bitwise_count")
+
+
 def popcount_density(spread: np.ndarray) -> np.ndarray:
+    """Conta bit set per pixel.
+
+    Order:
+    1) Numba JIT parallel (preferito: piu veloce su 1080p, 0.5ms vs 1.6ms)
+    2) numpy.bitwise_count (NumPy 2.0+, SIMD ma single-thread)
+    3) Fallback numpy bit-shift puro
+    """
+    if spread.dtype == np.uint16:
+        spread_c = np.ascontiguousarray(spread, dtype=np.uint16)
+        if HAS_NUMBA:
+            return _jit_popcount_density_u16(spread_c)
+        if _HAS_NP_BITCOUNT:
+            return np.bitwise_count(spread_c).astype(np.float32, copy=False)
+        H, W = spread_c.shape
+        out = np.zeros((H, W), dtype=np.float32)
+        for b in range(16):
+            out += ((spread_c >> b) & 1).astype(np.float32)
+        return out
+    spread_c = np.ascontiguousarray(spread, dtype=np.uint8)
     if HAS_NUMBA:
-        return _jit_popcount_density(np.ascontiguousarray(spread, dtype=np.uint8))
+        return _jit_popcount_density(spread_c)
-    # Fallback
+    if _HAS_NP_BITCOUNT:
+        return np.bitwise_count(spread_c).astype(np.float32, copy=False)
     H, W = spread.shape
     out = np.zeros((H, W), dtype=np.float32)
     for b in range(8):

pm2d/auto_tune.py

@@ -14,6 +14,9 @@ Ritorna dict con i key esatti del form `edit_params`.
 
 from __future__ import annotations
 
+import hashlib
+from collections import OrderedDict
+
 import cv2
 import numpy as np
 
@@ -24,17 +27,33 @@ def _to_gray(img: np.ndarray) -> np.ndarray:
     return img
 
 
+# Cache in-memory (LRU) dei risultati auto_tune per stesso input ROI.
+_TUNE_CACHE: OrderedDict[str, dict] = OrderedDict()
+_TUNE_CACHE_SIZE = 32
+
+
 def detect_rotational_symmetry(
     gray: np.ndarray, step_deg: float = 5.0, corr_thresh: float = 0.75,
 ) -> dict:
     """Rileva simmetria rotazionale su edge map (più robusto a sfondo uniforme).
 
+    Downsample a max 128 px prima di correlare per abbattere il costo
+    O(n_angles · H · W) senza perdere precisione (la simmetria rotazionale
+    è invariante a subsampling moderato).
+
     Ritorna dict con:
       - order: int, 1=nessuna, 2=180°, 3=120°, 4=90°, 6=60°, 8=45°
       - period_deg: float, periodo minimo di simmetria (360/order)
       - confidence: float [0..1], correlazione minima tra rotazioni equivalenti
     """
     h, w = gray.shape
+    target = 128
+    if max(h, w) > target:
+        sf = target / max(h, w)
+        new_w = max(32, int(w * sf))
+        new_h = max(32, int(h * sf))
+        gray = cv2.resize(gray, (new_w, new_h), interpolation=cv2.INTER_AREA)
+        h, w = gray.shape
     # Usa magnitude gradiente (rotation-invariant rispetto a bg uniforme)
     gx = cv2.Sobel(gray, cv2.CV_32F, 1, 0, ksize=3)
     gy = cv2.Sobel(gray, cv2.CV_32F, 0, 1, ksize=3)
@@ -88,9 +107,12 @@ def analyze_gradients(gray: np.ndarray) -> dict:
     gy = cv2.Sobel(gray, cv2.CV_32F, 0, 1, ksize=3)
     mag = cv2.magnitude(gx, gy)
 
-    # Percentili magnitude
+    # Percentili magnitude: p55/p85 usati per soglie weak/strong (più aderenti
+    # alla distribuzione reale rispetto a p50/p80 + clamp).
     p50 = float(np.percentile(mag, 50))
+    p55 = float(np.percentile(mag, 55))
     p80 = float(np.percentile(mag, 80))
+    p85 = float(np.percentile(mag, 85))
     p95 = float(np.percentile(mag, 95))
     mag_max = float(mag.max())
 
@@ -112,7 +134,8 @@ def analyze_gradients(gray: np.ndarray) -> dict:
         ent = 0.0
 
     return {
-        "p50": p50, "p80": p80, "p95": p95, "mag_max": mag_max,
+        "p50": p50, "p55": p55, "p80": p80, "p85": p85, "p95": p95,
+        "mag_max": mag_max,
         "strong_pct": strong_pct, "weak_pct": weak_pct,
         "orient_entropy": ent,
         "n_pixels": mag.size,
@@ -120,11 +143,41 @@ def analyze_gradients(gray: np.ndarray) -> dict:
     }
 
 
-def auto_tune(template_bgr: np.ndarray, mask: np.ndarray | None = None) -> dict:
+def _cache_key(template_bgr: np.ndarray, mask: np.ndarray | None) -> str:
+    h = hashlib.md5()
+    h.update(np.ascontiguousarray(template_bgr).tobytes())
+    h.update(f"shape={template_bgr.shape}".encode())
+    if mask is not None:
+        h.update(np.ascontiguousarray(mask).tobytes())
+    return h.hexdigest()
+
+
+def auto_tune(
+    template_bgr: np.ndarray,
+    mask: np.ndarray | None = None,
+    angle_tolerance_deg: float | None = None,
+    angle_center_deg: float = 0.0,
+) -> dict:
     """Analizza template e ritorna dict parametri suggeriti.
 
     Chiavi compatibili con edit_params PARAM_SCHEMA.
+
+    angle_tolerance_deg: se != None, restringe angle_range a
+    (center - tol, center + tol). Usare quando l'orientamento del
+    pezzo e' noto a priori (feeder con guida, posizionamento
+    meccanico): training molto piu rapido (24x meno varianti per
+    tol=15° vs 360° pieno).
+
+    Risultato cachato in-memory (LRU): ri-chiamare con stessa ROI è O(1).
     """
+    ck = _cache_key(template_bgr, mask)
+    if angle_tolerance_deg is not None:
+        ck = f"{ck}|tol={angle_tolerance_deg}|c={angle_center_deg}"
+    cached = _TUNE_CACHE.get(ck)
+    if cached is not None:
+        _TUNE_CACHE.move_to_end(ck)
+        return dict(cached)
+
     gray = _to_gray(template_bgr)
     h, w = gray.shape
     if mask is not None:
@@ -136,16 +189,22 @@ def auto_tune(template_bgr: np.ndarray, mask: np.ndarray | None = None) -> dict:
     stats = analyze_gradients(gray_for_stats)
     sym = detect_rotational_symmetry(gray_for_stats)
 
-    # Soglie magnitude: usa percentili per robustezza illuminazione.
+    # Soglie magnitude: usa percentili reali (p85/p55) senza clamp duro a 100.
-    # Target: strong_grad ~= valore a percentile 80-90 in assoluto, ma
+    # Sobel ksize=3 su uint8 può arrivare a ~1020, quindi clamp massimo 400
-    # clamp per compatibilità uint8 (Sobel può sforare).
+    # evita saturazione del threshold su template ad alto contrasto.
-    strong_grad = float(np.clip(stats["p80"], 20.0, 100.0))
+    strong_grad = float(np.clip(stats["p85"], 30.0, 400.0))
-    weak_grad = float(np.clip(strong_grad * 0.5, 10.0, 60.0))
+    weak_grad = float(np.clip(stats["p55"], 15.0, strong_grad * 0.7))
 
-    # num_features: 1 feature ogni ~25 px forti, clamp 48..192
+    # num_features: ibrido perimetro + densità. Target = min(perimeter_budget,
-    target_feat = int(np.clip(stats["n_strong"] / 25, 48, 192))
+    # density_budget) per non generare più feature di quante edge nitide siano
+    # disponibili, ma neanche meno di quante il perimetro possa tracciare.
+    perim_budget = int(2 * (h + w) * 0.4)          # ~40% dei pixel di perimetro
+    density_budget = int(stats["n_strong"] / 20)   # 1 feature ogni ~20 px forti
+    target_feat = int(np.clip(min(perim_budget, density_budget), 64, 192))
 
-    # pyramid_levels in base alla dimensione minima
+    # pyramid_levels in base a dimensione minima E densità feature: un template
+    # grande ma povero di feature non deve scendere troppi livelli (rischio
+    # collasso a <16 feature al top level).
     min_side = min(h, w)
     if min_side < 60:
         pyr = 1
@@ -155,12 +214,20 @@ def auto_tune(template_bgr: np.ndarray, mask: np.ndarray | None = None) -> dict:
         pyr = 3
     else:
         pyr = 4
+    # Cap: non scendere sotto ~16 feature al top level (feature ÷ 4^(pyr-1))
+    max_pyr_from_feat = max(1, int(np.floor(np.log2(max(1, target_feat / 16.0)) / 2.0)) + 1)
+    pyr = min(pyr, max_pyr_from_feat)
 
     # spread_radius proporzionale a risoluzione + pyramid (tolleranza ~1% dim)
     spread_radius = int(np.clip(max(3, min_side * 0.02), 3, 8))
 
-    # angle range ridotto se simmetria rotazionale
+    # angle range: priorita' a tolerance hint utente, poi simmetria rotazionale.
-    angle_max = 360.0 / sym["order"] if sym["order"] > 1 else 360.0
+    if angle_tolerance_deg is not None:
+        angle_min = float(angle_center_deg - angle_tolerance_deg)
+        angle_max = float(angle_center_deg + angle_tolerance_deg)
+    else:
+        angle_min = 0.0
+        angle_max = 360.0 / sym["order"] if sym["order"] > 1 else 360.0
 
     # min_score: se entropia orient alta → template distintivo → soglia alta ok
     # se entropia bassa → template ambiguo → soglia più permissiva
@@ -171,12 +238,15 @@ def auto_tune(template_bgr: np.ndarray, mask: np.ndarray | None = None) -> dict:
     else:
         min_score = 0.45
 
-    # angle step: 5° default; se simmetria, mantengo step ma range ridotto
+    # angle step adattivo (Halcon-style): atan(2/max_side) deg, clampato.
-    angle_step = 5.0
+    # Template grande → step fine (rotazione minima visibile su perimetro).
+    # Template piccolo → step grosso (over-sampling = sprecato).
+    max_side = max(h, w)
+    angle_step = float(np.clip(np.degrees(np.arctan2(2.0, max_side)), 1.0, 8.0))
 
-    return {
+    result = {
         "backend": "line",
-        "angle_min": 0.0,
+        "angle_min": angle_min,
         "angle_max": angle_max,
         "angle_step": angle_step,
         "scale_min": 1.0,
@@ -196,6 +266,12 @@ def auto_tune(template_bgr: np.ndarray, mask: np.ndarray | None = None) -> dict:
         "_symmetry_conf": round(sym["confidence"], 2),
         "_orient_entropy": round(stats["orient_entropy"], 2),
     }
+    # Store in LRU cache
+    _TUNE_CACHE[ck] = dict(result)
+    _TUNE_CACHE.move_to_end(ck)
+    while len(_TUNE_CACHE) > _TUNE_CACHE_SIZE:
+        _TUNE_CACHE.popitem(last=False)
+    return result
 
 
 def summarize(tune: dict) -> str:

pm2d/web/server.py

@@ -9,10 +9,12 @@ Endpoint:
 """
 from __future__ import annotations
 
+import hashlib
 import os
 import tempfile
 import time
 import uuid
+from collections import OrderedDict
 from pathlib import Path
 
 import cv2
@@ -61,6 +63,39 @@ CACHE_DIR.mkdir(exist_ok=True)
 # Cache in-memory (soft, ricaricata da disco se mancante)
 _IMG_CACHE: dict[str, np.ndarray] = {}
 
+# Cache matcher addestrati: (roi_hash, params_hash) -> LineShapeMatcher
+# LRU con capacità limitata
+_MATCHER_CACHE: OrderedDict = OrderedDict()
+_MATCHER_CACHE_SIZE = 8
+
+
+def _matcher_cache_key(roi: np.ndarray, tech: dict) -> str:
+    h = hashlib.md5()
+    h.update(roi.tobytes())
+    # Solo parametri che influenzano il training
+    relevant = ("num_features", "weak_grad", "strong_grad",
+                "angle_min", "angle_max", "angle_step",
+                "scale_min", "scale_max", "scale_step",
+                "spread_radius", "pyramid_levels")
+    for k in relevant:
+        h.update(f"{k}={tech.get(k)}".encode())
+    h.update(f"shape={roi.shape}".encode())
+    return h.hexdigest()
+
+
+def _cache_get_matcher(key: str):
+    m = _MATCHER_CACHE.get(key)
+    if m is not None:
+        _MATCHER_CACHE.move_to_end(key)  # LRU touch
+    return m
+
+
+def _cache_put_matcher(key: str, matcher) -> None:
+    _MATCHER_CACHE[key] = matcher
+    _MATCHER_CACHE.move_to_end(key)
+    while len(_MATCHER_CACHE) > _MATCHER_CACHE_SIZE:
+        _MATCHER_CACHE.popitem(last=False)
+
 
 def _store_image(img: np.ndarray) -> str:
     iid = uuid.uuid4().hex[:12]
@@ -214,9 +249,9 @@ PRECISION_ANGLE_STEP = {
 # Un operatore sceglie il livello di rigore, non un numero astratto.
 FILTRO_FP_MAP = {
     "off":      0.0,   # disabilitato: mantieni tutti i match shape-based
-    "leggero":  0.20,  # tollera variazioni intensità/illuminazione forti
+    "leggero":  0.30,  # tollera variazioni intensità/illuminazione forti
-    "medio":    0.35,  # default bilanciato (consigliato)
+    "medio":    0.50,  # default bilanciato (consigliato)
-    "forte":    0.50,  # scarta match con intensità molto diversa dal template
+    "forte":    0.70,  # scarta match con intensità molto diversa dal template
 }
 
 
@@ -229,6 +264,7 @@ class SimpleMatchParams(BaseModel):
     scala: str = "fissa"              # chiave SCALE_PRESETS
     precisione: str = "normale"       # chiave PRECISION_ANGLE_STEP
     filtro_fp: str = "medio"          # chiave FILTRO_FP_MAP
+    penalita_scala: float = 0.0       # 0 = score shape invariante, >0 = penalizza scala != 1
     min_score: float = 0.65
     max_matches: int = 25
 
@@ -281,6 +317,7 @@ def _simple_to_technical(
         "max_matches": p.max_matches,
         "nms_radius": 0,
         "verify_threshold": FILTRO_FP_MAP.get(p.filtro_fp, 0.35),
+        "scale_penalty": p.penalita_scala,
     }
 
 
@@ -292,6 +329,49 @@ def index():
     return HTMLResponse(html_path.read_text(encoding="utf-8"))
 
 
+@app.post("/upload_to_folder")
+async def upload_to_folder(file: UploadFile = File(...)):
+    """Salva file caricato nella cartella IMAGES_DIR. Ritorna lista aggiornata."""
+    if not IMAGES_DIR.is_dir():
+        raise HTTPException(500, f"IMAGES_DIR non esiste: {IMAGES_DIR}")
+    # Sanitizza nome file (no traversal)
+    name = Path(file.filename or "upload.png").name
+    if not name:
+        raise HTTPException(400, "nome file vuoto")
+    ext = Path(name).suffix.lower()
+    allowed = {".png", ".jpg", ".jpeg", ".bmp", ".tif", ".tiff"}
+    if ext not in allowed:
+        raise HTTPException(400, f"estensione non supportata: {ext}")
+    # Leggi contenuto e valida come immagine
+    data = await file.read()
+    arr = np.frombuffer(data, dtype=np.uint8)
+    img = cv2.imdecode(arr, cv2.IMREAD_COLOR)
+    if img is None:
+        raise HTTPException(400, "file non è un'immagine valida")
+    # Evita overwrite: se esiste, aggiungi suffisso numerico
+    target = IMAGES_DIR / name
+    if target.exists():
+        stem = target.stem; suffix = target.suffix
+        i = 1
+        while True:
+            alt = IMAGES_DIR / f"{stem}_{i}{suffix}"
+            if not alt.exists():
+                target = alt; break
+            i += 1
+    # Scrivi su disco
+    with open(target, "wb") as f:
+        f.write(data)
+    # Ritorna lista aggiornata
+    return {
+        "saved_as": target.name,
+        "dir": str(IMAGES_DIR),
+        "files": sorted(
+            p.name for p in IMAGES_DIR.iterdir()
+            if p.is_file() and p.suffix.lower() in allowed
+        ),
+    }
+
+
 @app.get("/folder_image/{filename}")
 def folder_image(filename: str, w: int = 120):
     """Serve thumbnail PNG dell'immagine IMAGES_DIR (scalata a width w)."""
@@ -375,17 +455,33 @@ def match(p: MatchParams):
     h = max(1, min(h, model.shape[0] - y))
     roi_img = model[y:y + h, x:x + w]
 
-    m = LineShapeMatcher(
+    tech_for_cache = {
-        num_features=p.num_features,
+        "num_features": p.num_features,
-        weak_grad=p.weak_grad, strong_grad=p.strong_grad,
+        "weak_grad": p.weak_grad, "strong_grad": p.strong_grad,
-        angle_range_deg=(p.angle_min, p.angle_max),
+        "angle_min": p.angle_min, "angle_max": p.angle_max,
-        angle_step_deg=p.angle_step,
+        "angle_step": p.angle_step,
-        scale_range=(p.scale_min, p.scale_max),
+        "scale_min": p.scale_min, "scale_max": p.scale_max,
-        scale_step=p.scale_step,
+        "scale_step": p.scale_step,
-        spread_radius=p.spread_radius,
+        "spread_radius": p.spread_radius,
-        pyramid_levels=p.pyramid_levels,
+        "pyramid_levels": p.pyramid_levels,
-    )
+    }
-    t0 = time.time(); n = m.train(roi_img); t_train = time.time() - t0
+    key = _matcher_cache_key(roi_img, tech_for_cache)
+    m = _cache_get_matcher(key)
+    if m is None:
+        m = LineShapeMatcher(
+            num_features=p.num_features,
+            weak_grad=p.weak_grad, strong_grad=p.strong_grad,
+            angle_range_deg=(p.angle_min, p.angle_max),
+            angle_step_deg=p.angle_step,
+            scale_range=(p.scale_min, p.scale_max),
+            scale_step=p.scale_step,
+            spread_radius=p.spread_radius,
+            pyramid_levels=p.pyramid_levels,
+        )
+        t0 = time.time(); n = m.train(roi_img); t_train = time.time() - t0
+        _cache_put_matcher(key, m)
+    else:
+        n = len(m.variants); t_train = 0.0
     nms = p.nms_radius if p.nms_radius > 0 else None
     t0 = time.time()
     matches = m.find(
@@ -429,22 +525,29 @@ def match_simple(p: SimpleMatchParams):
 
     tech = _simple_to_technical(p, roi_img)
 
-    m = LineShapeMatcher(
+    key = _matcher_cache_key(roi_img, tech)
-        num_features=tech["num_features"],
+    m = _cache_get_matcher(key)
-        weak_grad=tech["weak_grad"], strong_grad=tech["strong_grad"],
+    if m is None:
-        angle_range_deg=(tech["angle_min"], tech["angle_max"]),
+        m = LineShapeMatcher(
-        angle_step_deg=tech["angle_step"],
+            num_features=tech["num_features"],
-        scale_range=(tech["scale_min"], tech["scale_max"]),
+            weak_grad=tech["weak_grad"], strong_grad=tech["strong_grad"],
-        scale_step=tech["scale_step"],
+            angle_range_deg=(tech["angle_min"], tech["angle_max"]),
-        spread_radius=tech["spread_radius"],
+            angle_step_deg=tech["angle_step"],
-        pyramid_levels=tech["pyramid_levels"],
+            scale_range=(tech["scale_min"], tech["scale_max"]),
-    )
+            scale_step=tech["scale_step"],
-    t0 = time.time(); n = m.train(roi_img); t_train = time.time() - t0
+            spread_radius=tech["spread_radius"],
+            pyramid_levels=tech["pyramid_levels"],
+        )
+        t0 = time.time(); n = m.train(roi_img); t_train = time.time() - t0
+        _cache_put_matcher(key, m)
+    else:
+        n = len(m.variants); t_train = 0.0
     nms = tech["nms_radius"] if tech["nms_radius"] > 0 else None
     t0 = time.time()
     matches = m.find(
         scene, min_score=tech["min_score"], max_matches=tech["max_matches"],
         nms_radius=nms, verify_threshold=tech["verify_threshold"],
+        scale_penalty=tech.get("scale_penalty", 0.0),
     )
     t_find = time.time() - t0
 

pm2d/web/static/app.js

@@ -48,6 +48,8 @@ function readUserParams() {
     scala: document.getElementById("p-scala").value,
     precisione: document.getElementById("p-precisione").value,
     filtro_fp: document.getElementById("p-filtro-fp").value,
+    penalita_scala: parseFloat(
+      document.getElementById("p-penalita-scala").value),
     min_score: parseFloat(document.getElementById("p-min-score").value),
     max_matches: parseInt(document.getElementById("p-max-matches").value, 10),
   };
@@ -80,6 +82,21 @@ async function fetchImagesList() {
   return await r.json();
 }
 
+async function uploadToFolder(file) {
+  const fd = new FormData();
+  fd.append("file", file);
+  const r = await fetch("/upload_to_folder", { method: "POST", body: fd });
+  if (!r.ok) throw new Error(await r.text());
+  return await r.json();
+}
+
+async function refreshPickers() {
+  const {files, dir} = await fetchImagesList();
+  buildThumbPicker("picker-model", files, onSelectModel);
+  buildThumbPicker("picker-scene", files, onSelectScene);
+  return {files, dir};
+}
+
 function buildThumbPicker(pickerId, files, onSelect) {
   const picker = document.getElementById(pickerId);
   const current = picker.querySelector(".picker-current");
@@ -277,12 +294,17 @@ async function doMatch() {
     const SCALE_MAP = {fissa:[1,1,0.1], mini:[0.9,1.1,0.05],
                        medio:[0.75,1.25,0.05], max:[0.5,1.5,0.05]};
     const PREC_MAP = {veloce:10, normale:5, preciso:2};
-    const FP_MAP = {off:0, leggero:0.20, medio:0.35, forte:0.50};
+    // Allineato a FILTRO_FP_MAP server-side (server.py)
+    const FP_MAP = {off:0, leggero:0.30, medio:0.50, forte:0.70};
     const [smin, smax, sstep] = SCALE_MAP[user.scala];
+    // NB: SYM_MAP[invariante]=0 e' valido (zero rotazioni). Uso ?? per
+    // distinguere "chiave mancante" da "valore zero": altrimenti 0 || 360
+    // collassa invariante a 360 = bug "simmetria non ha effetto".
+    const angMax = SYM_MAP[user.simmetria] ?? 360;
     body = {
       model_id: state.model.id, scene_id: state.scene.id, roi: state.roi,
-      angle_min: 0, angle_max: SYM_MAP[user.simmetria] || 360,
+      angle_min: 0, angle_max: angMax,
-      angle_step: PREC_MAP[user.precisione] || 5,
+      angle_step: PREC_MAP[user.precisione] ?? 5,
       scale_min: smin, scale_max: smax, scale_step: sstep,
       min_score: user.min_score, max_matches: user.max_matches,
       num_features: adv.num_features ?? 96,
@@ -290,7 +312,7 @@ async function doMatch() {
       strong_grad: adv.strong_grad ?? 60,
       spread_radius: adv.spread_radius ?? 5,
       pyramid_levels: adv.pyramid_levels ?? 3,
-      verify_threshold: adv.verify_threshold ?? (FP_MAP[user.filtro_fp] ?? 0.35),
+      verify_threshold: adv.verify_threshold ?? (FP_MAP[user.filtro_fp] ?? 0.50),
       nms_radius: adv.nms_radius ?? 0,
     };
   } else {
@@ -349,14 +371,28 @@ window.addEventListener("DOMContentLoaded", async () => {
   buildAdvancedForm();
   setupROI();
   // Popola picker immagini da IMAGES_DIR (con thumbnail)
-  const {files, dir} = await fetchImagesList();
+  const {files, dir} = await refreshPickers();
-  buildThumbPicker("picker-model", files, onSelectModel);
-  buildThumbPicker("picker-scene", files, onSelectScene);
   if (files.length === 0) {
-    setStatus(`Nessuna immagine in ${dir} (configura IMAGES_DIR in .env)`);
+    setStatus(`Nessuna immagine in ${dir} (carica file o configura IMAGES_DIR)`);
   } else {
-    setStatus(`${files.length} immagini disponibili in ${dir}`);
+    setStatus(`${files.length} immagini in ${dir}`);
   }
+
+  // Upload file nella folder
+  const upEl = document.getElementById("file-upload");
+  upEl.addEventListener("change", async (e) => {
+    const f = e.target.files[0];
+    if (!f) return;
+    setStatus(`Caricamento ${f.name} nella cartella...`);
+    try {
+      const res = await uploadToFolder(f);
+      await refreshPickers();
+      setStatus(`Salvato come ${res.saved_as} (${res.files.length} file totali)`);
+    } catch (err) {
+      setStatus(`Errore upload: ${err.message}`);
+    }
+    e.target.value = "";  // consente re-upload stesso file
+  });
   document.getElementById("btn-match").addEventListener("click", doMatch);
   const slider = document.getElementById("p-min-score");
   slider.addEventListener("input", (e) => {

pm2d/web/static/index.html

@@ -26,6 +26,10 @@
       <div class="picker-list"></div>
     </div>
     <button class="btn btn-go" id="btn-match">▶ MATCH</button>
+    <label class="btn" title="Carica nuovo file nella cartella immagini">
+      ⬆ Carica file
+      <input type="file" id="file-upload" accept="image/*" hidden>
+    </label>
     <span id="status">Seleziona modello, disegna ROI, seleziona scena</span>
   </div>
 </header>
@@ -101,6 +105,18 @@
       </select>
     </div>
 
+    <div class="field">
+      <label>Peso dimensione nel score
+        <span class="hint">(penalizza scala ≠ 1.0)</span>
+      </label>
+      <select id="p-penalita-scala">
+        <option value="0" selected>Nessuno (score shape puro)</option>
+        <option value="0.3">Leggero (−30% max)</option>
+        <option value="0.5">Medio (−50% max)</option>
+        <option value="0.8">Forte (−80% max)</option>
+      </select>
+    </div>
+
     <div class="field">
       <label>Score minimo <span id="v-score">0.65</span>
         <span class="hint">(più basso = più match anche incerti)</span>