Merge pull request #457 from jo-mueller/connect-napari-selection-with-clusters-plotter

Connect napari selection with clusters plotter

Author: jo-mueller

src/napari_clusters_plotter/_new_plotter_widget.py

@@ -21,6 +21,11 @@
 from qtpy.QtWidgets import QComboBox, QVBoxLayout, QWidget
 
 from ._algorithm_widget import BaseWidget
+from ._utilities import (
+    _get_selected_objects,
+    _get_selection_event,
+    _is_selectable_layer,
+)
 
 
 class PlottingType(Enum):
@@ -565,6 +570,31 @@ def _on_update_layer_selection(
                     f"Layer {layer.name} does not have events.features or events.properties"
                 )
 
+            # connect selection event
+            if _is_selectable_layer(layer):
+                selection_event = _get_selection_event(layer)
+                selection_event.connect(self._update_selected_object_feature)
+
+    def _update_selected_object_feature(self) -> None:
+        """
+        Get the selected object from the layer and updates the entry in MANUAL_CLUSTER_ID
+        """
+        # do nothing if more than one layer is selected
+        if len(self.layers) > 1:
+            return
+        layer = self.layers[0]
+        selected_data = _get_selected_objects(layer)
+        cluster = np.zeros(len(layer.features), dtype=np.uint64)
+        cluster[list(selected_data)] = 1
+
+        if np.all(cluster == 0):
+            return
+
+        # get copy of features table, modify and overwrite to trigger draw event
+        features_table = layer.features
+        features_table["SELECTED_LAYER_CLUSTER_ID"] = pd.Categorical(cluster)
+        layer.features = features_table
+
     def _clean_up(self):
         """In case of empty layer selection"""
 
@@ -777,7 +807,9 @@ def _set_layer_color(self, layer, colors):
             # Ensure the first color is transparent for the background
             colors = np.insert(colors, 0, [0, 0, 0, 0], axis=0)
             color_dict = dict(zip(_get_unique_values(layer), colors))
+            layer.events.selected_label.block()
             layer.colormap = DirectLabelColormap(color_dict=color_dict)
+            layer.events.selected_label.unblock()
         layer.refresh()
 
     def _reset(self):

src/napari_clusters_plotter/_tests/test_plotter.py

@@ -749,3 +749,48 @@ def test_cluster_visibility_toggle(make_napari_viewer, create_sample_layers):
     plotter_widget._on_show_plot_overlay(state=False)
     plotter_widget._on_show_plot_overlay(state=True)
     plotter_widget._on_show_plot_overlay(state=False)
+
+
+@pytest.mark.parametrize(
+    "create_sample_layers",
+    [create_multi_point_layer, create_multi_labels_layer],
+)
+def test_selected_data_point_layer(make_napari_viewer, create_sample_layers):
+    from napari_clusters_plotter import PlotterWidget
+    from napari_clusters_plotter._utilities import _get_selection_event
+
+    viewer = make_napari_viewer()
+    _, layer2 = create_sample_layers()
+
+    # add layers to viewer
+    viewer.add_layer(layer2)
+    plotter_widget = PlotterWidget(viewer)
+    viewer.window.add_dock_widget(plotter_widget, area="right")
+
+    # select last layer and create a random selection on the layer
+    viewer.layers.selection.active = layer2
+
+    event = _get_selection_event(layer2)
+    if isinstance(layer2, Points):
+        selection = [1, 2]
+        layer2.selected_data = selection
+        event.emit()
+    elif isinstance(layer2, Labels):
+        selection = 1
+        layer2.selected_label = selection
+        event()
+
+    assert "SELECTED_LAYER_CLUSTER_ID" in layer2.features.columns
+
+    # use SELECTED_DATA_LAYER_CLUSTER_ID as hue for layer2
+    viewer.layers.selection.active = layer2
+    plotter_widget._selectors["hue"].setCurrentText(
+        "SELECTED_LAYER_CLUSTER_ID"
+    )
+
+    assert np.array_equal(
+        np.argwhere(
+            plotter_widget.plotting_widget.active_artist.color_indices
+        ).flatten(),
+        np.asarray([selection]).flatten(),
+    )

src/napari_clusters_plotter/_utilities.py

@@ -1,8 +1,15 @@
-from typing import Union
+from typing import List, Union
 
 import dask.array as da
 import numpy as np
-from napari.layers import Image, Labels
+from napari.layers import Image, Labels, Layer, Points, Shapes
+from napari.utils.events import Event
+
+_selectable_layers = [
+    Labels,
+    Points,
+    # TODO: Shapes support is planned for future implementation; currently excluded from selectable layers due to incomplete support.
+]
 
 
 def _get_unique_values(layer: Union[Image, Labels]) -> np.ndarray:
@@ -29,3 +36,45 @@ def _get_unique_values(layer: Union[Image, Labels]) -> np.ndarray:
         unique_values = da.unique(data).compute()
 
     return unique_values
+
+
+def _is_selectable_layer(layer: Layer) -> bool:
+    """
+    Check if the layer is selectable.
+    """
+    if type(layer) in _selectable_layers:
+        return True
+    return False
+
+
+def _get_selected_objects(layer: Layer) -> List[int]:
+    """
+    Retrieve id of selected object on napari canvas
+    """
+    if not _is_selectable_layer(layer):
+        raise TypeError(
+            f"Layer type {type(layer)} is not supported for selection."
+        )
+
+    if isinstance(layer, Points):
+        return list(layer.selected_data)
+    elif isinstance(layer, Labels):
+        return [layer.selected_label]
+    elif isinstance(layer, Shapes):
+        return list(layer.selected_data)
+
+
+def _get_selection_event(layer: Layer) -> Event:
+    """
+    Get the selection event for the layer.
+    """
+    if not _is_selectable_layer(layer):
+        raise TypeError(
+            f"Layer type {type(layer)} is not supported for selection events."
+        )
+    if isinstance(layer, Points):
+        return layer.selected_data.events.items_changed
+    elif isinstance(layer, Labels):
+        return layer.events.selected_label
+    elif isinstance(layer, Shapes):
+        return layer.events.highlight