Merge pull request #38 from funkelab/v0.2-dev

V0.2 dev

Author: cmalinmayor

finn/layers/tracks/_tests/test_tracks.py

@@ -9,23 +9,30 @@
     validate_kwargs_sorted,
 )
 
-# def test_empty_tracks():
-#     """Test instantiating Tracks layer without data."""
-#     pts = Tracks()
-#     assert pts.data.shape == (0, 4)
-
-
 data_array_2dt = np.zeros((1, 4))
 data_list_2dt = list(data_array_2dt)
 dataframe_2dt = pd.DataFrame(data=data_array_2dt, columns=["track_id", "t", "y", "x"])
 
 
+@pytest.mark.parametrize("ndim", [3, 4])
+def test_empty_tracks(ndim):
+    """Test instantiating Tracks layer without data."""
+    pts = Tracks(data=None, ndim=ndim)
+    assert pts.data.shape == (0, ndim + 1)
+
+
 @pytest.mark.parametrize("data", [data_array_2dt, data_list_2dt, dataframe_2dt])
 def test_tracks_layer_2dt_ndim(data):
     """Test instantiating Tracks layer, check 2D+t dimensionality."""
     layer = Tracks(data)
     assert layer.ndim == 3
 
+    layer = Tracks(data, ndim=3)
+    assert layer.ndim == 3
+
+    with pytest.raises(ValueError, match="Provided ndim 4 and data ndim 3 do not match."):
+        layer = Tracks(data, ndim=4)
+
 
 data_array_3dt = np.zeros((1, 5))
 data_list_3dt = list(data_array_3dt)
@@ -282,7 +289,8 @@ def test_track_connex_validity() -> None:
     # number of tracks
     n_tracks = 6
 
-    # the number of 'False' in the track_connex array should be equal to the number of tracks
+    # the number of 'False' in the track_connex array should be equal to the number
+    # of tracks
     assert np.sum(~layer._manager.track_connex) == n_tracks
 
 

finn/layers/tracks/_track_utils.py

@@ -1,7 +1,7 @@
 import numpy as np
 import numpy.typing as npt
 import pandas as pd
-from scipy.sparse import coo_matrix
+from scipy.sparse import coo_matrix, csr_matrix
 from scipy.spatial import cKDTree
 
 from finn.layers.utils.layer_utils import _FeatureTable
@@ -81,6 +81,8 @@ def __init__(self, data: np.ndarray) -> None:
     @staticmethod
     def _fast_points_lookup(sorted_time: np.ndarray) -> dict[int, slice]:
         """Computes a fast lookup table from time to their respective points slicing."""
+        if sorted_time.shape[0] == 0:
+            return {}
 
         # finds where t transitions to t + 1
         transitions = np.nonzero(sorted_time[:-1] - sorted_time[1:])[0] + 1
@@ -131,12 +133,16 @@ def data(self, data: list | np.ndarray) -> None:
 
         # make a second lookup table using a sparse matrix to convert track id
         # to the vertex indices
-        self._id2idxs = coo_matrix(
-            (
-                np.broadcast_to(1, self.track_ids.size),  # just dummy ones
-                (self.track_ids, np.arange(self.track_ids.size)),
-            )
-        ).tocsr()
+        if self.data.shape[0] == 0:
+            # make an empty csr matrix
+            self._id2idxs = csr_matrix(np.array([[]]))
+        else:
+            self._id2idxs = coo_matrix(
+                (
+                    np.broadcast_to(1, self.track_ids.size),  # just dummy ones
+                    (self.track_ids, np.arange(self.track_ids.size)),
+                )
+            ).tocsr()
 
     @property
     def features(self) -> pd.DataFrame:
@@ -279,7 +285,8 @@ def build_tracks(self) -> None:
         track_connex = np.ones(self.data.shape[0], dtype=bool)
         track_connex[indices_new_id] = False
         # Add 'False' for the last entry too (end of the last track)
