Update utils/bubble_detect.py

utils/bubble_detect.py

@@ -4,109 +4,75 @@ Enhanced speech bubble detection for manga
 import cv2
 import numpy as np
 from shapely.geometry import Polygon
+from shapely.ops import unary_union
 
 
 def detect_speech_bubbles(img_pil, min_area=500, max_area=None, debug=False):
     """
-    Detect speech bubbles in manga images.
-    
-    Args:
-        img_pil: PIL Image
-        min_area: Minimum bubble area in pixels
-        max_area: Maximum bubble area (None = 1/4 of image)
-        debug: If True, return debug info
-    
+    Basic speech bubble detection using adaptive threshold + morphology.
+
     Returns:
         List of bubble polygons [(x,y), ...]
     """
     img = cv2.cvtColor(np.array(img_pil), cv2.COLOR_RGB2BGR)
     gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
-    
+
     h, w = gray.shape
     if max_area is None:
-        max_area = (h * w) // 4  # Max 1/4 of image
-    
-    # Adaptive threshold handles varying lighting better
+        max_area = (h * w) // 4  # bubbles should not be entire page
+
     th = cv2.adaptiveThreshold(
-        gray, 255,
+        gray,
+        255,
         cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
         cv2.THRESH_BINARY,
-        35, 10
+        35,
+        10,
     )
-    
-    inv = 255 - th  # Bubbles become white regions
-    
-    # Close small gaps in bubble borders
-    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (7, 7))
-    cleaned = cv2.morphologyEx(inv, cv2.MORPH_CLOSE, kernel, iterations=2)
-    
-    # Remove small noise
+
+    inv = 255 - th  # bubbles → white
+
+    kernel_close = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (7, 7))
+    cleaned = cv2.morphologyEx(inv, cv2.MORPH_CLOSE, kernel_close, iterations=2)
+
     kernel_open = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3))
     cleaned = cv2.morphologyEx(cleaned, cv2.MORPH_OPEN, kernel_open, iterations=1)
