Merge branch 'iou-tests' into div-test-cases

.github/workflows/ci.yml

@@ -49,6 +49,9 @@ jobs:
 
       - name: Coverage
         uses: codecov/codecov-action@v5
+        with:
+          token: ${{ secrets.CODECOV_TOKEN }}
+
 
   benchmark:
     name: Benchmark

src/traccuracy/matchers/_ctc.py

@@ -2,7 +2,6 @@
 
 from typing import TYPE_CHECKING
 
-import numpy as np
 from tqdm import tqdm
 
 if TYPE_CHECKING:
@@ -80,46 +79,27 @@ def _compute_mapping(self, gt_graph: TrackingGraph, pred_graph: TrackingGraph):
                 if pred_label_key in G_pred.graph.nodes[node]
             }
 
-            (
-                overlapping_gt_labels,
-                overlapping_pred_labels,
-                intersection,
-            ) = get_labels_with_overlap(gt_frame, pred_frame, overlap="iogt")
-
-            for i in range(len(overlapping_gt_labels)):
-                gt_label = overlapping_gt_labels[i]
-                pred_label = overlapping_pred_labels[i]
-                # CTC metrics only match comp IDs to a single GT ID if there is majority overlap
-                if intersection[i] > 0.5:
-                    mapping.append(
-                        (gt_label_to_id[gt_label], pred_label_to_id[pred_label])
-                    )
+            frame_map = match_frame_majority(gt_frame, pred_frame)
+            # Switch from segmentation ids to node ids
+            for gt_label, pred_label in frame_map:
+                mapping.append((gt_label_to_id[gt_label], pred_label_to_id[pred_label]))
 
         return mapping
 
 
-def detection_test(gt_blob: np.ndarray, comp_blob: np.ndarray) -> int:
-    """Check if computed marker overlaps majority of the reference marker.
+def match_frame_majority(gt_frame, pred_frame):
+    mapping = []
+    (
+        overlapping_gt_labels,
+        overlapping_pred_labels,
+        intersection,
+    ) = get_labels_with_overlap(gt_frame, pred_frame, overlap="iogt")
 
-    Given a reference marker and computer marker in original coordinates,
-    return True if the computed marker overlaps strictly more than half
-    of the reference marker's pixels, otherwise False.
+    for gt_label, pred_label, iogt in zip(
+        overlapping_gt_labels, overlapping_pred_labels, intersection
+    ):
+        # CTC metrics only match comp IDs to a single GT ID if there is majority overlap
+        if iogt > 0.5:
+            mapping.append((gt_label, pred_label))
 
-    Parameters
-    ----------
-    gt_blob : np.ndarray
-        2D or 3D boolean mask representing the pixels of the ground truth
-        marker
-    comp_blob : np.ndarray
-        2D or 3D boolean mask representing the pixels of the computed
-        marker
-
-    Returns
-    -------
-    bool
-        True if computed marker majority overlaps reference marker, else False.
-    """
-    n_gt_pixels = np.sum(gt_blob)
-    intersection = np.logical_and(gt_blob, comp_blob)
-    comp_blob_matches_gt_blob = int(np.sum(intersection) > 0.5 * n_gt_pixels)
-    return comp_blob_matches_gt_blob
+    return mapping

tests/examples/segs.py

