Update app.py

app.py

@@ -3,19 +3,18 @@ Gradio app to compare object‑detection models:
   • Ultralytics YOLOv12 (n, s, m, l, x)
   • Ultralytics YOLOv11 (n, s, m, l, x)
   • Roboflow RF‑DETR (Base, Large)
-  • Custom fine‑tuned checkpoints for either framework (upload .pt/.pth files)
+  • Custom fine‑tuned checkpoints (.pt/.pth upload)
 
-Revision 2025‑04‑19‑b:
-  • Fixed indentation error in error‑handling branch.
-  • Unavailable weights report as concise messages.
-  • Bounding boxes: 2 px, 60 % opacity.
+Revision 2025‑04‑19‑c:
+  • Re‑indented entire file with 4‑space consistency to remove `IndentationError`.
+  • Thin, semi‑transparent 60 % boxes; concise error labels.
 """
 
 from __future__ import annotations
 
 import time
 from pathlib import Path
-from typing import List, Tuple, Dict, Optional
+from typing import Dict, List, Optional, Tuple
 
 import cv2
 import numpy as np
@@ -30,7 +29,7 @@ from rfdetr.util.coco_classes import COCO_CLASSES
 # Model registry & lazy loader
 ###############################################################################
 
-YOLO_MODEL_MAP = {
+YOLO_MODEL_MAP: Dict[str, str] = {
     "YOLOv12‑n": "yolov12n.pt",
     "YOLOv12‑s": "yolov12s.pt",
     "YOLOv12‑m": "yolov12m.pt",
@@ -56,64 +55,81 @@ ALL_MODELS = list(YOLO_MODEL_MAP.keys()) + list(RFDETR_MODEL_MAP.keys()) + [
 _loaded: Dict[str, object] = {}
 
 def load_model(choice: str, custom_file: Optional[Path] = None):
+    """Return and cache a detector matching *choice*."""
     if choice in _loaded:
         return _loaded[choice]
+
     try:
         if choice in YOLO_MODEL_MAP:
-            mdl = YOLO(YOLO_MODEL_MAP[choice])
+            model = YOLO(YOLO_MODEL_MAP[choice])
         elif choice in RFDETR_MODEL_MAP:
-            mdl = RFDETRBase() if RFDETR_MODEL_MAP[choice] == "base" else RFDETRLarge()
+            model = RFDETRBase() if RFDETR_MODEL_MAP[choice] == "base" else RFDETRLarge()
         elif choice.startswith("Custom YOLO"):
-            if not custom_file:
+            if custom_file is None:
                 raise ValueError("Upload a YOLO .pt/.pth checkpoint first.")
-            mdl = YOLO(str(custom_file))
+            model = YOLO(str(custom_file))
         elif choice.startswith("Custom RF‑DETR"):
-            if not custom_file:
+            if custom_file is None:
                 raise ValueError("Upload an RF‑DETR .pth checkpoint first.")
-            mdl = RFDETRBase(pretrain_weights=str(custom_file))
+            model = RFDETRBase(pretrain_weights=str(custom_file))
         else:
             raise ValueError(f"Unsupported model choice: {choice}")
-    except Exception as e:
-        raise RuntimeError(str(e)) from e
-    _loaded[choice] = mdl
-    return mdl
+    except Exception as exc:
+        raise RuntimeError(str(exc)) from exc
+
+    _loaded[choice] = model
+    return model
 
 ###############################################################################
 # Inference helpers
 ###############################################################################
 
-box_annotator = sv.BoxAnnotator(thickness=2)
+BOX_THICKNESS = 2
+BOX_ALPHA = 0.6
+
+box_annotator = sv.BoxAnnotator(thickness=BOX_THICKNESS)
 label_annotator = sv.LabelAnnotator()
 
-def blend_overlay(base_np: np.ndarray, overlay_np: np.ndarray, alpha: float = 0.6) -> np.ndarray:
-    return cv2.addWeighted(overlay_np, alpha, base_np, 1 - alpha, 0)
+def _blend(base: np.ndarray, overlay: np.ndarray, alpha: float = BOX_ALPHA) -> np.ndarray:
+    return cv2.addWeighted(overlay, alpha, base, 1 - alpha, 0)
 
 def run_single_inference(model, image: Image.Image, threshold: float) -> Tuple[Image.Image, float]:
     start = time.perf_counter()
+
     if isinstance(model, (RFDETRBase, RFDETRLarge)):
         detections = model.predict(image, threshold=threshold)
-        label_source = COCO_CLASSES
+        label_src = COCO_CLASSES
     else:
-        result = model.predict(image, verbose=False)[0]
-        detections = sv.Detections.from_ultralytics(result)
-        label_source = model.names
+        ul_result = model.predict(image, verbose=False)[0]
+        detections = sv.Detections.from_ultralytics(ul_result)
+        label_src = model.names  # type: ignore
+
     runtime = time.perf_counter() - start
-    img_np = cv2.cvtColor(np.array(image), cv2.COLOR_RGB2BGR)
-    overlay = img_np.copy()
+
+    base_bgr = cv2.cvtColor(np.array(image), cv2.COLOR_RGB2BGR)
+    overlay = base_bgr.copy()
+
     overlay = box_annotator.annotate(overlay, detections)
     overlay = label_annotator.annotate(
         overlay,
         detections,
-        [f"{label_source[c]} {p:.2f}" for c, p in zip(detections.class_id, detections.confidence)],
+        [f"{label_src[cid]} {conf:.2f}" for cid, conf in zip(detections.class_id, detections.confidence)],
     )
-    blended = blend_overlay(img_np, overlay, alpha=0.6)
-    return Image.fromarray(cv2.cvtColor(blended, cv2.COLOR_BGR2RGB)), runtime
+
+    blended = _blend(base_bgr, overlay)
+    out_pil = Image.fromarray(cv2.cvtColor(blended, cv2.COLOR_BGR2RGB))
+    return out_pil, runtime
 
 ###############################################################################
 # Gradio callback
 ###############################################################################
 
-def compare_models(models: List[str], img: Image.Image, threshold: float, custom_file: Optional[Path]):
+def compare_models(
+    models: List[str],
+    img: Image.Image,
+    threshold: float,
+    custom_file: Optional[Path],
+):
     if img is None:
         raise gr.Error("Please upload an image first.")
     if img.mode != "RGB":
@@ -122,42 +138,46 @@ def compare_models(models: List[str], img: Image.Image, threshold: float, custom
     results: List[Image.Image] = []
     legends: Dict[str, str] = {}
 
-    for m in models:
+    for model_name in models:
         try:
-            model_obj = load_model(m, custom_file)
-            annotated, t = run_single_inference(model_obj, img, threshold)
+            detector = load_model(model_name, custom_file)
+            annotated, latency = run_single_inference(detector, img, threshold)
             results.append(annotated)
-            legends[m] = f"{t*1000:.1f} ms"
-        except Exception as e:
+            legends[model_name] = f"{latency*1000:.1f} ms"
+        except Exception as exc:
             results.append(Image.new("RGB", img.size, (40, 40, 40)))
-            err_msg = str(e)
-            if "No such file" in err_msg or "not found" in err_msg:
-                legends[m] = "Unavailable (weights not found)"
+            emsg = str(exc)
+            if "No such file" in emsg or "not found" in emsg:
+                legends[model_name] = "Unavailable (weights not found)"
             else:
-                legends[m] = f"ERROR: {err_msg.splitlines()[0][:120]}"
+                legends[model_name] = f"ERROR: {emsg.splitlines()[0][:120]}"
 
     return results, legends
 
 ###############################################################################
-# UI
+# Gradio UI
 ###############################################################################
 
 def build_demo():
     with gr.Blocks(title="CV Model Comparison") as demo:
         gr.Markdown(
-            """# 🔍 Compare Object‑Detection Models\nUpload an image, choose detectors, and optionally add a custom checkpoint.\nBounding boxes are thin and 60 % opaque for clarity."""
+            """# 🔍 Compare Object‑Detection Models\nUpload an image, choose detectors, and optionally add a custom checkpoint.\nBounding boxes are thin (2 px) and 60 % transparent for clarity."""
         )
