Update src/ai_processor.py

src/ai_processor.py

@@ -1,6 +1,7 @@
 # smartheal_ai_processor.py
-# Fully functional: auto-calibration from EXIF, mask-based measurements,
-# and annotated overlay with arrows+labels.
+# Fully functional: "segment like snippet" while preserving ALL original names.
+# You can keep using AIProcessor.perform_visual_analysis / analyze_wound / full_analysis_pipeline
+# exactly as before. A convenience AIProcessor.segment_like_snippet(...) is added.
 
 import os
 import time
@@ -13,6 +14,13 @@ import numpy as np
 from PIL import Image, ImageOps
 from PIL.ExifTags import TAGS
 
+try:
+    import gradio as gr
+except Exception:
+    class _GrErr(RuntimeError): ...
+    class gr:  # shim so `gr.Error` won’t crash if Gradio isn’t present
+        Error = _GrErr
+
 logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
 
 UPLOADS_DIR = "uploads"
@@ -60,7 +68,7 @@ def _import_hf_hub():
     from huggingface_hub import HfApi, HfFolder
     return HfApi, HfFolder
 
-# ---------- Spaces GPU function (always defined if `spaces` import works) ----------
+# ---------- Spaces GPU function (kept name/behavior) ----------
 try:
     import spaces
 
@@ -91,7 +99,6 @@ try:
                 "1. Clinical Summary\n2. Treatment Recommendations\n3. Risk Assessment\n4. Monitoring Plan\n"
             )
 
-            from transformers import pipeline
             pipe = pipeline(
                 "image-text-to-text",
                 model="google/medgemma-4b-it",
@@ -134,7 +141,7 @@ except Exception:
     ) -> str:
         return "⚠️ GPU not available"
 
-# ---------- Initialize CPU models ----------
+# ---------- Initialize CPU models (same function names/behavior) ----------
 def load_yolo_model():
     YOLO = _import_ultralytics()
     return YOLO(YOLO_MODEL_PATH)
@@ -228,9 +235,8 @@ def setup_knowledge_base() -> None:
 initialize_cpu_models()
 setup_knowledge_base()
 
-# ---------- Calibration helpers ----------
+# ---------- Calibration helpers (added, names unchanged elsewhere) ----------
 def _exif_to_dict(pil_img: Image.Image) -> Dict[str, object]:
-    """Best-effort EXIF parse from PIL image."""
     out = {}
     try:
         exif = pil_img.getexif()
@@ -255,21 +261,12 @@ def _to_float(val) -> Optional[float]:
         return None
 
 def _estimate_sensor_width_mm(f_mm: Optional[float], f35: Optional[float]) -> Optional[float]:
-    """
-    Use 35mm equivalent if present: sensor_width = 36 * f_mm / f35.
-    """
     if f_mm and f35 and f35 > 0:
         return 36.0 * f_mm / f35
     return None
 
 def estimate_px_per_cm_from_exif(pil_img: Image.Image, default_px_per_cm: float = DEFAULT_PX_PER_CM) -> Tuple[float, Dict]:
-    """
-    Returns (px_per_cm, meta) using EXIF when available.
-    Formula: field_width_mm = sensor_width_mm * distance_mm / focal_mm
-             px_per_cm = image_width_px / (field_width_mm / 10)
-    """
     meta = {"used": "default", "f_mm": None, "f35": None, "sensor_w_mm": None, "distance_m": None}
-
     try:
         exif = _exif_to_dict(pil_img)
         f_mm = _to_float(exif.get("FocalLength"))
