maker: mm/px a mano nel wizard DXF per immagini da file (Refs #98)

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

src/backend/api/routers/vision.py

@@ -40,22 +40,14 @@ _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). 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.
+# 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.
 _IMAGE_SIGNATURES: tuple[tuple[bytes, ...], ...] = (
     (b"\x89PNG\r\n\x1a\n",),         # PNG
     (b"\xff\xd8\xff",),              # JPEG
@@ -91,7 +83,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 _VISION_IMAGE_TYPES:  # #99
+    if image.content_type not in ALLOWED_IMAGE_TYPES:
         raise HTTPException(
             status_code=status.HTTP_400_BAD_REQUEST,
             detail=f"File type {image.content_type} not allowed. Must be an image.",

src/backend/tests/test_vision_bmp.py

@@ -1,109 +0,0 @@
-"""#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/frontend/flask_app/static/js/dxf_recipe_wizard.js

@@ -21,6 +21,7 @@ function dxfRecipeWizard(taskId, csrf, msgs) {
     imageName: '',
     imageSrc: '',
     dxfFile: null,
+    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)
@@ -59,8 +60,19 @@ function dxfRecipeWizard(taskId, csrf, msgs) {
     },
 
     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; },
     get canRun() {
-      return !!(this.stationId && this.calibrated && this.imageFile && this.dxfFile) && !this.busy;
+      // #98: la scala a mano sostituisce la calibrazione della stazione
+      return !!(this.stationId && (this.calibrated || this.manualPxMm !== null) && this.imageFile && this.dxfFile) && !this.busy;
     },
 
     _setImage(file) {
@@ -120,6 +132,8 @@ function dxfRecipeWizard(taskId, csrf, msgs) {
         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
+        if (this.manualPxMm !== null) 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');

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

@@ -680,13 +680,23 @@
                         <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 && manualPxMm === null" class="mt-1 text-xs text-amber-600">{# #98: nascosto con mm/px valido #}
                           <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>
+                      <!-- #98: mm/px a mano per immagini da file, sostituisce la calibrazione della stazione -->
+                      <div>
+                        <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>
                       <!-- Immagine: camera o file -->
                       <div class="grid grid-cols-1 sm:grid-cols-2 gap-3">
                         <div>

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")
@@ -229,4 +235,5 @@ 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 "Pezzo scuro su fondo chiaro" in html or "Dark part on light" in html