fix: absorb near-miss vision_rect noise inside text blocks

Apple Vision's rect and text detectors have ~3-5px boundary
misalignment, causing small noise rects inside text blocks to
survive absorption at 73-85% containment (below the 85% threshold).

Add block_padding parameter (default 5px) that expands text block
bboxes during containment checks, compensating for the detector
boundary divergence. Validated on 7 Draw Things screenshots:
354 → 345 detections (9 noise rects absorbed), zero false absorptions.

Author: swaynehales

tests/test_group.py

@@ -240,3 +240,49 @@ def test_rect_outside_text_block_preserved():
     assert groups_formed == 1
     assert len(result) == 2
     assert any(d.source == "vision_rect" for d in result)
+
+
+def test_near_miss_rect_absorbed_with_padding():
+    """vision_rect extending a few pixels beyond text block is absorbed.
+
+    Real-world case: Apple Vision's rect detector extends ~5px beyond its
+    text detector boundary. Without padding the rect survives at ~80%
+    containment (below the 85% threshold). With 5px block padding it's
+    absorbed.
+    """
+    from uitag.group import group_text_blocks
+
+    # Based on basic-settings-2: Sampler section, rect SoM 20 / block SoM 21
+    # Block lines span y:692-803, but the rect starts at y:687 (5px above)
+    dets = [
+        _det("Different samplers can converge at", x=36, y=692, w=471, h=18),
+        _det("different step counts and may result", x=36, y=716, w=471, h=18),
+        _det("in different qualities.", x=36, y=740, w=200, h=18),
+        # Rect starts 5px above the first text line
+        _det("rectangle", x=36, y=687, w=87, h=24, source="vision_rect"),
+    ]
+    result, groups_formed = group_text_blocks(dets)
+
+    assert groups_formed == 1
+    # Rect should be absorbed thanks to block_padding
+    text_blocks = [d for d in result if d.source == "vision_text_block"]
+    rects = [d for d in result if d.source == "vision_rect"]
+    assert len(text_blocks) == 1
+    assert len(rects) == 0
+
+
+def test_near_miss_rect_without_padding_survives():
+    """Verify near-miss rect survives when padding is explicitly zero."""
+    from uitag.group import group_text_blocks
+
+    dets = [
+        _det("Different samplers can converge at", x=36, y=692, w=471, h=18),
+        _det("different step counts and may result", x=36, y=716, w=471, h=18),
+        _det("in different qualities.", x=36, y=740, w=200, h=18),
+        _det("rectangle", x=36, y=687, w=87, h=24, source="vision_rect"),
+    ]
+    result, groups_formed = group_text_blocks(dets, block_padding=0)
+
+    assert groups_formed == 1
+    rects = [d for d in result if d.source == "vision_rect"]
+    assert len(rects) == 1  # Rect survives without padding

uitag/florence.py

@@ -31,7 +31,6 @@
 _LEAKED_LOC_PREFIX = re.compile(r"^(loc_\d+>\s*)+")
 
 
-
 def _load_model():
     """Lazy-load model as singleton (load once, reuse across calls)."""
     global _model, _processor

uitag/group.py

@@ -10,6 +10,7 @@ def group_text_blocks(
     max_y_gap_factor: float = 1.0,
     x_align_tolerance: int = 20,
     containment_threshold: float = 0.85,
+    block_padding: int = 5,
 ) -> tuple[list[Detection], int]:
     """Group adjacent vision_text lines into text blocks.
 
@@ -19,7 +20,9 @@ def group_text_blocks(
 
     Groups of 2+ lines become a single detection with source
     ``"vision_text_block"`` and space-joined labels. Vision rectangles
-    mostly contained within text blocks are absorbed.
+    mostly contained within text blocks are absorbed (block bbox is
+    expanded by ``block_padding`` pixels to compensate for boundary
+    misalignment between Vision's rect and text detectors).
 
     Returns:
         (updated_detections, groups_formed)
@@ -86,7 +89,9 @@ def group_text_blocks(
 
     for det in other_dets:
         if det.source == "vision_rect" and text_blocks:
-            if _is_contained_in_any(det, text_blocks, containment_threshold):
+            if _is_contained_in_any(
+                det, text_blocks, containment_threshold, block_padding
+            ):
                 continue
         filtered_other.append(det)
 
@@ -103,13 +108,24 @@ def _is_contained_in_any(
     rect: Detection,
     blocks: list[Detection],
     threshold: float,
+    padding: int = 0,
 ) -> bool:
-    """Check if rect is mostly contained within any text block."""
+    """Check if rect is mostly contained within any text block.
+
+    The block bbox is expanded by ``padding`` pixels on all sides to
+    compensate for Apple Vision's boundary misalignment between its
+    rectangle and text detectors.
+    """
     for block in blocks:
-        ix1 = max(rect.x, block.x)
-        iy1 = max(rect.y, block.y)
-        ix2 = min(rect.x + rect.width, block.x + block.width)
-        iy2 = min(rect.y + rect.height, block.y + block.height)
+        bx1 = block.x - padding
+        by1 = block.y - padding
+        bx2 = block.x + block.width + padding
+        by2 = block.y + block.height + padding
+
+        ix1 = max(rect.x, bx1)
+        iy1 = max(rect.y, by1)
+        ix2 = min(rect.x + rect.width, bx2)
+        iy2 = min(rect.y + rect.height, by2)
 
         if ix2 <= ix1 or iy2 <= iy1:
             continue