Adding Radio button

app.py

@@ -1,102 +1,107 @@
 import gradio as gr
 import numpy as np
 from ultralytics import YOLO
-# import cv2
+import cv2
 from weld_tiling import detect_tiled_softnms, draw_detections
 
 # Load model once at startup
-model = YOLO("best_7-15-25.pt")
+MODEL = YOLO("best_7-15-25.pt")
 
 # Class names (must match your training config)
-CLASS_NAMES = [
-    "Valve", "Butterfly Valve", "Flange", "PRV", "Reducer",
-    "shop_bw", "shop_sw", "Union", "Weld-o-let",
-    "field_bw", "field_sw", "Insulation"
-]
-
-# def detect_weld_types(image: np.ndarray) -> tuple[np.ndarray, str]:
-#     try:
-#         # I'm not sure how to apply this to the original existing code
-#         results = detect_tiled_softnms(
-#         model, image,
-#         tile_size=1024, overlap=0.23,
-#         per_tile_conf=0.2, per_tile_iou=0.7,
-#         softnms_iou=0.6, softnms_method="hard", softnms_sigma=0.5,
-#         final_conf=0.38, device=None, imgsz=1280
-#         )
-#         # results = model(image)
-#
-#         boxes = results[0].boxes
-#         class_ids = boxes.cls.cpu().numpy().astype(int) if boxes.cls is not None else []
-#
-#         weld_counts = {}
-#         for cls_id in class_ids:
-#             if 0 <= cls_id < len(CLASS_NAMES):
-#                 name = CLASS_NAMES[cls_id]
-#                 weld_counts[name] = weld_counts.get(name, 0) + 1
-#
-#         annotated_img = results[0].plot()  # BGR
-#         annotated_img = cv2.cvtColor(annotated_img, cv2.COLOR_BGR2RGB)
-#
-#         weld_summary = "\n".join(f"{k}: {v}" for k, v in weld_counts.items()) or "No weld types found."
-#
-#         return annotated_img, str(weld_summary)
-#
-#     except Exception as e:
-#         print("Error:", e)
-#         # Ensure fallback types are strictly correct
-#         return image, "Detection error occurred."
-
-
-# Build Gradio UI
-
-def detect_weld_types(image: np.ndarray) -> tuple[np.ndarray, str]:
-    """
-    Gradio expects/returns RGB numpy arrays. The tiler also works in RGB.
-    """
-    try:
-        # Run tiled inference
-        out = detect_tiled_softnms(
-            model, image,
-            tile_size=1024, overlap=0.23,
-            per_tile_conf=0.20, per_tile_iou=0.70,
-            softnms_iou=0.60, softnms_method="hard", softnms_sigma=0.50,
-            final_conf=0.38,
-            imgsz=1280,          # keep >= tile_size; int or [h, w]
-            device=None
-        )
-
-        boxes = out["boxes"]      # (N,4) xyxy in full-image pixels
-        confs = out["conf"]       # (N,)
-        cls_ids = out["cls"]      # (N,)
-        class_names = out["names"]     # {id: name}
-
-        # Count per class using model-provided names
-        counts = {}
-        for cid in cls_ids:
-            cname = class_names.get(int(cid), str(int(cid)))
-            counts[cname] = counts.get(cname, 0) + 1
-
-        # Make an annotated image (RGB in, RGB out)
-        annotated_img = draw_detections(image.copy(), boxes, confs, cls_ids, class_names)
-
-        # Pretty summary text (sorted by count desc)
-        if counts:
-            summary_lines = [f"{k}: {v}" for k, v in sorted(counts.items(), key=lambda kv: -kv[1])]
-            summary = "\n".join(summary_lines)
+# CLASS_NAMES = [
+#     "Valve", "Butterfly Valve", "Flange", "PRV", "Reducer",
+#     "shop_bw", "shop_sw", "Union", "Weld-o-let",
+#     "field_bw", "field_sw", "Insulation"
+# ]
+
+class DetectWelds:
+    def __init__(self):
+        self.model = MODEL
+        self.class_names = [
+            "Valve", "Butterfly Valve", "Flange", "PRV", "Reducer", "shop_bw",
+            "shop_sw", "Union", "Weld-o-let", "field_bw", "field_sw", "Insulation"
+        ]
+
+    def weld_detection(self, input_image: np.ndarray, prediction_type):
+        if prediction_type == "tiling":
+            annotated_image, welds = self.detect_weld_types(input_image)
         else:
