GeoViG Debug: Add detailed logging for model inference

app.py

@@ -104,8 +104,14 @@ def _draw_detections(image: Image.Image, result, score_thr=0.3):
     draw = ImageDraw.Draw(img_draw)
     seg_np_img = np.array(image.convert("RGB"))
     
+    print(f"DEBUG: Result type: {type(result)}")
+    if isinstance(result, (list, tuple)):
+        print(f"DEBUG: Result length: {len(result)}")
+        if len(result) > 0:
+            print(f"DEBUG: [0] type: {type(result[0])}")
+    
     # Robust unpacking for mmdet 2.x
-    if isinstance(result, (list, tuple)) and len(result) == 2:
+    if isinstance(result, (list, tuple)) and len(result) == 2 and isinstance(result[0], list):
         bbox_result, segm_result = result
     else:
         bbox_result, segm_result = result, None
@@ -113,6 +119,13 @@ def _draw_detections(image: Image.Image, result, score_thr=0.3):
     count = 0
     if bbox_result is not None:
         for cls_id, bboxes in enumerate(bbox_result):
+            if len(bboxes) == 0: continue
+            
+            # Print highest score for this class to debug thresholding
+            max_s = np.max(bboxes[:, 4]) if bboxes.size > 0 else 0
+            if max_s > 0.1:
+                print(f"DEBUG: Cls {cls_id} ({COCO_NAMES[cls_id] if cls_id < len(COCO_NAMES) else cls_id}) max score: {max_s:.4f}")
+
             color = tuple(np.random.randint(100, 255, 3).tolist())
             for i, bbox in enumerate(bboxes):
                 if bbox[4] < score_thr: continue
@@ -132,32 +145,32 @@ def _draw_detections(image: Image.Image, result, score_thr=0.3):
                         seg_sample = np.array(color, dtype=np.uint8)
                         seg_np_img[mask_bool] = (seg_np_img[mask_bool] * 0.5 + seg_sample * 0.5).astype(np.uint8)
                     except Exception as e:
-                        print(f"Mask blend failed: {e}")
+                        print(f"DEBUG: Mask blend failed: {e}")
     
-    if count == 0:
-        print(f"No objects detected above {score_thr} threshold.")
-                    
+    print(f"DEBUG: Total detections drawn: {count}")
     return img_draw.convert("RGB"), Image.fromarray(seg_np_img)
 
 DET_MODEL_CACHE = {}
 def detect(image: Image.Image, model_size: str, score_thr: float):
     if image is None: return None, None
     try:
-        # Move imports inside to avoid health-check timeout
         import geovig_det_backbone
         from mmdet.apis import init_detector, inference_detector
         import cv2
-    except ImportError:
+    except ImportError as e:
+        print(f"DEBUG: Import Error: {e}")
         return image, image
     
     key = f"det_{model_size.lower()}"
     if key not in DET_MODEL_CACHE:
         cfg = {"M": "configs/mask_rcnn_geovig_m_fpn_1x_coco.py", "B": "configs/mask_rcnn_geovig_b_fpn_1x_coco.py"}[model_size]
         path = get_ckpt_path(key)
+        print(f"DEBUG: Loading detector {key} from {path}")
         if not path: return image, image
         DET_MODEL_CACHE[key] = init_detector(cfg, path, device="cpu")
     
     cv_img = cv2.cvtColor(np.array(image.convert("RGB")), cv2.COLOR_RGB2BGR)
+    print(f"DEBUG: Running inference...")
     result = inference_detector(DET_MODEL_CACHE[key], cv_img)
     return _draw_detections(image, result, score_thr=score_thr)
 
@@ -177,36 +190,39 @@ def segment_medical(image: Image.Image, dataset: str, score_thr: float):
         cfg = {"Kvasir-SEG": "configs/kvasir/mask_rcnn_geovig_m_fpn_1x_kvasir.py", "DSB 2018": "configs/dsb/mask_rcnn_geovig_m_fpn_1x_dsb.py"}[dataset]
         v_key = "kvasir_m" if dataset == "Kvasir-SEG" else "dsb_m"
         path = get_ckpt_path(v_key)
+        print(f"DEBUG: Loading medical {key} from {path}")
         if not path: return image
         MED_MODEL_CACHE[key] = init_detector(cfg, path, device="cpu")
         
     cv_img = cv2.cvtColor(np.array(image.convert("RGB")), cv2.COLOR_RGB2BGR)
+    print(f"DEBUG: Running medical inference...")
     result = inference_detector(MED_MODEL_CACHE[key], cv_img)
     
+    print(f"DEBUG: Med Result type: {type(result)}")
     if isinstance(result, (list, tuple)) and len(result) == 2:
         bbox_result, segm_result = result
     else:
         bbox_result, segm_result = result, None
     
     combined_mask = np.zeros(cv_img.shape[:2], dtype=np.float32)
-    found_med = False
-    if segm_result:
-        for cls_id, cls_masks in enumerate(segm_result):
-            for i, mask in enumerate(cls_masks):
-                # Ensure we don't index out of bounds if bbox results are shorter
-                if i < len(bbox_result[cls_id]) and bbox_result[cls_id][i, 4] >= score_thr:
-                    found_med = True
-                    if isinstance(mask, dict):
-                        import pycocotools.mask as mask_util
-                        mask = mask_util.decode(mask)
-                    combined_mask = np.maximum(combined_mask, mask.astype(np.float32))
+    found_med = 0
+    if bbox_result is not None:
+        for cls_id, bboxes in enumerate(bbox_result):
+            if bboxes.size > 0:
+                print(f"DEBUG: Med Cls {cls_id} max score: {np.max(bboxes[:, 4]):.4f}")
+            for i, bbox in enumerate(bboxes):
+                if i < len(segm_result[cls_id]) if segm_result else False:
+                    if bbox[4] >= score_thr:
+                        found_med += 1
+                        mask = segm_result[cls_id][i]
+                        if isinstance(mask, dict):
+                            import pycocotools.mask as mask_util
+                            mask = mask_util.decode(mask)
+                        combined_mask = np.maximum(combined_mask, mask.astype(np.float32))
                 
-    if not found_med:
-        print(f"Medical: No segmentation found at threshold {score_thr}")
-
+    print(f"DEBUG: Med Total segments: {found_med}")
     img_arr = np.array(image.convert("RGB")).astype(float)
     overlay = img_arr.copy()
-    # Green-cyan tint for medical masks
     overlay[combined_mask > 0.5] = np.array([0, 200, 150], dtype=float)
     blended = (img_arr * 0.4 + overlay * 0.6).astype(np.uint8)
     return Image.fromarray(blended)