Upload folder using huggingface_hub

measure_finger.py

@@ -31,6 +31,7 @@ from src.confidence import (
     compute_overall_confidence,
 )
 from src.debug_observer import draw_comprehensive_edge_overlay
+from src.ring_size import recommend_ring_size
 
 # Calibration coefficients (from regression on 60 measurements)
 _CALIBRATION_PATH = Path(__file__).parent / "src" / "calibration.json"
@@ -703,6 +704,11 @@ def measure_finger(
             width_data["median_width_cm"] = cal_cm
             width_data["raw_width_cm"] = raw_cm
 
+            # Add ring size for overlay
+            rec = recommend_ring_size(cal_cm)
+            if rec:
+                width_data["ring_size_rec"] = rec
+
             debug_image = draw_comprehensive_edge_overlay(
                 full_image=image_canonical,
                 edge_data=edge_data,
@@ -792,6 +798,13 @@ def main() -> int:
     else:
         result["calibration_applied"] = False
 
+    # Ring size recommendation (from calibrated diameter)
+    diameter = result.get("finger_outer_diameter_cm")
+    if diameter is not None:
+        rec = recommend_ring_size(diameter)
+        if rec:
+            result["ring_size"] = rec
+
     # Save output
     save_output(result, args.output)
     print(f"Results saved to: {args.output}")
@@ -804,6 +817,9 @@ def main() -> int:
         print(f"Finger diameter: {result['finger_outer_diameter_cm']} cm")
         if result.get("raw_diameter_cm"):
             print(f"  (raw: {result['raw_diameter_cm']} cm, calibrated)")
+        rec = result.get("ring_size")
+        if rec:
+            print(f"Ring size: best match {rec['best_match']}, recommended {rec['range_min']}-{rec['range_max']}")
         print(f"Confidence: {result['confidence']}")
         return 0
 

src/debug_observer.py

@@ -1203,9 +1203,16 @@ def draw_comprehensive_edge_overlay(
     if raw_cm is not None:
         width_label += f" (raw {raw_cm:.3f})"
 
+    # Ring size recommendation
+    ring_rec = width_data.get("ring_size_rec")
+    ring_label = ""
+    if ring_rec:
+        ring_label = f"  Ring Size: best {ring_rec['best_match']}, try {ring_rec['range_min']}-{ring_rec['range_max']}"
+
     annotations = [
         f"Sobel Edge Detection Results:",
         width_label,
+        ring_label,
         f"  Std Dev: {std_px:.2f} px",
         f"  Valid Edges: {np.sum(valid_rows)}/{len(valid_rows)} ({valid_pct:.1f}%)",
         f"  Measurements: {num_samples}",

src/ring_size.py

@@ -0,0 +1,54 @@
+"""Ring size recommendation from calibrated finger width."""
+
+from typing import Dict, Optional, Tuple
+
+# China standard ring size chart: size → inner diameter (mm)
+RING_SIZE_CHART = {
+    6: 16.9,
+    7: 17.7,
+    8: 18.6,
+    9: 19.4,
+    10: 20.3,
+    11: 21.1,
+    12: 21.9,
+    13: 22.7,
+}
+
+# Sorted sizes for lookup
+_SORTED_SIZES = sorted(RING_SIZE_CHART.items(), key=lambda x: x[1])
+
+
+def recommend_ring_size(diameter_cm: float) -> Optional[Dict]:
+    """Recommend ring size from calibrated finger outer diameter.
+
+    Returns dict with:
+        - best_match: nearest ring size (int)
+        - best_match_inner_mm: inner diameter of best match
+        - range_min / range_max: recommended 2-size range
+        - diameter_mm: input converted to mm
+    Returns None if diameter is out of reasonable range.
+    """
+    diameter_mm = diameter_cm * 10.0
+
+    if diameter_mm < 14.0 or diameter_mm > 26.0:
+        return None
+
+    # Find nearest size
+    best_size, best_inner = min(_SORTED_SIZES, key=lambda x: abs(x[1] - diameter_mm))
+
+    # Find second nearest size
+    second_size, second_inner = min(
+        (s for s in _SORTED_SIZES if s[0] != best_size),
+        key=lambda x: abs(x[1] - diameter_mm),
+    )
+
+    range_min = min(best_size, second_size)
+    range_max = max(best_size, second_size)
+
+    return {
+        "best_match": best_size,
+        "best_match_inner_mm": best_inner,
+        "range_min": range_min,
+        "range_max": range_max,
+        "diameter_mm": round(diameter_mm, 2),
+    }

web_demo/app.py

@@ -20,6 +20,7 @@ ROOT_DIR = Path(__file__).resolve().parents[1]
 sys.path.insert(0, str(ROOT_DIR))
 
 from measure_finger import measure_finger, apply_calibration
+from src.ring_size import recommend_ring_size
 
 APP_ROOT = Path(__file__).resolve().parent
 UPLOAD_DIR = APP_ROOT / "uploads"
@@ -127,8 +128,12 @@ def _run_measurement(
     raw_diameter = result.get("finger_outer_diameter_cm")
     if raw_diameter is not None:
         result["raw_diameter_cm"] = round(raw_diameter, 4)
-        result["finger_outer_diameter_cm"] = round(apply_calibration(raw_diameter), 4)
+        calibrated = round(apply_calibration(raw_diameter), 4)
+        result["finger_outer_diameter_cm"] = calibrated
         result["calibration_applied"] = True
+        rec = recommend_ring_size(calibrated)
+        if rec:
+            result["ring_size"] = rec
 
     result_json_name = f"{run_id}__result.json"
     result_json_path = RESULTS_DIR / result_json_name