Now, also mitosis are detected, if daughters appear in the future with a timegap > 0. It is similar to the fiji plugin implementation

Author: TimoK93

ctc_metrics/metrics/biological/bc.py

@@ -21,7 +21,6 @@ def get_ids_that_ends_with_split(
     counts = counts[parents > 0]
     parents = parents[parents > 0]
     ends_with_split = parents[counts > 1]
-    print("ends_with_split:", ends_with_split)
     return ends_with_split
 
 
@@ -54,8 +53,10 @@ def is_matching(
         mapped_comp: list,
         ref_children: np.ndarray,
         comp_children: np.ndarray,
-        tr: int,
-        tc: int
+        t_parent_end_ref: int,
+        t_parent_end_comp: int,
+        t_child_start_ref: list,
+        t_child_start_comp: list,
 ):
     """
     Checks if the reference and the computed track match.
@@ -67,8 +68,10 @@ def is_matching(
         mapped_comp: The matched labels of the result masks.
         ref_children: The children ids of the reference track.
         comp_children: The children ids of the computed track.
-        tr: The frame of the reference track end.
-        tc: The frame of the computed track end.
+        t_parent_end_ref: The frame of the reference track end.
+        t_parent_end_comp: The frame of the computed track end.
+        t_child_start_ref: The frame of the reference track start.
+        t_child_start_comp: The frame of the computed track start.
 
     Returns:
         True if the reference and the computed track match, False otherwise.
@@ -77,21 +80,33 @@ def is_matching(
     if len(ref_children) != len(comp_children):
         return False
     # Compare parents
-    t1, _ = min(tr, tc), max(tr, tc)
-    mr, mc = mapped_ref[t1], mapped_comp[t1]
+    t_start = min(t_parent_end_ref, t_parent_end_comp)
+    mr, mc = mapped_ref[t_start], mapped_comp[t_start]
     if np.sum(mc == id_comp) < 1 or np.sum(mr == id_ref) != 1:
         return False
     ind = np.argwhere(mr == id_ref).squeeze()
     if mc[ind] != id_comp:
         return False
-    # # Compare children  ### WHAT IS A CORRECT DETECTED MITOSIS?
-    # mr, mc = np.concatenate(mapped_ref[t2 + 1]), np.concatenate(mapped_comp[t2 + 1])
-    # if not np.all(np.isin(comp_children, mc)):
-    #     return False
-    # if not np.all(np.isin(mr[np.isin(mc, comp_children)], ref_children)):
-    #     return False
+    # Compare children
+    #  Iterate over all GT ids and check if the first detection is matched to the correct reference children
+    matched_children = []
+    for i, t_ref in zip(ref_children, t_child_start_ref):
+        for j, t_comp in zip(comp_children, t_child_start_comp):
+            t_max = max(t_ref, t_comp)
+            if i in mapped_ref[t_max] and j in mapped_comp[t_max]:
+                ind = mapped_ref[t_max].index(i)
+                if mapped_comp[t_max][ind] == j:
+                    # There is a match!
+                    if j not in matched_children:
+                        matched_children.append(j)
+                    break
+
+    if len(matched_children) != len(ref_children):
+        return False
+
     return True
 
+
 def raw_division_metrics(
         comp_tracks: np.ndarray,
         ref_tracks: np.ndarray,
@@ -101,7 +116,7 @@ def raw_division_metrics(
 ):
     """
     Computes number of true positives, false positives, and false negatives for divisions.
-    
+
     Args:
         comp_tracks: The result tracks. A (n,4) numpy ndarray with columns:
             - label
@@ -137,36 +152,49 @@ def raw_division_metrics(
     ends_with_split_comp = get_ids_that_ends_with_split(comp_tracks)
     t_comp = np.asarray([comp_tracks[comp_tracks[:, 0] == comp][0, 2]
                          for comp in ends_with_split_comp])
-    
-    # If there are no divisions in the reference 
+
+    # If there are no divisions in the reference
     if len(ends_with_split_ref) == 0:
         return (0, len(ends_with_split_comp), 0)
-    
+
     # If there are no divisions in the computed result
     if len(ends_with_split_comp) == 0:
         return (0, 0, len(ends_with_split_ref))
-    
+
     # Find all matches between reference and computed branching events (mitosis)
     matches = []
-    for comp, tc in zip(ends_with_split_comp, t_comp):
+    for comp, t_parent_end_start in zip(ends_with_split_comp, t_comp):
         # Find potential matches
-        pot_matches = np.abs(t_ref - tc) <= i
+        pot_matches = np.abs(t_ref - t_parent_end_start) <= i
         if len(pot_matches) == 0:
             continue
         comp_children = comp_tracks[comp_tracks[:, 3] == comp][:, 0]
+        t_child_start_comp = []
+        for j in comp_children:
+            t = comp_tracks[comp_tracks[:, 0] == j][0, 1]
+            t_child_start_comp.append(t)
         # Evaluate potential matches
-        for ref, tr in zip(
+        for ref, t_parent_end_ref in zip(
                 ends_with_split_ref[pot_matches],
                 t_ref[pot_matches]
         ):
             ref_children = ref_tracks[ref_tracks[:, 3] == ref][:, 0]
+            t_child_start_ref = []
+            for j in ref_children:
+                t = ref_tracks[ref_tracks[:, 0] == j][0, 1]
+                t_child_start_ref.append(t)
             if is_matching(
-                    comp, ref, mapped_ref, mapped_comp, ref_children,
-                    comp_children, tr, tc
+                    comp, ref,
+                    mapped_ref, mapped_comp,
+                    ref_children, comp_children,
+                    t_parent_end_ref, t_parent_end_start,
+                    t_child_start_ref,
+                    t_child_start_comp,
             ):
                 matches.append((ref, comp))
     return (len(matches), len(ends_with_split_comp) - len(matches), len(ends_with_split_ref) - len(matches))
 
+
 def bc(
         tp: int,
         fp: int,