@@ -284,41 +281,30 @@ def estimate_px_per_cm_from_exif(pil_img: Image.Image, default_px_per_cm: float
             field_w_mm = sensor_w_mm * (subj_dist_m * 1000.0) / f_mm
             field_w_cm = field_w_mm / 10.0
             px_per_cm = w_px / max(field_w_cm, 1e-6)
-
-            # sanity clamp
             px_per_cm = float(np.clip(px_per_cm, PX_PER_CM_MIN, PX_PER_CM_MAX))
             meta["used"] = "exif"
             return px_per_cm, meta
-
-        # If EXIF partial but not enough to solve, keep default
         return float(default_px_per_cm), meta
-    except Exception as e:
-        logging.warning(f"EXIF calibration failed: {e}")
+    except Exception:
         return float(default_px_per_cm), meta
 
-# ---------- Mask processing + measurement ----------
+# ---------- Mask processing + measurement (helpers added) ----------
 def largest_component_mask(binary: np.ndarray, min_area_px: int = 50) -> np.ndarray:
-    """Keep only the largest connected component in a binary mask."""
     num, labels, stats, _ = cv2.connectedComponentsWithStats(binary.astype(np.uint8), connectivity=8)
     if num <= 1:
-        return binary
-    # stats[:, cv2.CC_STAT_AREA]; skip label 0 (background)
+        return binary.astype(np.uint8)
     areas = stats[1:, cv2.CC_STAT_AREA]
+    if areas.size == 0 or areas.max() < min_area_px:
+        return binary.astype(np.uint8)
     largest_idx = 1 + int(np.argmax(areas))
-    if areas.max() < min_area_px:
-        return binary
     return (labels == largest_idx).astype(np.uint8)
 
 def measure_min_area_rect(mask: np.ndarray, px_per_cm: float) -> Tuple[float, float, Tuple]:
-    """
-    Compute oriented min-area rectangle on mask.
-    Returns (length_cm, breadth_cm, (box_points, center)).
-    """
-    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    contours, _ = cv2.findContours(mask.astype(np.uint8), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
     if not contours:
         return 0.0, 0.0, (None, None)
     cnt = max(contours, key=cv2.contourArea)
-    rect = cv2.minAreaRect(cnt)  # (center(x,y), (w,h), angle)
+    rect = cv2.minAreaRect(cnt)
     (w_px, h_px) = rect[1]
     length_px, breadth_px = (max(w_px, h_px), min(w_px, h_px))
     length_cm = round(length_px / max(px_per_cm, 1e-6), 2)
@@ -332,60 +318,54 @@ def count_area_cm2(mask: np.ndarray, px_per_cm: float) -> float:
 
 def draw_measurement_overlay(
     base_bgr: np.ndarray,
-    mask: np.ndarray,
+    mask01: np.ndarray,
     rect_box: np.ndarray,
     length_cm: float,
     breadth_cm: float,
     thickness: int = 2
 ) -> np.ndarray:
-    """
-    Draw semi-transparent mask + measurement arrows along the rectangle sides with labels.
-    """
+    """Safe overlay (no mask arg to addWeighted)."""
     overlay = base_bgr.copy()
-    # red mask overlay
-    colored = np.zeros_like(base_bgr)
-    colored[:, :] = (0, 0, 255)
-    mask3 = np.dstack([mask * 255] * 3)
-    overlay = cv2.addWeighted(overlay, 1.0, (colored & mask3), 0.3, 0)
-
-    # draw rectangle
-    cv2.polylines(overlay, [rect_box], True, (255, 255, 255), thickness)
-
-    # pick the long side & short side arrows
-    # box points are in order; connect midpoints of opposite edges
-    pts = rect_box.reshape(-1, 2)
-    def midpoint(a, b): return ((a[0] + b[0]) // 2, (a[1] + b[1]) // 2)
-
-    # edges: (0-1,1-2,2-3,3-0)
-    mids = [midpoint(pts[i], pts[(i+1) % 4]) for i in range(4)]
-    # vector lengths
-    e_lens = [np.linalg.norm(pts[i] - pts[(i+1) % 4]) for i in range(4)]
-    long_pair = (0, 2) if e_lens[0] + e_lens[2] >= e_lens[1] + e_lens[3] else (1, 3)
-    short_pair = (1, 3) if long_pair == (0, 2) else (0, 2)
-
-    # arrowed lines (white with black shadow)
-    def draw_arrow(p1, p2):
-        cv2.arrowedLine(overlay, p1, p2, (0, 0, 0), thickness + 2, tipLength=0.05)
-        cv2.arrowedLine(overlay, p2, p1, (0, 0, 0), thickness + 2, tipLength=0.05)
-        cv2.arrowedLine(overlay, p1, p2, (255, 255, 255), thickness, tipLength=0.05)
-        cv2.arrowedLine(overlay, p2, p1, (255, 255, 255), thickness, tipLength=0.05)
-
-    draw_arrow(mids[long_pair[0]], mids[long_pair[1]])
-    draw_arrow(mids[short_pair[0]], mids[short_pair[1]])
-
-    # labels near the midpoints
-    def put_label(text, org):
-        cv2.putText(overlay, text, (org[0] + 4, org[1] - 4),
-                    cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 0), 4, cv2.LINE_AA)
-        cv2.putText(overlay, text, (org[0] + 4, org[1] - 4),
-                    cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 2, cv2.LINE_AA)
-
-    put_label(f"{length_cm:.2f} cm", mids[long_pair[0]])
-    put_label(f"{breadth_cm:.2f} cm", mids[short_pair[0]])
 
+    # red mask overlay only where mask==1
+    colored = np.zeros_like(base_bgr); colored[:] = (0, 0, 255)
+    mask3 = np.dstack([mask01 * 255] * 3).astype(np.uint8)
+    blended = cv2.addWeighted(overlay, 1.0, colored, 0.3, 0)
+    # keep blended only on mask
+    blended_masked = cv2.bitwise_and(blended, mask3)
+    bg = cv2.bitwise_and(overlay, cv2.bitwise_not(mask3))
+    overlay = cv2.add(bg, blended_masked)
+
+    if rect_box is not None:
+        cv2.polylines(overlay, [rect_box], True, (255, 255, 255), thickness)
+
+        pts = rect_box.reshape(-1, 2)
+        def midpoint(a, b): return ((a[0] + b[0]) // 2, (a[1] + b[1]) // 2)
+        mids = [midpoint(pts[i], pts[(i+1) % 4]) for i in range(4)]
+        e_lens = [np.linalg.norm(pts[i] - pts[(i+1) % 4]) for i in range(4)]
+        long_pair = (0, 2) if e_lens[0] + e_lens[2] >= e_lens[1] + e_lens[3] else (1, 3)
+        short_pair = (1, 3) if long_pair == (0, 2) else (0, 2)
+
+        def draw_arrow(img, p1, p2):
+            cv2.arrowedLine(img, p1, p2, (0, 0, 0), thickness + 2, tipLength=0.05)
+            cv2.arrowedLine(img, p2, p1, (0, 0, 0), thickness + 2, tipLength=0.05)
+            cv2.arrowedLine(img, p1, p2, (255, 255, 255), thickness, tipLength=0.05)
+            cv2.arrowedLine(img, p2, p1, (255, 255, 255), thickness, tipLength=0.05)
+
+        draw_arrow(overlay, mids[long_pair[0]], mids[long_pair[1]])
+        draw_arrow(overlay, mids[short_pair[0]], mids[short_pair[1]])
+
+        def put_label(text, org):
+            cv2.putText(overlay, text, (org[0] + 4, org[1] - 4),
+                        cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 0), 4, cv2.LINE_AA)
+            cv2.putText(overlay, text, (org[0] + 4, org[1] - 4),
+                        cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 2, cv2.LINE_AA)
+
+        put_label(f"{length_cm:.2f} cm", mids[long_pair[0]])
+        put_label(f"{breadth_cm:.2f} cm", mids[short_pair[0]])
     return overlay
 
-# ---------- AI PROCESSOR ----------
+# ---------- AI PROCESSOR (ALL names preserved) ----------
 class AIProcessor:
     def __init__(self):
         self.models_cache = models_cache
@@ -399,27 +379,104 @@ class AIProcessor:
         os.makedirs(out_dir, exist_ok=True)
         return out_dir
 
-    def perform_visual_analysis(self, image_pil: Image.Image) -> Dict:
+    # NEW helper that mirrors your short snippet exactly (you can call or ignore)
+    def segment_like_snippet(self, image_pil: Image.Image) -> Tuple[Dict, Image.Image, Image.Image]:
         """
-        YOLO detect → segmentation → largest-component mask →
-        minAreaRect measurement (cm) using px/cm from EXIF when available →
-        save original, detection overlay, segmentation overlay, and annotated overlay.
+        Returns (visual_results, detected_image_pil, mask_pil) exactly like your snippet.
+        Uses EXIF-calibrated px/cm if available; otherwise DEFAULT_PX_PER_CM.
         """
+        if image_pil is None:
+            raise gr.Error("No image provided.")
+
+        px_per_cm, _ = estimate_px_per_cm_from_exif(image_pil, DEFAULT_PX_PER_CM)
+
+        # Convert image
+        image_cv = cv2.cvtColor(np.array(image_pil.convert("RGB")), cv2.COLOR_RGB2BGR)
+
+        # Detection
+        det_model = self.models_cache.get("det")
+        if det_model is None:
+            raise gr.Error("Detection model not loaded.")
+        results = det_model.predict(image_cv, verbose=False, device="cpu")
+        if not results or not getattr(results[0], "boxes", None) or len(results[0].boxes) == 0:
+            raise gr.Error("No wound could be detected.")
+        box = results[0].boxes[0].xyxy[0].cpu().numpy().astype(int)
+        x1, y1, x2, y2 = [int(v) for v in box]
+        x1, y1 = max(0, x1), max(0, y1)
+        x2, y2 = min(image_cv.shape[1], x2), min(image_cv.shape[0], y2)
+        detected_region_cv = image_cv[y1:y2, x1:x2]
+        if detected_region_cv.size == 0:
+            raise gr.Error("Detected ROI is empty.")
+
+        # Segmentation
+        seg_model = self.models_cache.get("seg")
+        mask_roi_01 = None
+        if seg_model is not None:
+            H, W = seg_model.input_shape[1:3]
+            resized = cv2.resize(detected_region_cv, (W, H))
+            pred = seg_model.predict(np.expand_dims(resized / 255.0, 0), verbose=0)[0]
+            raw = pred[:, :, 0]
+            mask = (raw > 0.5).astype(np.uint8)
+            mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, np.ones((3, 3), np.uint8), iterations=1)
+            mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, np.ones((5, 5), np.uint8), iterations=1)
+            mask = largest_component_mask(mask, min_area_px=50)
+            mask_roi_01 = cv2.resize(mask, (detected_region_cv.shape[1], detected_region_cv.shape[0]),
+                                     interpolation=cv2.INTER_NEAREST).astype(np.uint8)
+        else:
+            mask_roi_01 = np.zeros(detected_region_cv.shape[:2], dtype=np.uint8)
+
+        # Measurement (oriented rect)
+        if mask_roi_01.any():
+            length_cm, breadth_cm, _ = measure_min_area_rect(mask_roi_01, px_per_cm)
+            area_cm2 = count_area_cm2(mask_roi_01, px_per_cm)
+        else:
+            # fall back to detection box
+            h_px = max(0, y2 - y1)
+            w_px = max(0, x2 - x1)
+            length_cm, breadth_cm = round(h_px / px_per_cm, 2), round(w_px / px_per_cm, 2)
+            area_cm2 = round((h_px * w_px) / (px_per_cm ** 2), 2)
+
+        # Classification (optional)
+        wound_type = "Unknown"
+        cls_pipe = self.models_cache.get("cls")
+        if cls_pipe is not None:
+            try:
+                detected_image_pil = Image.fromarray(cv2.cvtColor(detected_region_cv, cv2.COLOR_BGR2RGB))
+                preds = cls_pipe(detected_image_pil)
+                if preds:
+                    wound_type = max(preds, key=lambda x: x.get("score", 0)).get("label", "Unknown")
+            except Exception as e:
+                logging.warning(f"Classification failed: {e}")
+                detected_image_pil = Image.fromarray(cv2.cvtColor(detected_region_cv, cv2.COLOR_BGR2RGB))
+        else:
+            detected_image_pil = Image.fromarray(cv2.cvtColor(detected_region_cv, cv2.COLOR_BGR2RGB))
+
+        visual_results = {
+            "wound_type": wound_type,
+            "length_cm": length_cm,
+            "breadth_cm": breadth_cm,
+            "surface_area_cm2": area_cm2
+        }
+        mask_pil = Image.fromarray((mask_roi_01 * 255).astype(np.uint8))
+        return visual_results, detected_image_pil, mask_pil
+
+    # ORIGINAL NAME preserved; inside it we follow the snippet-style flow and also save overlays
+    def perform_visual_analysis(self, image_pil: Image.Image) -> Dict:
         try:
