operatore: acquisizione immagine, proxy execute e overlay per camera_measure/dxf_compare (#46)

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

src/backend/api/routers/reports.py

@@ -23,7 +23,6 @@ async def download_spc_report(
     operator_id: int | None = Query(None),
     lot_number: str | None = Query(None),
     serial_number: str | None = Query(None),
-    production_run_id: int | None = Query(None),  # #58
     user: User = Depends(require_metrologist),
     db: AsyncSession = Depends(get_db),
 ) -> Response:
@@ -33,7 +32,6 @@ async def download_spc_report(
             db, recipe_id, subtask_id,
             version_id, date_from, date_to,
             operator_id, lot_number, serial_number,
-            production_run_id=production_run_id,  # #58
         )
     except Exception as e:
         raise HTTPException(
@@ -59,7 +57,6 @@ async def download_measurement_report(
     operator_id: int | None = Query(None),
     lot_number: str | None = Query(None),
     serial_number: str | None = Query(None),
-    production_run_id: int | None = Query(None),  # #58
     user: User = Depends(require_metrologist),
     db: AsyncSession = Depends(get_db),
 ) -> Response:
@@ -69,7 +66,6 @@ async def download_measurement_report(
             db, recipe_id, subtask_id,
             version_id, date_from, date_to,
             operator_id, lot_number, serial_number,
-            production_run_id=production_run_id,  # #58
         )
     except Exception as e:
         raise HTTPException(

src/backend/api/routers/statistics.py

@@ -3,13 +3,12 @@ from datetime import datetime
 from src.backend.models.api.tipi import UtcNaiveInput
 
 from fastapi import APIRouter, Depends, HTTPException, Query, status
-from sqlalchemy import and_, func, select
+from sqlalchemy import and_, select
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from src.backend.database import get_db
 from src.backend.api.middleware.api_key import require_metrologist
 from src.backend.models.orm.measurement import Measurement
-from src.backend.models.orm.production import ProductionRun
 from src.backend.models.orm.recipe import RecipeVersion
 from src.backend.models.orm.task import RecipeSubtask, RecipeTask
 from src.backend.models.orm.user import User
@@ -39,7 +38,6 @@ async def _query_measurements(
     operator_id: int | None = None,
     lot_number: str | None = None,
     serial_number: str | None = None,
-    production_run_id: int | None = None,  # #58: solo le misure di una sessione
 ) -> list[Measurement]:
     """Query measurements with common filters.
 
@@ -69,9 +67,6 @@ async def _query_measurements(
     if serial_number is not None:
         filters.append(Measurement.serial_number == serial_number)
 
-    if production_run_id is not None:
-        filters.append(Measurement.production_run_id == production_run_id)
-
     query = (
         select(Measurement)
         .where(and_(*filters) if filters else True)
@@ -111,7 +106,6 @@ async def get_summary(
     operator_id: int | None = Query(None),
     lot_number: str | None = Query(None),
     serial_number: str | None = Query(None),
-    production_run_id: int | None = Query(None),  # #58
     user: User = Depends(require_metrologist),
     db: AsyncSession = Depends(get_db),
 ) -> SummaryData:
@@ -119,7 +113,6 @@ async def get_summary(
     measurements = await _query_measurements(
         db, recipe_id, version_id, subtask_id,
         date_from, date_to, operator_id, lot_number, serial_number,
-        production_run_id=production_run_id,  # #58
     )
     pass_fail_values = [m.pass_fail for m in measurements]
     return compute_summary(pass_fail_values)
@@ -135,7 +128,6 @@ async def get_capability(
     operator_id: int | None = Query(None),
     lot_number: str | None = Query(None),
     serial_number: str | None = Query(None),
-    production_run_id: int | None = Query(None),  # #58
     user: User = Depends(require_metrologist),
     db: AsyncSession = Depends(get_db),
 ) -> CapabilityData:
@@ -143,7 +135,6 @@ async def get_capability(
     measurements = await _query_measurements(
         db, recipe_id, version_id, subtask_id,
         date_from, date_to, operator_id, lot_number, serial_number,
-        production_run_id=production_run_id,  # #58
     )
     values = [float(m.value) for m in measurements]
     tol = await _get_subtask_tolerances(db, subtask_id)
@@ -160,7 +151,6 @@ async def get_control_chart(
     operator_id: int | None = Query(None),
     lot_number: str | None = Query(None),
     serial_number: str | None = Query(None),
-    production_run_id: int | None = Query(None),  # #58
     user: User = Depends(require_metrologist),
     db: AsyncSession = Depends(get_db),
 ) -> ControlChartData:
@@ -168,7 +158,6 @@ async def get_control_chart(
     measurements = await _query_measurements(
         db, recipe_id, version_id, subtask_id,
         date_from, date_to, operator_id, lot_number, serial_number,
-        production_run_id=production_run_id,  # #58
     )
     values = [float(m.value) for m in measurements]
     timestamps = [m.measured_at for m in measurements]
@@ -189,7 +178,6 @@ async def get_histogram(
     operator_id: int | None = Query(None),
     lot_number: str | None = Query(None),
     serial_number: str | None = Query(None),
-    production_run_id: int | None = Query(None),  # #58
     n_bins: int = Query(20, ge=5, le=100),
     user: User = Depends(require_metrologist),
     db: AsyncSession = Depends(get_db),
@@ -198,7 +186,6 @@ async def get_histogram(
     measurements = await _query_measurements(
         db, recipe_id, version_id, subtask_id,
         date_from, date_to, operator_id, lot_number, serial_number,
-        production_run_id=production_run_id,  # #58
     )
     values = [float(m.value) for m in measurements]
     return compute_histogram(values, n_bins)
@@ -248,49 +235,3 @@ async def get_recipe_subtasks(
             })
 
     return subtasks_list
-
-
-@router.get("/runs")
-async def get_recipe_runs(
-    recipe_id: int = Query(...),
-    user: User = Depends(require_metrologist),
-    db: AsyncSession = Depends(get_db),
-) -> list[dict]:
-    """#58: production runs of a recipe (for the "Sessione" filter), newest first."""
-    runs = (await db.execute(
-        select(ProductionRun)
-        .where(ProductionRun.recipe_id == recipe_id)
-        .order_by(ProductionRun.started_at.desc(), ProductionRun.id.desc())
-    )).scalars().all()
-    # #58: conta solo le misure dei run della ricetta, non tutta la tabella.
-    run_ids = [r.id for r in runs]
-    counts = {}
-    if run_ids:
-        counts = dict((await db.execute(
-            select(Measurement.production_run_id, func.count(Measurement.id))
-            .where(Measurement.production_run_id.in_(run_ids))
-            .group_by(Measurement.production_run_id)
-        )).all())
-    operator_ids = {r.operator_id for r in runs}
-    names = {}
-    if operator_ids:
-        names = dict((await db.execute(
-            select(User.id, User.display_name).where(User.id.in_(operator_ids))
-        )).all())
-    return [
-        {
-            "id": r.id,
-            "station_id": r.station_id,
-            "station_name": r.station.name if r.station else None,
-            "operator_id": r.operator_id,
-            "operator_name": names.get(r.operator_id),
-            "started_at": r.started_at.isoformat() if r.started_at else None,
-            "closed_at": r.closed_at.isoformat() if r.closed_at else None,
-            "status": r.status,
-            "lot_number": r.lot_number,
-            "serial_number": r.serial_number,
-            "cycle_count": r.cycle_count,
-            "measurement_count": counts.get(r.id, 0),
-        }
-        for r in runs
-    ]

src/backend/services/report_service.py

@@ -48,7 +48,6 @@ async def _query_measurements(
     operator_id: int | None = None,
     lot_number: str | None = None,
     serial_number: str | None = None,
-    production_run_id: int | None = None,  # #58
 ) -> list[Measurement]:
     """Query measurements with common filters (duplicated from statistics router)."""
     filters = []
@@ -74,9 +73,6 @@ async def _query_measurements(
     if serial_number is not None:
         filters.append(Measurement.serial_number == serial_number)
 
-    if production_run_id is not None:
-        filters.append(Measurement.production_run_id == production_run_id)
-
     query = (
         select(Measurement)
         .where(and_(*filters) if filters else True)
@@ -285,7 +281,6 @@ async def generate_spc_report(
     operator_id: int | None = None,
     lot_number: str | None = None,
     serial_number: str | None = None,
-    production_run_id: int | None = None,  # #58
 ) -> bytes:
     """Generate SPC PDF report and return bytes.
 
@@ -295,7 +290,6 @@ async def generate_spc_report(
     measurements = await _query_measurements(
         db, recipe_id, version_id, subtask_id,
         date_from, date_to, operator_id, lot_number, serial_number,
-        production_run_id=production_run_id,  # #58
     )
 
     # 2. Compute SPC data
@@ -342,8 +336,6 @@ async def generate_spc_report(
         filters_desc.append(f"Lot: {lot_number}")
     if serial_number:
         filters_desc.append(f"Serial: {serial_number}")
-    if production_run_id is not None:
-        filters_desc.append(f"Run: {production_run_id}")  # #58
 
     # 6. Render HTML template
     template = _jinja_env.get_template("spc_report.html")
@@ -375,14 +367,12 @@ async def generate_measurement_report(
     operator_id: int | None = None,
     lot_number: str | None = None,
     serial_number: str | None = None,
-    production_run_id: int | None = None,  # #58
 ) -> bytes:
     """Generate measurement table PDF report and return bytes."""
     # 1. Query measurements
     measurements = await _query_measurements(
         db, recipe_id, version_id, subtask_id,
         date_from, date_to, operator_id, lot_number, serial_number,
-        production_run_id=production_run_id,  # #58
     )
 
     # 2. Get recipe info
@@ -437,8 +427,6 @@ async def generate_measurement_report(
         filters_desc.append(f"Lot: {lot_number}")
     if serial_number:
         filters_desc.append(f"Serial: {serial_number}")
-    if production_run_id is not None:
-        filters_desc.append(f"Run: {production_run_id}")  # #58
 
     # 7. Render template
     template = _jinja_env.get_template("measurement_report.html")

src/backend/tests/test_statistics.py

@@ -211,79 +211,3 @@ class TestDateFilter:
         assert resp.status_code == 200
         # All measurements should be within this wide range
         assert resp.json()["total"] >= 2
-
-
-class TestRunFilter:
-    """#58: statistiche per sessione di produzione."""
-
-    async def _setup(self, db_session, user, metro):
-        from datetime import datetime
-        from src.backend.models.orm.production import ProductionRun
-        from src.backend.models.orm.station import Station
-        from src.backend.models.orm.recipe import RecipeVersion
-        from sqlalchemy import select
-        recipe = await create_test_recipe(db_session, user.id)
-        version = (await db_session.execute(
-            select(RecipeVersion).where(RecipeVersion.recipe_id == recipe.id)
-        )).scalars().first()
-        station = Station(code="ST-58", name="Stazione 58", active=True, created_by=user.id)
-        db_session.add(station)
-        await db_session.commit()
-        runs = []
-        for i, lot in enumerate(["L1", "L2"]):
-            run = ProductionRun(
-                station_id=station.id, recipe_id=recipe.id, version_id=version.id,
-                operator_id=user.id, status="closed", lot_number=lot,
-                started_at=datetime(2026, 1, 1 + i),
-            )
-            db_session.add(run)
-            runs.append(run)
-        await db_session.commit()
-        return recipe, runs
-
-    async def test_filter_by_run_and_unfiltered(
-        self, client, measurement_tec_user, metrologist_user, db_session,
-    ):
-        from src.backend.models.orm.measurement import Measurement
-        recipe, runs = await self._setup(db_session, measurement_tec_user, metrologist_user)
-        subtask_id, version_id = await _seed_measurements(
-            client, measurement_tec_user, recipe.id, [10.0, 10.1, 10.2],
-        )
-        # Assegna le prime due misure al run 1, la terza al run 2.
-        from sqlalchemy import select
-        ms = (await db_session.execute(
-            select(Measurement).order_by(Measurement.id)
-        )).scalars().all()
-        ms[0].production_run_id = runs[0].id
-        ms[1].production_run_id = runs[0].id
-        ms[2].production_run_id = runs[1].id
-        await db_session.commit()
-
-        h = auth_headers(metrologist_user)
-        r1 = await client.get("/api/statistics/summary", headers=h,
-                              params={"recipe_id": recipe.id, "production_run_id": runs[0].id})
-        assert r1.json()["total"] == 2
-        r2 = await client.get("/api/statistics/summary", headers=h,
-                              params={"recipe_id": recipe.id, "production_run_id": runs[1].id})
-        assert r2.json()["total"] == 1
-        r_all = await client.get("/api/statistics/summary", headers=h,
-                                 params={"recipe_id": recipe.id})
-        assert r_all.json()["total"] == 3
-
-        runs_resp = await client.get("/api/statistics/runs", headers=h,
-                                     params={"recipe_id": recipe.id})
-        assert runs_resp.status_code == 200
-        data = runs_resp.json()
-        assert [r["id"] for r in data] == [runs[1].id, runs[0].id]  # più recente prima
-        assert [r["measurement_count"] for r in data] == [1, 2]
-        assert data[0]["lot_number"] == "L2"
-        assert data[0]["station_name"] == "Stazione 58"
-        assert data[0]["closed_at"] is None
-
-    async def test_runs_require_metrologist(
-        self, client, measurement_tec_user, db_session,
-    ):
-        resp = await client.get("/api/statistics/runs",
-                                headers=auth_headers(measurement_tec_user),
-                                params={"recipe_id": 1})
-        assert resp.status_code == 403

src/frontend/flask_app/blueprints/measure.py

@@ -1,8 +1,10 @@
 """MeasurementTec blueprint - recipe selection and measurement execution."""
 import urllib.parse
 
+import requests as http_requests
+
 from flask import (
-    Blueprint, abort, flash, jsonify, redirect, render_template,
+    Blueprint, Response, abort, flash, jsonify, redirect, render_template,
     request, session, url_for,
 )
 from flask_babel import gettext as _
@@ -820,3 +822,67 @@ def api_close_production(run_id: int):
 def api_get_file(file_path: str):
     """Proxy: Serve file from API server (browser can't send X-API-Key)."""
     return proxy_file(file_path)
+
+
+# ---------------------------------------------------------------------------
+# Route: vision execute (#46) - the browser sends an image, we relay it to
+# POST /api/vision/execute (multipart) because it cannot send X-API-Key itself.
+# ---------------------------------------------------------------------------
+@measure_bp.route("/api/vision/execute", methods=["POST"])
+@login_required
+@role_required("MeasurementTec")
+def api_vision_execute():
+    """Proxy: run the task's VisionSuite recipe on the uploaded image."""
+    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
+
+    # Same context fields as the manual flow; empty ones are left out so the
+    # backend sees them as absent rather than as "".
+    form = {"task_id": task_id}
+    for key in ("task_type", "lot_number", "serial_number", "production_run_id"):
+        val = request.form.get(key)
+        if val:
+            form[key] = val
+    form.setdefault("lot_number", session.get("lot_number", ""))
+    form.setdefault("serial_number", session.get("serial_number", ""))
+
+    resp = api_client.post(
+        "/api/vision/execute",
+        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
+
+
+@measure_bp.route("/api/vision/results/<int:result_id>/image", methods=["GET"])
+@login_required
+@role_required("MeasurementTec")
+def api_vision_result_image(result_id: int):
+    """Proxy: the image saved with a vision result (needs X-API-Key)."""
+    base_url = Config.API_SERVER_URL.rstrip("/")
+    resp = http_requests.get(
+        f"{base_url}/api/vision/results/{result_id}/image",
+        headers={"X-API-Key": session.get("api_key", "")},
+        timeout=30,
+    )
+    if resp.status_code != 200:
+        return Response(resp.text, status=resp.status_code)
+    return Response(
+        resp.content,
+        content_type=resp.headers.get("content-type", "application/octet-stream"),
+    )

src/frontend/flask_app/blueprints/statistics.py

@@ -50,7 +50,7 @@ def _proxy_statistics(endpoint: str):
     for key in [
         "recipe_id", "version_id", "subtask_id",
         "date_from", "date_to", "operator_id",
-        "lot_number", "serial_number", "n_bins", "production_run_id",  # #58
+        "lot_number", "serial_number", "n_bins",
     ]:
         val = request.args.get(key)
         if val is not None and val != "":
@@ -127,27 +127,6 @@ def api_subtasks():
     return jsonify(resp)
 
 
-@statistics_bp.route("/api/runs")
-@login_required
-@role_required("Metrologist")
-def api_runs():
-    """Proxy: production runs of a recipe (#58, "Sessione" filter)."""
-    params = {}
-    recipe_id = request.args.get("recipe_id")
-    if recipe_id:
-        params["recipe_id"] = recipe_id
-
-    resp = api_client.get("/api/statistics/runs", params=params)
-
-    if isinstance(resp, dict) and resp.get("error"):
-        error_body = {"error": True, "detail": resp.get("detail", "")}
-        if resp.get("session_expired"):
-            error_body["session_expired"] = True
-        return jsonify(error_body), resp.get("status_code", 500)
-
-    return jsonify(resp)
-
-
 # ============================================================================
 # PROXY REPORT PDF → FastAPI
 # ============================================================================
@@ -158,7 +137,7 @@ def _proxy_report(endpoint: str):
     for key in [
         "recipe_id", "version_id", "subtask_id",
         "date_from", "date_to", "operator_id",
-        "lot_number", "serial_number", "production_run_id",  # #58
+        "lot_number", "serial_number",
     ]:
         val = request.args.get(key)
         if val is not None and val != "":

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

@@ -0,0 +1,125 @@
+/**
+ * Vision execute - Alpine component for camera_measure / dxf_compare tasks (#46).
+ *
+ * The operator takes (or picks) an image, `acquire(blob)` sends it to the Flask
+ * proxy, and the result - quote table, outcome, failures, overlay - is shown on
+ * the image. `acquire(blob)` is the single entry point on purpose: the agent
+ * camera (#3) will call it with its own blob and reuse everything below.
+ *
+ * Config comes from window.__visionCfg (set by the template):
+ *   executeUrl, imageUrlTpl (with a 0 placeholder for the result id), taskId,
+ *   taskType, subtasks, labels.
+ * Run context (lot, serial, production run) is read lazily through `ctx()`,
+ * which the template binds to the parent task component.
+ */
+function visionExecute() {
+  // Overlay colour per role (VisionSuite roles: reference, roi, found).
+  const ROLE_COLORS = { reference: '#2563eb', found: '#16a34a', roi: '#f59e0b' };
+
+  return {
+    busy: false,
+    error: '',
+    result: null,      // last execute response
+    imageSrc: '',      // object URL of the acquired image (shown under the overlay)
+    ctx: () => ({}),   // replaced by the template: {lot, serial, runId}
+
+    // Entry point shared with the future agent camera.
+    async acquire(blob) {
+      if (!blob || this.busy) return;
+      const cfg = window.__visionCfg || {};
+      this.busy = true;
+      this.error = '';
+      this.result = null;
+      // Show the picked image at once: the overlay is drawn on top when the result arrives.
+      if (this.imageSrc) URL.revokeObjectURL(this.imageSrc);
+      this.imageSrc = URL.createObjectURL(blob);
+      try {
+        const c = this.ctx() || {};
+        const fd = new FormData();
+        fd.append('task_id', cfg.taskId);
+        fd.append('task_type', cfg.taskType || '');
+        fd.append('image', blob, blob.name || 'capture.jpg');
+        fd.append('lot_number', c.lot || '');
+        fd.append('serial_number', c.serial || '');
+        if (c.runId) fd.append('production_run_id', c.runId);
+        const csrf = document.querySelector('meta[name=csrf-token]')?.content || '';
+        const resp = await fetch(cfg.executeUrl, {
+          method: 'POST', headers: { 'X-CSRFToken': csrf }, body: fd,
+        });
+        const body = await resp.json().catch(() => ({}));
+        if (!resp.ok || body.error) {
+          this.error = body.detail || (cfg.labels && cfg.labels.requestFailed) || 'Error';
+          return;
+        }
+        this.result = body;
+        // Draw once Alpine has rendered the canvas.
+        this.$nextTick(() => this.drawOverlay());
+      } catch (e) {
+        this.error = (cfg.labels && cfg.labels.requestFailed) || 'Error';
+      } finally {
+        this.busy = false;
+      }
+    },
+
+    // Input change: take the file and allow picking the same one again.
+    onPick(ev) {
+      const f = ev.target.files && ev.target.files[0];
+      ev.target.value = '';
+      if (f) this.acquire(f);
+    },
+
+    // Image shown: the saved one from the server when available, else the local one.
+    get shownImage() {
+      const cfg = window.__visionCfg || {};
+      if (this.result && this.result.vision_result_id && cfg.imageUrlTpl) {
+        return cfg.imageUrlTpl.replace('/0/', '/' + this.result.vision_result_id + '/');
+      }
+      return this.imageSrc;
+    },
+
+    // Quote rows: server measurements joined with the subtask names.
+    get rows() {
+      const cfg = window.__visionCfg || {};
+      const subs = cfg.subtasks || [];
+      return ((this.result && this.result.measurements) || []).map((m) => {
+        const st = subs.find((s) => s.id === m.subtask_id) || {};
+        return {
+          label: (st.marker_number ? st.marker_number + '. ' : '') + (st.measurement_type || st.name || '#' + m.subtask_id),
+          value: m.value,
+          unit: st.unit || 'mm',
+          status: m.pass_fail,
+        };
+      });
+    },
+
+    statusClass(s) {
+      // Same palette as the measurement markers of the manual flow.
+      if (s === 'pass') return 'bg-measure-pass/20 text-measure-pass border border-measure-pass/40';
+      if (s === 'fail') return 'bg-red-100 dark:bg-red-900/30 text-measure-fail border border-measure-fail/40';
+      if (s === 'warning') return 'bg-amber-100 dark:bg-amber-900/30 text-measure-warning border border-measure-warning/40';
+      return 'bg-[var(--bg-secondary)] text-[var(--text-muted)] border border-[var(--border-color)]';
+    },
+
+    // Canvas is sized to the natural image, so overlay coordinates (image px)
+    // are used as they are and CSS scales the whole thing to the displayed size.
+    drawOverlay() {
+      const img = this.$refs.img, cv = this.$refs.overlay;
+      if (!img || !cv || !img.naturalWidth) return;
+      cv.width = img.naturalWidth;
+      cv.height = img.naturalHeight;
+      const g = cv.getContext('2d');
+      g.clearRect(0, 0, cv.width, cv.height);
+      g.lineWidth = Math.max(2, cv.width / 400);
+      g.lineJoin = 'round';
+      for (const item of ((this.result && this.result.overlay) || [])) {
+        const rows = item.rows || [], cols = item.cols || [];
+        if (!rows.length || rows.length !== cols.length) continue;
+        g.strokeStyle = ROLE_COLORS[item.role] || '#ef4444';
+        g.beginPath();
+        g.moveTo(cols[0], rows[0]);
+        for (let i = 1; i < rows.length; i++) g.lineTo(cols[i], rows[i]);
+        g.stroke();
+      }
+    },
+  };
+}

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

@@ -191,7 +191,8 @@
   {# ================================================================
      MAIN — 3-column layout
      ================================================================ #}
-  <div class="flex-1 flex overflow-hidden">
+  {# #46: camera_measure / dxf_compare get the acquisition panel below instead of the manual layout #}
+  <div class="flex-1 flex overflow-hidden" x-show="!isVisionTask">
 
     {# ──────────────────────────────────────────────
        LEFT SIDEBAR — Marker list (vertical, hidden when no subtasks)
@@ -451,6 +452,63 @@
 
   </div>
 
+  {# ================================================================
+     VISION PANEL (#46) - acquire an image, run the recipe server-side, show the
+     quotes and the overlay. acquire(blob) is the entry point the agent camera
+     (#3) will reuse.
+     ================================================================ #}
+  <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">
+
+    <div class="flex-1 min-w-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' : ''">
+          <span x-text="result ? '{{ _('Riprova') }}' : '{{ _('Acquisisci immagine') }}'"></span>
+          <input type="file" accept="image/*" capture="environment" class="hidden"
+                 @change="onPick($event)" :disabled="busy">
+        </label>
+        <span x-show="busy" class="text-sm text-[var(--text-muted)]">{{ _('Elaborazione in corso...') }}</span>
+      </div>
+
+      <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>
+      </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">
+      <div class="text-sm font-bold text-[var(--text-primary)]">
+        {{ _('Esito') }}: <span x-text="(result && result.outcome) || '-'"></span>
+      </div>
+
+      <table class="w-full text-sm" x-show="rows.length">
+        <template x-for="r in rows" :key="r.label">
+          <tr>
+            <td class="py-1 pr-2 text-[var(--text-secondary)]" x-text="r.label"></td>
+            <td class="py-1 pr-2 font-mono text-right" x-text="Number(r.value).toFixed(3) + ' ' + r.unit"></td>
+            <td class="py-1"><span class="inline-block px-2 py-0.5 rounded text-xs font-bold" :class="statusClass(r.status)" x-text="r.status"></span></td>
+          </tr>
+        </template>
+      </table>
+
+      <div x-show="result && result.failures && result.failures.length"
+           class="p-2 rounded-lg bg-amber-50 dark:bg-amber-900/20 border border-amber-300 dark:border-amber-700 text-xs">
+        <div class="font-bold mb-1">{{ _('Strumenti falliti') }}</div>
+        <template x-for="f in ((result && result.failures) || [])" :key="f.tool_id">
+          <div><span class="font-mono" x-text="f.tool_name || f.tool_id"></span>: <span x-text="f.error"></span></div>
+        </template>
+      </div>
+    </div>
+  </div>
+
   {# ================================================================
      MEASUREMENT TIMER BANNER
      ================================================================ #}
@@ -912,6 +970,18 @@
 <script src="{{ url_for('static', filename='js/numpad.js') }}"></script>
 <script src="{{ url_for('static', filename='js/annotation-viewer.js') }}?v=6"></script>
 <script src="{{ url_for('static', filename='js/caliper.js') }}"></script>
+{# #46: acquisition + overlay for camera_measure / dxf_compare #}
+<script>
+  window.__visionCfg = {
+    executeUrl: '{{ url_for("measure.api_vision_execute") }}',
+    imageUrlTpl: '{{ url_for("measure.api_vision_result_image", result_id=0) }}',
+    taskId: {{ task.id|tojson }},
+    taskType: {{ (task.task_type or '')|tojson }},
+    subtasks: window.__taskSubtasks,
+    labels: { requestFailed: {{ _('Richiesta non riuscita')|tojson }} },
+  };
+</script>
+<script src="{{ url_for('static', filename='js/vision_execute.js') }}"></script>
 {# The clock's rules - how a delay reads, when the buzzer goes, where the
    measurement lives - are shared with the other screens rather than restated. #}
 <script src="{{ url_for('static', filename='js/production-clock.js') }}"></script>
@@ -1776,6 +1846,12 @@ function taskExecute() {
       return declared === 'measure' || declared === 'camera_measure';
     },
 
+    /* #46: image-based tasks run a VisionSuite recipe on the server. */
+    get isVisionTask() {
+      const t = this.task.task_type;
+      return t === 'camera_measure' || t === 'dxf_compare';
+    },
+
     /* A measurement task with no quotes yet: the recipe is unfinished. Said out
        loud rather than silently rendering an empty screen. */
     get isMeasureTaskWithoutQuotes() {

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

@@ -35,19 +35,6 @@
         </select>
       </div>
 
-      <!-- Sessione di produzione (#58) -->
-      <div>
-        <label class="block text-xs font-medium text-steel mb-1">{{ _("Sessione") }}</label>
-        <select x-model="selectedRunId"
-                :disabled="runs.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="">{{ _("Tutte le sessioni") }}</option>
-          <template x-for="r in runs" :key="r.id">
-            <option :value="r.id" x-text="runLabel(r)"></option>
-          </template>
-        </select>
-      </div>
-
       <!-- Subtask -->
       <div>
         <label class="block text-xs font-medium text-steel mb-1">{{ _("Punto di misura") }}</label>
@@ -271,8 +258,6 @@ function spcDashboard() {
     // Filter state
     selectedRecipeId: '',
     selectedSubtaskId: '',
-    selectedRunId: '',  // #58
-    runs: [],  // #58 sessioni della ricetta
     dateFrom: '',
     dateTo: '',
     subtasks: [],
@@ -296,8 +281,6 @@ function spcDashboard() {
 
     async onRecipeChange() {
       this.selectedSubtaskId = '';
-      this.selectedRunId = '';  // #58
-      this.runs = [];
       this.subtasks = [];
       this.hasData = false;
       this.summary = null;
@@ -307,15 +290,6 @@ function spcDashboard() {
 
       if (!this.selectedRecipeId) return;
 
-      // #58: sessioni della ricetta per il filtro «Sessione»
-      try {
-        const rresp = await fetch('/statistics/api/runs?recipe_id=' + this.selectedRecipeId);
-        const rdata = await rresp.json();
-        if (Array.isArray(rdata)) this.runs = rdata;
-      } catch (e) {
-        console.error('Error loading runs:', e);
-      }
-
       // Load subtasks for dropdown
       try {
         const resp = await fetch('/statistics/api/subtasks?recipe_id=' + this.selectedRecipeId);
@@ -328,12 +302,6 @@ function spcDashboard() {
       }
     },
 
-    // #58: etichetta sessione = data, stazione, operatore, lotto
-    runLabel(r) {
-      const d = r.started_at ? new Date(r.started_at + (r.started_at.endsWith('Z') ? '' : 'Z')).toLocaleString() : '';
-      return [d, r.station_name, r.operator_name, r.lot_number].filter(Boolean).join(' · ');
-    },
-
     async loadData() {
       if (!this.selectedRecipeId) return;
 
@@ -344,7 +312,6 @@ function spcDashboard() {
       const params = new URLSearchParams();
       params.set('recipe_id', this.selectedRecipeId);
       if (this.selectedSubtaskId) params.set('subtask_id', this.selectedSubtaskId);
-      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());
 
@@ -450,7 +417,6 @@ function spcDashboard() {
         const params = new URLSearchParams();
         params.set('recipe_id', this.selectedRecipeId);
         if (this.selectedSubtaskId) params.set('subtask_id', this.selectedSubtaskId);
-        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());
 

src/frontend/flask_app/tests/test_measure_vision.py

@@ -0,0 +1,86 @@
+"""gitea:Adriano/TieMeasureFlow#46 - operator side of the vision tasks.
+
+The backend of contract B is not merged yet: api_client is mocked.
+"""
+import io
+from unittest.mock import MagicMock, patch
+
+from tests.conftest import api_get_router
+
+TASK = {
+    "id": 12, "recipe_id": 3, "version_id": 5, "task_type": "camera_measure",
+    "title": "Foto", "directive": None, "description": None, "file_path": None,
+    "file_type": None, "annotations_json": None, "subtasks": [],
+}
+RECIPE = {
+    "id": 3, "code": "REC-1", "name": "Ricetta",
+    "measurement_interval_minutes": 30, "allow_manual_input": True,
+    "current_version": {"id": 5, "version_number": 1},
+}
+
+
+def test_execute_page_has_acquire_input(logged_in_client, mock_api_client, monkeypatch):
+    """camera_measure screen offers the file/camera input and the acquire entry point."""
+    monkeypatch.setattr("blueprints.measure.Config.STATION_CODE", "ST-TEST")
+    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,
+    })
+    html = logged_in_client.get("/measure/execute/12").get_data(as_text=True)
+    assert 'capture="environment"' in html
+    assert 'accept="image/*"' in html
+    assert "visionExecute()" in html
+    assert "/measure/api/vision/execute" in html
+
+
+def test_vision_execute_proxy_forwards_multipart(logged_in_client, mock_api_client):
+    mock_api_client.post.return_value = {
+        "vision_result_id": 7, "outcome": "ok", "overlay": [], "failures": [],
+        "measurements": [{"subtask_id": 1, "value": 9.9, "pass_fail": "pass"}],
+    }
+    resp = logged_in_client.post(
+        "/measure/api/vision/execute",
+        data={
+            "task_id": "12", "lot_number": "L1", "serial_number": "S1",
+            "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()["vision_result_id"] == 7
+    args, kwargs = mock_api_client.post.call_args
+    assert args[0] == "/api/vision/execute"
+    assert kwargs["data"]["task_id"] == "12"
+    assert kwargs["data"]["lot_number"] == "L1"
+    assert kwargs["data"]["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_vision_execute_proxy_requires_image(logged_in_client, mock_api_client):
+    resp = logged_in_client.post("/measure/api/vision/execute", data={"task_id": "12"})
+    assert resp.status_code == 400
+    mock_api_client.post.assert_not_called()
+
+
+def test_vision_execute_proxy_relays_backend_error(logged_in_client, mock_api_client):
+    mock_api_client.post.return_value = {"error": True, "status_code": 422, "detail": "bad"}
+    resp = logged_in_client.post(
+        "/measure/api/vision/execute",
+        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"] == "bad"
+
+
+def test_vision_result_image_proxy(logged_in_client):
+    fake = MagicMock(status_code=200, content=b"IMG", headers={"content-type": "image/jpeg"})
+    with patch("blueprints.measure.http_requests.get", return_value=fake) as g:
+        resp = logged_in_client.get("/measure/api/vision/results/7/image")
+    assert resp.status_code == 200 and resp.data == b"IMG"
+    assert g.call_args[0][0].endswith("/api/vision/results/7/image")
+    assert g.call_args[1]["headers"]["X-API-Key"] == "test-api-key-12345"

src/frontend/flask_app/tests/test_statistics.py

@@ -112,21 +112,3 @@ class TestSPCProxy:
         assert resp.status_code == 200
         data = resp.get_json()
         assert "cp" in data
-
-
-class TestRunsProxy:
-    """#58: filtro per sessione di produzione."""
-
-    def test_runs_proxy(self, logged_in_client, mock_api_client):
-        mock_api_client.get.return_value = [{"id": 5, "measurement_count": 3}]
-        resp = logged_in_client.get("/statistics/api/runs?recipe_id=7")
-        assert resp.status_code == 200
-        assert resp.get_json()[0]["id"] == 5
-        args, kwargs = mock_api_client.get.call_args
-        assert args[0] == "/api/statistics/runs"
-        assert kwargs["params"] == {"recipe_id": "7"}
-
-    def test_summary_forwards_production_run_id(self, logged_in_client, mock_api_client):
-        mock_api_client.get.return_value = {"total": 1}
-        logged_in_client.get("/statistics/api/summary?recipe_id=1&production_run_id=5")
-        assert mock_api_client.get.call_args.kwargs["params"]["production_run_id"] == "5"