maker: pan dell'immagine di prova non si interrompe col mouse (Refs #104)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Jbf7qKuxsnAVjxthRy7dnB

src/backend/api/routers/tasks.py

@@ -250,6 +250,8 @@ async def create_task(
         file_type=data.file_type,
         annotations_json=data.annotations_json,
         vision_json=data.vision_json,
+        # #97: camera e modo di analisi (dict gia' validato dal modello)
+        acquisition_json=data.acquisition_json.model_dump() if data.acquisition_json else None,
         # #53 #55: ciclo (default dal tipo), chiusura, campi extra
         in_loop=data.in_loop if data.in_loop is not None else default_in_loop(data.task_type),
         at_close=data.at_close,

src/backend/api/routers/vision.py

@@ -8,6 +8,7 @@ import base64
 import binascii
 import io
 import json
+import mimetypes
 from typing import Literal
 
 from fastapi.responses import FileResponse
@@ -23,7 +24,7 @@ from src.backend.api.routers.files import (
 from src.backend.config import settings
 from src.backend.database import get_db
 from src.backend.models.api.vision import (
-    VisionExecuteResponse, VisionMeasurementResult, VisionRecipeResponse,
+    VisionCheckResponse, VisionExecuteResponse, VisionMeasurementResult, VisionRecipeResponse,
     VisionRecipeUploadResponse, VisionReferenceImageResponse,
 )
 from src.backend.models.orm.vision import VisionResult
@@ -40,14 +41,22 @@ _IMAGE_EXTENSIONS = {
     "image/png": "png",
     "image/gif": "gif",
     "image/webp": "webp",
+    "image/bmp": "bmp",          # #99
+    "image/x-ms-bmp": "bmp",     # #99
 }
 
+# #99: the Opto bench cameras save BMP and the worker decodes it (PIL), so the
+# vision routes accept it on top of files.py's list. files.py is untouched: its
+# attachments are served by extension and BMP is not meant to be shown there.
+_VISION_IMAGE_TYPES = ALLOWED_IMAGE_TYPES | {"image/bmp", "image/x-ms-bmp"}
+
 # Sniffed from the first bytes, independent of the declared Content-Type: a
 # text file uploaded as "image/png" passes the header check above and must
-# still be caught before it reaches the worker as a bare 500 (#15). BMP and
-# TIFF are included even though `_IMAGE_EXTENSIONS` does not accept them,
-# because PIL - and so the worker - can decode both; this check only refuses
-# what is not a real image at all, it does not narrow the allow-list above.
+# still be caught before it reaches the worker as a bare 500 (#15). TIFF is
+# included even though the allow-list does not accept it (PIL, and so the
+# worker, can decode it; browsers do not show it in the result); BMP is now
+# also allowed (#99). This check only refuses what is not a real image at all,
+# it does not narrow the allow-list above.
 _IMAGE_SIGNATURES: tuple[tuple[bytes, ...], ...] = (
     (b"\x89PNG\r\n\x1a\n",),         # PNG
     (b"\xff\xd8\xff",),              # JPEG
@@ -83,7 +92,7 @@ async def _read_image(image: UploadFile) -> bytes:
     is in hand - the same two-step convention `files.py::upload_file` already
     uses, reused rather than reinvented here.
     """
-    if image.content_type not in ALLOWED_IMAGE_TYPES:
+    if image.content_type not in _VISION_IMAGE_TYPES:  # #99
         raise HTTPException(
             status_code=status.HTTP_400_BAD_REQUEST,
             detail=f"File type {image.content_type} not allowed. Must be an image.",
@@ -164,6 +173,22 @@ async def execute(
     )
 
 
+@router.post("/check", response_model=VisionCheckResponse)
+async def check(
+    task_id: int = Form(...),
+    image: UploadFile = File(...),
+    production_run_id: int | None = Form(None, gt=0),
+    db: AsyncSession = Depends(get_db),
+    current_user: User = Depends(require_measurement_tec),
+) -> VisionCheckResponse:
+    """#97: analisi di un frame senza salvare nulla (ne' risultato ne' misure)."""
+    task = await _task_or_404(db, task_id)
+    report = await vision_service.check_task(
+        db, task, await _read_image(image), production_run_id=production_run_id,
+    )
+    return VisionCheckResponse(**report)
+
+
 @router.get("/results/{result_id}/image")
 async def get_result_image(
     result_id: int,
@@ -342,6 +367,20 @@ async def preview(
     return await vision_service.preview(db, task, await _read_image(image))
 
 
+@router.post("/dxf-preview")
+async def dxf_preview(
+    dxf: UploadFile = File(...),
+    current_user: User = Depends(require_maker),
+) -> dict:
+    """#101: anteprima del DXF scelto nel wizard «Crea ricetta da DXF» (contorni
+    in mm e dimensioni), letto dal worker con lo stesso lettore del confronto.
+    Non scrive nulla; stesso limite di dimensione della rotta dxf-compare."""
+    dxf_bytes = await dxf.read()
+    if not validate_file_size(len(dxf_bytes)):
+        raise _422([f"the DXF exceeds {settings.max_upload_size_mb}MB"])
+    return await vision_service.dxf_preview(dxf_bytes)
+
+
 @router.post("/tasks/{task_id}/recipe/dxf-compare")
 async def create_dxf_compare_recipe(
     task_id: int,
@@ -409,8 +448,50 @@ async def create_dxf_compare_recipe(
     placed, errors = vision_service.match_recipe_files(body["graph"], uploads)
     if errors:
         raise _422(errors)
+    # #105: l'immagine di riferimento resta nella cartella (non e' in meta, quindi
+    # /validate e l'esecuzione la ignorano) e il wizard puo' riaprirla; entra nel digest.
+    placed[f"riferimento.{_IMAGE_EXTENSIONS.get(image.content_type, 'png')}"] = image_bytes
     recipe_dir, check = await _store_validate_assign(task, body["graph"], placed)
     await vision_service.ensure_points_quote(db, task, min_points_pct)
     await db.commit()
     response.update(saved=True, recipe_dir=recipe_dir, outputs=check["outputs"])
     return response
+
+
+@router.get("/tasks/{task_id}/recipe/dxf-compare/source")
+async def get_dxf_compare_source(
+    task_id: int,
+    db: AsyncSession = Depends(get_db),
+    current_user: User = Depends(require_maker),
+) -> dict:
+    """#105: i parametri della ricetta fatta con «Crea ricetta da DXF», per modificarla.
+
+    404 se il task non ha una ricetta del wizard (nessuna, o caricata a mano).
+    """
+    task = await _task_or_404(db, task_id)
+    source = vision_service.dxf_compare_source(task.vision_json, task.vision_recipe_dir)
+    if source is None:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="nessuna ricetta da DXF su questo task",
+        )
+    return source
+
+
+@router.get("/tasks/{task_id}/recipe/files/{path:path}")
+async def get_recipe_file(
+    task_id: int,
+    path: str,
+    db: AsyncSession = Depends(get_db),
+    current_user: User = Depends(require_maker),
+) -> FileResponse:
+    """#105: un file della cartella ricetta del task (DXF, immagine di riferimento).
+
+    Percorso non sicuro, file assente o task senza ricetta: sempre 404.
+    """
+    task = await _task_or_404(db, task_id)
+    target = vision_service.recipe_file_path(task.vision_recipe_dir, path)
+    if target is None:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="file not found")
+    media_type = mimetypes.guess_type(target.name)[0] or "application/octet-stream"
+    return FileResponse(target, media_type=media_type)

src/backend/migrations/versions/021_task_acquisition.py

@@ -0,0 +1,31 @@
+"""recipe_tasks.acquisition_json (#97)
+
+recipe_tasks.acquisition_json: camera e modo di analisi scelti nel task,
+{"camera_url", "camera_source", "modo": "impulsiva" | "in_linea"}; NULL = la
+camera della stazione dell'operatore, analisi impulsiva (come prima).
+
+Revision ID: 021_task_acquisition
+Revises: 020_station_camera
+Create Date: 2026-10-24
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+revision: str = '021_task_acquisition'
+down_revision: Union[str, None] = '020_station_camera'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    # batch_alter_table come nelle migrazioni vicine: serve a SQLite
+    with op.batch_alter_table('recipe_tasks') as batch:
+        batch.add_column(sa.Column('acquisition_json', sa.JSON(), nullable=True))
+
+
+def downgrade() -> None:
+    with op.batch_alter_table('recipe_tasks') as batch:
+        batch.drop_column('acquisition_json')

src/backend/models/api/task.py

@@ -2,8 +2,9 @@
 import re
 from typing import Any, Literal, Optional
 
-from pydantic import BaseModel, ConfigDict, Field, model_validator
+from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
 
+from src.backend.models.api.station import _normalize_http_url
 from src.backend.models.orm.task import DEFAULT_LOOP_TASK_TYPES, TASK_TYPES
 
 # Kept in step with the ORM enum so the two cannot drift apart.
@@ -159,6 +160,30 @@ class SubtaskResponse(BaseModel):
     vision_output: Optional[str] = None
 
 
+class AcquisitionConfig(BaseModel):
+    """#97: camera (servizio + sorgente) e modo di analisi scelti nel task."""
+    camera_url: str = Field(..., max_length=500)
+    camera_source: str = Field(..., min_length=1, max_length=200)
+    modo: Literal["impulsiva", "in_linea"] = "impulsiva"
+
+    @field_validator("camera_url")
+    @classmethod
+    def _check_camera_url(cls, value: str) -> str:
+        # stessa normalizzazione delle stazioni; qui il vuoto non e' ammesso
+        normalized = _normalize_http_url(value, "camera_url")
+        if normalized is None:
+            raise ValueError("camera_url must not be empty")
+        return normalized
+
+    @field_validator("camera_source")
+    @classmethod
+    def _check_camera_source(cls, value: str) -> str:
+        value = value.strip()
+        if not value:
+            raise ValueError("camera_source must not be empty")
+        return value
+
+
 class TaskCreate(BaseModel):
     """Schema for creating a task."""
     title: str = Field(..., min_length=1, max_length=255)
@@ -169,6 +194,7 @@ class TaskCreate(BaseModel):
     file_type: Optional[str] = Field(None, pattern="^(image|pdf)$")
     annotations_json: Optional[dict[str, Any]] = None
     vision_json: Optional[dict] = None
+    acquisition_json: Optional[AcquisitionConfig] = None  # #97
     # #53: assente = default dal tipo (misure e check nel ciclo)
     in_loop: Optional[bool] = None
     at_close: bool = False
@@ -186,6 +212,7 @@ class TaskUpdate(BaseModel):
     file_type: Optional[str] = Field(None, pattern="^(image|pdf)$")
     annotations_json: Optional[dict[str, Any]] = None
     vision_json: Optional[dict] = None
+    acquisition_json: Optional[AcquisitionConfig] = None  # #97
     in_loop: Optional[bool] = None
     at_close: Optional[bool] = None
     fields: Optional[list[dict[str, Any]]] = None
@@ -207,6 +234,7 @@ class TaskResponse(BaseModel):
     file_type: Optional[str] = None
     annotations_json: Optional[dict[str, Any]] = None
     vision_json: Optional[dict] = None
+    acquisition_json: Optional[AcquisitionConfig] = None  # #97
     in_loop: bool = False
     at_close: bool = False
     fields: Optional[list[dict[str, Any]]] = None

src/backend/models/api/vision.py

@@ -24,6 +24,16 @@ class VisionExecuteResponse(BaseModel):
     failures: list[dict] = []
 
 
+class VisionCheckResponse(BaseModel):
+    """What `POST /api/vision/check` returns (#97): the analysis, nothing saved."""
+    outcome: str | None = None
+    overlay: list[dict] = []
+    failures: list[dict] = []
+    measurements: list[VisionMeasurementResult] = []
+    # esito della lettura della calibrazione: ok | no_camera | not_calibrated | unreachable
+    calibration: str
+
+
 class VisionRecipeOutput(BaseModel):
     """One numeric output a recipe offers to the quotes."""
     key: str

src/backend/models/orm/task.py

@@ -65,6 +65,9 @@ class RecipeTask(Base):
     # Cartella immutabile (relativa a upload_path) con recipe.json e i file di
     # meta della ricetta VisionSuite v2 (#46).
     vision_recipe_dir: Mapped[Optional[str]] = mapped_column(String(500), nullable=True)
+    # #97: camera e modo di analisi del task, {camera_url, camera_source, modo};
+    # NULL = camera della stazione corrente, analisi impulsiva.
+    acquisition_json: Mapped[Optional[dict]] = mapped_column(JSON, nullable=True)
     # #53: il task fa parte del ciclo di produzione (default dal tipo: misure e
     # check si', gli altri no; un task 'note' si puo' mettere nel ciclo a mano).
     in_loop: Mapped[bool] = mapped_column(

src/backend/services/recipe_service.py

@@ -117,6 +117,8 @@ async def _copy_tasks_to_version(
             vision_json=task.vision_json,
             # Cartella immutabile: basta il riferimento (#46).
             vision_recipe_dir=task.vision_recipe_dir,
+            # #97: camera e modo di analisi seguono il task nella nuova versione.
+            acquisition_json=task.acquisition_json,
             # #53 #55: ciclo, chiusura e campi extra seguono il task nella nuova versione.
             in_loop=task.in_loop,
             at_close=task.at_close,

src/backend/services/vision_service.py

@@ -224,6 +224,25 @@ async def dxf_compare_recipe(
     return body
 
 
+async def dxf_preview(dxf_bytes: bytes, worker_url: str | None = None) -> dict:
+    """#101: anteprima del DXF (contorni in mm + dimensioni) dal worker. Sostituita dai test."""
+    body = await call_worker_multipart(
+        "/dxf/preview",
+        files={"dxf": ("disegno.dxf", dxf_bytes, "application/octet-stream")},
+        data={},
+        worker_url=worker_url,
+    )
+    # forma minima del contratto: senza contorni e dimensioni non c'e' nulla da mostrare
+    required = {"contorni", "bbox", "larghezza_mm", "altezza_mm", "entita", "punti"}
+    if not required <= body.keys():
+        raise HTTPException(
+            status_code=status.HTTP_502_BAD_GATEWAY,
+            detail="the vision worker's answer was malformed: missing "
+                   + ", ".join(sorted(required - body.keys())),
+        )
+    return body
+
+
 # Stati di fetch_station_calibration (#83)
 CAL_OK = "ok"
 CAL_NO_CAMERA = "no_camera"            # la stazione non ha camera_url/camera_source
@@ -231,35 +250,36 @@ CAL_NOT_CALIBRATED = "not_calibrated"  # l'acquisitore risponde 404 (o un valore
 CAL_UNREACHABLE = "unreachable"        # l'acquisitore non risponde
 
 
-async def fetch_station_calibration(station: Station | None) -> tuple[dict | None, str]:
-    """Legge la calibrazione dall'acquisitore della stazione (C1, #83).
+async def fetch_calibration(
+    camera_url: str | None, camera_source: str | None, label: str = "",
+) -> tuple[dict | None, str]:
+    """Legge la calibrazione da un acquisitore (C1, #83; generalizzata in #97).
 
     GET {camera_url}/camera/calibration?source={camera_source}. La calibrazione
     vive nell'acquisitore: TMF la legge, non la tiene. Ritorna (dict, "ok")
     oppure (None, motivo) per distinguere «non calibrata» da «irraggiungibile».
-    Un px_per_mm non finito o <= 0 conta come non calibrata.
+    Un px_per_mm non finito o <= 0 conta come non calibrata. `label` serve
+    solo ai log (stazione o task).
     """
-    if station is None or not station.camera_url or not station.camera_source:
+    if not camera_url or not camera_source:
         return None, CAL_NO_CAMERA
-    url = f"{station.camera_url.rstrip('/')}/camera/calibration"
+    url = f"{camera_url.rstrip('/')}/camera/calibration"
     try:
         # timeout breve: e' una lettura di servizio, non deve bloccare l'execute
         async with httpx.AsyncClient(timeout=5.0) as client:
-            response = await client.get(url, params={"source": station.camera_source})
+            response = await client.get(url, params={"source": camera_source})
     except httpx.HTTPError as exc:
-        logger.warning("acquisitore della stazione %s non raggiungibile: %s", station.code, exc)
+        logger.warning("acquisitore %s non raggiungibile: %s", label, exc)
         return None, CAL_UNREACHABLE
     if response.status_code == status.HTTP_404_NOT_FOUND:
         return None, CAL_NOT_CALIBRATED
     if response.status_code != 200:
-        logger.warning(
-            "acquisitore della stazione %s: HTTP %s", station.code, response.status_code,
-        )
+        logger.warning("acquisitore %s: HTTP %s", label, response.status_code)
         return None, CAL_UNREACHABLE
     try:
         body = response.json()
     except ValueError:
-        logger.warning("acquisitore della stazione %s: risposta non JSON", station.code)
+        logger.warning("acquisitore %s: risposta non JSON", label)
         return None, CAL_UNREACHABLE
     px_per_mm = body.get("px_per_mm") if isinstance(body, dict) else None
     if not (_is_measurable(px_per_mm) and px_per_mm > 0):
@@ -267,6 +287,33 @@ async def fetch_station_calibration(station: Station | None) -> tuple[dict | Non
     return body, CAL_OK
 
 
+async def fetch_station_calibration(station: Station | None) -> tuple[dict | None, str]:
+    """Calibrazione dall'acquisitore della stazione (C1, #83): vedi fetch_calibration."""
+    if station is None:
+        return None, CAL_NO_CAMERA
+    return await fetch_calibration(
+        station.camera_url, station.camera_source, f"della stazione {station.code}",
+    )
+
+
+def task_camera(task: RecipeTask, station: Station | None) -> tuple[str | None, str | None]:
+    """Camera di un task (#97): acquisition_json, altrimenti quella della stazione."""
+    acquisition = task.acquisition_json
+    if isinstance(acquisition, dict) and acquisition.get("camera_url") and acquisition.get("camera_source"):
+        return acquisition["camera_url"], acquisition["camera_source"]
+    if station is not None:
+        return station.camera_url, station.camera_source
+    return None, None
+
+
+async def fetch_task_calibration(
+    task: RecipeTask, station: Station | None,
+) -> tuple[dict | None, str]:
+    """Calibrazione della camera del task (#97), stessi esiti CAL_* di fetch_calibration."""
+    camera_url, camera_source = task_camera(task, station)
+    return await fetch_calibration(camera_url, camera_source, f"del task {task.id}")
+
+
 async def get_station_calibration(station: Station | None) -> dict | None:
     """La calibrazione C1 della stazione, o None in ogni altro caso (#83)."""
     calibration, _ = await fetch_station_calibration(station)
@@ -438,6 +485,84 @@ def list_recipe_files(recipe_dir: str | None) -> list[str]:
     )
 
 
+# #105: nomi e id della ricetta costruita da «Crea ricetta da DXF» (src/vision/costruttori.py).
+_WIZARD_DXF_FILE = "disegno.dxf"
+_WIZARD_CALIBRATION_FILE = "calibrazione.json"
+_WIZARD_REFERENCE_STEM = "riferimento"
+
+
+def _is_real_number(value: object) -> bool:
+    return isinstance(value, (int, float)) and not isinstance(value, bool) and math.isfinite(value)
+
+
+def dxf_compare_source(graph: dict | None, recipe_dir: str | None) -> dict | None:
+    """#105: i parametri con cui il wizard ha costruito la ricetta, per riaprirlo.
+
+    Legge i valori dal grafo (tool `pezzo` LocateBlob, tool `dxf` CompareDxf) e i
+    file dalla cartella ricetta. None se il grafo non e' uno del wizard (il task
+    non ha ricetta, o l'ha caricata a mano): la rotta risponde 404. Pura: niente DB.
+    """
+    if not isinstance(graph, dict) or not isinstance(graph.get("tools"), list):
+        return None
+    tools = {t.get("id"): t for t in graph["tools"] if isinstance(t, dict)}
+    pezzo, confronto = tools.get("pezzo"), tools.get("dxf")
+    if not pezzo or pezzo.get("kind") != "LocateBlob":
+        return None
+    if not confronto or confronto.get("kind") != "CompareDxf":
+        return None
+    p_values = pezzo.get("values") if isinstance(pezzo.get("values"), dict) else {}
+    c_values = confronto.get("values") if isinstance(confronto.get("values"), dict) else {}
+    band, min_pct = c_values.get("band_plus"), c_values.get("points_in_pct_nominal")
+    if not (_is_real_number(band) and _is_real_number(min_pct)):
+        return None
+    polarity = p_values.get("polarity")
+    if polarity not in ("dark", "light"):
+        polarity = "dark"  # default di LocateBlob e della rotta di creazione
+
+    folder = None
+    if recipe_dir:
+        try:
+            folder = _safe_join(settings.upload_path, recipe_dir)
+        except (ValueError, OSError):
+            folder = None
+    if folder is not None and not folder.is_dir():
+        folder = None
+
+    px_per_mm = None
+    dxf_name = None
+    image_name = None
+    if folder is not None:
+        try:
+            cal = json.loads((folder / _WIZARD_CALIBRATION_FILE).read_text(encoding="utf-8"))
+            value = cal.get("px_per_mm") if isinstance(cal, dict) else None
+            if _is_real_number(value) and value > 0:
+                px_per_mm = float(value)
+        except (OSError, ValueError):
+            px_per_mm = None  # manca o illeggibile: il wizard chiedera' la scala
+        if (folder / _WIZARD_DXF_FILE).is_file():
+            dxf_name = _WIZARD_DXF_FILE
+        for candidate in sorted(folder.glob(f"{_WIZARD_REFERENCE_STEM}.*")):
+            if candidate.is_file():
+                image_name = candidate.name
+                break
+    return {
+        "band_mm": float(band), "min_points_pct": float(min_pct), "polarity": polarity,
+        "px_per_mm": px_per_mm, "dxf": dxf_name, "image": image_name,
+    }
+
+
+def recipe_file_path(recipe_dir: str | None, relative: str) -> Path | None:
+    """#105: percorso di un file della cartella ricetta, o None se non sicuro o assente."""
+    if not recipe_dir:
+        return None
+    try:
+        folder = _safe_join(settings.upload_path, recipe_dir)
+        target = _safe_join(folder, relative)
+    except (ValueError, OSError):
+        return None
+    return target if target.is_file() else None
+
+
 def save_result_files(
     task_id: int, image_bytes: bytes, overlay: list, image_ext: str = "png",
 ) -> tuple[str, str]:
@@ -498,14 +623,15 @@ async def execute_task(
         )
     # Worker della stazione della sessione di produzione (#45); senza run o senza URL: centrale
     station_url = None
-    # Calibrazione letta dall'acquisitore della stazione (#83); None = non c'e'
-    calibration = None
+    # Calibrazione letta dall'acquisitore (#83); None = non c'e'. #97: la camera e'
+    # quella del task se la ricetta ne sceglie una, altrimenti quella della stazione.
+    station = None
     if run is not None:
         station = (await db.execute(
             select(Station).where(Station.id == run.station_id)
         )).scalar_one_or_none()
         station_url = (station.vision_worker_url or None) if station is not None else None
-        calibration = await get_station_calibration(station)
+    calibration, _ = await fetch_task_calibration(task, station)
 
     if not task.vision_json:
         raise HTTPException(
@@ -623,6 +749,85 @@ async def execute_task(
     return result, saved, report
 
 
+async def check_task(
+    db: AsyncSession,
+    task: RecipeTask,
+    image_bytes: bytes,
+    *,
+    production_run_id: int | None = None,
+) -> dict:
+    """Esegue il grafo come execute_task ma NON salva nulla (#97).
+
+    Anteprima per l'operatore (ingresso nel task, ciclo «in linea»): niente
+    VisionResult, niente file, niente misure. L'esito per quota usa
+    calculate_pass_fail sulle quote con vision_output, nell'ordine di
+    marker_number come execute. Le quote che il grafo non produce (pezzo non
+    ancora in posizione) restano fuori da `measurements` e il perche' sta in
+    `failures`: un'anteprima non deve dare 422 a ogni frame.
+    """
+    if task.task_type not in VISION_TASK_TYPES:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
+            detail=f"task type {task.task_type!r} is not a camera measurement",
+        )
+    station = None
+    station_url = None
+    if production_run_id is not None:
+        # stesse regole di execute: 404 / 422 / 409 sulla sessione di produzione
+        run = await measurement_service.validate_run_for_version(
+            db, production_run_id, task.version_id,
+        )
+        station = (await db.execute(
+            select(Station).where(Station.id == run.station_id)
+        )).scalar_one_or_none()
+        station_url = (station.vision_worker_url or None) if station is not None else None
+    if not task.vision_json:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
+            detail="this task carries no vision graph",
+        )
+    quotes = (await db.execute(
+        select(RecipeSubtask)
+        .where(RecipeSubtask.task_id == task.id)
+        .where(RecipeSubtask.vision_output.is_not(None))
+        .order_by(RecipeSubtask.marker_number)
+    )).scalars().all()
+    if not quotes:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
+            detail="no quote on this task names a vision output",
+        )
+
+    # stessa calibrazione di execute: camera del task, altrimenti della stazione
+    calibration, cal_reason = await fetch_task_calibration(task, station)
+    worker_kwargs: dict = {}
+    if calibration is not None:
+        worker_kwargs["calibration"] = {"px_per_mm": float(calibration["px_per_mm"])}
+    report = await _call_worker(
+        image_bytes, task.vision_json, recipe_dir=task.vision_recipe_dir,
+        worker_url=station_url,
+        **worker_kwargs,
+    )
+    outputs = report["outputs"]
+    measurements = [
+        {
+            "subtask_id": q.id,
+            "value": float(outputs[q.vision_output]),
+            "pass_fail": measurement_service.calculate_pass_fail(
+                float(outputs[q.vision_output]), q,
+            )[0],
+        }
+        for q in quotes if _is_measurable(outputs.get(q.vision_output))
+    ]
+    return {
+        "outcome": report.get("outcome"),
+        "overlay": report.get("overlay") or [],
+        "failures": report.get("failures") or [],
+        "measurements": measurements,
+        "calibration": cal_reason,
+    }
+
+
 def _reference_file_path(reference: VisionReferenceImage) -> Path:
     return settings.upload_path / reference.path
 
@@ -753,9 +958,29 @@ async def ensure_points_quote(
     Una sola volta: se esiste gia' una quota con `vision_output`, non si tocca.
     Se la versione ha gia' misure non si scrive (il copy-on-write sta nel router
     dei task, qui non si aggira): ritorna False. Ritorna True se l'ha creata.
+    #105: unica eccezione, la quota nata da qui (`dxf.points_in_pct`, «Punti in
+    tolleranza») senza misure segue la soglia nuova: ltl = min_points_pct, e
+    ritorna True anche in quel caso.
     """
     from src.backend.services import recipe_service  # import locale: evita cicli
 
+    # #105: ricetta ripresa e salvata con un'altra soglia -> la quota la segue
+    own = (await db.execute(
+        select(RecipeSubtask)
+        .where(RecipeSubtask.task_id == task.id)
+        .where(RecipeSubtask.vision_output == "dxf.points_in_pct")
+        .where(RecipeSubtask.description == "Punti in tolleranza")
+        .limit(1)
+    )).scalar_one_or_none()
+    if own is not None:
+        # soglia invariata o versione con misure: la quota resta com'e'
+        same = own.ltl is not None and float(own.ltl) == float(min_points_pct)
+        if same or await recipe_service.version_has_measurements(db, task.version_id):
+            return False
+        own.ltl = min_points_pct
+        await db.flush()
+        return True
+
     existing = (await db.execute(
         select(RecipeSubtask.id)
         .where(RecipeSubtask.task_id == task.id)

src/backend/tests/test_migrations.py

@@ -341,3 +341,22 @@ class TestStationCameraMigration:
         assert "vision_worker_url" in cols("stations")  # la 019 resta
         command.upgrade(cfg, "head")  # e di nuovo su
         assert {"camera_url", "camera_source"} <= cols("stations")
+
+
+class TestTaskAcquisitionMigration:
+    """021_task_acquisition: recipe_tasks.acquisition_json, su e giu (#97)."""
+
+    def test_021_upgrade_and_downgrade(self, sqlite_database_url):
+        db_path, _ = sqlite_database_url
+        cfg = _alembic_config()
+
+        def cols(table):
+            return {c["name"] for c in _inspect(db_path).get_columns(table)}
+
+        command.upgrade(cfg, "head")
+        assert "acquisition_json" in cols("recipe_tasks")
+        command.downgrade(cfg, "020_station_camera")
+        assert "acquisition_json" not in cols("recipe_tasks")
+        assert "camera_url" in cols("stations")  # la 020 resta
+        command.upgrade(cfg, "head")  # e di nuovo su
+        assert "acquisition_json" in cols("recipe_tasks")

src/backend/tests/test_task_acquisition.py

@@ -0,0 +1,308 @@
+"""#97: camera e modo di analisi nel task, POST /api/vision/check senza salvataggio.
+
+Il worker e l'acquisitore non girano nei test: si fingono (fixture di
+test_vision_dxf_compare e test_vision_station_worker).
+"""
+import pytest
+from sqlalchemy import func, select
+
+from src.backend.config import settings
+from src.backend.models.orm.measurement import Measurement
+from src.backend.models.orm.task import RecipeSubtask, RecipeTask
+from src.backend.models.orm.vision import VisionResult
+from src.backend.tests.conftest import auth_headers, create_test_recipe
+from src.backend.tests.test_vision_copy_on_write import (
+    _current_task_and_subtask, _seed_measurement,
+)
+from src.backend.tests.test_vision_dxf_compare import (  # noqa: F401 (fixture acquisitore)
+    CAL, CAMERA_URL, acquisitore, redirect_uploads,
+)
+from src.backend.tests.test_vision_execute import an_image
+from src.backend.tests.test_vision_station_worker import (  # noqa: F401 (fixture worker_calls)
+    _camera_task, _execute, _station_with_run, worker_calls,
+)
+
+TASK_CAMERA = "http://10.0.0.50:8300"
+ACQ = {"camera_url": TASK_CAMERA, "camera_source": "camera:601020", "modo": "in_linea"}
+
+
+async def _task_with_acquisition(db_session, user_id, acquisition=ACQ):
+    recipe, task = await _camera_task(db_session, user_id)
+    task.acquisition_json = acquisition
+    await db_session.commit()
+    return recipe, task
+
+
+# --- modello e API del task ---------------------------------------------------
+
+@pytest.mark.asyncio
+async def test_create_task_stores_and_normalizes_acquisition(client, db_session, maker_user):
+    recipe = await create_test_recipe(db_session, maker_user.id)
+    resp = await client.post(
+        f"/api/recipes/{recipe.id}/tasks",
+        headers=auth_headers(maker_user),
+        json={
+            "title": "Camera", "task_type": "camera_measure",
+            "acquisition_json": {"camera_url": " http://h:1/ ", "camera_source": " camera:1 "},
+        },
+    )
+    assert resp.status_code == 201, resp.text
+    body = resp.json()
+    # url normalizzato come nelle stazioni, sorgente senza spazi, modo di default
+    expected = {"camera_url": "http://h:1", "camera_source": "camera:1", "modo": "impulsiva"}
+    assert body["acquisition_json"] == expected
+    db_session.expunge_all()
+    task = (await db_session.execute(
+        select(RecipeTask).where(RecipeTask.id == body["id"])
+    )).scalar_one()
+    assert task.acquisition_json == expected  # sul DB, non solo nella risposta
+    got = await client.get(f"/api/tasks/{body['id']}", headers=auth_headers(maker_user))
+    assert got.json()["acquisition_json"] == expected
+
+
+@pytest.mark.asyncio
+async def test_task_without_acquisition_is_null(client, db_session, maker_user):
+    recipe = await create_test_recipe(db_session, maker_user.id)
+    resp = await client.get(f"/api/recipes/{recipe.id}/tasks", headers=auth_headers(maker_user))
+    assert resp.json()[0]["acquisition_json"] is None
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("bad", [
+    {"camera_url": "ftp://h", "camera_source": "camera:1"},
+    {"camera_url": "  ", "camera_source": "camera:1"},
+    {"camera_url": "http://h", "camera_source": "   "},
+    {"camera_url": "http://h", "camera_source": "x" * 201},
+    {"camera_url": "http://h", "camera_source": "camera:1", "modo": "continua"},
+    {"camera_source": "camera:1"},
+])
+async def test_invalid_acquisition_is_422(client, db_session, maker_user, bad):
+    recipe = await create_test_recipe(db_session, maker_user.id)
+    resp = await client.post(
+        f"/api/recipes/{recipe.id}/tasks",
+        headers=auth_headers(maker_user),
+        json={"title": "Camera", "task_type": "camera_measure", "acquisition_json": bad},
+    )
+    assert resp.status_code == 422, resp.text
+
+
+@pytest.mark.asyncio
+async def test_update_sets_and_clears_acquisition(client, db_session, maker_user):
+    recipe = await create_test_recipe(db_session, maker_user.id)
+    _, task, _ = await _current_task_and_subtask(db_session, recipe.id)
+    resp = await client.put(
+        f"/api/tasks/{task.id}", headers=auth_headers(maker_user), json={"acquisition_json": ACQ},
+    )
+    assert resp.status_code == 200, resp.text
+    assert resp.json()["acquisition_json"] == ACQ
+    resp = await client.put(
+        f"/api/tasks/{task.id}", headers=auth_headers(maker_user), json={"acquisition_json": None},
+    )
+    assert resp.status_code == 200
+    assert resp.json()["acquisition_json"] is None  # null = camera della stazione
+
+
+@pytest.mark.asyncio
+async def test_copy_on_write_preserves_acquisition(client, db_session, maker_user):
+    recipe = await create_test_recipe(db_session, maker_user.id)
+    _, task, _ = await _current_task_and_subtask(db_session, recipe.id)
+    task.acquisition_json = ACQ
+    await db_session.flush()
+    await _seed_measurement(db_session, recipe.id, maker_user.id)
+    db_session.expunge_all()
+
+    resp = await client.put(
+        f"/api/recipes/{recipe.id}", headers=auth_headers(maker_user),
+        json={"change_notes": "forza il copy-on-write"},
+    )
+    assert resp.status_code == 200
+    db_session.expunge_all()
+    version, new_task, _ = await _current_task_and_subtask(db_session, recipe.id)
+    assert version.version_number == 2
+    assert new_task.acquisition_json == ACQ
+
+
+# --- calibrazione dalla camera del task ----------------------------------------
+
+@pytest.mark.asyncio
+async def test_execute_reads_calibration_from_the_task_camera(
+    client, db_session, measurement_tec_user, worker_calls, acquisitore,
+):
+    recipe, task = await _task_with_acquisition(db_session, measurement_tec_user.id)
+    # stazione con camera propria: la camera del task prevale
+    station, run = await _station_with_run(db_session, measurement_tec_user, recipe, None)
+    station.camera_url, station.camera_source = CAMERA_URL, "camera:A1"
+    await db_session.commit()
+    await _execute(client, measurement_tec_user, task, run)
+    assert acquisitore["urls"] == [(f"{TASK_CAMERA}/camera/calibration", {"source": "camera:601020"})]
+    assert worker_calls[0]["calibration"] == {"px_per_mm": CAL["px_per_mm"]}
+    result = (await db_session.execute(select(VisionResult))).scalars().one()
+    assert result.calibration_snapshot["px_per_mm"] == CAL["px_per_mm"]
+
+
+@pytest.mark.asyncio
+async def test_execute_task_camera_works_without_a_run(
+    client, db_session, measurement_tec_user, worker_calls, acquisitore,
+):
+    _, task = await _task_with_acquisition(db_session, measurement_tec_user.id)
+    await _execute(client, measurement_tec_user, task)  # niente sessione di produzione
+    assert acquisitore["urls"][0][0] == f"{TASK_CAMERA}/camera/calibration"
+    assert "calibration" in worker_calls[0]
+
+
+@pytest.mark.asyncio
+async def test_execute_falls_back_to_the_station_camera(
+    client, db_session, measurement_tec_user, worker_calls, acquisitore,
+):
+    recipe, task = await _camera_task(db_session, measurement_tec_user.id)  # acquisition_json null
+    station, run = await _station_with_run(db_session, measurement_tec_user, recipe, None)
+    station.camera_url, station.camera_source = CAMERA_URL, "camera:A1"
+    await db_session.commit()
+    await _execute(client, measurement_tec_user, task, run)
+    assert acquisitore["urls"] == [(f"{CAMERA_URL}/camera/calibration", {"source": "camera:A1"})]
+    assert worker_calls[0]["calibration"] == {"px_per_mm": CAL["px_per_mm"]}
+
+
+# --- POST /api/vision/check ----------------------------------------------------
+
+async def _check(client, user, task, run=None):
+    data = {"task_id": str(task.id)}
+    if run is not None:
+        data["production_run_id"] = str(run.id)
+    return await client.post(
+        "/api/vision/check", headers=auth_headers(user),
+        files={"image": ("p.png", an_image(), "image/png")}, data=data,
+    )
+
+
+async def _counts(db_session):
+    return tuple([
+        (await db_session.execute(select(func.count()).select_from(model))).scalar_one()
+        for model in (Measurement, VisionResult)
+    ])
+
+
+@pytest.mark.asyncio
+async def test_check_saves_nothing_and_reports_pass_fail(
+    client, db_session, measurement_tec_user, monkeypatch, acquisitore,
+):
+    _, task = await _task_with_acquisition(db_session, measurement_tec_user.id)
+    seen = {}
+
+    async def fake_call(image_bytes, graph, **kwargs):
+        seen.update(kwargs)
+        return {"outputs": {"t1.diameter": 11.0}, "failures": [{"tool_name": "t"}],
+                "overlay": [{"kind": "line"}], "outcome": "fail",
+                "engine_version": "e" * 40, "duration_ms": 3}
+
+    monkeypatch.setattr("src.backend.services.vision_service._call_worker", fake_call)
+    before = await _counts(db_session)
+
+    resp = await _check(client, measurement_tec_user, task)
+
+    assert resp.status_code == 200, resp.text
+    body = resp.json()
+    quote = (await db_session.execute(
+        select(RecipeSubtask).where(RecipeSubtask.task_id == task.id)
+    )).scalars().one()
+    assert body == {
+        "outcome": "fail", "overlay": [{"kind": "line"}], "failures": [{"tool_name": "t"}],
+        "measurements": [{"subtask_id": quote.id, "value": 11.0, "pass_fail": "fail"}],
+        "calibration": "ok",
+    }
+    assert seen["calibration"] == {"px_per_mm": CAL["px_per_mm"]}  # stessa calibrazione di execute
+    assert await _counts(db_session) == before  # niente misure ne' VisionResult
+    assert not list(settings.upload_path.rglob("*.overlay.json"))  # ne' file
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("value,expected", [(10.0, "pass"), (10.4, "warning"), (9.0, "fail")])
+async def test_check_pass_fail_levels(
+    client, db_session, measurement_tec_user, monkeypatch, value, expected,
+):
+    _, task = await _camera_task(db_session, measurement_tec_user.id)
+
+    async def fake_call(image_bytes, graph, **kwargs):
+        return {"outputs": {"t1.diameter": value}, "failures": [], "engine_version": "e" * 40}
+
+    monkeypatch.setattr("src.backend.services.vision_service._call_worker", fake_call)
+    resp = await _check(client, measurement_tec_user, task)
+    assert resp.json()["measurements"][0]["pass_fail"] == expected
+    assert resp.json()["calibration"] == "no_camera"  # senza camera ne' stazione
+
+
+@pytest.mark.asyncio
+async def test_check_calibration_reasons(
+    client, db_session, measurement_tec_user, worker_calls, acquisitore,
+):
+    _, task = await _task_with_acquisition(db_session, measurement_tec_user.id)
+    acquisitore["cal"] = None
+    assert (await _check(client, measurement_tec_user, task)).json()["calibration"] == "not_calibrated"
+    acquisitore["cal"] = "down"
+    assert (await _check(client, measurement_tec_user, task)).json()["calibration"] == "unreachable"
+    assert "calibration" not in worker_calls[-1]  # senza calibrazione la ricetta usa la sua
+
+
+@pytest.mark.asyncio
+async def test_check_omits_quotes_the_graph_did_not_produce(
+    client, db_session, measurement_tec_user, monkeypatch,
+):
+    _, task = await _camera_task(db_session, measurement_tec_user.id)
+
+    async def fake_call(image_bytes, graph, **kwargs):
+        return {"outputs": {}, "failures": [{"tool_name": "blob"}], "engine_version": "e" * 40}
+
+    monkeypatch.setattr("src.backend.services.vision_service._call_worker", fake_call)
+    resp = await _check(client, measurement_tec_user, task)
+    assert resp.status_code == 200  # un'anteprima non da' 422 a ogni frame
+    assert resp.json()["measurements"] == []
+    assert resp.json()["failures"] == [{"tool_name": "blob"}]
+
+
+@pytest.mark.asyncio
+async def test_check_422_without_graph_or_quotes_or_vision_type(
+    client, db_session, measurement_tec_user, worker_calls,
+):
+    _, task = await _camera_task(db_session, measurement_tec_user.id)
+    task.vision_json = None
+    await db_session.commit()
+    assert (await _check(client, measurement_tec_user, task)).status_code == 422
+
+    task.vision_json = {"schema_version": 1, "name": "p", "tools": []}
+    quote = (await db_session.execute(
+        select(RecipeSubtask).where(RecipeSubtask.task_id == task.id)
+    )).scalars().one()
+    quote.vision_output = None
+    await db_session.commit()
+    assert (await _check(client, measurement_tec_user, task)).status_code == 422
+
+    task.task_type = "measure"
+    await db_session.commit()
+    assert (await _check(client, measurement_tec_user, task)).status_code == 422
+
+
+@pytest.mark.asyncio
+async def test_check_with_run_uses_station_worker_and_station_camera(
+    client, db_session, measurement_tec_user, worker_calls, acquisitore,
+):
+    recipe, task = await _camera_task(db_session, measurement_tec_user.id)
+    station, run = await _station_with_run(
+        db_session, measurement_tec_user, recipe, "http://10.0.0.7:8100")
+    station.camera_url, station.camera_source = CAMERA_URL, "camera:A1"
+    await db_session.commit()
+    before = await _counts(db_session)
+    resp = await _check(client, measurement_tec_user, task, run)
+    assert resp.status_code == 200, resp.text
+    assert worker_calls[0]["worker_url"] == "http://10.0.0.7:8100"
+    assert acquisitore["urls"][0][0] == f"{CAMERA_URL}/camera/calibration"
+    assert await _counts(db_session) == before
+
+
+@pytest.mark.asyncio
+async def test_check_requires_login(client, db_session, measurement_tec_user, worker_calls):
+    _, task = await _camera_task(db_session, measurement_tec_user.id)
+    resp = await client.post(
+        "/api/vision/check", files={"image": ("p.png", an_image(), "image/png")},
+        data={"task_id": str(task.id)},
+    )
+    assert resp.status_code in (401, 403)

src/backend/tests/test_vision_bmp.py

@@ -0,0 +1,109 @@
+"""#99: the vision routes accept BMP (the Opto bench cameras save it); TIFF and
+non-images stay refused. files.py (attachments) is not touched by this."""
+import io
+
+import pytest
+from PIL import Image
+from sqlalchemy import select
+
+from src.backend.config import settings
+from src.backend.models.orm.vision import VisionReferenceImage
+from src.backend.tests.conftest import auth_headers, create_test_recipe
+from src.backend.tests.test_vision_upload_limits import (  # noqa: F401 - fixtures
+    recipe_parts, redirect_uploads, worker_says,
+)
+
+
+def a_bmp() -> bytes:
+    buffer = io.BytesIO()
+    Image.new("L", (64, 64), color=0).save(buffer, format="BMP")
+    return buffer.getvalue()
+
+
+def a_tiff() -> bytes:
+    buffer = io.BytesIO()
+    Image.new("L", (64, 64), color=0).save(buffer, format="TIFF")
+    return buffer.getvalue()
+
+
+async def a_camera_task(db_session, user):
+    recipe = await create_test_recipe(db_session, user.id)
+    _, task, _ = await recipe_parts(db_session, recipe.id)
+    task.task_type = "camera_measure"
+    task.vision_json = {"schema_version": 1, "name": "p", "tools": []}
+    await db_session.commit()
+    return task
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("content_type", ["image/bmp", "image/x-ms-bmp"])
+async def test_preview_accepts_a_bmp(
+    client, db_session, maker_user, worker_says, content_type,
+):
+    task = await a_camera_task(db_session, maker_user)
+    worker_says({"t1.diameter": 10.0})
+
+    response = await client.post(
+        "/api/vision/preview",
+        headers=auth_headers(maker_user),
+        files={"image": ("p.bmp", a_bmp(), content_type)},
+        data={"task_id": str(task.id)},
+    )
+
+    assert response.status_code != 400, response.text
+    assert response.status_code != 422, response.text
+
+
+@pytest.mark.asyncio
+async def test_preview_still_rejects_a_tiff(
+    client, db_session, maker_user, worker_says,
+):
+    task = await a_camera_task(db_session, maker_user)
+    worker_says({"t1.diameter": 10.0})
+
+    response = await client.post(
+        "/api/vision/preview",
+        headers=auth_headers(maker_user),
+        files={"image": ("p.tif", a_tiff(), "image/tiff")},
+        data={"task_id": str(task.id)},
+    )
+
+    assert response.status_code == 400
+
+
+@pytest.mark.asyncio
+async def test_a_text_file_declared_bmp_is_refused_on_its_bytes(
+    client, db_session, maker_user, worker_says,
+):
+    task = await a_camera_task(db_session, maker_user)
+    worker_says({"t1.diameter": 10.0})
+
+    response = await client.post(
+        "/api/vision/preview",
+        headers=auth_headers(maker_user),
+        files={"image": ("p.bmp", b"i am not an image", "image/bmp")},
+        data={"task_id": str(task.id)},
+    )
+
+    assert response.status_code == 422
+
+
+@pytest.mark.asyncio
+async def test_reference_image_bmp_is_saved_with_the_bmp_extension(
+    client, db_session, maker_user,
+):
+    recipe = await create_test_recipe(db_session, maker_user.id)
+    _, task, _ = await recipe_parts(db_session, recipe.id)
+    await db_session.commit()
+
+    response = await client.post(
+        "/api/vision/reference-images",
+        headers=auth_headers(maker_user),
+        files={"image": ("p.bmp", a_bmp(), "image/x-ms-bmp")},
+        data={"task_id": str(task.id)},
+    )
+
+    assert response.status_code == 200, response.text
+    saved = (await db_session.execute(select(VisionReferenceImage))).scalars().one()
+    assert saved.path.endswith(".bmp")
+    assert (settings.upload_path / saved.path).exists()

src/backend/tests/test_vision_dxf_preview.py

@@ -0,0 +1,90 @@
+"""#101: POST /api/vision/dxf-preview, anteprima del DXF nel wizard.
+
+Il worker non gira nei test: `vision_service.dxf_preview` si sostituisce.
+"""
+import pytest
+from fastapi import HTTPException
+
+from src.backend.config import settings
+from src.backend.services import vision_service
+from src.backend.tests.conftest import auth_headers
+
+BODY = {
+    "contorni": [[[0.0, 0.0], [10.0, 0.0], [10.0, 5.0], [0.0, 5.0], [0.0, 0.0]]],
+    "bbox": {"xmin": 0.0, "ymin": 0.0, "xmax": 10.0, "ymax": 5.0},
+    "larghezza_mm": 10.0, "altezza_mm": 5.0, "entita": 1, "punti": 5,
+}
+
+
+def _post(client, user, content=b"0\nEOF"):
+    return client.post(
+        "/api/vision/dxf-preview",
+        headers=auth_headers(user),
+        files={"dxf": ("d.dxf", content, "application/octet-stream")},
+    )
+
+
+@pytest.mark.asyncio
+async def test_dxf_preview_forwards_the_file_and_returns_the_worker_body(
+    client, maker_user, monkeypatch,
+):
+    calls = []
+
+    async def fake(dxf_bytes, worker_url=None):
+        calls.append(dxf_bytes)
+        return BODY
+
+    monkeypatch.setattr("src.backend.services.vision_service.dxf_preview", fake)
+    resp = await _post(client, maker_user, b"DXF-BYTES")
+    assert resp.status_code == 200, resp.text
+    assert resp.json() == BODY
+    assert calls == [b"DXF-BYTES"]
+
+
+@pytest.mark.asyncio
+async def test_dxf_preview_forwards_the_worker_422(client, maker_user, monkeypatch):
+    async def fake(dxf_bytes, worker_url=None):
+        raise HTTPException(status_code=422, detail="DXF illeggibile: file vuoto")
+
+    monkeypatch.setattr("src.backend.services.vision_service.dxf_preview", fake)
+    resp = await _post(client, maker_user, b"")
+    assert resp.status_code == 422
+    assert resp.json()["detail"] == "DXF illeggibile: file vuoto"
+
+
+@pytest.mark.asyncio
+async def test_dxf_preview_requires_maker(client, measurement_tec_user, monkeypatch):
+    async def fake(dxf_bytes, worker_url=None):
+        return BODY
+
+    monkeypatch.setattr("src.backend.services.vision_service.dxf_preview", fake)
+    resp = await _post(client, measurement_tec_user)
+    assert resp.status_code == 403
+
+
+@pytest.mark.asyncio
+async def test_dxf_preview_too_big_is_422(client, maker_user, monkeypatch):
+    monkeypatch.setattr(settings, "max_upload_size_mb", 0)
+    resp = await _post(client, maker_user, b"x" * 10)
+    assert resp.status_code == 422
+
+
+@pytest.mark.asyncio
+async def test_dxf_preview_service_posts_to_worker_and_checks_shape(monkeypatch):
+    seen = {}
+
+    async def fake_multipart(path, *, files, data, worker_url=None, timeout=120.0):
+        seen.update(path=path, files=files)
+        return BODY
+
+    monkeypatch.setattr(vision_service, "call_worker_multipart", fake_multipart)
+    assert await vision_service.dxf_preview(b"abc") == BODY
+    assert seen["path"] == "/dxf/preview" and seen["files"]["dxf"][1] == b"abc"
+
+    async def malformed(path, *, files, data, worker_url=None, timeout=120.0):
+        return {"contorni": []}
+
+    monkeypatch.setattr(vision_service, "call_worker_multipart", malformed)
+    with pytest.raises(HTTPException) as exc:
+        await vision_service.dxf_preview(b"abc")
+    assert exc.value.status_code == 502

src/backend/tests/test_vision_dxf_source.py

@@ -0,0 +1,226 @@
+"""#105: la ricetta «Crea ricetta da DXF» si puo' riaprire e modificare.
+
+Il worker non gira nei test: si finge come in test_vision_dxf_compare.
+"""
+import base64
+import io
+import json
+
+import pytest
+from PIL import Image
+from sqlalchemy import select
+
+from src.backend.config import settings
+from src.backend.models.orm.task import RecipeSubtask, RecipeTask
+from src.backend.services import vision_service
+from src.backend.tests.conftest import auth_headers
+from src.backend.tests.test_vision_dxf_compare import (  # noqa: F401 (fixture)
+    redirect_uploads, validate_ok,
+)
+from src.backend.tests.test_vision_recipe_upload import an_image, make_task
+
+DXF = b"0\nEOF"
+
+
+def _wizard_graph(band=0.3, pct=90.0, polarity="light") -> dict:
+    """Grafo come lo costruisce src/vision/costruttori.py::_graph."""
+    return {
+        "schema_version": 2, "name": "Confronto DXF",
+        "meta": {"dxf": {"disegno": {"path": "disegno.dxf", "sha256": "x"}},
+                 "calibration": {"path": "calibrazione.json", "sha256": "y"}},
+        "tools": [
+            {"id": "pezzo", "name": "Pezzo", "kind": "LocateBlob",
+             "values": {"polarity": polarity}, "links": {}},
+            {"id": "dxf", "name": "Confronto DXF", "kind": "CompareDxf",
+             "values": {"band_plus": band, "band_minus": band, "points_in_pct_nominal": pct},
+             "links": {}},
+        ],
+    }
+
+
+@pytest.fixture
+def w2(monkeypatch):
+    async def fake(image_bytes, dxf_bytes, **kwargs):
+        graph = _wizard_graph(kwargs["band_mm"], kwargs["min_points_pct"], kwargs["polarity"])
+        return {
+            "graph": graph,
+            "files": {
+                "disegno.dxf": base64.b64encode(dxf_bytes).decode(),
+                "calibrazione.json": base64.b64encode(
+                    json.dumps({"px_per_mm": kwargs["px_per_mm"]}).encode()).decode(),
+            },
+            "outputs": {"dxf.points_in_pct": 99.0}, "overlay": [], "outcome": "pass",
+        }
+    monkeypatch.setattr("src.backend.services.vision_service.dxf_compare_recipe", fake)
+
+
+def _bmp() -> bytes:
+    buf = io.BytesIO()
+    Image.new("L", (32, 32)).save(buf, format="BMP")
+    return buf.getvalue()
+
+
+def _save(client, user, task, *, image=None, ctype="image/png", **data):
+    return client.post(
+        f"/api/vision/tasks/{task.id}/recipe/dxf-compare",
+        headers=auth_headers(user),
+        files={"image": ("p", image if image is not None else an_image(), ctype),
+               "dxf": ("d.dxf", DXF, "application/octet-stream")},
+        data={"save": "true", "px_per_mm": "10", **{k: str(v) for k, v in data.items()}},
+    )
+
+
+@pytest.mark.asyncio
+async def test_save_keeps_the_reference_image_png(client, db_session, maker_user, w2, validate_ok):
+    task, _ = await make_task(db_session, maker_user)
+    image = an_image()
+
+    resp = await _save(client, maker_user, task, image=image)
+
+    assert resp.status_code == 200, resp.text
+    folder = settings.upload_path / resp.json()["recipe_dir"]
+    assert (folder / "riferimento.png").read_bytes() == image
+    assert (folder / "disegno.dxf").read_bytes() == DXF  # il resto della cartella non cambia
+
+
+@pytest.mark.asyncio
+async def test_save_keeps_the_reference_image_bmp(client, db_session, maker_user, w2, validate_ok):
+    task, _ = await make_task(db_session, maker_user)
+    image = _bmp()
+
+    resp = await _save(client, maker_user, task, image=image, ctype="image/bmp")
+
+    assert resp.status_code == 200, resp.text
+    folder = settings.upload_path / resp.json()["recipe_dir"]
+    assert (folder / "riferimento.bmp").read_bytes() == image
+
+
+@pytest.mark.asyncio
+async def test_source_returns_what_the_wizard_saved(client, db_session, maker_user, w2, validate_ok):
+    task, _ = await make_task(db_session, maker_user)
+    await _save(client, maker_user, task, band_mm=0.3, min_points_pct=90, polarity="light")
+
+    resp = await client.get(
+        f"/api/vision/tasks/{task.id}/recipe/dxf-compare/source", headers=auth_headers(maker_user),
+    )
+
+    assert resp.status_code == 200, resp.text
+    assert resp.json() == {
+        "band_mm": 0.3, "min_points_pct": 90.0, "polarity": "light", "px_per_mm": 10.0,
+        "dxf": "disegno.dxf", "image": "riferimento.png",
+    }
+
+
+@pytest.mark.asyncio
+async def test_source_404_without_recipe_or_with_a_hand_made_graph(client, db_session, maker_user):
+    task, _ = await make_task(db_session, maker_user)
+    url = f"/api/vision/tasks/{task.id}/recipe/dxf-compare/source"
+
+    assert (await client.get(url, headers=auth_headers(maker_user))).status_code == 404
+
+    task.vision_json = {"schema_version": 2, "name": "a mano", "tools": [], "meta": {}}
+    await db_session.commit()
+    resp = await client.get(url, headers=auth_headers(maker_user))
+    assert resp.status_code == 404
+    assert resp.json()["detail"] == "nessuna ricetta da DXF su questo task"
+
+
+@pytest.mark.asyncio
+async def test_source_needs_maker(client, db_session, maker_user, measurement_tec_user):
+    task, _ = await make_task(db_session, maker_user)
+    resp = await client.get(
+        f"/api/vision/tasks/{task.id}/recipe/dxf-compare/source",
+        headers=auth_headers(measurement_tec_user),
+    )
+    assert resp.status_code == 403
+
+
+def test_source_of_an_old_recipe_has_no_image_and_no_unreadable_scale(tmp_path, monkeypatch):
+    monkeypatch.setattr(settings, "upload_dir", str(tmp_path))
+    folder = tmp_path / "vision" / "recipes" / "1" / "abc"
+    folder.mkdir(parents=True)
+    (folder / "disegno.dxf").write_bytes(DXF)
+    (folder / "calibrazione.json").write_text("{non json", encoding="utf-8")
+
+    source = vision_service.dxf_compare_source(_wizard_graph(), "vision/recipes/1/abc")
+
+    assert source["image"] is None and source["px_per_mm"] is None
+    assert source["dxf"] == "disegno.dxf"
+    assert vision_service.dxf_compare_source(None, None) is None
+    # senza cartella i valori del grafo restano
+    assert vision_service.dxf_compare_source(_wizard_graph(), None)["dxf"] is None
+
+
+@pytest.mark.asyncio
+async def test_files_returns_the_bytes(client, db_session, maker_user, w2, validate_ok):
+    task, _ = await make_task(db_session, maker_user)
+    image = _bmp()
+    await _save(client, maker_user, task, image=image, ctype="image/bmp")
+
+    img = await client.get(
+        f"/api/vision/tasks/{task.id}/recipe/files/riferimento.bmp", headers=auth_headers(maker_user),
+    )
+    dxf = await client.get(
+        f"/api/vision/tasks/{task.id}/recipe/files/disegno.dxf", headers=auth_headers(maker_user),
+    )
+
+    assert img.status_code == 200 and img.content == image
+    assert img.headers["content-type"].startswith("image/")
+    assert dxf.status_code == 200 and dxf.content == DXF
+    assert dxf.headers["content-type"]  # dal tipo dell'estensione, di ripiego octet-stream
+
+
+@pytest.mark.asyncio
+async def test_files_404_on_unsafe_missing_or_no_recipe(client, db_session, maker_user, w2, validate_ok):
+    task, _ = await make_task(db_session, maker_user)
+    base = f"/api/vision/tasks/{task.id}/recipe/files/"
+    headers = auth_headers(maker_user)
+
+    assert (await client.get(base + "disegno.dxf", headers=headers)).status_code == 404  # nessuna ricetta
+
+    await _save(client, maker_user, task)
+    assert (await client.get(base + "manca.bmp", headers=headers)).status_code == 404
+    for unsafe in ("../x", "%2e%2e/x", "..%2f..%2fx", "sub/../../x"):
+        assert (await client.get(base + unsafe, headers=headers)).status_code == 404, unsafe
+    # la funzione non lascia uscire dalla cartella nemmeno con un assoluto
+    assert vision_service.recipe_file_path("vision/recipes/1/abc", "../x") is None
+    assert vision_service.recipe_file_path("vision/recipes/1/abc", "/etc/passwd") is None
+    assert vision_service.recipe_file_path("../fuori", "x") is None
+
+
+@pytest.mark.asyncio
+async def test_resave_follows_the_new_threshold(client, db_session, maker_user, w2, validate_ok):
+    task, _ = await make_task(db_session, maker_user)
+    task_id = task.id
+    await _save(client, maker_user, task, min_points_pct=95)
+
+    resp = await _save(client, maker_user, task, min_points_pct=80)
+
+    assert resp.status_code == 200, resp.text
+    db_session.expire_all()
+    quotes = (await db_session.execute(
+        select(RecipeSubtask).where(RecipeSubtask.vision_output == "dxf.points_in_pct")
+        .where(RecipeSubtask.task_id == task_id))).scalars().all()
+    assert len(quotes) == 1 and float(quotes[0].ltl) == 80.0
+
+
+@pytest.mark.asyncio
+async def test_ensure_points_quote_leaves_quote_with_measurements(
+    client, db_session, maker_user, w2, validate_ok, monkeypatch,
+):
+    task, _ = await make_task(db_session, maker_user)
+    task_id = task.id
+    await _save(client, maker_user, task, min_points_pct=95)
+
+    async def has_measurements(db, version_id):
+        return True
+    monkeypatch.setattr("src.backend.services.recipe_service.version_has_measurements", has_measurements)
+    task = await db_session.get(RecipeTask, task_id)
+
+    changed = await vision_service.ensure_points_quote(db_session, task, 80)
+
+    assert changed is False
+    quote = (await db_session.execute(
+        select(RecipeSubtask).where(RecipeSubtask.vision_output == "dxf.points_in_pct")
+        .where(RecipeSubtask.task_id == task_id))).scalar_one()
+    assert float(quote.ltl) == 95.0

src/frontend/flask_app/blueprints/maker.py

@@ -5,6 +5,7 @@ import math
 import requests as http_requests
 
 from functools import wraps
+from urllib.parse import quote  # #105: percorso del file ricetta nell'URL del backend
 
 from flask import Blueprint, Response, abort, flash, jsonify, redirect, render_template, request, session, url_for
 from flask_babel import gettext as _
@@ -701,6 +702,65 @@ def api_dxf_compare_recipe(task_id: int):
     return jsonify(resp), 200
 
 
+# #105: parametri della ricetta DXF gia' salvata sul task, per riaprire il wizard compilato
+@maker_bp.route("/api/vision/tasks/<int:task_id>/recipe/dxf-compare/source", methods=["GET"])
+@login_required
+@role_required("Maker")
+def api_dxf_compare_source(task_id: int):
+    """Proxy: parametri e file della ricetta DXF del task (404 se non ce n'e' una) (#105)."""
+    resp = api_client.get(f"/api/vision/tasks/{task_id}/recipe/dxf-compare/source")
+    # Codice e corpo del backend arrivano com'e': il 404 vuol dire «nessuna ricetta da DXF»
+    if resp.get("error"):
+        return jsonify(resp), resp.get("status_code", 500)
+    return jsonify(resp), 200
+
+
+# #105: un file della cartella ricetta (DXF, immagine di riferimento) come byte, non JSON
+@maker_bp.route("/api/vision/tasks/<int:task_id>/recipe/files/<path:path>", methods=["GET"])
+@login_required
+@role_required("Maker")
+def api_vision_recipe_file(task_id: int, path: str):
+    """Proxy: byte di un file della cartella ricetta del task, con content-type del backend (#105)."""
+    # Niente segmenti '..' o backslash: urllib3 normalizzerebbe l'URL fuori da questa rotta del backend
+    if "\\" in path or ".." in path.split("/"):
+        return jsonify({"error": True, "detail": _("File non trovato")}), 404
+    try:
+        resp = http_requests.get(
+            f"{Config.API_SERVER_URL.rstrip('/')}/api/vision/tasks/{task_id}/recipe/files/{quote(path)}",
+            headers={"X-API-Key": session.get("api_key", "")},
+            timeout=30,
+        )
+    except http_requests.RequestException as exc:
+        return jsonify({
+            "error": True,
+            "detail": _("Servizio non raggiungibile: %(detail)s", detail=str(exc)),
+        }), 502
+    return Response(
+        resp.content,
+        status=resp.status_code,
+        content_type=resp.headers.get("content-type", "application/octet-stream"),
+    )
+
+
+# #101: anteprima del DXF appena scelto nel wizard (contorni letti dal vision worker)
+@maker_bp.route("/api/vision/dxf-preview", methods=["POST"])
+@login_required
+@role_required("Maker")
+def api_dxf_preview():
+    """Proxy: anteprima del DXF (contorni, bbox, L x H) prima di creare la ricetta (#101)."""
+    dxf = request.files.get("dxf")
+    if dxf is None or not dxf.filename:
+        return jsonify({"error": True, "detail": _("Serve il file DXF")}), 400
+
+    resp = api_client.post(
+        "/api/vision/dxf-preview",
+        files={"dxf": (dxf.filename, dxf.read(), dxf.mimetype or "application/octet-stream")},
+    )
+    if resp.get("error"):
+        return jsonify(resp), resp.get("status_code", 500)
+    return jsonify(resp), 200
+
+
 @maker_bp.route("/api/files/<path:file_path>", methods=["GET"])
 @login_required
 def api_get_file(file_path: str):

src/frontend/flask_app/blueprints/measure.py

@@ -1,4 +1,5 @@
 """MeasurementTec blueprint - recipe selection and measurement execution."""
+import json
 import urllib.parse
 
 import requests as http_requests
@@ -337,6 +338,14 @@ def task_execute(task_id: int):
             measurement_interval_minutes = recipe_resp.get("measurement_interval_minutes")
             allow_manual_input = bool(recipe_resp.get("allow_manual_input", True))
 
+    # #97: camera del task (acquisition_json) o della stazione; il modo di analisi
+    # (impulsiva / in_linea) viene dal task. Solo i task visione ne hanno bisogno.
+    camera = None
+    camera_mode = "impulsiva"
+    if task_resp.get("task_type") in ("camera_measure", "dxf_compare"):
+        camera = _task_camera(task_resp, _current_station()[0])
+        camera_mode = _task_mode(task_resp)
+
     return render_template(
         "measure/task_execute.html",
         task=task_resp,
@@ -345,7 +354,8 @@ def task_execute(task_id: int):
         all_task_ids=all_task_ids,
         measurement_interval_minutes=measurement_interval_minutes,
         allow_manual_input=allow_manual_input,
-        camera_enabled=_station_camera(_current_station()[0]) is not None,
+        camera_enabled=camera is not None,
+        camera_mode=camera_mode,
     )
 
 
@@ -1001,6 +1011,42 @@ def api_vision_execute():
     return jsonify(resp), 200
 
 
+# #97: analysis of a frame without saving anything (preview before «Registra»).
+@measure_bp.route("/api/vision/check", methods=["POST"])
+@login_required
+@role_required("MeasurementTec")
+def api_vision_check():
+    """Proxy: run the task's VisionSuite recipe on the image, nothing is saved."""
+    image = request.files.get("image")
+    task_id = request.form.get("task_id")
+    if image is None or not task_id:
+        return jsonify({
+            "error": True,
+            "detail": _("Dati mancanti: task_id e image sono obbligatori"),
+        }), 400
+
+    form = {"task_id": task_id}
+    if request.form.get("production_run_id"):
+        form["production_run_id"] = request.form["production_run_id"]
+
+    resp = api_client.post(
+        "/api/vision/check",
+        data=form,
+        files={"image": (
+            image.filename or "capture.jpg",
+            image.read(),
+            image.mimetype or "application/octet-stream",
+        )},
+    )
+    if resp.get("error"):
+        status_code = resp.get("status_code", 500)
+        body = {"error": True, "detail": resp.get("detail", _("Errore nell'esecuzione"))}
+        if resp.get("session_expired"):
+            body["session_expired"] = True
+        return jsonify(body), status_code if status_code >= 400 else 500
+    return jsonify(resp), 200
+
+
 def _station_camera(station_code: str | None) -> tuple[str, str] | None:
     """(camera_url, camera_source) of the station, None when it has no camera.
 
@@ -1019,6 +1065,31 @@ def _station_camera(station_code: str | None) -> tuple[str, str] | None:
     return str(url), str(source)
 
 
+def _task_acquisition(task: dict | None) -> dict | None:
+    """#97: acquisition_json of a task as a dict, None when absent or unreadable."""
+    acq = task.get("acquisition_json") if isinstance(task, dict) else None
+    if isinstance(acq, str):
+        try:
+            acq = json.loads(acq)
+        except ValueError:
+            return None
+    return acq if isinstance(acq, dict) else None
+
+
+def _task_camera(task: dict | None, station_code: str | None) -> tuple[str, str] | None:
+    """#97: camera of a task = its acquisition_json (url + source), else the station's."""
+    acq = _task_acquisition(task)
+    if acq and acq.get("camera_url") and acq.get("camera_source"):
+        return str(acq["camera_url"]), str(acq["camera_source"])
+    return _station_camera(station_code)
+
+
+def _task_mode(task: dict | None) -> str:
+    """#97: analysis mode of a task, «impulsiva» unless acquisition_json says «in_linea»."""
+    acq = _task_acquisition(task)
+    return "in_linea" if acq and acq.get("modo") == "in_linea" else "impulsiva"
+
+
 # #72: the browser asks the station's camera service (vs-gui) for a frame; the
 # service address is a server-side matter, so Flask relays and the PNG goes back as is.
 @measure_bp.route("/api/vision/grab", methods=["POST"])
@@ -1026,7 +1097,16 @@ def _station_camera(station_code: str | None) -> tuple[str, str] | None:
 @role_required("MeasurementTec")
 def api_vision_grab():
     """Proxy: grab one frame from the current station's camera, answer a PNG."""
-    camera = _station_camera(_current_station()[0])
+    # #97: con task_id (form o json) la camera e' quella del task, altrimenti della stazione
+    payload = request.get_json(silent=True) or {}
+    task_id = request.form.get("task_id") or payload.get("task_id")
+    task = None
+    if task_id:
+        try:
+            task = api_client.get(f"/api/tasks/{int(task_id)}")
+        except (TypeError, ValueError):
+            task = None
+    camera = _task_camera(task, _current_station()[0])
     if camera is None:
         return jsonify({
             "error": True,

src/frontend/flask_app/static/js/dxf_recipe_wizard.js

@@ -6,6 +6,7 @@
 function dxfRecipeWizard(taskId, csrf, msgs) {
   // Colori overlay per ruolo, uguali a vision_execute.js (reference, roi, found)
   const ROLE_COLORS = { reference: '#2563eb', found: '#16a34a', roi: '#f59e0b' };
+  const VALUE_UNITS = { 'dxf.points_in_pct': '%', 'dxf.distance_avg': 'mm', 'dxf.distance_min': 'mm', 'dxf.distance_max': 'mm' }; // #104
   const VALUE_KEYS = ['dxf.points_in_pct', 'dxf.distance_avg', 'dxf.distance_min', 'dxf.distance_max'];
 
   return {
@@ -20,7 +21,15 @@ function dxfRecipeWizard(taskId, csrf, msgs) {
     imageFile: null,       // immagine caricata o acquisita
     imageName: '',
     imageSrc: '',
+    imagePx: null,         // #102: {w, h} in pixel, letto dall'<img> dell'anteprima
+    imageBroken: false,    // #102: il browser non sa mostrare il formato (il file resta valido per l'invio)
+    calPxMm: null,         // #102: px/mm della calibrazione della stazione
     dxfFile: null,
+    dxfPreview: null,      // #101: risposta di /dxf-preview {contorni, bbox, larghezza_mm, altezza_mm, entita, punti}
+    dxfPreviewBusy: false,
+    dxfPreviewError: '',
+    _dxfPreviewSeq: 0,     // #101: una risposta arrivata dopo un cambio di file si scarta
+    mmPx: '',              // #98: mm/px a mano (immagine da file), stringa con virgola o punto
     bandMm: 0.1,
     minPointsPct: 95,
     dark: true,            // spuntato = pezzo scuro su fondo chiaro (controluce)
@@ -29,10 +38,112 @@ function dxfRecipeWizard(taskId, csrf, msgs) {
     error: '',
     notice: '',
     result: null,          // corpo B3 {result, saved, recipe_dir, outputs}
+    imageSource: '',       // #104: '' | 'file' | 'camera'; il campo mm/px vale solo per 'file'
+    tested: false,         // #104: true dopo una Prova (anche fallita): mostra la sezione del risultato
+    zoom: 1,               // #104: scala dell'immagine di prova (1 = pixel nativi)
+    fitZoom: 1,            // #104: zoom di Adatta (sotto o pari a questo il viewport segue l'immagine)
+    panning: false,        // #104: trascinamento in corso
+    _pan: null,            // #104: {x, y, left, top} al pointerdown
+    resPx: null,           // #104: {w, h} in pixel dell'immagine di prova (per la dimensione del wrapper)
+    runPxPerMm: null,      // #104: scala usata nell'ultima Prova (null = calibrazione stazione)
+    runBandMm: null,       // #104: banda usata nell'ultima Prova
+    runMinPointsPct: null, // #104: soglia usata nell'ultima Prova
+    existing: null,        // #105: risposta di /source (ricetta DXF gia' salvata sul task); null = nessuna
+    existingInfo: false,   // #105: «Ricetta esistente caricata...» dopo aver compilato il wizard
+    existingWarn: '',      // #105: avviso (immagine non salvata, file illeggibili)
+    dxfFromRecipe: false,  // #105: il DXF viene dalla ricetta (l'<input type=file> non puo' mostrarne il nome)
+    _existingApplied: false, // #105: il wizard e' gia' stato compilato dalla ricetta (non sovrascrivere le modifiche)
+    _existingReady: null,  // #105: promessa della prima lettura di /source
+    _srcSeq: 0,            // #105: una risposta di /source arrivata dopo una lettura piu' recente si scarta
+    _dxfPickSeq: 0,        // #105: sale a ogni scelta manuale del DXF; i file della ricetta arrivati dopo si scartano
+    _imgPickSeq: 0,        // #105: idem per l'immagine (_setImage)
+
+    // #105: all'avvio legge se il task ha gia' una ricetta da DXF (serve per l'etichetta del bottone)
+    init() {
+      if (this.taskId) this._existingReady = this.loadExisting();
+    },
 
     async toggle() {
       this.open = !this.open;
-      if (this.open && !this.stations.length) await this.loadStations();
+      if (this.open) {
+        this.openExisting(); // #105: compila il wizard dalla ricetta esistente, in parallelo alle stazioni
+        if (!this.stations.length) await this.loadStations();
+      }
+    },
+
+    // #105: GET /source -> this.existing (null se 404 o errore)
+    async loadExisting() {
+      const seq = ++this._srcSeq;
+      let found = null;
+      try {
+        const resp = await fetch(`/maker/api/vision/tasks/${this.taskId}/recipe/dxf-compare/source`);
+        if (resp.ok) {
+          const body = await resp.json().catch(() => null);
+          if (body && typeof body === 'object' && !body.error) found = body;
+        }
+      } catch (e) { console.error('dxfRecipeWizard source', e); }
+      if (seq !== this._srcSeq) return; // lettura piu' recente in corso
+      this.existing = found;
+    },
+
+    // #105: all'apertura, una sola volta, riempie il wizard con la ricetta esistente
+    async openExisting() {
+      if (this._existingReady) await this._existingReady;
+      if (!this.existing || this._existingApplied) return;
+      await this.applyExisting();
+    },
+
+    // #105: mm/px da px/mm, fino a 6 cifre significative e virgola decimale; '' se non valido
+    _mmPxFrom(pxPerMm) {
+      const v = Number(pxPerMm);
+      if (!Number.isFinite(v) || v <= 0) return '';
+      return String(Number((1 / v).toPrecision(6))).replace('.', ',');
+    },
+
+    // #105: un file della cartella ricetta -> File; null se assente o illeggibile (in quel caso avvisa)
+    async _fetchRecipeFile(name) {
+      try {
+        const resp = await fetch(`/maker/api/vision/tasks/${this.taskId}/recipe/files/${encodeURIComponent(name)}`);
+        if (!resp.ok) throw new Error('HTTP ' + resp.status);
+        const blob = await resp.blob();
+        return new File([blob], name, { type: blob.type || '' });
+      } catch (e) {
+        console.error('dxfRecipeWizard file', name, e);
+        this.existingWarn = this.msgs.existingFilesFailed || 'Cannot read the recipe files';
+        return null;
+      }
+    },
+
+    // #105: valori salvati nei campi, poi DXF e immagine di riferimento dalla cartella ricetta
+    async applyExisting() {
+      const e = this.existing;
+      if (!e) return;
+      this._existingApplied = true;
+      this.error = '';
+      this.notice = '';
+      this.existingWarn = '';
+      const band = Number(e.band_mm), pct = Number(e.min_points_pct);
+      if (Number.isFinite(band) && band > 0) this.bandMm = band;
+      if (Number.isFinite(pct) && pct > 0) this.minPointsPct = pct;
+      this.dark = e.polarity === 'dark';
+      const mm = this._mmPxFrom(e.px_per_mm);
+      if (mm) this.mmPx = mm; // il campo compare quando l'immagine e' da file
+      this.existingInfo = true;
+      // Sequenze lette prima di scaricare: se l'utente sceglie un file a mano nel frattempo, vince lui
+      const dxfSeq = this._dxfPickSeq, imgSeq = this._imgPickSeq;
+      const [dxf, img] = await Promise.all([
+        e.dxf ? this._fetchRecipeFile(e.dxf) : null,
+        e.image ? this._fetchRecipeFile(e.image) : null,
+      ]);
+      if (dxf && dxfSeq === this._dxfPickSeq) {
+        this.dxfFile = dxf;
+        this.dxfFromRecipe = true;
+        this.result = null;
+        this.tested = false;
+        this.loadDxfPreview();
+      }
+      if (img && imgSeq === this._imgPickSeq) this._setImage(img, 'file'); // 'file': il campo mm/px compare gia' compilato
+      if (!e.image && !this.existingWarn) this.existingWarn = this.msgs.noReferenceImage || 'Reference image not saved';
     },
 
     async loadStations() {
@@ -49,33 +160,144 @@ function dxfRecipeWizard(taskId, csrf, msgs) {
 
     // Cambio stazione: rilegge lo stato di calibrazione dall'acquisitore
     async onStation() {
-      this.calState = ''; this.calLabel = ''; this.calUrl = '';
+      this.calState = ''; this.calLabel = ''; this.calUrl = ''; this.calPxMm = null;
       this.result = null;
+      this.tested = false; // #104
       if (!this.stationId) return;
       const r = await fetchStationCalibration(this.stationId);
       this.calState = r.state || 'unreachable';
       this.calUrl = r.calibration_url || '';
-      if (this.calState === 'calibrated') this.calLabel = formatCalibration(r.calibration || {});
+      if (this.calState === 'calibrated') {
+        this.calLabel = formatCalibration(r.calibration || {});
+        const c = Number((r.calibration || {}).px_per_mm); // #102: scala per il campo in mm dell'anteprima
+        this.calPxMm = Number.isFinite(c) && c > 0 ? c : null;
+      }
     },
 
     get calibrated() { return this.calState === 'calibrated'; },
+    // #98: mm/px inserito a mano -> px/mm; null se vuoto o fuori da 0.00001..100 (limiti di /camera/calibrazioni/manuale, #95)
+    get manualPxMm() {
+      const raw = String(this.mmPx || '').trim().replace(',', '.');
+      if (!raw) return null;
+      const v = Number(raw);
+      if (!Number.isFinite(v) || v < 0.00001 || v > 100) return null;
+      return 1 / v;
+    },
+    // #98: compilato ma non valido -> errore in pagina
+    get mmPxInvalid() { return String(this.mmPx || '').trim() !== '' && this.manualPxMm === null; },
+    // #104: la scala a mano vale solo per un'immagine da file; con la camera vale la calibrazione della stazione
+    get useManualScale() { return this.imageSource === 'file' && this.manualPxMm !== null; },
     get canRun() {
-      return !!(this.stationId && this.calibrated && this.imageFile && this.dxfFile) && !this.busy;
+      // #98: la scala a mano sostituisce la calibrazione della stazione (#104: solo per immagini da file)
+      return !!(this.stationId && (this.calibrated || this.useManualScale) && this.imageFile && this.dxfFile) && !this.busy;
     },
 
-    _setImage(file) {
+    _setImage(file, source) {
       if (this.imageSrc) URL.revokeObjectURL(this.imageSrc);
-      this.imageFile = file;
-      this.imageName = file.name || '';
-      this.imageSrc = URL.createObjectURL(file);
+      // #102: con file null (immagine tolta) si azzera anche l'anteprima
+      this.imageFile = file || null;
+      this.imageName = (file && file.name) || '';
+      this.imageSrc = file ? URL.createObjectURL(file) : '';
+      this.imagePx = null;
+      this.imageBroken = false;
       this.result = null;
+      this.tested = false; // #104
+      this.resPx = null; // #104
+      this.imageSource = file ? (source || '') : ''; // #104
+      this._imgPickSeq++; // #105: una scelta piu' recente batte i file della ricetta ancora in arrivo
+    },
+
+    // #102: l'<img> dell'anteprima e' caricata: legge i pixel; se non si carica il formato non e' mostrabile
+    onImagePreviewLoad(el) {
+      this.imageBroken = false;
+      this.imagePx = el && el.naturalWidth ? { w: el.naturalWidth, h: el.naturalHeight } : null;
+    },
+    onImagePreviewError() {
+      this.imageBroken = !!this.imageSrc;
+      this.imagePx = null;
+    },
+    // #102: nome usato dal template (stesso valore dell'URL gia' usato per l'overlay dei risultati)
+    get imagePreviewUrl() { return this.imageSrc; },
+    // #102: «W × H px · campo ≈ L × H mm»; scala = mm/px a mano se valido, altrimenti calibrazione della stazione
+    get imagePreviewSummary() {
+      const p = this.imagePx;
+      if (!p) return '';
+      const lang = document.documentElement.lang || 'it';
+      const f = (v, d) => Number(v).toLocaleString(lang, { minimumFractionDigits: d, maximumFractionDigits: d });
+      let text = `${f(p.w, 0)} × ${f(p.h, 0)} px`;
+      const pxMm = this.useManualScale ? this.manualPxMm : (this.calibrated ? this.calPxMm : null); // #104
+      if (pxMm) text += ` · ${this.msgs.imageField || 'field'} ≈ ${f(p.w / pxMm, 2)} × ${f(p.h / pxMm, 2)} mm`;
+      return text;
     },
 
     onImage(ev) {
       const f = ev.target.files && ev.target.files[0];
-      if (f) this._setImage(f);
+      if (f) this._setImage(f, 'file'); // #104
+    },
+    onDxf(ev) {
+      this.dxfFile = (ev.target.files && ev.target.files[0]) || null;
+      this._dxfPickSeq++; // #105: scelta a mano: il DXF della ricetta in arrivo si scarta
+      this.dxfFromRecipe = false; // #105
+      this.result = null;
+      this.tested = false; // #104
+      this.loadDxfPreview(); // #101: anteprima appena si sceglie il file
+    },
+
+    // #101: legge il DXF sul vision worker (via Flask e backend) e ne mostra i contorni
+    async loadDxfPreview() {
+      const seq = ++this._dxfPreviewSeq;
+      this.dxfPreview = null;
+      this.dxfPreviewError = '';
+      this.dxfPreviewBusy = false;
+      if (!this.dxfFile) return; // file tolto: tutto azzerato
+      this.dxfPreviewBusy = true;
+      try {
+        const fd = new FormData();
+        fd.append('dxf', this.dxfFile, this.dxfFile.name);
+        const resp = await fetch('/maker/api/vision/dxf-preview', {
+          method: 'POST', headers: { 'X-CSRFToken': this._csrf() }, body: fd,
+        });
+        const body = await resp.json().catch(() => ({}));
+        if (seq !== this._dxfPreviewSeq) return; // file cambiato nel frattempo
+        if (!resp.ok || body.error) this.dxfPreviewError = this._errorText(body);
+        else this.dxfPreview = body;
+      } catch (e) {
+        if (seq !== this._dxfPreviewSeq) return;
+        this.dxfPreviewError = this.msgs.requestFailed || String(e);
+      }
+      if (seq === this._dxfPreviewSeq) this.dxfPreviewBusy = false;
+    },
+
+    // #101: una stringa `points` per ogni contorno, per <polyline>
+    dxfPreviewPaths() {
+      const contorni = (this.dxfPreview && this.dxfPreview.contorni) || [];
+      return contorni.filter(c => c && c.length > 1).map(c => c.map(p => p[0] + ',' + p[1]).join(' '));
+    },
+
+    // #101: tutti i contorni in un solo attributo `d` ("M x y L x y ..."): x-for non funziona dentro <svg>
+    dxfPreviewD() {
+      const contorni = (this.dxfPreview && this.dxfPreview.contorni) || [];
+      return contorni.filter(c => c && c.length > 1)
+        .map(c => c.map((p, i) => (i ? 'L ' : 'M ') + p[0] + ' ' + p[1]).join(' ')).join(' ');
+    },
+
+    // #101: viewBox sul bbox con margine 5% (minimo 0.5 mm per lato)
+    dxfPreviewViewBox() {
+      const b = this.dxfPreview && this.dxfPreview.bbox;
+      if (!b) return '0 0 1 1';
+      const w = b.xmax - b.xmin, h = b.ymax - b.ymin;
+      const m = Math.max(0.5, 0.05 * Math.max(w, h));
+      return [b.xmin - m, b.ymin - m, w + 2 * m, h + 2 * m].map(v => +v.toFixed(3)).join(' ');
+    },
+
+    // #101: «L × H mm · N entità», decimale con virgola (2 decimali) secondo la lingua pagina
+    get dxfPreviewSummary() {
+      const d = this.dxfPreview;
+      if (!d) return '';
+      const f = v => Number(v).toLocaleString(document.documentElement.lang || 'it',
+        { minimumFractionDigits: 2, maximumFractionDigits: 2 });
+      return `${f(d.larghezza_mm)} × ${f(d.altezza_mm)} mm · ${d.entita} ${this.msgs.dxfEntities || 'entities'}`;
     },
-    onDxf(ev) { this.dxfFile = (ev.target.files && ev.target.files[0]) || null; this.result = null; },
 
     // Frame dalla camera della stazione scelta
     async grab() {
@@ -91,7 +313,7 @@ function dxfRecipeWizard(taskId, csrf, msgs) {
           this.error = body.detail || this.msgs.requestFailed || 'Error';
         } else {
           const blob = await resp.blob();
-          this._setImage(new File([blob], 'camera.png', { type: blob.type || 'image/png' }));
+          this._setImage(new File([blob], 'camera.png', { type: blob.type || 'image/png' }), 'camera'); // #104
         }
       } catch (e) {
         this.error = this.msgs.requestFailed || String(e);
@@ -115,11 +337,17 @@ function dxfRecipeWizard(taskId, csrf, msgs) {
       this.busy = true;
       this.error = '';
       this.notice = '';
+      // #104: parametri usati, mostrati accanto ai risultati
+      this.runPxPerMm = this.useManualScale ? this.manualPxMm : (this.calibrated ? this.calPxMm : null);
+      this.runBandMm = this.bandMm;
+      this.runMinPointsPct = this.minPointsPct;
       try {
         const fd = new FormData();
         fd.append('image', this.imageFile, this.imageFile.name || 'capture.png');
         fd.append('dxf', this.dxfFile, this.dxfFile.name);
         fd.append('station_id', this.stationId);
+        // #98: scala a mano; il backend la preferisce alla calibrazione della stazione (#104: solo con immagine da file)
+        if (this.useManualScale) fd.append('px_per_mm', String(this.manualPxMm));
         fd.append('band_mm', String(this.bandMm));
         fd.append('min_points_pct', String(this.minPointsPct));
         fd.append('polarity', this.dark ? 'dark' : 'light');
@@ -137,18 +365,116 @@ function dxfRecipeWizard(taskId, csrf, msgs) {
             this.notice = this.msgs.saved || 'Saved';
             // Il componente visionRecipe ricarica cartella, file e uscite delle quote
             this.$dispatch('dxf-recipe-saved', { taskId: this.taskId });
+            // #105: il task ha ora una ricetta (etichetta «Modifica»); il wizard e' gia' allineato, non si ricompila
+            this._existingApplied = true;
+            this.existingInfo = false;
+            this.existingWarn = ''; // #105: l'immagine di riferimento ora e' salvata con la ricetta
+            await this.loadExisting();
           }
         }
       } catch (e) {
         this.error = this.msgs.requestFailed || String(e);
       }
       this.busy = false;
+      // #104: la sezione del risultato compare anche con Prova fallita (immagine a sinistra, errore a destra)
+      this.tested = true;
+      this.$nextTick(() => this.fit());
     },
 
     // Le quattro uscite del confronto, nell'ordine fisso
     get values() {
       const out = (this.result && this.result.result && this.result.result.outputs) || {};
-      return VALUE_KEYS.map(k => ({ key: k, value: out[k] }));
+      return VALUE_KEYS.map(k => ({ key: k, value: out[k], label: this._valueLabel(k), unit: VALUE_UNITS[k] })); // #104
+    },
+
+    // #104: etichette leggibili (testi passati da msgs), chiave grezza come ripiego
+    _valueLabel(k) {
+      const m = { 'dxf.points_in_pct': this.msgs.pointsInBand, 'dxf.distance_avg': this.msgs.distAvg,
+        'dxf.distance_min': this.msgs.distMin, 'dxf.distance_max': this.msgs.distMax };
+      return m[k] || k;
+    },
+
+    // #104: esito della ricetta sul riferimento: pass / warning / fail (src/vision/runner.py); altro = valore grezzo
+    get outcome() { return (this.result && this.result.result && this.result.result.outcome) || ''; },
+    get outcomeLabel() {
+      const m = { pass: this.msgs.outcomePass, warning: this.msgs.outcomeWarning, fail: this.msgs.outcomeFail };
+      return m[this.outcome] || this.outcome;
+    },
+    get outcomeClass() {
+      return { pass: 'text-emerald-600', warning: 'text-amber-600', fail: 'text-red-500' }[this.outcome] || 'text-[var(--text-muted)]';
+    },
+    // #104: scala usata nell'ultima Prova, con la fonte
+    get scaleSummary() {
+      if (!this.runPxPerMm) return this.msgs.scaleStation || 'station calibration';
+      const lang = document.documentElement.lang || 'it';
+      const mm = (1 / this.runPxPerMm).toLocaleString(lang, { maximumFractionDigits: 6 });
+      return `${mm} mm/px (${this.imageSource === 'file' ? (this.msgs.scaleManual || 'manual') : (this.msgs.scaleStation || 'station calibration')})`;
+    },
+
+    // #104: zoom dell'immagine di prova. Il wrapper e' largo naturalWidth*zoom; il canvas resta in pixel immagine e lo scala il CSS
+    get zoomPct() { return Math.round(this.zoom * 100) + ' %'; },
+    get zoomW() { return this.resPx ? this.resPx.w * this.zoom : 0; },
+    get zoomH() { return this.resPx ? this.resPx.h * this.zoom : 0; },
+    // #104: altezza massima del viewport = min(70vh, 520px)
+    _maxVpH() { return Math.min(0.7 * (typeof window !== 'undefined' && window.innerHeight ? window.innerHeight : 800), 520); },
+    // #104: con zoom <= Adatta il viewport e' alto come l'immagine scalata (min 200px), altrimenti al massimo
+    get vpHeight() {
+      const max = this._maxVpH();
+      if (!this.resPx || this.zoom > this.fitZoom * 1.0001) return max;
+      return Math.min(max, Math.max(200, this.zoomH));
+    },
+    // #104: l'immagine e' piu' grande dello spazio: si puo' trascinare
+    get canPan() { return !!this.resPx && this.zoom > this.fitZoom * 1.0001; },
+    get panCursor() { return this.canPan ? (this.panning ? 'grabbing' : 'grab') : 'default'; },
+    // #104: pan col puntatore (mouse e touch): scroll del viewport di quanto si muove il puntatore
+    onPanDown(ev) {
+      const vp = this.$refs.viewport;
+      if (!vp || (ev.pointerType === 'mouse' && ev.button)) return;
+      // #104: senza preventDefault Chromium manda pointercancel al primo movimento del mouse e il pan si ferma
+      if (ev.preventDefault) ev.preventDefault();
+      this._pan = { x: ev.clientX, y: ev.clientY, left: vp.scrollLeft, top: vp.scrollTop };
+      this.panning = true;
+      try { vp.setPointerCapture(ev.pointerId); } catch (e) { /* puntatore gia' rilasciato */ }
+    },
+    onPanMove(ev) {
+      const vp = this.$refs.viewport;
+      if (!this._pan || !vp) return;
+      vp.scrollLeft = this._pan.left - (ev.clientX - this._pan.x);
+      vp.scrollTop = this._pan.top - (ev.clientY - this._pan.y);
+    },
+    onPanEnd() { this._pan = null; this.panning = false; },
+    zoomBy(f) {
+      const vp = this.$refs.viewport;
+      const old = this.zoom;
+      const z = Math.min(8, Math.max(0.05, old * f));
+      if (z === old) return;
+      // centro visibile invariato: coordinate immagine del centro prima, scroll dopo il nuovo layout
+      let cx = 0, cy = 0;
+      if (vp) { cx = (vp.scrollLeft + vp.clientWidth / 2) / old; cy = (vp.scrollTop + vp.clientHeight / 2) / old; }
+      this.zoom = z;
+      if (vp) this.$nextTick(() => { vp.scrollLeft = cx * z - vp.clientWidth / 2; vp.scrollTop = cy * z - vp.clientHeight / 2; });
+    },
+    // #104: Fit = tutta l'immagine nel viewport (altezza massima, non quella corrente che segue l'immagine)
+    fit() {
+      const vp = this.$refs.viewport, img = this.$refs.img;
+      if (!vp || !img || !img.naturalWidth || !vp.clientWidth) return;
+      const z = Math.min(8, Math.max(0.05, Math.min(vp.clientWidth / img.naturalWidth, this._maxVpH() / img.naturalHeight)));
+      this.zoom = z;
+      this.fitZoom = z;
+      vp.scrollLeft = 0; vp.scrollTop = 0;
+    },
+    // #104: Ctrl+rotella = zoom
+    onWheel(ev) {
+      if (!ev.ctrlKey) return;
+      ev.preventDefault();
+      this.zoomBy(ev.deltaY < 0 ? 1.25 : 1 / 1.25);
+    },
+    // #104: load dell'immagine di prova: dimensioni, overlay e adattamento allo spazio
+    onResultImgLoad() {
+      const img = this.$refs.img;
+      this.resPx = img && img.naturalWidth ? { w: img.naturalWidth, h: img.naturalHeight } : null;
+      this.drawOverlay();
+      this.$nextTick(() => this.fit());
     },
 
     fmt(v) {

src/frontend/flask_app/static/js/vision_execute.js

@@ -11,6 +11,13 @@
  *   taskType, subtasks, labels.
  * Run context (lot, serial, production run) is read lazily through `ctx()`,
  * which the template binds to the parent task component.
+ *
+ * #97: with a camera (cameraAvailable, the task's or the station's) the task opens
+ * on a frame already grabbed and analysed (/vision/check, nothing saved: «preview»).
+ * modo «impulsiva»: «Acquisisci» redoes grab+check. modo «in_linea»: continuous
+ * loop grab+check, one request at a time, standing still while paused / page hidden
+ * / leaving / saving. «Registra» saves the LAST frame shown through /vision/execute.
+ * Extra config: cameraAvailable, modo, checkUrl.
  */
 function visionExecute() {
   // Overlay colour per role (VisionSuite roles: reference, roi, found).
@@ -24,6 +31,125 @@ function visionExecute() {
     imageSrc: '',      // object URL of the acquired image (shown under the overlay)
     ctx: () => ({}),   // replaced by the template: {lot, serial, runId}
 
+    // #97: preview / loop state
+    preview: false,    // result on screen is an analysis only, not saved
+    saved: false,      // «Registra» done: the saved result replaces the preview
+    lastBlob: null,    // last frame shown, the one «Registra» saves
+    paused: false,     // operator paused the in-line loop
+    registering: false, // «Registra» in progress: the loop stands still
+    leaving: false,    // page is being left: no more requests
+    looping: false,    // an in-line loop is running
+    gen: 0,            // bumped by «Registra»: answers of older requests are dropped
+
+    // #97: start on a frame already acquired and analysed; hook visibility and exit.
+    init() {
+      if (!this.hasCamera) return;
+      document.addEventListener('visibilitychange', () => { if (!document.hidden) this.kick(); });
+      const leave = () => { this.leaving = true; };
+      window.addEventListener('pagehide', leave);
+      window.addEventListener('beforeunload', leave);
+      // After x-init has bound ctx(): in-line starts the loop, impulsive grabs once.
+      this.$nextTick(() => { if (this.inLinea) this.loop(); else this.grab(); });
+    },
+
+    get hasCamera() { return !!(window.__visionCfg || {}).cameraAvailable; },
+    get inLinea() { return this.hasCamera && (window.__visionCfg || {}).modo === 'in_linea'; },
+    // «Registra» needs a frame on screen that is not saved yet
+    get canRecord() { return !!this.lastBlob && !this.saved && !this.registering; },
+
+    shouldRun() {
+      return this.inLinea && !this.paused && !this.saved && !this.registering
+        && !this.leaving && !document.hidden;
+    },
+
+    // Page visible again: restart the loop unless the operator paused it.
+    kick() { if (this.shouldRun() && !this.looping) this.loop(); },
+
+    // In-line loop: one request at a time, at least 300 ms between two of them
+    // (longer after an error, so a dead camera is not hammered).
+    async loop() {
+      if (this.looping) return;
+      this.looping = true;
+      try {
+        while (this.shouldRun()) {
+          const ok = await this.grab();
+          await new Promise((r) => setTimeout(r, ok ? 300 : 2000));
+        }
+      } finally {
+        this.looping = false;
+      }
+    },
+
+    // «Pausa» / «Riprendi»; after «Registra» only «Riprendi» restarts the loop.
+    togglePause() {
+      if (this.paused || this.saved) {
+        this.paused = false;
+        this.saved = false;
+        this.loop();
+      } else {
+        this.paused = true;
+      }
+    },
+
+    // Analysis only (/vision/check): the frame becomes the preview, nothing is saved.
+    async analyze(blob) {
+      const cfg = window.__visionCfg || {};
+      if (!blob || !cfg.checkUrl) return false;
+      const gen = this.gen;
+      this.busy = true;
+      this.error = '';
+      try {
+        const c = this.ctx() || {};
+        const fd = new FormData();
+        fd.append('task_id', cfg.taskId);
+        fd.append('image', blob, blob.name || 'capture.jpg');
+        if (c.runId) fd.append('production_run_id', c.runId);
+        const csrf = document.querySelector('meta[name=csrf-token]')?.content || '';
+        const resp = await fetch(cfg.checkUrl, {
+          method: 'POST', headers: { 'X-CSRFToken': csrf }, body: fd,
+        });
+        const body = await resp.json().catch(() => ({}));
+        if (gen !== this.gen) return false;   // «Registra» took over
+        if (!resp.ok || body.error) {
+          this.error = body.detail || (cfg.labels && cfg.labels.requestFailed) || 'Error';
+          return false;
+        }
+        if (this.imageSrc) URL.revokeObjectURL(this.imageSrc);
+        this.imageSrc = URL.createObjectURL(blob);
+        this.lastBlob = blob;
+        this.result = body;
+        this.preview = true;
+        this.saved = false;
+        this.$nextTick(() => this.drawOverlay());
+        return true;
+      } catch (e) {
+        if (gen === this.gen) this.error = (cfg.labels && cfg.labels.requestFailed) || 'Error';
+        return false;
+      } finally {
+        if (gen === this.gen) this.busy = false;
+      }
+    },
+
+    // «Registra»: save the LAST frame shown with the usual /vision/execute.
+    async record() {
+      if (!this.canRecord) return;
+      const blob = this.lastBlob;
+      this.registering = true;
+      this.gen++;              // drop whatever request is still in flight
+      this.busy = false;
+      this.grabbing = false;
+      try {
+        await this.acquire(blob);
+        if (!this.error && this.result && this.result.vision_result_id) {
+          this.preview = false;
+          this.saved = true;
+        }
+      } finally {
+        this.registering = false;
+        this.kick();           // in-line: stays still while saved, restarts if the save failed
+      }
+    },
+
     // Entry point shared with the future agent camera.
     async acquire(blob) {
       if (!blob || this.busy) return;
@@ -64,37 +190,52 @@ function visionExecute() {
 
     // Station camera (#72): the Flask proxy answers a PNG, which goes through
     // acquire() like a picked file. Errors show as the execute ones do.
+    // #97: sends task_id (the task's camera wins over the station's); with a camera
+    // the frame goes to the preview analysis. Returns true when the frame was analysed.
     async grab() {
       const cfg = window.__visionCfg || {};
-      if (this.busy || this.grabbing || !cfg.grabUrl) return;
+      if (this.busy || this.grabbing || this.registering || !cfg.grabUrl) return false;
+      const gen = this.gen;
       this.grabbing = true;
       this.error = '';
       let blob = null;
       try {
         const csrf = document.querySelector('meta[name=csrf-token]')?.content || '';
+        const fd = new FormData();
+        fd.append('task_id', cfg.taskId);
         const resp = await fetch(cfg.grabUrl, {
-          method: 'POST', headers: { 'X-CSRFToken': csrf },
+          method: 'POST', headers: { 'X-CSRFToken': csrf }, body: fd,
         });
         if (!resp.ok) {
           const body = await resp.json().catch(() => ({}));
-          this.error = body.detail || (cfg.labels && cfg.labels.requestFailed) || 'Error';
-          return;
+          if (gen === this.gen) this.error = body.detail || (cfg.labels && cfg.labels.requestFailed) || 'Error';
+          return false;
         }
         blob = await resp.blob();
       } catch (e) {
-        this.error = (cfg.labels && cfg.labels.requestFailed) || 'Error';
-        return;
+        if (gen === this.gen) this.error = (cfg.labels && cfg.labels.requestFailed) || 'Error';
+        return false;
       } finally {
-        this.grabbing = false;
+        if (gen === this.gen) this.grabbing = false;
       }
-      if (blob) await this.acquire(blob);
+      if (!blob || gen !== this.gen) return false;
+      if (this.hasCamera) return await this.analyze(blob);
+      await this.acquire(blob);
+      return !this.error;
     },
 
     // Input change: take the file and allow picking the same one again.
+    // #97: with a camera the file is a preview too (the loop pauses), «Registra» saves it.
     onPick(ev) {
       const f = ev.target.files && ev.target.files[0];
       ev.target.value = '';
-      if (f) this.acquire(f);
+      if (!f) return;
+      if (this.hasCamera) {
+        if (this.inLinea) this.paused = true;
+        this.analyze(f);
+      } else {
+        this.acquire(f);
+      }
     },
 
     // Image shown: the saved one from the server when available, else the local one.

src/frontend/flask_app/templates/maker/task_editor.html

@@ -662,11 +662,16 @@
                 <!-- ========== Crea ricetta da DXF (#83): solo dxf_compare ========== -->
                 <template x-if="task.task_type === 'dxf_compare'">
                   <div class="mt-4 pt-3 border-t border-[var(--border-color)]"
-                       x-data="dxfRecipeWizard(task.id, () => csrfToken(), {{ {'requestFailed': _('Richiesta non riuscita'), 'saved': _('Ricetta salvata')}|tojson_attr }})">
-                    <button type="button" class="btn btn-secondary text-xs" @click="toggle()">
+                       x-data="dxfRecipeWizard(task.id, () => csrfToken(), {{ {'requestFailed': _('Richiesta non riuscita'), 'saved': _('Ricetta salvata'), 'dxfEntities': _('entità'), 'imageField': _('campo'), 'pointsInBand': _('Punti in banda'), 'distAvg': _('Distanza media'), 'distMin': _('Distanza minima'), 'distMax': _('Distanza massima'), 'outcomePass': _('Conforme'), 'outcomeWarning': _('Con avvisi'), 'outcomeFail': _('Non conforme'), 'scaleManual': _('mm/px a mano'), 'scaleStation': _('calibrazione stazione'), 'createLabel': _('Crea ricetta da DXF'), 'editLabel': _('Modifica ricetta da DXF'), 'noReferenceImage': _('Immagine di riferimento non salvata (ricetta creata prima): acquisiscila o caricala'), 'existingFilesFailed': _('Impossibile leggere i file della ricetta esistente')}|tojson_attr }})">{# #104: etichette del risultato della Prova; #105: etichette del bottone e avvisi della ricetta esistente #}
+                    {# #105: «Modifica ricetta da DXF» se il task ha gia' una ricetta da DXF #}
+                    <button type="button" class="btn btn-secondary text-xs" @click="toggle()"
+                            x-text="existing ? msgs.editLabel : msgs.createLabel">
                       {{ _('Crea ricetta da DXF') }}
                     </button>
                     <div x-show="open" x-cloak class="mt-3 space-y-3">
+                      <!-- #105: ricetta esistente caricata nel wizard -->
+                      <p x-show="existingInfo" class="text-xs text-emerald-600">{{ _('Ricetta esistente caricata: Prova e poi Salva ricetta per sostituirla') }}</p>
+                      <p x-show="existingWarn" class="text-xs text-amber-600" x-text="existingWarn"></p>
                       <!-- Stazione -->
                       <div>
                         <label class="tmf-label text-xs">{{ _('Stazione') }}</label>
@@ -680,14 +685,14 @@
                         <p x-show="stationId && calibrated" class="mt-1 text-xs text-emerald-600">
                           {{ _('Calibrazione') }}: <span x-text="calLabel"></span>
                         </p>
-                        <p x-show="stationId && calState && !calibrated" class="mt-1 text-xs text-amber-600">
+                        <p x-show="stationId && calState && !calibrated && !useManualScale" class="mt-1 text-xs text-amber-600">{# #98: nascosto con mm/px valido (#104: solo per immagine da file) #}
                           <span x-text="calState === 'uncalibrated' ? {{ _('Stazione non calibrata: calibrala prima di creare la ricetta.')|tojson_attr }} : {{ _('Acquisitore non raggiungibile: impossibile leggere la calibrazione.')|tojson_attr }}"></span>
                           <a :href="calUrl" target="_blank" rel="noopener" x-show="calUrl"
                              class="font-medium text-primary hover:underline">{{ _('Calibra') }}</a>
                           <span class="text-[var(--text-muted)]">({{ _('oppure vedi la pagina Stazioni') }})</span>
                         </p>
                       </div>
-                      <!-- Immagine: camera o file -->
+                      <!-- Immagine: camera o file. #104: prima le scelte, poi le anteprime affiancate -->
                       <div class="grid grid-cols-1 sm:grid-cols-2 gap-3">
                         <div>
                           <label class="tmf-label text-xs">{{ _('Immagine del pezzo') }}</label>
@@ -700,10 +705,48 @@
                             </label>
                           </div>
                           <p class="mt-1 text-xs text-[var(--text-muted)]" x-text="imageName"></p>
+                          <!-- #98: mm/px a mano, #104: solo per un'immagine da file; sostituisce la calibrazione della stazione -->
+                          <div x-show="imageSource === 'file'" class="mt-2">
+                            <label class="tmf-label text-xs">{{ _('mm/px (immagine da file)') }}</label>
+                            <input type="text" inputmode="decimal" class="tmf-input text-xs" x-model="mmPx" placeholder="0,01406">
+                            <p x-show="manualPxMm !== null" class="mt-1 text-xs text-emerald-600">
+                              = <span x-text="fmt(manualPxMm)"></span> px/mm
+                            </p>
+                            <p x-show="mmPxInvalid" class="mt-1 text-xs text-amber-600">{{ _('mm/px non valido') }}</p>
+                            <p class="mt-1 text-xs text-[var(--text-muted)]">{{ _('Se compilato sostituisce la calibrazione della stazione; la scala resta salvata nella ricetta.') }}</p>
+                          </div>
                         </div>
                         <div>
                           <label class="tmf-label text-xs">{{ _('Disegno (.dxf)') }}</label>
                           <input type="file" accept=".dxf" class="tmf-input text-xs" @change="onDxf($event)">
+                          <!-- #105: DXF preso dalla ricetta esistente (l'input file non puo' mostrarne il nome) -->
+                          <p x-show="dxfFromRecipe && dxfFile" class="mt-1 text-xs text-[var(--text-muted)]" x-text="dxfFile ? dxfFile.name : ''"></p>
+                          <!-- #101: lettura del disegno appena scelto il .dxf -->
+                          <p x-show="dxfPreviewBusy" class="mt-1 text-xs text-[var(--text-muted)]">{{ _('Lettura DXF…') }}</p>
+                          <p x-show="dxfPreviewError" class="mt-1 text-xs text-red-500" x-text="dxfPreviewError"></p>
+                        </div>
+                      </div>
+                      <!-- #104: anteprime sotto le scelte, scatole alte uguali (240px) per stare allineate -->
+                      <div class="grid grid-cols-1 sm:grid-cols-2 gap-3 items-start">
+                        <div x-show="imagePreviewUrl">
+                          <!-- #102: anteprima dell'immagine -->
+                          <img x-show="!imageBroken" :src="imagePreviewUrl" alt=""
+                               @load="onImagePreviewLoad($event.target)" @error="onImagePreviewError()"
+                               class="block w-full rounded border border-[var(--border-color)]"
+                               style="height: 240px; object-fit: contain; background: var(--bg-primary);">
+                          <p x-show="imageBroken" class="text-xs text-amber-600">{{ _('Anteprima non disponibile per questo formato') }}</p>
+                          <p x-show="imagePreviewSummary" class="mt-1 text-xs text-[var(--text-muted)]" x-text="imagePreviewSummary"></p>
+                        </div>
+                        <div x-show="dxfPreview" class="sm:col-start-2">{# #104: resta a destra anche senza anteprima immagine #}
+                          <svg x-bind:view-box.camel="dxfPreviewViewBox()" preserveAspectRatio="xMidYMid meet"
+                               class="block w-full rounded border border-[var(--border-color)]"
+                               style="height: 240px; background: var(--bg-primary);">
+                            <!-- #101: un solo path (x-for/template non funziona nel namespace SVG); view-box.camel perche' il parser HTML abbassa viewBox -->
+                            <path :d="dxfPreviewD()" fill="none" stroke="var(--color-primary, #2563eb)"
+                                  stroke-width="1.5" vector-effect="non-scaling-stroke"
+                                  stroke-linejoin="round"></path>
+                          </svg>
+                          <p class="mt-1 text-xs text-[var(--text-muted)]" x-text="dxfPreviewSummary"></p>
                         </div>
                       </div>
                       <!-- Pochi parametri -->
@@ -728,21 +771,57 @@
                         <button type="button" class="btn btn-primary text-xs" @click="run(true)"
                                 :disabled="!canRun || !result">{{ _('Salva ricetta') }}</button>
                       </div>
-                      <p x-show="error" class="text-xs text-red-500" x-text="error"></p>
-                      <p x-show="notice" class="text-xs text-emerald-600" x-text="notice"></p>
-                      <!-- Anteprima con overlay e quattro valori -->
-                      <div x-show="imageSrc" class="relative">
-                        <img x-ref="img" :src="imageSrc" alt="" class="block w-full rounded border border-[var(--border-color)]"
-                             @load="drawOverlay()">
-                        <canvas x-ref="overlay" class="absolute inset-0 w-full h-full pointer-events-none"></canvas>
+                      <!-- #104: errore di acquisizione prima di una Prova (dopo, sta nella colonna dei dati) -->
+                      <p x-show="error && !tested" class="text-xs text-red-500" x-text="error"></p>
+                      <!-- #104: risultato della Prova su due colonne: immagine con zoom a sinistra, dati ed errori a destra -->
+                      <div x-show="tested" class="grid grid-cols-1 sm:grid-cols-2 gap-3 items-start">{# #104: risultati a destra gia' da 640px, come le altre griglie del wizard #}
+                        <div>
+                          <!-- #104: barra zoom in sovrimpressione, fuori dal contenuto scorrevole -->
+                          <div class="relative">
+                            <div class="absolute top-2 right-2 z-10 flex items-center gap-1 rounded px-1 py-0.5"
+                                 style="background: rgba(0,0,0,.55); color: #fff;">
+                              <button type="button" class="px-1.5 text-xs rounded hover:bg-white/20" @click="zoomBy(1 / 1.25)" title="{{ _('Riduci') }}">&minus;</button>
+                              <button type="button" class="px-1.5 text-xs rounded hover:bg-white/20" @click="zoomBy(1.25)" title="{{ _('Ingrandisci') }}">+</button>
+                              <button type="button" class="px-1.5 text-xs rounded hover:bg-white/20" @click="fit()">{{ _('Adatta') }}</button>
+                              <span class="text-xs px-1" x-text="zoomPct"></span>
+                            </div>
+                            <!-- #104: pan col puntatore (mouse e dito), cursore grab; altezza che segue l'immagine finche' zoom <= Adatta -->
+                            <div x-ref="viewport" @wheel="onWheel($event)"
+                                 @pointerdown="onPanDown($event)" @pointermove="onPanMove($event)"
+                                 @pointerup="onPanEnd()" @pointercancel="onPanEnd()"
+                                 class="rounded border border-[var(--border-color)]"
+                                 :style="'overflow:auto;touch-action:none;user-select:none;background:var(--bg-primary);height:' + vpHeight + 'px;cursor:' + panCursor">
+                            <div class="relative" :style="zoomW ? ('width:' + zoomW + 'px;height:' + zoomH + 'px') : 'width:100%'">
+                              <img x-ref="img" :src="imageSrc" alt="" class="block" draggable="false" style="width: 100%; height: 100%; user-select: none;"
+                                   @load="onResultImgLoad()">
+                              <canvas x-ref="overlay" class="absolute inset-0 w-full h-full pointer-events-none"></canvas>
+                            </div>
+                            </div>
+                          </div>
+                        </div>
+                        <div class="space-y-2">
+                          <p x-show="error" class="text-xs text-red-500" x-text="error"></p>
+                          <p x-show="notice" class="text-xs text-emerald-600" x-text="notice"></p>
+                          <div x-show="result" class="space-y-2">
+                            <p class="text-xs">{{ _('Esito') }}: <span class="font-semibold" :class="outcomeClass" x-text="outcomeLabel"></span></p>
+                            <table class="tmf-table text-xs">
+                              <tbody>
+                                <template x-for="v in values" :key="v.key">
+                                  <tr>
+                                    <td :title="v.key" x-text="v.label"></td>
+                                    <td class="text-right"><span x-text="fmt(v.value)"></span> <span class="text-[var(--text-muted)]" x-text="v.unit"></span></td>
+                                  </tr>
+                                </template>
+                              </tbody>
+                            </table>
+                            <ul class="text-xs text-[var(--text-muted)] space-y-0.5">
+                              <li>{{ _('Scala') }}: <span x-text="scaleSummary"></span></li>
+                              <li>{{ _('Banda ± mm') }}: <span x-text="fmt(runBandMm)"></span></li>
+                              <li>{{ _('Soglia punti in banda %%') }}: <span x-text="fmt(runMinPointsPct)"></span></li>
+                            </ul>
+                          </div>
+                        </div>
                       </div>
-                      <table x-show="result" class="tmf-table text-xs">
-                        <tbody>
-                          <template x-for="v in values" :key="v.key">
-                            <tr><td class="font-mono" x-text="v.key"></td><td class="text-right" x-text="fmt(v.value)"></td></tr>
-                          </template>
-                        </tbody>
-                      </table>
                     </div>
                   </div>
                 </template>

src/frontend/flask_app/templates/measure/task_execute.html

@@ -534,9 +534,10 @@
   <div x-show="isVisionTask" x-cloak
        x-data="visionExecute()"
        x-init="ctx = () => ({ lot: lotNumber, serial: serialNumber, runId: productionRun ? productionRun.id : null })"
-       class="flex-1 overflow-auto p-3 flex flex-col lg:flex-row gap-3">
+       class="flex-1 min-h-0 overflow-hidden p-3 flex flex-col lg:flex-row gap-3">
+    {# #96: il pannello non scorre mai (overflow-hidden, min-h-0): l'immagine sta in fit nello spazio che resta #}
 
-    <div class="flex-1 min-w-0 flex flex-col gap-2">
+    <div class="flex-1 min-w-0 min-h-0 flex flex-col gap-2">
       <div class="flex items-center gap-2 flex-wrap">
         {# On a tablet this opens the camera; on a PC it picks a file. «Riprova» reuses the same input. #}
         <label class="btn btn-primary text-sm gap-1.5 cursor-pointer" :class="busy ? 'opacity-50 pointer-events-none' : ''">
@@ -545,12 +546,29 @@
                  @change="onPick($event)" :disabled="busy">
         </label>
         {% if camera_enabled %}
-        {# #72: frame dalla camera della stazione, stessa strada di acquire() #}
+        {# #97: camera del task (o della stazione). Impulsiva: «Acquisisci» rifa grab+check; in linea: «Pausa»/«Riprendi» sul ciclo #}
+        {% if camera_mode == 'in_linea' %}
+        <button type="button" class="btn btn-secondary text-sm gap-1.5" @click="togglePause()"
+                :class="registering ? 'opacity-50 pointer-events-none' : ''"
+                :disabled="registering">
+          <span x-text="(paused || saved) ? '{{ _('Riprendi') }}' : '{{ _('Pausa') }}'"></span>
+        </button>
+        {% else %}
+        {# #72: frame dalla camera, stessa strada di acquire(); #97: ora grab + analisi senza salvare #}
         <button type="button" class="btn btn-secondary text-sm gap-1.5" @click="grab()"
                 :class="(busy || grabbing) ? 'opacity-50 pointer-events-none' : ''"
                 :disabled="busy || grabbing">
-          <span>{{ _('Acquisisci dalla camera') }}</span>
+          <span>{{ _('Acquisisci') }}</span>
         </button>
+        {% endif %}
+        {# #97: salva l'ULTIMO frame mostrato (execute); fino ad allora e' solo un'anteprima #}
+        <button type="button" class="btn btn-primary text-sm gap-1.5" @click="record()"
+                :class="canRecord ? '' : 'opacity-50 pointer-events-none'"
+                :disabled="!canRecord">
+          <span>{{ _('Registra') }}</span>
+        </button>
+        <span x-show="preview && !saved" x-cloak
+              class="inline-block px-2 py-0.5 rounded text-xs font-bold bg-amber-50 dark:bg-amber-900/20 border border-amber-300 dark:border-amber-700">{{ _('Anteprima, non registrata') }}</span>
         <span x-show="grabbing" class="text-sm text-[var(--text-muted)]">{{ _('Acquisizione in corso...') }}</span>
         {% endif %}
         <span x-show="busy" class="text-sm text-[var(--text-muted)]">{{ _('Elaborazione in corso...') }}</span>
@@ -558,16 +576,18 @@
 
       <div x-show="error" class="p-2 rounded-lg bg-red-50 dark:bg-red-900/20 border border-red-200 dark:border-red-800 text-sm text-measure-fail" x-text="error"></div>
 
-      <div x-show="shownImage" class="relative border border-[var(--border-color)] rounded-lg overflow-hidden bg-black/5">
-        <img x-ref="img" :src="shownImage" @load="drawOverlay()" alt="" class="block w-full h-auto">
-        <canvas x-ref="overlay" class="absolute inset-0 w-full h-full pointer-events-none"></canvas>
+      {# #96: riquadro flex-1 min-h-0; img e canvas object-contain sovrapposti (il canvas ha la stessa risoluzione naturale dell'immagine, quindi l'overlay resta allineato) #}
+      <div x-show="shownImage" class="relative flex-1 min-h-0 border border-[var(--border-color)] rounded-lg overflow-hidden bg-black/5">
+        <img x-ref="img" :src="shownImage" @load="drawOverlay()" alt="" class="absolute inset-0 w-full h-full object-contain">
+        <canvas x-ref="overlay" class="absolute inset-0 w-full h-full object-contain pointer-events-none"></canvas>
       </div>
       <div x-show="!shownImage" class="text-sm text-[var(--text-muted)]">
         {{ _('Nessuna immagine acquisita: premi «Acquisisci immagine».') }}
       </div>
     </div>
 
-    <div class="lg:w-80 shrink-0 flex flex-col gap-2" x-show="result">
+    {# #96: colonna esito con scorrimento proprio (solo con molte quote); sotto lg max 40% dell'altezza #}
+    <div class="lg:w-80 shrink-0 min-h-0 overflow-y-auto max-h-[40%] lg:max-h-none flex flex-col gap-2" x-show="result">
       <div class="text-sm font-bold text-[var(--text-primary)]">
         {{ _('Esito') }}: <span x-text="(result && result.outcome) || '-'"></span>
       </div>
@@ -1146,6 +1166,9 @@
   window.__visionCfg = {
     executeUrl: '{{ url_for("measure.api_vision_execute") }}',
     grabUrl: '{{ url_for("measure.api_vision_grab") }}',
+    checkUrl: '{{ url_for("measure.api_vision_check") }}',  {# #97: analisi senza salvare #}
+    cameraAvailable: {{ (camera_enabled|default(false))|tojson }},
+    modo: {{ (camera_mode|default('impulsiva'))|tojson }},
     imageUrlTpl: '{{ url_for("measure.api_vision_result_image", result_id=0) }}',
     taskId: {{ task.id|tojson }},
     taskType: {{ (task.task_type or '')|tojson }},

src/frontend/flask_app/templates/statistics/dashboard.html

@@ -51,7 +51,9 @@
       <!-- Subtask -->
       <div>
         <label class="block text-xs font-medium text-steel mb-1">{{ _("Punto di misura") }}</label>
+        <!-- #100: il cambio di punto ricarica subito, senza «Applica filtri» -->
         <select x-model="selectedSubtaskId"
+                @change="loadData()"
                 :disabled="subtasks.length === 0"
                 class="w-full rounded-lg border border-[var(--border-color)] bg-[var(--bg-primary)] text-[var(--text-primary)] px-3 py-2 text-sm focus:ring-2 focus:ring-primary focus:border-primary disabled:opacity-50">
           <option value="">{{ _("Tutti i punti") }}</option>
@@ -287,20 +289,52 @@
               </div>
             </div>
           </template>
-          <template x-if="!capability || capability.cp == null">
+          <!-- #100: con «Tutti i punti» tabella con una riga per punto di misura -->
+          <template x-if="!loadedSubtaskId && capabilityAll.length > 0">
+            <div>
+              <table class="w-full text-sm">
+                <thead>
+                  <tr class="text-xs text-steel text-left">
+                    <th class="py-1 font-medium">{{ _("Punto di misura") }}</th>
+                    <th class="py-1 font-medium text-right">n</th>
+                    <th class="py-1 font-medium text-right">Cp</th>
+                    <th class="py-1 font-medium text-right">Cpk</th>
+                  </tr>
+                </thead>
+                <tbody>
+                  <template x-for="row in capabilityAll" :key="row.subtask.id">
+                    <tr class="cursor-pointer hover:bg-[var(--bg-primary)] border-t border-[var(--border-color)]"
+                        @click="selectedSubtaskId = String(row.subtask.id); loadData()">
+                      <td class="py-1.5 pr-2" x-text="'#' + row.subtask.marker_number + ' — ' + row.subtask.description"></td>
+                      <td class="py-1.5 text-right font-mono" x-text="row.data && row.data.n != null ? row.data.n : '—'"></td>
+                      <td class="py-1.5 text-right font-mono font-bold"
+                          :class="row.data && row.data.cp != null ? capabilityColor(row.data.cp) : 'text-steel'"
+                          x-text="row.data && row.data.cp != null ? row.data.cp : '—'"></td>
+                      <td class="py-1.5 text-right font-mono font-bold"
+                          :class="row.data && row.data.cpk != null ? capabilityColor(row.data.cpk) : 'text-steel'"
+                          x-text="row.data && row.data.cpk != null ? row.data.cpk : '—'"></td>
+                    </tr>
+                  </template>
+                </tbody>
+              </table>
+              <p class="text-xs text-steel mt-3">{{ _("Scegli un punto per carta di controllo e istogramma") }}</p>
+            </div>
+          </template>
+          <template x-if="(!capability || capability.cp == null) && (loadedSubtaskId || capabilityAll.length === 0)">
             <p class="text-center text-steel py-8">{{ _("Seleziona un punto di misura per calcolare gli indici") }}</p>
           </template>
         </div>
       </div>
 
       <!-- Row 2: Carta di Controllo -->
-      <div class="bg-[var(--bg-secondary)] rounded-xl border border-[var(--border-color)] p-5 shadow-sm mb-6">
+      <!-- #100: x-show (non x-if) perche' renderCharts() cerca gli id nel DOM; nascosta senza punto -->
+      <div x-show="loadedSubtaskId" class="bg-[var(--bg-secondary)] rounded-xl border border-[var(--border-color)] p-5 shadow-sm mb-6">
         <h2 class="text-sm font-semibold text-steel uppercase tracking-wider mb-4">{{ _("Carta di Controllo") }}</h2>
         <div id="control-chart" style="min-height: 350px;"></div>
       </div>
 
       <!-- Row 3: Istogramma -->
-      <div class="bg-[var(--bg-secondary)] rounded-xl border border-[var(--border-color)] p-5 shadow-sm mb-6">
+      <div x-show="loadedSubtaskId" class="bg-[var(--bg-secondary)] rounded-xl border border-[var(--border-color)] p-5 shadow-sm mb-6">
         <h2 class="text-sm font-semibold text-steel uppercase tracking-wider mb-4">{{ _("Istogramma") }}</h2>
         <div id="histogram-chart" style="min-height: 350px;"></div>
       </div>
@@ -346,6 +380,8 @@ function spcDashboard() {
     subtasks: [],
 
     // Data state
+    loadedSubtaskId: '',  // #100 punto con cui sono stati caricati i dati (i pannelli dipendono da questo)
+    capabilityAll: [],  // #100 con «Tutti i punti»: [{subtask, data}] una riga per punto
     summary: null,
     capability: null,
     controlChart: null,
@@ -408,6 +444,8 @@ function spcDashboard() {
 
     async onRecipeChange() {
       this.selectedSubtaskId = '';
+      this.loadedSubtaskId = '';  // #100
+      this.capabilityAll = [];  // #100
       this.selectedRunId = '';  // #58
       this.runs = [];
       this.subtasks = [];
@@ -459,10 +497,11 @@ function spcDashboard() {
       if (this.selectedRunId) params.set('production_run_id', this.selectedRunId);  // #58
       if (this.dateFrom) params.set('date_from', new Date(this.dateFrom + 'T00:00:00').toISOString());
       if (this.dateTo) params.set('date_to', new Date(this.dateTo + 'T23:59:59.999').toISOString());
+      const requestedSubtaskId = this.selectedSubtaskId;  // #100 punto richiesto da questa chiamata
 
       try {
         // Parallel fetch of all endpoints
-        const [summaryResp, capabilityResp, controlResp, histogramResp] = await Promise.allSettled([
+        const [summaryResp, capabilityResp, controlResp, histogramResp, allResp] = await Promise.allSettled([
           fetch('/statistics/api/summary?' + params.toString()).then(r => r.json()),
           this.selectedSubtaskId
             ? fetch('/statistics/api/capability?' + params.toString()).then(r => r.json())
@@ -473,6 +512,17 @@ function spcDashboard() {
           this.selectedSubtaskId
             ? fetch('/statistics/api/histogram?' + params.toString()).then(r => r.json())
             : Promise.resolve(null),
+          // #100: senza punto scelto, capability di ogni punto della ricetta
+          requestedSubtaskId
+            ? Promise.resolve([])
+            : Promise.all(this.subtasks.map(st => {
+                const p = new URLSearchParams(params.toString());
+                p.set('subtask_id', st.id);
+                return fetch('/statistics/api/capability?' + p.toString())
+                  .then(r => r.json())
+                  .then(d => ({ subtask: st, data: (d && !d.error) ? d : null }))
+                  .catch(() => ({ subtask: st, data: null }));
+              })),
         ]);
 
         // Summary (always available)
@@ -505,6 +555,9 @@ function spcDashboard() {
           this.histogram = null;
         }
 
+        // #100: lista per-punto solo con «Tutti i punti»; con un punto resta il flusso di prima
+        this.capabilityAll = (allResp.status === 'fulfilled' && Array.isArray(allResp.value)) ? allResp.value : [];
+        this.loadedSubtaskId = requestedSubtaskId;
         this.hasData = true;
 
         // Render charts after DOM update
@@ -522,7 +575,7 @@ function spcDashboard() {
 
     renderCharts() {
       // Control chart
-      if (this.controlChart && this.selectedSubtaskId) {
+      if (this.controlChart && this.loadedSubtaskId) {  // #100
         renderControlChart('control-chart', this.controlChart);
       } else {
         const el = document.getElementById('control-chart');
@@ -530,7 +583,7 @@ function spcDashboard() {
       }
 
       // Histogram
-      if (this.histogram && this.selectedSubtaskId) {
+      if (this.histogram && this.loadedSubtaskId) {  // #100
         const tol = this.capability ? {
           utl: this.capability.utl,
           ltl: this.capability.ltl,

src/frontend/flask_app/tests/js/test_dxf_preview.js

@@ -0,0 +1,301 @@
+/**
+ * #101: anteprima DXF del wizard «Crea ricetta da DXF», con plain node.
+ * Copre dxfPreviewPaths, dxfPreviewViewBox, dxfPreviewSummary e lo scarto
+ * di una risposta arrivata dopo un cambio di file.
+ *
+ * Run from src/frontend/flask_app: node tests/js/test_dxf_preview.js
+ */
+'use strict';
+const fs = require('fs');
+const path = require('path');
+
+global.document = { documentElement: { lang: 'it' } };
+const src = fs.readFileSync(
+  path.join(__dirname, '..', '..', 'static', 'js', 'dxf_recipe_wizard.js'), 'utf8',
+);
+eval(src + ';global.dxfRecipeWizard = dxfRecipeWizard;');
+
+let failures = 0;
+function check(label, cond, extra) {
+  if (cond) console.log('ok - ' + label);
+  else { failures++; console.log('FAIL - ' + label + (extra ? ' :: ' + extra : '')); }
+}
+
+const PREVIEW = {
+  contorni: [[[0, -5], [12.3, -5], [12.3, 0], [0, 0], [0, -5]], [[1, -1]]],
+  bbox: { xmin: 0, ymin: -5.1, xmax: 12.3, ymax: 0 },
+  larghezza_mm: 12.3, altezza_mm: 5.1, entita: 2, punti: 6,
+};
+
+(async () => {
+  const w = dxfRecipeWizard(1, () => 'tok', { dxfEntities: 'entità' });
+
+  check('senza anteprima: nessun path', w.dxfPreviewPaths().length === 0);
+  check('senza anteprima: summary vuoto', w.dxfPreviewSummary === '');
+
+  w.dxfPreview = PREVIEW;
+  const paths = w.dxfPreviewPaths();
+  check('un contorno con >1 punti diventa una polyline (quello da 1 punto no)', paths.length === 1);
+  check('formato points', paths[0] === '0,-5 12.3,-5 12.3,0 0,0 0,-5', paths[0]);
+
+  // #101: path unico per <path :d>
+  check('dxfPreviewD', w.dxfPreviewD() === 'M 0 -5 L 12.3 -5 L 12.3 0 L 0 0 L 0 -5', w.dxfPreviewD());
+  w.dxfPreview = null;
+  check('dxfPreviewD vuoto senza anteprima', w.dxfPreviewD() === '');
+  w.dxfPreview = PREVIEW;
+
+  const vb = w.dxfPreviewViewBox().split(' ').map(Number);
+  const m = Math.max(0.5, 0.05 * 12.3);
+  check('viewBox con margine 5%', Math.abs(vb[0] + m) < 1e-3 && Math.abs(vb[2] - (12.3 + 2 * m)) < 1e-3, vb.join(' '));
+
+  // Disegno minuscolo: margine minimo 0.5 mm
+  w.dxfPreview = { ...PREVIEW, bbox: { xmin: 0, ymin: 0, xmax: 1, ymax: 1 } };
+  check('margine minimo 0.5 mm', Math.abs(w.dxfPreviewViewBox().split(' ').map(Number)[0] + 0.5) < 1e-3);
+
+  w.dxfPreview = PREVIEW;
+  const s = w.dxfPreviewSummary;
+  check('summary L × H mm · N entità', s.includes('×') && s.includes('mm') && s.endsWith('2 entità')
+    && /12[,.]30/.test(s) && /5[,.]10/.test(s), s);
+
+  // Risposta tardiva scartata: due scelte di file, la prima risponde per ultima
+  const resolvers = [];
+  global.fetch = () => new Promise(res => resolvers.push(res));
+  global.FormData = class { append() {} };
+  const w2 = dxfRecipeWizard(1, () => 'tok', {});
+  const reply = (body, ok = true) => ({ ok, json: async () => body });
+  w2.dxfFile = { name: 'a.dxf' };
+  const p1 = w2.loadDxfPreview();
+  w2.dxfFile = { name: 'b.dxf' };
+  const p2 = w2.loadDxfPreview();
+  resolvers[1](reply(PREVIEW));
+  await p2;
+  resolvers[0](reply({ ...PREVIEW, entita: 99 }));
+  await p1;
+  check('la risposta vecchia non sovrascrive la nuova', w2.dxfPreview && w2.dxfPreview.entita === 2);
+  check('busy spento', w2.dxfPreviewBusy === false);
+
+  // File tolto: tutto azzerato
+  w2.dxfFile = null;
+  await w2.loadDxfPreview();
+  check('file tolto azzera anteprima ed errore', w2.dxfPreview === null && w2.dxfPreviewError === '');
+
+  // Errore 422 con detail
+  global.fetch = async () => reply({ detail: 'DXF illeggibile: x' }, false);
+  w2.dxfFile = { name: 'c.dxf' };
+  await w2.loadDxfPreview();
+  check('errore col detail', w2.dxfPreviewError === 'DXF illeggibile: x' && w2.dxfPreview === null, w2.dxfPreviewError);
+
+  // #102: anteprima dell'immagine
+  const wi = dxfRecipeWizard(1, () => 'tok', { imageField: 'campo' });
+  check('#102 senza immagine: summary vuoto', wi.imagePreviewSummary === '');
+  global.URL.createObjectURL = () => 'blob:x';
+  global.URL.revokeObjectURL = () => {};
+  wi._setImage({ name: 'a.bmp' }, 'file'); // #104: la scala a mano vale solo per file
+  check('#102 _setImage imposta URL e nome', wi.imagePreviewUrl === 'blob:x' && wi.imageName === 'a.bmp');
+  wi.onImagePreviewLoad({ naturalWidth: 2000, naturalHeight: 1000 });
+  check('#102 senza scala: solo pixel', /2[. ]?000 × 1[. ]?000 px$/.test(wi.imagePreviewSummary), wi.imagePreviewSummary);
+  wi.mmPx = '0,01';
+  check('#102 con mm/px a mano: campo in mm', /px · campo ≈ 20,00 × 10,00 mm$/.test(wi.imagePreviewSummary), wi.imagePreviewSummary);
+  wi.mmPx = ''; wi.calState = 'calibrated'; wi.calPxMm = 100;
+  check('#102 con calibrazione stazione: campo in mm', /campo ≈ 20,00 × 10,00 mm$/.test(wi.imagePreviewSummary), wi.imagePreviewSummary);
+  wi.onImagePreviewError();
+  check('#102 errore <img>: imageBroken e file ancora valido', wi.imageBroken === true && wi.imageFile && wi.imagePx === null);
+  wi._setImage(null);
+  check('#102 _setImage(null) azzera', wi.imagePreviewUrl === '' && wi.imageFile === null && wi.imageName === ''
+    && wi.imagePx === null && wi.imageBroken === false && wi.imagePreviewSummary === '');
+
+  // #104: scala a mano solo per immagini da file
+  const w4 = dxfRecipeWizard(1, () => 'tok', {});
+  w4._setImage({ name: 'a.bmp' }, 'file');
+  w4.mmPx = '0,01406';
+  check('#104 useManualScale vero con file', w4.useManualScale === true);
+  w4._setImage({ name: 'camera.png' }, 'camera');
+  check('#104 useManualScale falso con camera anche se mmPx valido', w4.manualPxMm !== null && w4.useManualScale === false);
+  w4.stationId = '1'; w4.dxfFile = { name: 'd.dxf' };
+  check('#104 canRun con camera richiede la calibrazione', w4.canRun === false);
+  w4.calState = 'calibrated'; w4.calPxMm = 50;
+  check('#104 canRun con camera e stazione calibrata', w4.canRun === true);
+
+  // #104: run() con la camera non invia px_per_mm; con il file si
+  const sent = [];
+  global.FormData = class { append(k, v) { sent.push(k); } };
+  global.fetch = async () => ({ ok: true, json: async () => ({ result: { outputs: {}, overlay: [], outcome: 'pass' } }) });
+  const tick = [];
+  w4.$nextTick = f => tick.push(f);
+  w4.$dispatch = () => {};
+  w4.$refs = {};
+  await w4.run(false);
+  check('#104 run con camera: niente px_per_mm', !sent.includes('px_per_mm') && sent.includes('station_id'), sent.join(','));
+  check('#104 run: tested true e scala = stazione', w4.tested === true && w4.runPxPerMm === 50);
+  sent.length = 0;
+  w4._setImage({ name: 'a.bmp' }, 'file');
+  w4.mmPx = '0,02';
+  await w4.run(false);
+  check('#104 run con file: px_per_mm inviato', sent.includes('px_per_mm') && Math.abs(w4.runPxPerMm - 50) < 1e-9, sent.join(','));
+  check('#104 esito pass', w4.outcome === 'pass' && w4.outcomeClass.includes('emerald'));
+
+  // #104: tested torna false dopo _setImage / onDxf / onStation
+  w4.tested = true; w4._setImage(null);
+  check('#104 tested falso dopo _setImage', w4.tested === false && w4.imageSource === '');
+  w4.tested = true; w4.onDxf({ target: { files: [] } });
+  check('#104 tested falso dopo onDxf', w4.tested === false);
+  w4.tested = true; w4.stationId = ''; await w4.onStation();
+  check('#104 tested falso dopo onStation', w4.tested === false);
+
+  // #104: zoomBy rispetta i limiti 0.05..8
+  const w5 = dxfRecipeWizard(1, () => 'tok', {});
+  w5.$nextTick = f => f();
+  w5.$refs = {};
+  for (let i = 0; i < 40; i++) w5.zoomBy(1.25);
+  check('#104 zoom massimo 8', w5.zoom === 8, String(w5.zoom));
+  for (let i = 0; i < 80; i++) w5.zoomBy(1 / 1.25);
+  check('#104 zoom minimo 0.05', w5.zoom === 0.05, String(w5.zoom));
+  w5.zoom = 1;
+  const vp = { scrollLeft: 100, scrollTop: 50, clientWidth: 200, clientHeight: 100 };
+  w5.$refs = { viewport: vp };
+  w5.zoomBy(2);
+  check('#104 zoomBy tiene il centro', w5.zoom === 2 && vp.scrollLeft === 300 && vp.scrollTop === 150, vp.scrollLeft + ',' + vp.scrollTop);
+  check('#104 zoomPct', w5.zoomPct === '200 %');
+
+  // #104: fit = min(viewport/immagine)
+  w5.$refs = { viewport: { clientWidth: 500, clientHeight: 400, scrollLeft: 9, scrollTop: 9 }, img: { naturalWidth: 2000, naturalHeight: 1000 } };
+  w5.fit();
+  check('#104 fit limitato dalla larghezza', Math.abs(w5.zoom - 0.25) < 1e-9, String(w5.zoom));
+  w5.$refs.img = { naturalWidth: 1000, naturalHeight: 2000 };
+  w5.fit();
+  check('#104 fit limitato dall altezza massima (520 senza window)', Math.abs(w5.zoom - 0.26) < 1e-9, String(w5.zoom));
+  w5.$refs.viewport.clientWidth = 0; w5.zoom = 1; w5.fit();
+  check('#104 fit con viewport nascosto non cambia', w5.zoom === 1);
+
+  // #105: ricetta esistente -> wizard compilato
+  global.File = class { constructor(parts, name, opts) { this.parts = parts; this.name = name; this.type = (opts && opts.type) || ''; } };
+  const SRC = { band_mm: 0.3, min_points_pct: 90, polarity: 'light', px_per_mm: 71.1237, dxf: 'disegno.dxf', image: 'riferimento.bmp' };
+  const blobOf = t => ({ type: t });
+  const mkFetch = (routes, calls) => async (url) => {
+    calls.push(url);
+    for (const k of Object.keys(routes)) if (url.endsWith(k)) return routes[k]();
+    return { ok: false, status: 404, json: async () => ({ error: true }) };
+  };
+  const okJson = body => () => ({ ok: true, json: async () => body });
+  const okBlob = t => () => ({ ok: true, blob: async () => blobOf(t) });
+
+  const w6 = dxfRecipeWizard(8, () => 'tok', { noReferenceImage: 'senza immagine', editLabel: 'Modifica', createLabel: 'Crea' });
+  w6.$nextTick = f => f();
+  const calls6 = [];
+  global.fetch = mkFetch({
+    '/recipe/dxf-compare/source': okJson(SRC),
+    '/recipe/files/disegno.dxf': okBlob('application/dxf'),
+    '/recipe/files/riferimento.bmp': okBlob('image/bmp'),
+    '/dxf-preview': okJson(PREVIEW),
+  }, calls6);
+  global.FormData = class { append() {} };
+  check('#105 senza ricetta: existing null', w6.existing === null);
+  w6.init();
+  await w6._existingReady;
+  check('#105 init legge /source', w6.existing && w6.existing.band_mm === 0.3 && calls6[0] === '/maker/api/vision/tasks/8/recipe/dxf-compare/source', calls6.join(','));
+  await w6.toggle();
+  await w6.openExisting();
+  check('#105 apertura: banda, soglia, polarita', w6.bandMm === 0.3 && w6.minPointsPct === 90 && w6.dark === false);
+  check('#105 mm/px = 1/px_per_mm con virgola', w6.mmPx === '0,01406', w6.mmPx);
+  check('#105 DXF caricato dalla cartella', w6.dxfFile && w6.dxfFile.name === 'disegno.dxf' && w6.dxfFromRecipe === true);
+  await new Promise(r => setTimeout(r, 0)); // l'anteprima parte senza essere attesa
+  check('#105 anteprima DXF richiesta', calls6.some(u => u.endsWith('/dxf-preview')) && w6.dxfPreview !== null);
+  check('#105 immagine con source file: il campo mm/px vale', w6.imageFile && w6.imageFile.name === 'riferimento.bmp'
+    && w6.imageSource === 'file' && w6.imageSrc === 'blob:x');
+  check('#105 info mostrata, nessun avviso', w6.existingInfo === true && w6.existingWarn === '');
+  const nCalls = calls6.length;
+  w6.bandMm = 0.2;
+  await w6.openExisting();
+  check('#105 seconda apertura non ricompila', w6.bandMm === 0.2 && calls6.length === nCalls);
+
+  // #105: ricetta senza immagine salvata -> avviso
+  const w7 = dxfRecipeWizard(8, () => 'tok', { noReferenceImage: 'senza immagine' });
+  global.fetch = mkFetch({
+    '/recipe/dxf-compare/source': okJson({ ...SRC, image: null, px_per_mm: null }),
+    '/recipe/files/disegno.dxf': okBlob('application/dxf'),
+    '/dxf-preview': okJson(PREVIEW),
+  }, []);
+  w7.init(); await w7._existingReady; await w7.openExisting();
+  check('#105 senza immagine: avviso e nessun file', w7.existingWarn === 'senza immagine' && w7.imageFile === null && w7.imageSource === '');
+  check('#105 px_per_mm null: mm/px resta vuoto', w7.mmPx === '');
+
+  // #105: 404 -> existing null, etichetta «Crea»
+  const w8 = dxfRecipeWizard(9, () => 'tok', {});
+  global.fetch = mkFetch({}, []);
+  w8.init(); await w8._existingReady; await w8.openExisting();
+  check('#105 404: existing null e nessuna compilazione', w8.existing === null && w8.existingInfo === false && w8.dxfFile === null);
+
+  // #105: file scelti a mano durante il download della ricetta non si sovrascrivono
+  const w9 = dxfRecipeWizard(8, () => 'tok', {});
+  const gates = {};
+  const gate = k => () => new Promise(res => { gates[k] = () => res({ ok: true, blob: async () => blobOf(k) }); });
+  global.fetch = mkFetch({
+    '/recipe/dxf-compare/source': okJson(SRC),
+    '/recipe/files/disegno.dxf': gate('dxf'),
+    '/recipe/files/riferimento.bmp': gate('bmp'),
+    '/dxf-preview': okJson(PREVIEW),
+  }, []);
+  w9.init(); await w9._existingReady;
+  const pa = w9.openExisting();
+  await new Promise(r => setTimeout(r, 0));
+  w9.onDxf({ target: { files: [{ name: 'mio.dxf' }] } });
+  w9._setImage({ name: 'mia.bmp' }, 'file');
+  gates.dxf(); gates.bmp();
+  await pa;
+  check('#105 DXF scelto a mano non sovrascritto', w9.dxfFile.name === 'mio.dxf' && w9.dxfFromRecipe === false);
+  check('#105 immagine scelta a mano non sovrascritta', w9.imageFile.name === 'mia.bmp');
+
+  // #105: file della ricetta illeggibile -> avviso
+  const w10 = dxfRecipeWizard(8, () => 'tok', { existingFilesFailed: 'illeggibili' });
+  global.fetch = mkFetch({
+    '/recipe/dxf-compare/source': okJson(SRC),
+    '/recipe/files/disegno.dxf': () => ({ ok: false, status: 404 }),
+    '/recipe/files/riferimento.bmp': okBlob('image/bmp'),
+  }, []);
+  w10.init(); await w10._existingReady; await w10.openExisting();
+  check('#105 DXF illeggibile: avviso, immagine comunque caricata', w10.existingWarn === 'illeggibili' && w10.dxfFile === null && w10.imageFile !== null);
+
+  // #105: dopo Salva si rilegge /source e il wizard non si ricompila
+  const w11 = dxfRecipeWizard(8, () => 'tok', {});
+  w11.$nextTick = f => f(); w11.$dispatch = () => {}; w11.$refs = {};
+  w11.stationId = '1'; w11.calState = 'calibrated'; w11.calPxMm = 50;
+  w11.imageFile = { name: 'a.bmp' }; w11.dxfFile = { name: 'd.dxf' };
+  global.FormData = class { append() {} };
+  global.fetch = async (url, opts) => url.endsWith('/source')
+    ? { ok: true, json: async () => SRC }
+    : { ok: true, json: async () => ({ saved: true, result: { outputs: {}, overlay: [], outcome: 'pass' } }) };
+  await w11.run(true);
+  check('#105 dopo Salva: existing letto e non ricompilato', w11.existing && w11.existing.band_mm === 0.3 && w11._existingApplied === true);
+
+  // #104: pan col puntatore
+  const wpan = dxfRecipeWizard(1, () => 'tok', {});
+  const vppan = { scrollLeft: 100, scrollTop: 100, clientWidth: 500, clientHeight: 400, setPointerCapture() {} };
+  wpan.$refs = { viewport: vppan };
+  wpan.onPanDown({ clientX: 200, clientY: 200, pointerId: 1, pointerType: 'mouse', button: 0 });
+  wpan.onPanMove({ clientX: 170, clientY: 180 });
+  check('#104 pan: pointermove (-30,-20) -> scroll +30/+20', vppan.scrollLeft === 130 && vppan.scrollTop === 120, vppan.scrollLeft + ',' + vppan.scrollTop);
+  check('#104 pan: grabbing durante il trascinamento', wpan.panning === true);
+  wpan.onPanEnd();
+  wpan.onPanMove({ clientX: 0, clientY: 0 });
+  check('#104 pan: dopo pointerup non scrolla', vppan.scrollLeft === 130 && wpan.panning === false);
+  wpan.onPanDown({ clientX: 0, clientY: 0, pointerId: 1, pointerType: 'mouse', button: 2 });
+  check('#104 pan: il tasto destro non parte', wpan.panning === false);
+
+  // #104: altezza del viewport
+  global.window = { innerHeight: 1000 }; // max = min(700, 520) = 520
+  wpan.resPx = { w: 2000, h: 1000 };
+  wpan.$refs = { viewport: { clientWidth: 500, scrollLeft: 0, scrollTop: 0 }, img: { naturalWidth: 2000, naturalHeight: 1000 } };
+  wpan.fit(); // zoom = min(500/2000, 520/1000) = 0.25
+  check('#104 fit usa l altezza massima', Math.abs(wpan.zoom - 0.25) < 1e-9 && wpan.fitZoom === wpan.zoom, String(wpan.zoom));
+  check('#104 altezza a Fit = immagine scalata', wpan.vpHeight === 250 && wpan.canPan === false, String(wpan.vpHeight)); // zoomH = 250
+  wpan.resPx = { w: 2000, h: 400 }; // zoomH = 100 -> minimo 200
+  check('#104 altezza minima 200', wpan.vpHeight === 200, String(wpan.vpHeight));
+  wpan.zoom = 1;
+  check('#104 con zoom > Adatta altezza massima e pan attivo', wpan.vpHeight === 520 && wpan.canPan === true && wpan.panCursor === 'grab');
+  global.window = { innerHeight: 500 }; // 70vh = 350
+  check('#104 altezza massima = 70vh se minore di 520', wpan.vpHeight === 350, String(wpan.vpHeight));
+  delete global.window;
+
+  if (failures) { console.log(failures + ' fallimenti'); process.exit(1); }
+  console.log('tutto ok');
+})();

src/frontend/flask_app/tests/test_dxf_preview_js.py

@@ -0,0 +1,35 @@
+"""Runs the plain-node DXF preview behaviour test (tests/js/test_dxf_preview.js).
+
+Same thin pytest wrapper pattern as test_numpad_js.py: shells out to ``node``
+and asserts the script's own exit code. Skips (does not fail) when node is
+not installed.
+
+Covers gitea:Adriano/TieMeasureFlow#101.
+"""
+import shutil
+import subprocess
+from pathlib import Path
+
+import pytest
+
+FLASK_APP_DIR = Path(__file__).resolve().parent.parent
+JS_TEST = Path(__file__).resolve().parent / "js" / "test_dxf_preview.js"
+
+
+def test_dxf_preview_js_behaviour():
+    node = shutil.which("node")
+    if not node:
+        pytest.skip("node non installato: test JS di dxf_recipe_wizard.js saltato")
+
+    result = subprocess.run(
+        [node, str(JS_TEST)],
+        cwd=str(FLASK_APP_DIR),
+        capture_output=True,
+        text=True,
+        timeout=30,
+    )
+
+    assert result.returncode == 0, (
+        f"tests/js/test_dxf_preview.js fallito (exit {result.returncode})\n"
+        f"stdout:\n{result.stdout}\nstderr:\n{result.stderr}"
+    )

src/frontend/flask_app/tests/test_dxf_recipe_routes.py

@@ -178,6 +178,12 @@ class TestDxfCompareProxy:
         assert set(kwargs["files"]) == {"image", "dxf"}
         assert kwargs["files"]["image"][1] == PNG
 
+    def test_manual_px_per_mm_forwarded(self, logged_in_client, mock_api_client):
+        # #98: scala a mano dal wizard (immagine da file): inoltrata al backend
+        mock_api_client.post.return_value = self.OK
+        self._post(logged_in_client, station_id="4", px_per_mm="71.1237")
+        assert mock_api_client.post.call_args.kwargs["data"]["px_per_mm"] == "71.1237"
+
     def test_save_true_forwarded(self, logged_in_client, mock_api_client):
         mock_api_client.post.return_value = {**self.OK, "saved": True, "recipe_dir": "vision/recipes/7/x"}
         resp = self._post(logged_in_client, save="true")
@@ -204,6 +210,122 @@ class TestDxfCompareProxy:
         mock_api_client.post.assert_not_called()
 
 
+class TestDxfPreviewProxy:
+    """#101: anteprima del DXF scelto nel wizard (proxy verso il backend)."""
+    URL = "/maker/api/vision/dxf-preview"
+    OK = {
+        "contorni": [[[0.0, -5.0], [10.0, -5.0], [10.0, 0.0], [0.0, 0.0]]],
+        "bbox": {"xmin": 0.0, "ymin": -5.0, "xmax": 10.0, "ymax": 0.0},
+        "larghezza_mm": 10.0, "altezza_mm": 5.0, "entita": 1, "punti": 4,
+    }
+
+    def _post(self, client, with_file=True):
+        data = {"dxf": (io.BytesIO(b"0\nEOF"), "d.dxf")} if with_file else {}
+        return client.post(self.URL, data=data, content_type="multipart/form-data")
+
+    def test_forwards_file(self, logged_in_client, mock_api_client):
+        mock_api_client.post.return_value = self.OK
+        resp = self._post(logged_in_client)
+        assert resp.status_code == 200
+        assert resp.get_json()["larghezza_mm"] == 10.0
+        args, kwargs = mock_api_client.post.call_args
+        assert args[0] == "/api/vision/dxf-preview"
+        assert set(kwargs["files"]) == {"dxf"}
+        assert kwargs["files"]["dxf"][0] == "d.dxf"
+        assert kwargs["files"]["dxf"][1] == b"0\nEOF"
+
+    def test_missing_file_is_400(self, logged_in_client, mock_api_client):
+        resp = self._post(logged_in_client, with_file=False)
+        assert resp.status_code == 400
+        mock_api_client.post.assert_not_called()
+
+    def test_backend_422_propagates(self, logged_in_client, mock_api_client):
+        mock_api_client.post.return_value = {
+            "error": True, "status_code": 422, "detail": "DXF illeggibile: x"}
+        resp = self._post(logged_in_client)
+        assert resp.status_code == 422
+        assert resp.get_json()["detail"] == "DXF illeggibile: x"
+
+    def test_requires_maker_role(self, logged_in_client, mock_api_client):
+        with logged_in_client.session_transaction() as sess:
+            sess["user"] = {**sess["user"], "roles": ["MeasurementTec"]}
+        assert self._post(logged_in_client).status_code == 403
+        mock_api_client.post.assert_not_called()
+
+
+class TestDxfSourceProxy:
+    """#105: parametri della ricetta DXF gia' salvata (proxy verso il backend)."""
+    URL = "/maker/api/vision/tasks/7/recipe/dxf-compare/source"
+    OK = {"band_mm": 0.3, "min_points_pct": 95.0, "polarity": "dark", "px_per_mm": 71.12,
+          "dxf": "disegno.dxf", "image": "riferimento.bmp"}
+
+    def test_forwards_body(self, logged_in_client, mock_api_client):
+        mock_api_client.get.return_value = self.OK
+        resp = logged_in_client.get(self.URL)
+        assert resp.status_code == 200
+        assert resp.get_json() == self.OK
+        assert mock_api_client.get.call_args.args[0] == "/api/vision/tasks/7/recipe/dxf-compare/source"
+
+    def test_404_propagates(self, logged_in_client, mock_api_client):
+        mock_api_client.get.return_value = {
+            "error": True, "status_code": 404, "detail": "nessuna ricetta da DXF su questo task"}
+        resp = logged_in_client.get(self.URL)
+        assert resp.status_code == 404
+        assert resp.get_json()["detail"] == "nessuna ricetta da DXF su questo task"
+
+    def test_requires_maker_role(self, logged_in_client, mock_api_client):
+        with logged_in_client.session_transaction() as sess:
+            sess["user"] = {**sess["user"], "roles": ["MeasurementTec"]}
+        assert logged_in_client.get(self.URL).status_code == 403
+        mock_api_client.get.assert_not_called()
+
+
+class TestRecipeFileProxy:
+    """#105: file della cartella ricetta (DXF, immagine di riferimento) passati come byte."""
+    URL = "/maker/api/vision/tasks/7/recipe/files/riferimento.bmp"
+    BMP = b"BM 1 fake bmp"
+
+    def _fake_file(self, status=200, content=BMP, ctype="image/bmp"):
+        resp = MagicMock(status_code=status, content=content)
+        resp.headers = {"content-type": ctype}
+        return resp
+
+    def test_bytes_and_content_type_pass_through(self, logged_in_client, mock_api_client):
+        with patch("blueprints.maker.http_requests.get", return_value=self._fake_file()) as get:
+            resp = logged_in_client.get(self.URL)
+        assert resp.status_code == 200
+        assert resp.data == self.BMP
+        assert resp.mimetype == "image/bmp"
+        args, kwargs = get.call_args
+        assert args[0].endswith("/api/vision/tasks/7/recipe/files/riferimento.bmp")
+        assert kwargs["headers"]["X-API-Key"] == "test-api-key-12345"
+
+    def test_backend_404_propagates(self, logged_in_client, mock_api_client):
+        body = b'{"detail":"file non trovato"}'
+        with patch("blueprints.maker.http_requests.get",
+                   return_value=self._fake_file(404, body, "application/json")):
+            resp = logged_in_client.get(self.URL)
+        assert resp.status_code == 404
+        assert resp.get_json()["detail"] == "file non trovato"
+
+    def test_unsafe_path_is_404_without_calling_backend(self, logged_in_client, mock_api_client):
+        with patch("blueprints.maker.http_requests.get") as get:
+            for path in ("a/../../x", "..%5Cx", "%2e%2e/x"):
+                assert logged_in_client.get(f"/maker/api/vision/tasks/7/recipe/files/{path}").status_code == 404
+        get.assert_not_called()
+
+    def test_service_down_is_502(self, logged_in_client, mock_api_client):
+        with patch("blueprints.maker.http_requests.get", side_effect=requests.ConnectionError("giu")):
+            assert logged_in_client.get(self.URL).status_code == 502
+
+    def test_requires_maker_role(self, logged_in_client, mock_api_client):
+        with logged_in_client.session_transaction() as sess:
+            sess["user"] = {**sess["user"], "roles": ["MeasurementTec"]}
+        with patch("blueprints.maker.http_requests.get") as get:
+            assert logged_in_client.get(self.URL).status_code == 403
+        get.assert_not_called()
+
+
 class TestPages:
     def test_stations_page_has_calibration_cell(self, logged_in_client):
         with patch("blueprints.admin.api_client") as admin_api:
@@ -229,4 +351,10 @@ class TestPages:
         assert "js/dxf_recipe_wizard.js" in html
         assert "dxfRecipeWizard(" in html
         assert "@dxf-recipe-saved" in html
+        assert 'x-model="mmPx"' in html  # #98: campo mm/px a mano
+        assert "dxfPreviewD()" in html and "view-box.camel" in html  # #101: anteprima SVG del DXF
+        assert "imageSource === 'file'" in html and "zoomBy(" in html and "fit()" in html  # #104: mm/px solo da file, zoom e Fit
+        assert 'onPanDown($event)' in html  # #104: pan col puntatore
+        assert "imagePreviewUrl" in html and "imagePreviewSummary" in html  # #102: anteprima immagine
+        assert "existing ? msgs.editLabel : msgs.createLabel" in html and "Modifica ricetta da DXF" in html  # #105: etichetta dinamica
         assert "Pezzo scuro su fondo chiaro" in html or "Dark part on light" in html

src/frontend/flask_app/tests/test_measure_vision_check.py

@@ -0,0 +1,182 @@
+"""gitea:Adriano/TieMeasureFlow#97 - operator: image already analysed on entry.
+
+The backend (POST /api/vision/check, task.acquisition_json) is built elsewhere:
+api_client and requests are mocked here with the contract's shapes.
+"""
+import io
+import json
+from unittest.mock import MagicMock, patch
+
+from tests.conftest import api_get_router
+from tests.test_measure_camera_grab import (
+    PNG, RECIPE, STATION, TASK, _fake, _station,
+)
+
+ACQ = {"camera_url": "http://acq-host:9000", "camera_source": "camera:601020", "modo": "in_linea"}
+
+
+def _task_with(acq):
+    return {**TASK, "acquisition_json": acq}
+
+
+# --- grab: the camera of the task, else the station's -------------------------
+def test_grab_with_task_id_uses_task_camera(logged_in_client, mock_api_client, monkeypatch):
+    _station(mock_api_client, monkeypatch, STATION)
+    mock_api_client.get.side_effect = api_get_router({"/api/tasks/12": _task_with(ACQ)})
+    with patch("blueprints.measure.http_requests.post", return_value=_fake()) as post:
+        resp = logged_in_client.post("/measure/api/vision/grab", data={"task_id": "12"})
+    assert resp.status_code == 200 and resp.data == PNG
+    args, kwargs = post.call_args
+    assert args[0] == "http://acq-host:9000/camera/grab"
+    assert kwargs["json"]["source"] == "camera:601020"
+    mock_api_client.get_station_by_code.assert_not_called()
+
+
+def test_grab_task_id_in_json_works_too(logged_in_client, mock_api_client, monkeypatch):
+    _station(mock_api_client, monkeypatch, STATION)
+    mock_api_client.get.side_effect = api_get_router({"/api/tasks/12": _task_with(ACQ)})
+    with patch("blueprints.measure.http_requests.post", return_value=_fake()) as post:
+        resp = logged_in_client.post("/measure/api/vision/grab", json={"task_id": 12})
+    assert resp.status_code == 200
+    assert post.call_args[0][0] == "http://acq-host:9000/camera/grab"
+
+
+def test_grab_task_without_acquisition_uses_station(logged_in_client, mock_api_client, monkeypatch):
+    _station(mock_api_client, monkeypatch, STATION)
+    mock_api_client.get.side_effect = api_get_router({"/api/tasks/12": _task_with(None)})
+    with patch("blueprints.measure.http_requests.post", return_value=_fake()) as post:
+        resp = logged_in_client.post("/measure/api/vision/grab", data={"task_id": "12"})
+    assert resp.status_code == 200
+    args, kwargs = post.call_args
+    assert args[0] == "http://host.docker.internal:8765/camera/grab"
+    assert kwargs["json"]["source"] == "camera:folder"
+
+
+def test_grab_task_camera_wins_even_if_station_has_none(logged_in_client, mock_api_client, monkeypatch):
+    _station(mock_api_client, monkeypatch, {**STATION, "camera_url": None})
+    mock_api_client.get.side_effect = api_get_router({"/api/tasks/12": _task_with(ACQ)})
+    with patch("blueprints.measure.http_requests.post", return_value=_fake()) as post:
+        resp = logged_in_client.post("/measure/api/vision/grab", data={"task_id": "12"})
+    assert resp.status_code == 200
+    assert post.call_args[0][0] == "http://acq-host:9000/camera/grab"
+
+
+def test_grab_task_lookup_error_falls_back_to_station(logged_in_client, mock_api_client, monkeypatch):
+    _station(mock_api_client, monkeypatch, STATION)
+    mock_api_client.get.side_effect = api_get_router(
+        {"/api/tasks/12": {"error": True, "status_code": 404, "detail": "x"}})
+    with patch("blueprints.measure.http_requests.post", return_value=_fake()) as post:
+        resp = logged_in_client.post("/measure/api/vision/grab", data={"task_id": "12"})
+    assert resp.status_code == 200
+    assert post.call_args[0][0] == "http://host.docker.internal:8765/camera/grab"
+
+
+def test_grab_acquisition_as_json_string(logged_in_client, mock_api_client, monkeypatch):
+    _station(mock_api_client, monkeypatch, {**STATION, "camera_url": None})
+    mock_api_client.get.side_effect = api_get_router(
+        {"/api/tasks/12": _task_with(json.dumps(ACQ))})
+    with patch("blueprints.measure.http_requests.post", return_value=_fake()) as post:
+        resp = logged_in_client.post("/measure/api/vision/grab", data={"task_id": "12"})
+    assert resp.status_code == 200
+    assert post.call_args[0][0] == "http://acq-host:9000/camera/grab"
+
+
+# --- check proxy ---------------------------------------------------------------
+CHECK_OK = {
+    "outcome": "ok", "overlay": [], "failures": [], "calibration": "ok",
+    "measurements": [{"subtask_id": 1, "value": 9.9, "pass_fail": "pass"}],
+}
+
+
+def test_check_proxy_forwards_multipart(logged_in_client, mock_api_client):
+    mock_api_client.post.return_value = CHECK_OK
+    resp = logged_in_client.post(
+        "/measure/api/vision/check",
+        data={
+            "task_id": "12", "production_run_id": "4",
+            "image": (io.BytesIO(b"\xff\xd8\xff fake"), "shot.jpg", "image/jpeg"),
+        },
+        content_type="multipart/form-data",
+    )
+    assert resp.status_code == 200
+    assert resp.get_json()["measurements"][0]["pass_fail"] == "pass"
+    args, kwargs = mock_api_client.post.call_args
+    assert args[0] == "/api/vision/check"
+    assert kwargs["data"] == {"task_id": "12", "production_run_id": "4"}
+    name, content, mime = kwargs["files"]["image"]
+    assert name == "shot.jpg" and mime == "image/jpeg" and content.startswith(b"\xff\xd8")
+
+
+def test_check_proxy_without_run_leaves_it_out(logged_in_client, mock_api_client):
+    mock_api_client.post.return_value = CHECK_OK
+    logged_in_client.post(
+        "/measure/api/vision/check",
+        data={"task_id": "12", "image": (io.BytesIO(b"x"), "a.jpg", "image/jpeg")},
+        content_type="multipart/form-data",
+    )
+    assert mock_api_client.post.call_args[1]["data"] == {"task_id": "12"}
+
+
+def test_check_proxy_requires_image(logged_in_client, mock_api_client):
+    resp = logged_in_client.post("/measure/api/vision/check", data={"task_id": "12"})
+    assert resp.status_code == 400
+    mock_api_client.post.assert_not_called()
+
+
+def test_check_proxy_relays_backend_error(logged_in_client, mock_api_client):
+    mock_api_client.post.return_value = {"error": True, "status_code": 422, "detail": "nessun grafo"}
+    resp = logged_in_client.post(
+        "/measure/api/vision/check",
+        data={"task_id": "12", "image": (io.BytesIO(b"x"), "a.jpg", "image/jpeg")},
+        content_type="multipart/form-data",
+    )
+    assert resp.status_code == 422
+    assert resp.get_json()["detail"] == "nessun grafo"
+
+
+def test_check_requires_login(client):
+    resp = client.post("/measure/api/vision/check")
+    assert resp.status_code in (302, 401)
+
+
+# --- execute page: buttons and config -------------------------------------------
+def _page(logged_in_client, mock_api_client, monkeypatch, station, task):
+    _station(mock_api_client, monkeypatch, station)
+    mock_api_client.get_station_recipes.return_value = {"items": [{"id": 3}]}
+    mock_api_client.get.side_effect = api_get_router({
+        "/api/tasks/12": task,
+        "/api/recipes/3/tasks": [{"id": 12, "order_index": 0}],
+        "/api/recipes/3": RECIPE,
+    })
+    return logged_in_client.get("/measure/execute/12").get_data(as_text=True)
+
+
+def test_page_impulsive_has_acquire_and_record(logged_in_client, mock_api_client, monkeypatch):
+    html = _page(logged_in_client, mock_api_client, monkeypatch, STATION, TASK)
+    assert 'cameraAvailable: true' in html
+    assert 'modo: "impulsiva"' in html
+    assert "/measure/api/vision/check" in html
+    assert "grab()" in html and "record()" in html
+    assert "togglePause()" not in html
+    assert "Anteprima, non registrata" in html
+
+
+def test_page_in_line_has_pause_and_record(logged_in_client, mock_api_client, monkeypatch):
+    html = _page(logged_in_client, mock_api_client, monkeypatch, STATION, _task_with(ACQ))
+    assert 'modo: "in_linea"' in html
+    assert "togglePause()" in html and "record()" in html
+    assert "grab()" not in html  # the loop grabs by itself
+
+
+def test_page_task_camera_enables_it_without_station_camera(logged_in_client, mock_api_client, monkeypatch):
+    html = _page(logged_in_client, mock_api_client, monkeypatch,
+                 {**STATION, "camera_url": None}, _task_with({**ACQ, "modo": "impulsiva"}))
+    assert 'cameraAvailable: true' in html
+    assert "grab()" in html
+
+
+def test_page_without_camera_is_as_before(logged_in_client, mock_api_client, monkeypatch):
+    html = _page(logged_in_client, mock_api_client, monkeypatch,
+                 {**STATION, "camera_url": None}, TASK)
+    assert 'cameraAvailable: false' in html
+    assert "record()" not in html and "togglePause()" not in html and "grab()" not in html

src/frontend/flask_app/tests/test_statistics.py

@@ -167,3 +167,11 @@ class TestRunTaskResultsProxy:
         assert 'id="run-task-results"' in html
         assert "loadTaskResults" in html
         assert "/statistics/api/runs/" in html
+
+    def test_dashboard_all_points_overview(self, logged_in_client, mock_api_client):
+        # #100: con «Tutti i punti» la pagina ha tabella per-punto e select che ricarica da solo
+        mock_api_client.get.return_value = {"items": [], "total": 0, "pages": 1}
+        html = logged_in_client.get("/statistics/dashboard").get_data(as_text=True)
+        assert "capabilityAll" in html
+        assert "loadedSubtaskId" in html
+        assert '@change="loadData()"' in html

src/frontend/flask_app/tests/test_vision_panel_fit.py

@@ -0,0 +1,54 @@
+"""gitea:Adriano/TieMeasureFlow#96 - l'immagine del task visione sta in fit, senza scorrimento.
+
+Controllo sulle classi del template: pannello overflow-hidden, img/canvas
+object-contain sovrapposti, nessun h-auto sull'immagine (era la causa dello scorrimento).
+"""
+from pathlib import Path
+
+TEMPLATE = Path(__file__).resolve().parents[1] / "templates" / "measure" / "task_execute.html"
+
+
+def _panel():
+    src = TEMPLATE.read_text(encoding="utf-8")
+    start = src.rindex("<div", 0, src.index('x-data="visionExecute()"'))
+    end = src.index("MEASUREMENT TIMER BANNER")
+    return src[start:end]
+
+
+def _tag_with(panel, marker):
+    # Il tag (aperto) che contiene il marker; i '>' dentro le virgolette (es. "=>") non lo chiudono.
+    pos = panel.index(marker)
+    i = panel.rindex("<", 0, pos)
+    quote = None
+    for j in range(i, len(panel)):
+        c = panel[j]
+        if quote:
+            quote = None if c == quote else quote
+        elif c in "\"'":
+            quote = c
+        elif c == ">":
+            return panel[i:j + 1]
+    raise AssertionError(marker)
+
+
+def test_panel_does_not_scroll():
+    tag = _tag_with(_panel(), 'x-data="visionExecute()"')
+    assert "overflow-hidden" in tag and "min-h-0" in tag
+    assert "overflow-auto" not in tag
+
+
+def test_image_is_object_contain_without_h_auto():
+    panel = _panel()
+    img = _tag_with(panel, 'x-ref="img"')
+    assert "object-contain" in img
+    assert "h-auto" not in img
+    canvas = _tag_with(panel, 'x-ref="overlay"')
+    assert "object-contain" in canvas  # stesso fit dell'img: overlay allineato
+
+
+def test_image_box_and_outcome_column_can_shrink():
+    panel = _panel()
+    box = _tag_with(panel, 'x-show="shownImage"')
+    assert "flex-1" in box and "min-h-0" in box
+    outcome = _tag_with(panel, 'x-show="result">')
+    assert "overflow-y-auto" in outcome and "min-h-0" in outcome

src/frontend/flask_app/translations/en/LC_MESSAGES/messages.po

@@ -3485,3 +3485,102 @@ msgstr "Invalid camera address"
 #: templates/admin/stations.html blueprints/admin.py (#88)
 msgid "Risposta non valida dal servizio camera"
 msgstr "Invalid response from the camera service"
+
+#: templates/statistics/dashboard.html (#100)
+msgid "Scegli un punto per carta di controllo e istogramma"
+msgstr "Choose a point for the control chart and histogram"
+
+#: templates/maker/task_editor.html blueprints/maker.py (#101)
+msgid "Serve il file DXF"
+msgstr "The DXF file is required"
+
+msgid "Lettura DXF…"
+msgstr "Reading DXF…"
+
+msgid "entità"
+msgstr "entities"
+
+#: templates/maker/task_editor.html (#102)
+msgid "campo"
+msgstr "field"
+
+#: templates/maker/task_editor.html (#102)
+msgid "Anteprima non disponibile per questo formato"
+msgstr "Preview not available for this format"
+
+#: templates/maker/task_editor.html (#104)
+msgid "Riduci"
+msgstr "Zoom out"
+
+#: templates/maker/task_editor.html (#104)
+msgid "Ingrandisci"
+msgstr "Zoom in"
+
+#: templates/maker/task_editor.html (#104)
+msgid "Adatta"
+msgstr "Fit"
+
+#: templates/maker/task_editor.html (#104)
+msgid "Scala"
+msgstr "Scale"
+
+#: templates/maker/task_editor.html (#104)
+msgid "Punti in banda"
+msgstr "Points in band"
+
+#: templates/maker/task_editor.html (#104)
+msgid "Distanza media"
+msgstr "Average distance"
+
+#: templates/maker/task_editor.html (#104)
+msgid "Distanza minima"
+msgstr "Minimum distance"
+
+#: templates/maker/task_editor.html (#104)
+msgid "Distanza massima"
+msgstr "Maximum distance"
+
+#: templates/maker/task_editor.html (#104)
+msgid "Conforme"
+msgstr "Pass"
+
+#: templates/maker/task_editor.html (#104)
+msgid "Con avvisi"
+msgstr "Warning"
+
+#: templates/maker/task_editor.html (#104)
+msgid "Non conforme"
+msgstr "Fail"
+
+#: templates/maker/task_editor.html (#104)
+msgid "mm/px a mano"
+msgstr "manual mm/px"
+
+#: templates/maker/task_editor.html (#104)
+msgid "calibrazione stazione"
+msgstr "station calibration"
+
+#: templates/maker/task_editor.html blueprints/maker.py (#105)
+msgid "Modifica ricetta da DXF"
+msgstr "Edit recipe from DXF"
+
+#: templates/maker/task_editor.html blueprints/maker.py (#105)
+msgid "Immagine di riferimento non salvata (ricetta creata prima): acquisiscila o caricala"
+msgstr "Reference image not saved (recipe created earlier): capture or upload it"
+
+#: templates/maker/task_editor.html blueprints/maker.py (#105)
+msgid "Impossibile leggere i file della ricetta esistente"
+msgstr "Cannot read the files of the existing recipe"
+
+#: templates/maker/task_editor.html blueprints/maker.py (#105)
+msgid "Ricetta esistente caricata: Prova e poi Salva ricetta per sostituirla"
+msgstr "Existing recipe loaded: Test, then Save recipe to replace it"
+
+#: templates/maker/task_editor.html blueprints/maker.py (#105)
+msgid "File non trovato"
+msgstr "File not found"
+
+#: templates/maker/task_editor.html blueprints/maker.py (#105)
+#, python-format
+msgid "Servizio non raggiungibile: %(detail)s"
+msgstr "Service not reachable: %(detail)s"

src/frontend/flask_app/translations/it/LC_MESSAGES/messages.po

@@ -3473,3 +3473,98 @@ msgstr "Indirizzo della camera non valido"
 #: templates/admin/stations.html blueprints/admin.py (#88)
 msgid "Risposta non valida dal servizio camera"
 msgstr "Risposta non valida dal servizio camera"
+
+#: templates/maker/task_editor.html blueprints/maker.py (#101)
+msgid "Serve il file DXF"
+msgstr "Serve il file DXF"
+
+msgid "Lettura DXF…"
+msgstr "Lettura DXF…"
+
+msgid "entità"
+msgstr "entità"
+
+#: templates/maker/task_editor.html (#102)
+msgid "campo"
+msgstr "campo"
+
+#: templates/maker/task_editor.html (#102)
+msgid "Anteprima non disponibile per questo formato"
+msgstr "Anteprima non disponibile per questo formato"
+
+#: templates/maker/task_editor.html (#104)
+msgid "Riduci"
+msgstr "Riduci"
+
+#: templates/maker/task_editor.html (#104)
+msgid "Ingrandisci"
+msgstr "Ingrandisci"
+
+#: templates/maker/task_editor.html (#104)
+msgid "Adatta"
+msgstr "Adatta"
+
+#: templates/maker/task_editor.html (#104)
+msgid "Scala"
+msgstr "Scala"
+
+#: templates/maker/task_editor.html (#104)
+msgid "Punti in banda"
+msgstr "Punti in banda"
+
+#: templates/maker/task_editor.html (#104)
+msgid "Distanza media"
+msgstr "Distanza media"
+
+#: templates/maker/task_editor.html (#104)
+msgid "Distanza minima"
+msgstr "Distanza minima"
+
+#: templates/maker/task_editor.html (#104)
+msgid "Distanza massima"
+msgstr "Distanza massima"
+
+#: templates/maker/task_editor.html (#104)
+msgid "Conforme"
+msgstr "Conforme"
+
+#: templates/maker/task_editor.html (#104)
+msgid "Con avvisi"
+msgstr "Con avvisi"
+
+#: templates/maker/task_editor.html (#104)
+msgid "Non conforme"
+msgstr "Non conforme"
+
+#: templates/maker/task_editor.html (#104)
+msgid "mm/px a mano"
+msgstr "mm/px a mano"
+
+#: templates/maker/task_editor.html (#104)
+msgid "calibrazione stazione"
+msgstr "calibrazione stazione"
+
+#: templates/maker/task_editor.html blueprints/maker.py (#105)
+msgid "Modifica ricetta da DXF"
+msgstr "Modifica ricetta da DXF"
+
+#: templates/maker/task_editor.html blueprints/maker.py (#105)
+msgid "Immagine di riferimento non salvata (ricetta creata prima): acquisiscila o caricala"
+msgstr "Immagine di riferimento non salvata (ricetta creata prima): acquisiscila o caricala"
+
+#: templates/maker/task_editor.html blueprints/maker.py (#105)
+msgid "Impossibile leggere i file della ricetta esistente"
+msgstr "Impossibile leggere i file della ricetta esistente"
+
+#: templates/maker/task_editor.html blueprints/maker.py (#105)
+msgid "Ricetta esistente caricata: Prova e poi Salva ricetta per sostituirla"
+msgstr "Ricetta esistente caricata: Prova e poi Salva ricetta per sostituirla"
+
+#: templates/maker/task_editor.html blueprints/maker.py (#105)
+msgid "File non trovato"
+msgstr "File non trovato"
+
+#: templates/maker/task_editor.html blueprints/maker.py (#105)
+#, python-format
+msgid "Servizio non raggiungibile: %(detail)s"
+msgstr "Servizio non raggiungibile: %(detail)s"

src/vision/costruttori.py

@@ -184,6 +184,66 @@ def _candidate_anchors(gray: np.ndarray, dxf_path: Path, px_per_mm: float,
     return anchors
 
 
+def chiudi_contorni(dxf_bytes: bytes) -> tuple[bytes, dict]:
+    """#103: unisce le entita' aperte (LINE/ARC/polilinee aperte in fila) in contorni chiusi.
+
+    CompareDxf taglia il contorno misurato agli estremi di ogni entita' aperta
+    del disegno (cut_open_ends): con un profilo spezzato in LINE+ARC e banda
+    larga non resta nessun punto in banda e il confronto fallisce. Qui le catene
+    chiuse diventano una LWPOLYLINE chiusa (con bulge per gli archi).
+
+    Pura e senza eccezioni nuove: se non c'e' nulla da unire, o ezdxf non legge
+    il file, ritorna i byte originali (sha invariato, ricette esistenti stabili).
+    Ritorna (bytes, {"anelli", "entita_unite", "entita_libere"}).
+    """
+    nulla = {"anelli": 0, "entita_unite": 0, "entita_libere": 0}
+    try:
+        import ezdxf
+        from ezdxf import edgeminer as em, edgesmith as es
+
+        with tempfile.TemporaryDirectory() as tmp:
+            src = Path(tmp) / "in.dxf"
+            src.write_bytes(dxf_bytes)
+            doc = ezdxf.readfile(str(src))
+            msp = doc.modelspace()
+            # edges_from_entities_2d salta le entita' gia' chiuse (restano dove sono)
+            edges = list(es.edges_from_entities_2d(msp))
+            if not edges:
+                return dxf_bytes, nulla
+            loops = em.find_all_loops(em.Deposit(edges, gap_tol=0.01))  # 0.01 mm: giunzioni CAD
+            usati: set = set()
+            unite: list = []  # (polilinea, entita' di partenza)
+            # loop piu' lungo per primo, ogni edge usato una sola volta
+            for loop in sorted(loops, key=lambda lp: -sum(e.length for e in lp)):
+                ids = {e.id for e in loop}
+                if ids & usati:
+                    continue
+                usati |= ids
+                unite.append((loop, es.lwpolyline_from_chain(loop)))
+            if not unite:
+                return dxf_bytes, {**nulla, "entita_libere": len(edges)}
+            entita_unite = 0
+            for loop, pl in unite:
+                pl.closed = True
+                payload = getattr(loop[0], "payload", None)
+                layer = getattr(getattr(payload, "dxf", None), "layer", None)
+                if layer:
+                    pl.dxf.layer = layer  # stesso layer dell'entita' di partenza
+                for e in loop:
+                    ent = getattr(e, "payload", None)
+                    if ent is not None and ent.is_alive:
+                        msp.delete_entity(ent)  # sostituita dalla polilinea chiusa
+                msp.add_foreign_entity(pl)
+                entita_unite += len(loop)
+            dst = Path(tmp) / "out.dxf"
+            doc.saveas(str(dst))
+            info = {"anelli": len(unite), "entita_unite": entita_unite,
+                    "entita_libere": len(edges) - entita_unite}
+            return dst.read_bytes(), info
+    except Exception:  # noqa: BLE001 - DXF illeggibile: l'errore resta quello a valle
+        return dxf_bytes, nulla
+
+
 def _run(gray, graph, px_per_mm, folder) -> RunOutcome:
     return run_graph(gray, graph, calibration={"px_per_mm": px_per_mm}, recipe_dir=folder)
 
@@ -211,6 +271,9 @@ def build_dxf_compare(
         raise CostruttoreError(f"polarity deve essere una di {list(_POLARITIES)}")
     if not dxf_bytes:
         raise CostruttoreError("DXF vuoto")
+    # #103: entita' aperte unite in contorni chiusi PRIMA dello sha: disegno.dxf,
+    # grafo e runtime usano tutti il DXF chiuso
+    dxf_bytes, _info_chiusura = chiudi_contorni(dxf_bytes)
 
     frame = _gray_u8(gray)
     calibration_bytes = json.dumps({"px_per_mm": px_per_mm}).encode("utf-8")

src/vision_worker/main.py

@@ -11,13 +11,14 @@ import io
 import json
 import os
 import re
+import tempfile  # #101
 from pathlib import Path
 
 import numpy as np
 from fastapi import FastAPI, File, Form, HTTPException, UploadFile, status
 from PIL import Image, UnidentifiedImageError
 
-from src.vision.costruttori import CostruttoreError, build_dxf_compare  # #83
+from src.vision.costruttori import CostruttoreError, build_dxf_compare, chiudi_contorni  # #83 #103
 from src.vision.runner import (
     GraphBuildError,
     RunOutcome,
@@ -288,3 +289,91 @@ async def recipes_dxf_compare(
                 status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
                 detail=f"recipe build failed: {type(exc).__name__}: {exc}",
             ) from exc
+
+
+# #101: tetto ai punti dell'anteprima DXF (un profilo fitto non deve gonfiare
+# la risposta ne' rallentare il disegno SVG nel browser).
+_PREVIEW_MAX_POINTS = 20000
+
+
+def _decimate(points: list[list[float]], keep: int) -> list[list[float]]:
+    """Decimazione uniforme a `keep` punti (>= 2), primo e ultimo sempre inclusi."""
+    n = len(points)
+    if n <= keep or keep < 2:
+        return points
+    idx = sorted({round(i * (n - 1) / (keep - 1)) for i in range(keep)})
+    return [points[i] for i in idx]
+
+
+def _dxf_preview(dxf_bytes: bytes) -> dict:
+    """#101: legge il DXF con lo stesso lettore di CompareDxf (read_xld_dxf) e ne
+    ritorna i contorni in mm, asse y verso il basso (come immagine e SVG).
+
+    Funzione sincrona e pura: la rotta la esegue in un thread. Solleva
+    CostruttoreError per DXF vuoto, illeggibile o senza geometria.
+    """
+    if not dxf_bytes:
+        raise CostruttoreError("DXF illeggibile: file vuoto")
+    from visionsuite.io.dxf import read_xld_dxf
+    # #103: l'anteprima mostra cio' che il confronto usera' (contorni chiusi)
+    dxf_bytes, _ = chiudi_contorni(dxf_bytes)
+    with tempfile.TemporaryDirectory() as tmp:
+        path = Path(tmp) / "disegno.dxf"
+        path.write_bytes(dxf_bytes)
+        try:
+            # flip_y=False + scale=1: coordinate native del DXF, in mm; il
+            # ribaltamento dell'asse y lo facciamo noi sotto (y = -y_dxf)
+            conts = list(read_xld_dxf(str(path), sampling_distance=0.05,
+                                      scale=1.0, flip_y=False))
+        except Exception as exc:  # noqa: BLE001 - qualunque errore di lettura = DXF illeggibile
+            raise CostruttoreError(f"DXF illeggibile: {type(exc).__name__}: {exc}") from exc
+
+    contorni: list[list[list[float]]] = []
+    for cont in conts:
+        pts = np.asarray(cont.points, dtype=float)  # (riga, colonna) = (y_dxf, x_dxf)
+        if pts.ndim != 2 or pts.shape[0] < 2:
+            continue
+        line = [[float(c), float(-r)] for r, c in pts]
+        if cont.closed and line[0] != line[-1]:
+            line.append(list(line[0]))  # chiude il giro anche nella polilinea SVG
+        contorni.append(line)
+    if not contorni:
+        raise CostruttoreError("DXF senza geometria")
+
+    # #101: le dimensioni si misurano sui punti completi, prima della decimazione
+    xs = [p[0] for c in contorni for p in c]
+    ys = [p[1] for c in contorni for p in c]
+    xmin, xmax, ymin, ymax = min(xs), max(xs), min(ys), max(ys)
+
+    total = len(xs)
+    if total > _PREVIEW_MAX_POINTS:
+        # quota per contorno proporzionale, minimo 2 punti
+        contorni = [
+            _decimate(c, max(2, int(len(c) * _PREVIEW_MAX_POINTS / total))) for c in contorni
+        ]
+    contorni = [[[round(x, 3), round(y, 3)] for x, y in c] for c in contorni]
+    xmin, xmax, ymin, ymax = (round(v, 3) for v in (xmin, xmax, ymin, ymax))
+    return {
+        "contorni": contorni,
+        "bbox": {"xmin": xmin, "ymin": ymin, "xmax": xmax, "ymax": ymax},
+        "larghezza_mm": round(xmax - xmin, 3),
+        "altezza_mm": round(ymax - ymin, 3),
+        "entita": len(contorni),
+        "punti": sum(len(c) for c in contorni),
+    }
+
+
+@app.post("/dxf/preview")
+async def dxf_preview(dxf: UploadFile = File(...)) -> dict:
+    """#101: anteprima del disegno DXF (contorni + dimensioni in mm) per il
+    wizard «Crea ricetta da DXF». Solo lettura, leggera: nessun run slot."""
+    dxf_bytes = await dxf.read()
+    try:
+        return await asyncio.to_thread(_dxf_preview, dxf_bytes)
+    except CostruttoreError as exc:
+        raise _unprocessable(str(exc)) from exc
+    except Exception as exc:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"dxf preview failed: {type(exc).__name__}: {exc}",
+        ) from exc

src/vision_worker/tests/test_chiudi_contorni.py

@@ -0,0 +1,101 @@
+"""#103: chiudi_contorni unisce LINE/ARC aperti in contorni chiusi (test sincroni, no pytest-asyncio)."""
+import hashlib
+import io
+import tempfile
+from pathlib import Path
+
+import cv2
+import ezdxf
+import numpy as np
+import pytest
+
+from src.vision.costruttori import CostruttoreError, build_dxf_compare, chiudi_contorni
+from src.vision_worker.main import _dxf_preview
+
+
+def _dxf(riempi) -> bytes:
+    doc = ezdxf.new("R2010")
+    riempi(doc.modelspace())
+    buf = io.StringIO()
+    doc.write(buf)
+    return buf.getvalue().encode("utf-8")
+
+
+def _quattro_line(msp, w=20.0, h=10.0):
+    pts = [(0, 0), (w, 0), (w, h), (0, h)]
+    for i in range(4):
+        msp.add_line(pts[i], pts[(i + 1) % 4])
+
+
+def _entita(dxf: bytes):
+    with tempfile.TemporaryDirectory() as tmp:  # readfile gestisce da solo codifica e CRLF
+        path = Path(tmp) / "o.dxf"
+        path.write_bytes(dxf)
+        return list(ezdxf.readfile(str(path)).modelspace())
+
+
+def test_chiudi_rettangolo_di_4_line_in_una_polilinea_chiusa():
+    out, info = chiudi_contorni(_dxf(_quattro_line))
+    assert info == {"anelli": 1, "entita_unite": 4, "entita_libere": 0}
+    ents = _entita(out)
+    assert [e.dxftype() for e in ents] == ["LWPOLYLINE"] and ents[0].closed
+    xs = [p[0] for p in ents[0].get_points()]
+    ys = [p[1] for p in ents[0].get_points()]
+    assert (min(xs), max(xs), min(ys), max(ys)) == (0, 20, 0, 10)  # bbox invariato
+
+
+def test_chiudi_asola_line_e_arc_ha_bulge():
+    def asola(msp):  # asola 20x10: due LINE orizzontali + due semicerchi r=5
+        msp.add_line((5, 0), (15, 0))
+        msp.add_arc((15, 5), 5, -90, 90)
+        msp.add_line((15, 10), (5, 10))
+        msp.add_arc((5, 5), 5, 90, 270)
+    out, info = chiudi_contorni(_dxf(asola))
+    assert info["anelli"] == 1 and info["entita_unite"] == 4
+    ents = _entita(out)
+    assert len(ents) == 1 and ents[0].closed
+    assert any(abs(p[4]) > 1e-6 for p in ents[0].get_points())  # gli archi diventano bulge
+
+
+def test_dxf_gia_chiuso_resta_identico():
+    def chiuso(msp):
+        msp.add_lwpolyline([(0, 0), (20, 0), (20, 10), (0, 10)], close=True)
+        msp.add_circle((10, 5), 2)
+    dxf = _dxf(chiuso)
+    out, info = chiudi_contorni(dxf)
+    assert out == dxf and info["anelli"] == 0
+
+
+def test_line_isolata_resta_e_byte_identici():
+    dxf = _dxf(lambda msp: msp.add_line((0, 0), (10, 0)))
+    out, info = chiudi_contorni(dxf)
+    assert out == dxf and info["anelli"] == 0 and info["entita_libere"] == 1
+
+
+def test_byte_non_dxf_ritornati_identici():
+    brutto = b"questo non e' un dxf"
+    out, info = chiudi_contorni(brutto)
+    assert out == brutto and info["anelli"] == 0
+
+
+def test_preview_di_quattro_line_e_una_sola_entita():
+    resp = _dxf_preview(_dxf(_quattro_line))
+    assert resp["entita"] == 1 and resp["larghezza_mm"] == 20 and resp["altezza_mm"] == 10
+
+
+@pytest.mark.parametrize("band", [0.1, 0.3])
+def test_chiudi_build_dxf_compare_banda_larga_con_4_line(band):
+    # rettangolo scuro 20x10 mm su bianco, 20 px/mm; disegno = 4 LINE aperte
+    ppm = 20.0
+    img = np.full((int(40 * ppm), int(60 * ppm)), 255, np.uint8)
+    cx, cy = img.shape[1] // 2, img.shape[0] // 2
+    cv2.rectangle(img, (cx - int(10 * ppm), cy - int(5 * ppm)),
+                  (cx + int(10 * ppm), cy + int(5 * ppm)), 0, -1)
+    dxf = _dxf(_quattro_line)
+    ris = build_dxf_compare(img, dxf, px_per_mm=ppm, band_mm=band)
+    assert ris["outputs"]["dxf.points_in_pct"] > 90.0
+    # il disegno nella ricetta e' quello chiuso, non l'originale
+    import base64
+    salvato = base64.b64decode(ris["files"]["disegno.dxf"])
+    assert salvato != dxf and hashlib.sha256(salvato).hexdigest() == \
+        ris["graph"]["meta"]["dxf"]["disegno"]["sha256"]

src/vision_worker/tests/test_dxf_compare.py

@@ -80,3 +80,67 @@ async def test_dxf_compare_immagine_non_decodificabile_e_422():
 async def test_dxf_compare_parametro_fuori_range_e_422():
     response = await _post(_png(a_scene(0.0)), SAMPLE_DXF.read_bytes(), polarity="grigio")
     assert response.status_code == 422
+
+
+# --- #101: POST /dxf/preview ---------------------------------------------------
+
+def _rect_dxf(width: float, height: float, y0: float = 3.0) -> bytes:
+    """DXF minimo con ezdxf: un rettangolo chiuso, y in alto rispetto a 0."""
+    import ezdxf
+    doc = ezdxf.new()
+    doc.modelspace().add_lwpolyline(
+        [(1, y0), (1 + width, y0), (1 + width, y0 + height), (1, y0 + height)], close=True,
+    )
+    buffer = io.StringIO()
+    doc.write(buffer)
+    return buffer.getvalue().encode("utf-8")
+
+
+def _post_preview(dxf: bytes):
+    # TestClient sincrono: non serve pytest-asyncio (assente nel venv del worker)
+    from fastapi.testclient import TestClient
+    return TestClient(app).post(
+        "/dxf/preview", files={"dxf": ("d.dxf", dxf, "application/octet-stream")},
+    )
+
+
+def test_dxf_preview_rettangolo_10x5():
+    resp = _post_preview(_rect_dxf(10, 5))
+    assert resp.status_code == 200, resp.text
+    body = resp.json()
+    assert body["larghezza_mm"] == 10 and body["altezza_mm"] == 5
+    assert body["entita"] == 1 and body["punti"] == sum(len(c) for c in body["contorni"])
+    # y ribaltata: il rettangolo stava a y 3..8 nel DXF, ora a -8..-3 (asse verso il basso)
+    assert body["bbox"] == {"xmin": 1, "ymin": -8, "xmax": 11, "ymax": -3}
+    ring = body["contorni"][0]
+    assert ring[0] == ring[-1]  # contorno chiuso: primo == ultimo
+    assert all(-8 <= y <= -3 for _, y in ring)
+
+
+@pytest.mark.parametrize("content", [b"", b"questo non e' un dxf"])
+def test_dxf_preview_illeggibile_e_422(content):
+    resp = _post_preview(content)
+    assert resp.status_code == 422
+    assert resp.json()["detail"].startswith("DXF")
+
+
+def test_dxf_preview_senza_geometria_e_422():
+    import ezdxf
+    doc = ezdxf.new()
+    buffer = io.StringIO()
+    doc.write(buffer)
+    resp = _post_preview(buffer.getvalue().encode("utf-8"))
+    assert resp.status_code == 422
+    assert "senza geometria" in resp.json()["detail"]
+
+
+def test_dxf_preview_decima_oltre_il_tetto(monkeypatch):
+    from src.vision_worker import main
+    monkeypatch.setattr(main, "_PREVIEW_MAX_POINTS", 50)
+    import ezdxf
+    doc = ezdxf.new()
+    doc.modelspace().add_circle((0, 0), 20)
+    buffer = io.StringIO()
+    doc.write(buffer)
+    full = main._dxf_preview(buffer.getvalue().encode("utf-8"))
+    assert full["punti"] <= 50 + 1 and full["larghezza_mm"] == pytest.approx(40, abs=0.01)  # dimensioni dai punti completi