Note
Go to the end to download the full example code
Multiple viewer widget¶
This is an example on how to have more than one viewer in the same napari window. Additional viewers state will be synchronized with the main viewer. Switching to 3D display will only impact the main viewer.
This example also contain option to enable cross that will be moved to the current dims point (viewer.dims.point).
from copy import deepcopy
import numpy as np
from packaging.version import parse as parse_version
from qtpy.QtCore import Qt
from qtpy.QtWidgets import (
QCheckBox,
QDoubleSpinBox,
QPushButton,
QSplitter,
QTabWidget,
QVBoxLayout,
QWidget,
)
from superqt.utils import qthrottled
import napari
from napari.components.layerlist import Extent
from napari.components.viewer_model import ViewerModel
from napari.layers import Image, Labels, Layer, Vectors
from napari.qt import QtViewer
from napari.utils.action_manager import action_manager
from napari.utils.events.event import WarningEmitter
from napari.utils.notifications import show_info
NAPARI_GE_4_16 = parse_version(napari.__version__) > parse_version("0.4.16")
def copy_layer_le_4_16(layer: Layer, name: str = ""):
res_layer = deepcopy(layer)
# this deepcopy is not optimal for labels and images layers
if isinstance(layer, (Image, Labels)):
res_layer.data = layer.data
res_layer.metadata["viewer_name"] = name
res_layer.events.disconnect()
res_layer.events.source = res_layer
for emitter in res_layer.events.emitters.values():
emitter.disconnect()
emitter.source = res_layer
return res_layer
def copy_layer(layer: Layer, name: str = ""):
if NAPARI_GE_4_16:
return copy_layer_le_4_16(layer, name)
res_layer = Layer.create(*layer.as_layer_data_tuple())
res_layer.metadata["viewer_name"] = name
return res_layer
def get_property_names(layer: Layer):
klass = layer.__class__
res = []
for event_name, event_emitter in layer.events.emitters.items():
if isinstance(event_emitter, WarningEmitter):
continue
if event_name in ("thumbnail", "name"):
continue
if (
isinstance(getattr(klass, event_name, None), property)
and getattr(klass, event_name).fset is not None
):
res.append(event_name)
return res
def center_cross_on_mouse(
viewer_model: napari.components.viewer_model.ViewerModel,
):
"""move the cross to the mouse position"""
if not getattr(viewer_model, "mouse_over_canvas", True):
# There is no way for napari 0.4.15 to check if mouse is over sending canvas.
show_info(
"Mouse is not over the canvas. You may need to click on the canvas."
)
return
viewer_model.dims.current_step = tuple(
np.round(
[
max(min_, min(p, max_)) / step
for p, (min_, max_, step) in zip(
viewer_model.cursor.position, viewer_model.dims.range
)
]
).astype(int)
)
action_manager.register_action(
name='napari:move_point',
command=center_cross_on_mouse,
description='Move dims point to mouse position',
keymapprovider=ViewerModel,
)
action_manager.bind_shortcut('napari:move_point', 'C')
class own_partial:
"""
Workaround for deepcopy not copying partial functions
(Qt widgets are not serializable)
"""
def __init__(self, func, *args, **kwargs) -> None:
self.func = func
self.args = args
self.kwargs = kwargs
def __call__(self, *args, **kwargs):
return self.func(*(self.args + args), **{**self.kwargs, **kwargs})
def __deepcopy__(self, memodict=None):
if memodict is None:
memodict = {}
return own_partial(
self.func,
*deepcopy(self.args, memodict),
**deepcopy(self.kwargs, memodict),
)
class QtViewerWrap(QtViewer):
def __init__(self, main_viewer, *args, **kwargs) -> None:
super().__init__(*args, **kwargs)
self.main_viewer = main_viewer
def _qt_open(
self,
filenames: list,
stack: bool,
plugin: str = None,
layer_type: str = None,
**kwargs,
):
"""for drag and drop open files"""
self.main_viewer.window._qt_viewer._qt_open(
filenames, stack, plugin, layer_type, **kwargs
)
class CrossWidget(QCheckBox):
"""
Widget to control the cross layer. because of the performance reason
the cross update is throttled
"""
def __init__(self, viewer: napari.Viewer) -> None:
super().__init__("Add cross layer")
self.viewer = viewer
self.setChecked(False)
self.stateChanged.connect(self._update_cross_visibility)
self.layer = None
self.viewer.dims.events.order.connect(self.update_cross)
self.viewer.dims.events.ndim.connect(self._update_ndim)
self.viewer.dims.events.current_step.connect(self.update_cross)
self._extent = None
self._update_extent()
self.viewer.dims.events.connect(self._update_extent)
@qthrottled(leading=False)
def _update_extent(self):
"""
Calculate the extent of the data.
Ignores the the cross layer itself in calculating the extent.
"""
if NAPARI_GE_4_16:
layers = [
layer
for layer in self.viewer.layers
if layer is not self.layer
]
self._extent = self.viewer.layers.get_extent(layers)
else:
extent_list = [
layer.extent
for layer in self.viewer.layers
if layer is not self.layer
]
self._extent = Extent(
data=None,
world=self.viewer.layers._get_extent_world(extent_list),
step=self.viewer.layers._get_step_size(extent_list),
)
self.update_cross()
def _update_ndim(self, event):
if self.layer in self.viewer.layers:
self.viewer.layers.remove(self.layer)
self.layer = Vectors(name=".cross", ndim=event.value)
self.layer.edge_width = 1.5
self.update_cross()
def _update_cross_visibility(self, state):
if state:
self.viewer.layers.append(self.layer)
else:
self.viewer.layers.remove(self.layer)
self.update_cross()
def update_cross(self):
if self.layer not in self.viewer.layers:
return
point = self.viewer.dims.current_step
vec = []
for i, (lower, upper) in enumerate(self._extent.world.T):
if (upper - lower) / self._extent.step[i] == 1:
continue
point1 = list(point)
point1[i] = (lower + self._extent.step[i] / 2) / self._extent.step[
i
]
point2 = [0 for _ in point]
point2[i] = (upper - lower) / self._extent.step[i]
vec.append((point1, point2))
if np.any(self.layer.scale != self._extent.step):
self.layer.scale = self._extent.step
self.layer.data = vec
class ExampleWidget(QWidget):
"""
Dummy widget showcasing how to place additional widgets to the right
of the additional viewers.
"""
def __init__(self) -> None:
super().__init__()
self.btn = QPushButton("Perform action")
self.spin = QDoubleSpinBox()
layout = QVBoxLayout()
layout.addWidget(self.spin)
layout.addWidget(self.btn)
layout.addStretch(1)
self.setLayout(layout)
class MultipleViewerWidget(QSplitter):
"""The main widget of the example."""
def __init__(self, viewer: napari.Viewer) -> None:
super().__init__()
self.viewer = viewer
self.viewer_model1 = ViewerModel(title="model1")
self.viewer_model2 = ViewerModel(title="model2")
self._block = False
self.qt_viewer1 = QtViewerWrap(viewer, self.viewer_model1)
self.qt_viewer2 = QtViewerWrap(viewer, self.viewer_model2)
self.tab_widget = QTabWidget()
w1 = ExampleWidget()
w2 = ExampleWidget()
self.tab_widget.addTab(w1, "Sample 1")
self.tab_widget.addTab(w2, "Sample 2")
viewer_splitter = QSplitter()
viewer_splitter.setOrientation(Qt.Vertical)
viewer_splitter.addWidget(self.qt_viewer1)
viewer_splitter.addWidget(self.qt_viewer2)
viewer_splitter.setContentsMargins(0, 0, 0, 0)
self.addWidget(viewer_splitter)
self.addWidget(self.tab_widget)
self.viewer.layers.events.inserted.connect(self._layer_added)
self.viewer.layers.events.removed.connect(self._layer_removed)
self.viewer.layers.events.moved.connect(self._layer_moved)
self.viewer.layers.selection.events.active.connect(
self._layer_selection_changed
)
self.viewer.dims.events.current_step.connect(self._point_update)
self.viewer_model1.dims.events.current_step.connect(self._point_update)
self.viewer_model2.dims.events.current_step.connect(self._point_update)
self.viewer.dims.events.order.connect(self._order_update)
self.viewer.events.reset_view.connect(self._reset_view)
self.viewer_model1.events.status.connect(self._status_update)
self.viewer_model2.events.status.connect(self._status_update)
def _status_update(self, event):
self.viewer.status = event.value
def _reset_view(self):
self.viewer_model1.reset_view()
self.viewer_model2.reset_view()
def _layer_selection_changed(self, event):
"""
update of current active layer
"""
if self._block:
return
if event.value is None:
self.viewer_model1.layers.selection.active = None
self.viewer_model2.layers.selection.active = None
return
self.viewer_model1.layers.selection.active = self.viewer_model1.layers[
event.value.name
]
self.viewer_model2.layers.selection.active = self.viewer_model2.layers[
event.value.name
]
def _point_update(self, event):
for model in [self.viewer, self.viewer_model1, self.viewer_model2]:
if model.dims is event.source:
continue
if len(self.viewer.layers) != len(model.layers):
continue
model.dims.current_step = event.value
def _order_update(self):
order = list(self.viewer.dims.order)
if len(order) <= 2:
self.viewer_model1.dims.order = order
self.viewer_model2.dims.order = order
return
order[-3:] = order[-2], order[-3], order[-1]
self.viewer_model1.dims.order = order
order = list(self.viewer.dims.order)
order[-3:] = order[-1], order[-2], order[-3]
self.viewer_model2.dims.order = order
def _layer_added(self, event):
"""add layer to additional viewers and connect all required events"""
self.viewer_model1.layers.insert(
event.index, copy_layer(event.value, "model1")
)
self.viewer_model2.layers.insert(
event.index, copy_layer(event.value, "model2")
)
for name in get_property_names(event.value):
getattr(event.value.events, name).connect(
own_partial(self._property_sync, name)
)
if isinstance(event.value, Labels):
event.value.events.set_data.connect(self._set_data_refresh)
self.viewer_model1.layers[
event.value.name
].events.set_data.connect(self._set_data_refresh)
self.viewer_model2.layers[
event.value.name
].events.set_data.connect(self._set_data_refresh)
if event.value.name != ".cross":
self.viewer_model1.layers[event.value.name].events.data.connect(
self._sync_data
)
self.viewer_model2.layers[event.value.name].events.data.connect(
self._sync_data
)
event.value.events.name.connect(self._sync_name)
self._order_update()
def _sync_name(self, event):
"""sync name of layers"""
index = self.viewer.layers.index(event.source)
self.viewer_model1.layers[index].name = event.source.name
self.viewer_model2.layers[index].name = event.source.name
def _sync_data(self, event):
"""sync data modification from additional viewers"""
if self._block:
return
for model in [self.viewer, self.viewer_model1, self.viewer_model2]:
layer = model.layers[event.source.name]
if layer is event.source:
continue
try:
self._block = True
layer.data = event.source.data
finally:
self._block = False
def _set_data_refresh(self, event):
"""
synchronize data refresh between layers
"""
if self._block:
return
for model in [self.viewer, self.viewer_model1, self.viewer_model2]:
layer = model.layers[event.source.name]
if layer is event.source:
continue
try:
self._block = True
layer.refresh()
finally:
self._block = False
def _layer_removed(self, event):
"""remove layer in all viewers"""
self.viewer_model1.layers.pop(event.index)
self.viewer_model2.layers.pop(event.index)
def _layer_moved(self, event):
"""update order of layers"""
dest_index = (
event.new_index
if event.new_index < event.index
else event.new_index + 1
)
self.viewer_model1.layers.move(event.index, dest_index)
self.viewer_model2.layers.move(event.index, dest_index)
def _property_sync(self, name, event):
"""Sync layers properties (except the name)"""
if event.source not in self.viewer.layers:
return
try:
self._block = True
setattr(
self.viewer_model1.layers[event.source.name],
name,
getattr(event.source, name),
)
setattr(
self.viewer_model2.layers[event.source.name],
name,
getattr(event.source, name),
)
finally:
self._block = False
if __name__ == "__main__":
from qtpy import QtCore, QtWidgets
QtWidgets.QApplication.setAttribute(QtCore.Qt.AA_ShareOpenGLContexts)
# above two lines are needed to allow to undock the widget with
# additional viewers
view = napari.Viewer()
dock_widget = MultipleViewerWidget(view)
cross = CrossWidget(view)
view.window.add_dock_widget(dock_widget, name="Sample")
view.window.add_dock_widget(cross, name="Cross", area="left")
view.open_sample('napari', 'cells3d')
napari.run()