Update app.py

app.py

@@ -1155,7 +1155,99 @@ IOA_SUPPRESSION_THRESHOLD = 0.7
 # --- BOX COMBINATION LOGIC (PURE VERTICAL FIX) ---
 # ============================================================================
 
+# def calculate_iou(box1, box2):
+#     x1_a, y1_a, x2_a, y2_a = box1
+#     x1_b, y1_b, x2_b, y2_b = box2
+#     x_left = max(x1_a, x1_b)
+#     y_top = max(y1_a, y1_b)
+#     x_right = min(x2_a, x2_b)
+#     y_bottom = min(y2_a, y2_b)
+#     intersection_area = max(0, x_right - x_left) * max(0, y_bottom - y_top)
+#     box_a_area = (x2_a - x1_a) * (y2_a - y1_a)
+#     box_b_area = (x2_b - x1_b) * (y2_b - y1_b)
+#     union_area = float(box_a_area + box_b_area - intersection_area)
+#     return intersection_area / union_area if union_area > 0 else 0
+
+
+# def filter_nested_boxes(detections, ioa_threshold=0.80):
+#     if not detections: return []
+#     for d in detections:
+#         x1, y1, x2, y2 = d['coords']
+#         d['area'] = (x2 - x1) * (y2 - y1)
+#     detections.sort(key=lambda x: x['area'], reverse=True)
+#     keep_indices = []
+#     is_suppressed = [False] * len(detections)
+#     for i in range(len(detections)):
+#         if is_suppressed[i]: continue
+#         keep_indices.append(i)
+#         box_a = detections[i]['coords']
+#         for j in range(i + 1, len(detections)):
+#             if is_suppressed[j]: continue
+#             box_b = detections[j]['coords']
+#             x_left = max(box_a[0], box_b[0])
+#             y_top = max(box_a[1], box_b[1])
+#             x_right = min(box_a[2], box_b[2])
+#             y_bottom = min(box_a[3], box_b[3])
+#             intersection = max(0, x_right - x_left) * max(0, y_bottom - y_top)
+#             area_b = detections[j]['area']
+#             if area_b > 0 and intersection / area_b > ioa_threshold:
+#                 is_suppressed[j] = True
+#     return [detections[i] for i in keep_indices]
+
+
+# # --- UPDATED: page_width argument removed ---
+# def merge_overlapping_boxes(detections, iou_threshold):
+#     if not detections: return []
+#     detections.sort(key=lambda d: d['conf'], reverse=True)
+#     merged_detections = []
+#     is_merged = [False] * len(detections)
+    
+#     for i in range(len(detections)):
+#         if is_merged[i]: continue
+#         current_box = detections[i]['coords']
+#         current_class = detections[i]['class']
+#         merged_x1, merged_y1, merged_x2, merged_y2 = current_box
+#         for j in range(i + 1, len(detections)):
+#             if is_merged[j] or detections[j]['class'] != current_class: continue
+#             other_box = detections[j]['coords']
+#             iou = calculate_iou(current_box, other_box)
+#             if iou > iou_threshold:
+#                 merged_x1 = min(merged_x1, other_box[0])
+#                 merged_y1 = min(merged_y1, other_box[1])
+#                 merged_x2 = max(merged_x2, other_box[2])
+#                 merged_y2 = max(merged_y2, other_box[3])
+#                 is_merged[j] = True
+#         merged_detections.append({
+#             'coords': (merged_x1, merged_y1, merged_x2, merged_y2),
+#             'y1': merged_y1, 
+#             'class': current_class, 
+#             'conf': detections[i]['conf']
+#         })
+    
+#     # --- PURE VERTICAL FIX IMPLEMENTATION ---
+#     # Sort ONLY by the top y-coordinate (coords[1]).
+#     # This ignores horizontal position and any complex layout.
+#     merged_detections.sort(key=lambda d: d['coords'][1])
+    
+#     return merged_detections
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 def calculate_iou(box1, box2):
+    """Calculate Intersection over Union between two boxes."""
     x1_a, y1_a, x2_a, y2_a = box1
     x1_b, y1_b, x2_b, y2_b = box2
     x_left = max(x1_a, x1_b)
@@ -1169,67 +1261,143 @@ def calculate_iou(box1, box2):
     return intersection_area / union_area if union_area > 0 else 0
 
 