-    
+
     contours, _ = cv2.findContours(cleaned, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-    
+
     bubbles = []
-    debug_info = []
-    
     for cnt in contours:
         area = cv2.contourArea(cnt)
-        
-        # Filter by area
         if area < min_area or area > max_area:
             continue
-        
-        # Get bounding box
+
         x, y, bw, bh = cv2.boundingRect(cnt)
-        
-        # Filter by aspect ratio (too thin/wide = not a bubble)
         aspect_ratio = max(bw, bh) / (min(bw, bh) + 1)
-        if aspect_ratio > 5:  # Too elongated
+        if aspect_ratio > 5:
             continue
-        
-        # Check if shape is reasonably bubble-like
-        # Bubbles are usually somewhat round/elliptical
+
         perimeter = cv2.arcLength(cnt, True)
+        if perimeter == 0:
+            continue
         circularity = 4 * np.pi * area / (perimeter * perimeter + 1)
-        
-        # Approximate polygon
+
         epsilon = 0.01 * perimeter
         approx = cv2.approxPolyDP(cnt, epsilon, True)
-        
         poly = [(int(p[0][0]), int(p[0][1])) for p in approx]
-        
-        # Store bubble
+
         bubbles.append(poly)
-        
-        if debug:
-            debug_info.append({
-                'area': area,
-                'aspect_ratio': aspect_ratio,
-                'circularity': circularity,
-                'vertices': len(poly),
-                'bbox': (x, y, bw, bh)
-            })
-    
-    print(f"🎈 Detected {len(bubbles)} candidate bubbles")
-    
-    if debug:
-        return bubbles, debug_info
-    
+
+    print(f"🎈 detect_speech_bubbles: {len(bubbles)} candidates")
     return bubbles
 
 
 def merge_overlapping_bubbles(bubbles, iou_threshold=0.3):
     """
     Merge bubbles that overlap significantly.
-    Useful when bubble detection creates multiple contours for one bubble.
     """
-    from shapely.geometry import Polygon
-    from shapely.ops import unary_union
-    
     if len(bubbles) <= 1:
         return bubbles
-    
-    # Convert to Shapely polygons
+
     shapes = []
     for b in bubbles:
         try:
@@ -114,60 +80,48 @@ def merge_overlapping_bubbles(bubbles, iou_threshold=0.3):
             if not p.is_valid:
                 p = p.buffer(0)
             shapes.append(p)
-        except:
+        except Exception:
             continue
-    
-    # Group overlapping bubbles
-    merged = []
+
+    merged_polys = []
     used = set()
-    
-    for i, shape1 in enumerate(shapes):
+
+    for i, s1 in enumerate(shapes):
         if i in used:
             continue
-        
-        group = [shape1]
+
+        group = [s1]
         used.add(i)
-        
-        for j, shape2 in enumerate(shapes[i+1:], start=i+1):
+
+        for j, s2 in enumerate(shapes[i + 1 :], start=i + 1):
             if j in used:
                 continue
-            
-            # Check overlap
-            intersection = shape1.intersection(shape2).area
-            union = shape1.union(shape2).area
-            iou = intersection / union if union > 0 else 0
-            
+            inter = s1.intersection(s2).area
+            union = s1.union(s2).area
+            iou = inter / union if union > 0 else 0.0
             if iou > iou_threshold:
-                group.append(shape2)
+                group.append(s2)
                 used.add(j)
-        
-        # Merge group
-        if len(group) > 1:
-            merged_shape = unary_union(group)
-            if merged_shape.geom_type == 'Polygon':
-                merged.append(list(merged_shape.exterior.coords)[:-1])
-            else:
-                # Multiple separate regions - add them separately
-                for geom in merged_shape.geoms:
-                    if geom.geom_type == 'Polygon':
-                        merged.append(list(geom.exterior.coords)[:-1])
+
+        merged_shape = unary_union(group)
+        if merged_shape.geom_type == "Polygon":
+            merged_polys.append([(int(x), int(y)) for x, y in merged_shape.exterior.coords[:-1]])
         else:
-            merged.append(list(group[0].exterior.coords)[:-1])
-    
-    print(f"🔄 Merged {len(bubbles)} bubbles → {len(merged)} bubbles")
-    return merged
+            for g in merged_shape.geoms:
+                if g.geom_type == "Polygon":
+                    merged_polys.append([(int(x), int(y)) for x, y in g.exterior.coords[:-1]])
+
+    print(f"🔄 merge_overlapping_bubbles: {len(bubbles)} → {len(merged_polys)}")
+    return merged_polys
 
 
 def filter_nested_bubbles(bubbles):
     """
-    Remove bubbles that are completely inside other bubbles.
-    Keeps the outer bubble.
+    Remove bubbles completely inside other bubbles; keep larger ones.
     """
-    from shapely.geometry import Polygon
-    
     if len(bubbles) <= 1:
         return bubbles
-    
+
     shapes = []
     for b in bubbles:
         try:
@@ -175,52 +129,44 @@ def filter_nested_bubbles(bubbles):
             if not p.is_valid:
                 p = p.buffer(0)
             shapes.append((p, b))
-        except:
+        except Exception:
             continue
-    
-    # Sort by area (largest first)
+
     shapes.sort(key=lambda x: x[0].area, reverse=True)
-    
+
     filtered = []
-    for i, (shape1, poly1) in enumerate(shapes):
+    for i, (s1, poly1) in enumerate(shapes):
         is_nested = False
-        
-        for j, (shape2, poly2) in enumerate(shapes):
+        for j, (s2, poly2) in enumerate(shapes):
             if i == j:
                 continue
-            
-            # Check if shape1 is inside shape2
-            if shape2.contains(shape1):
+            if s2.contains(s1):
                 is_nested = True
                 break
-        
         if not is_nested:
             filtered.append(poly1)
-    
+
     if len(filtered) < len(bubbles):
-        print(f"🗑️ Removed {len(bubbles) - len(filtered)} nested bubbles")
-    
+        print(f"🗑️ filter_nested_bubbles: removed {len(bubbles) - len(filtered)} nested")
     return filtered
 
 
-def detect_speech_bubbles_robust(img_pil, min_area=500, merge_overlaps=True, filter_nested=True):
+def detect_speech_bubbles_robust(img_pil, min_area=500, merge_overlaps=True, filter_nested_flag=True):
     """
     Robust bubble detection with post-processing.
-    
     This is the recommended function to use.
     """
-    # Initial detection
     bubbles = detect_speech_bubbles(img_pil, min_area=min_area)
-    
-    if len(bubbles) == 0:
+
+    if not bubbles:
+        print("⚠️ detect_speech_bubbles_robust: no initial bubbles")
         return []
-    
-    # Post-processing
+
     if merge_overlaps:
         bubbles = merge_overlapping_bubbles(bubbles)
-    
-    if filter_nested:
+
+    if filter_nested_flag:
         bubbles = filter_nested_bubbles(bubbles)
-    
-    print(f"✅ Final: {len(bubbles)} speech bubbles")
-    return bubbles
+
+    print(f"✅ detect_speech_bubbles_robust: final {len(bubbles)} bubbles")
+    return bubbles