motile-tracker 3.1.1.dev0__tar.gz → 3.1.2.dev0__tar.gz

{motile_tracker-3.1.1.dev0 → motile_tracker-3.1.2.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: motile-tracker
-Version: 3.1.1.dev0
+Version: 3.1.2.dev0
 Summary: Application for interactive tracking with global optimization
 Author-email: Caroline Malin-Mayor <malinmayorc@janelia.hhmi.org>
 License: BSD 3-Clause License
@@ -31,6 +31,8 @@ Requires-Dist: motile>=0.3
 Requires-Dist: motile_toolbox==0.4.0
 Requires-Dist: pydantic
 Requires-Dist: tifffile[all]
+Requires-Dist: tqdm
+Requires-Dist: dask[array]>=2021.10.0
 Requires-Dist: fonticon-fontawesome6
 Requires-Dist: pyqtgraph
 Requires-Dist: lxml_html_clean

{motile_tracker-3.1.1.dev0 → motile_tracker-3.1.2.dev0}/docs/source/getting_started.rst

@@ -74,7 +74,16 @@ is incorporating the detection and linking corrections into the optimization tas
 Each ``Tracking Run`` will be stored in the ``Results List`` widget.
 These are the runs that are stored in memory - if you run tracking multiple
 times with different inputs or parameters, you can click back and forth
-between the results here. Here you can also save any runs that you want to store for later.
+between the results here. Here you can also save any runs that you want to store for later,
+or export the tracks to a csv file. If your input was a Labels layer, the
+``node_id`` will be determined by segmentation label id. If your original segmentation
+repeated labels across time, the application will relabel them all to be unique, and
+the new label id will be used as the node id.
+If your input was a Points layer, the ``node_id`` is simply the index of the
+node in the list of points.
+Note: This does not save the output segmentation. If you want to save
+the relabeled segmentation, you can do so through napari by selecting the
+layer and then selecting ``File``-> ``Save selected layers``
 Deleting runs you do not want to keep viewing is a good idea, since these are stored in memory.
 Runs that were saved in previous sessions do not appear here until you load them from disk with the ``Load Tracks`` button.
 The tracking results can also be visualized as a lineage tree.

{motile_tracker-3.1.1.dev0 → motile_tracker-3.1.2.dev0}/docs/source/motile.rst

@@ -47,19 +47,6 @@ The ``Run Viewer`` contains the following information:
 - The ``Graph of solver gap``, which is mostly for debugging purposes.
   The solver gap is an optimization value that should decrease at each iteration.
 - The run settings, including ``Hyperparameters``, ``Costs``, and ``Attribute weights``.
-- The ``Save run`` button. This button will take you to a file dialog to save the
-  whole run, so that if you close napari and re-open it, you can load the run
-  and see the results.
-- The ``Export tracks to CSV`` button, which will take you to a file dialog for saving
-  a csv file containing the tracks. If your input was a Labels layer, the
-  ``node_id`` will be determined by segmentation label id. If your original segmentation
-  repeated labels across time, the application will relabel them all to be unique, and
-  the new label id will be used as the node id.
-  If your input was a Points layer, the ``node_id`` is simply the index of the
-  node in the list of points.
-    - Note: This does not save the output segmentation. If you want to save
-    the relabeled segmentation, you can do so through napari by selecting the
-    layer and then selecting ``File``-> ``Save selected layers``
 - The ``Back to editing`` button, which will return you to the ``Run Editor`` in its
   previous state.
 - The ``Edit this run`` button. This button will take you back to the ``Run Editor``,

{motile_tracker-3.1.1.dev0 → motile_tracker-3.1.2.dev0}/pyproject.toml

@@ -38,6 +38,8 @@ dependencies =[
     "motile_toolbox == 0.4.0",
     "pydantic",
     "tifffile[all]",
+    "tqdm",
+    "dask[array]>=2021.10.0",
     "fonticon-fontawesome6",
     "pyqtgraph",
     "lxml_html_clean",  # only to deal with napari dependencies being broken

{motile_tracker-3.1.1.dev0 → motile_tracker-3.1.2.dev0}/src/motile_tracker/application_menus/menu_widget.py

@@ -25,6 +25,7 @@ class MenuWidget(QScrollArea):
         tabwidget.addTab(motile_widget, "Track with Motile")
         tabwidget.addTab(editing_widget, "Edit Tracks")
         tabwidget.addTab(tracks_viewer.tracks_list, "Results List")
+        tabwidget.addTab(tracks_viewer.collection_widget, "Collections")
 
         layout = QVBoxLayout()
         layout.addWidget(tabwidget)

motile_tracker-3.1.2.dev0/src/motile_tracker/data_views/views/layers/contour_labels.py

@@ -0,0 +1,121 @@
+from __future__ import annotations
+
+import functools
+from typing import Optional
+
+import napari
+import numpy as np
+from napari.layers.labels._labels_utils import (
+    expand_slice,
+)
+from napari.utils import DirectLabelColormap
+from scipy import ndimage as ndi
+
+
+def get_contours(
+    labels: np.ndarray,
+    thickness: int,
+    background_label: int,
+    group_labels: list[int] | None = None,
+):
+    """Computes the contours of a 2D label image.
+
+    Parameters
+    ----------
+    labels : array of integers
+        An input labels image.
+    thickness : int
+        It controls the thickness of the inner boundaries. The outside thickness is always 1.
+        The final thickness of the contours will be `thickness + 1`.
+    background_label : int
+        That label is used to fill everything outside the boundaries.
+
+    Returns
+    -------
+    A new label image in which only the boundaries of the input image are kept.
+    """
+    struct_elem = ndi.generate_binary_structure(labels.ndim, 1)
+
+    thick_struct_elem = ndi.iterate_structure(struct_elem, thickness).astype(bool)
+
+    dilated_labels = ndi.grey_dilation(labels, footprint=struct_elem)
+    eroded_labels = ndi.grey_erosion(labels, footprint=thick_struct_elem)
+    not_boundaries = dilated_labels == eroded_labels
+
+    contours = labels.copy()
+    contours[not_boundaries] = background_label
+
+    # instead of filling with background label, fill the group label with their normal color
+    if group_labels is not None and len(group_labels) > 0:
+        group_mask = functools.reduce(
+            np.logical_or, (labels == val for val in group_labels)
+        )
+        combined_mask = not_boundaries & group_mask
+        contours = np.where(combined_mask, labels, contours)
+
+    return contours
+
+
+class ContourLabels(napari.layers.Labels):
+    """Extended labels layer that allows to show contours and filled labels simultaneously"""
+
+    @property
+    def _type_string(self) -> str:
+        return "labels"  # to make sure that the layer is treated as labels layer for saving
+
+    def __init__(
+        self,
+        data: np.array,
+        name: str,
+        opacity: float,
+        scale: tuple,
+        colormap: DirectLabelColormap,
+    ):
+        super().__init__(
+            data=data,
+            name=name,
+            opacity=opacity,
+            scale=scale,
+            colormap=colormap,
+        )
+
+        self.group_labels = None
+
+    def _calculate_contour(
+        self, labels: np.ndarray, data_slice: tuple[slice, ...]
+    ) -> Optional[np.ndarray]:
+        """Calculate the contour of a given label array within the specified data slice.
+
+        Parameters
+        ----------
+        labels : np.ndarray
+            The label array.
+        data_slice : Tuple[slice, ...]
+            The slice of the label array on which to calculate the contour.
+
+        Returns
+        -------
+        Optional[np.ndarray]
+            The calculated contour as a boolean mask array.
+            Returns None if the contour parameter is less than 1,
+            or if the label array has more than 2 dimensions.
+        """
+        if self.contour < 1:
+            return None
+        if labels.ndim > 2:
+            return None
+
+        expanded_slice = expand_slice(data_slice, labels.shape, 1)
+        sliced_labels = get_contours(
+            labels[expanded_slice],
+            self.contour,
+            self.colormap.background_value,
+            self.group_labels,
+        )
+
+        # Remove the latest one-pixel border from the result
+        delta_slice = tuple(
+            slice(s1.start - s2.start, s1.stop - s2.start)
+            for s1, s2 in zip(data_slice, expanded_slice, strict=False)
+        )
+        return sliced_labels[delta_slice]

{motile_tracker-3.1.1.dev0 → motile_tracker-3.1.2.dev0}/src/motile_tracker/data_views/views/layers/track_labels.py

@@ -18,6 +18,8 @@ if TYPE_CHECKING:
 
 from motile_toolbox.candidate_graph.graph_attributes import NodeAttr
 
+from motile_tracker.data_views.views.layers.contour_labels import ContourLabels
+
 
 def new_label(layer: TrackLabels):
     """A function to override the default napari labels new_label function.
@@ -67,7 +69,7 @@ def _new_label(layer: TrackLabels, new_track_id=True):
         )
 
 
-class TrackLabels(napari.layers.Labels):
+class TrackLabels(ContourLabels):
     """Extended labels layer that holds the track information and emits
     and responds to dynamics visualization signals"""
 
@@ -97,6 +99,10 @@ class TrackLabels(napari.layers.Labels):
         )
 
         self.viewer = viewer
+        self.viewer.dims.events.ndisplay.connect(
+            lambda: self.update_label_colormap(visible=None)
+        )
+        self.group_labels = None
 
         # Key bindings (should be specified both on the viewer (in tracks_viewer)
         # and on the layer to overwrite napari defaults)
@@ -322,8 +328,22 @@ class TrackLabels(napari.layers.Labels):
         with self.events.selected_label.blocker():
             highlighted = self.tracks_viewer.selected_nodes
 
+            if visible is None:
+                visible = self.group_labels if self.group_labels is not None else "all"
+
+            # update the opacity of the cyclic label colormap values according to whether nodes are visible/invisible/highlighted
+            self.colormap.color_dict = {
+                key: np.array(
+                    [*value[:-1], 0.6 if key is not None and key != 0 else value[-1]],
+                    dtype=np.float32,
+                )
+                for key, value in self.colormap.color_dict.items()
+            }
+
             # update the opacity of the cyclic label colormap values according to whether nodes are visible/invisible/highlighted
             if visible == "all":
+                self.contour = 0
+                self.group_labels = None
                 self.colormap.color_dict = {
                     key: np.array(
                         [
@@ -336,13 +356,17 @@ class TrackLabels(napari.layers.Labels):
                 }
 
             else:
-                self.colormap.color_dict = {
-                    key: np.array([*value[:-1], 0], dtype=np.float32)
-                    for key, value in self.colormap.color_dict.items()
-                }
-                for node in visible:
-                    # find the index in the colormap
-                    self.colormap.color_dict[node][-1] = 0.6
+                if self.viewer.dims.ndisplay == 2:
+                    self.contour = 1
+                    self.group_labels = visible
+                else:
+                    self.colormap.color_dict = {
+                        key: np.array([*value[:-1], 0], dtype=np.float32)
+                        for key, value in self.colormap.color_dict.items()
+                    }
+                    for node in visible:
+                        # find the index in the colormap
+                        self.colormap.color_dict[node][-1] = 0.6
 
             for node in highlighted:
                 self.colormap.color_dict[node][-1] = 1  # full opacity
@@ -350,6 +374,7 @@ class TrackLabels(napari.layers.Labels):
             self.colormap = DirectLabelColormap(
                 color_dict=self.colormap.color_dict
             )  # create a new colormap from the updated colors (otherwise it does not refresh)
+            self.refresh()
 
     def new_colormap(self):
         """Override existing function to generate new colormap on tracks_viewer and