fix: iterative necrotic recovery (3x30px) — bridges gap to necrotic toes

src/segmentation.py

@@ -331,29 +331,30 @@ def recover_necrotic_tissue(
     l_channel: np.ndarray,
     a_channel: np.ndarray,
     s_channel: np.ndarray,
-    necrotic_l_max: float = 35.0,
-    necrotic_s_max: float = 80.0,
-    dilation_px: int = 40,
-    min_region_px: int = 200,
+    necrotic_l_max: float = 45.0,
+    necrotic_s_max: float = 120.0,
+    min_region_px: int = 100,
 ) -> np.ndarray:
     """Recover dark necrotic tissue regions adjacent to detected foreground.
 
-    Necrotic tissue (eschar, gangrene) is very dark (low L*) and low saturation,
-    which the segmentation model often misclassifies as background.
-    This function detects such regions adjacent to the foot and reclassifies
-    them as ulcer (class 3).
+    Necrotic tissue (eschar, gangrene, dry/wet gangrene on toes) is very dark
+    and the model often misclassifies it as background. This function uses
+    iterative dilation to progressively recover necrotic regions connected
+    to the foot, even when there's a gap between the detected foot and the toes.
 
-    Detection criteria for necrotic pixels:
-        - L* < 35 (very dark)
-        - Saturation < 80 (not vivid colored — rules out colored backgrounds)
+    Detection criteria for necrotic candidate pixels:
+        - L* < 45 (dark tissue — covers eschar, gangrene, necrotic toes)
+        - Saturation < 120 (not vivid colored — rules out green/blue backgrounds)
         - Currently classified as background (class 0)
-        - Adjacent to (within dilation_px of) detected foreground
-        - Forms a connected region >= min_region_px pixels
+
+    Iterative approach: dilate foreground progressively (3 rounds x 30px),
+    recovering necrotic candidates at each step. This bridges gaps between
+    the detected foot and disconnected necrotic regions like toes.
     """
     h, w = classmap.shape
     recovered = classmap.copy()
 
-    # Candidate necrotic pixels: dark, low saturation, currently background
+    # Candidate necrotic pixels: dark, not vivid, currently background
     is_background = recovered == 0
     necrotic_candidates = (
         is_background
@@ -364,36 +365,50 @@ def recover_necrotic_tissue(
     if not np.any(necrotic_candidates):
         return recovered
 
-    # Adjacency: dilate the current foreground to find nearby regions
-    foreground = (recovered > 0).astype(np.uint8)
-    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (dilation_px, dilation_px))
-    foreground_dilated = cv2.dilate(foreground, kernel).astype(bool)
+    # Iterative recovery: progressively expand from detected foreground
+    # Each round dilates 30px and recovers adjacent necrotic tissue,
+    # then the recovered tissue becomes part of the foreground for the next round.
+    # 3 rounds × 30px = up to 90px reach from the original foreground edge.
+    dilation_step = 30
+    num_rounds = 3
 
-    # Keep only candidates adjacent to detected foot
-    adjacent_necrotic = necrotic_candidates & foreground_dilated
+    current_foreground = (recovered > 0).astype(np.uint8)
 
-    if not np.any(adjacent_necrotic):
-        return recovered
+    for round_idx in range(num_rounds):
+        kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (dilation_step, dilation_step))
+        fg_dilated = cv2.dilate(current_foreground, kernel).astype(bool)
 
-    # Connected component filtering: only keep regions large enough to be real tissue
-    adjacent_u8 = adjacent_necrotic.astype(np.uint8)
-    num_labels, labels, stats, _ = cv2.connectedComponentsWithStats(adjacent_u8, connectivity=8)
+        # Candidates that are within reach this round
+        adjacent = necrotic_candidates & fg_dilated & (recovered == 0)
 
-    for label_id in range(1, num_labels):
-        area = stats[label_id, cv2.CC_STAT_AREA]
-        if area >= min_region_px:
-            # This region is large enough to be real necrotic tissue
-            region_mask = labels == label_id
+        if not np.any(adjacent):
+            break
+
+        # Connected component filtering
+        adjacent_u8 = adjacent.astype(np.uint8)
+        num_labels, labels, stats, _ = cv2.connectedComponentsWithStats(adjacent_u8, connectivity=8)
+
+        recovered_any = False
+        for label_id in range(1, num_labels):
+            area = stats[label_id, cv2.CC_STAT_AREA]
+            if area < min_region_px:
+                continue
 
-            # Verify it's actually connected to the foreground (not just nearby)
-            # Check if dilating this region touches existing foreground
-            region_u8 = region_mask.astype(np.uint8)
-            region_dilated = cv2.dilate(region_u8, cv2.getStructuringElement(
-                cv2.MORPH_ELLIPSE, (5, 5)
-            ))
-            touches_foreground = np.any((region_dilated > 0) & (foreground > 0))
+            region_mask = labels == label_id
 
-            if touches_foreground:
+            # Verify it touches current foreground
+            region_dilated = cv2.dilate(
+                region_mask.astype(np.uint8),
+                cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (7, 7))
+            )
+            if np.any((region_dilated > 0) & (current_foreground > 0)):
                 recovered[region_mask] = 3  # Ulcer (necrotic)
+                recovered_any = True
+
+        if not recovered_any:
+            break
+
+        # Update foreground for next round (include newly recovered tissue)
+        current_foreground = (recovered > 0).astype(np.uint8)
 
     return recovered