byotrack 1.2.0.dev2__tar.gz → 1.2.0.dev3__tar.gz

{byotrack-1.2.0.dev2 → byotrack-1.2.0.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: byotrack
-Version: 1.2.0.dev2
+Version: 1.2.0.dev3
 Summary: Biological particle tracking with Python
 Home-page: https://github.com/raphaelreme/byotrack
 Author: Raphael Reme

{byotrack-1.2.0.dev2 → byotrack-1.2.0.dev3}/byotrack/__init__.py

@@ -83,4 +83,4 @@ from byotrack.api.tracks import Track
 from byotrack.video import Video, VideoTransformConfig
 
 
-__version__ = "1.2.0.dev2"
+__version__ = "1.2.0.dev3"

{byotrack-1.2.0.dev2 → byotrack-1.2.0.dev3}/byotrack/api/detector/detections.py

@@ -36,6 +36,32 @@ def _check_confidence(confidence: torch.Tensor) -> None:
     assert confidence.dtype is torch.float32
 
 
+@numba.njit
+def _compute_mass(segmentation: np.ndarray) -> np.ndarray:
+    """Extract the number of pixels of each object in the segmentation
+
+    Args:
+        segmentation (np.ndarray): Segmentation mask
+
+    Returns:
+        np.ndarray: Mass for each object
+            Shape (n,), dtype: int32
+
+    """
+    n = segmentation.max()
+    mass = np.zeros(n, dtype=np.int32)
+
+    # Ravel in 1D
+    segmentation = segmentation.reshape(-1)
+
+    for i in range(segmentation.shape[0]):
+        instance = segmentation[i] - 1
+        if instance != -1:
+            mass[instance] += 1
+
+    return mass
+
+
 @numba.njit(parallel=False)
 def _position_from_segmentation(segmentation: np.ndarray) -> np.ndarray:
     """Return the center (mean) of each instance in the segmentation"""
@@ -278,6 +304,8 @@ class Detections:
             Shape: ([D, ]H, W), dtype: int32
         confidence (torch.Tensor): Confidence for each instance
             Shape: (N,), dtype: float32
+        mass (torch.Tensor): Size of each object in pixel, inferred from the data.
+            Shape: (N,), dtype: int32
         use_median_position (bool): Use median instead of mean to compute positions from segmentation.
             Default: True (Usually more robust)
 
@@ -360,6 +388,15 @@ class Detections:
 
         return confidence
 
+    @property
+    def mass(self) -> torch.Tensor:
+        mass = self.data.get("mass", self._lazy_extrapolated_data.get("mass"))
+        if mass is None:
+            mass = self._extrapolate_mass()
+            self._lazy_extrapolated_data["confidence"] = mass
+
+        return mass
+
     @property
     def use_median_position(self) -> bool:
         return self._use_median_position
@@ -443,6 +480,15 @@ class Detections:
         """Extrapolate confidence"""
         return torch.ones(self.length)
 
+    def _extrapolate_mass(self) -> torch.Tensor:
+        if "segmentation" in self.data:
+            return torch.tensor(_compute_mass(self.data["segmentation"].numpy()), dtype=torch.int32)
+
+        if "bbox" in self.data:
+            return self.data["bbox"][:, self.dim :].prod(dim=-1)
+
+        return torch.ones(self.length, dtype=torch.int32)
+
     def __len__(self) -> int:
         return self.length
 

{byotrack-1.2.0.dev2 → byotrack-1.2.0.dev3}/byotrack/api/features_extractor.py

@@ -61,7 +61,7 @@ class MassExtractor(FeaturesExtractor):
     """Extract the mass of each detection (number of pixels)"""
 
     def __call__(self, frame: np.ndarray, detections: byotrack.Detections):
-        torch.tensor(compute_mass(detections.segmentation.numpy()), dtype=torch.float32)
+        return detections.mass
 
 
 class IntensityExtractor(FeaturesExtractor):
@@ -71,31 +71,6 @@ class IntensityExtractor(FeaturesExtractor):
         torch.tensor(compute_intensity(detections.segmentation.numpy(), frame.sum(axis=-1)), dtype=torch.float32)
 
 
-@numba.njit
-def compute_mass(segmentation: np.ndarray) -> np.ndarray:
-    """Extract the number of pixels of each detection
-
-    Args:
-        segmentation (np.ndarray): Segmentation mask
-
-    Returns:
-        np.ndarray: Mass for each object
-
-    """
-    n = segmentation.max()
-    mass = np.zeros(n, dtype=np.uint)
-
-    # Ravel in 1D
-    segmentation = segmentation.reshape(-1)
-
-    for i in range(segmentation.shape[0]):
-        instance = segmentation[i] - 1
-        if instance != -1:
-            mass[instance] += 1
-
-    return mass
-
-
 @numba.njit
 def compute_intensity(segmentation: np.ndarray, frame: np.ndarray) -> np.ndarray:
     """Extract the cumulated intensity of each detection

{byotrack-1.2.0.dev2 → byotrack-1.2.0.dev3}/byotrack/dataset/ctc.py

@@ -286,6 +286,8 @@ def _fast_disk_2d(
     positions: np.ndarray,
     identifiers: np.ndarray,
     radius: np.ndarray,
+    *,
+    overwrite=False,
 ):
     """Fast inplace drawing of disk in 2D
 
@@ -300,6 +302,8 @@ def _fast_disk_2d(
             Shape: (n,), dtype: uint16
         radius (np.ndarray): Radius of each disk
             Shape: (n, ), dtype: float32
+        overwrite (bool): Overwrite pixels that are already written (!=0)
+            Default: False
 
     """
     positions_round = np.round(positions).astype(np.int64)
@@ -315,6 +319,9 @@ def _fast_disk_2d(
             if not 0 <= i < segmentation.shape[0] or not 0 <= j < segmentation.shape[1]:
                 continue
 
+            if not overwrite and segmentation[i, j] != 0 and best_dist[i, j] == np.inf:
+                continue
+
             delta = pos - positions[k]
             dist = delta @ delta
 
@@ -325,12 +332,15 @@ def _fast_disk_2d(
 
 
 @numba.njit(parallel=True)
-def _fast_disk_3d(
+def _fast_disk_3d(  # pylint: disable=too-many-locals
     segmentation: np.ndarray,
     bbox: np.ndarray,
     positions: np.ndarray,
     identifiers: np.ndarray,
     radius: np.ndarray,
+    *,
+    anisoptropy=1.0,
+    overwrite=False,
 ):
     """Fast inplace drawing of disk in 3D
 
@@ -345,6 +355,11 @@ def _fast_disk_3d(
             Shape: (n,), dtype: uint16
         radius (np.ndarray): Radius of each disk
             Shape: (n, ), dtype: float32
+        anisotropy (float): Relative size of a pixel along the depth dimension
+            versus height/width dimensions.
+            Default: 1.0
+        overwrite (bool): Overwrite pixels that are already written (!=0)
+            Default: False
 
     """
     positions_round = np.round(positions).astype(np.int64)
@@ -364,7 +379,11 @@ def _fast_disk_3d(
             ):
                 continue
 
+            if not overwrite and segmentation[z, i, j] != 0 and best_dist[z, i, j] == np.inf:
+                continue
+
             delta = pos - positions[k]
+            delta[0] *= anisoptropy  # Increase distance in Z by the anisotropy
             dist = delta @ delta
 
             if dist <= radius[k]:
@@ -378,6 +397,9 @@ def draw_disk(
     positions: np.ndarray,
     identifiers: np.ndarray,
     radius: np.ndarray,
+    *,
+    anisotropy=1.0,
+    overwrite=False,
 ):
     """Draw disks on the segmentation
 
@@ -390,21 +412,27 @@ def draw_disk(
             Shape: (n,), dtype: uint16
         radius (np.ndarray): Radius of each disk
             Shape: (n, ), dtype: float32)
+        anisotropy (float): Relative size of a pixel along the depth dimension
+            versus height/width dimensions.
+            Default: 1.0
+        overwrite (bool): Overwrite pixels that are already written (!=0)
+            Default: False
+
     """
     # Wrapped to redirect in 2D/3D and numba does not support np.indices in 3.8
     if segmentation.ndim == 3:
         thresh = round(radius.max())
         bbox: np.ndarray = np.indices((thresh * 2 + 1, thresh * 2 + 1, thresh * 2 + 1)).transpose(1, 2, 3, 0) - thresh
         bbox = bbox.reshape(-1, 3)
-        _fast_disk_3d(segmentation, bbox, positions, identifiers, radius)
+        _fast_disk_3d(segmentation, bbox, positions, identifiers, radius, anisoptropy=anisotropy, overwrite=overwrite)
     else:
         thresh = int(round(radius.max()))
         bbox = np.indices((thresh * 2 + 1, thresh * 2 + 1)).transpose(1, 2, 0) - thresh
         bbox = bbox.reshape(-1, 2)
-        _fast_disk_2d(segmentation, bbox, positions, identifiers, radius)
+        _fast_disk_2d(segmentation, bbox, positions, identifiers, radius, overwrite=overwrite)
 
 
-def save_tracks(  # pylint: disable=too-many-branches,too-many-locals,too-many-statements
+def save_tracks(  # pylint: disable=too-many-branches,too-many-locals,too-many-statements,too-many-arguments
     path: Union[str, os.PathLike],
     tracks: Collection[byotrack.Track],
     detections_sequence: Sequence[byotrack.Detections] = (),
@@ -415,6 +443,8 @@ def save_tracks(  # pylint: disable=too-many-branches,too-many-locals,too-many-s
     last=0,
     shape: Optional[Tuple[int, ...]] = None,
     n_digit=4,
+    anisotropy=1.0,
+    overwrite_detections=False,
 ):
     """Save tracks in the CTC format [10]
 
@@ -453,6 +483,11 @@ def save_tracks(  # pylint: disable=too-many-branches,too-many-locals,too-many-s
             Default: None
         n_digit (int): Number of digit used to encode time in file names.
             Default: 4
+        anisotropy (float): Relative size of a pixel along the depth dimension
+            versus height/width dimensions.
+            Default: 1.0
+        overwrite_detections (bool): Overwrite the segmentation of objects with disk.
+            Default: False (Disk are only drawn on background)
 
     """
     path = pathlib.Path(path)
@@ -517,6 +552,8 @@ def save_tracks(  # pylint: disable=too-many-branches,too-many-locals,too-many-s
                 torch.stack(disk_positions).numpy(),
                 np.array(disk_ids, dtype=np.uint16) + 1,
                 np.full(len(disk_ids), default_radius, dtype=np.float32),
+                anisotropy=anisotropy,
+                overwrite=overwrite_detections,
             )
 
             # Safety checks because CTC is quite restrictive

{byotrack-1.2.0.dev2 → byotrack-1.2.0.dev3}/byotrack/fiji/run.py

@@ -10,16 +10,23 @@ class FijiRunner:  # pylint: disable=too-few-public-methods
     Attributes:
         fiji_path (str | os.PathLike): Path to the fiji executable
             The executable can be found inside the installation folder of Fiji.
-            Linux: Fiji.app/ImageJ-<os>.exe
+            Linux: Fiji.app/ImageJ-<os>
             Windows: Fiji.app/ImageJ-<os>.exe
             MacOs: Fiji.app/Contents/MacOs/ImageJ-<os>
+        capture_outputs (bool): Whether to PIPE stderr and stdout into Python
+            This will allow you to find the stdout/stderr inside `last_outputs`.
+            But outputs are captured, and you do not see them while the scripts run.
+            Default: False
+        last_outputs (subprocess.CompletedProcess): Outputs of the last subprocess.run
 
     """
 
     cmd = './{fiji} --ij2 --headless --console --run "{script}" "{args}"'
 
-    def __init__(self, fiji_path: Union[str, os.PathLike]) -> None:
+    def __init__(self, fiji_path: Union[str, os.PathLike], capture_outputs=False) -> None:
         self.fiji_path = fiji_path
+        self.capture_outputs = capture_outputs
+        self.last_outputs: subprocess.CompletedProcess = subprocess.CompletedProcess("", 0)
 
         assert os.path.isfile(fiji_path), "Unable to found the given path"
 
@@ -42,4 +49,8 @@ class FijiRunner:  # pylint: disable=too-few-public-methods
             cmd = cmd[2:]  # Strip ./ on windows
 
         print("Calling Fiji with:", cmd)
-        return subprocess.run(cmd, check=True, cwd=os.path.dirname(self.fiji_path), shell=True).returncode
+        self.last_outputs = subprocess.run(
+            cmd, check=True, cwd=os.path.dirname(self.fiji_path), shell=True, capture_output=self.capture_outputs
+        )
+
+        return self.last_outputs.returncode

{byotrack-1.2.0.dev2 → byotrack-1.2.0.dev3}/byotrack/implementation/linker/frame_by_frame/base.py

@@ -268,7 +268,7 @@ class FrameByFrameLinkerParameters:  # pylint: disable=too-many-instance-attribu
         self.split_factor = split_factor
         self.merge_factor = merge_factor
 
-        if merge_factor >= 1.0 or split_factor >= 1.0:
+        if merge_factor > 1.0 or split_factor > 1.0:
             warnings.warn("Merge or split factors should be lower than 1")
 
     association_threshold: float = 5.0
@@ -280,7 +280,7 @@ class FrameByFrameLinkerParameters:  # pylint: disable=too-many-instance-attribu
     merge_factor: float = 0.0
 
 
-class FrameByFrameLinker(byotrack.OnlineLinker):
+class FrameByFrameLinker(byotrack.OnlineLinker):  # pylint: disable=too-many-instance-attributes
     """Links detections online using frame-by-frame association
 
     Abstract class for frame-by-frame linker. It decomposes the update step in 6 parts:
@@ -338,8 +338,13 @@ class FrameByFrameLinker(byotrack.OnlineLinker):
         self.inactive_tracks: List[TrackHandler] = []
         self.active_tracks: List[TrackHandler] = []
         self.all_positions: List[torch.Tensor] = []
-        self.split_links = torch.zeros((0, 2), dtype=torch.int32)
-        self.merge_links = torch.zeros((0, 2), dtype=torch.int32)
+        self.active_mass = torch.zeros((0,), dtype=torch.float32)
+
+        # Instantaneous useful quantities
+        self._links = torch.zeros((0, 2), dtype=torch.int32)
+        self._split_links = torch.zeros((0, 2), dtype=torch.int32)
+        self._merge_links = torch.zeros((0, 2), dtype=torch.int32)
+        self._unmatched_detections = torch.full((0,), True)
 
     def reset(self) -> None:
         super().reset()
@@ -349,8 +354,11 @@ class FrameByFrameLinker(byotrack.OnlineLinker):
         self.inactive_tracks = []
         self.active_tracks = []
         self.all_positions = []
-        self.split_links = torch.zeros((0, 2), dtype=torch.int32)
-        self.merge_links = torch.zeros((0, 2), dtype=torch.int32)
+        self.active_mass = torch.zeros((0,), dtype=torch.float32)
+        self._links = torch.zeros((0, 2), dtype=torch.int32)
+        self._split_links = torch.zeros((0, 2), dtype=torch.int32)
+        self._merge_links = torch.zeros((0, 2), dtype=torch.int32)
+        self._unmatched_detections = torch.full((0,), True)
 
     def collect(self) -> List[byotrack.Track]:
         tracks = []
@@ -412,65 +420,52 @@ class FrameByFrameLinker(byotrack.OnlineLinker):
         """
 
     @abstractmethod
-    def post_association(self, frame: np.ndarray, detections: byotrack.Detections, links: torch.Tensor):
-        """Update the tracks and the internal variables of the tracker
-
-        It should call the `update` method of each active tracks and update any internal model/data.
-        It should also create new track handlers for each extra detection.
-        Finally, it is also responsible to register the position of each active track in `all_positions`
-        for the current time frame.
+    def post_association(self, frame: np.ndarray, detections: byotrack.Detections, active_mask: torch.Tensor):
+        """Update the internal state of the tracker after `update_active_tracks`
 
-        See `update_active_tracks` which can be called inside this implementation to handle tracks termination
-        and creation.
+        It should update any internal model/data. It is also responsible to register the position of each active
+        track in `all_positions` for the current time frame.
 
         Args:
             frame (np.ndarray): The current frame of the video
                 Shape: (H, W, C), dtype: float
             detections (byotrack.Detections): Detections for the given frame
-            links (torch.Tensor): The links made between active tracks and the detections
-                Shape: (L, 2), dtype: int32
+            active_mask (torch.Tensor): Boolean tensor indicating True for still active tracks
+                Shape: (N_tracks), dtype: bool
 
         """
 
     def update_active_tracks(  # pylint: disable=too-many-branches,too-many-statements,too-many-locals
-        self, links: torch.Tensor, detections: byotrack.Detections
-    ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+        self, detections: byotrack.Detections
+    ) -> torch.Tensor:
         """Updates tracks handler and creates new ones for extra detections
 
         Tracks that are terminated are stored inside `inactive_tracks` and dropped from `active_tracks`.
-        It can be called inside `post_association` to facilitate the code.
+        It is called by update before `post_association`.
 
         It also handles merges and splits. In the case of some specific merges, it may change a few links.
         The updated links are returned, with a still_active mask for tracks and a new_track mask
         for detections.
 
         Args:
-            links (torch.Tensor): The links made between active tracks and the detections
-                Shape: (L, 2), dtype: int32
             detections (byotrack.Detections): Detections for the given frame
 
         Returns:
-            torch.Tensor: Updated links (in case of some specific merges)
-                Shape: (L, 2), dtype: int32
             torch.Tensor: Boolean tensor indicating True for still active tracks
                 Shape: (N_tracks), dtype: bool
-            torch.Tensor: Boolean tensor indicating True for newly created tracks from detections
-                Shape: (N_dets), dtype: bool
 
         """
-        if self.split_links.shape[0] + self.merge_links.shape[0] == 0:  # Fall back to old simpler version
-            return links, self._update_active_tracks(links), self._handle_extra_detections(detections, links)
+        if self._split_links.shape[0] + self._merge_links.shape[0] == 0:  # Fall back to old simpler version
+            active_mask = self._update_active_tracks()
+            self._handle_extra_detections(detections)
+            return active_mask
 
         # Ugly to handle merge and splits smoothly... If you do not care about that, read only the old simpler version
         # Or even use offline split and merge strategies.
 
-        # Find unmatched measures
-        unmatched = torch.full((len(detections),), True)
-        unmatched[links[:, 1]] = False
-
         # Create new tracks from unmatched measures
         new_tracks: List[TrackHandler] = []
-        for i in torch.arange(len(detections))[unmatched].tolist():
+        for i in torch.arange(len(detections))[self._unmatched_detections].tolist():
             track = TrackHandler(
                 self.specs.n_valid,
                 self.specs.n_gap,
@@ -482,20 +477,22 @@ class FrameByFrameLinker(byotrack.OnlineLinker):
 
         # Lots of useful identifiers mapping
         det_to_new_track = torch.full((len(detections),), -1, dtype=torch.int32)
-        det_to_new_track[torch.arange(len(detections))[unmatched]] = torch.arange(len(new_tracks), dtype=torch.int32)
+        det_to_new_track[torch.arange(len(detections))[self._unmatched_detections]] = torch.arange(
+            len(new_tracks), dtype=torch.int32
+        )
 
         track_to_det = torch.full((len(self.active_tracks),), -1, dtype=torch.int32)
-        track_to_det[links[:, 0]] = links[:, 1]
+        track_to_det[self._links[:, 0]] = self._links[:, 1]
         det_to_track = torch.full((len(detections),), -1, dtype=torch.int32)
-        det_to_track[links[:, 1]] = links[:, 0]
+        det_to_track[self._links[:, 1]] = self._links[:, 0]
 
         track_to_det_split = torch.full((len(self.active_tracks),), -1, dtype=torch.int32)
-        track_to_det_split[self.split_links[:, 0]] = self.split_links[:, 1]
+        track_to_det_split[self._split_links[:, 0]] = self._split_links[:, 1]
 
         track_to_det_merge = torch.full((len(self.active_tracks),), -1, dtype=torch.int32)
-        track_to_det_merge[self.merge_links[:, 0]] = self.merge_links[:, 1]
+        track_to_det_merge[self._merge_links[:, 0]] = self._merge_links[:, 1]
         det_to_track_merge = torch.full((len(detections),), -1, dtype=torch.int32)
-        det_to_track_merge[self.merge_links[:, 1]] = self.merge_links[:, 0]
+        det_to_track_merge[self._merge_links[:, 1]] = self._merge_links[:, 0]
 
         # Update active tracks (for merges and splits, they are still active but replaced by a new handler)
         active_mask = torch.full((len(self.active_tracks),), False)
@@ -619,30 +616,24 @@ class FrameByFrameLinker(byotrack.OnlineLinker):
             track.merge_id = det_to_merge_id[track.merge_id]
 
         # Relabel links
-        links[:, 0] = torch.arange(len(track_to_det))[track_to_det != -1]
-        links[:, 1] = track_to_det[track_to_det != -1]
+        self._links[:, 0] = torch.arange(len(track_to_det))[track_to_det != -1]
+        self._links[:, 1] = track_to_det[track_to_det != -1]
 
         self.active_tracks = still_active + new_tracks
 
-        return links, active_mask, unmatched
+        return active_mask
 
-    def _update_active_tracks(self, links: torch.Tensor) -> torch.Tensor:
+    def _update_active_tracks(self) -> torch.Tensor:
         """Calls `update` for active tracks and return a boolean mask that indicates which track is still active
 
         Tracks that are terminated are stored inside `inactive_tracks` and dropped from `active_tracks`.
 
-        It can be called inside `post_association` to simplify the code.
-
-        Args:
-            links (torch.Tensor): The links made between active tracks and the detections
-                Shape: (L, 2), dtype: int32
-
         Returns:
             torch.Tensor: Boolean tensor indicating True for still active tracks
 
         """
         i_to_j = torch.full((len(self.active_tracks),), -1, dtype=torch.int32)
-        i_to_j[links[:, 0]] = links[:, 1]
+        i_to_j[self._links[:, 0]] = self._links[:, 1]
         active_mask = torch.full((len(self.active_tracks),), False)
         still_active = []
         for i, track in enumerate(self.active_tracks):
@@ -659,36 +650,21 @@ class FrameByFrameLinker(byotrack.OnlineLinker):
 
         return active_mask
 
-    def _handle_extra_detections(self, detections: byotrack.Detections, links: torch.Tensor) -> torch.Tensor:
+    def _handle_extra_detections(self, detections: byotrack.Detections):
         """Handle extra detections by creating new track handlers
 
-        It can be called inside `post_association` to create track handlers from extra detections. It
-        returns a boolean mask indicating a track creating for each detection.
-
         Args:
             detections (byotrack.Detections): Detections for the given frame
-            links (torch.Tensor): The links made between active tracks and the detections
-                Shape: (L, 2), dtype: int32
-
-        Returns:
-            torch.Tensor: Boolean tensor indicating True for newly created tracks from detections
-                Shape: (N_dets), dtype: bool
 
         """
-        # Find unmatched measures
-        unmatched = torch.full((len(detections),), True)
-        unmatched[links[:, 1]] = False
-
         # Create a new active track for each unmatched measure
-        for i in torch.arange(len(detections))[unmatched].tolist():
+        for i in torch.arange(len(detections))[self._unmatched_detections].tolist():
             handler = TrackHandler(
                 self.specs.n_valid, self.specs.n_gap, self.frame_id, len(self.inactive_tracks) + len(self.active_tracks)
             )
             handler.update(self.frame_id, i)
             self.active_tracks.append(handler)
 
-        return unmatched
-
     def update_detections(self, detections: byotrack.Detections) -> byotrack.Detections:
         """Optional modification of the currrent detections based on the current state
 
@@ -720,15 +696,16 @@ class FrameByFrameLinker(byotrack.OnlineLinker):
         """
 
         cost, threshold = self.cost(frame, detections)
-        links = self.specs.association_method.solve(cost, threshold)
+        self._links = self.specs.association_method.solve(cost, threshold)
+
+        self._unmatched_detections = torch.full((len(detections),), True)
+        self._unmatched_detections[self._links[:, 1]] = False
 
         if self.specs.merge_factor == 0 and self.specs.split_factor == 0:
-            return links  # No merge or splits
+            return self._links  # No merge or splits
 
-        unmatched_detections = torch.full((len(detections),), True)
-        unmatched_detections[links[:, 1]] = False
         unmatched_tracks = torch.full((len(self.active_tracks),), True)
-        unmatched_tracks[links[:, 0]] = False
+        unmatched_tracks[self._links[:, 0]] = False
         valid_tracks = torch.tensor(
             [(track.track_state == TrackHandler.TrackState.VALID) for track in self.active_tracks], dtype=torch.bool
         )
@@ -736,25 +713,45 @@ class FrameByFrameLinker(byotrack.OnlineLinker):
         if self.specs.merge_factor > 0:
             # We simply do a 2nd association between unassociated VALID tracks with associated detections
             tracks_mask = unmatched_tracks & valid_tracks
-            self.merge_links = self.specs.association_method.solve(
-                cost[tracks_mask][:, ~unmatched_detections], threshold * self.specs.merge_factor
+
+            # TODO: Mass factor
+            # self.active_mass[tracks_mask]
+
+            self._merge_links = self.specs.association_method.solve(
+                cost[tracks_mask][:, ~self._unmatched_detections], threshold * self.specs.merge_factor
             )
 
             # Relabel
-            self.merge_links[:, 0] = torch.arange(len(self.active_tracks))[tracks_mask][self.merge_links[:, 0]]
-            self.merge_links[:, 1] = torch.arange(len(detections))[~unmatched_detections][self.merge_links[:, 1]]
+            self._merge_links[:, 0] = torch.arange(len(self.active_tracks))[tracks_mask][self._merge_links[:, 0]]
+            self._merge_links[:, 1] = torch.arange(len(detections))[~self._unmatched_detections][
+                self._merge_links[:, 1]
+            ]
 
         if self.specs.split_factor > 0:
             # We simply do a 2nd association between associated tracks with unassociated detections
-            self.split_links = self.specs.association_method.solve(
-                cost[~unmatched_tracks][:, unmatched_detections], threshold * self.specs.split_factor
+
+            # Split mass factor
+            # We increase the distance if the split is not evenly weighted and if it does not sum at the previous mass
+            track_mass = self.active_mass[self._links[:, 0]]
+            associated_mass = detections.mass[self._links[:, 1]]
+            non_associated_mass = detections.mass[self._unmatched_detections]
+
+            even_factor = torch.maximum(associated_mass[:, None], non_associated_mass[None, :]) / torch.minimum(
+                associated_mass[:, None], non_associated_mass[None, :]
+            )
+            sum_ = associated_mass[:, None] + non_associated_mass[None, :]
+            mass_factor = torch.maximum(track_mass[:, None], sum_) / torch.minimum(track_mass[:, None], sum_)
+
+            self._split_links = self.specs.association_method.solve(
+                cost[~unmatched_tracks][:, self._unmatched_detections] * even_factor * mass_factor,
+                threshold * self.specs.split_factor,
             )
 
             # Relabel
-            self.split_links[:, 0] = torch.arange(len(self.active_tracks))[~unmatched_tracks][self.split_links[:, 0]]
-            self.split_links[:, 1] = torch.arange(len(detections))[unmatched_detections][self.split_links[:, 1]]
+            self._split_links[:, 0] = torch.arange(len(self.active_tracks))[~unmatched_tracks][self._split_links[:, 0]]
+            self._split_links[:, 1] = torch.arange(len(detections))[self._unmatched_detections][self._split_links[:, 1]]
 
-        return links
+        return self._links
 
     def update(self, frame: np.ndarray, detections: byotrack.Detections) -> None:
         self.frame_id += 1
@@ -776,8 +773,15 @@ class FrameByFrameLinker(byotrack.OnlineLinker):
                 remove_feats = True
                 self.features_extractor.register(frame, detections)
 
-        links = self.associate(frame, detections)
-        self.post_association(frame, detections, links)
+        self.associate(frame, detections)
+        active_mask = self.update_active_tracks(detections)
+        self.post_association(frame, detections, active_mask)
+
+        # Handle mass with a fixed ema and concatenate with mass of newly created track
+        self.active_mass[self._links[:, 0]] -= (1.0 - 0.8) * (
+            self.active_mass[self._links[:, 0]] - detections.mass[self._links[:, 1]]
+        )
+        self.active_mass = torch.cat((self.active_mass[active_mask], detections.mass[self._unmatched_detections]))
 
         assert len(self.all_positions[-1]) == len(
             self.active_tracks

{byotrack-1.2.0.dev2 → byotrack-1.2.0.dev3}/byotrack/implementation/linker/frame_by_frame/kalman_linker.py

@@ -342,22 +342,19 @@ class KalmanLinker(FrameByFrameLinker):
         cost = -self.projections[:, None].log_likelihood(detections.position[None, ..., None])
         return cost, -torch.log(torch.tensor(self.specs.association_threshold)).item()
 
-    def post_association(self, _: np.ndarray, detections: byotrack.Detections, links: torch.Tensor):
+    def post_association(self, _: np.ndarray, detections: byotrack.Detections, active_mask: torch.Tensor):
         if self.active_states is None or self.kalman_filter is None or self.projections is None:
             raise RuntimeError("The linker should already be initialized.")
 
-        # Update handlers
-        links, active_mask, unmatched = self.update_active_tracks(links, detections)
-
         # Update the state of associated tracks (unassociated tracks keep the predicted state)
-        self.active_states[links[:, 0]] = self.kalman_filter.update(
-            self.active_states[links[:, 0]],
-            detections.position[links[:, 1]][..., None],
-            projection=self.projections[links[:, 0]],
+        self.active_states[self._links[:, 0]] = self.kalman_filter.update(
+            self.active_states[self._links[:, 0]],
+            detections.position[self._links[:, 1]][..., None],
+            projection=self.projections[self._links[:, 0]],
         )
 
         # Create new states for unmatched measures
-        unmatched_measures = detections.position[unmatched]
+        unmatched_measures = detections.position[self._unmatched_detections]
 
         # Build the initial states for tracks:
         # We initialize the position using the detection position and the measurement std as covariance.

{byotrack-1.2.0.dev2 → byotrack-1.2.0.dev3}/byotrack/implementation/linker/frame_by_frame/koft.py

@@ -38,7 +38,7 @@ class KOFTLinkerParameters(KalmanLinkerParameters):
             order-th derivative can change between two consecutive frames. A common rule of thumb is to use
             3 * process_std ~= max_t(| x^(order)(t) - x^(order)(t+1)|). It can be provided for each dimension).
             Default: 1.5 pixels / frame^order
-        kalman_order (int): Order of the Kalman filter to use. 0 is not supported.
+        kalman_order (int): Order of the Kalman filter to use. 0 is for brownian motion (it predicts a 0 velocity)
             1 for directed brownian motion, 2 for accelerated brownian motions, etc...
             Default: 1
         n_valid (int): Number associated detections required to validate the track after its creation.
@@ -118,8 +118,6 @@ class KOFTLinkerParameters(KalmanLinkerParameters):
         self.extract_flows_on_detections = extract_flows_on_detections
         self.always_measure_velocity = always_measure_velocity
 
-        assert self.kalman_order >= 1, "With KOFT, the velocity is measured and thus should be modeled."
-
     flow_std: Union[float, torch.Tensor] = 1.0
     extract_flows_on_detections: bool = False
     always_measure_velocity: bool = True
@@ -234,9 +232,13 @@ class KOFTLinker(KalmanLinker):
                 self.specs.detection_std,
                 self.specs.process_std,
                 dim=detections.dim,
-                order=self.specs.kalman_order,
+                order=self.specs.kalman_order + (self.specs.kalman_order == 0),
                 approximate=True,  # Approximate so that a flow precisely means the velocity modeled here
             )
+            if self.specs.kalman_order == 0:
+                # In order 0, we still model velocity, but we always predict it at 0
+                self.kalman_filter.process_matrix[detections.dim :, detections.dim :] = 0
+
             # Doubles the measurement space to measure velocity
             self.kalman_filter.measurement_matrix = torch.eye(detections.dim * 2, self.kalman_filter.state_dim)
             self.kalman_filter.measurement_noise = torch.eye(detections.dim * 2)
@@ -297,22 +299,19 @@ class KOFTLinker(KalmanLinker):
         cost = -projections[:, None].log_likelihood(detections.position[None, ..., None])
         return cost, -torch.log(torch.tensor(self.specs.association_threshold)).item()
 
-    def post_association(self, _: np.ndarray, detections: byotrack.Detections, links: torch.Tensor):
+    def post_association(self, _: np.ndarray, detections: byotrack.Detections, active_mask: torch.Tensor):
         if self.active_states is None or self.kalman_filter is None or self.projections is None:
             raise RuntimeError("The linker should already be initialized.")
 
         self.last_detections = detections  # Save detections (May be required)
 
-        # Update handlers
-        links, active_mask, unmatched = self.update_active_tracks(links, detections)
-
         # Update the state of associated tracks (unassociated tracks keep the predicted state)
-        self.active_states[links[:, 0]] = self.kalman_filter.update(
-            self.active_states[links[:, 0]],
-            detections.position[links[:, 1]][..., None],
+        self.active_states[self._links[:, 0]] = self.kalman_filter.update(
+            self.active_states[self._links[:, 0]],
+            detections.position[self._links[:, 1]][..., None],
             projection=torch_kf.GaussianState(
-                self.projections.mean[links[:, 0], : detections.dim],
-                self.projections.covariance[links[:, 0], : detections.dim, : detections.dim],
+                self.projections.mean[self._links[:, 0], : detections.dim],
+                self.projections.covariance[self._links[:, 0], : detections.dim, : detections.dim],
                 None,  # /!\ inv(cov[:2,:2]) != inv(cov)[:2, :2] =>
             ),
             measurement_matrix=self.kalman_filter.measurement_matrix[: detections.dim],
@@ -320,7 +319,7 @@ class KOFTLinker(KalmanLinker):
         )
 
         # Create new states for unmatched measures
-        unmatched_measures = detections.position[unmatched]
+        unmatched_measures = detections.position[self._unmatched_detections]
         self.n_initial = unmatched_measures.shape[0]
 
         # Build the initial states for tracks:

{byotrack-1.2.0.dev2 → byotrack-1.2.0.dev3}/byotrack/implementation/linker/frame_by_frame/nearest_neighbor.py

@@ -135,21 +135,20 @@ class NearestNeighborLinker(FrameByFrameLinker):
             self.specs.association_threshold,
         )
 
-    def post_association(self, _: np.ndarray, detections: byotrack.Detections, links: torch.Tensor):
+    def post_association(self, _: np.ndarray, detections: byotrack.Detections, active_mask: torch.Tensor):
         if self.active_positions is None:
             self.active_positions = torch.empty((0, detections.position.shape[1]))
 
-        # Update handlers
-        links, active_mask, unmatched = self.update_active_tracks(links, detections)
-
         # Update tracks positions with detections
         # Optionally using an EMA to reduce detections noise
-        self.active_positions[links[:, 0]] -= (1.0 - self.specs.ema) * (
-            self.active_positions[links[:, 0]] - detections.position[links[:, 1]]
+        self.active_positions[self._links[:, 0]] -= (1.0 - self.specs.ema) * (
+            self.active_positions[self._links[:, 0]] - detections.position[self._links[:, 1]]
         )
 
         # Merge still active positions and new ones
-        self.active_positions = torch.cat((self.active_positions[active_mask], detections.position[unmatched]))
+        self.active_positions = torch.cat(
+            (self.active_positions[active_mask], detections.position[self._unmatched_detections])
+        )
 
         self.all_positions.append(self.active_positions.clone())
 

{byotrack-1.2.0.dev2 → byotrack-1.2.0.dev3}/byotrack/implementation/linker/trackmate/trackmate.py

@@ -123,7 +123,6 @@ class TrackMateLinker(byotrack.Linker):  # pylint: disable=too-few-public-method
 
     Note:
         This implementation requires Fiji to be installed (https://imagej.net/downloads)
-        And tifffile library (https://github.com/cgohlke/tifffile#quickstart)
 
     Note:
         In case of missed detections, positions are filled with nan. To fill nan with true values, use an Interpolator
@@ -144,7 +143,7 @@ class TrackMateLinker(byotrack.Linker):  # pylint: disable=too-few-public-method
         Args:
             fiji_path (str | os.PathLike): Path to the fiji executable
                 The executable can be found inside the installation folder of Fiji.
-                Linux: Fiji.app/ImageJ-<os>.exe
+                Linux: Fiji.app/ImageJ-<os>
                 Windows: Fiji.app/ImageJ-<os>.exe
                 MacOs: Fiji.app/Contents/MacOs/ImageJ-<os>
 

{byotrack-1.2.0.dev2 → byotrack-1.2.0.dev3}/byotrack/metrics/ctc.py

@@ -8,6 +8,7 @@ In the future, we may wrap the Fiji plugin to access BIO metrics.
 import os
 import pathlib
 import platform
+import re
 import shutil
 import subprocess
 import tempfile
@@ -16,6 +17,7 @@ import warnings
 
 
 import byotrack
+from byotrack import fiji
 from byotrack.dataset import ctc
 from byotrack.utils import sorted_alphanumeric
 
@@ -39,6 +41,7 @@ class CTCSoftwareRunner:  # pylint: disable=too-few-public-methods
         ctc_software (pathlib.Path): Path to the ctc software folder.
             It should be the root folder containing Win/Linux/Mac subfolders with their executables.
         system (str): The user system in the CTC nomenclature. One of Linux, Mac or Win.
+        last_log (str): Logs of the last computed metrics
 
     """
 
@@ -46,6 +49,7 @@ class CTCSoftwareRunner:  # pylint: disable=too-few-public-methods
 
     def __init__(self, ctc_software: Union[str, os.PathLike]):
         self.ctc_software = pathlib.Path(ctc_software)
+        self.last_log = ""
 
         self.system = platform.system()
         if self.system == "Darwin":
@@ -99,6 +103,8 @@ class CTCSoftwareRunner:  # pylint: disable=too-few-public-methods
                 "Cannot parse outputs, the CTC software probably found an error: " + output_string
             ) from exc
 
+        self.last_log = (pathlib.Path(dataset) / f"{seq:02}_RES" / f"{metric}_log.txt").read_text("utf-8")
+
         return value
 
 
@@ -129,10 +135,6 @@ class CTCMetrics(CTCSoftwareRunner):
 
     """
 
-    def __init__(self, ctc_software):
-        super().__init__(ctc_software)
-        self.last_log = ""
-
     def compute_tracking_metric(
         self,
         metric: str,
@@ -191,8 +193,6 @@ class CTCMetrics(CTCSoftwareRunner):
             else:
                 raise ValueError("Without any detections, `shape` must be provided")
 
-        if detections_sequence:
-            shape = detections_sequence[0].shape
         with tempfile.TemporaryDirectory(prefix="ByoTrack-CTC-Metrics") as output_dir:
             output_path = pathlib.Path(output_dir)
             ground_truth_path = output_path / "01_GT" / ("SEG" if metric == "SEG" else "TRA")
@@ -216,10 +216,7 @@ class CTCMetrics(CTCSoftwareRunner):
                     **kwargs,
                 )
 
-            results = self.run(metric, output_path, 1)
-            self.last_log = (output_path / "01_RES" / f"{metric}_log.txt").read_text("utf-8")
-
-            return results
+            return self.run(metric, output_path, 1)
 
     def compute_detection_metric(
         self,
@@ -268,10 +265,7 @@ class CTCMetrics(CTCSoftwareRunner):
                     ground_truth_path, ground_truth_detections_sequence, as_res=False, as_seg=metric == "SEG"
                 )
 
-            results = self.run(metric, output_path, 1)
-            self.last_log = (output_path / "01_RES" / f"{metric}_log.txt").read_text("utf-8")
-
-            return results
+            return self.run(metric, output_path, 1)
 
     @staticmethod
     def copy_ground_truth(
@@ -351,3 +345,147 @@ class CTCMetrics(CTCSoftwareRunner):
         for path in res_tiff_paths if is_res else gt_track_tiff_paths:
             frame_id = int(path.stem[4 if is_res else 9 :])
             shutil.copy(path, target_path / f"man_{'seg' if as_seg else 'track'}{frame_id:04}.tif")
+
+
+class BioMetrics:
+    """Wrapper around the CTC "Biological measures" Fiji plugin [10]
+
+    It allows the computations of BIO metrics for the Cell Tracking Challenge [10].
+
+    Note:
+        This implementation requires Fiji to be installed (https://imagej.net/downloads)
+        with the CTC plugins (https://github.com/CellTrackingChallenge/fiji-plugins)
+
+    Attributes:
+        runner (byotrack.fiji.FijiRunner): Fiji runner
+        last_metrics (Tuple[float, float, float, float]): Sub metrics information for the last computed BIO
+            It consists of ("CT", "TF", "BC(i)", "CCA"). Their average gives the BIO metric.
+
+    """
+
+    plugin_name = "Biological measures"
+    # Reg exp for parsing outputs: find the last 4 numbers in the output line such in the format 'a, b, c, d]]'
+    output_regexp = re.compile(r"([+-]?\d*\.\d+), ([+-]?\d*\.\d+), ([+-]?\d*\.\d+), ([+-]?\d*\.\d+)]]$")
+
+    def __init__(self, fiji_path: Union[str, os.PathLike]) -> None:
+        """Constructor
+
+        Args:
+            fiji_path (str | os.PathLike): Path to the fiji executable
+                The executable can be found inside the installation folder of Fiji.
+                Linux: Fiji.app/ImageJ-<os>
+                Windows: Fiji.app/ImageJ-<os>.exe
+                MacOs: Fiji.app/Contents/MacOs/ImageJ-<os>
+
+        """
+        self.runner = fiji.FijiRunner(fiji_path, capture_outputs=True)
+        self.last_metrics = (0.0, 0.0, 0.0, 0.0)
+
+    def run(self, dataset: Union[str, os.PathLike], seq=1, n_digit=4) -> float:
+        """Run the CTC "Biological measures" plugin on the given dataset.
+
+        The dataset should already have results stored in it. It expects the CTC format.
+
+        Args:
+            metric (str): The metric to evaluate. One of (TRA, DET, SEG).
+            dataset (Union[str, os.PathLike]): Path to the dataset to evaluate.
+            seq (int): Sequence to evaluate inside the dataset.
+                The plugin will compare {dataset}/{seq:02}_RES with {dataset}/{seq:02}_GT
+                Default: 1
+            n_digit (int): Number of digits used to encode time in file names.
+                It is dataset dependant, but in ByoTrack, by default we use 4 digits.
+                Default: 4
+
+        Returns:
+            float: The evaluated metric
+
+        """
+        path = pathlib.Path(dataset)
+
+        # Let's do output redirection
+        self.runner.run(
+            "Biological measures", resPath=path / f"{seq:02}_RES", gtPath=path / f"{seq:02}_GT", noOfDigits=n_digit
+        )
+
+        line = self.runner.last_outputs.stdout.decode().strip().split("\n")[-1]
+        match = self.output_regexp.search(line)
+        if not match:
+            raise RuntimeError("Cannot parse outputs, the CTC software probably found an error: " + line)
+
+        self.last_metrics = tuple(  # type: ignore
+            (float(group) if float(group) >= 0.0 else 0.0) for group in match.groups()
+        )
+
+        return sum(self.last_metrics) / 4
+
+    def compute(
+        self,
+        tracks: Collection[byotrack.Track],
+        ground_truth_tracks: Union[str, os.PathLike, Collection[byotrack.Track]],
+        *,
+        detections_sequence: Sequence[byotrack.Detections] = (),
+        ground_truth_detections_sequence: Sequence[byotrack.Detections] = (),
+        **kwargs,
+    ) -> float:
+        """Compute BIO metric for the given tracks and ground truthes.
+
+        It will create a temporary folder, to store the tracks and ground-truthes in the right format and then
+        execute the CTC plugins. The temporary folder is removed at the end.
+
+        See `run` to simply compute the metric of an already existing folder.
+
+        Note:
+            In CTC, matching of predicted tracks with GT ones is done based on a kind of IOU.
+            Therefore, it may be useful to provide the detections_sequence associated with the tracks.
+            You may also tweak the `default_radius` arguments (in kwargs). (See `ctc.save_tracks`)
+
+        Args:
+            tracks (Collection[byotrack.Track]): Predicted tracks to evaluate.
+            ground_truth_tracks (Union[str, os.PathLike, Collection[byotrack.Track]]): Ground truth data.
+                It is either a path to the GT tracks folder, which will be copied in our temporary folder.
+                Or it is a list of ByoTrack.Track, that will be saved in the temporary folder.
+            detections_sequence (Sequence[byotrack.Detections]): Optional detections, used when saving the tracks.
+                Default: ()  # No detections and tracks segmentations will be disk of radius `default_radius`.
+            ground_truth_detections_sequence (Sequence[byotrack.Detections]): Optional detections for ground-truth.
+                When saving the GT tracks, these detections are used. See `ctc.save_tracks`.
+                Default: ()  # No detections and tracks segmentations will be disk of radius `default_radius`.
+            **kwargs: Additional arguments to provide to the `ctc.save_tracks` function.
+                'shape': Provide the shape of saved image. It is mandatory if no detections is provided.
+                'default_radius': Radius of the disk drawn for tracks that have no detections.
+                'last': Last frame to consider. (Typically to shorten the sequences,
+                or if no object is tracked on the last frames, this will enforce the creation of empty tiff files)
+
+        """
+        if "shape" in kwargs:
+            shape = kwargs.pop("shape")
+        else:
+            if detections_sequence:
+                shape = detections_sequence[0].shape
+            elif ground_truth_detections_sequence:
+                shape = ground_truth_detections_sequence[0].shape
+            else:
+                raise ValueError("Without any detections, `shape` must be provided")
+
+        with tempfile.TemporaryDirectory(prefix="ByoTrack-CTC-Metrics") as output_dir:
+            output_path = pathlib.Path(output_dir)
+            ground_truth_path = output_path / "01_GT" / "TRA"
+            ctc.save_tracks(
+                output_path / "01_RES", tracks, detections_sequence, as_res=True, shape=shape, n_digit=4, **kwargs
+            )
+            if isinstance(ground_truth_tracks, (str, os.PathLike)):
+                if ground_truth_detections_sequence:
+                    warnings.warn(
+                        "When using a saved GT folder, it will be copied and ground-truth detections are ignored"
+                    )
+                CTCMetrics.copy_ground_truth(ground_truth_tracks, ground_truth_path)
+            else:
+                ctc.save_tracks(
+                    ground_truth_path,
+                    ground_truth_tracks,
+                    ground_truth_detections_sequence,
+                    as_res=False,
+                    shape=shape,
+                    **kwargs,
+                )
+
+            return self.run(output_path, 1)

{byotrack-1.2.0.dev2 → byotrack-1.2.0.dev3}/byotrack.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: byotrack
-Version: 1.2.0.dev2
+Version: 1.2.0.dev3
 Summary: Biological particle tracking with Python
 Home-page: https://github.com/raphaelreme/byotrack
 Author: Raphael Reme