Merge pull request #324 from funkelab/322-rendering-of-contour-labels-in-3d

322 rendering of contour labels in 3d

Author: cmalinmayor

src/motile_tracker/data_views/views/layers/track_labels.py

@@ -123,11 +123,7 @@ def __init__(
     # Connect click events to node selection
     def click(self, _, event):
         if (
-            event.type == "mouse_press"
-            and self.mode == "pan_zoom"
-            and not (
-                self.tracks_viewer.mode == "lineage" and self.viewer.dims.ndisplay == 3
-            )
+            event.type == "mouse_press" and self.mode == "pan_zoom"
         ):  # disable selecting in lineage mode in 3D
             # differentiate between click and drag
             was_click = yield from detect_click(event)
@@ -140,18 +136,37 @@ def assign_new_label(self, event):
 
         new_label(self)
 
-    def process_click(self, event: Event, label: int):
-        """Process the click event to update the selected nodes"""
+    def process_click(
+        self, event: Event, label: int, layer: ContourLabels | None = None
+    ):
+        """Process the click event to update the selected nodes.
 
-        if (
-            label is not None and label != 0 and self.colormap.map(label)[-1] != 0
-        ):  # check opacity (=visibility) in the colormap
-            append = "Shift" in event.modifiers
-            jump = "Control" in event.modifiers
-            if jump:
-                self.tracks_viewer.center_on_node(label)
+        Args:
+            event (Event): The click event.
+            label (int): The label value at the clicked position.
+            layer (ContourLabels | None): The (ortho view) layer from which the click originated.
+                If provided, it is used to check label visibility in that layer's colormap.
+        """
+
+        if label is not None and label != 0:
+            # check visibility in the respective colormap. If a label is not visible, it
+            # is not allowed to be selected from this view
+            if layer is not None:
+                is_visible = layer.colormap.color_dict.get(label)[3] > 0
+            else:
+                is_visible = self.colormap.color_dict.get(label)[3] > 0
+            if is_visible:
+                append = "Shift" in event.modifiers
+                jump = "Control" in event.modifiers
+                if jump:
+                    self.tracks_viewer.center_on_node(label)
+                else:
+                    self.tracks_viewer.selected_nodes.add(label, append)
             else:
-                self.tracks_viewer.selected_nodes.add(label, append)
+                warnings.warn(
+                    f"Node {label} is not visible in this view and cannot be selected.",
+                    stacklevel=2,
+                )
 
     def _get_colormap(self) -> DirectLabelColormap:
         """Get a DirectLabelColormap that maps node ids to their track ids, and then
@@ -315,7 +330,7 @@ def update_label_colormap(self, visible: list[int] | str) -> None:
 
         highlighted = set(self.tracks_viewer.selected_nodes)
         foreground = self.colormap.color_dict.keys() if visible == "all" else visible
-        background = (
+        self.background = (
             []
             if visible == "all"
             else self.colormap.color_dict.keys() - visible - highlighted
@@ -328,7 +343,13 @@ def update_label_colormap(self, visible: list[int] | str) -> None:
             if not self.foreground_contour:
                 self.filled_labels.extend(foreground)
 
-        self.set_opacity(background, self.background_opacity)
+        # special case: 3D rendering + partially filled contours -> set background opacity
+        # to 0
+        if self._slice.slice_input.ndisplay == 3 and self.contour > 0:
+            self.set_opacity(self.background, 0)
+        else:
+            # set normal background opacity
+            self.set_opacity(self.background, self.background_opacity)
         self.set_opacity(foreground, self.foreground_opacity)
         self.set_opacity(highlighted, self.highlight_opacity)
         self.refresh_colormap()

src/motile_tracker/data_views/views/layers/track_points.py

@@ -122,8 +122,20 @@ def add(self, coords: list[float]):
         with self.events.current_size.blocker():
             super().add(coords)
 
-    def process_click(self, event: Event, point_index: int | None):
-        """Select the clicked point(s)"""
+    def process_click(
+        self,
+        event: Event,
+        point_index: int | None,
+        _layer: napari.layers.Points | None = None,
+    ):
+        """Select the clicked point(s)
+
+        Args:
+            event (Event): The mouse event
+            point_index (int | None): The index of the clicked point, or None if no point
+                was clicked
+            _layer (napari.layers.Points | None): Optional, unused. The (ortho view) layer on which the click occurred, which is forwarded by default.
+        """
 
         if point_index is None:
             self.tracks_viewer.selected_nodes.reset()

src/motile_tracker/data_views/views/ortho_views.py

@@ -1,3 +1,4 @@
+import copy
 import inspect
 
 import napari_orthogonal_views.ortho_view_widget as ov_widget
@@ -100,13 +101,14 @@ def get_property_names_from_class(layer_cls):
         - {"mode", "size", "current_size"},
     },
     TrackLabels: {
+        "forward_exclude": {"colormap"},
         "reverse_exclude": set(get_property_names_from_class(Labels))
         - {
             "mode",
             "selected_label",
             "n_edit_dimensions",
             "brush_size",
-        }  # Let TrackLabels handle these properties on its own because it is listening to
+        },  # Let TrackLabels handle these properties on its own because it is listening to
         # them and we do not want to overwrite through reverse syncing.
     },
 }
@@ -217,6 +219,40 @@ def paint_wrapper(event: Event):
     copied_layer.events.paint.connect(paint_wrapper)
 
 
+def colormap_hook(orig_layer: TrackLabels, copied_layer: Labels) -> None:
+    """Hook to sync colormap changes from the original TrackLabels layer to the copied
+    layers. We need a hook for the special case in which one of the views is showing a 3D
+     rendering in combination with partially filled contour labels. Since contours are not
+     rendered in 3D, we want to display the non-filled labels with full opacity instead.
+
+    Args:
+        orig_layer (TrackLabels): TracksLabels layer from which the copied layer is
+            derived.
+        copied_layer (ContourLabels): ContourLabels equivalent of the TracksLabels layer.
+    """
+
+    def sync_colormap(orig_layer: TrackLabels, copied_layer: Labels, event: Event):
+        """Sync the colormap from the original TrackLabels instance to the copied
+        ContourLabels instance. Check the slice ndisplay and contour settings to adjust
+        background opacity accordingly."""
+
+        copied_layer.colormap = copy.deepcopy(orig_layer.colormap)
+        if copied_layer._slice.slice_input.ndisplay == 3 and orig_layer.contour > 0:
+            copied_layer.set_opacity(orig_layer.background, 0)
+        else:
+            copied_layer.set_opacity(
+                orig_layer.background, orig_layer.background_opacity
+            )
+        copied_layer.refresh_colormap()
+
+    def update_colormap_wrapper(event: Event):
+        """Wrap paint event and send to original layer."""
+
+        return sync_colormap(orig_layer, copied_layer, event)
+
+    orig_layer.events.colormap.connect(update_colormap_wrapper)
+
+
 def track_layers_hook(
     orig_layer: TrackLabels | TrackPoints, copied_layer: Labels | Points
 ) -> None:
@@ -239,7 +275,7 @@ def click(
             was_click = yield from detect_click(event)
             if was_click:
                 value = get_click_value(layer, event)
-                orig_layer.process_click(event, value)
+                orig_layer.process_click(event, value, layer)
 
     # Wrap and attach click callback
     def click_wrapper(layer, event):
@@ -265,6 +301,7 @@ def initialize_ortho_views(viewer: Viewer) -> OrthoViewManager:
     orth_view_manager.register_layer_hook((TrackLabels, TrackPoints), track_layers_hook)
     orth_view_manager.register_layer_hook((TrackLabels), paint_event_hook)
     orth_view_manager.register_layer_hook((TrackPoints), point_data_hook)
+    orth_view_manager.register_layer_hook((TrackLabels), colormap_hook)
     orth_view_manager.set_sync_filters(sync_filters)
     orth_view_manager.activate_checkboxes = True