+
         with gr.Row():
-            model_select = gr.CheckboxGroup(ALL_MODELS, value=["YOLOv12‑n"], label="Select models")
-            threshold_slider = gr.Slider(0.0, 1.0, 0.5, 0.05, label="Confidence threshold")
-        custom_file = gr.File(label="Upload custom checkpoint (.pt/.pth)", file_types=[".pt", ".pth"], interactive=True)
-        image_in = gr.Image(type="pil", label="Image", sources=["upload", "webcam"])
+            sel_models = gr.CheckboxGroup(ALL_MODELS, value=["YOLOv12‑n"], label="Models")
+            conf_slider = gr.Slider(0.0, 1.0, 0.5, 0.05, label="Confidence")
+
+        ckpt_file = gr.File(label="Custom checkpoint (.pt/.pth)", file_types=[".pt", ".pth"], interactive=True)
+        img_in = gr.Image(type="pil", label="Image", sources=["upload", "webcam"])
+
         with gr.Row():
-            gallery = gr.Gallery(label="Annotated results", columns=2, height="auto")
-        legends_out = gr.JSON(label="Latency / status by model")
-        gr.Button("Run Inference", variant="primary").click(
-            compare_models, [model_select, image_in, threshold_slider, custom_file], [gallery, legends_out]
-        )
+            gallery = gr.Gallery(label="Results", columns=2, height="auto")
+        legend_out = gr.JSON(label="Latency / status by model")
+
+        run_btn = gr.Button("Run Inference", variant="primary")
+        run_btn.click(compare_models, [sel_models, img_in, conf_slider, ckpt_file], [gallery, legend_out])
+
     return demo
 
 if __name__ == "__main__":