[WIP] 1D PlotWidget

examples/colocalization.py

@@ -0,0 +1,30 @@
+import numpy as np
+from skimage import data
+from skimage.color import rgb2hed
+from scipy.stats import linregress
+
+
+import napari
+
+ihc_rgb = data.immunohistochemistry()
+ihc_hed = rgb2hed(ihc_rgb)
+
+with napari.gui_qt():
+    viewer = napari.Viewer()
+    viewer.add_image(ihc_hed[..., ::2], channel_axis=-1)
+    # add a docked figure
+    fig, dw = viewer.window.add_docked_figure()
+    # get a handle to the plotWidget
+    ax = fig[0, 0]
+
+    # calculate some data
+    x, y = ihc_hed[..., 0].ravel(), ihc_hed[..., 2].ravel()
+    data = np.array((x, y)).T
+    slope, intercept, r_value, p_value, std_err = linregress(x, y)
+    linex = np.linspace(x.min(), x.max(), 200)
+    liney = slope * linex + intercept
+
+    # plot the scatter plot and line
+    ax.plot((linex, liney), color='g', marker_size=0, width=2)
+    ax.scatter(data, size=2, edge_width=0, face_color='m')
+    viewer.window._qt_window.setGeometry(400, 100, 800, 900)

examples/mouse_drag_callback_lineprofile.py

@@ -0,0 +1,53 @@
+"""
+Example updating the status bar with line profile info while dragging
+lines around in a shapes layer.
+"""
+
+from skimage import data
+from skimage import measure
+import numpy as np
+import napari
+from napari._vispy import Fig
+
+
+def get_line_data(image, start, end):
+    return measure.profile_line(image, start, end)
+
+
+with napari.gui_qt():
+    np.random.seed(1)
+    viewer = napari.Viewer()
+    chelsea = data.chelsea().mean(-1)
+    viewer.add_image(chelsea)
+    shapes_layer = viewer.add_shapes(
+        [np.array([[11, 13], [250, 313]]), np.array([[100, 10], [10, 345]])],
+        shape_type='line',
+        edge_width=5,
+        edge_color='coral',
+        face_color='royalblue',
+    )
+    shapes_layer.mode = 'select'
+
+    # add the figure as a dock_widget
+    fig, dw = viewer.window.add_docked_figure(area='right', initial_width=250)
+    # add a new subplot to the figure for each line in the shapes layer
+    lines = [
+        fig[i, 0].plot(get_line_data(chelsea, *line), marker_size=0)
+        for i, line in enumerate(shapes_layer.data)
+    ]
+
+    # hook the lines up to events
+    def profile_lines(image, shape_layer):
+        # only a single line for this example
+        for i, line in enumerate(shape_layer.data):
+            if i in shape_layer._selected_data:
+                lines[i].set_data(get_line_data(image, *line))
+                fig[i, 0].autoscale()
+
+    @shapes_layer.mouse_drag_callbacks.append
+    def profile_lines_drag(layer, event):
+        profile_lines(chelsea, layer)
+        yield
+        while event.type == 'mouse_move':
+            profile_lines(chelsea, layer)
+            yield

examples/vispy_dock.py

@@ -0,0 +1,51 @@
+"""
+An example of a rendering bug using QDockWidgets
+"""
+
+import sys
+import numpy as np
+
+from vispy import scene, plot
+
+from qtpy.QtCore import Qt, QSize
+from qtpy import QtWidgets
+
+
+class QtPlotWidget(QtWidgets.QWidget):
+    def __init__(self):
+        super().__init__()
+        self.canvas = scene.SceneCanvas(bgcolor='k', keys=None, vsync=True)
+        self.canvas.native.setMinimumSize(QSize(300, 100))
+        self.setLayout(QtWidgets.QHBoxLayout())
+        self.layout().addWidget(self.canvas.native)
+        _ = scene.visuals.Line(
+            pos=np.array([[0, 0], [700, 500]]),
+            color='w',
+            parent=self.canvas.scene,
+        )
+
+        # self.plot = self.canvas.central_widget.add_widget(
+        #     plot.PlotWidget(fg_color='w')
+        # )
+        # self.plot.histogram(np.random.randn(10000), bins=100, color='b')
+        # the histogram is just an example, but the axes alone are sufficient:
+        # self.plot._configure_2d()
+
+
+class MainWindow(QtWidgets.QMainWindow):
+    def __init__(self):
+        super().__init__()
+        self.resize(700, 500)
+        dock_widget = QtWidgets.QDockWidget(self)
+        self.plot = QtPlotWidget()
+        dock_widget.setWidget(self.plot)
+        self.addDockWidget(Qt.BottomDockWidgetArea, dock_widget)
+
+
+if __name__ == '__main__':
+    # import vispy
+    # print(vispy.sys_info())
+    appQt = QtWidgets.QApplication(sys.argv)
+    win = MainWindow()
+    win.show()
+    appQt.exec_()

