Working slicer

Author: dstansby

src/napari_matplotlib/base.py

@@ -1,5 +1,8 @@
 import napari
-from matplotlib.backends.backend_qt5agg import FigureCanvas, NavigationToolbar2QT
+from matplotlib.backends.backend_qt5agg import (
+    FigureCanvas,
+    NavigationToolbar2QT,
+)
 from matplotlib.figure import Figure
 from qtpy.QtWidgets import QVBoxLayout, QWidget
 
@@ -45,3 +48,36 @@ def current_z(self) -> int:
         Current z-step of the viewer.
         """
         return self.viewer.dims.current_step[0]
+
+
+class SingleLayerWidget(NapariMPLWidget):
+    """
+    Widget that takes a single napari layer as input.
+
+    This handles:
+
+    - updating the ``layer`` attribute when the selected layer is changed in
+      the napari viewer
+    - calling the ``draw()`` method when the current step is changed in the
+      napari viewer
+
+    Attributes
+    ----------
+    layer : `napari.layers.Layer`
+        Currently selected layer.
+    """
+
+    def __init__(self, napari_viewer: napari.viewer.Viewer):
+        super().__init__(napari_viewer)
+        self.layer = self.viewer.layers[-1]
+        self.viewer.layers.selection.events.active.connect(self.update_layer)
+        self.viewer.dims.events.current_step.connect(self.draw)
+
+    def update_layer(self, event: napari.utils.events.Event) -> None:
+        """
+        Update the currently selected layer.
+        """
+        # Update current layer when selection changed in viewer
+        if event.value:
+            self.layer = event.value
+            self.draw()

src/napari_matplotlib/histogram.py

@@ -1,15 +1,15 @@
 import napari
 import numpy as np
 
-from .base import NapariMPLWidget
+from .base import SingleLayerWidget
 
 __all__ = ["HistogramWidget"]
 
 
 _COLORS = {"r": "tab:red", "g": "tab:green", "b": "tab:blue"}
 
 
-class HistogramWidget(NapariMPLWidget):
+class HistogramWidget(SingleLayerWidget):
     """
     Widget to display a histogram of the currently selected layer.
 
@@ -21,23 +21,9 @@ class HistogramWidget(NapariMPLWidget):
 
     def __init__(self, napari_viewer: napari.viewer.Viewer):
         super().__init__(napari_viewer)
-        self.layer = self.viewer.layers[-1]
+        self.draw()
 
-        self.viewer.dims.events.current_step.connect(self.hist_current_layer)
-        self.viewer.layers.selection.events.active.connect(self.update_layer)
-
-        self.hist_current_layer()
-
-    def update_layer(self, event: napari.utils.events.Event) -> None:
-        """
-        Update the currently selected layer.
-        """
-        # Update current layer when selection changed in viewer
-        if event.value:
-            self.layer = event.value
-            self.hist_current_layer()
-
-    def hist_current_layer(self) -> None:
+    def draw(self) -> None:
         """
         Clear the axes and histogram the currently selected layer/slice.
         """

src/napari_matplotlib/slice.py

@@ -1,39 +1,94 @@
+from typing import Dict
+
 import napari
+import numpy as np
 from qtpy.QtWidgets import QComboBox, QHBoxLayout, QSpinBox
 
-from napari_matplotlib.base import NapariMPLWidget
+from napari_matplotlib.base import SingleLayerWidget
 
 __all__ = ["SliceWidget"]
 
 _dims = ["x", "y", "z"]
 
 
-class SliceWidget(NapariMPLWidget):
+class SliceWidget(SingleLayerWidget):
+    """
+    Plot a 1D slice along a given dimension.
+    """
+
     def __init__(self, napari_viewer: napari.viewer.Viewer):
         super().__init__(napari_viewer)
 
-        self.layer = self.viewer.layers[-1]
-
         button_layout = QHBoxLayout()
         self.layout().addLayout(button_layout)
 
         self.dim_selector = QComboBox()
         button_layout.addWidget(self.dim_selector)
+        self.dim_selector.addItems(_dims)
 
-        self.selectors = {}
+        self.slice_selectors = {}
         for d in _dims:
-            self.selectors[d] = QSpinBox()
-            button_layout.addWidget(self.selectors[d])
+            self.slice_selectors[d] = QSpinBox()
+            button_layout.addWidget(self.slice_selectors[d])
+
+        self.update_slice_selectors()
+        self.viewer.dims.events.current_step.connect(self.draw)
+
+        self.draw()
+
+    @property
+    def current_dim(self) -> str:
+        """
+        Currently selected slice dimension.
+        """
+        return self.dim_selector.currentText()
+
+    @property
+    def current_dim_index(self) -> int:
+        """
+        Currently selected slice dimension index.
+        """
+        # Note the reversed list because in napari the z-axis is the first
+        # numpy axis
+        return _dims[::-1].index(self.current_dim)
 
-        self.update_dim_selector()
-        self.viewer.layers.selection.events.changed.connect(
-            self.update_dim_selector
-        )
+    @property
+    def selector_values(self) -> Dict[str, int]:
+        return {d: self.slice_selectors[d].value() for d in _dims}
 
-    def update_dim_selector(self) -> None:
+    def update_slice_selectors(self) -> None:
         """
-        Update options in the dimension selector from currently selected layer.
+        Update range and enabled status of the slice selectors, and the value
+        of the z slice selector.
         """
-        dims = ["x", "y", "z"]
-        self.dim_selector.clear()
-        self.dim_selector.addItems(dims[0 : self.layer.data.ndim])
+        # Update min/max
+        for i, dim in enumerate(_dims):
+            self.slice_selectors[dim].setRange(0, self.layer.data.shape[i])
+
+        # The z dimension is always set by current z in the viewer
+        self.slice_selectors["z"].setValue(self.current_z)
+        self.slice_selectors[self.current_dim].setEnabled(False)
+
+    def draw(self) -> None:
+        self.update_slice_selectors()
+        self.axes.clear()
+        x = np.arange(self.layer.data.shape[self.current_dim_index])
+
+        slices = []
+        for d in _dims:
+            if d == self.current_dim:
+                # Select all data along this axis
+                slices.append(slice(None))
+            else:
+                # Select specific index
+                val = self.selector_values[d]
+                slices.append(slice(val, val + 1))
+
+        slices = slices[::-1]
+        y = self.layer.data[tuple(slices)].ravel()
+
+        self.axes.plot(x, y)
+        self.axes.set_xlabel(self.current_dim)
+        self.axes.set_title(self.layer.name)
+
+        self.canvas.draw()