-def filter_nested_boxes(detections, ioa_threshold=0.80):
-    if not detections: return []
-    for d in detections:
-        x1, y1, x2, y2 = d['coords']
-        d['area'] = (x2 - x1) * (y2 - y1)
-    detections.sort(key=lambda x: x['area'], reverse=True)
-    keep_indices = []
-    is_suppressed = [False] * len(detections)
-    for i in range(len(detections)):
-        if is_suppressed[i]: continue
-        keep_indices.append(i)
-        box_a = detections[i]['coords']
-        for j in range(i + 1, len(detections)):
-            if is_suppressed[j]: continue
-            box_b = detections[j]['coords']
-            x_left = max(box_a[0], box_b[0])
-            y_top = max(box_a[1], box_b[1])
-            x_right = min(box_a[2], box_b[2])
-            y_bottom = min(box_a[3], box_b[3])
-            intersection = max(0, x_right - x_left) * max(0, y_bottom - y_top)
-            area_b = detections[j]['area']
-            if area_b > 0 and intersection / area_b > ioa_threshold:
-                is_suppressed[j] = True
-    return [detections[i] for i in keep_indices]
+def calculate_ioa(box1, box2):
+    """Calculate Intersection over Area of box2."""
+    x1_a, y1_a, x2_a, y2_a = box1
+    x1_b, y1_b, x2_b, y2_b = box2
+    x_left = max(x1_a, x1_b)
+    y_top = max(y1_a, y1_b)
+    x_right = min(x2_a, x2_b)
+    y_bottom = min(y2_a, y2_b)
+    intersection_area = max(0, x_right - x_left) * max(0, y_bottom - y_top)
+    box_a_area = (x2_a - x1_a) * (y2_a - y1_a)
+    return intersection_area / box_a_area if box_a_area > 0 else 0
 
 
-# --- UPDATED: page_width argument removed ---
 def merge_overlapping_boxes(detections, iou_threshold):
-    if not detections: return []
+    """
+    Merges overlapping boxes of the same class based on IOU threshold.
+    Returns boxes sorted by y-coordinate (top to bottom).
+    """
+    if not detections:
+        return []
+    
+    # Sort by confidence (highest first) for merge priority
     detections.sort(key=lambda d: d['conf'], reverse=True)
+    
     merged_detections = []
     is_merged = [False] * len(detections)
     
     for i in range(len(detections)):
-        if is_merged[i]: continue
+        if is_merged[i]:
+            continue
+            
         current_box = detections[i]['coords']
         current_class = detections[i]['class']
         merged_x1, merged_y1, merged_x2, merged_y2 = current_box
+        
+        # Try to merge with all subsequent boxes of same class
         for j in range(i + 1, len(detections)):
-            if is_merged[j] or detections[j]['class'] != current_class: continue
+            if is_merged[j] or detections[j]['class'] != current_class:
+                continue
+                
             other_box = detections[j]['coords']
             iou = calculate_iou(current_box, other_box)
+            
             if iou > iou_threshold:
+                # Expand merged box to encompass both
                 merged_x1 = min(merged_x1, other_box[0])
                 merged_y1 = min(merged_y1, other_box[1])
                 merged_x2 = max(merged_x2, other_box[2])
-                merged_y2 = max(merged_y2, other_box[3])
+                merged_y2 = max(merged_y2, other_box[3])  # ← FIX THE TYPO HERE
                 is_merged[j] = True
+        
         merged_detections.append({
             'coords': (merged_x1, merged_y1, merged_x2, merged_y2),
-            'y1': merged_y1, 
-            'class': current_class, 
+            'y1': merged_y1,
+            'class': current_class,
             'conf': detections[i]['conf']
         })
     
-    # --- PURE VERTICAL FIX IMPLEMENTATION ---
-    # Sort ONLY by the top y-coordinate (coords[1]).
-    # This ignores horizontal position and any complex layout.
+    # Sort by y-coordinate (top to bottom) for consistent ordering
     merged_detections.sort(key=lambda d: d['coords'][1])
     
     return merged_detections
+
+
+def filter_nested_boxes(detections, ioa_threshold=0.80):
+    """
+    Removes boxes that are nested inside larger boxes.
+    Keeps the larger (parent) box and suppresses smaller (child) boxes.
+    """
+    if not detections:
+        return []
+    
+    # Calculate area for all detections
+    for d in detections:
+        x1, y1, x2, y2 = d['coords']
+        d['area'] = (x2 - x1) * (y2 - y1)
+    
+    # Sort by area (largest first) to prioritize keeping parent boxes
+    detections.sort(key=lambda x: x['area'], reverse=True)
+    
+    keep_indices = []
+    is_suppressed = [False] * len(detections)
+    
+    for i in range(len(detections)):
+        if is_suppressed[i]:
+            continue
+            
+        keep_indices.append(i)
+        box_a = detections[i]['coords']
+        
+        # Check all smaller boxes
+        for j in range(i + 1, len(detections)):
+            if is_suppressed[j]:
+                continue
+                
+            box_b = detections[j]['coords']
+            
+            # Calculate intersection
+            x_left = max(box_a[0], box_b[0])
+            y_top = max(box_a[1], box_b[1])
+            x_right = min(box_a[2], box_b[2])
+            y_bottom = min(box_a[3], box_b[3])
+            
+            intersection = max(0, x_right - x_left) * max(0, y_bottom - y_top)
+            area_b = detections[j]['area']
+            
+            # If small box is mostly inside large box, suppress it
+            if area_b > 0 and intersection / area_b > ioa_threshold:
+                is_suppressed[j] = True
+    
+    # Return kept detections in original y-sorted order
+    kept_detections = [detections[i] for i in keep_indices]
+    kept_detections.sort(key=lambda d: d['coords'][1])
+    
+    return kept_detections
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 # ============================================================================
 # --- UTILITY FUNCTIONS (Retained) ---