napari/_qt/qt_main_window.py

@@ -185,6 +185,8 @@ def add_dock_widget(
         area: str = 'bottom',
         allowed_areas=None,
         shortcut=None,
+        initial_width=None,
+        initial_height=None,
     ):
         """Convenience method to add a QDockWidget to the main window
 
@@ -203,13 +205,28 @@ def add_dock_widget(
             By default, all areas are allowed.
         shortcut : str, optional
             Keyboard shortcut to appear in dropdown menu.
+        initial_width : int, optional
+            Initial width for the docket widget.
+        initial_height : int, optional
+            Initial height for the docket widget.
 
         Returns
         -------
         dock_widget : QtViewerDockWidget
             `dock_widget` that can pass viewer events.
         """
 
+        if not isinstance(widget, QWidget):
+            if hasattr(widget, 'native') and isinstance(
+                widget.native, QWidget
+            ):
+                widget = widget.native
+            else:
+                raise TypeError(
+                    "widget must be a QWidget or vispy widget."
+                    f" Got: {type(widget)}"
+                )
+
         dock_widget = QtViewerDockWidget(
             self.qt_viewer,
             widget,
@@ -218,9 +235,25 @@ def add_dock_widget(
             allowed_areas=allowed_areas,
             shortcut=shortcut,
         )
+
         self._add_viewer_dock_widget(dock_widget)
+        if initial_width:
+            self._qt_window.resizeDocks(
+                [dock_widget], [initial_width], Qt.Horizontal
+            )
+        if initial_height:
+            self._qt_window.resizeDocks(
+                [dock_widget], [initial_height], Qt.Vertical
+            )
         return dock_widget
 
+    def add_docked_figure(self, **kwargs):
+        from .._vispy import Fig
+
+        fig = Fig()
+        dw = self.add_dock_widget(fig, **kwargs)
+        return fig, dw
+
     def _add_viewer_dock_widget(self, dock_widget: QtViewerDockWidget):
         """Add a QtViewerDockWidget to the main window
 

napari/_vispy/__init__.py

@@ -1 +1,3 @@
 from .utils import create_vispy_visual
+from .vispy_plot import PlotWidget
+from .vispy_figure import Fig

napari/_vispy/cameras.py

@@ -0,0 +1,30 @@
+from vispy.scene.cameras import PanZoomCamera
+import numpy as np
+
+
+class PanZoom1DCamera(PanZoomCamera):
+    def __init__(self, axis=1, *args, **kwargs):
+        """A camera that can only Pan/Zoom along one axis.
+
+        Useful in a PlotWidget.
+
+        Parameters
+        ----------
+        axis : int, optional
+            The axis to constrain. (This axis will NOT pan or zoom).
+                0 => lock x axis
+                1 => lock y axis
+                by default 1
+        """
+        self.axis = axis
+        super().__init__(*args, **kwargs)
+
+    def zoom(self, factor, center=None):
+        if np.isscalar(factor):
+            factor = [factor, factor]
+        factor[self.axis] = 1
+        return super().zoom(factor, center=center)
+
+    def pan(self, pan):
+        pan[self.axis] = 0
+        self.rect = self.rect + pan

napari/_vispy/vispy_figure.py

@@ -0,0 +1,30 @@
+from vispy.plot.fig import Fig as VispyFig
+
+from .vispy_plot import PlotWidget
+
+
+class Fig(VispyFig):
+    """Subclas of vispy.plot.Fig mostly just to use our internal plot widget.
+    """
+
+    def __init__(
+        self,
+        bgcolor='k',
+        size=(800, 600),
+        show=True,
+        keys=None,
+        vsync=True,
+        **kwargs,
+    ):
+        self._plot_widgets = []
+        self._grid = None  # initialize before the freeze occurs
+        super(VispyFig, self).__init__(
+            bgcolor=bgcolor,
+            keys=keys,
+            show=show,
+            size=size,
+            vsync=vsync,
+            **kwargs,
+        )
+        self._grid = self.central_widget.add_grid()
+        self._grid._default_class = PlotWidget