byotrack 1.2.0.dev0__tar.gz → 1.2.0.dev2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: byotrack
-Version: 1.2.0.dev0
+Version: 1.2.0.dev2
 Summary: Biological particle tracking with Python
 Home-page: https://github.com/raphaelreme/byotrack
 Author: Raphael Reme
@@ -28,7 +28,7 @@ Requires-Dist: platformdirs
 Requires-Dist: pylapy[scipy]
 Requires-Dist: tifffile[all]
 Requires-Dist: torch
-Requires-Dist: torch_tps
+Requires-Dist: torch-tps
 Requires-Dist: tqdm
 Provides-Extra: full
 Requires-Dist: matplotlib; extra == "full"

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

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

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

@@ -38,7 +38,7 @@ def _check_confidence(confidence: torch.Tensor) -> None:
 
 @numba.njit(parallel=False)
 def _position_from_segmentation(segmentation: np.ndarray) -> np.ndarray:
-    """Return the centre of each instance in the segmentation"""
+    """Return the center (mean) of each instance in the segmentation"""
     # A bit slower than previous version in 2D, but still fine
 
     n = segmentation.max()
@@ -57,6 +57,42 @@ def _position_from_segmentation(segmentation: np.ndarray) -> np.ndarray:
     return m_1.astype(np.float32) / m_0.reshape(-1, 1)
 
 
+@numba.njit(parallel=False)
+def _median_from_segmentation(segmentation: np.ndarray) -> np.ndarray:
+    """Return the center (median) of each instance in the segmentation"""
+
+    # Flatten space axes
+    flat_segmentation = segmentation.reshape(-1)
+
+    n = segmentation.max()
+    counts = np.zeros(n, dtype=np.uint)
+
+    for i in range(flat_segmentation.shape[0]):
+        instance = flat_segmentation[i] - 1
+        if instance != -1:
+            counts[instance] += 1
+
+    m = np.max(counts)
+
+    # Reset counts and allocate position
+    counts[:] = 0
+    positions = np.empty((n, m, len(segmentation.shape)), dtype=np.uint)
+
+    for index in np.ndindex(*segmentation.shape):
+        instance = segmentation[index] - 1
+        if instance != -1:
+            positions[instance, counts[instance]] = index
+            counts[instance] += 1
+
+    # Compute medians
+    median = np.zeros((n, len(segmentation.shape)), dtype=np.float32)
+    for instance in range(n):
+        for axis in range(len(segmentation.shape)):
+            median[instance, axis] = np.median(positions[instance, : counts[instance], axis])
+
+    return median
+
+
 @numba.njit
 def _bbox_from_segmentation(segmentation: np.ndarray) -> np.ndarray:
     # A bit slower than previous version in 2D, but still fine
@@ -242,12 +278,15 @@ class Detections:
             Shape: ([D, ]H, W), dtype: int32
         confidence (torch.Tensor): Confidence for each instance
             Shape: (N,), dtype: float32
+        use_median_position (bool): Use median instead of mean to compute positions from segmentation.
+            Default: True (Usually more robust)
 
     """
 
-    def __init__(self, data: Dict[str, torch.Tensor], frame_id: int = -1) -> None:
+    def __init__(self, data: Dict[str, torch.Tensor], frame_id: int = -1, use_median_position=True) -> None:
         self.length = -1
         self.dim = -1
+        self._use_median_position = use_median_position
 
         if "position" in data:
             _check_position(data["position"])
@@ -321,6 +360,20 @@ class Detections:
 
         return confidence
 
+    @property
+    def use_median_position(self) -> bool:
+        return self._use_median_position
+
+    @use_median_position.setter
+    def use_median_position(self, value: bool) -> None:
+        if value is self._use_median_position:
+            return
+
+        self._use_median_position = value
+
+        # Invalidate computed positions
+        self._lazy_extrapolated_data.pop("position")
+
     def _extrapolate_shape(self) -> Tuple[int, ...]:
         """Extrapolate shape from data
 
@@ -354,6 +407,8 @@ class Detections:
 
         """
         if "segmentation" in self.data:
+            if self.use_median_position:
+                return torch.tensor(_median_from_segmentation(self.data["segmentation"].numpy()))
             return torch.tensor(_position_from_segmentation(self.data["segmentation"].numpy()))
 
         return self.data["bbox"][:, : self.dim] + (self.data["bbox"][:, self.dim :] - 1) / 2

{byotrack-1.2.0.dev0 → byotrack-1.2.0.dev2}/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,67 @@ 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):
+        torch.tensor(compute_mass(detections.segmentation.numpy()), dtype=torch.float32)
+
+
+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_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
+
+    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.dev0 → byotrack-1.2.0.dev2}/byotrack/dataset/ctc.py

@@ -40,6 +40,8 @@ class GroundTruthDetector(byotrack.BatchDetector):
 
     """
 
+    progress_bar_description = "Detections (Load from CTC format)"
+
     def detect(self, batch: np.ndarray) -> List[byotrack.Detections]:
         assert batch.shape[-1] == 1, "Multichannel segmentation are not supported"
         assert np.issubdtype(batch.dtype, np.integer)
@@ -131,7 +133,7 @@ def load_tracks(  # pylint: disable=too-many-locals,too-many-branches,too-many-s
     segmentation_paths = path.glob("mask*.tif") if is_res else path.glob("man_*.tif")
     loader = byotrack.video.reader.FrameTiffLoader()
 
-    for path_ in tqdm.tqdm(byotrack.utils.sorted_alphanumeric(segmentation_paths)):
+    for path_ in tqdm.tqdm(byotrack.utils.sorted_alphanumeric(segmentation_paths), desc="Loading CTC tracks"):
         if is_res:
             frame_id = int(path_.stem[len("mask") :])
         elif "seg" in path.stem:
@@ -225,7 +227,7 @@ def save_detections(
 
     os.makedirs(path, exist_ok=True)
 
-    for frame_id, detections in enumerate(tqdm.tqdm(detections_sequence)):
+    for frame_id, detections in enumerate(tqdm.tqdm(detections_sequence, desc="Saving Detections to CTC")):
         segmentation = detections.segmentation.numpy().astype(np.uint16)
 
         if as_res:
@@ -472,7 +474,7 @@ def save_tracks(  # pylint: disable=too-many-branches,too-many-locals,too-many-s
     else:
         assert shape is not None, "Without detections_sequence, you need to provide the shape argument"
 
-    for frame_id in tqdm.trange(last + 1):
+    for frame_id in tqdm.trange(last + 1, desc="Saving tracks to CTC"):
         has_detections = len(detections_sequence) > frame_id
 
         disk_positions = []