-            summary = "No weld types found."
+            annotated_image, welds = self.detect_weld_types_no_tiling(input_image)
+        return annotated_image, welds
+
+    def detect_weld_types_no_tiling(self, image: np.ndarray) -> tuple[np.ndarray, str]:
+        try:
+            results = self.model(image)
+            boxes = results[0].boxes
+            class_ids = boxes.cls.cpu().numpy().astype(int) if boxes.cls is not None else []
+            weld_counts = {}
+            for cls_id in class_ids:
+                if 0 <= cls_id < len(self.class_names):
+                    name = self.class_names[cls_id]
+                    weld_counts[name] = weld_counts.get(name, 0) + 1
+
+            annotated_img = results[0].plot()  # BGR
+            annotated_img = cv2.cvtColor(annotated_img, cv2.COLOR_BGR2RGB)
+
+            weld_summary = "\n".join(f"{k}: {v}" for k, v in weld_counts.items()) or "No weld types found."
+
+            return annotated_img, str(weld_summary)
+
+        except Exception as e:
+            print("Error:", e)
+            # Ensure fallback types are strictly correct
+            return image, "Detection error occurred."
 
-        return annotated_img, summary
+    def detect_weld_types(self, image: np.ndarray) -> tuple[np.ndarray, str]:
+        """
+        Gradio expects/returns RGB numpy arrays. The tiler also works in RGB.
+        """
+        try:
+            # Run tiled inference
+            out = detect_tiled_softnms(
+                self.model, image,
+                tile_size=512, overlap=0.23,
+                per_tile_conf=0.20, per_tile_iou=0.70,
+                softnms_iou=0.60, softnms_method="hard", softnms_sigma=0.50,
+                final_conf=0.5,
+                imgsz=1280,          # keep >= tile_size; int or [h, w]
+                device=None
+            )
 
-    except Exception as e:
-        print("Error in detect_weld_types:", repr(e))
-        return image, "Detection error occurred."
+            boxes = out["boxes"]      # (N,4) xyxy in full-image pixels
+            confs = out["conf"]       # (N,)
+            cls_ids = out["cls"]      # (N,)
+            class_names = out["names"]     # {id: name}
+
+            # Count per class using model-provided names
+            counts = {}
+            for cid in cls_ids:
+                cname = class_names.get(int(cid), str(int(cid)))
+                counts[cname] = counts.get(cname, 0) + 1
+
+            # Make an annotated image (RGB in, RGB out)
+            annotated_img = draw_detections(image.copy(), boxes, confs, cls_ids, class_names)
+
+            # Pretty summary text (sorted by count desc)
+            if counts:
+                summary_lines = [f"{k}: {v}" for k, v in sorted(counts.items(), key=lambda kv: -kv[1])]
+                summary = "\n".join(summary_lines)
+            else:
+                summary = "No weld types found."
+
+            return annotated_img, summary
+
+        except Exception as e:
+            print("Error in detect_weld_types:", repr(e))
+            return image, "Detection error occurred."
 
 
 app = gr.Interface(
-    fn=detect_weld_types,
-    inputs=gr.Image(type="numpy", label="Upload a welding diagram"),
+    fn=DetectWelds().weld_detection,
+    inputs=[
+        gr.Image(type="numpy", label="Upload a welding diagram"),
+        gr.Radio(['tiling', 'no tiling'], label="Tiling Option", value="tiling")
+    ],
     outputs=[
         gr.Image(type="numpy", label="Detected Welds"),
         gr.Textbox(label="Weld Types Found")

weld_tiling.py

@@ -173,7 +173,7 @@ def detect_tiled_softnms(
         # ✅ Ultralytics now requires imgsz as int or [h,w]
         resolved_imgsz = tile_size if imgsz is None else imgsz
 
-        results = model.predict(
+        results = model(
             source=tile,
             conf=per_tile_conf,
             iou=per_tile_iou,