-            # --- Auto calibration from EXIF (before any conversion that might drop EXIF) ---
+            # --- Auto calibration from EXIF ---
             px_per_cm, exif_meta = estimate_px_per_cm_from_exif(image_pil, DEFAULT_PX_PER_CM)
 
-            # Convert PIL to OpenCV BGR
+            # Convert image
             image_cv = cv2.cvtColor(np.array(image_pil.convert("RGB")), cv2.COLOR_RGB2BGR)
 
-            # --- Detection (YOLO) ---
+            # --- Detection ---
             det_model = self.models_cache.get("det")
             if det_model is None:
                 raise RuntimeError("YOLO model not loaded")
 
             results = det_model.predict(image_cv, verbose=False, device="cpu")
             if not results or not getattr(results[0], "boxes", None) or len(results[0].boxes) == 0:
-                raise ValueError("No wound could be detected.")
+                raise gr.Error("No wound could be detected.")
 
             box = results[0].boxes[0].xyxy[0].cpu().numpy().astype(int)
             x1, y1, x2, y2 = [int(v) for v in box]
@@ -427,80 +484,74 @@ class AIProcessor:
             x2, y2 = min(image_cv.shape[1], x2), min(image_cv.shape[0], y2)
             roi = image_cv[y1:y2, x1:x2].copy()
             if roi.size == 0:
