Upload folder using huggingface_hub

measure_finger.py

@@ -26,7 +26,12 @@ from src.sam_card_detection import (
 )
 from src.finger_segmentation import segment_hand, isolate_finger, clean_mask, get_finger_contour
 from src.geometry import estimate_finger_axis, localize_ring_zone, localize_ring_zone_from_landmarks, compute_cross_section_width
-from src.edge_refinement import refine_edges_sobel, should_use_sobel_measurement, compare_edge_methods
+from src.edge_refinement import (
+    refine_edges_sobel,
+    should_use_sobel_measurement,
+    compare_edge_methods,
+    MIN_MASK_SAMPLES,
+)
 from src.confidence import (
     compute_card_confidence,
     compute_finger_confidence,
@@ -808,6 +813,22 @@ def measure_finger(
                   f"std={sobel_measurement['std_width_px']:.2f}px, "
                   f"quality={sobel_measurement['edge_quality']['overall_score']:.3f})")
 
+            # Hard-fail mask mode when there aren't enough valid rows to
+            # trust the median. Without this gate a single surviving row
+            # still produces a "valid" measurement.
+            if edge_method == "mask":
+                num_samples = int(sobel_measurement.get("num_samples", 0))
+                if num_samples < MIN_MASK_SAMPLES:
+                    print(f"Insufficient valid edge samples: {num_samples} < {MIN_MASK_SAMPLES}")
+                    return create_output(
+                        card_detected=card_detected,
+                        finger_detected=True,
+                        scale_px_per_cm=px_per_cm,
+                        view_angle_ok=view_angle_ok,
+                        fail_reason=f"insufficient_edge_samples_{num_samples}",
+                        edge_method_used="mask",
+                    )
+
         except Exception as e:
             print(f"Edge refinement failed: {e}")
             sobel_failed = True
@@ -1162,6 +1183,17 @@ def _measure_single_finger_from_shared(
                 mask_mode=mask_mode,
                 finger_name=finger_name,
             )
+            # Hard-fail mask mode when too few valid rows survived all the
+            # invalidation gates.
+            if edge_method == "mask":
+                num_samples = int(sobel_measurement.get("num_samples", 0))
+                if num_samples < MIN_MASK_SAMPLES:
+                    return create_output(
+                        card_detected=card_detected, finger_detected=True,
+                        scale_px_per_cm=px_per_cm, view_angle_ok=view_angle_ok,
+                        fail_reason=f"insufficient_edge_samples_{num_samples}",
+                        edge_method_used="mask",
+                    )
         except Exception:
             sobel_failed = True
             if edge_method in ("sobel", "mask"):

src/edge_refinement.py

@@ -52,6 +52,13 @@ from src.edge_refinement_constants import (
 # Configure logging
 logger = logging.getLogger(__name__)
 
+# Minimum valid cross-sections required for a trustworthy mask-based width
+# measurement. Below this the median is too sensitive to individual row
+# errors (webbing leakage, axis drift, finger tilt), so callers should fail
+# the measurement rather than report a potentially-wrong number. 20 keeps
+# parity with the contour path's 20-sample target.
+MIN_MASK_SAMPLES = 20
+
 
 # =============================================================================
 # Helper Functions (extracted from nested scope)
@@ -1053,7 +1060,6 @@ def should_use_sobel_measurement(
         # otherwise reasonable width usually indicates the per-finger mask
         # bled into an adjacent finger and width validation killed most
         # rows — contour is safer in that situation.
-        MIN_MASK_SAMPLES = 20  # parity with the contour path's 20 samples
         num_samples = int(sobel_result.get("num_samples", 0))
         if num_samples < MIN_MASK_SAMPLES:
             return False, f"mask_samples_low_{num_samples}"

web_demo/app.py

@@ -9,13 +9,15 @@ from __future__ import annotations
 import csv
 import io
 import json
+import logging
 import os
 import re
 import sys
 import uuid
+from concurrent.futures import ThreadPoolExecutor
 from datetime import datetime
 from pathlib import Path
-from typing import Dict, Any, Tuple
+from typing import Any, Dict, Optional, Tuple
 
 import cv2
 import numpy as np
@@ -42,6 +44,46 @@ DEMO_HAND_MASK_METHOD = "sam"
 
 app = Flask(__name__)
 
+logger = logging.getLogger(__name__)
+
+# Persist to Supabase off the request thread: two storage uploads + a row
+# insert add multi-second latency that the user would otherwise stare at
+# after the measurement is already done. max_workers=2 is plenty — each
+# request queues one task, and we don't need ordering.
+_persist_executor = ThreadPoolExecutor(max_workers=2, thread_name_prefix="supa-persist")
+
+
+def _persist_measurement_async(
+    *,
+    upload_path: Optional[Path],
+    upload_name: str,
+    result_png_path: Path,
+    result_png_name: str,
+    record: Dict[str, Any],
+) -> None:
+    """Upload the photo + result PNG to Supabase Storage and insert the
+    measurement row. Designed to run in a worker thread — takes no request
+    state and logs (rather than raises) on failure so a broken Supabase
+    connection never poisons the measurement the user just saw.
+    """
+    def _task() -> None:
+        try:
+            photo_url = None
+            result_url = None
+            if upload_path and upload_path.exists():
+                photo_url = upload_file(str(upload_path), f"photos/{upload_name}")
+            if result_png_path.exists():
+                result_url = upload_file(str(result_png_path), f"results/{result_png_name}")
+            record_with_urls = dict(record)
+            record_with_urls["photo_url"] = photo_url
+            record_with_urls["result_url"] = result_url
+            save_measurement(record_with_urls)
+        except Exception as exc:  # noqa: BLE001
+            logger.exception("Supabase persist failed for run %s: %s",
+                             record.get("run_id"), exc)
+
+    _persist_executor.submit(_task)
+
 
 def _allowed_file(filename: str) -> bool:
     return Path(filename).suffix.lower() in ALLOWED_EXTENSIONS
@@ -259,41 +301,38 @@ def _run_measurement(
     result_json_path = RESULTS_DIR / result_json_name
     _save_json(result_json_path, result)
 
-    # --- Persist to Supabase ---
-    photo_public_url = None
-    result_public_url = None
-    if upload_path and upload_path.exists():
-        photo_public_url = upload_file(str(upload_path), f"photos/{upload_name}")
-    if result_png_path.exists():
-        result_public_url = upload_file(str(result_png_path), f"results/{result_png_name}")
-
-    ring_size = result.get("ring_size", {})
-    measurement_id = save_measurement({
-        "run_id": run_id,
-        "kol_name": kol_name,
-        "mode": "single",
-        "ring_model": ring_model,
-        "finger_index": finger_index,
-        "diameter_cm": result.get("finger_outer_diameter_cm"),
-        "confidence": result.get("confidence"),
-        "overall_best_size": ring_size.get("best_match"),
-        "overall_range_min": ring_size.get("range_min"),
-        "overall_range_max": ring_size.get("range_max"),
-        "photo_url": photo_public_url,
-        "result_url": result_public_url,
-        "result_json": result,
-        "fail_reason": result.get("fail_reason"),
-    })
-
     payload = {
         "success": result.get("fail_reason") is None,
         "result": result,
         "result_image_url": f"/results/{result_png_name}",
         "input_image_url": input_image_url,
         "result_json_url": f"/results/{result_json_name}",
-        "measurement_id": measurement_id,
     }
 
+    # Persist to Supabase in the background — do not block the response on
+    # storage uploads or DB inserts.
+    ring_size = result.get("ring_size", {})
+    _persist_measurement_async(
+        upload_path=upload_path,
+        upload_name=upload_name,
+        result_png_path=result_png_path,
+        result_png_name=result_png_name,
+        record={
+            "run_id": run_id,
+            "kol_name": kol_name,
+            "mode": "single",
+            "ring_model": ring_model,
+            "finger_index": finger_index,
+            "diameter_cm": result.get("finger_outer_diameter_cm"),
+            "confidence": result.get("confidence"),
+            "overall_best_size": ring_size.get("best_match"),
+            "overall_range_min": ring_size.get("range_min"),
+            "overall_range_max": ring_size.get("range_max"),
+            "result_json": result,
+            "fail_reason": result.get("fail_reason"),
+        },
+    )
+
     return jsonify(payload)
 
 
@@ -354,14 +393,6 @@ def _run_multi_measurement(
     result_json_path = RESULTS_DIR / result_json_name
     _save_json(result_json_path, result)
 
-    # --- Persist to Supabase ---
-    photo_public_url = None
-    result_public_url = None
-    if upload_path and upload_path.exists():
-        photo_public_url = upload_file(str(upload_path), f"photos/{upload_name}")
-    if result_png_path.exists():
-        result_public_url = upload_file(str(result_png_path), f"results/{result_png_name}")
-
     # Compute overall confidence from per-finger data
     confidences = [
         pf.get("confidence") for pf in per_finger.values()
@@ -369,22 +400,6 @@ def _run_multi_measurement(
     ]
     overall_confidence = min(confidences) if confidences else None
 
-    measurement_id = save_measurement({
-        "run_id": run_id,
-        "kol_name": kol_name,
-        "mode": "multi",
-        "ring_model": ring_model,
-        "overall_best_size": result.get("overall_best_size"),
-        "overall_range_min": result.get("overall_range_min"),
-        "overall_range_max": result.get("overall_range_max"),
-        "per_finger": per_finger,
-        "confidence": overall_confidence,
-        "photo_url": photo_public_url,
-        "result_url": result_public_url,
-        "result_json": result,
-        "fail_reason": result.get("fail_reason"),
-    })
-
     payload = {
         "success": result.get("fail_reason") is None,
         "mode": "multi",
@@ -392,9 +407,29 @@ def _run_multi_measurement(
         "result_image_url": f"/results/{result_png_name}",
         "input_image_url": input_image_url,
         "result_json_url": f"/results/{result_json_name}",
-        "measurement_id": measurement_id,
     }
 
+    # Persist to Supabase in the background.
+    _persist_measurement_async(
+        upload_path=upload_path,
+        upload_name=upload_name,
+        result_png_path=result_png_path,
+        result_png_name=result_png_name,
+        record={
+            "run_id": run_id,
+            "kol_name": kol_name,
+            "mode": "multi",
+            "ring_model": ring_model,
+            "overall_best_size": result.get("overall_best_size"),
+            "overall_range_min": result.get("overall_range_min"),
+            "overall_range_max": result.get("overall_range_max"),
+            "per_finger": per_finger,
+            "confidence": overall_confidence,
+            "result_json": result,
+            "fail_reason": result.get("fail_reason"),
+        },
+    )
+
     return jsonify(payload)
 
 

web_demo/templates/index.html

@@ -26,7 +26,7 @@
           <span class="file-hint">JPG / PNG supported · 1080p or higher recommended</span>
         </label>
 
-        <ul class="capture-tips">
+        <ul class="capture-tips" hidden>
           <li><strong>Turn on your phone's flash</strong>, it helps sharpen the finger edges.</li>
           <li><strong>Use plain white background</strong>, a sheet of paper works great.</li>
           <li><strong>Spread your fingers naturally</strong>, place the card beside your hand.</li>