@@ -122,7 +122,7 @@ def make_split_cell_3d(
     mask = sphere(center, radius, shape=arr_shape)
     im[mask] = labels[0]
     # get indices where y value greater than center
-    mask[:, 0 : center[1]] = 0
+    mask[:, 0 : center[1] + 1] = 0
     im[mask] = labels[1]
     return im
 
@@ -195,6 +195,37 @@ def undersegmentation_2d() -> tuple[np.ndarray, np.ndarray]:
     return gt, pred
 
 
+def no_overlap_2d() -> tuple[np.ndarray, np.ndarray]:
+    """Two cells with no overlap in 2d."""
+    gt = make_one_cell_2d(label=1, center=(5, 5), radius=7)
+    pred = make_one_cell_2d(label=2, center=(17, 17), radius=7)
+    return gt, pred
+
+
+def multicell_2d() -> tuple[np.ndarray, np.ndarray]:
+    """Two cells in each image, one that overlaps and one that doesn't"""
+    arr_shape = (32, 32)
+    radius = 5
+
+    gt = np.zeros(arr_shape, dtype="int32")
+    pred = np.zeros(arr_shape, dtype="int32")
+
+    # Overlap cell
+    rr, cc = disk((5, 5), radius, shape=arr_shape)
+    gt[rr, cc] = 1
+    pred[rr, cc] = 3
+
+    # Unique gt
+    rr, cc = disk((17, 17), radius, shape=arr_shape)
+    gt[rr, cc] = 2
+
+    # Unique pred
+    rr, cc = disk((25, 7), radius, shape=arr_shape)
+    pred[rr, cc] = 4
+
+    return gt, pred
+
+
 ### CANONICAL 3D SEGMENTATION EXAMPLES ###
 def good_segmentation_3d() -> tuple[np.ndarray, np.ndarray]:
     """A pretty good (but not perfect) pair of segmentations in 3d.
@@ -263,6 +294,37 @@ def undersegmentation_3d() -> tuple[np.ndarray, np.ndarray]:
     return gt, pred
 
 
+def no_overlap_3d() -> tuple[np.ndarray, np.ndarray]:
+    """3D segmentations with no overlap"""
+    gt = make_one_cell_3d(label=1, center=(5, 5, 5), radius=5)
+    pred = make_one_cell_3d(label=2, center=(17, 17, 17), radius=6)
+    return gt, pred
+
+
+def multicell_3d() -> tuple[np.ndarray, np.ndarray]:
+    """Two cells in each image, one that overlaps and one that doesn't"""
+    arr_shape = (32, 32, 32)
+    radius = 5
+
+    gt = np.zeros(arr_shape, dtype="int32")
+    pred = np.zeros(arr_shape, dtype="int32")
+
+    # Overlap cell
+    mask = sphere((5, 5, 5), radius, shape=arr_shape)
+    gt[mask] = 1
+    pred[mask] = 3
+
+    # Unique gt
+    mask = sphere((17, 17, 17), radius, shape=arr_shape)
+    gt[mask] = 2
+
+    # Unique pred
+    mask = sphere((25, 7, 7), radius, shape=arr_shape)
+    pred[mask] = 4
+
+    return gt, pred
+
+
 def nodes_from_segmentation(
     seg: np.ndarray,
     frame: int,

tests/matchers/test_ctc.py

@@ -1,13 +1,16 @@
+from collections import Counter
+
 import networkx as nx
 import numpy as np
 import pytest
 
+import tests.examples.segs as ex_segs
 from tests.test_utils import get_annotated_movie
 from traccuracy._tracking_graph import TrackingGraph
-from traccuracy.matchers._ctc import CTCMatcher
+from traccuracy.matchers._ctc import CTCMatcher, match_frame_majority
 
 
-def test_match_ctc():
+def test_CTCMatcher():
     matcher = CTCMatcher()
 
     # shapes don't match
@@ -46,3 +49,81 @@ def test_match_ctc():
     # gt and pred node should be the same
     for pair in matched.mapping:
         assert pair[0] == pair[1]
+
+
+class Test_match_frame_majority:
+    @pytest.mark.parametrize(
+        "data",
+        [ex_segs.good_segmentation_2d(), ex_segs.good_segmentation_3d()],
+        ids=["2D", "3D"],
+    )
+    def test_good_seg(self, data):
+        ex_match = [(1, 2)]
+        comp_match = match_frame_majority(*data)
+        assert Counter(ex_match) == Counter(comp_match)
+
+    @pytest.mark.parametrize(
+        "data",
+        [
+            ex_segs.false_positive_segmentation_2d(),
+            ex_segs.false_positive_segmentation_3d(),
+        ],
+        ids=["2D", "3D"],
+    )
+    def test_false_pos_seg(self, data):
+        ex_match = []
+        comp_match = match_frame_majority(*data)
+        assert Counter(ex_match) == Counter(comp_match)
+
+    @pytest.mark.parametrize(
+        "data",
+        [
+            ex_segs.false_negative_segmentation_2d(),
+            ex_segs.false_negative_segmentation_3d(),
+        ],
+        ids=["2D", "3D"],
+    )
+    def test_false_neg_seg(self, data):
+        ex_match = []
+        comp_match = match_frame_majority(*data)
+        assert Counter(ex_match) == Counter(comp_match)
+
+    @pytest.mark.parametrize(
+        "data",
+        [ex_segs.oversegmentation_2d(), ex_segs.oversegmentation_3d()],
+        ids=["2D", "3D"],
+    )
+    def test_split(self, data):
+        ex_match = [(1, 2)]
+        comp_match = match_frame_majority(*data)
+        assert Counter(ex_match) == Counter(comp_match)
+
+    @pytest.mark.parametrize(
+        "data",
+        [ex_segs.undersegmentation_2d(), ex_segs.undersegmentation_3d()],
+        ids=["2D", "3D"],
+    )
+    def test_merge(self, data):
+        ex_match = [(1, 3), (2, 3)]
+        comp_match = match_frame_majority(*data)
+        assert Counter(ex_match) == Counter(comp_match)
+
+    @pytest.mark.parametrize(
+        "data",
+        [ex_segs.no_overlap_2d(), ex_segs.no_overlap_3d()],
+        ids=["2D", "3D"],
+    )
+    def test_no_overlap(self, data):
+        ex_match = []
+        comp_match = match_frame_majority(*data)
+        assert Counter(ex_match) == Counter(comp_match)
+
+    @pytest.mark.parametrize(
+        "data",
+        [ex_segs.multicell_2d(), ex_segs.multicell_3d()],
+        ids=["2D", "3D"],
+    )
+    def test_multicell(self, data):
+        ex_match = [(1, 3)]
+        comp_match = match_frame_majority(*data)
+        assert Counter(ex_match) == Counter(comp_match)