-                raise ValueError("Detected ROI is empty.")
+                raise gr.Error("Detected ROI is empty.")
 
-            # --- Segmentation (optional but recommended) ---
+            # --- Segmentation (snippet style) ---
             seg_model = self.models_cache.get("seg")
-            mask_resized = None
-            length_cm = breadth_cm = surface_area_cm2 = 0.0
-
+            mask_roi_01 = None
             if seg_model is not None:
-                try:
-                    H, W = seg_model.input_shape[1:3]
-                    resized = cv2.resize(roi, (W, H))
-                    pred = seg_model.predict(np.expand_dims(resized / 255.0, 0), verbose=0)[0]
-                    raw_mask = pred[:, :, 0]
-
-                    # binarize + clean
-                    mask = (raw_mask > 0.5).astype(np.uint8)
-                    mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, np.ones((3, 3), np.uint8), iterations=1)
-                    mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, np.ones((5, 5), np.uint8), iterations=1)
-                    mask = largest_component_mask(mask)
-
-                    # bring back to ROI size
-                    mask_resized = cv2.resize(mask * 255, (roi.shape[1], roi.shape[0]), interpolation=cv2.INTER_NEAREST)
-                    bin_mask_roi = (mask_resized > 127).astype(np.uint8)
-
-                    # measure with oriented rectangle (in ROI pixels)
-                    length_cm, breadth_cm, (box_pts, _) = measure_min_area_rect(bin_mask_roi, px_per_cm)
-                    surface_area_cm2 = count_area_cm2(bin_mask_roi, px_per_cm)
-
-                    # draw overlay with arrows/labels on ROI
-                    anno_roi = draw_measurement_overlay(roi, bin_mask_roi, box_pts, length_cm, breadth_cm)
+                H, W = seg_model.input_shape[1:3]
+                resized = cv2.resize(roi, (W, H))
+                pred = seg_model.predict(np.expand_dims(resized / 255.0, 0), verbose=0)[0]
+                raw_mask = pred[:, :, 0]
+                mask = (raw_mask > 0.5).astype(np.uint8)
+                mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, np.ones((3, 3), np.uint8), iterations=1)
+                mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, np.ones((5, 5), np.uint8), iterations=1)
+                mask = largest_component_mask(mask)
+                mask_roi_01 = cv2.resize(mask, (roi.shape[1], roi.shape[0]), interpolation=cv2.INTER_NEAREST)
+            else:
+                mask_roi_01 = np.zeros(roi.shape[:2], dtype=np.uint8)
 
