byotrack 1.2.0.dev1__tar.gz → 1.2.0.dev3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: byotrack
-Version: 1.2.0.dev1
+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.dev1 → 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.dev1"
+__version__ = "1.2.0.dev3"

{byotrack-1.2.0.dev1 → 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.dev1 → byotrack-1.2.0.dev3}/byotrack/api/features_extractor.py

@@ -4,6 +4,7 @@ from abc import ABC, abstractmethod
 from typing import Iterable
 
 import numpy as np
+import numba  # type: ignore
 import torch
 
 import byotrack  # pylint: disable=cyclic-import
@@ -56,4 +57,42 @@ class MultiFeaturesExtractor(FeaturesExtractor):
         return torch.cat(features, dim=-1)
 
 
-# TODO: Add some examples
+class MassExtractor(FeaturesExtractor):
+    """Extract the mass of each detection (number of pixels)"""
+
+    def __call__(self, frame: np.ndarray, detections: byotrack.Detections):
+        return detections.mass
+
+
+class IntensityExtractor(FeaturesExtractor):
+    """Extract the sum of intensities of each detection"""
+
+    def __call__(self, frame: np.ndarray, detections: byotrack.Detections):
+        torch.tensor(compute_intensity(detections.segmentation.numpy(), frame.sum(axis=-1)), dtype=torch.float32)
+
+
+@numba.njit
+def compute_intensity(segmentation: np.ndarray, frame: np.ndarray) -> np.ndarray:
+    """Extract the cumulated intensity of each detection
+
+    Args:
+        segmentation (np.ndarray): Segmentation mask
+        frame (np.ndarray): Video frame (should have the same number of pixels than segmentation)
+
+    Returns:
+        np.ndarray: Sum of intensity for each object
+
+    """
+    n = segmentation.max()
+    intensity = np.zeros(n, dtype=frame.dtype)
+
+    # Ravel in 1D
+    segmentation = segmentation.reshape(-1)
+    frame = frame.reshape(-1)
+
+    for i in range(segmentation.shape[0]):
+        instance = segmentation[i] - 1
+        if instance != -1:
+            intensity[instance] += frame[i]
+
+    return intensity

{byotrack-1.2.0.dev1 → 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.dev1 → 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