-        track_connex[-1] = False
+        if self.data.shape[0] != 0:
+            track_connex[-1] = False
 
         self._points_id = points_id
         self._track_vertices = track_vertices

finn/layers/tracks/tracks.py

@@ -50,7 +50,7 @@ class Tracks(Layer):
         Optional dictionary mapping each property to a colormap for that
         property. This allows each property to be assigned a specific colormap,
         rather than having a global colormap for everything.
-    experimental_clipping_planes : list of dicts, list of ClippingPlane, or ClippingPlaneList
+    experimental_clipping_planes : list of dicts, list of ClippingPlane, ClippingPlaneList
         Each dict defines a clipping plane in 3D in data coordinates.
         Valid dictionary keys are {'position', 'normal', and 'enabled'}.
         Values on the negative side of the normal are discarded if the plane is enabled.
@@ -70,6 +70,9 @@ class Tracks(Layer):
         Layer metadata.
     name : str
         Name of the layer.
+    ndim : int, optional
+        The number of spatio-temporal dimensions of the tracks. Necessary if data is None
+        to initialize an empty tracks layer.
     opacity : float
         Opacity of the layer visual, between 0.0 and 1.0.
     projection_mode : str
@@ -123,6 +126,7 @@ def __init__(
         head_length: int = 0,
         metadata=None,
         name=None,
+        ndim=None,
         opacity=1.0,
         projection_mode="none",
         properties=None,
@@ -135,12 +139,20 @@ def __init__(
         units=None,
         visible=True,
     ) -> None:
+        if ndim is None and data is None:
+            raise ValueError("Must provide ndim or data to tracks layer")
+
         # if not provided with any data, set up an empty layer in 2D+t
         # otherwise convert the data to an np.ndarray
-        data = np.empty((0, 4)) if data is None else np.asarray(data)
+        data = np.empty((0, ndim + 1)) if data is None else np.asarray(data)
 
         # set the track data dimensions (remove ID from data)
-        ndim = data.shape[1] - 1
+        if ndim is None:
+            ndim = data.shape[1] - 1
+        elif ndim != data.shape[1] - 1:
+            raise ValueError(
+                f"Provided ndim {ndim} and data ndim {data.shape[1] - 1} do not match."
+            )
 
         super().__init__(
             data,
@@ -225,10 +237,10 @@ def _extent_data(self) -> np.ndarray:
         """
         if len(self.data) == 0:
             extrema = np.full((2, self.ndim), np.nan)
-        else:
-            maxs = np.max(self.data, axis=0)
-            mins = np.min(self.data, axis=0)
-            extrema = np.vstack([mins, maxs])
+            return extrema
+        maxs = np.max(self.data, axis=0)
+        mins = np.min(self.data, axis=0)
+        extrema = np.vstack([mins, maxs])
         return extrema[:, 1:]
 
     def _get_ndim(self) -> int:
@@ -247,6 +259,7 @@ def _get_state(self) -> dict[str, Any]:
         state.update(
             {
                 "data": self.data,
+                "ndim": self.ndim,
                 "properties": self.properties,
                 "graph": self.graph,
                 "color_by": self.color_by,
@@ -299,7 +312,11 @@ def _update_thumbnail(self) -> None:
         colormapped = np.zeros(self._thumbnail_shape)
         colormapped[..., 3] = 1
 
-        if self._view_data is not None and self.track_colors is not None:
+        if (
+            self._view_data is not None
+            and self.track_colors is not None
+            and self.data.shape[0] > 0
+        ):
             de = self._extent_data
             min_vals = [de[0, i] for i in self._slice_input.displayed]
             shape = np.ceil(
@@ -599,7 +616,8 @@ def _norm(p):
         else:
             # if we don't have a colormap, get one and scale the properties
             colormap = AVAILABLE_COLORMAPS[self.colormap]
-            vertex_properties = _norm(vertex_properties)
+            if vertex_properties.size > 0:
+                vertex_properties = _norm(vertex_properties)
 
         # actually set the vertex colors
         self._track_colors = colormap.map(vertex_properties)
@@ -648,7 +666,8 @@ def _check_color_by_in_features(self) -> None:
             warn(
                 (
                     trans._(
-                        "Previous color_by key {key!r} not present in features. Falling back to track_id",
+                        "Previous color_by key {key!r} not present in features. "
+                        "Falling back to track_id",
                         deferred=True,
                         key=self._color_by,
                     )

finn/track_application_menus/main_app.py

@@ -14,12 +14,12 @@ class MainApp(QWidget):
     def __init__(self, viewer: finn.Viewer):
         super().__init__()
 
-        menu_widget = MenuWidget(viewer)
+        self.menu_widget = MenuWidget(viewer)
         tree_widget = TreeWidget(viewer)
 
         viewer.window.add_dock_widget(tree_widget, area="bottom", name="Tree View")
 
         layout = QVBoxLayout()
-        layout.addWidget(menu_widget)
+        layout.addWidget(self.menu_widget)
 
         self.setLayout(layout)

finn/track_application_menus/menu_widget.py

@@ -18,16 +18,16 @@ def __init__(self, viewer: finn.Viewer):
         # motile_widget = MotileWidget(viewer)
         editing_widget = EditingMenu(viewer)
 
-        tabwidget = QTabWidget()
+        self.tabwidget = QTabWidget()
 
         # tabwidget.addTab(motile_widget, "Track with Motile")
-        tabwidget.addTab(tracks_viewer.tracks_list, "Tracks List")
-        tabwidget.addTab(editing_widget, "Edit Tracks")
+        self.tabwidget.addTab(tracks_viewer.tracks_list, "Tracks List")
+        self.tabwidget.addTab(editing_widget, "Edit Tracks")
 
         layout = QVBoxLayout()
-        layout.addWidget(tabwidget)
+        layout.addWidget(self.tabwidget)
 
-        self.setWidget(tabwidget)
+        self.setWidget(self.tabwidget)
         self.setWidgetResizable(True)
 
         self.setLayout(layout)

finn_builtins/_ndims_balls.py

@@ -0,0 +1,43 @@
+import numpy as np
+import pytest
+
+from finn_builtins.example_data import (
+    Fluo_N2DL_HeLa,
+    Fluo_N2DL_HeLa_crop,
+    Mouse_Embryo_Membrane,
+    delete_all,
+)
+
+
+@pytest.mark.slow
+def test_sample_data():
+    delete_all()
+    raw_layer_data, seg_layer_data = Mouse_Embryo_Membrane()
+    raw_data = raw_layer_data[0]
+    seg_data = seg_layer_data[0]
+    shape = (117, 123, 127, 127)
+    assert raw_data.shape == shape
+    assert seg_data.shape == shape
+    assert raw_data.dtype == np.uint16
+    assert seg_data.dtype == np.uint16
+
+
+@pytest.mark.slow
+@pytest.mark.parametrize(
+    ("ds_function", "img_shape", "point_shape"),
+    [
+        (Fluo_N2DL_HeLa, (92, 700, 1100), (8602, 3)),
+        (Fluo_N2DL_HeLa_crop, (92, 210, 340), (1266, 3)),
+    ],
+)
+def test_Fluo_N2DL_Hela(ds_function, img_shape, point_shape):
+    delete_all()
+    raw_layer_data, seg_layer_data, points_layer_data = ds_function()
+    raw_data = raw_layer_data[0]
+    seg_data = seg_layer_data[0]
+    points = points_layer_data[0]
+    assert raw_data.shape == img_shape
+    assert seg_data.shape == img_shape
+    assert raw_data.dtype == np.uint16
+    assert seg_data.dtype == np.uint16
+    assert points.shape == point_shape