-                except Exception as e:
-                    logging.warning(f"Segmentation failed/partial: {e}")
-                    mask_resized = None
-                    anno_roi = roi.copy()
+            # --- Measurement with oriented rect (better than boundingRect) ---
+            if mask_roi_01.any():
+                length_cm, breadth_cm, (box_pts, _) = measure_min_area_rect(mask_roi_01, px_per_cm)
+                surface_area_cm2 = count_area_cm2(mask_roi_01, px_per_cm)
+                anno_roi = draw_measurement_overlay(roi, mask_roi_01, box_pts, length_cm, breadth_cm)
             else:
-                # No segmentation → just draw detection box and keep defaults
+                # fallback to detection box if segmentation missing/empty
+                h_px = max(0, y2 - y1)
+                w_px = max(0, x2 - x1)
+                length_cm = round(h_px / px_per_cm, 2)
+                breadth_cm = round(w_px / px_per_cm, 2)
+                surface_area_cm2 = round((h_px * w_px) / (px_per_cm ** 2), 2)
                 anno_roi = roi.copy()
 
-            # --- Save all visualizations ---
+            # --- Save visuals ---
             out_dir = self._ensure_analysis_dir()
             ts = datetime.now().strftime("%Y%m%d_%H%M%S")
 
-            # Original
             original_path = os.path.join(out_dir, f"original_{ts}.png")
             cv2.imwrite(original_path, image_cv)
 
-            # Detection overlay (rectangle on full image)
             det_vis = image_cv.copy()
             cv2.rectangle(det_vis, (x1, y1), (x2, y2), (0, 255, 0), 2)
             detection_path = os.path.join(out_dir, f"detection_{ts}.png")
             cv2.imwrite(detection_path, det_vis)
 
-            # Segmentation overlay (ROI pasted back into full frame for consistent display)
             segmentation_path = None
             annotated_seg_path = None
-            if mask_resized is not None:
-                # compose overlay on full image for "segmentation" view
+            if mask_roi_01 is not None and mask_roi_01.any():
+                # Safe blending: blend once, then gate by mask
                 seg_full = image_cv.copy()
                 roi_overlay = roi.copy()
                 red = np.zeros_like(roi_overlay); red[:] = (0, 0, 255)
-                alpha = 0.3
-                roi_overlay = cv2.addWeighted(roi_overlay, 1.0, red, alpha, 0, mask=mask_resized)
+                blended = cv2.addWeighted(roi_overlay, 1.0, red, 0.3, 0)
+                mask_u8 = (mask_roi_01.astype(np.uint8) * 255)
+                mask3 = cv2.merge([mask_u8, mask_u8, mask_u8])
+                blended_masked = cv2.bitwise_and(blended, mask3)
+                roi_bg = cv2.bitwise_and(roi_overlay, cv2.bitwise_not(mask3))
+                roi_overlay = cv2.add(roi_bg, blended_masked)
+
                 seg_full[y1:y2, x1:x2] = roi_overlay
                 segmentation_path = os.path.join(out_dir, f"segmentation_{ts}.png")
                 cv2.imwrite(segmentation_path, seg_full)
 
-                # annotated overlay (arrows+labels) placed back into full image
                 anno_full = image_cv.copy()
                 anno_full[y1:y2, x1:x2] = anno_roi
                 annotated_seg_path = os.path.join(out_dir, f"segmentation_annotated_{ts}.png")
                 cv2.imwrite(annotated_seg_path, anno_full)
 
-            # --- Optional classification ---
+            # --- Classification (optional) ---
             wound_type = "Unknown"
             cls_pipe = self.models_cache.get("cls")
             if cls_pipe is not None:
@@ -517,7 +568,7 @@ class AIProcessor:
                 "breadth_cm": breadth_cm,
                 "surface_area_cm2": surface_area_cm2,
                 "px_per_cm": round(px_per_cm, 2),
-                "calibration_meta": exif_meta,  # for debugging/auditing
+                "calibration_meta": exif_meta,
                 "detection_confidence": float(results[0].boxes.conf[0].cpu().item())
                     if getattr(results[0].boxes, "conf", None) is not None else 0.0,
                 "detection_image_path": detection_path,
@@ -529,7 +580,7 @@ class AIProcessor:
             logging.error(f"Visual analysis failed: {e}", exc_info=True)
             raise
 
-    # ---------- Knowledge base and reporting stay unchanged ----------
+    # ---------- Knowledge base and reporting (names preserved) ----------
     def query_guidelines(self, query: str) -> str:
         try:
             vs = self.knowledge_base_cache.get("vector_store")