def __init__(self, layer):
super().__init__()
self.layer = layer
layer.events.blending.connect(self._on_blending_change)
layer.events.opacity.connect(self._on_opacity_change)
self.setObjectName('layer')
self.setMouseTracking(True)
self.grid_layout = QGridLayout(self)
self.grid_layout.setContentsMargins(0, 0, 0, 0)
self.grid_layout.setSpacing(2)
self.grid_layout.setColumnMinimumWidth(0, 86)
self.grid_layout.setColumnStretch(1, 1)
self.setLayout(self.grid_layout)
sld = QSlider(Qt.Horizontal, parent=self)
sld.setFocusPolicy(Qt.NoFocus)
sld.setMinimum(0)
sld.setMaximum(100)
sld.setSingleStep(1)
sld.valueChanged.connect(self.changeOpacity)
self.opacitySlider = sld
self._on_opacity_change()
blend_comboBox = QComboBox(self)
blend_comboBox.addItems(Blending.keys())
index = blend_comboBox.findText(
self.layer.blending, Qt.MatchFixedString
)
blend_comboBox.setCurrentIndex(index)
blend_comboBox.activated[str].connect(self.changeBlending)
self.blendComboBox = blend_comboBox
def __init__(self, layer):
super().__init__()
self.layer = layer
layer.events.blending.connect(self._on_blending_change)
layer.events.opacity.connect(self._on_opacity_change)
self.setObjectName('layer')
self.setMouseTracking(True)
self.grid_layout = QGridLayout()
self.grid_layout.setContentsMargins(0, 0, 0, 0)
self.grid_layout.setSpacing(2)
self.setLayout(self.grid_layout)
sld = QSlider(Qt.Horizontal)
sld.setFocusPolicy(Qt.NoFocus)
sld.setMinimum(0)
sld.setMaximum(100)
sld.setSingleStep(1)
sld.setValue(self.layer.opacity * 100)
sld.valueChanged[int].connect(
lambda value=sld: self.changeOpacity(value))
self.opacitySilder = sld
blend_comboBox = QComboBox()
for blend in Blending:
blend_comboBox.addItem(str(blend))
index = blend_comboBox.findText(self.layer.blending,
Qt.MatchFixedString)
blend_comboBox.setCurrentIndex(index)
blend_comboBox.activated[str].connect(
lambda text=blend_comboBox: self.changeBlending(text))
self.blendComboBox = blend_comboBox
def __init__(self, layer):
super().__init__(layer)
self.layer.events.edge_width.connect(self._on_edge_width_change)
self.layer.events.edge_color.connect(self._on_edge_color_change)
self.layer.events.face_color.connect(self._on_face_color_change)
sld = QSlider(Qt.Horizontal, self)
sld.setFocusPolicy(Qt.NoFocus)
sld.setFixedWidth(75)
sld.setMinimum(0)
sld.setMaximum(40)
sld.setSingleStep(1)
value = self.layer.edge_width
if isinstance(value, Iterable):
if isinstance(value, list):
value = np.asarray(value)
value = value.mean()
sld.setValue(int(value))
sld.valueChanged[int].connect(lambda value=sld:
self.changeWidth(value))
self.widthSlider = sld
self.grid_layout.addWidget(QLabel('width:'), 3, 0)
self.grid_layout.addWidget(sld, 3, 1)
face_comboBox = QComboBox()
colors = self.layer._colors
for c in colors:
face_comboBox.addItem(c)
index = face_comboBox.findText(
self.layer.face_color, Qt.MatchFixedString)
if index >= 0:
face_comboBox.setCurrentIndex(index)
face_comboBox.activated[str].connect(lambda text=face_comboBox:
self.changeFaceColor(text))
self.faceComboBox = face_comboBox
self.grid_layout.addWidget(QLabel('face_color:'), 4, 0)
self.grid_layout.addWidget(face_comboBox, 4, 1)
edge_comboBox = QComboBox()
colors = self.layer._colors
for c in colors:
edge_comboBox.addItem(c)
index = edge_comboBox.findText(
self.layer.edge_color, Qt.MatchFixedString)
if index >= 0:
edge_comboBox.setCurrentIndex(index)
edge_comboBox.activated[str].connect(lambda text=edge_comboBox:
self.changeEdgeColor(text))
self.edgeComboBox = edge_comboBox
self.grid_layout.addWidget(QLabel('edge_color:'), 5, 0)
self.grid_layout.addWidget(edge_comboBox, 5, 1)
self.setExpanded(False)
def __init__(self, layer):
super().__init__(layer)
self.layer.events.colormap.connect(self._on_colormap_change)
self.layer.events.gamma.connect(self._on_gamma_change)
self.layer.events.contrast_limits.connect(
self._on_contrast_limits_change
)
comboBox = QtColormapComboBox(self)
comboBox.setObjectName("colormapComboBox")
comboBox._allitems = set(self.layer.colormaps)
for name, cm in AVAILABLE_COLORMAPS.items():
if name in self.layer.colormaps:
comboBox.addItem(cm._display_name, name)
comboBox.activated[str].connect(self.changeColor)
self.colormapComboBox = comboBox
# Create contrast_limits slider
self.contrastLimitsSlider = QHRangeSlider(
self.layer.contrast_limits,
self.layer.contrast_limits_range,
parent=self,
)
self.contrastLimitsSlider.mousePressEvent = self._clim_mousepress
set_clim = partial(setattr, self.layer, 'contrast_limits')
set_climrange = partial(setattr, self.layer, 'contrast_limits_range')
self.contrastLimitsSlider.valuesChanged.connect(set_clim)
self.contrastLimitsSlider.rangeChanged.connect(set_climrange)
# gamma slider
sld = QSlider(Qt.Horizontal, parent=self)
sld.setFocusPolicy(Qt.NoFocus)
sld.setMinimum(2)
sld.setMaximum(200)
sld.setSingleStep(2)
sld.setValue(100)
sld.valueChanged.connect(self.gamma_slider_changed)
self.gammaSlider = sld
self._on_gamma_change()
self.colorbarLabel = QLabel(parent=self)
self.colorbarLabel.setObjectName('colorbar')
self.colorbarLabel.setToolTip(trans._('Colorbar'))
self._on_colormap_change()
def __init__(self, layer):
super().__init__(layer)
self.layer.events.colormap.connect(self._on_colormap_change)
self.layer.events.contrast_limits.connect(
lambda e: self.contrast_limits_slider_update()
)
self.layer.events.gamma.connect(lambda e: self.gamma_slider_update())
comboBox = QComboBox()
for cmap in self.layer.colormaps:
comboBox.addItem(cmap)
comboBox._allitems = set(self.layer.colormaps)
comboBox.activated[str].connect(
lambda text=comboBox: self.changeColor(text)
)
self.colormapComboBox = comboBox
# Create contrast_limits slider
self.contrastLimitsSlider = QHRangeSlider(
slider_range=[0, 1, 0.0001], values=[0, 1]
)
self.contrastLimitsSlider.setEmitWhileMoving(True)
self.contrastLimitsSlider.collapsable = False
self.contrastLimitsSlider.setEnabled(True)
self.contrastLimitsSlider.rangeChanged.connect(
self.contrast_limits_slider_changed
)
self.contrast_limits_slider_update()
# gamma slider
sld = QSlider(Qt.Horizontal)
sld.setFocusPolicy(Qt.NoFocus)
sld.setMinimum(2)
sld.setMaximum(200)
sld.setSingleStep(2)
sld.setValue(100)
sld.valueChanged[int].connect(self.gamma_slider_changed)
self.gammaSlider = sld
self.gamma_slider_update()
self.colorbarLabel = QLabel()
self.colorbarLabel.setObjectName('colorbar')
self.colorbarLabel.setToolTip('Colorbar')
self._on_colormap_change(None)
def __init__(self, layer):
super().__init__(layer)
self.layer.events.colormap.connect(self._on_colormap_change)
self.layer.events.gamma.connect(self.gamma_slider_update)
self.layer.events.contrast_limits.connect(self._on_clims_change)
comboBox = QComboBox()
comboBox.addItems(self.layer.colormaps)
comboBox._allitems = set(self.layer.colormaps)
comboBox.activated[str].connect(self.changeColor)
self.colormapComboBox = comboBox
# Create contrast_limits slider
self.contrastLimitsSlider = QHRangeSlider(
self.layer.contrast_limits, self.layer.contrast_limits_range
)
self.contrastLimitsSlider.mousePressEvent = self._clim_mousepress
set_clim = partial(setattr, self.layer, 'contrast_limits')
set_climrange = partial(setattr, self.layer, 'contrast_limits_range')
self.contrastLimitsSlider.valuesChanged.connect(set_clim)
self.contrastLimitsSlider.rangeChanged.connect(set_climrange)
# gamma slider
sld = QSlider(Qt.Horizontal)
sld.setFocusPolicy(Qt.NoFocus)
sld.setMinimum(2)
sld.setMaximum(200)
sld.setSingleStep(2)
sld.setValue(100)
sld.valueChanged.connect(self.gamma_slider_changed)
self.gammaSlider = sld
self.gamma_slider_update()
self.colorbarLabel = QLabel()
self.colorbarLabel.setObjectName('colorbar')
self.colorbarLabel.setToolTip('Colorbar')
self._on_colormap_change()
def __init__(self, layer):
super().__init__()
self.layer = layer
self.layer.events.blending.connect(self._on_blending_change)
self.layer.events.opacity.connect(self._on_opacity_change)
self.setAttribute(Qt.WA_DeleteOnClose)
self.setObjectName('layer')
self.setMouseTracking(True)
self.grid_layout = QGridLayout(self)
self.grid_layout.setContentsMargins(0, 0, 0, 0)
self.grid_layout.setSpacing(2)
self.grid_layout.setColumnMinimumWidth(0, 86)
self.grid_layout.setColumnStretch(1, 1)
self.setLayout(self.grid_layout)
sld = QSlider(Qt.Horizontal, parent=self)
sld.setFocusPolicy(Qt.NoFocus)
sld.setMinimum(0)
sld.setMaximum(100)
sld.setSingleStep(1)
sld.valueChanged.connect(self.changeOpacity)
self.opacitySlider = sld
self._on_opacity_change()
blend_comboBox = QComboBox(self)
for index, (data, text) in enumerate(BLENDING_TRANSLATIONS.items()):
data = data.value
blend_comboBox.addItem(text, data)
if data == self.layer.blending:
blend_comboBox.setCurrentIndex(index)
blend_comboBox.activated[str].connect(self.changeBlending)
self.blendComboBox = blend_comboBox
def __init__(self, layer):
super().__init__(layer)
self.layer.events.mode.connect(self.set_mode)
self.layer.events.n_dimensional.connect(self._on_n_dim_change)
self.layer.events.symbol.connect(self._on_symbol_change)
self.layer.events.size.connect(self._on_size_change)
self.layer.events.edge_color.connect(self._on_edge_color_change)
self.layer.events.face_color.connect(self._on_face_color_change)
self.layer.events.editable.connect(self._on_editable_change)
sld = QSlider(Qt.Horizontal)
sld.setFocusPolicy(Qt.NoFocus)
sld.setMinimum(1)
sld.setMaximum(100)
sld.setSingleStep(1)
value = self.layer.size
sld.setValue(int(value))
sld.valueChanged[int].connect(lambda value=sld: self.changeSize(value))
self.sizeSlider = sld
face_comboBox = QComboBox()
colors = self.layer._colors
for c in colors:
face_comboBox.addItem(c)
face_comboBox.activated[str].connect(
lambda text=face_comboBox: self.changeFaceColor(text))
self.faceComboBox = face_comboBox
self.faceColorSwatch = QFrame()
self.faceColorSwatch.setObjectName('swatch')
self.faceColorSwatch.setToolTip('Face color swatch')
self._on_face_color_change(None)
edge_comboBox = QComboBox()
colors = self.layer._colors
for c in colors:
edge_comboBox.addItem(c)
edge_comboBox.activated[str].connect(
lambda text=edge_comboBox: self.changeEdgeColor(text))
self.edgeComboBox = edge_comboBox
self.edgeColorSwatch = QFrame()
self.edgeColorSwatch.setObjectName('swatch')
self.edgeColorSwatch.setToolTip('Edge color swatch')
self._on_edge_color_change(None)
symbol_comboBox = QComboBox()
for s in Symbol:
symbol_comboBox.addItem(str(s))
index = symbol_comboBox.findText(self.layer.symbol,
Qt.MatchFixedString)
symbol_comboBox.setCurrentIndex(index)
symbol_comboBox.activated[str].connect(
lambda text=symbol_comboBox: self.changeSymbol(text))
self.symbolComboBox = symbol_comboBox
ndim_cb = QCheckBox()
ndim_cb.setToolTip('N-dimensional points')
ndim_cb.setChecked(self.layer.n_dimensional)
ndim_cb.stateChanged.connect(
lambda state=ndim_cb: self.change_ndim(state))
self.ndimCheckBox = ndim_cb
self.select_button = QtSelectButton(layer)
self.addition_button = QtAdditionButton(layer)
self.panzoom_button = QtPanZoomButton(layer)
self.delete_button = QtDeletePointsButton(layer)
self.button_group = QButtonGroup(self)
self.button_group.addButton(self.select_button)
self.button_group.addButton(self.addition_button)
self.button_group.addButton(self.panzoom_button)
# grid_layout created in QtLayerControls
# addWidget(widget, row, column, [row_span, column_span])
self.grid_layout.addWidget(self.panzoom_button, 0, 6)
self.grid_layout.addWidget(self.select_button, 0, 5)
self.grid_layout.addWidget(self.addition_button, 0, 4)
self.grid_layout.addWidget(self.delete_button, 0, 3)
self.grid_layout.addWidget(QLabel('opacity:'), 1, 0, 1, 3)
self.grid_layout.addWidget(self.opacitySilder, 1, 3, 1, 4)
self.grid_layout.addWidget(QLabel('point size:'), 2, 0, 1, 3)
self.grid_layout.addWidget(self.sizeSlider, 2, 3, 1, 4)
self.grid_layout.addWidget(QLabel('blending:'), 3, 0, 1, 3)
self.grid_layout.addWidget(self.blendComboBox, 3, 3, 1, 4)
self.grid_layout.addWidget(QLabel('symbol:'), 4, 0, 1, 3)
self.grid_layout.addWidget(self.symbolComboBox, 4, 3, 1, 4)
self.grid_layout.addWidget(QLabel('face color:'), 5, 0, 1, 3)
self.grid_layout.addWidget(self.faceComboBox, 5, 3, 1, 3)
self.grid_layout.addWidget(self.faceColorSwatch, 5, 6)
self.grid_layout.addWidget(QLabel('edge color:'), 6, 0, 1, 3)
self.grid_layout.addWidget(self.edgeComboBox, 6, 3, 1, 3)
self.grid_layout.addWidget(self.edgeColorSwatch, 6, 6)
self.grid_layout.addWidget(QLabel('n-dim:'), 7, 0, 1, 3)
self.grid_layout.addWidget(self.ndimCheckBox, 7, 3)
self.grid_layout.setRowStretch(8, 1)
self.grid_layout.setVerticalSpacing(4)
class QtTracksControls(QtLayerControls):
"""Qt view and controls for the Tracks layer.
Parameters
----------
layer : napari.layers.Tracks
An instance of a Tracks layer.
Attributes
----------
grid_layout : qtpy.QtWidgets.QGridLayout
Layout of Qt widget controls for the layer.
layer : layers.Tracks
An instance of a Tracks layer.
"""
def __init__(self, layer):
super().__init__(layer)
# NOTE(arl): there are no events fired for changing checkboxes
self.layer.events.tail_width.connect(self._on_tail_width_change)
self.layer.events.tail_length.connect(self._on_tail_length_change)
self.layer.events.properties.connect(self._on_properties_change)
self.layer.events.colormap.connect(self._on_colormap_change)
self.layer.events.color_by.connect(self._on_color_by_change)
# combo box for track coloring, we can get these from the properties
# keys
self.color_by_combobox = QComboBox()
self.color_by_combobox.addItems(self.layer.properties_to_color_by)
self.colormap_combobox = QComboBox()
for name, colormap in AVAILABLE_COLORMAPS.items():
display_name = colormap._display_name
self.colormap_combobox.addItem(display_name, name)
# slider for track tail length
self.tail_length_slider = QSlider(Qt.Horizontal)
self.tail_length_slider.setFocusPolicy(Qt.NoFocus)
self.tail_length_slider.setMinimum(1)
self.tail_length_slider.setMaximum(MAX_TAIL_LENGTH)
self.tail_length_slider.setSingleStep(1)
# slider for track edge width
self.tail_width_slider = QSlider(Qt.Horizontal)
self.tail_width_slider.setFocusPolicy(Qt.NoFocus)
self.tail_width_slider.setMinimum(1)
self.tail_width_slider.setMaximum(MAX_TAIL_WIDTH)
self.tail_width_slider.setSingleStep(1)
# checkboxes for display
self.id_checkbox = QCheckBox()
self.tail_checkbox = QCheckBox()
self.tail_checkbox.setChecked(True)
self.graph_checkbox = QCheckBox()
self.graph_checkbox.setChecked(True)
self.tail_width_slider.valueChanged.connect(self.change_tail_width)
self.tail_length_slider.valueChanged.connect(self.change_tail_length)
self.tail_checkbox.stateChanged.connect(self.change_display_tail)
self.id_checkbox.stateChanged.connect(self.change_display_id)
self.graph_checkbox.stateChanged.connect(self.change_display_graph)
self.color_by_combobox.currentTextChanged.connect(self.change_color_by)
self.colormap_combobox.currentTextChanged.connect(self.change_colormap)
# grid_layout created in QtLayerControls
# addWidget(widget, row, column, [row_span, column_span])
self.grid_layout.addWidget(QLabel(trans._('color by:')), 0, 0)
self.grid_layout.addWidget(self.color_by_combobox, 0, 1)
self.grid_layout.addWidget(QLabel(trans._('colormap:')), 1, 0)
self.grid_layout.addWidget(self.colormap_combobox, 1, 1)
self.grid_layout.addWidget(QLabel(trans._('blending:')), 2, 0)
self.grid_layout.addWidget(self.blendComboBox, 2, 1)
self.grid_layout.addWidget(QLabel(trans._('opacity:')), 3, 0)
self.grid_layout.addWidget(self.opacitySlider, 3, 1)
self.grid_layout.addWidget(QLabel(trans._('tail width:')), 4, 0)
self.grid_layout.addWidget(self.tail_width_slider, 4, 1)
self.grid_layout.addWidget(QLabel(trans._('tail length:')), 5, 0)
self.grid_layout.addWidget(self.tail_length_slider, 5, 1)
self.grid_layout.addWidget(QLabel(trans._('tail:')), 6, 0)
self.grid_layout.addWidget(self.tail_checkbox, 6, 1)
self.grid_layout.addWidget(QLabel(trans._('show ID:')), 7, 0)
self.grid_layout.addWidget(self.id_checkbox, 7, 1)
self.grid_layout.addWidget(QLabel(trans._('graph:')), 8, 0)
self.grid_layout.addWidget(self.graph_checkbox, 8, 1)
self.grid_layout.setRowStretch(9, 1)
self.grid_layout.setColumnStretch(1, 1)
self.grid_layout.setSpacing(4)
self._on_tail_length_change()
self._on_tail_width_change()
self._on_colormap_change()
self._on_color_by_change()
def _on_tail_width_change(self, event=None):
"""Receive layer model track line width change event and update slider.
Parameters
----------
event : qtpy.QtCore.QEvent, optional.
Event from the Qt context, by default None.
"""
with self.layer.events.tail_width.blocker():
value = self.layer.tail_width
value = np.clip(int(2 * value), 1, MAX_TAIL_WIDTH)
self.tail_width_slider.setValue(value)
def _on_tail_length_change(self, event=None):
"""Receive layer model track line width change event and update slider.
Parameters
----------
event : qtpy.QtCore.QEvent, optional.
Event from the Qt context, by default None.
"""
with self.layer.events.tail_length.blocker():
value = self.layer.tail_length
value = np.clip(value, 1, MAX_TAIL_LENGTH)
self.tail_length_slider.setValue(value)
def _on_properties_change(self, event=None):
"""Change the properties that can be used to color the tracks."""
with self.layer.events.properties.blocker():
with qt_signals_blocked(self.color_by_combobox):
self.color_by_combobox.clear()
self.color_by_combobox.addItems(self.layer.properties_to_color_by)
def _on_colormap_change(self, event=None):
"""Receive layer model colormap change event and update combobox.
Parameters
----------
event : qtpy.QtCore.QEvent, optional.
Event from the Qt context, by default None.
"""
with self.layer.events.colormap.blocker():
self.colormap_combobox.setCurrentIndex(
self.colormap_combobox.findData(self.layer.colormap))
def _on_color_by_change(self, event=None):
"""Receive layer model color_by change event and update combobox.
Parameters
----------
event : qtpy.QtCore.QEvent, optional.
Event from the Qt context, by default None.
"""
with self.layer.events.color_by.blocker():
color_by = self.layer.color_by
idx = self.color_by_combobox.findText(color_by,
Qt.MatchFixedString)
self.color_by_combobox.setCurrentIndex(idx)
def change_tail_width(self, value):
"""Change track line width of shapes on the layer model.
Parameters
----------
value : float
Line width of track tails.
"""
self.layer.tail_width = float(value) / 2.0
def change_tail_length(self, value):
"""Change edge line width of shapes on the layer model.
Parameters
----------
value : int
Line length of track tails.
"""
self.layer.tail_length = value
def change_display_tail(self, state):
self.layer.display_tail = self.tail_checkbox.isChecked()
def change_display_id(self, state):
self.layer.display_id = self.id_checkbox.isChecked()
def change_display_graph(self, state):
self.layer.display_graph = self.graph_checkbox.isChecked()
def change_color_by(self, value: str):
self.layer.color_by = value
def change_colormap(self, colormap: str):
self.layer.colormap = self.colormap_combobox.currentData()
def __init__(self, layer):
super().__init__(layer)
self.layer.events.interpolation.connect(self._on_interpolation_change)
self.layer.events.rendering.connect(self._on_rendering_change)
self.layer.events.iso_threshold.connect(self._on_iso_threshold_change)
self.layer.events.attenuation.connect(self._on_attenuation_change)
self.layer.events._ndisplay.connect(self._on_ndisplay_change)
self.layer.events.depiction.connect(self._on_depiction_change)
self.layer.plane.events.thickness.connect(
self._on_plane_thickness_change)
self.interpComboBox = QComboBox(self)
self.interpComboBox.activated[str].connect(self.changeInterpolation)
self.interpLabel = QLabel(trans._('interpolation:'))
renderComboBox = QComboBox(self)
rendering_options = [i.value for i in ImageRendering]
renderComboBox.addItems(rendering_options)
index = renderComboBox.findText(self.layer.rendering,
Qt.MatchFixedString)
renderComboBox.setCurrentIndex(index)
renderComboBox.activated[str].connect(self.changeRendering)
self.renderComboBox = renderComboBox
self.renderLabel = QLabel(trans._('rendering:'))
self.depictionComboBox = QComboBox(self)
depiction_options = [d.value for d in VolumeDepiction]
self.depictionComboBox.addItems(depiction_options)
index = self.depictionComboBox.findText(self.layer.depiction,
Qt.MatchFixedString)
self.depictionComboBox.setCurrentIndex(index)
self.depictionComboBox.activated[str].connect(self.changeDepiction)
self.depictionLabel = QLabel(trans._('depiction:'))
self.planeControls = QtPlaneControls()
self.planeControls.planeThicknessSlider.setValue(
self.layer.plane.thickness)
self.planeControls.planeThicknessSlider.valueChanged.connect(
self.changePlaneThickness)
action_manager.bind_button(
'napari:orient_plane_normal_along_z',
self.planeControls.planeNormalButtons.zButton,
)
action_manager.bind_button(
'napari:orient_plane_normal_along_y',
self.planeControls.planeNormalButtons.yButton,
)
action_manager.bind_button(
'napari:orient_plane_normal_along_x',
self.planeControls.planeNormalButtons.xButton,
)
action_manager.bind_button(
'napari:orient_plane_normal_along_view_direction',
self.planeControls.planeNormalButtons.obliqueButton,
)
sld = QSlider(Qt.Horizontal, parent=self)
sld.setFocusPolicy(Qt.NoFocus)
sld.setMinimum(0)
sld.setMaximum(100)
sld.setSingleStep(1)
sld.setValue(int(self.layer.iso_threshold * 100))
sld.valueChanged.connect(self.changeIsoThreshold)
self.isoThresholdSlider = sld
self.isoThresholdLabel = QLabel(trans._('iso threshold:'))
sld = QSlider(Qt.Horizontal, parent=self)
sld.setFocusPolicy(Qt.NoFocus)
sld.setMinimum(0)
sld.setMaximum(100)
sld.setSingleStep(1)
sld.setValue(int(self.layer.attenuation * 200))
sld.valueChanged.connect(self.changeAttenuation)
self.attenuationSlider = sld
self.attenuationLabel = QLabel(trans._('attenuation:'))
self._on_ndisplay_change()
colormap_layout = QHBoxLayout()
if hasattr(self.layer, 'rgb') and self.layer.rgb:
colormap_layout.addWidget(QLabel("RGB"))
self.colormapComboBox.setVisible(False)
self.colorbarLabel.setVisible(False)
else:
colormap_layout.addWidget(self.colorbarLabel)
colormap_layout.addWidget(self.colormapComboBox)
colormap_layout.addStretch(1)
# grid_layout created in QtLayerControls
# addWidget(widget, row, column, [row_span, column_span])
self.grid_layout.addWidget(QLabel(trans._('opacity:')), 0, 0)
self.grid_layout.addWidget(self.opacitySlider, 0, 1)
self.grid_layout.addWidget(QLabel(trans._('contrast limits:')), 1, 0)
self.grid_layout.addWidget(self.contrastLimitsSlider, 1, 1)
self.grid_layout.addWidget(QLabel(trans._('auto-contrast:')), 2, 0)
self.grid_layout.addWidget(self.autoScaleBar, 2, 1)
self.grid_layout.addWidget(QLabel(trans._('gamma:')), 3, 0)
self.grid_layout.addWidget(self.gammaSlider, 3, 1)
self.grid_layout.addWidget(QLabel(trans._('colormap:')), 4, 0)
self.grid_layout.addLayout(colormap_layout, 4, 1)
self.grid_layout.addWidget(QLabel(trans._('blending:')), 5, 0)
self.grid_layout.addWidget(self.blendComboBox, 5, 1)
self.grid_layout.addWidget(self.interpLabel, 6, 0)
self.grid_layout.addWidget(self.interpComboBox, 6, 1)
self.grid_layout.addWidget(self.renderLabel, 7, 0)
self.grid_layout.addWidget(self.renderComboBox, 7, 1)
self.grid_layout.addWidget(self.depictionLabel, 8, 0)
self.grid_layout.addWidget(self.depictionComboBox, 8, 1)
self.grid_layout.addWidget(self.planeControls, 9, 0, 2, 2)
self.grid_layout.addWidget(self.isoThresholdLabel, 11, 0)
self.grid_layout.addWidget(self.isoThresholdSlider, 11, 1)
self.grid_layout.addWidget(self.attenuationLabel, 12, 0)
self.grid_layout.addWidget(self.attenuationSlider, 12, 1)
self.grid_layout.setRowStretch(13, 1)
self.grid_layout.setColumnStretch(1, 1)
self.grid_layout.setSpacing(4)
def __init__(self, layer):
super().__init__(layer)
self.layer.events.mode.connect(self._on_mode_change)
self.layer.events.selected_label.connect(self._on_selection_change)
self.layer.events.brush_size.connect(self._on_brush_size_change)
self.layer.events.contiguous.connect(self._on_contig_change)
self.layer.events.n_dimensional.connect(self._on_n_dim_change)
self.layer.events.editable.connect(self._on_editable_change)
self.layer.events.preserve_labels.connect(
self._on_preserve_labels_change
)
self.layer.events.color_mode.connect(self._on_color_mode_change)
# selection spinbox
self.selectionSpinBox = QSpinBox()
self.selectionSpinBox.setKeyboardTracking(False)
self.selectionSpinBox.setSingleStep(1)
self.selectionSpinBox.setMinimum(0)
self.selectionSpinBox.setMaximum(2147483647)
self.selectionSpinBox.valueChanged.connect(self.changeSelection)
self.selectionSpinBox.setAlignment(Qt.AlignCenter)
self._on_selection_change()
sld = QSlider(Qt.Horizontal)
sld.setFocusPolicy(Qt.NoFocus)
sld.setMinimum(1)
sld.setMaximum(40)
sld.setSingleStep(1)
sld.valueChanged.connect(self.changeSize)
self.brushSizeSlider = sld
self._on_brush_size_change()
contig_cb = QCheckBox()
contig_cb.setToolTip('contiguous editing')
contig_cb.stateChanged.connect(self.change_contig)
self.contigCheckBox = contig_cb
self._on_contig_change()
ndim_cb = QCheckBox()
ndim_cb.setToolTip('n-dimensional editing')
ndim_cb.stateChanged.connect(self.change_ndim)
self.ndimCheckBox = ndim_cb
self._on_n_dim_change()
preserve_labels_cb = QCheckBox()
preserve_labels_cb.setToolTip(
'preserve existing labels while painting'
)
preserve_labels_cb.stateChanged.connect(self.change_preserve_labels)
self.preserveLabelsCheckBox = preserve_labels_cb
self._on_preserve_labels_change()
# shuffle colormap button
self.colormapUpdate = QtModePushButton(
None, 'shuffle', slot=self.changeColor, tooltip='shuffle colors',
)
self.panzoom_button = QtModeRadioButton(
layer,
'zoom',
Mode.PAN_ZOOM,
tooltip='Pan/zoom mode (Space)',
checked=True,
)
self.pick_button = QtModeRadioButton(
layer, 'picker', Mode.PICK, tooltip='Pick mode'
)
self.paint_button = QtModeRadioButton(
layer, 'paint', Mode.PAINT, tooltip='Paint mode'
)
btn = 'Cmd' if sys.platform == 'darwin' else 'Ctrl'
self.fill_button = QtModeRadioButton(
layer, 'fill', Mode.FILL, tooltip=f'Fill mode ({btn})'
)
self.erase_button = QtModeRadioButton(
layer, 'erase', Mode.ERASE, tooltip='Erase mode (Alt)'
)
self.button_group = QButtonGroup(self)
self.button_group.addButton(self.panzoom_button)
self.button_group.addButton(self.paint_button)
self.button_group.addButton(self.pick_button)
self.button_group.addButton(self.fill_button)
self.button_group.addButton(self.erase_button)
self._on_editable_change()
button_row = QHBoxLayout()
button_row.addStretch(1)
button_row.addWidget(self.colormapUpdate)
button_row.addWidget(self.erase_button)
button_row.addWidget(self.fill_button)
button_row.addWidget(self.paint_button)
button_row.addWidget(self.pick_button)
button_row.addWidget(self.panzoom_button)
button_row.setSpacing(4)
button_row.setContentsMargins(0, 0, 0, 5)
color_mode_comboBox = QComboBox(self)
color_mode_comboBox.addItems(LabelColorMode.keys())
index = color_mode_comboBox.findText(
self.layer.color_mode, Qt.MatchFixedString
)
color_mode_comboBox.setCurrentIndex(index)
color_mode_comboBox.activated[str].connect(self.change_color_mode)
self.colorModeComboBox = color_mode_comboBox
self._on_color_mode_change()
color_layout = QHBoxLayout()
color_layout.addWidget(QtColorBox(layer))
color_layout.addWidget(self.selectionSpinBox)
# grid_layout created in QtLayerControls
# addWidget(widget, row, column, [row_span, column_span])
self.grid_layout.addLayout(button_row, 0, 0, 1, 4)
self.grid_layout.addWidget(QLabel('label:'), 1, 0, 1, 1)
self.grid_layout.addLayout(color_layout, 1, 1, 1, 3)
self.grid_layout.addWidget(QLabel('opacity:'), 2, 0, 1, 1)
self.grid_layout.addWidget(self.opacitySlider, 2, 1, 1, 3)
self.grid_layout.addWidget(QLabel('brush size:'), 3, 0, 1, 1)
self.grid_layout.addWidget(self.brushSizeSlider, 3, 1, 1, 3)
self.grid_layout.addWidget(QLabel('blending:'), 4, 0, 1, 1)
self.grid_layout.addWidget(self.blendComboBox, 4, 1, 1, 3)
self.grid_layout.addWidget(QLabel('color mode:'), 5, 0, 1, 1)
self.grid_layout.addWidget(self.colorModeComboBox, 5, 1, 1, 3)
self.grid_layout.addWidget(QLabel('contiguous:'), 6, 0, 1, 1)
self.grid_layout.addWidget(self.contigCheckBox, 6, 1, 1, 1)
self.grid_layout.addWidget(QLabel('n-dim:'), 6, 2, 1, 1)
self.grid_layout.addWidget(self.ndimCheckBox, 6, 3, 1, 1)
self.grid_layout.addWidget(QLabel('preserve labels:'), 7, 0, 1, 2)
self.grid_layout.addWidget(self.preserveLabelsCheckBox, 7, 1, 1, 1)
self.grid_layout.setRowStretch(8, 1)
self.grid_layout.setColumnStretch(1, 1)
self.grid_layout.setSpacing(4)
class TimeChartDisplay(Display):
def __init__(self,
parent=None,
args=[],
macros=None,
show_pv_add_panel=True,
config_file=None):
"""
Create all the widgets, including any child dialogs.
Parameters
----------
parent : QWidget
The parent widget of the charting display
args : list
The command parameters
macros : str
Macros to modify the UI parameters at runtime
show_pv_add_panel : bool
Whether or not to show the PV add panel on top of the graph
"""
super(TimeChartDisplay, self).__init__(parent=parent,
args=args,
macros=macros)
self.legend_font = None
self.channel_map = dict()
self.setWindowTitle("TimeChart Tool")
self.main_layout = QVBoxLayout()
self.body_layout = QVBoxLayout()
self.pv_add_panel = QFrame()
self.pv_add_panel.setVisible(show_pv_add_panel)
self.pv_add_panel.setMaximumHeight(50)
self.pv_layout = QHBoxLayout()
self.pv_name_line_edt = QLineEdit()
self.pv_name_line_edt.setAcceptDrops(True)
self.pv_name_line_edt.returnPressed.connect(self.add_curve)
self.pv_protocol_cmb = QComboBox()
self.pv_protocol_cmb.addItems(["ca://", "archive://"])
self.pv_protocol_cmb.setEnabled(False)
self.pv_connect_push_btn = QPushButton("Connect")
self.pv_connect_push_btn.clicked.connect(self.add_curve)
self.tab_panel = QTabWidget()
self.tab_panel.setMinimumWidth(350)
self.tab_panel.setMaximumWidth(350)
self.curve_settings_tab = QWidget()
self.data_settings_tab = QWidget()
self.chart_settings_tab = QWidget()
self.charting_layout = QHBoxLayout()
self.chart = PyDMTimePlot(plot_by_timestamps=False)
self.chart.setDownsampling(ds=False, auto=False, mode=None)
self.chart.plot_redrawn_signal.connect(self.update_curve_data)
self.chart.setBufferSize(DEFAULT_BUFFER_SIZE)
self.chart.setPlotTitle(DEFAULT_CHART_TITLE)
self.splitter = QSplitter()
self.curve_settings_layout = QVBoxLayout()
self.curve_settings_layout.setAlignment(Qt.AlignTop)
self.curve_settings_layout.setSizeConstraint(QLayout.SetMinAndMaxSize)
self.curve_settings_layout.setSpacing(5)
self.crosshair_settings_layout = QVBoxLayout()
self.crosshair_settings_layout.setAlignment(Qt.AlignTop)
self.crosshair_settings_layout.setSpacing(5)
self.enable_crosshair_chk = QCheckBox("Crosshair")
self.crosshair_coord_lbl = QLabel()
self.crosshair_coord_lbl.setWordWrap(True)
self.curve_settings_inner_frame = QFrame()
self.curve_settings_inner_frame.setLayout(self.curve_settings_layout)
self.curve_settings_scroll = QScrollArea()
self.curve_settings_scroll.setVerticalScrollBarPolicy(
Qt.ScrollBarAsNeeded)
self.curve_settings_scroll.setHorizontalScrollBarPolicy(
Qt.ScrollBarAlwaysOff)
self.curve_settings_scroll.setWidget(self.curve_settings_inner_frame)
self.curve_settings_scroll.setWidgetResizable(True)
self.enable_crosshair_chk.setChecked(False)
self.enable_crosshair_chk.clicked.connect(
self.handle_enable_crosshair_checkbox_clicked)
self.enable_crosshair_chk.clicked.emit(False)
self.curves_tab_layout = QHBoxLayout()
self.curves_tab_layout.addWidget(self.curve_settings_scroll)
self.data_tab_layout = QVBoxLayout()
self.data_tab_layout.setAlignment(Qt.AlignTop)
self.data_tab_layout.setSpacing(5)
self.chart_settings_layout = QVBoxLayout()
self.chart_settings_layout.setAlignment(Qt.AlignTop)
self.chart_settings_layout.setSpacing(5)
self.chart_layout = QVBoxLayout()
self.chart_layout.setSpacing(10)
self.chart_panel = QWidget()
self.chart_panel.setMinimumHeight(400)
self.chart_control_layout = QHBoxLayout()
self.chart_control_layout.setAlignment(Qt.AlignHCenter)
self.chart_control_layout.setSpacing(10)
self.zoom_x_layout = QVBoxLayout()
self.zoom_x_layout.setAlignment(Qt.AlignTop)
self.zoom_x_layout.setSpacing(5)
self.plus_icon = IconFont().icon("plus", color=QColor("green"))
self.minus_icon = IconFont().icon("minus", color=QColor("red"))
self.view_all_icon = IconFont().icon("globe", color=QColor("blue"))
self.reset_icon = IconFont().icon("circle-o-notch",
color=QColor("green"))
self.zoom_in_x_btn = QPushButton("X Zoom")
self.zoom_in_x_btn.setIcon(self.plus_icon)
self.zoom_in_x_btn.clicked.connect(
partial(self.handle_zoom_in_btn_clicked, "x", True))
self.zoom_in_x_btn.setEnabled(False)
self.zoom_out_x_btn = QPushButton("X Zoom")
self.zoom_out_x_btn.setIcon(self.minus_icon)
self.zoom_out_x_btn.clicked.connect(
partial(self.handle_zoom_in_btn_clicked, "x", False))
self.zoom_out_x_btn.setEnabled(False)
self.zoom_y_layout = QVBoxLayout()
self.zoom_y_layout.setAlignment(Qt.AlignTop)
self.zoom_y_layout.setSpacing(5)
self.zoom_in_y_btn = QPushButton("Y Zoom")
self.zoom_in_y_btn.setIcon(self.plus_icon)
self.zoom_in_y_btn.clicked.connect(
partial(self.handle_zoom_in_btn_clicked, "y", True))
self.zoom_in_y_btn.setEnabled(False)
self.zoom_out_y_btn = QPushButton("Y Zoom")
self.zoom_out_y_btn.setIcon(self.minus_icon)
self.zoom_out_y_btn.clicked.connect(
partial(self.handle_zoom_in_btn_clicked, "y", False))
self.zoom_out_y_btn.setEnabled(False)
self.view_all_btn = QPushButton("View All")
self.view_all_btn.setIcon(self.view_all_icon)
self.view_all_btn.clicked.connect(self.handle_view_all_button_clicked)
self.view_all_btn.setEnabled(False)
self.view_all_reset_chart_layout = QVBoxLayout()
self.view_all_reset_chart_layout.setAlignment(Qt.AlignTop)
self.view_all_reset_chart_layout.setSpacing(5)
self.pause_chart_layout = QVBoxLayout()
self.pause_chart_layout.setAlignment(Qt.AlignTop)
self.pause_chart_layout.setSpacing(5)
self.reset_chart_btn = QPushButton("Reset")
self.reset_chart_btn.setIcon(self.reset_icon)
self.reset_chart_btn.clicked.connect(
self.handle_reset_chart_btn_clicked)
self.reset_chart_btn.setEnabled(False)
self.pause_icon = IconFont().icon("pause", color=QColor("red"))
self.play_icon = IconFont().icon("play", color=QColor("green"))
self.pause_chart_btn = QPushButton()
self.pause_chart_btn.setIcon(self.pause_icon)
self.pause_chart_btn.clicked.connect(
self.handle_pause_chart_btn_clicked)
self.title_settings_layout = QVBoxLayout()
self.title_settings_layout.setAlignment(Qt.AlignTop)
self.title_settings_layout.setSpacing(5)
self.title_settings_grpbx = QGroupBox("Title and Legend")
self.title_settings_grpbx.setMaximumHeight(120)
self.import_export_data_layout = QVBoxLayout()
self.import_export_data_layout.setAlignment(Qt.AlignTop)
self.import_export_data_layout.setSpacing(5)
self.import_data_btn = QPushButton("Import...")
self.import_data_btn.clicked.connect(
self.handle_import_data_btn_clicked)
self.export_data_btn = QPushButton("Export...")
self.export_data_btn.clicked.connect(
self.handle_export_data_btn_clicked)
self.chart_title_layout = QHBoxLayout()
self.chart_title_layout.setSpacing(10)
self.chart_title_lbl = QLabel(text="Graph Title")
self.chart_title_line_edt = QLineEdit()
self.chart_title_line_edt.setText(self.chart.getPlotTitle())
self.chart_title_line_edt.textChanged.connect(
self.handle_title_text_changed)
self.chart_title_font_btn = QPushButton()
self.chart_title_font_btn.setFixedHeight(24)
self.chart_title_font_btn.setFixedWidth(24)
self.chart_title_font_btn.setIcon(IconFont().icon("font"))
self.chart_title_font_btn.clicked.connect(
partial(self.handle_chart_font_changed, "title"))
self.chart_change_axis_settings_btn = QPushButton(
text="Change Axis Settings...")
self.chart_change_axis_settings_btn.clicked.connect(
self.handle_change_axis_settings_clicked)
self.update_datetime_timer = QTimer(self)
self.update_datetime_timer.timeout.connect(
self.handle_update_datetime_timer_timeout)
self.chart_sync_mode_layout = QVBoxLayout()
self.chart_sync_mode_layout.setSpacing(5)
self.chart_sync_mode_grpbx = QGroupBox("Data Sampling Mode")
self.chart_sync_mode_grpbx.setMaximumHeight(100)
self.chart_sync_mode_sync_radio = QRadioButton("Synchronous")
self.chart_sync_mode_async_radio = QRadioButton("Asynchronous")
self.chart_sync_mode_async_radio.setChecked(True)
self.graph_drawing_settings_layout = QVBoxLayout()
self.graph_drawing_settings_layout.setAlignment(Qt.AlignVCenter)
self.chart_interval_layout = QFormLayout()
self.chart_redraw_rate_lbl = QLabel("Redraw Rate (Hz)")
self.chart_redraw_rate_spin = QSpinBox()
self.chart_redraw_rate_spin.setRange(MIN_REDRAW_RATE_HZ,
MAX_REDRAW_RATE_HZ)
self.chart_redraw_rate_spin.setValue(DEFAULT_REDRAW_RATE_HZ)
self.chart_redraw_rate_spin.editingFinished.connect(
self.handle_redraw_rate_changed)
self.chart_data_sampling_rate_lbl = QLabel("Data Sampling Rate (Hz)")
self.chart_data_async_sampling_rate_spin = QSpinBox()
self.chart_data_async_sampling_rate_spin.setRange(
MIN_DATA_SAMPLING_RATE_HZ, MAX_DATA_SAMPLING_RATE_HZ)
self.chart_data_async_sampling_rate_spin.setValue(
DEFAULT_DATA_SAMPLING_RATE_HZ)
self.chart_data_async_sampling_rate_spin.editingFinished.connect(
self.handle_data_sampling_rate_changed)
self.chart_data_sampling_rate_lbl.hide()
self.chart_data_async_sampling_rate_spin.hide()
self.chart_limit_time_span_layout = QHBoxLayout()
self.chart_limit_time_span_layout.setSpacing(5)
self.limit_time_plan_text = "Limit Time Span"
self.chart_limit_time_span_chk = QCheckBox(self.limit_time_plan_text)
self.chart_limit_time_span_chk.hide()
self.chart_limit_time_span_lbl = QLabel("Hr:Min:Sec")
self.chart_limit_time_span_hours_spin_box = QSpinBox()
self.chart_limit_time_span_hours_spin_box.setMaximum(999)
self.chart_limit_time_span_minutes_spin_box = QSpinBox()
self.chart_limit_time_span_minutes_spin_box.setMaximum(59)
self.chart_limit_time_span_seconds_spin_box = QSpinBox()
self.chart_limit_time_span_seconds_spin_box.setMaximum(59)
self.chart_limit_time_span_activate_btn = QPushButton("Apply")
self.chart_limit_time_span_activate_btn.setDisabled(True)
self.chart_ring_buffer_layout = QFormLayout()
self.chart_ring_buffer_size_lbl = QLabel("Ring Buffer Size")
self.chart_ring_buffer_size_edt = QLineEdit()
self.chart_ring_buffer_size_edt.returnPressed.connect(
self.handle_buffer_size_changed)
self.chart_ring_buffer_size_edt.setText(str(DEFAULT_BUFFER_SIZE))
self.show_legend_chk = QCheckBox("Show Legend")
self.show_legend_chk.clicked.connect(
self.handle_show_legend_checkbox_clicked)
self.show_legend_chk.setChecked(self.chart.showLegend)
self.legend_font_btn = QPushButton()
self.legend_font_btn.setFixedHeight(24)
self.legend_font_btn.setFixedWidth(24)
self.legend_font_btn.setIcon(IconFont().icon("font"))
self.legend_font_btn.clicked.connect(
partial(self.handle_chart_font_changed, "legend"))
self.graph_background_color_layout = QFormLayout()
self.axis_grid_color_layout = QFormLayout()
self.background_color_lbl = QLabel("Graph Background Color ")
self.background_color_btn = QPushButton()
self.background_color_btn.setStyleSheet(
"background-color: " + self.chart.getBackgroundColor().name())
self.background_color_btn.setContentsMargins(10, 0, 5, 5)
self.background_color_btn.setMaximumWidth(20)
self.background_color_btn.clicked.connect(
self.handle_background_color_button_clicked)
self.axis_settings_layout = QVBoxLayout()
self.axis_settings_layout.setSpacing(10)
self.show_x_grid_chk = QCheckBox("Show x Grid")
self.show_x_grid_chk.setChecked(self.chart.showXGrid)
self.show_x_grid_chk.clicked.connect(
self.handle_show_x_grid_checkbox_clicked)
self.show_y_grid_chk = QCheckBox("Show y Grid")
self.show_y_grid_chk.setChecked(self.chart.showYGrid)
self.show_y_grid_chk.clicked.connect(
self.handle_show_y_grid_checkbox_clicked)
self.axis_color_lbl = QLabel("Axis and Grid Color")
self.axis_color_btn = QPushButton()
self.axis_color_btn.setStyleSheet("background-color: " +
DEFAULT_CHART_AXIS_COLOR.name())
self.axis_color_btn.setContentsMargins(10, 0, 5, 5)
self.axis_color_btn.setMaximumWidth(20)
self.axis_color_btn.clicked.connect(
self.handle_axis_color_button_clicked)
self.grid_opacity_lbl = QLabel("Grid Opacity")
self.grid_opacity_lbl.setEnabled(False)
self.grid_opacity_slr = QSlider(Qt.Horizontal)
self.grid_opacity_slr.setFocusPolicy(Qt.StrongFocus)
self.grid_opacity_slr.setRange(0, 10)
self.grid_opacity_slr.setValue(5)
self.grid_opacity_slr.setTickInterval(1)
self.grid_opacity_slr.setSingleStep(1)
self.grid_opacity_slr.setTickPosition(QSlider.TicksBelow)
self.grid_opacity_slr.valueChanged.connect(
self.handle_grid_opacity_slider_mouse_release)
self.grid_opacity_slr.setEnabled(False)
self.reset_data_settings_btn = QPushButton("Reset Data Settings")
self.reset_data_settings_btn.clicked.connect(
self.handle_reset_data_settings_btn_clicked)
self.reset_chart_settings_btn = QPushButton("Reset Chart Settings")
self.reset_chart_settings_btn.clicked.connect(
self.handle_reset_chart_settings_btn_clicked)
self.curve_checkbox_panel = QWidget()
self.graph_drawing_settings_grpbx = QGroupBox("Graph Intervals")
self.graph_drawing_settings_grpbx.setAlignment(Qt.AlignTop)
self.axis_settings_grpbx = QGroupBox("Graph Appearance")
self.app = QApplication.instance()
self.setup_ui()
self.curve_settings_disp = None
self.axis_settings_disp = None
self.chart_data_export_disp = None
self.chart_data_import_disp = None
self.grid_alpha = 5
self.time_span_limit_hours = None
self.time_span_limit_minutes = None
self.time_span_limit_seconds = None
self.data_sampling_mode = ASYNC_DATA_SAMPLING
# If there is an imported config file, let's start TimeChart with the imported configuration data
if config_file:
importer = SettingsImporter(self)
try:
importer.import_settings(config_file)
except SettingsImporterException:
display_message_box(
QMessageBox.Critical, "Import Failure",
"Cannot import the file '{0}'. Check the log for the error details."
.format(config_file))
logger.exception(
"Cannot import the file '{0}'.".format(config_file))
def ui_filepath(self):
"""
The path to the UI file created by Qt Designer, if applicable.
"""
# No UI file is being used
return None
def ui_filename(self):
"""
The name the UI file created by Qt Designer, if applicable.
"""
# No UI file is being used
return None
def setup_ui(self):
"""
Initialize the widgets and layouts.
"""
self.setLayout(self.main_layout)
self.pv_layout.addWidget(self.pv_protocol_cmb)
self.pv_layout.addWidget(self.pv_name_line_edt)
self.pv_layout.addWidget(self.pv_connect_push_btn)
self.pv_add_panel.setLayout(self.pv_layout)
QTimer.singleShot(0, self.pv_name_line_edt.setFocus)
self.curve_settings_tab.setLayout(self.curves_tab_layout)
self.chart_settings_tab.setLayout(self.chart_settings_layout)
self.setup_chart_settings_layout()
self.data_settings_tab.setLayout(self.data_tab_layout)
self.setup_data_tab_layout()
self.tab_panel.addTab(self.curve_settings_tab, "Curves")
self.tab_panel.addTab(self.data_settings_tab, "Data")
self.tab_panel.addTab(self.chart_settings_tab, "Graph")
self.crosshair_settings_layout.addWidget(self.enable_crosshair_chk)
self.crosshair_settings_layout.addWidget(self.crosshair_coord_lbl)
self.zoom_x_layout.addWidget(self.zoom_in_x_btn)
self.zoom_x_layout.addWidget(self.zoom_out_x_btn)
self.zoom_y_layout.addWidget(self.zoom_in_y_btn)
self.zoom_y_layout.addWidget(self.zoom_out_y_btn)
self.view_all_reset_chart_layout.addWidget(self.reset_chart_btn)
self.view_all_reset_chart_layout.addWidget(self.view_all_btn)
self.pause_chart_layout.addWidget(self.pause_chart_btn)
self.import_export_data_layout.addWidget(self.import_data_btn)
self.import_export_data_layout.addWidget(self.export_data_btn)
self.chart_control_layout.addLayout(self.zoom_x_layout)
self.chart_control_layout.addLayout(self.zoom_y_layout)
self.chart_control_layout.addLayout(self.view_all_reset_chart_layout)
self.chart_control_layout.addLayout(self.pause_chart_layout)
self.chart_control_layout.addLayout(self.crosshair_settings_layout)
self.chart_control_layout.addLayout(self.import_export_data_layout)
self.chart_control_layout.insertSpacing(5, 30)
self.chart_layout.addWidget(self.chart)
self.chart_layout.addLayout(self.chart_control_layout)
self.chart_panel.setLayout(self.chart_layout)
self.splitter.addWidget(self.chart_panel)
self.splitter.addWidget(self.tab_panel)
self.splitter.setSizes([1, 0])
self.splitter.setHandleWidth(10)
self.splitter.setStretchFactor(0, 0)
self.splitter.setStretchFactor(1, 1)
self.charting_layout.addWidget(self.splitter)
self.body_layout.addWidget(self.pv_add_panel)
self.body_layout.addLayout(self.charting_layout)
self.body_layout.setSpacing(0)
self.body_layout.setContentsMargins(0, 0, 0, 0)
self.main_layout.addLayout(self.body_layout)
self.enable_chart_control_buttons(False)
handle = self.splitter.handle(1)
layout = QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
button = QToolButton(handle)
button.setArrowType(Qt.LeftArrow)
button.clicked.connect(lambda: self.handle_splitter_button(True))
layout.addWidget(button)
button = QToolButton(handle)
button.setArrowType(Qt.RightArrow)
button.clicked.connect(lambda: self.handle_splitter_button(False))
layout.addWidget(button)
handle.setLayout(layout)
def handle_splitter_button(self, left=True):
if left:
self.splitter.setSizes([1, 1])
else:
self.splitter.setSizes([1, 0])
def change_legend_font(self, font):
if font is None:
return
self.legend_font = font
items = self.chart.plotItem.legend.items
for i in items:
i[1].item.setFont(font)
i[1].resizeEvent(None)
i[1].updateGeometry()
def change_title_font(self, font):
current_text = self.chart.plotItem.titleLabel.text
args = {
"family": font.family,
"size": "{}pt".format(font.pointSize()),
"bold": font.bold(),
"italic": font.italic(),
}
self.chart.plotItem.titleLabel.setText(current_text, **args)
def handle_chart_font_changed(self, target):
if target not in ("title", "legend"):
return
dialog = QFontDialog(self)
dialog.setOption(QFontDialog.DontUseNativeDialog, True)
if target == "title":
dialog.fontSelected.connect(self.change_title_font)
else:
dialog.fontSelected.connect(self.change_legend_font)
dialog.open()
def setup_data_tab_layout(self):
self.chart_sync_mode_sync_radio.toggled.connect(
partial(self.handle_sync_mode_radio_toggle,
self.chart_sync_mode_sync_radio))
self.chart_sync_mode_async_radio.toggled.connect(
partial(self.handle_sync_mode_radio_toggle,
self.chart_sync_mode_async_radio))
self.chart_sync_mode_layout.addWidget(self.chart_sync_mode_sync_radio)
self.chart_sync_mode_layout.addWidget(self.chart_sync_mode_async_radio)
self.chart_sync_mode_grpbx.setLayout(self.chart_sync_mode_layout)
self.data_tab_layout.addWidget(self.chart_sync_mode_grpbx)
self.chart_limit_time_span_layout.addWidget(
self.chart_limit_time_span_lbl)
self.chart_limit_time_span_layout.addWidget(
self.chart_limit_time_span_hours_spin_box)
self.chart_limit_time_span_layout.addWidget(
self.chart_limit_time_span_minutes_spin_box)
self.chart_limit_time_span_layout.addWidget(
self.chart_limit_time_span_seconds_spin_box)
self.chart_limit_time_span_layout.addWidget(
self.chart_limit_time_span_activate_btn)
self.chart_limit_time_span_lbl.hide()
self.chart_limit_time_span_hours_spin_box.hide()
self.chart_limit_time_span_minutes_spin_box.hide()
self.chart_limit_time_span_seconds_spin_box.hide()
self.chart_limit_time_span_activate_btn.hide()
self.chart_limit_time_span_hours_spin_box.valueChanged.connect(
self.handle_time_span_changed)
self.chart_limit_time_span_minutes_spin_box.valueChanged.connect(
self.handle_time_span_changed)
self.chart_limit_time_span_seconds_spin_box.valueChanged.connect(
self.handle_time_span_changed)
self.chart_limit_time_span_chk.clicked.connect(
self.handle_limit_time_span_checkbox_clicked)
self.chart_limit_time_span_activate_btn.clicked.connect(
self.handle_chart_limit_time_span_activate_btn_clicked)
self.chart_interval_layout.addRow(self.chart_redraw_rate_lbl,
self.chart_redraw_rate_spin)
self.chart_interval_layout.addRow(
self.chart_data_sampling_rate_lbl,
self.chart_data_async_sampling_rate_spin)
self.graph_drawing_settings_layout.addLayout(
self.chart_interval_layout)
self.graph_drawing_settings_layout.addWidget(
self.chart_limit_time_span_chk)
self.graph_drawing_settings_layout.addLayout(
self.chart_limit_time_span_layout)
self.chart_ring_buffer_layout.addRow(self.chart_ring_buffer_size_lbl,
self.chart_ring_buffer_size_edt)
self.graph_drawing_settings_layout.addLayout(
self.chart_ring_buffer_layout)
self.graph_drawing_settings_grpbx.setLayout(
self.graph_drawing_settings_layout)
self.data_tab_layout.addWidget(self.graph_drawing_settings_grpbx)
self.chart_sync_mode_async_radio.toggled.emit(True)
self.data_tab_layout.addWidget(self.reset_data_settings_btn)
def setup_chart_settings_layout(self):
self.chart_title_layout.addWidget(self.chart_title_lbl)
self.chart_title_layout.addWidget(self.chart_title_line_edt)
self.chart_title_layout.addWidget(self.chart_title_font_btn)
self.title_settings_layout.addLayout(self.chart_title_layout)
legend_layout = QHBoxLayout()
legend_layout.addWidget(self.show_legend_chk)
legend_layout.addWidget(self.legend_font_btn)
self.title_settings_layout.addLayout(legend_layout)
self.title_settings_layout.addWidget(
self.chart_change_axis_settings_btn)
self.title_settings_grpbx.setLayout(self.title_settings_layout)
self.chart_settings_layout.addWidget(self.title_settings_grpbx)
self.graph_background_color_layout.addRow(self.background_color_lbl,
self.background_color_btn)
self.axis_settings_layout.addLayout(self.graph_background_color_layout)
self.axis_grid_color_layout.addRow(self.axis_color_lbl,
self.axis_color_btn)
self.axis_settings_layout.addLayout(self.axis_grid_color_layout)
self.axis_settings_layout.addWidget(self.show_x_grid_chk)
self.axis_settings_layout.addWidget(self.show_y_grid_chk)
self.axis_settings_layout.addWidget(self.grid_opacity_lbl)
self.axis_settings_layout.addWidget(self.grid_opacity_slr)
self.axis_settings_grpbx.setLayout(self.axis_settings_layout)
self.chart_settings_layout.addWidget(self.axis_settings_grpbx)
self.chart_settings_layout.addWidget(self.reset_chart_settings_btn)
self.update_datetime_timer.start(1000)
def add_curve(self):
"""
Add a new curve to the chart.
"""
pv_name = self._get_full_pv_name(self.pv_name_line_edt.text())
if pv_name and len(pv_name):
color = random_color(curve_colors_only=True)
for k, v in self.channel_map.items():
if color == v.color:
color = random_color(curve_colors_only=True)
self.add_y_channel(pv_name=pv_name,
curve_name=pv_name,
color=color)
self.handle_splitter_button(left=True)
def show_mouse_coordinates(self, x, y):
self.crosshair_coord_lbl.clear()
self.crosshair_coord_lbl.setText("x = {0:.3f}\ny = {1:.3f}".format(
x, y))
def handle_enable_crosshair_checkbox_clicked(self, is_checked):
self.chart.enableCrosshair(is_checked)
self.crosshair_coord_lbl.setVisible(is_checked)
self.chart.crosshair_position_updated.connect(
self.show_mouse_coordinates)
def add_y_channel(self,
pv_name,
curve_name,
color,
line_style=Qt.SolidLine,
line_width=2,
symbol=None,
symbol_size=None,
is_visible=True):
if pv_name in self.channel_map:
logger.error("'{0}' has already been added.".format(pv_name))
return
curve = self.chart.addYChannel(y_channel=pv_name,
name=curve_name,
color=color,
lineStyle=line_style,
lineWidth=line_width,
symbol=symbol,
symbolSize=symbol_size)
curve.show() if is_visible else curve.hide()
if self.show_legend_chk.isChecked():
self.change_legend_font(self.legend_font)
self.channel_map[pv_name] = curve
self.generate_pv_controls(pv_name, color)
self.enable_chart_control_buttons()
try:
self.app.add_connection(curve.channel)
except AttributeError:
# these methods are not needed on future versions of pydm
pass
def generate_pv_controls(self, pv_name, curve_color):
"""
Generate a set of widgets to manage the appearance of a curve. The set of widgets includes:
1. A checkbox which shows the curve on the chart if checked, and hide the curve if not
checked
2. Three buttons -- Modify..., Focus, and Remove. Modify... will bring up the Curve
Settings dialog. Focus adjusts the chart's zooming for the current curve.
Remove will delete the curve from the chart
Parameters
----------
pv_name: str
The name of the PV the current curve is being plotted for
curve_color : QColor
The color of the curve to paint for the checkbox label to help the user track the curve
to the checkbox
"""
individual_curve_layout = QVBoxLayout()
size_policy = QSizePolicy()
size_policy.setVerticalPolicy(QSizePolicy.Fixed)
size_policy.setHorizontalPolicy(QSizePolicy.Fixed)
individual_curve_grpbx = QGroupBox()
individual_curve_grpbx.setMinimumWidth(300)
individual_curve_grpbx.setMinimumHeight(120)
individual_curve_grpbx.setAlignment(Qt.AlignTop)
individual_curve_grpbx.setSizePolicy(size_policy)
individual_curve_grpbx.setObjectName(pv_name + "_grb")
individual_curve_grpbx.setLayout(individual_curve_layout)
checkbox = QCheckBox(parent=individual_curve_grpbx)
checkbox.setObjectName(pv_name + "_chb")
palette = checkbox.palette()
palette.setColor(QPalette.Active, QPalette.WindowText, curve_color)
checkbox.setPalette(palette)
display_name = pv_name.split("://")[1]
if len(display_name) > MAX_DISPLAY_PV_NAME_LENGTH:
# Only display max allowed number of characters of the PV Name
display_name = display_name[
:int(MAX_DISPLAY_PV_NAME_LENGTH / 2) - 1] + "..." + \
display_name[
-int(MAX_DISPLAY_PV_NAME_LENGTH / 2) + 2:]
checkbox.setText(display_name)
data_text = QLabel(parent=individual_curve_grpbx)
data_text.setWordWrap(True)
data_text.setObjectName(pv_name + "_lbl")
data_text.setPalette(palette)
checkbox.setChecked(True)
checkbox.toggled.connect(
partial(self.handle_curve_chkbox_toggled, checkbox))
if not self.chart.findCurve(pv_name).isVisible():
checkbox.setChecked(False)
modify_curve_btn = QPushButton("Modify...",
parent=individual_curve_grpbx)
modify_curve_btn.setObjectName(pv_name + "_btn_modify")
modify_curve_btn.setMaximumWidth(80)
modify_curve_btn.clicked.connect(
partial(self.display_curve_settings_dialog, pv_name))
focus_curve_btn = QPushButton("Focus", parent=individual_curve_grpbx)
focus_curve_btn.setObjectName(pv_name + "_btn_focus")
focus_curve_btn.setMaximumWidth(80)
focus_curve_btn.clicked.connect(partial(self.focus_curve, pv_name))
clear_curve_btn = QPushButton("Clear", parent=individual_curve_grpbx)
clear_curve_btn.setObjectName(pv_name + "_btn_clear")
clear_curve_btn.setMaximumWidth(80)
clear_curve_btn.clicked.connect(partial(self.clear_curve, pv_name))
# annotate_curve_btn = QPushButton("Annotate...",
# parent=individual_curve_grpbx)
# annotate_curve_btn.setObjectName(pv_name+"_btn_ann")
# annotate_curve_btn.setMaximumWidth(80)
# annotate_curve_btn.clicked.connect(
# partial(self.annotate_curve, pv_name))
remove_curve_btn = QPushButton("Remove", parent=individual_curve_grpbx)
remove_curve_btn.setObjectName(pv_name + "_btn_remove")
remove_curve_btn.setMaximumWidth(80)
remove_curve_btn.clicked.connect(partial(self.remove_curve, pv_name))
curve_btn_layout = QHBoxLayout()
curve_btn_layout.setSpacing(5)
curve_btn_layout.addWidget(modify_curve_btn)
curve_btn_layout.addWidget(focus_curve_btn)
curve_btn_layout.addWidget(clear_curve_btn)
# curve_btn_layout.addWidget(annotate_curve_btn)
curve_btn_layout.addWidget(remove_curve_btn)
individual_curve_layout.addWidget(checkbox)
individual_curve_layout.addWidget(data_text)
individual_curve_layout.addLayout(curve_btn_layout)
self.curve_settings_layout.addWidget(individual_curve_grpbx)
self.tab_panel.setCurrentIndex(0)
def handle_curve_chkbox_toggled(self, checkbox):
"""
Handle a checkbox's checked and unchecked events.
If a checkbox is checked, find the curve from the channel map. If found, re-draw the curve with its previous
appearance settings.
If a checkbox is unchecked, remove the curve from the chart, but keep the cached data in the channel map.
Parameters
----------
checkbox : QCheckBox
The current checkbox being toggled
"""
pv_name = self._get_full_pv_name(checkbox.text())
if checkbox.isChecked():
curve = self.channel_map.get(pv_name, None)
if curve:
curve.show()
self.chart.addLegendItem(curve, pv_name,
self.show_legend_chk.isChecked())
self.change_legend_font(self.legend_font)
else:
curve = self.chart.findCurve(pv_name)
if curve:
curve.hide()
self.chart.removeLegendItem(pv_name)
def display_curve_settings_dialog(self, pv_name):
"""
Bring up the Curve Settings dialog to modify the appearance of a curve.
Parameters
----------
pv_name : str
The name of the PV the curve is being plotted for
"""
self.curve_settings_disp = CurveSettingsDisplay(self, pv_name)
self.curve_settings_disp.show()
def focus_curve(self, pv_name):
curve = self.chart.findCurve(pv_name)
if curve:
self.chart.plotItem.setYRange(curve.minY, curve.maxY, padding=0)
def clear_curve(self, pv_name):
curve = self.chart.findCurve(pv_name)
if curve:
curve.initialize_buffer()
def annotate_curve(self, pv_name):
curve = self.chart.findCurve(pv_name)
if curve:
annot = TextItem(
html=
'<div style="text-align: center"><span style="color: #FFF;">This is the'
'</span><br><span style="color: #FF0; font-size: 16pt;">PEAK</span></div>',
anchor=(-0.3, 0.5),
border='w',
fill=(0, 0, 255, 100))
self.chart.annotateCurve(curve, annot)
def remove_curve(self, pv_name):
"""
Remove a curve from the chart permanently. This will also clear the channel map cache from retaining the
removed curve's appearance settings.
Parameters
----------
pv_name : str
The name of the PV the curve is being plotted for
"""
curve = self.chart.findCurve(pv_name)
if curve:
try:
self.app.remove_connection(curve.channel)
except AttributeError:
# these methods are not needed on future versions of pydm
pass
self.chart.removeYChannel(curve)
del self.channel_map[pv_name]
self.chart.removeLegendItem(pv_name)
widget = self.findChild(QGroupBox, pv_name + "_grb")
if widget:
widget.deleteLater()
if len(self.chart.getCurves()) < 1:
self.enable_chart_control_buttons(False)
self.show_legend_chk.setChecked(False)
def handle_title_text_changed(self, new_text):
self.chart.setPlotTitle(new_text)
def handle_change_axis_settings_clicked(self):
self.axis_settings_disp = AxisSettingsDisplay(self)
self.axis_settings_disp.show()
def handle_limit_time_span_checkbox_clicked(self, is_checked):
self.chart_limit_time_span_lbl.setVisible(is_checked)
self.chart_limit_time_span_hours_spin_box.setVisible(is_checked)
self.chart_limit_time_span_minutes_spin_box.setVisible(is_checked)
self.chart_limit_time_span_seconds_spin_box.setVisible(is_checked)
self.chart_limit_time_span_activate_btn.setVisible(is_checked)
self.chart_ring_buffer_size_lbl.setDisabled(is_checked)
self.chart_ring_buffer_size_edt.setDisabled(is_checked)
if not is_checked:
self.chart_limit_time_span_chk.setText(self.limit_time_plan_text)
def handle_time_span_changed(self):
self.time_span_limit_hours = self.chart_limit_time_span_hours_spin_box.value(
)
self.time_span_limit_minutes = self.chart_limit_time_span_minutes_spin_box.value(
)
self.time_span_limit_seconds = self.chart_limit_time_span_seconds_spin_box.value(
)
status = self.time_span_limit_hours > 0 or self.time_span_limit_minutes > 0 or self.time_span_limit_seconds > 0
self.chart_limit_time_span_activate_btn.setEnabled(status)
def handle_chart_limit_time_span_activate_btn_clicked(self):
timeout_milliseconds = (self.time_span_limit_hours * 3600 +
self.time_span_limit_minutes * 60 +
self.time_span_limit_seconds) * 1000
self.chart.setTimeSpan(timeout_milliseconds / 1000.0)
self.chart_ring_buffer_size_edt.setText(str(
self.chart.getBufferSize()))
def handle_buffer_size_changed(self):
try:
new_buffer_size = int(self.chart_ring_buffer_size_edt.text())
if new_buffer_size and int(new_buffer_size) >= MINIMUM_BUFFER_SIZE:
self.chart.setBufferSize(new_buffer_size)
except ValueError:
display_message_box(QMessageBox.Critical, "Invalid Values",
"Only integer values are accepted.")
def handle_redraw_rate_changed(self):
self.chart.maxRedrawRate = self.chart_redraw_rate_spin.value()
def handle_data_sampling_rate_changed(self):
# The chart expects the value in milliseconds
sampling_rate_seconds = 1.0 / self.chart_data_async_sampling_rate_spin.value(
)
buffer_size = self.chart.getBufferSize()
self.chart.setUpdateInterval(sampling_rate_seconds)
if self.chart.getBufferSize() < buffer_size:
self.chart.setBufferSize(buffer_size)
self.chart_ring_buffer_size_edt.setText(str(
self.chart.getBufferSize()))
def handle_background_color_button_clicked(self):
selected_color = QColorDialog.getColor()
self.chart.setBackgroundColor(selected_color)
self.background_color_btn.setStyleSheet("background-color: " +
selected_color.name())
def handle_axis_color_button_clicked(self):
selected_color = QColorDialog.getColor()
self.chart.setAxisColor(selected_color)
self.axis_color_btn.setStyleSheet("background-color: " +
selected_color.name())
def handle_grid_opacity_slider_mouse_release(self):
self.grid_alpha = float(self.grid_opacity_slr.value()) / 10.0
self.chart.setShowXGrid(self.show_x_grid_chk.isChecked(),
self.grid_alpha)
self.chart.setShowYGrid(self.show_y_grid_chk.isChecked(),
self.grid_alpha)
def handle_show_x_grid_checkbox_clicked(self, is_checked):
self.chart.setShowXGrid(is_checked, self.grid_alpha)
self.grid_opacity_lbl.setEnabled(is_checked
or self.show_y_grid_chk.isChecked())
self.grid_opacity_slr.setEnabled(is_checked
or self.show_y_grid_chk.isChecked())
def handle_show_y_grid_checkbox_clicked(self, is_checked):
self.chart.setShowYGrid(is_checked, self.grid_alpha)
self.grid_opacity_lbl.setEnabled(is_checked
or self.show_x_grid_chk.isChecked())
self.grid_opacity_slr.setEnabled(is_checked
or self.show_x_grid_chk.isChecked())
def handle_show_legend_checkbox_clicked(self, is_checked):
self.chart.setShowLegend(is_checked)
def handle_export_data_btn_clicked(self):
self.chart_data_export_disp = ChartDataExportDisplay(self)
self.chart_data_export_disp.show()
def handle_import_data_btn_clicked(self):
open_file_info = QFileDialog.getOpenFileName(
self,
caption="Open File",
directory=os.path.expanduser('~'),
filter=IMPORT_FILE_FORMAT)
open_filename = open_file_info[0]
if open_filename:
try:
importer = SettingsImporter(self)
importer.import_settings(open_filename)
except SettingsImporterException:
display_message_box(
QMessageBox.Critical, "Import Failure",
"Cannot import the file '{0}'. Check the log for the error details."
.format(open_filename))
logger.exception(
"Cannot import the file '{0}'".format(open_filename))
def handle_sync_mode_radio_toggle(self, radio_btn):
if radio_btn.isChecked():
if radio_btn.text() == "Synchronous":
self.data_sampling_mode = SYNC_DATA_SAMPLING
self.chart_data_sampling_rate_lbl.hide()
self.chart_data_async_sampling_rate_spin.hide()
self.chart.resetTimeSpan()
self.chart_limit_time_span_chk.setChecked(False)
self.chart_limit_time_span_chk.clicked.emit(False)
self.chart_limit_time_span_chk.hide()
self.chart.setUpdatesAsynchronously(False)
elif radio_btn.text() == "Asynchronous":
self.data_sampling_mode = ASYNC_DATA_SAMPLING
self.chart_data_sampling_rate_lbl.show()
self.chart_data_async_sampling_rate_spin.show()
self.chart_limit_time_span_chk.show()
self.chart.setUpdatesAsynchronously(True)
def handle_zoom_in_btn_clicked(self, axis, is_zoom_in):
scale_factor = 0.5
if not is_zoom_in:
scale_factor += 1.0
if axis == "x":
self.chart.getViewBox().scaleBy(x=scale_factor)
elif axis == "y":
self.chart.getViewBox().scaleBy(y=scale_factor)
def handle_view_all_button_clicked(self):
self.chart.plotItem.getViewBox().autoRange()
def handle_pause_chart_btn_clicked(self):
if self.chart.pausePlotting():
self.pause_chart_btn.setIcon(self.pause_icon)
else:
self.pause_chart_btn.setIcon(self.play_icon)
def handle_reset_chart_btn_clicked(self):
self.chart.getViewBox().setXRange(DEFAULT_X_MIN, 0)
self.chart.resetAutoRangeY()
@Slot()
def handle_reset_chart_settings_btn_clicked(self):
self.chart.setBackgroundColor(DEFAULT_CHART_BACKGROUND_COLOR)
self.background_color_btn.setStyleSheet(
"background-color: " + DEFAULT_CHART_BACKGROUND_COLOR.name())
self.chart.setAxisColor(DEFAULT_CHART_AXIS_COLOR)
self.axis_color_btn.setStyleSheet("background-color: " +
DEFAULT_CHART_AXIS_COLOR.name())
self.grid_opacity_slr.setValue(5)
self.show_x_grid_chk.setChecked(False)
self.show_x_grid_chk.clicked.emit(False)
self.show_y_grid_chk.setChecked(False)
self.show_y_grid_chk.clicked.emit(False)
self.show_legend_chk.setChecked(False)
self.chart.setShowXGrid(False)
self.chart.setShowYGrid(False)
self.chart.setShowLegend(False)
@Slot()
def handle_reset_data_settings_btn_clicked(self):
self.chart_ring_buffer_size_edt.setText(str(DEFAULT_BUFFER_SIZE))
self.chart_redraw_rate_spin.setValue(DEFAULT_REDRAW_RATE_HZ)
self.handle_redraw_rate_changed()
self.chart_data_async_sampling_rate_spin.setValue(
DEFAULT_DATA_SAMPLING_RATE_HZ)
self.chart_data_sampling_rate_lbl.hide()
self.chart_data_async_sampling_rate_spin.hide()
self.chart_sync_mode_async_radio.setChecked(True)
self.chart_sync_mode_async_radio.toggled.emit(True)
self.chart_limit_time_span_chk.setChecked(False)
self.chart_limit_time_span_chk.setText(self.limit_time_plan_text)
self.chart_limit_time_span_chk.clicked.emit(False)
self.chart.setUpdatesAsynchronously(True)
self.chart.resetTimeSpan()
self.chart.resetUpdateInterval()
self.chart.setBufferSize(DEFAULT_BUFFER_SIZE)
def enable_chart_control_buttons(self, enabled=True):
self.zoom_in_x_btn.setEnabled(enabled)
self.zoom_out_x_btn.setEnabled(enabled)
self.zoom_in_y_btn.setEnabled(enabled)
self.zoom_out_y_btn.setEnabled(enabled)
self.view_all_btn.setEnabled(enabled)
self.reset_chart_btn.setEnabled(enabled)
self.pause_chart_btn.setIcon(self.pause_icon)
self.pause_chart_btn.setEnabled(enabled)
self.export_data_btn.setEnabled(enabled)
def _get_full_pv_name(self, pv_name):
"""
Append the protocol to the PV Name.
Parameters
----------
pv_name : str
The name of the PV the curve is being plotted for
"""
if pv_name and "://" not in pv_name:
pv_name = ''.join([self.pv_protocol_cmb.currentText(), pv_name])
return pv_name
def handle_update_datetime_timer_timeout(self):
current_label = self.chart.getBottomAxisLabel()
new_label = "Current Time: " + TimeChartDisplay.get_current_datetime()
if X_AXIS_LABEL_SEPARATOR in current_label:
current_label = current_label[current_label.
find(X_AXIS_LABEL_SEPARATOR) +
len(X_AXIS_LABEL_SEPARATOR):]
new_label += X_AXIS_LABEL_SEPARATOR + current_label
self.chart.setLabel("bottom", text=new_label)
def update_curve_data(self, curve):
"""
Determine if the PV is active. If not, disable the related PV controls.
If the PV is active, update the PV controls' states.
Parameters
----------
curve : PlotItem
A PlotItem, i.e. a plot, to draw on the chart.
"""
pv_name = curve.address
min_y = curve.minY if curve.minY else 0
max_y = curve.maxY if curve.maxY else 0
current_y = curve.data_buffer[1, -1]
grb = self.findChild(QGroupBox, pv_name + "_grb")
lbl = grb.findChild(QLabel, pv_name + "_lbl")
lbl.setText("(yMin = {0:.3f}, yMax = {1:.3f}) y = {2:.3f}".format(
min_y, max_y, current_y))
chb = grb.findChild(QCheckBox, pv_name + "_chb")
connected = curve.connected
if connected and chb.isEnabled():
return
chb.setEnabled(connected)
btn_modify = grb.findChild(QPushButton, pv_name + "_btn_modify")
btn_modify.setEnabled(connected)
btn_focus = grb.findChild(QPushButton, pv_name + "_btn_focus")
btn_focus.setEnabled(connected)
# btn_ann = grb.findChild(QPushButton, pv_name + "_btn_ann")
# btn_ann.setEnabled(connected)
@staticmethod
def get_current_datetime():
current_date = datetime.datetime.now().strftime("%b %d, %Y")
current_time = datetime.datetime.now().strftime("%H:%M:%S")
current_datetime = current_time + ' (' + current_date + ')'
return current_datetime
@property
def gridAlpha(self):
return self.grid_alpha
def __init__(self, layer):
super().__init__(layer)
self.layer.events.interpolation2d.connect(
self._on_interpolation_change)
self.layer.events.interpolation3d.connect(
self._on_interpolation_change)
self.layer.events.rendering.connect(self._on_rendering_change)
self.layer.events.iso_threshold.connect(self._on_iso_threshold_change)
self.layer.events.attenuation.connect(self._on_attenuation_change)
self.layer.events._ndisplay.connect(self._on_ndisplay_change)
self.layer.events.depiction.connect(self._on_depiction_change)
self.layer.plane.events.thickness.connect(
self._on_plane_thickness_change)
self.interpComboBox = QComboBox(self)
self.interpComboBox.activated[str].connect(self.changeInterpolation)
self.interpLabel = QLabel(trans._('interpolation:'))
renderComboBox = QComboBox(self)
rendering_options = [i.value for i in ImageRendering]
renderComboBox.addItems(rendering_options)
index = renderComboBox.findText(self.layer.rendering,
Qt.MatchFixedString)
renderComboBox.setCurrentIndex(index)
renderComboBox.activated[str].connect(self.changeRendering)
self.renderComboBox = renderComboBox
self.renderLabel = QLabel(trans._('rendering:'))
self.depictionComboBox = QComboBox(self)
depiction_options = [d.value for d in VolumeDepiction]
self.depictionComboBox.addItems(depiction_options)
index = self.depictionComboBox.findText(self.layer.depiction,
Qt.MatchFixedString)
self.depictionComboBox.setCurrentIndex(index)
self.depictionComboBox.activated[str].connect(self.changeDepiction)
self.depictionLabel = QLabel(trans._('depiction:'))
# plane controls
self.planeNormalButtons = PlaneNormalButtons(self)
self.planeNormalLabel = QLabel(trans._('plane normal:'))
action_manager.bind_button(
'napari:orient_plane_normal_along_z',
self.planeNormalButtons.zButton,
)
action_manager.bind_button(
'napari:orient_plane_normal_along_y',
self.planeNormalButtons.yButton,
)
action_manager.bind_button(
'napari:orient_plane_normal_along_x',
self.planeNormalButtons.xButton,
)
action_manager.bind_button(
'napari:orient_plane_normal_along_view_direction',
self.planeNormalButtons.obliqueButton,
)
self.planeThicknessSlider = QLabeledDoubleSlider(Qt.Horizontal, self)
self.planeThicknessLabel = QLabel(trans._('plane thickness:'))
self.planeThicknessSlider.setFocusPolicy(Qt.NoFocus)
self.planeThicknessSlider.setMinimum(1)
self.planeThicknessSlider.setMaximum(50)
self.planeThicknessSlider.setValue(self.layer.plane.thickness)
self.planeThicknessSlider.valueChanged.connect(
self.changePlaneThickness)
sld = QSlider(Qt.Horizontal, parent=self)
sld.setFocusPolicy(Qt.NoFocus)
sld.setMinimum(0)
sld.setMaximum(100)
sld.setSingleStep(1)
sld.setValue(int(self.layer.iso_threshold * 100))
sld.valueChanged.connect(self.changeIsoThreshold)
self.isoThresholdSlider = sld
self.isoThresholdLabel = QLabel(trans._('iso threshold:'))
sld = QSlider(Qt.Horizontal, parent=self)
sld.setFocusPolicy(Qt.NoFocus)
sld.setMinimum(0)
sld.setMaximum(100)
sld.setSingleStep(1)
sld.setValue(int(self.layer.attenuation * 200))
sld.valueChanged.connect(self.changeAttenuation)
self.attenuationSlider = sld
self.attenuationLabel = QLabel(trans._('attenuation:'))
self._on_ndisplay_change()
colormap_layout = QHBoxLayout()
if hasattr(self.layer, 'rgb') and self.layer.rgb:
colormap_layout.addWidget(QLabel("RGB"))
self.colormapComboBox.setVisible(False)
self.colorbarLabel.setVisible(False)
else:
colormap_layout.addWidget(self.colorbarLabel)
colormap_layout.addWidget(self.colormapComboBox)
colormap_layout.addStretch(1)
self.layout().addRow(trans._('opacity:'), self.opacitySlider)
self.layout().addRow(trans._('contrast limits:'),
self.contrastLimitsSlider)
self.layout().addRow(trans._('auto-contrast:'), self.autoScaleBar)
self.layout().addRow(trans._('gamma:'), self.gammaSlider)
self.layout().addRow(trans._('colormap:'), colormap_layout)
self.layout().addRow(trans._('blending:'), self.blendComboBox)
self.layout().addRow(self.interpLabel, self.interpComboBox)
self.layout().addRow(self.depictionLabel, self.depictionComboBox)
self.layout().addRow(self.renderLabel, self.renderComboBox)
self.layout().addRow(self.isoThresholdLabel, self.isoThresholdSlider)
self.layout().addRow(self.attenuationLabel, self.attenuationSlider)
self.layout().addRow(self.planeNormalLabel, self.planeNormalButtons)
self.layout().addRow(self.planeThicknessLabel,
self.planeThicknessSlider)
def __init__(self, layer):
super().__init__(layer)
self.layer.events.n_dimensional.connect(self._on_n_dim_change)
self.layer.events.symbol.connect(self._on_symbol_change)
self.layer.events.size.connect(self._on_size_change)
self.layer.events.edge_color.connect(self._on_edge_color_change)
self.layer.events.face_color.connect(self._on_face_color_change)
sld = QSlider(Qt.Horizontal, self)
sld.setFocusPolicy(Qt.NoFocus)
sld.setFixedWidth(110)
sld.setMinimum(0)
sld.setMaximum(100)
sld.setSingleStep(1)
value = self.layer.size
if isinstance(value, Iterable):
if isinstance(value, list):
value = np.asarray(value)
value = value.mean()
sld.setValue(int(value))
sld.valueChanged[int].connect(lambda value=sld: self.changeSize(value))
self.sizeSlider = sld
self.grid_layout.addWidget(QLabel('size:'), 3, 0)
self.grid_layout.addWidget(sld, 3, 1)
face_comboBox = QComboBox()
colors = self.layer._colors
for c in colors:
face_comboBox.addItem(c)
index = face_comboBox.findText(self.layer.face_color,
Qt.MatchFixedString)
face_comboBox.setCurrentIndex(index)
face_comboBox.activated[str].connect(
lambda text=face_comboBox: self.changeFaceColor(text))
self.faceComboBox = face_comboBox
self.grid_layout.addWidget(QLabel('face_color:'), 4, 0)
self.grid_layout.addWidget(face_comboBox, 4, 1)
edge_comboBox = QComboBox()
colors = self.layer._colors
for c in colors:
edge_comboBox.addItem(c)
index = edge_comboBox.findText(self.layer.edge_color,
Qt.MatchFixedString)
edge_comboBox.setCurrentIndex(index)
edge_comboBox.activated[str].connect(
lambda text=edge_comboBox: self.changeEdgeColor(text))
self.edgeComboBox = edge_comboBox
self.grid_layout.addWidget(QLabel('edge_color:'), 5, 0)
self.grid_layout.addWidget(edge_comboBox, 5, 1)
symbol_comboBox = QComboBox()
for s in Symbol:
symbol_comboBox.addItem(str(s))
index = symbol_comboBox.findText(self.layer.symbol,
Qt.MatchFixedString)
symbol_comboBox.setCurrentIndex(index)
symbol_comboBox.activated[str].connect(
lambda text=symbol_comboBox: self.changeSymbol(text))
self.symbolComboBox = symbol_comboBox
self.grid_layout.addWidget(QLabel('symbol:'), 6, 0)
self.grid_layout.addWidget(symbol_comboBox, 6, 1)
ndim_cb = QCheckBox()
ndim_cb.setToolTip('N-dimensional markers')
ndim_cb.setChecked(self.layer.n_dimensional)
ndim_cb.stateChanged.connect(
lambda state=ndim_cb: self.change_ndim(state))
self.ndimCheckBox = ndim_cb
self.grid_layout.addWidget(QLabel('n-dim:'), 7, 0)
self.grid_layout.addWidget(ndim_cb, 7, 1)
self.setExpanded(False)
def __init__(self, layer):
super().__init__(layer)
self.layer.events.mode.connect(self.set_mode)
self.layer.events.edge_width.connect(self._on_edge_width_change)
self.layer.events.edge_color.connect(self._on_edge_color_change)
self.layer.events.face_color.connect(self._on_face_color_change)
self.layer.events.editable.connect(self._on_editable_change)
sld = QSlider(Qt.Horizontal)
sld.setFocusPolicy(Qt.NoFocus)
sld.setMinimum(0)
sld.setMaximum(40)
sld.setSingleStep(1)
value = self.layer.edge_width
if isinstance(value, Iterable):
if isinstance(value, list):
value = np.asarray(value)
value = value.mean()
sld.setValue(int(value))
sld.valueChanged[int].connect(
lambda value=sld: self.changeWidth(value)
)
self.widthSlider = sld
face_comboBox = QComboBox()
colors = self.layer._colors
for c in colors:
face_comboBox.addItem(c)
face_comboBox.activated[str].connect(
lambda text=face_comboBox: self.changeFaceColor(text)
)
self.faceComboBox = face_comboBox
self.faceColorSwatch = QFrame()
self.faceColorSwatch.setObjectName('swatch')
self.faceColorSwatch.setToolTip('Face color swatch')
self._on_face_color_change(None)
edge_comboBox = QComboBox()
colors = self.layer._colors
for c in colors:
edge_comboBox.addItem(c)
edge_comboBox.activated[str].connect(
lambda text=edge_comboBox: self.changeEdgeColor(text)
)
self.edgeComboBox = edge_comboBox
self.edgeColorSwatch = QFrame()
self.edgeColorSwatch.setObjectName('swatch')
self.edgeColorSwatch.setToolTip('Edge color swatch')
self._on_edge_color_change(None)
self.select_button = QtModeButton(
layer, 'select', Mode.SELECT, 'Select shapes'
)
self.direct_button = QtModeButton(
layer, 'direct', Mode.DIRECT, 'Select vertices'
)
self.panzoom_button = QtModeButton(
layer, 'zoom', Mode.PAN_ZOOM, 'Pan/zoom'
)
self.rectangle_button = QtModeButton(
layer, 'rectangle', Mode.ADD_RECTANGLE, 'Add rectangles'
)
self.ellipse_button = QtModeButton(
layer, 'ellipse', Mode.ADD_ELLIPSE, 'Add ellipses'
)
self.line_button = QtModeButton(
layer, 'line', Mode.ADD_LINE, 'Add lines'
)
self.path_button = QtModeButton(
layer, 'path', Mode.ADD_PATH, 'Add paths'
)
self.polygon_button = QtModeButton(
layer, 'polygon', Mode.ADD_POLYGON, 'Add polygons'
)
self.vertex_insert_button = QtModeButton(
layer, 'vertex_insert', Mode.VERTEX_INSERT, 'Insert vertex'
)
self.vertex_remove_button = QtModeButton(
layer, 'vertex_remove', Mode.VERTEX_REMOVE, 'Remove vertex'
)
self.move_front_button = QtMoveFrontButton(layer)
self.move_back_button = QtMoveBackButton(layer)
self.delete_button = QtDeleteShapeButton(layer)
self.panzoom_button.setChecked(True)
self.button_group = QButtonGroup(self)
self.button_group.addButton(self.select_button)
self.button_group.addButton(self.direct_button)
self.button_group.addButton(self.panzoom_button)
self.button_group.addButton(self.rectangle_button)
self.button_group.addButton(self.ellipse_button)
self.button_group.addButton(self.line_button)
self.button_group.addButton(self.path_button)
self.button_group.addButton(self.polygon_button)
self.button_group.addButton(self.vertex_insert_button)
self.button_group.addButton(self.vertex_remove_button)
button_grid = QGridLayout()
button_grid.addWidget(self.vertex_remove_button, 0, 1)
button_grid.addWidget(self.vertex_insert_button, 0, 2)
button_grid.addWidget(self.delete_button, 0, 3)
button_grid.addWidget(self.direct_button, 0, 4)
button_grid.addWidget(self.select_button, 0, 5)
button_grid.addWidget(self.panzoom_button, 0, 6)
button_grid.addWidget(self.move_back_button, 1, 0)
button_grid.addWidget(self.move_front_button, 1, 1)
button_grid.addWidget(self.ellipse_button, 1, 2)
button_grid.addWidget(self.rectangle_button, 1, 3)
button_grid.addWidget(self.polygon_button, 1, 4)
button_grid.addWidget(self.line_button, 1, 5)
button_grid.addWidget(self.path_button, 1, 6)
button_grid.setColumnStretch(2, 2)
button_grid.setSpacing(4)
# grid_layout created in QtLayerControls
# addWidget(widget, row, column, [row_span, column_span])
self.grid_layout.addLayout(button_grid, 0, 0, 1, 3)
self.grid_layout.addWidget(QLabel('opacity:'), 1, 0)
self.grid_layout.addWidget(self.opacitySilder, 1, 1, 1, 2)
self.grid_layout.addWidget(QLabel('edge width:'), 2, 0)
self.grid_layout.addWidget(self.widthSlider, 2, 1, 1, 2)
self.grid_layout.addWidget(QLabel('blending:'), 3, 0)
self.grid_layout.addWidget(self.blendComboBox, 3, 1, 1, 2)
self.grid_layout.addWidget(QLabel('face color:'), 4, 0)
self.grid_layout.addWidget(self.faceComboBox, 4, 2)
self.grid_layout.addWidget(self.faceColorSwatch, 4, 1)
self.grid_layout.addWidget(QLabel('edge color:'), 5, 0)
self.grid_layout.addWidget(self.edgeComboBox, 5, 2)
self.grid_layout.addWidget(self.edgeColorSwatch, 5, 1)
self.grid_layout.setRowStretch(6, 1)
self.grid_layout.setColumnStretch(1, 1)
self.grid_layout.setSpacing(4)
def __init__(self, layer):
super().__init__(layer)
self.layer.events.mode.connect(self._on_mode_change)
self.layer.events.edge_width.connect(self._on_edge_width_change)
self.layer.events.current_edge_color.connect(
self._on_current_edge_color_change)
self.layer.events.current_face_color.connect(
self._on_current_face_color_change)
self.layer.events.editable.connect(self._on_editable_change)
self.layer.text.events.visible.connect(self._on_text_visibility_change)
sld = QSlider(Qt.Horizontal)
sld.setFocusPolicy(Qt.NoFocus)
sld.setMinimum(0)
sld.setMaximum(40)
sld.setSingleStep(1)
value = self.layer.current_edge_width
if isinstance(value, Iterable):
if isinstance(value, list):
value = np.asarray(value)
value = value.mean()
sld.setValue(int(value))
sld.valueChanged.connect(self.changeWidth)
self.widthSlider = sld
self.select_button = QtModeRadioButton(layer,
'select',
Mode.SELECT,
tooltip='Select shapes')
self.direct_button = QtModeRadioButton(layer,
'direct',
Mode.DIRECT,
tooltip='Select vertices')
self.panzoom_button = QtModeRadioButton(layer,
'zoom',
Mode.PAN_ZOOM,
tooltip='Pan/zoom',
checked=True)
self.rectangle_button = QtModeRadioButton(layer,
'rectangle',
Mode.ADD_RECTANGLE,
tooltip='Add rectangles')
self.ellipse_button = QtModeRadioButton(layer,
'ellipse',
Mode.ADD_ELLIPSE,
tooltip='Add ellipses')
self.line_button = QtModeRadioButton(layer,
'line',
Mode.ADD_LINE,
tooltip='Add lines')
self.path_button = QtModeRadioButton(layer,
'path',
Mode.ADD_PATH,
tooltip='Add paths')
self.polygon_button = QtModeRadioButton(layer,
'polygon',
Mode.ADD_POLYGON,
tooltip='Add polygons')
self.vertex_insert_button = QtModeRadioButton(layer,
'vertex_insert',
Mode.VERTEX_INSERT,
tooltip='Insert vertex')
self.vertex_remove_button = QtModeRadioButton(layer,
'vertex_remove',
Mode.VERTEX_REMOVE,
tooltip='Remove vertex')
self.move_front_button = QtModePushButton(
layer,
'move_front',
slot=self.layer.move_to_front,
tooltip='Move to front',
)
self.move_back_button = QtModePushButton(
layer,
'move_back',
slot=self.layer.move_to_back,
tooltip='Move to back',
)
self.delete_button = QtModePushButton(
layer,
'delete_shape',
slot=self.layer.remove_selected,
tooltip='Delete selected shapes',
)
self.button_group = QButtonGroup(self)
self.button_group.addButton(self.select_button)
self.button_group.addButton(self.direct_button)
self.button_group.addButton(self.panzoom_button)
self.button_group.addButton(self.rectangle_button)
self.button_group.addButton(self.ellipse_button)
self.button_group.addButton(self.line_button)
self.button_group.addButton(self.path_button)
self.button_group.addButton(self.polygon_button)
self.button_group.addButton(self.vertex_insert_button)
self.button_group.addButton(self.vertex_remove_button)
button_grid = QGridLayout()
button_grid.addWidget(self.vertex_remove_button, 0, 2)
button_grid.addWidget(self.vertex_insert_button, 0, 3)
button_grid.addWidget(self.delete_button, 0, 4)
button_grid.addWidget(self.direct_button, 0, 5)
button_grid.addWidget(self.select_button, 0, 6)
button_grid.addWidget(self.panzoom_button, 0, 7)
button_grid.addWidget(self.move_back_button, 1, 1)
button_grid.addWidget(self.move_front_button, 1, 2)
button_grid.addWidget(self.ellipse_button, 1, 3)
button_grid.addWidget(self.rectangle_button, 1, 4)
button_grid.addWidget(self.polygon_button, 1, 5)
button_grid.addWidget(self.line_button, 1, 6)
button_grid.addWidget(self.path_button, 1, 7)
button_grid.setContentsMargins(5, 0, 0, 5)
button_grid.setColumnStretch(0, 1)
button_grid.setSpacing(4)
self.faceColorEdit = QColorSwatchEdit(
initial_color=self.layer.current_face_color,
tooltip='click to set current face color',
)
self._on_current_face_color_change()
self.edgeColorEdit = QColorSwatchEdit(
initial_color=self.layer.current_edge_color,
tooltip='click to set current edge color',
)
self._on_current_edge_color_change()
self.faceColorEdit.color_changed.connect(self.changeFaceColor)
self.edgeColorEdit.color_changed.connect(self.changeEdgeColor)
text_disp_cb = QCheckBox()
text_disp_cb.setToolTip('toggle text visibility')
text_disp_cb.setChecked(self.layer.text.visible)
text_disp_cb.stateChanged.connect(self.change_text_visibility)
self.textDispCheckBox = text_disp_cb
# grid_layout created in QtLayerControls
# addWidget(widget, row, column, [row_span, column_span])
self.grid_layout.addLayout(button_grid, 0, 0, 1, 2)
self.grid_layout.addWidget(QLabel('opacity:'), 1, 0)
self.grid_layout.addWidget(self.opacitySlider, 1, 1)
self.grid_layout.addWidget(QLabel('edge width:'), 2, 0)
self.grid_layout.addWidget(self.widthSlider, 2, 1)
self.grid_layout.addWidget(QLabel('blending:'), 3, 0)
self.grid_layout.addWidget(self.blendComboBox, 3, 1)
self.grid_layout.addWidget(QLabel('face color:'), 4, 0)
self.grid_layout.addWidget(self.faceColorEdit, 4, 1)
self.grid_layout.addWidget(QLabel('edge color:'), 5, 0)
self.grid_layout.addWidget(self.edgeColorEdit, 5, 1)
self.grid_layout.addWidget(QLabel('display text:'), 6, 0)
self.grid_layout.addWidget(self.textDispCheckBox, 6, 1)
self.grid_layout.setRowStretch(7, 1)
self.grid_layout.setColumnStretch(1, 1)
self.grid_layout.setSpacing(4)
def __init__(self, layer):
super().__init__()
self.layer = layer
layer.events.select.connect(self._on_select)
layer.events.deselect.connect(self._on_deselect)
layer.events.name.connect(self._on_layer_name_change)
layer.events.blending.connect(self._on_blending_change)
layer.events.opacity.connect(self._on_opacity_change)
layer.events.visible.connect(self._on_visible_change)
self.setObjectName('layer')
self.grid_layout = QGridLayout()
cb = QCheckBox(self)
cb.setObjectName('visibility')
cb.setToolTip('Layer visibility')
cb.setChecked(self.layer.visible)
cb.setProperty('mode', 'visibility')
cb.stateChanged.connect(lambda state=cb: self.changeVisible(state))
self.visibleCheckBox = cb
self.grid_layout.addWidget(cb, 0, 0)
textbox = QLineEdit(self)
textbox.setText(layer.name)
textbox.home(False)
textbox.setToolTip('Layer name')
textbox.setFixedWidth(122)
textbox.setAcceptDrops(False)
textbox.setEnabled(True)
textbox.editingFinished.connect(self.changeText)
self.nameTextBox = textbox
self.grid_layout.addWidget(textbox, 0, 1)
self.grid_layout.addWidget(QLabel('opacity:'), 1, 0)
sld = QSlider(Qt.Horizontal, self)
sld.setFocusPolicy(Qt.NoFocus)
sld.setFixedWidth(110)
sld.setMinimum(0)
sld.setMaximum(100)
sld.setSingleStep(1)
sld.setValue(self.layer.opacity * 100)
sld.valueChanged[int].connect(
lambda value=sld: self.changeOpacity(value))
self.opacitySilder = sld
self.grid_layout.addWidget(sld, 1, 1)
blend_comboBox = QComboBox()
for blend in self.layer._blending_modes:
blend_comboBox.addItem(blend)
index = blend_comboBox.findText(self.layer.blending,
Qt.MatchFixedString)
blend_comboBox.setCurrentIndex(index)
blend_comboBox.activated[str].connect(
lambda text=blend_comboBox: self.changeBlending(text))
self.blendComboBox = blend_comboBox
self.grid_layout.addWidget(QLabel('blending:'), 2, 0)
self.grid_layout.addWidget(blend_comboBox, 2, 1)
self.setLayout(self.grid_layout)
msg = 'Click to select\nDrag to rearrange\nDouble click to expand'
self.setToolTip(msg)
self.setExpanded(False)
self.setFixedWidth(250)
self.grid_layout.setColumnMinimumWidth(0, 100)
self.grid_layout.setColumnMinimumWidth(1, 100)
self.layer.selected = True
class Arboretum(QWidget):
""" Arboretum
A track visualization and lineage tree plotter integration for Napari.
"""
def __init__(self, *args, **kwargs):
super(Arboretum, self).__init__(*args, **kwargs)
layout = QVBoxLayout()
# add some buttons
self.load_button = QPushButton('Load...', self)
self.config_button = QPushButton('Configure...', self)
self.localize_button = QPushButton('Localize', self)
self.track_button = QPushButton('Track', self)
self.save_button = QPushButton('Save...', self)
# checkboxes
self.optimize_checkbox = QCheckBox()
self.optimize_checkbox.setChecked(True)
# self.use_states_checkbox = QCheckBox()
# self.use_states_checkbox.setChecked(True)
# combo boxes
self.tracking_mode_combobox = QComboBox()
for mode in BayesianUpdates:
self.tracking_mode_combobox.addItem(mode.name.lower())
default_mode = BayesianUpdates.EXACT
self.tracking_mode_combobox.setCurrentIndex(default_mode.value)
# # sliders
self.search_radius_slider = QSlider(Qt.Horizontal)
self.search_radius_slider.setFocusPolicy(Qt.NoFocus)
self.search_radius_slider.setMinimum(1)
self.search_radius_slider.setMaximum(300)
self.search_radius_slider.setSingleStep(1)
# self.search_radius_slider.setEnabled(False)
# dynamic labels
self.config_filename_label = QLabel()
self.localizations_label = QLabel()
self.tracks_label = QLabel()
self.status_label = QLabel()
self.search_radius_label = QLabel()
self.search_radius_label.setAlignment(Qt.AlignRight)
# load/save buttons
io_panel = QWidget()
io_layout = QHBoxLayout()
io_layout.addWidget(self.load_button)
io_layout.addWidget(self.save_button)
io_panel.setLayout(io_layout)
io_panel.setMaximumWidth(GUI_MAXIMUM_WIDTH)
layout.addWidget(io_panel)
# tracking panel
tracking_panel = QGroupBox('tracking')
tracking_layout = QGridLayout()
tracking_layout.addWidget(QLabel('method: '), 0, 0)
tracking_layout.addWidget(self.tracking_mode_combobox, 0, 1)
tracking_layout.addWidget(self.search_radius_label, 1, 0)
tracking_layout.addWidget(self.search_radius_slider, 1, 1)
tracking_layout.addWidget(QLabel('optimize: '), 2, 0)
tracking_layout.addWidget(self.optimize_checkbox, 2, 1)
tracking_layout.addWidget(self.config_button, 3, 0)
tracking_layout.addWidget(self.config_filename_label, 3, 1)
tracking_layout.addWidget(self.localize_button, 4, 0)
tracking_layout.addWidget(self.localizations_label, 4, 1)
tracking_layout.addWidget(self.track_button, 5, 0)
tracking_layout.addWidget(self.tracks_label, 5, 1)
tracking_layout.setColumnMinimumWidth(1, 150)
tracking_layout.setSpacing(4)
tracking_panel.setMaximumWidth(GUI_MAXIMUM_WIDTH)
tracking_panel.setLayout(tracking_layout)
layout.addWidget(tracking_panel)
# status panel
status_panel = QGroupBox('status')
status_layout = QHBoxLayout()
status_layout.addWidget(self.status_label)
status_panel.setMaximumWidth(GUI_MAXIMUM_WIDTH)
status_panel.setLayout(status_layout)
layout.addWidget(status_panel)
# set the layout
layout.setAlignment(Qt.AlignTop)
layout.setSpacing(4)
self.setLayout(layout)
self.setMaximumHeight(GUI_MAXIMUM_HEIGHT)
self.setMaximumWidth(GUI_MAXIMUM_WIDTH)
# callbacks
self.load_button.clicked.connect(self.load_data)
self.save_button.clicked.connect(self.export_data)
self.config_button.clicked.connect(self.load_config)
self.tracking_mode_combobox.currentTextChanged.connect(
self._on_mode_change)
self.search_radius_slider.valueChanged.connect(self._on_radius_change)
self._tracker_state = None
self._segmentation = None
self._localizations = None
self._tracks = None
self._btrack_cfg = None
self._active_layer = None
# TODO(arl): this is the working filename for the dataset
self.filename = None
self._search_radius = None
self._on_mode_change()
self.search_radius_slider.setValue(100)
def load_data(self):
""" load data in hdf or json format from btrack """
filename = QFileDialog.getOpenFileName(self, 'Open tracking data',
DEFAULT_PATH,
'Tracking files (*.hdf5 *.h5)')
# only load file if we actually chose one
if filename[0]:
self.filename = filename[0]
else:
self.filename = None
def load_config(self):
""" load a btrack configuration file """
filename = QFileDialog.getOpenFileName(self, 'Open tracking config',
DEFAULT_PATH,
'Tracking files (*.json)')
# only load file if we actually chose one
if filename[0]:
self.btrack_cfg = utils._get_btrack_cfg(filename=filename[0])
else:
self.btrack_cfg = None
def export_data(self):
""" export track data """
export_fn = os.path.join(DEFAULT_PATH, 'tracks.h5')
filename = QFileDialog.getSaveFileName(self, 'Export tracking data',
export_fn,
'Tracking files (*.h5, *.csv)')
# only export file if we actually chose one
if filename[0]:
filename, ext = os.path.splitext(filename[0])
if ext == '.h5':
utils.export_hdf(f'{filename}.h5', self.segmentation,
self.tracker_state)
elif ext == '.csv':
btrack.dataio.export_CSV(f'{filename}.csv', self.tracker_state)
@property
def ndim(self):
return self.segmentation.ndim
@property
def tracker_state(self) -> TrackerFrozenState:
return self._tracker_state
@tracker_state.setter
def tracker_state(self, state: TrackerFrozenState):
self._tracker_state = state
self.tracks = [state.tracks]
@property
def segmentation(self) -> np.ndarray:
return self._segmentation
@segmentation.setter
def segmentation(self, segmentation: Union[np.ndarray, Labels]):
if segmentation is None:
self._segmentation = None
return
elif isinstance(segmentation, np.ndarray):
self._segmentation = segmentation
else:
# assume this is a napari layer
self._segmentation = segmentation.data
# TODO(arl): check that we deal with multidimensional data correctly
assert (self._segmentation.ndim < 5)
@property
def tracks(self) -> list:
return self._tracks
@tracks.setter
def tracks(self, tracks):
self._tracks = tracks
n_tracks = sum([len(t) for t in tracks])
n_tracks_str = f'{n_tracks} tracks'
self.tracks_label.setText(n_tracks_str)
@property
def localizations(self) -> np.ndarray:
return self._localizations
@localizations.setter
def localizations(self, localizations: np.ndarray):
self._localizations = localizations
n_localizations_str = f'{localizations.shape[0]} objects'
self.localizations_label.setText(n_localizations_str)
@property
def btrack_cfg(self) -> dict:
return self._btrack_cfg
@btrack_cfg.setter
def btrack_cfg(self, cfg: dict):
self._btrack_cfg = cfg
truncate_fn = lambda f: f'...{f[-20:]}'
self.config_filename_label.setText(truncate_fn(cfg['Filename']))
@property
def volume(self) -> tuple:
""" get the volume to use for tracking """
if self.segmentation is None:
return ((0, 1200), (0, 1600), (-1e5, 1e5))
else:
volume = []
# assumes time is the first dimension
for dim in self.segmentation.shape[-2:]:
volume.append((0, dim))
#
# if len(volume) == 2:
volume.append((-1e5, 1e5))
return tuple(volume)
@property
def active_layer(self) -> str:
if self._active_layer is None: return ''
return self._active_layer
@active_layer.setter
def active_layer(self, layer_name: str):
self._active_layer = layer_name
@property
def tracking_mode(self) -> BayesianUpdates:
return self._tracking_mode
@tracking_mode.setter
def tracking_mode(self, mode: BayesianUpdates):
self._tracking_mode = mode
@property
def optimize(self) -> bool:
return self.optimize_checkbox.isChecked()
@property
def search_radius(self) -> int:
return self._search_radius
# if self.tracking_mode == BayesianUpdates.APPROXIMATE:
# return self._search_radius
# else:
# return None
def _on_mode_change(self, event=None):
mode = self.tracking_mode_combobox.currentText().upper()
self.tracking_mode = BayesianUpdates[mode]
# if self.tracking_mode == BayesianUpdates.APPROXIMATE:
# self.search_radius_slider.setEnabled(True)
# else:
# self.search_radius_slider.setEnabled(False)
def _on_radius_change(self, value):
self.search_radius_label.setText(f'{value}')
self._search_radius = value
def get_tree(self, track_id: int):
""" get a tree associated with this track """
print(f'Selected track: {track_id}')
if track_id:
# test, plot the track we've selected
selected_track = filter(lambda t: t.ID == track_id, self.tracks[0])
track = list(selected_track)[0]
# get the root node?
root = [t for t in self.tracks[0] if t.ID == track.root]
if root:
root = root[0]
else:
return
return (track_id, ) + tuple(_build_tree_graph(
root, self.tracks[0]))
return
def __init__(self, layer):
super().__init__(layer)
self.layer.events.mode.connect(self._on_mode_change)
self.layer.events.selected_label.connect(self._on_selection_change)
self.layer.events.brush_size.connect(self._on_brush_size_change)
self.layer.events.contiguous.connect(self._on_contig_change)
self.layer.events.n_dimensional.connect(self._on_n_dim_change)
self.layer.events.editable.connect(self._on_editable_change)
# shuffle colormap button
self.colormapUpdate = QPushButton('shuffle colors')
self.colormapUpdate.setObjectName('shuffle')
self.colormapUpdate.clicked.connect(self.changeColor)
self.colormapUpdate.setFixedHeight(28)
# selection spinbox
self.selectionSpinBox = QSpinBox()
self.selectionSpinBox.setKeyboardTracking(False)
self.selectionSpinBox.setSingleStep(1)
self.selectionSpinBox.setMinimum(0)
self.selectionSpinBox.setMaximum(2147483647)
self.selectionSpinBox.valueChanged.connect(self.changeSelection)
self._on_selection_change(None)
sld = QSlider(Qt.Horizontal)
sld.setFocusPolicy(Qt.NoFocus)
sld.setMinimum(1)
sld.setMaximum(40)
sld.setSingleStep(1)
sld.valueChanged[int].connect(lambda value=sld: self.changeSize(value))
self.brushSizeSlider = sld
self._on_brush_size_change(None)
contig_cb = QCheckBox()
contig_cb.setToolTip('contiguous editing')
contig_cb.stateChanged.connect(
lambda state=contig_cb: self.change_contig(state))
self.contigCheckBox = contig_cb
self._on_contig_change(None)
ndim_cb = QCheckBox()
ndim_cb.setToolTip('n-dimensional editing')
ndim_cb.stateChanged.connect(
lambda state=ndim_cb: self.change_ndim(state))
self.ndimCheckBox = ndim_cb
self._on_n_dim_change(None)
self.panzoom_button = QtModeButton(layer, 'zoom', Mode.PAN_ZOOM,
'Pan/zoom mode')
self.pick_button = QtModeButton(layer, 'picker', Mode.PICKER,
'Pick mode')
self.paint_button = QtModeButton(layer, 'paint', Mode.PAINT,
'Paint mode')
self.fill_button = QtModeButton(layer, 'fill', Mode.FILL, 'Fill mode')
self.button_group = QButtonGroup(self)
self.button_group.addButton(self.panzoom_button)
self.button_group.addButton(self.paint_button)
self.button_group.addButton(self.pick_button)
self.button_group.addButton(self.fill_button)
self.panzoom_button.setChecked(True)
self._on_editable_change(None)
button_row = QHBoxLayout()
button_row.addWidget(self.pick_button)
button_row.addWidget(self.fill_button)
button_row.addWidget(self.paint_button)
button_row.addWidget(self.panzoom_button)
button_row.addStretch(1)
button_row.setSpacing(4)
# grid_layout created in QtLayerControls
# addWidget(widget, row, column, [row_span, column_span])
self.grid_layout.addLayout(button_row, 0, 1, 1, 2)
self.grid_layout.addWidget(self.colormapUpdate, 0, 0)
self.grid_layout.addWidget(QLabel('label:'), 1, 0)
self.grid_layout.addWidget(self.selectionSpinBox, 1, 2)
self.grid_layout.addWidget(QtColorBox(layer), 1, 1)
self.grid_layout.addWidget(QLabel('opacity:'), 2, 0)
self.grid_layout.addWidget(self.opacitySilder, 2, 1, 1, 2)
self.grid_layout.addWidget(QLabel('brush size:'), 3, 0)
self.grid_layout.addWidget(self.brushSizeSlider, 3, 1, 1, 2)
self.grid_layout.addWidget(QLabel('blending:'), 4, 0)
self.grid_layout.addWidget(self.blendComboBox, 4, 1, 1, 2)
self.grid_layout.addWidget(QLabel('contiguous:'), 5, 0)
self.grid_layout.addWidget(self.contigCheckBox, 5, 1)
self.grid_layout.addWidget(QLabel('n-dim:'), 6, 0)
self.grid_layout.addWidget(self.ndimCheckBox, 6, 1)
self.grid_layout.setRowStretch(7, 1)
self.grid_layout.setColumnStretch(1, 1)
self.grid_layout.setSpacing(4)
def __init__(self, layer):
super().__init__(layer)
self.layer.events.n_dimensional.connect(self._on_n_dim_change)
self.layer.events.symbol.connect(self._on_symbol_change)
self.layer.events.size.connect(self._on_size_change)
self.layer.events.edge_color.connect(self._on_edge_color_change)
self.layer.events.face_color.connect(self._on_face_color_change)
sld = QSlider(Qt.Horizontal, self)
sld.setFocusPolicy(Qt.NoFocus)
sld.setFixedWidth(110)
sld.setMinimum(1)
sld.setMaximum(100)
sld.setSingleStep(1)
value = self.layer.size
sld.setValue(int(value))
sld.valueChanged[int].connect(lambda value=sld: self.changeSize(value))
self.sizeSlider = sld
row = self.grid_layout.rowCount()
self.grid_layout.addWidget(QLabel('size:'), row, self.name_column)
self.grid_layout.addWidget(sld, row, self.property_column)
face_comboBox = QComboBox()
colors = self.layer._colors
for c in colors:
face_comboBox.addItem(c)
index = face_comboBox.findText(self.layer.face_color,
Qt.MatchFixedString)
face_comboBox.setCurrentIndex(index)
face_comboBox.activated[str].connect(
lambda text=face_comboBox: self.changeFaceColor(text))
self.faceComboBox = face_comboBox
row = self.grid_layout.rowCount()
self.grid_layout.addWidget(QLabel('face_color:'), row,
self.name_column)
self.grid_layout.addWidget(face_comboBox, row, self.property_column)
edge_comboBox = QComboBox()
colors = self.layer._colors
for c in colors:
edge_comboBox.addItem(c)
index = edge_comboBox.findText(self.layer.edge_color,
Qt.MatchFixedString)
edge_comboBox.setCurrentIndex(index)
edge_comboBox.activated[str].connect(
lambda text=edge_comboBox: self.changeEdgeColor(text))
self.edgeComboBox = edge_comboBox
row = self.grid_layout.rowCount()
self.grid_layout.addWidget(QLabel('edge_color:'), row,
self.name_column)
self.grid_layout.addWidget(edge_comboBox, row, self.property_column)
symbol_comboBox = QComboBox()
for s in Symbol:
symbol_comboBox.addItem(str(s))
index = symbol_comboBox.findText(self.layer.symbol,
Qt.MatchFixedString)
symbol_comboBox.setCurrentIndex(index)
symbol_comboBox.activated[str].connect(
lambda text=symbol_comboBox: self.changeSymbol(text))
self.symbolComboBox = symbol_comboBox
row = self.grid_layout.rowCount()
self.grid_layout.addWidget(QLabel('symbol:'), row, self.name_column)
self.grid_layout.addWidget(symbol_comboBox, row, self.property_column)
ndim_cb = QCheckBox()
ndim_cb.setToolTip('N-dimensional points')
ndim_cb.setChecked(self.layer.n_dimensional)
ndim_cb.stateChanged.connect(
lambda state=ndim_cb: self.change_ndim(state))
self.ndimCheckBox = ndim_cb
row = self.grid_layout.rowCount()
self.grid_layout.addWidget(QLabel('n-dim:'), row, self.name_column)
self.grid_layout.addWidget(ndim_cb, row, self.property_column)
self.setExpanded(False)
def __init__(self, layer):
super().__init__(layer)
self.layer.events.colormap.connect(self._on_colormap_change)
self.layer.events.selected_label.connect(self._on_selection_change)
self.layer.events.brush_size.connect(self._on_brush_size_change)
self.layer.events.contiguous.connect(self._on_contig_change)
self.layer.events.n_dimensional.connect(self._on_n_dim_change)
self.colormap_update = QPushButton('click')
self.colormap_update.setObjectName('shuffle')
self.colormap_update.clicked.connect(self.changeColor)
self.colormap_update.setFixedWidth(112)
self.colormap_update.setFixedHeight(25)
shuffle_label = QLabel('shuffle colors:')
shuffle_label.setObjectName('shuffle-label')
row = self.grid_layout.rowCount()
self.grid_layout.addWidget(shuffle_label, row, self.name_column)
self.grid_layout.addWidget(
self.colormap_update, row, self.property_column
)
# selection spinbox
self.selection_spinbox = QSpinBox()
self.selection_spinbox.setSingleStep(1)
self.selection_spinbox.setMinimum(0)
self.selection_spinbox.setMaximum(2147483647)
self.selection_spinbox.setValue(self.layer.selected_label)
self.selection_spinbox.setFixedWidth(75)
self.selection_spinbox.valueChanged.connect(self.changeSelection)
row = self.grid_layout.rowCount()
self.grid_layout.addWidget(QLabel('label:'), row, self.name_column)
self.grid_layout.addWidget(
self.selection_spinbox, row, self.property_column
)
sld = QSlider(Qt.Horizontal, self)
sld.setFocusPolicy(Qt.NoFocus)
sld.setFixedWidth(110)
sld.setMinimum(1)
sld.setMaximum(40)
sld.setSingleStep(1)
value = self.layer.brush_size
if isinstance(value, Iterable):
if isinstance(value, list):
value = np.asarray(value)
value = value[:2].mean()
sld.setValue(int(value))
sld.valueChanged[int].connect(lambda value=sld: self.changeSize(value))
self.brush_size_slider = sld
row = self.grid_layout.rowCount()
self.grid_layout.addWidget(
QLabel('brush size:'), row, self.name_column
)
self.grid_layout.addWidget(sld, row, self.property_column)
contig_cb = QCheckBox()
contig_cb.setToolTip('contiguous editing')
contig_cb.setChecked(self.layer.contiguous)
contig_cb.stateChanged.connect(
lambda state=contig_cb: self.change_contig(state)
)
self.contig_checkbox = contig_cb
row = self.grid_layout.rowCount()
self.grid_layout.addWidget(
QLabel('contiguous:'), row, self.name_column
)
self.grid_layout.addWidget(contig_cb, row, self.property_column)
ndim_cb = QCheckBox()
ndim_cb.setToolTip('n-dimensional editing')
ndim_cb.setChecked(self.layer.n_dimensional)
ndim_cb.stateChanged.connect(
lambda state=ndim_cb: self.change_ndim(state)
)
self.ndim_checkbox = ndim_cb
row = self.grid_layout.rowCount()
self.grid_layout.addWidget(QLabel('n-dim:'), row, self.name_column)
self.grid_layout.addWidget(ndim_cb, row, self.property_column)
self.setExpanded(False)
def __init__(self, layer):
super().__init__(layer)
self.layer.events.mode.connect(self._on_mode_change)
self.layer.events.selected_label.connect(
self._on_selected_label_change)
self.layer.events.brush_size.connect(self._on_brush_size_change)
self.layer.events.contiguous.connect(self._on_contiguous_change)
self.layer.events.n_dimensional.connect(self._on_n_dimensional_change)
self.layer.events.contour.connect(self._on_contour_change)
self.layer.events.editable.connect(self._on_editable_change)
self.layer.events.preserve_labels.connect(
self._on_preserve_labels_change)
self.layer.events.color_mode.connect(self._on_color_mode_change)
# selection spinbox
self.selectionSpinBox = QSpinBox()
self.selectionSpinBox.setKeyboardTracking(False)
self.selectionSpinBox.setSingleStep(1)
self.selectionSpinBox.setMinimum(0)
self.selectionSpinBox.setMaximum(1024)
self.selectionSpinBox.valueChanged.connect(self.changeSelection)
self.selectionSpinBox.setAlignment(Qt.AlignCenter)
self._on_selected_label_change()
sld = QSlider(Qt.Horizontal)
sld.setFocusPolicy(Qt.NoFocus)
sld.setMinimum(1)
sld.setMaximum(40)
sld.setSingleStep(1)
sld.valueChanged.connect(self.changeSize)
self.brushSizeSlider = sld
self._on_brush_size_change()
contig_cb = QCheckBox()
contig_cb.setToolTip(trans._('contiguous editing'))
contig_cb.stateChanged.connect(self.change_contig)
self.contigCheckBox = contig_cb
self._on_contiguous_change()
ndim_cb = QCheckBox()
ndim_cb.setToolTip(trans._('edit all dimensions'))
ndim_cb.stateChanged.connect(self.change_ndim)
self.ndimCheckBox = ndim_cb
self._on_n_dimensional_change()
contour_sb = QSpinBox()
contour_sb.setToolTip(trans._('display contours of labels'))
contour_sb.valueChanged.connect(self.change_contour)
self.contourSpinBox = contour_sb
self.contourSpinBox.setKeyboardTracking(False)
self.contourSpinBox.setSingleStep(1)
self.contourSpinBox.setMinimum(0)
self.contourSpinBox.setMaximum(2147483647)
self.contourSpinBox.setAlignment(Qt.AlignCenter)
self._on_contour_change()
preserve_labels_cb = QCheckBox()
preserve_labels_cb.setToolTip(
trans._('preserve existing labels while painting'))
preserve_labels_cb.stateChanged.connect(self.change_preserve_labels)
self.preserveLabelsCheckBox = preserve_labels_cb
self._on_preserve_labels_change()
selectedColorCheckbox = QCheckBox()
selectedColorCheckbox.setToolTip(
trans._("Display only selected label"))
selectedColorCheckbox.stateChanged.connect(self.toggle_selected_mode)
self.selectedColorCheckbox = selectedColorCheckbox
# shuffle colormap button
self.colormapUpdate = QtModePushButton(
None,
'shuffle',
slot=self.changeColor,
tooltip=trans._('shuffle colors'),
)
self.panzoom_button = QtModeRadioButton(
layer,
'zoom',
Mode.PAN_ZOOM,
tooltip=trans._('Pan/zoom mode (Space)'),
checked=True,
)
self.pick_button = QtModeRadioButton(layer,
'picker',
Mode.PICK,
tooltip=trans._('Pick mode (L)'))
self.paint_button = QtModeRadioButton(
layer, 'paint', Mode.PAINT, tooltip=trans._('Paint mode (P)'))
self.fill_button = QtModeRadioButton(
layer,
'fill',
Mode.FILL,
tooltip=trans._("Fill mode (F) \nToggle with {key}".format(
key=KEY_SYMBOLS['Control'])),
)
self.erase_button = QtModeRadioButton(
layer,
'erase',
Mode.ERASE,
tooltip=trans._("Erase mode (E) \nToggle with {key}".format(
key=KEY_SYMBOLS['Alt'])),
)
self.button_group = QButtonGroup(self)
self.button_group.addButton(self.panzoom_button)
self.button_group.addButton(self.paint_button)
self.button_group.addButton(self.pick_button)
self.button_group.addButton(self.fill_button)
self.button_group.addButton(self.erase_button)
self._on_editable_change()
button_row = QHBoxLayout()
button_row.addStretch(1)
button_row.addWidget(self.colormapUpdate)
button_row.addWidget(self.erase_button)
button_row.addWidget(self.fill_button)
button_row.addWidget(self.paint_button)
button_row.addWidget(self.pick_button)
button_row.addWidget(self.panzoom_button)
button_row.setSpacing(4)
button_row.setContentsMargins(0, 0, 0, 5)
brush_shape_comboBox = QComboBox(self)
for index, (data,
text) in enumerate(LABEL_BRUSH_SHAPE_TRANSLATIONS.items()):
data = data.value
brush_shape_comboBox.addItem(text, data)
if self.layer.brush_shape == data:
brush_shape_comboBox.setCurrentIndex(index)
brush_shape_comboBox.activated[str].connect(self.change_brush_shape)
self.brushShapeComboBox = brush_shape_comboBox
self._on_brush_shape_change()
color_mode_comboBox = QComboBox(self)
for index, (data,
text) in enumerate(LABEL_COLOR_MODE_TRANSLATIONS.items()):
data = data.value
color_mode_comboBox.addItem(text, data)
if self.layer.color_mode == data:
color_mode_comboBox.setCurrentIndex(index)
color_mode_comboBox.activated[str].connect(self.change_color_mode)
self.colorModeComboBox = color_mode_comboBox
self._on_color_mode_change()
color_layout = QHBoxLayout()
self.colorBox = QtColorBox(layer)
color_layout.addWidget(self.colorBox)
color_layout.addWidget(self.selectionSpinBox)
# grid_layout created in QtLayerControls
# addWidget(widget, row, column, [row_span, column_span])
self.grid_layout.addLayout(button_row, 0, 0, 1, 4)
self.grid_layout.addWidget(QLabel(trans._('label:')), 1, 0, 1, 1)
self.grid_layout.addLayout(color_layout, 1, 1, 1, 3)
self.grid_layout.addWidget(QLabel(trans._('opacity:')), 2, 0, 1, 1)
self.grid_layout.addWidget(self.opacitySlider, 2, 1, 1, 3)
self.grid_layout.addWidget(QLabel(trans._('brush size:')), 3, 0, 1, 1)
self.grid_layout.addWidget(self.brushSizeSlider, 3, 1, 1, 3)
self.grid_layout.addWidget(QLabel(trans._('brush shape:')), 4, 0, 1, 1)
self.grid_layout.addWidget(self.brushShapeComboBox, 4, 1, 1, 3)
self.grid_layout.addWidget(QLabel(trans._('blending:')), 5, 0, 1, 1)
self.grid_layout.addWidget(self.blendComboBox, 5, 1, 1, 3)
self.grid_layout.addWidget(QLabel(trans._('color mode:')), 6, 0, 1, 1)
self.grid_layout.addWidget(self.colorModeComboBox, 6, 1, 1, 3)
self.grid_layout.addWidget(QLabel(trans._('contour:')), 7, 0, 1, 1)
self.grid_layout.addWidget(self.contourSpinBox, 7, 1, 1, 1)
self.grid_layout.addWidget(QLabel(trans._('contiguous:')), 8, 0, 1, 1)
self.grid_layout.addWidget(self.contigCheckBox, 8, 1, 1, 1)
self.grid_layout.addWidget(QLabel(trans._('n-dim:')), 8, 2, 1, 1)
self.grid_layout.addWidget(self.ndimCheckBox, 8, 3, 1, 1)
self.grid_layout.addWidget(QLabel(trans._('preserve labels:')), 9, 0,
1, 2)
self.grid_layout.addWidget(self.preserveLabelsCheckBox, 9, 1, 1, 1)
self.grid_layout.addWidget(QLabel(trans._('show selected:')), 9, 2, 1,
1)
self.grid_layout.addWidget(self.selectedColorCheckbox, 9, 3, 1, 1)
self.grid_layout.setRowStretch(9, 1)
self.grid_layout.setColumnStretch(1, 1)
self.grid_layout.setSpacing(4)
class QtTracksControls(QtLayerControls):
"""Qt view and controls for the Tracks layer.
Parameters
----------
layer : napari.layers.Tracks
An instance of a Tracks layer.
Attributes
----------
grid_layout : qtpy.QtWidgets.QGridLayout
Layout of Qt widget controls for the layer.
layer : layers.Tracks
An instance of a Tracks layer.
"""
layer: 'napari.layers.Tracks'
def __init__(self, layer):
super().__init__(layer)
# NOTE(arl): there are no events fired for changing checkboxes
self.layer.events.tail_width.connect(self._on_tail_width_change)
self.layer.events.tail_length.connect(self._on_tail_length_change)
self.layer.events.head_length.connect(self._on_head_length_change)
self.layer.events.properties.connect(self._on_properties_change)
self.layer.events.colormap.connect(self._on_colormap_change)
self.layer.events.color_by.connect(self._on_color_by_change)
# combo box for track coloring, we can get these from the properties
# keys
self.color_by_combobox = QComboBox()
self.color_by_combobox.addItems(self.layer.properties_to_color_by)
self.colormap_combobox = QComboBox()
for name, colormap in AVAILABLE_COLORMAPS.items():
display_name = colormap._display_name
self.colormap_combobox.addItem(display_name, name)
# slider for track head length
self.head_length_slider = QSlider(Qt.Horizontal)
self.head_length_slider.setFocusPolicy(Qt.NoFocus)
self.head_length_slider.setMinimum(0)
self.head_length_slider.setMaximum(self.layer._max_length)
self.head_length_slider.setSingleStep(1)
# slider for track tail length
self.tail_length_slider = QSlider(Qt.Horizontal)
self.tail_length_slider.setFocusPolicy(Qt.NoFocus)
self.tail_length_slider.setMinimum(1)
self.tail_length_slider.setMaximum(self.layer._max_length)
self.tail_length_slider.setSingleStep(1)
# slider for track edge width
self.tail_width_slider = QSlider(Qt.Horizontal)
self.tail_width_slider.setFocusPolicy(Qt.NoFocus)
self.tail_width_slider.setMinimum(1)
self.tail_width_slider.setMaximum(int(2 * self.layer._max_width))
self.tail_width_slider.setSingleStep(1)
# checkboxes for display
self.id_checkbox = QCheckBox()
self.tail_checkbox = QCheckBox()
self.tail_checkbox.setChecked(True)
self.graph_checkbox = QCheckBox()
self.graph_checkbox.setChecked(True)
self.tail_width_slider.valueChanged.connect(self.change_tail_width)
self.tail_length_slider.valueChanged.connect(self.change_tail_length)
self.head_length_slider.valueChanged.connect(self.change_head_length)
self.tail_checkbox.stateChanged.connect(self.change_display_tail)
self.id_checkbox.stateChanged.connect(self.change_display_id)
self.graph_checkbox.stateChanged.connect(self.change_display_graph)
self.color_by_combobox.currentTextChanged.connect(self.change_color_by)
self.colormap_combobox.currentTextChanged.connect(self.change_colormap)
self.layout().addRow(trans._('color by:'), self.color_by_combobox)
self.layout().addRow(trans._('colormap:'), self.colormap_combobox)
self.layout().addRow(trans._('blending:'), self.blendComboBox)
self.layout().addRow(trans._('opacity:'), self.opacitySlider)
self.layout().addRow(trans._('tail width:'), self.tail_width_slider)
self.layout().addRow(trans._('tail length:'), self.tail_length_slider)
self.layout().addRow(trans._('head length:'), self.head_length_slider)
self.layout().addRow(trans._('tail:'), self.tail_checkbox)
self.layout().addRow(trans._('show ID:'), self.id_checkbox)
self.layout().addRow(trans._('graph:'), self.graph_checkbox)
self._on_tail_length_change()
self._on_tail_width_change()
self._on_colormap_change()
self._on_color_by_change()
def _on_tail_width_change(self):
"""Receive layer model track line width change event and update slider."""
with self.layer.events.tail_width.blocker():
value = int(2 * self.layer.tail_width)
self.tail_width_slider.setValue(value)
def _on_tail_length_change(self):
"""Receive layer model track line width change event and update slider."""
with self.layer.events.tail_length.blocker():
value = self.layer.tail_length
self.tail_length_slider.setValue(value)
def _on_head_length_change(self):
"""Receive layer model track line width change event and update slider."""
with self.layer.events.head_length.blocker():
value = self.layer.head_length
self.head_length_slider.setValue(value)
def _on_properties_change(self):
"""Change the properties that can be used to color the tracks."""
with self.layer.events.properties.blocker():
with qt_signals_blocked(self.color_by_combobox):
self.color_by_combobox.clear()
self.color_by_combobox.addItems(self.layer.properties_to_color_by)
def _on_colormap_change(self):
"""Receive layer model colormap change event and update combobox."""
with self.layer.events.colormap.blocker():
self.colormap_combobox.setCurrentIndex(
self.colormap_combobox.findData(self.layer.colormap))
def _on_color_by_change(self):
"""Receive layer model color_by change event and update combobox."""
with self.layer.events.color_by.blocker():
color_by = self.layer.color_by
idx = self.color_by_combobox.findText(color_by,
Qt.MatchFixedString)
self.color_by_combobox.setCurrentIndex(idx)
def change_tail_width(self, value):
"""Change track line width of shapes on the layer model.
Parameters
----------
value : float
Line width of track tails.
"""
self.layer.tail_width = float(value) / 2.0
def change_tail_length(self, value):
"""Change edge line backward length of shapes on the layer model.
Parameters
----------
value : int
Line length of track tails.
"""
self.layer.tail_length = value
def change_head_length(self, value):
"""Change edge line forward length of shapes on the layer model.
Parameters
----------
value : int
Line length of track tails.
"""
self.layer.head_length = value
def change_display_tail(self, state):
self.layer.display_tail = self.tail_checkbox.isChecked()
def change_display_id(self, state):
self.layer.display_id = self.id_checkbox.isChecked()
def change_display_graph(self, state):
self.layer.display_graph = self.graph_checkbox.isChecked()
def change_color_by(self, value: str):
self.layer.color_by = value
def change_colormap(self, colormap: str):
self.layer.colormap = self.colormap_combobox.currentData()
class PyDMChartingDisplay(Display):
def __init__(self, parent=None, args=[], macros=None):
"""
Create all the widgets, including any child dialogs.
Parameters
----------
parent : QWidget
The parent widget of the charting display
args : list
The command parameters
macros : str
Macros to modify the UI parameters at runtime
"""
super(PyDMChartingDisplay, self).__init__(parent=parent,
args=args,
macros=macros)
self.channel_map = dict()
self.setWindowTitle("PyDM Charting Tool")
self.main_layout = QVBoxLayout()
self.body_layout = QVBoxLayout()
self.pv_layout = QHBoxLayout()
self.pv_name_line_edt = QLineEdit()
self.pv_name_line_edt.setAcceptDrops(True)
self.pv_name_line_edt.installEventFilter(self)
self.pv_protocol_cmb = QComboBox()
self.pv_protocol_cmb.addItems(["ca://", "archive://"])
self.pv_connect_push_btn = QPushButton("Connect")
self.pv_connect_push_btn.clicked.connect(self.add_curve)
self.tab_panel = QTabWidget()
self.tab_panel.setMaximumWidth(450)
self.curve_settings_tab = QWidget()
self.chart_settings_tab = QWidget()
self.charting_layout = QHBoxLayout()
self.chart = PyDMTimePlot(plot_by_timestamps=False, plot_display=self)
self.chart.setPlotTitle("Time Plot")
self.splitter = QSplitter()
self.curve_settings_layout = QVBoxLayout()
self.curve_settings_layout.setAlignment(Qt.AlignTop)
self.curve_settings_layout.setSizeConstraint(QLayout.SetMinAndMaxSize)
self.curve_settings_layout.setSpacing(5)
self.crosshair_settings_layout = QVBoxLayout()
self.crosshair_settings_layout.setAlignment(Qt.AlignTop)
self.crosshair_settings_layout.setSpacing(5)
self.enable_crosshair_chk = QCheckBox("Enable Crosshair")
self.cross_hair_coord_lbl = QLabel()
self.curve_settings_inner_frame = QFrame()
self.curve_settings_inner_frame.setLayout(self.curve_settings_layout)
self.curve_settings_scroll = QScrollArea()
self.curve_settings_scroll.setVerticalScrollBarPolicy(
Qt.ScrollBarAsNeeded)
self.curve_settings_scroll.setWidget(self.curve_settings_inner_frame)
self.curves_tab_layout = QHBoxLayout()
self.curves_tab_layout.addWidget(self.curve_settings_scroll)
self.enable_crosshair_chk.setChecked(False)
self.enable_crosshair_chk.clicked.connect(
self.handle_enable_crosshair_checkbox_clicked)
self.enable_crosshair_chk.clicked.emit(False)
self.chart_settings_layout = QVBoxLayout()
self.chart_settings_layout.setAlignment(Qt.AlignTop)
self.chart_layout = QVBoxLayout()
self.chart_panel = QWidget()
self.chart_control_layout = QHBoxLayout()
self.chart_control_layout.setAlignment(Qt.AlignHCenter)
self.chart_control_layout.setSpacing(10)
self.view_all_btn = QPushButton("View All")
self.view_all_btn.clicked.connect(self.handle_view_all_button_clicked)
self.view_all_btn.setEnabled(False)
self.auto_scale_btn = QPushButton("Auto Scale")
self.auto_scale_btn.clicked.connect(self.handle_auto_scale_btn_clicked)
self.auto_scale_btn.setEnabled(False)
self.reset_chart_btn = QPushButton("Reset")
self.reset_chart_btn.clicked.connect(
self.handle_reset_chart_btn_clicked)
self.reset_chart_btn.setEnabled(False)
self.resume_chart_text = "Resume"
self.pause_chart_text = "Pause"
self.pause_chart_btn = QPushButton(self.pause_chart_text)
self.pause_chart_btn.clicked.connect(
self.handle_pause_chart_btn_clicked)
self.title_settings_layout = QVBoxLayout()
self.title_settings_layout.setSpacing(10)
self.title_settings_grpbx = QGroupBox()
self.title_settings_grpbx.setFixedHeight(150)
self.import_data_btn = QPushButton("Import Data...")
self.import_data_btn.clicked.connect(
self.handle_import_data_btn_clicked)
self.export_data_btn = QPushButton("Export Data...")
self.export_data_btn.clicked.connect(
self.handle_export_data_btn_clicked)
self.chart_title_lbl = QLabel(text="Chart Title")
self.chart_title_line_edt = QLineEdit()
self.chart_title_line_edt.setText(self.chart.getPlotTitle())
self.chart_title_line_edt.textChanged.connect(
self.handle_title_text_changed)
self.chart_change_axis_settings_btn = QPushButton(
text="Change Axis Settings...")
self.chart_change_axis_settings_btn.clicked.connect(
self.handle_change_axis_settings_clicked)
self.update_datetime_timer = QTimer(self)
self.update_datetime_timer.timeout.connect(
self.handle_update_datetime_timer_timeout)
self.chart_sync_mode_layout = QVBoxLayout()
self.chart_sync_mode_layout.setSpacing(5)
self.chart_sync_mode_grpbx = QGroupBox("Data Sampling Mode")
self.chart_sync_mode_grpbx.setFixedHeight(80)
self.chart_sync_mode_sync_radio = QRadioButton("Synchronous")
self.chart_sync_mode_async_radio = QRadioButton("Asynchronous")
self.chart_sync_mode_async_radio.setChecked(True)
self.graph_drawing_settings_layout = QVBoxLayout()
self.chart_redraw_rate_lbl = QLabel("Redraw Rate (Hz)")
self.chart_redraw_rate_spin = QSpinBox()
self.chart_redraw_rate_spin.setRange(MIN_REDRAW_RATE_HZ,
MAX_REDRAW_RATE_HZ)
self.chart_redraw_rate_spin.setValue(DEFAULT_REDRAW_RATE_HZ)
self.chart_redraw_rate_spin.valueChanged.connect(
self.handle_redraw_rate_changed)
self.chart_data_sampling_rate_lbl = QLabel(
"Asynchronous Data Sampling Rate (Hz)")
self.chart_data_async_sampling_rate_spin = QSpinBox()
self.chart_data_async_sampling_rate_spin.setRange(
MIN_DATA_SAMPLING_RATE_HZ, MAX_DATA_SAMPLING_RATE_HZ)
self.chart_data_async_sampling_rate_spin.setValue(
DEFAULT_DATA_SAMPLING_RATE_HZ)
self.chart_data_async_sampling_rate_spin.valueChanged.connect(
self.handle_data_sampling_rate_changed)
self.chart_data_sampling_rate_lbl.hide()
self.chart_data_async_sampling_rate_spin.hide()
self.chart_limit_time_span_layout = QHBoxLayout()
self.chart_limit_time_span_layout.setSpacing(5)
self.limit_time_plan_text = "Limit Time Span"
self.chart_limit_time_span_chk = QCheckBox(self.limit_time_plan_text)
self.chart_limit_time_span_chk.hide()
self.chart_limit_time_span_lbl = QLabel("Hours : Minutes : Seconds")
self.chart_limit_time_span_hours_line_edt = QLineEdit()
self.chart_limit_time_span_minutes_line_edt = QLineEdit()
self.chart_limit_time_span_seconds_line_edt = QLineEdit()
self.chart_limit_time_span_activate_btn = QPushButton("Apply")
self.chart_limit_time_span_activate_btn.setDisabled(True)
self.chart_ring_buffer_size_lbl = QLabel("Ring Buffer Size")
self.chart_ring_buffer_size_edt = QLineEdit()
self.chart_ring_buffer_size_edt.installEventFilter(self)
self.chart_ring_buffer_size_edt.textChanged.connect(
self.handle_buffer_size_changed)
self.chart_ring_buffer_size_edt.setText(str(DEFAULT_BUFFER_SIZE))
self.show_legend_chk = QCheckBox("Show Legend")
self.show_legend_chk.setChecked(self.chart.showLegend)
self.show_legend_chk.clicked.connect(
self.handle_show_legend_checkbox_clicked)
self.graph_background_color_layout = QFormLayout()
self.background_color_lbl = QLabel("Graph Background Color ")
self.background_color_btn = QPushButton()
self.background_color_btn.setStyleSheet(
"background-color: " + self.chart.getBackgroundColor().name())
self.background_color_btn.setContentsMargins(10, 0, 5, 5)
self.background_color_btn.setMaximumWidth(20)
self.background_color_btn.clicked.connect(
self.handle_background_color_button_clicked)
self.axis_settings_layout = QVBoxLayout()
self.axis_settings_layout.setSpacing(5)
self.show_x_grid_chk = QCheckBox("Show x Grid")
self.show_x_grid_chk.setChecked(self.chart.showXGrid)
self.show_x_grid_chk.clicked.connect(
self.handle_show_x_grid_checkbox_clicked)
self.show_y_grid_chk = QCheckBox("Show y Grid")
self.show_y_grid_chk.setChecked(self.chart.showYGrid)
self.show_y_grid_chk.clicked.connect(
self.handle_show_y_grid_checkbox_clicked)
self.axis_color_lbl = QLabel("Axis and Grid Color")
self.axis_color_lbl.setEnabled(False)
self.axis_color_btn = QPushButton()
self.axis_color_btn.setStyleSheet("background-color: " +
DEFAULT_CHART_AXIS_COLOR.name())
self.axis_color_btn.setContentsMargins(10, 0, 5, 5)
self.axis_color_btn.setMaximumWidth(20)
self.axis_color_btn.clicked.connect(
self.handle_axis_color_button_clicked)
self.axis_color_btn.setEnabled(False)
self.grid_opacity_lbl = QLabel("Grid Opacity")
self.grid_opacity_lbl.setEnabled(False)
self.grid_opacity_slr = QSlider(Qt.Horizontal)
self.grid_opacity_slr.setFocusPolicy(Qt.StrongFocus)
self.grid_opacity_slr.setRange(0, 10)
self.grid_opacity_slr.setValue(5)
self.grid_opacity_slr.setTickInterval(1)
self.grid_opacity_slr.setSingleStep(1)
self.grid_opacity_slr.setTickPosition(QSlider.TicksBelow)
self.grid_opacity_slr.valueChanged.connect(
self.handle_grid_opacity_slider_mouse_release)
self.grid_opacity_slr.setEnabled(False)
self.reset_chart_settings_btn = QPushButton("Reset Chart Settings")
self.reset_chart_settings_btn.clicked.connect(
self.handle_reset_chart_settings_btn_clicked)
self.curve_checkbox_panel = QWidget()
self.graph_drawing_settings_grpbx = QGroupBox()
self.graph_drawing_settings_grpbx.setFixedHeight(270)
self.axis_settings_grpbx = QGroupBox()
self.axis_settings_grpbx.setFixedHeight(180)
self.app = QApplication.instance()
self.setup_ui()
self.curve_settings_disp = None
self.axis_settings_disp = None
self.chart_data_export_disp = None
self.chart_data_import_disp = None
self.grid_alpha = 5
self.time_span_limit_hours = None
self.time_span_limit_minutes = None
self.time_span_limit_seconds = None
self.data_sampling_mode = ASYNC_DATA_SAMPLING
def minimumSizeHint(self):
"""
The minimum recommended size of the main window.
"""
return QSize(1490, 800)
def ui_filepath(self):
"""
The path to the UI file created by Qt Designer, if applicable.
"""
# No UI file is being used
return None
def ui_filename(self):
"""
The name the UI file created by Qt Designer, if applicable.
"""
# No UI file is being used
return None
def setup_ui(self):
"""
Initialize the widgets and layouts.
"""
self.setLayout(self.main_layout)
self.pv_layout.addWidget(self.pv_protocol_cmb)
self.pv_layout.addWidget(self.pv_name_line_edt)
self.pv_layout.addWidget(self.pv_connect_push_btn)
QTimer.singleShot(0, self.pv_name_line_edt.setFocus)
self.curve_settings_tab.setLayout(self.curves_tab_layout)
self.chart_settings_tab.setLayout(self.chart_settings_layout)
self.setup_chart_settings_layout()
self.tab_panel.addTab(self.curve_settings_tab, "Curves")
self.tab_panel.addTab(self.chart_settings_tab, "Chart")
self.tab_panel.hide()
self.crosshair_settings_layout.addWidget(self.enable_crosshair_chk)
self.crosshair_settings_layout.addWidget(self.cross_hair_coord_lbl)
self.chart_control_layout.addWidget(self.auto_scale_btn)
self.chart_control_layout.addWidget(self.view_all_btn)
self.chart_control_layout.addWidget(self.reset_chart_btn)
self.chart_control_layout.addWidget(self.pause_chart_btn)
self.chart_control_layout.addLayout(self.crosshair_settings_layout)
self.chart_control_layout.addWidget(self.import_data_btn)
self.chart_control_layout.addWidget(self.export_data_btn)
self.chart_control_layout.setStretch(4, 15)
self.chart_control_layout.insertSpacing(5, 350)
self.chart_layout.addWidget(self.chart)
self.chart_layout.addLayout(self.chart_control_layout)
self.chart_panel.setLayout(self.chart_layout)
self.splitter.addWidget(self.chart_panel)
self.splitter.addWidget(self.tab_panel)
self.splitter.setStretchFactor(0, 0)
self.splitter.setStretchFactor(1, 1)
self.charting_layout.addWidget(self.splitter)
self.body_layout.addLayout(self.pv_layout)
self.body_layout.addLayout(self.charting_layout)
self.body_layout.addLayout(self.chart_control_layout)
self.main_layout.addLayout(self.body_layout)
self.enable_chart_control_buttons(False)
def setup_chart_settings_layout(self):
self.chart_sync_mode_sync_radio.toggled.connect(
partial(self.handle_sync_mode_radio_toggle,
self.chart_sync_mode_sync_radio))
self.chart_sync_mode_async_radio.toggled.connect(
partial(self.handle_sync_mode_radio_toggle,
self.chart_sync_mode_async_radio))
self.title_settings_layout.addWidget(self.chart_title_lbl)
self.title_settings_layout.addWidget(self.chart_title_line_edt)
self.title_settings_layout.addWidget(self.show_legend_chk)
self.title_settings_layout.addWidget(
self.chart_change_axis_settings_btn)
self.title_settings_grpbx.setLayout(self.title_settings_layout)
self.chart_settings_layout.addWidget(self.title_settings_grpbx)
self.chart_sync_mode_layout.addWidget(self.chart_sync_mode_sync_radio)
self.chart_sync_mode_layout.addWidget(self.chart_sync_mode_async_radio)
self.chart_sync_mode_grpbx.setLayout(self.chart_sync_mode_layout)
self.chart_settings_layout.addWidget(self.chart_sync_mode_grpbx)
self.chart_settings_layout.addWidget(self.chart_sync_mode_grpbx)
self.chart_limit_time_span_layout.addWidget(
self.chart_limit_time_span_lbl)
self.chart_limit_time_span_layout.addWidget(
self.chart_limit_time_span_hours_line_edt)
self.chart_limit_time_span_layout.addWidget(
self.chart_limit_time_span_minutes_line_edt)
self.chart_limit_time_span_layout.addWidget(
self.chart_limit_time_span_seconds_line_edt)
self.chart_limit_time_span_layout.addWidget(
self.chart_limit_time_span_activate_btn)
self.chart_limit_time_span_lbl.hide()
self.chart_limit_time_span_hours_line_edt.hide()
self.chart_limit_time_span_minutes_line_edt.hide()
self.chart_limit_time_span_seconds_line_edt.hide()
self.chart_limit_time_span_activate_btn.hide()
self.chart_limit_time_span_hours_line_edt.textChanged.connect(
self.handle_time_span_edt_text_changed)
self.chart_limit_time_span_minutes_line_edt.textChanged.connect(
self.handle_time_span_edt_text_changed)
self.chart_limit_time_span_seconds_line_edt.textChanged.connect(
self.handle_time_span_edt_text_changed)
self.chart_limit_time_span_chk.clicked.connect(
self.handle_limit_time_span_checkbox_clicked)
self.chart_limit_time_span_activate_btn.clicked.connect(
self.handle_chart_limit_time_span_activate_btn_clicked)
self.chart_limit_time_span_activate_btn.installEventFilter(self)
self.graph_background_color_layout.addRow(self.background_color_lbl,
self.background_color_btn)
self.graph_drawing_settings_layout.addLayout(
self.graph_background_color_layout)
self.graph_drawing_settings_layout.addWidget(
self.chart_redraw_rate_lbl)
self.graph_drawing_settings_layout.addWidget(
self.chart_redraw_rate_spin)
self.graph_drawing_settings_layout.addWidget(
self.chart_data_sampling_rate_lbl)
self.graph_drawing_settings_layout.addWidget(
self.chart_data_async_sampling_rate_spin)
self.graph_drawing_settings_layout.addWidget(
self.chart_limit_time_span_chk)
self.graph_drawing_settings_layout.addLayout(
self.chart_limit_time_span_layout)
self.graph_drawing_settings_layout.addWidget(
self.chart_ring_buffer_size_lbl)
self.graph_drawing_settings_layout.addWidget(
self.chart_ring_buffer_size_edt)
self.graph_drawing_settings_grpbx.setLayout(
self.graph_drawing_settings_layout)
self.axis_settings_layout.addWidget(self.show_x_grid_chk)
self.axis_settings_layout.addWidget(self.show_y_grid_chk)
self.axis_settings_layout.addWidget(self.axis_color_lbl)
self.axis_settings_layout.addWidget(self.axis_color_btn)
self.axis_settings_layout.addWidget(self.grid_opacity_lbl)
self.axis_settings_layout.addWidget(self.grid_opacity_slr)
self.axis_settings_grpbx.setLayout(self.axis_settings_layout)
self.chart_settings_layout.addWidget(self.graph_drawing_settings_grpbx)
self.chart_settings_layout.addWidget(self.axis_settings_grpbx)
self.chart_settings_layout.addWidget(self.reset_chart_settings_btn)
self.chart_sync_mode_async_radio.toggled.emit(True)
self.update_datetime_timer.start(1000)
def eventFilter(self, obj, event):
"""
Handle key and mouse events for any applicable widget.
Parameters
----------
obj : QWidget
The current widget that accepts the event
event : QEvent
The key or mouse event to handle
Returns
-------
True if the event was handled successfully; False otherwise
"""
if obj == self.pv_name_line_edt and event.type() == QEvent.KeyPress:
if event.key() == Qt.Key_Enter or event.key() == Qt.Key_Return:
self.add_curve()
return True
elif obj == self.chart_limit_time_span_activate_btn and event.type(
) == QEvent.KeyPress:
if event.key() == Qt.Key_Enter or event.key() == Qt.Key_Return:
self.handle_chart_limit_time_span_activate_btn_clicked()
return True
elif obj == self.chart_ring_buffer_size_edt:
if event.type() == QEvent.KeyPress and (event.key() == Qt.Key_Enter or event.key() == Qt.Key_Return) or \
event.type() == QEvent.FocusOut:
try:
buffer_size = int(self.chart_ring_buffer_size_edt.text())
if buffer_size < MINIMUM_BUFFER_SIZE:
self.chart_ring_buffer_size_edt.setText(
str(MINIMUM_BUFFER_SIZE))
except ValueError:
display_message_box(QMessageBox.Critical, "Invalid Values",
"Only integer values are accepted.")
return True
return super(PyDMChartingDisplay, self).eventFilter(obj, event)
def add_curve(self):
"""
Add a new curve to the chart.
"""
pv_name = self._get_full_pv_name(self.pv_name_line_edt.text())
color = random_color()
for k, v in self.channel_map.items():
if color == v.color:
color = random_color()
self.add_y_channel(pv_name=pv_name, curve_name=pv_name, color=color)
def handle_enable_crosshair_checkbox_clicked(self, is_checked):
self.chart.enableCrosshair(is_checked)
self.cross_hair_coord_lbl.setVisible(is_checked)
def add_y_channel(self,
pv_name,
curve_name,
color,
line_style=Qt.SolidLine,
line_width=2,
symbol=None,
symbol_size=None):
if pv_name in self.channel_map:
logger.error("'{0}' has already been added.".format(pv_name))
return
curve = self.chart.addYChannel(y_channel=pv_name,
name=curve_name,
color=color,
lineStyle=line_style,
lineWidth=line_width,
symbol=symbol,
symbolSize=symbol_size)
self.channel_map[pv_name] = curve
self.generate_pv_controls(pv_name, color)
self.enable_chart_control_buttons()
self.app.establish_widget_connections(self)
def generate_pv_controls(self, pv_name, curve_color):
"""
Generate a set of widgets to manage the appearance of a curve. The set of widgets includes:
1. A checkbox which shows the curve on the chart if checked, and hide the curve if not checked
2. Two buttons -- Modify... and Remove. Modify... will bring up the Curve Settings dialog. Remove will
delete the curve from the chart
This set of widgets will be hidden initially, until the first curve is plotted.
Parameters
----------
pv_name: str
The name of the PV the current curve is being plotted for
curve_color : QColor
The color of the curve to paint for the checkbox label to help the user track the curve to the checkbox
"""
checkbox = QCheckBox()
checkbox.setObjectName(pv_name)
palette = checkbox.palette()
palette.setColor(QPalette.Active, QPalette.WindowText, curve_color)
checkbox.setPalette(palette)
display_name = pv_name.split("://")[1]
if len(display_name) > MAX_DISPLAY_PV_NAME_LENGTH:
# Only display max allowed number of characters of the PV Name
display_name = display_name[:int(MAX_DISPLAY_PV_NAME_LENGTH / 2) - 1] + "..." + \
display_name[-int(MAX_DISPLAY_PV_NAME_LENGTH / 2) + 2:]
checkbox.setText(display_name)
data_text = QLabel()
data_text.setObjectName(pv_name)
data_text.setPalette(palette)
checkbox.setChecked(True)
checkbox.clicked.connect(
partial(self.handle_curve_chkbox_toggled, checkbox))
curve_btn_layout = QHBoxLayout()
modify_curve_btn = QPushButton("Modify...")
modify_curve_btn.setObjectName(pv_name)
modify_curve_btn.setMaximumWidth(100)
modify_curve_btn.clicked.connect(
partial(self.display_curve_settings_dialog, pv_name))
focus_curve_btn = QPushButton("Focus")
focus_curve_btn.setObjectName(pv_name)
focus_curve_btn.setMaximumWidth(100)
focus_curve_btn.clicked.connect(partial(self.focus_curve, pv_name))
annotate_curve_btn = QPushButton("Annotate...")
annotate_curve_btn.setObjectName(pv_name)
annotate_curve_btn.setMaximumWidth(100)
annotate_curve_btn.clicked.connect(
partial(self.annotate_curve, pv_name))
remove_curve_btn = QPushButton("Remove")
remove_curve_btn.setObjectName(pv_name)
remove_curve_btn.setMaximumWidth(100)
remove_curve_btn.clicked.connect(partial(self.remove_curve, pv_name))
curve_btn_layout.addWidget(modify_curve_btn)
curve_btn_layout.addWidget(focus_curve_btn)
curve_btn_layout.addWidget(annotate_curve_btn)
curve_btn_layout.addWidget(remove_curve_btn)
individual_curve_layout = QVBoxLayout()
individual_curve_layout.addWidget(checkbox)
individual_curve_layout.addWidget(data_text)
individual_curve_layout.addLayout(curve_btn_layout)
size_policy = QSizePolicy()
size_policy.setVerticalPolicy(QSizePolicy.Fixed)
individual_curve_grpbx = QGroupBox()
individual_curve_grpbx.setSizePolicy(size_policy)
individual_curve_grpbx.setObjectName(pv_name)
individual_curve_grpbx.setLayout(individual_curve_layout)
self.curve_settings_layout.addWidget(individual_curve_grpbx)
self.tab_panel.show()
def handle_curve_chkbox_toggled(self, checkbox):
"""
Handle a checkbox's checked and unchecked events.
If a checkbox is checked, find the curve from the channel map. If found, re-draw the curve with its previous
appearance settings.
If a checkbox is unchecked, remove the curve from the chart, but keep the cached data in the channel map.
Parameters
----------
checkbox : QCheckBox
The current checkbox being toggled
"""
pv_name = self._get_full_pv_name(checkbox.text())
if checkbox.isChecked():
curve = self.channel_map.get(pv_name, None)
if curve:
self.chart.addLegendItem(curve, pv_name,
self.show_legend_chk.isChecked())
curve.show()
else:
curve = self.chart.findCurve(pv_name)
if curve:
curve.hide()
self.chart.removeLegendItem(pv_name)
def display_curve_settings_dialog(self, pv_name):
"""
Bring up the Curve Settings dialog to modify the appearance of a curve.
Parameters
----------
pv_name : str
The name of the PV the curve is being plotted for
"""
self.curve_settings_disp = CurveSettingsDisplay(self, pv_name)
self.curve_settings_disp.show()
def focus_curve(self, pv_name):
curve = self.chart.findCurve(pv_name)
if curve:
self.chart.plotItem.setYRange(curve.minY, curve.maxY, padding=0)
def annotate_curve(self, pv_name):
curve = self.chart.findCurve(pv_name)
if curve:
annot = TextItem(
html=
'<div style="text-align: center"><span style="color: #FFF;">This is the'
'</span><br><span style="color: #FF0; font-size: 16pt;">PEAK</span></div>',
anchor=(-0.3, 0.5),
border='w',
fill=(0, 0, 255, 100))
annot = TextItem("test", anchor=(-0.3, 0.5))
self.chart.annotateCurve(curve, annot)
def remove_curve(self, pv_name):
"""
Remove a curve from the chart permanently. This will also clear the channel map cache from retaining the
removed curve's appearance settings.
Parameters
----------
pv_name : str
The name of the PV the curve is being plotted for
"""
curve = self.chart.findCurve(pv_name)
if curve:
self.chart.removeYChannel(curve)
del self.channel_map[pv_name]
self.chart.removeLegendItem(pv_name)
widgets = self.findChildren(
(QCheckBox, QLabel, QPushButton, QGroupBox), pv_name)
for w in widgets:
w.deleteLater()
if len(self.chart.getCurves()) < 1:
self.enable_chart_control_buttons(False)
self.show_legend_chk.setChecked(False)
def handle_title_text_changed(self, new_text):
self.chart.setPlotTitle(new_text)
def handle_change_axis_settings_clicked(self):
self.axis_settings_disp = AxisSettingsDisplay(self)
self.axis_settings_disp.show()
def handle_limit_time_span_checkbox_clicked(self, is_checked):
self.chart_limit_time_span_lbl.setVisible(is_checked)
self.chart_limit_time_span_hours_line_edt.setVisible(is_checked)
self.chart_limit_time_span_minutes_line_edt.setVisible(is_checked)
self.chart_limit_time_span_seconds_line_edt.setVisible(is_checked)
self.chart_limit_time_span_activate_btn.setVisible(is_checked)
self.chart_ring_buffer_size_lbl.setDisabled(is_checked)
self.chart_ring_buffer_size_edt.setDisabled(is_checked)
if not is_checked:
self.chart_limit_time_span_chk.setText(self.limit_time_plan_text)
def handle_time_span_edt_text_changed(self, new_text):
try:
self.time_span_limit_hours = int(
self.chart_limit_time_span_hours_line_edt.text())
self.time_span_limit_minutes = int(
self.chart_limit_time_span_minutes_line_edt.text())
self.time_span_limit_seconds = int(
self.chart_limit_time_span_seconds_line_edt.text())
except ValueError as e:
self.time_span_limit_hours = None
self.time_span_limit_minutes = None
self.time_span_limit_seconds = None
if self.time_span_limit_hours is not None and self.time_span_limit_minutes is not None and \
self.time_span_limit_seconds is not None:
self.chart_limit_time_span_activate_btn.setEnabled(True)
else:
self.chart_limit_time_span_activate_btn.setEnabled(False)
def handle_chart_limit_time_span_activate_btn_clicked(self):
if self.time_span_limit_hours is None or self.time_span_limit_minutes is None or \
self.time_span_limit_seconds is None:
display_message_box(
QMessageBox.Critical, "Invalid Values",
"Hours, minutes, and seconds expect only integer values.")
else:
timeout_milliseconds = (self.time_span_limit_hours * 3600 +
self.time_span_limit_minutes * 60 +
self.time_span_limit_seconds) * 1000
self.chart.setTimeSpan(timeout_milliseconds / 1000.0)
self.chart_ring_buffer_size_edt.setText(
str(self.chart.getBufferSize()))
def handle_buffer_size_changed(self, new_buffer_size):
try:
if new_buffer_size and int(new_buffer_size) > MINIMUM_BUFFER_SIZE:
self.chart.setBufferSize(new_buffer_size)
except ValueError:
display_message_box(QMessageBox.Critical, "Invalid Values",
"Only integer values are accepted.")
def handle_redraw_rate_changed(self, new_redraw_rate):
self.chart.maxRedrawRate = new_redraw_rate
def handle_data_sampling_rate_changed(self, new_data_sampling_rate):
# The chart expects the value in milliseconds
sampling_rate_seconds = 1 / new_data_sampling_rate
self.chart.setUpdateInterval(sampling_rate_seconds)
def handle_background_color_button_clicked(self):
selected_color = QColorDialog.getColor()
self.chart.setBackgroundColor(selected_color)
self.background_color_btn.setStyleSheet("background-color: " +
selected_color.name())
def handle_axis_color_button_clicked(self):
selected_color = QColorDialog.getColor()
self.chart.setAxisColor(selected_color)
self.axis_color_btn.setStyleSheet("background-color: " +
selected_color.name())
def handle_grid_opacity_slider_mouse_release(self):
self.grid_alpha = float(self.grid_opacity_slr.value()) / 10.0
self.chart.setShowXGrid(self.show_x_grid_chk.isChecked(),
self.grid_alpha)
self.chart.setShowYGrid(self.show_y_grid_chk.isChecked(),
self.grid_alpha)
def handle_show_x_grid_checkbox_clicked(self, is_checked):
self.chart.setShowXGrid(is_checked, self.grid_alpha)
self.axis_color_lbl.setEnabled(is_checked
or self.show_y_grid_chk.isChecked())
self.axis_color_btn.setEnabled(is_checked
or self.show_y_grid_chk.isChecked())
self.grid_opacity_lbl.setEnabled(is_checked
or self.show_y_grid_chk.isChecked())
self.grid_opacity_slr.setEnabled(is_checked
or self.show_y_grid_chk.isChecked())
def handle_show_y_grid_checkbox_clicked(self, is_checked):
self.chart.setShowYGrid(is_checked, self.grid_alpha)
self.axis_color_lbl.setEnabled(is_checked
or self.show_x_grid_chk.isChecked())
self.axis_color_btn.setEnabled(is_checked
or self.show_x_grid_chk.isChecked())
self.grid_opacity_lbl.setEnabled(is_checked
or self.show_x_grid_chk.isChecked())
self.grid_opacity_slr.setEnabled(is_checked
or self.show_x_grid_chk.isChecked())
def handle_show_legend_checkbox_clicked(self, is_checked):
self.chart.setShowLegend(is_checked)
def handle_export_data_btn_clicked(self):
self.chart_data_export_disp = ChartDataExportDisplay(self)
self.chart_data_export_disp.show()
def handle_import_data_btn_clicked(self):
open_file_info = QFileDialog.getOpenFileName(self,
caption="Save File",
filter="*." +
IMPORT_FILE_FORMAT)
open_file_name = open_file_info[0]
if open_file_name:
importer = SettingsImporter(self)
importer.import_settings(open_file_name)
def handle_sync_mode_radio_toggle(self, radio_btn):
if radio_btn.isChecked():
if radio_btn.text() == "Synchronous":
self.data_sampling_mode = SYNC_DATA_SAMPLING
self.chart_data_sampling_rate_lbl.hide()
self.chart_data_async_sampling_rate_spin.hide()
self.chart.resetTimeSpan()
self.chart_limit_time_span_chk.setChecked(False)
self.chart_limit_time_span_chk.clicked.emit(False)
self.chart_limit_time_span_chk.hide()
self.graph_drawing_settings_grpbx.setFixedHeight(180)
self.chart.setUpdatesAsynchronously(False)
elif radio_btn.text() == "Asynchronous":
self.data_sampling_mode = ASYNC_DATA_SAMPLING
self.chart_data_sampling_rate_lbl.show()
self.chart_data_async_sampling_rate_spin.show()
self.chart_limit_time_span_chk.show()
self.graph_drawing_settings_grpbx.setFixedHeight(270)
self.chart.setUpdatesAsynchronously(True)
self.app.establish_widget_connections(self)
def handle_auto_scale_btn_clicked(self):
self.chart.resetAutoRangeX()
self.chart.resetAutoRangeY()
def handle_view_all_button_clicked(self):
self.chart.getViewBox().autoRange()
def handle_pause_chart_btn_clicked(self):
if self.chart.pausePlotting():
self.pause_chart_btn.setText(self.pause_chart_text)
else:
self.pause_chart_btn.setText(self.resume_chart_text)
def handle_reset_chart_btn_clicked(self):
self.chart.getViewBox().setXRange(DEFAULT_X_MIN, 0)
self.chart.resetAutoRangeY()
@Slot()
def handle_reset_chart_settings_btn_clicked(self):
self.chart_ring_buffer_size_edt.setText(str(DEFAULT_BUFFER_SIZE))
self.chart_redraw_rate_spin.setValue(DEFAULT_REDRAW_RATE_HZ)
self.chart_data_async_sampling_rate_spin.setValue(
DEFAULT_DATA_SAMPLING_RATE_HZ)
self.chart_data_sampling_rate_lbl.hide()
self.chart_data_async_sampling_rate_spin.hide()
self.chart_sync_mode_async_radio.setChecked(True)
self.chart_sync_mode_async_radio.toggled.emit(True)
self.chart_limit_time_span_chk.setChecked(False)
self.chart_limit_time_span_chk.setText(self.limit_time_plan_text)
self.chart_limit_time_span_chk.clicked.emit(False)
self.chart.setUpdatesAsynchronously(True)
self.chart.resetTimeSpan()
self.chart.resetUpdateInterval()
self.chart.setBufferSize(DEFAULT_BUFFER_SIZE)
self.chart.setBackgroundColor(DEFAULT_CHART_BACKGROUND_COLOR)
self.background_color_btn.setStyleSheet(
"background-color: " + DEFAULT_CHART_BACKGROUND_COLOR.name())
self.chart.setAxisColor(DEFAULT_CHART_AXIS_COLOR)
self.axis_color_btn.setStyleSheet("background-color: " +
DEFAULT_CHART_AXIS_COLOR.name())
self.grid_opacity_slr.setValue(5)
self.show_x_grid_chk.setChecked(False)
self.show_x_grid_chk.clicked.emit(False)
self.show_y_grid_chk.setChecked(False)
self.show_y_grid_chk.clicked.emit(False)
self.show_legend_chk.setChecked(False)
self.chart.setShowXGrid(False)
self.chart.setShowYGrid(False)
self.chart.setShowLegend(False)
def enable_chart_control_buttons(self, enabled=True):
self.auto_scale_btn.setEnabled(enabled)
self.view_all_btn.setEnabled(enabled)
self.reset_chart_btn.setEnabled(enabled)
self.pause_chart_btn.setText(self.pause_chart_text)
self.pause_chart_btn.setEnabled(enabled)
self.export_data_btn.setEnabled(enabled)
def _get_full_pv_name(self, pv_name):
"""
Append the protocol to the PV Name.
Parameters
----------
pv_name : str
The name of the PV the curve is being plotted for
"""
if pv_name and "://" not in pv_name:
pv_name = ''.join([self.pv_protocol_cmb.currentText(), pv_name])
return pv_name
def handle_update_datetime_timer_timeout(self):
current_label = self.chart.getBottomAxisLabel()
new_label = "Current Time: " + PyDMChartingDisplay.get_current_datetime(
)
if X_AXIS_LABEL_SEPARATOR in current_label:
current_label = current_label[current_label.
find(X_AXIS_LABEL_SEPARATOR) +
len(X_AXIS_LABEL_SEPARATOR):]
new_label += X_AXIS_LABEL_SEPARATOR + current_label
self.chart.setLabel("bottom", text=new_label)
def update_curve_data(self, curve):
"""
Determine if the PV is active. If not, disable the related PV controls. If the PV is active, update the PV
controls' states.
Parameters
----------
curve : PlotItem
A PlotItem, i.e. a plot, to draw on the chart.
"""
pv_name = curve.name()
max_x = self.chart.getViewBox().viewRange()[1][0]
max_y = self.chart.getViewBox().viewRange()[1][1]
current_y = curve.data_buffer[1, -1]
widgets = self.findChildren((QCheckBox, QLabel, QPushButton), pv_name)
for w in widgets:
if np.isnan(current_y):
if isinstance(w, QCheckBox):
w.setChecked(False)
else:
if isinstance(w, QCheckBox) and not w.isEnabled():
w.setChecked(True)
if isinstance(w, QLabel):
w.clear()
w.setText(
"(yMin = {0:.3f}, yMax = {1:.3f}) y = {2:.3f}".format(
max_x, max_y, current_y))
w.show()
w.setEnabled(not np.isnan(current_y))
if isinstance(w, QPushButton) and w.text() == "Remove":
# Enable the Remove button to make removing inactive PVs possible anytime
w.setEnabled(True)
def show_mouse_coordinates(self, x, y):
self.cross_hair_coord_lbl.clear()
self.cross_hair_coord_lbl.setText("x = {0:.3f}, y = {1:.3f}".format(
x, y))
@staticmethod
def get_current_datetime():
current_date = datetime.datetime.now().strftime("%b %d, %Y")
current_time = datetime.datetime.now().strftime("%H:%M:%S")
current_datetime = current_time + ' (' + current_date + ')'
return current_datetime
@property
def gridAlpha(self):
return self.grid_alpha
def __init__(self, layer):
super().__init__(layer)
self.layer.events.interpolation.connect(self._on_interpolation_change)
self.layer.events.rendering.connect(self._on_rendering_change)
self.layer.events.iso_threshold.connect(self._on_iso_threshold_change)
self.layer.events.attenuation.connect(self._on_attenuation_change)
self.layer.dims.events.ndisplay.connect(self._on_ndisplay_change)
self.interpComboBox = QComboBox(self)
self.interpComboBox.activated[str].connect(self.changeInterpolation)
self.interpLabel = QLabel('interpolation:')
renderComboBox = QComboBox(self)
renderComboBox.addItems(Rendering.keys())
index = renderComboBox.findText(
self.layer.rendering, Qt.MatchFixedString
)
renderComboBox.setCurrentIndex(index)
renderComboBox.activated[str].connect(self.changeRendering)
self.renderComboBox = renderComboBox
self.renderLabel = QLabel('rendering:')
sld = QSlider(Qt.Horizontal, parent=self)
sld.setFocusPolicy(Qt.NoFocus)
sld.setMinimum(0)
sld.setMaximum(100)
sld.setSingleStep(1)
sld.setValue(int(self.layer.iso_threshold * 100))
sld.valueChanged.connect(self.changeIsoThreshold)
self.isoThresholdSlider = sld
self.isoThresholdLabel = QLabel('iso threshold:')
sld = QSlider(Qt.Horizontal, parent=self)
sld.setFocusPolicy(Qt.NoFocus)
sld.setMinimum(0)
sld.setMaximum(100)
sld.setSingleStep(1)
sld.setValue(int(self.layer.attenuation * 200))
sld.valueChanged.connect(self.changeAttenuation)
self.attenuationSlider = sld
self.attenuationLabel = QLabel('attenuation:')
self._on_ndisplay_change()
colormap_layout = QHBoxLayout()
colormap_layout.addWidget(self.colorbarLabel)
colormap_layout.addWidget(self.colormapComboBox)
colormap_layout.addStretch(1)
# grid_layout created in QtLayerControls
# addWidget(widget, row, column, [row_span, column_span])
self.grid_layout.addWidget(QLabel('opacity:'), 0, 0)
self.grid_layout.addWidget(self.opacitySlider, 0, 1)
self.grid_layout.addWidget(QLabel('contrast limits:'), 1, 0)
self.grid_layout.addWidget(self.contrastLimitsSlider, 1, 1)
self.grid_layout.addWidget(QLabel('gamma:'), 2, 0)
self.grid_layout.addWidget(self.gammaSlider, 2, 1)
self.grid_layout.addWidget(QLabel('colormap:'), 3, 0)
self.grid_layout.addLayout(colormap_layout, 3, 1)
self.grid_layout.addWidget(QLabel('blending:'), 4, 0)
self.grid_layout.addWidget(self.blendComboBox, 4, 1)
self.grid_layout.addWidget(self.interpLabel, 5, 0)
self.grid_layout.addWidget(self.interpComboBox, 5, 1)
self.grid_layout.addWidget(self.renderLabel, 6, 0)
self.grid_layout.addWidget(self.renderComboBox, 6, 1)
self.grid_layout.addWidget(self.isoThresholdLabel, 7, 0)
self.grid_layout.addWidget(self.isoThresholdSlider, 7, 1)
self.grid_layout.addWidget(self.attenuationLabel, 8, 0)
self.grid_layout.addWidget(self.attenuationSlider, 8, 1)
self.grid_layout.setRowStretch(9, 1)
self.grid_layout.setColumnStretch(1, 1)
self.grid_layout.setSpacing(4)
def __init__(self, layer):
super().__init__(layer)
self.layer.events.interpolation.connect(self._on_interpolation_change)
self.layer.events.rendering.connect(self._on_rendering_change)
self.layer.events.iso_threshold.connect(self._on_iso_threshold_change)
self.layer.dims.events.ndisplay.connect(self._on_ndisplay_change)
interp_comboBox = QComboBox()
for interp in Interpolation:
interp_comboBox.addItem(str(interp))
index = interp_comboBox.findText(self.layer.interpolation,
Qt.MatchFixedString)
interp_comboBox.setCurrentIndex(index)
interp_comboBox.activated[str].connect(
lambda text=interp_comboBox: self.changeInterpolation(text))
self.interpComboBox = interp_comboBox
self.interpLabel = QLabel('interpolation:')
renderComboBox = QComboBox()
for render in Rendering:
renderComboBox.addItem(str(render))
index = renderComboBox.findText(self.layer.rendering,
Qt.MatchFixedString)
renderComboBox.setCurrentIndex(index)
renderComboBox.activated[str].connect(
lambda text=renderComboBox: self.changeRendering(text))
self.renderComboBox = renderComboBox
self.renderLabel = QLabel('rendering:')
sld = QSlider(Qt.Horizontal)
sld.setFocusPolicy(Qt.NoFocus)
sld.setMinimum(0)
sld.setMaximum(100)
sld.setSingleStep(1)
sld.setValue(self.layer.iso_threshold * 100)
sld.valueChanged[int].connect(
lambda value=sld: self.changeIsoTheshold(value))
self.isoThesholdSilder = sld
self.isoThesholdLabel = QLabel('iso threshold:')
self._on_ndisplay_change(None)
# grid_layout created in QtLayerControls
# addWidget(widget, row, column, [row_span, column_span])
self.grid_layout.addWidget(QLabel('opacity:'), 0, 0)
self.grid_layout.addWidget(self.opacitySilder, 0, 1, 1, 2)
self.grid_layout.addWidget(QLabel('contrast limits:'), 1, 0)
self.grid_layout.addWidget(self.contrastLimitsSlider, 1, 1, 1, 2)
self.grid_layout.addWidget(QLabel('gamma:'), 2, 0)
self.grid_layout.addWidget(self.gammaSlider, 2, 1, 1, 2)
self.grid_layout.addWidget(self.isoThesholdLabel, 3, 0)
self.grid_layout.addWidget(self.isoThesholdSilder, 3, 1, 1, 2)
self.grid_layout.addWidget(QLabel('colormap:'), 4, 0)
self.grid_layout.addWidget(self.colormapComboBox, 4, 2)
self.grid_layout.addWidget(self.colorbarLabel, 4, 1)
self.grid_layout.addWidget(QLabel('blending:'), 5, 0)
self.grid_layout.addWidget(self.blendComboBox, 5, 1, 1, 2)
self.grid_layout.addWidget(self.renderLabel, 6, 0)
self.grid_layout.addWidget(self.renderComboBox, 6, 1, 1, 2)
self.grid_layout.addWidget(self.interpLabel, 7, 0)
self.grid_layout.addWidget(self.interpComboBox, 7, 1, 1, 2)
self.grid_layout.setRowStretch(8, 1)
self.grid_layout.setColumnStretch(1, 1)
self.grid_layout.setVerticalSpacing(4)
def __init__(self, layer):
super().__init__(layer)
self.layer.events.mode.connect(self._on_mode_change)
self.layer.events.n_dimensional.connect(self._on_n_dimensional_change)
self.layer.events.symbol.connect(self._on_symbol_change)
self.layer.events.size.connect(self._on_size_change)
self.layer.events.current_edge_color.connect(
self._on_current_edge_color_change)
self.layer.events.current_face_color.connect(
self._on_current_face_color_change)
self.layer.events.editable.connect(self._on_editable_change)
self.layer.text.events.visible.connect(self._on_text_visibility_change)
sld = QSlider(Qt.Horizontal)
sld.setFocusPolicy(Qt.NoFocus)
sld.setMinimum(1)
sld.setMaximum(100)
sld.setSingleStep(1)
value = self.layer.current_size
sld.setValue(int(value))
sld.valueChanged.connect(self.changeSize)
self.sizeSlider = sld
self.faceColorEdit = QColorSwatchEdit(
initial_color=self.layer.current_face_color,
tooltip='click to set current face color',
)
self.edgeColorEdit = QColorSwatchEdit(
initial_color=self.layer.current_edge_color,
tooltip='click to set current edge color',
)
self.faceColorEdit.color_changed.connect(self.changeFaceColor)
self.edgeColorEdit.color_changed.connect(self.changeEdgeColor)
symbol_comboBox = QComboBox()
symbol_comboBox.addItems([str(s) for s in Symbol])
index = symbol_comboBox.findText(self.layer.symbol,
Qt.MatchFixedString)
symbol_comboBox.setCurrentIndex(index)
symbol_comboBox.activated[str].connect(self.changeSymbol)
self.symbolComboBox = symbol_comboBox
ndim_cb = QCheckBox()
ndim_cb.setToolTip('N-dimensional points')
ndim_cb.setChecked(self.layer.n_dimensional)
ndim_cb.stateChanged.connect(self.change_ndim)
self.ndimCheckBox = ndim_cb
self.select_button = QtModeRadioButton(layer,
'select_points',
Mode.SELECT,
tooltip='Select points')
self.addition_button = QtModeRadioButton(layer,
'add_points',
Mode.ADD,
tooltip='Add points')
self.panzoom_button = QtModeRadioButton(layer,
'pan_zoom',
Mode.PAN_ZOOM,
tooltip='Pan/zoom',
checked=True)
self.delete_button = QtModePushButton(
layer,
'delete_shape',
slot=self.layer.remove_selected,
tooltip='Delete selected points',
)
text_disp_cb = QCheckBox()
text_disp_cb.setToolTip('toggle text visibility')
text_disp_cb.setChecked(self.layer.text.visible)
text_disp_cb.stateChanged.connect(self.change_text_visibility)
self.textDispCheckBox = text_disp_cb
self.button_group = QButtonGroup(self)
self.button_group.addButton(self.select_button)
self.button_group.addButton(self.addition_button)
self.button_group.addButton(self.panzoom_button)
button_row = QHBoxLayout()
button_row.addStretch(1)
button_row.addWidget(self.delete_button)
button_row.addWidget(self.addition_button)
button_row.addWidget(self.select_button)
button_row.addWidget(self.panzoom_button)
button_row.setContentsMargins(0, 0, 0, 5)
button_row.setSpacing(4)
# grid_layout created in QtLayerControls
# addWidget(widget, row, column, [row_span, column_span])
self.grid_layout.addLayout(button_row, 0, 1)
self.grid_layout.addWidget(QLabel('opacity:'), 1, 0)
self.grid_layout.addWidget(self.opacitySlider, 1, 1)
self.grid_layout.addWidget(QLabel('point size:'), 2, 0)
self.grid_layout.addWidget(self.sizeSlider, 2, 1)
self.grid_layout.addWidget(QLabel('blending:'), 3, 0)
self.grid_layout.addWidget(self.blendComboBox, 3, 1)
self.grid_layout.addWidget(QLabel('symbol:'), 4, 0)
self.grid_layout.addWidget(self.symbolComboBox, 4, 1)
self.grid_layout.addWidget(QLabel('face color:'), 5, 0)
self.grid_layout.addWidget(self.faceColorEdit, 5, 1)
self.grid_layout.addWidget(QLabel('edge color:'), 6, 0)
self.grid_layout.addWidget(self.edgeColorEdit, 6, 1)
self.grid_layout.addWidget(QLabel('display text:'), 7, 0)
self.grid_layout.addWidget(self.textDispCheckBox, 7, 1)
self.grid_layout.addWidget(QLabel('n-dim:'), 8, 0)
self.grid_layout.addWidget(self.ndimCheckBox, 8, 1)
self.grid_layout.setRowStretch(9, 1)
self.grid_layout.setColumnStretch(1, 1)
self.grid_layout.setSpacing(4)
def __init__(self, layer):
super().__init__()
self.layer = layer
layer.events.select.connect(lambda v: self.setSelected(True))
layer.events.deselect.connect(lambda v: self.setSelected(False))
layer.events.name.connect(self._on_layer_name_change)
layer.events.blending.connect(self._on_blending_change)
layer.events.opacity.connect(self._on_opacity_change)
layer.events.visible.connect(self._on_visible_change)
layer.events.thumbnail.connect(self._on_thumbnail_change)
self.setObjectName('layer')
self.vbox_layout = QVBoxLayout()
self.top = QFrame()
self.top_layout = QHBoxLayout()
self.grid = QFrame()
self.grid_layout = QGridLayout()
self.vbox_layout.addWidget(self.top)
self.vbox_layout.addWidget(self.grid)
self.vbox_layout.setSpacing(0)
self.top.setFixedHeight(38)
self.top_layout.setContentsMargins(0, 0, 0, 0)
self.grid_layout.setContentsMargins(0, 0, 0, 0)
self.top_layout.setAlignment(Qt.AlignCenter)
self.top.setLayout(self.top_layout)
self.grid.setLayout(self.grid_layout)
self.setLayout(self.vbox_layout)
self.name_column = 0
self.property_column = 1
cb = QCheckBox(self)
cb.setObjectName('visibility')
cb.setToolTip('Layer visibility')
cb.setChecked(self.layer.visible)
cb.setProperty('mode', 'visibility')
cb.stateChanged.connect(lambda state=cb: self.changeVisible(state))
self.visibleCheckBox = cb
self.top_layout.addWidget(cb)
tb = QLabel(self)
tb.setObjectName('thumbmnail')
tb.setToolTip('Layer thumbmnail')
self.thumbnail_label = tb
self._on_thumbnail_change(None)
self.top_layout.addWidget(tb)
textbox = QLineEdit(self)
textbox.setText(layer.name)
textbox.home(False)
textbox.setToolTip('Layer name')
textbox.setAcceptDrops(False)
textbox.setEnabled(True)
textbox.editingFinished.connect(self.changeText)
self.nameTextBox = textbox
self.top_layout.addWidget(textbox)
pb = QPushButton(self)
pb.setToolTip('Expand properties')
pb.clicked.connect(self.changeExpanded)
pb.setObjectName('expand')
self.expand_button = pb
self.top_layout.addWidget(pb)
row = self.grid_layout.rowCount()
sld = QSlider(Qt.Horizontal, self)
sld.setFocusPolicy(Qt.NoFocus)
sld.setMinimum(0)
sld.setMaximum(100)
sld.setSingleStep(1)
sld.setValue(self.layer.opacity * 100)
sld.valueChanged[int].connect(
lambda value=sld: self.changeOpacity(value))
self.opacitySilder = sld
row = self.grid_layout.rowCount()
self.grid_layout.addWidget(QLabel('opacity:'), row, self.name_column)
self.grid_layout.addWidget(sld, row, self.property_column)
row = self.grid_layout.rowCount()
blend_comboBox = QComboBox()
for blend in Blending:
blend_comboBox.addItem(str(blend))
index = blend_comboBox.findText(self.layer.blending,
Qt.MatchFixedString)
blend_comboBox.setCurrentIndex(index)
blend_comboBox.activated[str].connect(
lambda text=blend_comboBox: self.changeBlending(text))
self.blendComboBox = blend_comboBox
self.grid_layout.addWidget(QLabel('blending:'), row, self.name_column)
self.grid_layout.addWidget(blend_comboBox, row, self.property_column)
msg = 'Click to select\nDrag to rearrange\nDouble click to expand'
self.setToolTip(msg)
self.setExpanded(False)
self.setFixedWidth(250)
self.grid_layout.setColumnMinimumWidth(0, 100)
self.grid_layout.setColumnMinimumWidth(1, 100)
self.setSelected(self.layer.selected)
def __init__(self, layer):
super().__init__(layer)
self.layer.events.mode.connect(self._on_mode_change)
self.layer.events.edge_width.connect(self._on_edge_width_change)
self.layer.events.current_edge_color.connect(
self._on_current_edge_color_change
)
self.layer.events.current_face_color.connect(
self._on_current_face_color_change
)
self.layer.events.editable.connect(self._on_editable_change)
self.layer.text.events.visible.connect(self._on_text_visibility_change)
sld = QSlider(Qt.Horizontal)
sld.setFocusPolicy(Qt.NoFocus)
sld.setMinimum(0)
sld.setMaximum(40)
sld.setSingleStep(1)
value = self.layer.current_edge_width
if isinstance(value, Iterable):
if isinstance(value, list):
value = np.asarray(value)
value = value.mean()
sld.setValue(int(value))
sld.valueChanged.connect(self.changeWidth)
self.widthSlider = sld
def _radio_button(
parent,
btn_name,
mode,
action_name,
extra_tooltip_text='',
**kwargs,
):
"""
Convenience local function to create a RadioButton and bind it to
an action at the same time.
Parameters
----------
parent : Any
Parent of the generated QtModeRadioButton
btn_name : str
name fo the button
mode : Enum
Value Associated to current button
action_name : str
Action triggered when button pressed
extra_tooltip_text : str
Text you want added after the automatic tooltip set by the
action manager
**kwargs:
Passed to QtModeRadioButton
Returns
-------
button: QtModeRadioButton
button bound (or that will be bound to) to action `action_name`
Notes
-----
When shortcuts are modifed/added/removed via the action manager, the
tooltip will be updated to reflect the new shortcut.
"""
action_name = 'napari:' + action_name
btn = QtModeRadioButton(parent, btn_name, mode, **kwargs)
action_manager.bind_button(
action_name,
btn,
extra_tooltip_text='',
)
return btn
self.select_button = _radio_button(
layer, 'select', Mode.SELECT, "activate_select_mode"
)
self.direct_button = _radio_button(
layer, 'direct', Mode.DIRECT, "activate_direct_mode"
)
self.panzoom_button = _radio_button(
layer,
'zoom',
Mode.PAN_ZOOM,
"napari:activate_shape_pan_zoom_mode",
extra_tooltip_text=trans._('(or hold Space)'),
checked=True,
)
self.rectangle_button = _radio_button(
layer,
'rectangle',
Mode.ADD_RECTANGLE,
"activate_add_rectangle_mode",
)
self.ellipse_button = _radio_button(
layer,
'ellipse',
Mode.ADD_ELLIPSE,
"activate_add_ellipse_mode",
)
self.line_button = _radio_button(
layer, 'line', Mode.ADD_LINE, "activate_add_line_mode"
)
self.path_button = _radio_button(
layer, 'path', Mode.ADD_PATH, "activate_add_path_mode"
)
self.polygon_button = _radio_button(
layer,
'polygon',
Mode.ADD_POLYGON,
"activate_add_polygon_mode",
)
self.vertex_insert_button = _radio_button(
layer,
'vertex_insert',
Mode.VERTEX_INSERT,
"activate_vertex_insert_mode",
)
self.vertex_remove_button = _radio_button(
layer,
'vertex_remove',
Mode.VERTEX_REMOVE,
"activate_vertex_remove_mode",
)
self.move_front_button = QtModePushButton(
layer,
'move_front',
slot=self.layer.move_to_front,
tooltip=trans._('Move to front'),
)
action_manager.bind_button(
'napari:move_shapes_selection_to_front', self.move_front_button
)
self.move_back_button = QtModePushButton(
layer,
'move_back',
slot=self.layer.move_to_back,
tooltip=trans._('Move to back'),
)
action_manager.bind_button(
'napari:move_shapes_selection_to_back', self.move_back_button
)
self.delete_button = QtModePushButton(
layer,
'delete_shape',
slot=self.layer.remove_selected,
tooltip=trans._(
"Delete selected shapes ({shortcut})",
shortcut=Shortcut('Backspace').platform,
),
)
self.button_group = QButtonGroup(self)
self.button_group.addButton(self.select_button)
self.button_group.addButton(self.direct_button)
self.button_group.addButton(self.panzoom_button)
self.button_group.addButton(self.rectangle_button)
self.button_group.addButton(self.ellipse_button)
self.button_group.addButton(self.line_button)
self.button_group.addButton(self.path_button)
self.button_group.addButton(self.polygon_button)
self.button_group.addButton(self.vertex_insert_button)
self.button_group.addButton(self.vertex_remove_button)
button_grid = QGridLayout()
button_grid.addWidget(self.vertex_remove_button, 0, 2)
button_grid.addWidget(self.vertex_insert_button, 0, 3)
button_grid.addWidget(self.delete_button, 0, 4)
button_grid.addWidget(self.direct_button, 0, 5)
button_grid.addWidget(self.select_button, 0, 6)
button_grid.addWidget(self.panzoom_button, 0, 7)
button_grid.addWidget(self.move_back_button, 1, 1)
button_grid.addWidget(self.move_front_button, 1, 2)
button_grid.addWidget(self.ellipse_button, 1, 3)
button_grid.addWidget(self.rectangle_button, 1, 4)
button_grid.addWidget(self.polygon_button, 1, 5)
button_grid.addWidget(self.line_button, 1, 6)
button_grid.addWidget(self.path_button, 1, 7)
button_grid.setContentsMargins(5, 0, 0, 5)
button_grid.setColumnStretch(0, 1)
button_grid.setSpacing(4)
self.faceColorEdit = QColorSwatchEdit(
initial_color=self.layer.current_face_color,
tooltip=trans._('click to set current face color'),
)
self._on_current_face_color_change()
self.edgeColorEdit = QColorSwatchEdit(
initial_color=self.layer.current_edge_color,
tooltip=trans._('click to set current edge color'),
)
self._on_current_edge_color_change()
self.faceColorEdit.color_changed.connect(self.changeFaceColor)
self.edgeColorEdit.color_changed.connect(self.changeEdgeColor)
text_disp_cb = QCheckBox()
text_disp_cb.setToolTip(trans._('toggle text visibility'))
text_disp_cb.setChecked(self.layer.text.visible)
text_disp_cb.stateChanged.connect(self.change_text_visibility)
self.textDispCheckBox = text_disp_cb
# grid_layout created in QtLayerControls
# addWidget(widget, row, column, [row_span, column_span])
self.grid_layout.addLayout(button_grid, 0, 0, 1, 2)
self.grid_layout.addWidget(QLabel(trans._('opacity:')), 1, 0)
self.grid_layout.addWidget(self.opacitySlider, 1, 1)
self.grid_layout.addWidget(QLabel(trans._('edge width:')), 2, 0)
self.grid_layout.addWidget(self.widthSlider, 2, 1)
self.grid_layout.addWidget(QLabel(trans._('blending:')), 3, 0)
self.grid_layout.addWidget(self.blendComboBox, 3, 1)
self.grid_layout.addWidget(QLabel(trans._('face color:')), 4, 0)
self.grid_layout.addWidget(self.faceColorEdit, 4, 1)
self.grid_layout.addWidget(QLabel(trans._('edge color:')), 5, 0)
self.grid_layout.addWidget(self.edgeColorEdit, 5, 1)
self.grid_layout.addWidget(QLabel(trans._('display text:')), 6, 0)
self.grid_layout.addWidget(self.textDispCheckBox, 6, 1)
self.grid_layout.setRowStretch(7, 1)
self.grid_layout.setColumnStretch(1, 1)
self.grid_layout.setSpacing(4)
def __init__(self, layer):
super().__init__(layer)
self.layer.events.mode.connect(self._on_mode_change)
self.layer.events.n_dimensional.connect(self._on_n_dimensional_change)
self.layer.events.symbol.connect(self._on_symbol_change)
self.layer.events.size.connect(self._on_size_change)
self.layer.events.current_edge_color.connect(
self._on_current_edge_color_change)
self.layer._edge.events.current_color.connect(
self._on_current_edge_color_change)
self.layer.events.current_face_color.connect(
self._on_current_face_color_change)
self.layer._face.events.current_color.connect(
self._on_current_face_color_change)
self.layer.events.editable.connect(self._on_editable_change)
self.layer.text.events.visible.connect(self._on_text_visibility_change)
sld = QSlider(Qt.Horizontal)
sld.setFocusPolicy(Qt.NoFocus)
sld.setMinimum(1)
sld.setMaximum(100)
sld.setSingleStep(1)
value = self.layer.current_size
sld.setValue(int(value))
sld.valueChanged.connect(self.changeSize)
self.sizeSlider = sld
self.faceColorEdit = QColorSwatchEdit(
initial_color=self.layer.current_face_color,
tooltip=trans._('click to set current face color'),
)
self.edgeColorEdit = QColorSwatchEdit(
initial_color=self.layer.current_edge_color,
tooltip=trans._('click to set current edge color'),
)
self.faceColorEdit.color_changed.connect(self.changeFaceColor)
self.edgeColorEdit.color_changed.connect(self.changeEdgeColor)
symbol_comboBox = QComboBox()
current_index = 0
for index, (data, text) in enumerate(SYMBOL_TRANSLATION.items()):
data = data.value
symbol_comboBox.addItem(text, data)
if data == self.layer.symbol:
current_index = index
symbol_comboBox.setCurrentIndex(current_index)
symbol_comboBox.activated[str].connect(self.changeSymbol)
self.symbolComboBox = symbol_comboBox
ndim_cb = QCheckBox()
ndim_cb.setToolTip(trans._('N-dimensional points'))
ndim_cb.setChecked(self.layer.n_dimensional)
ndim_cb.stateChanged.connect(self.change_ndim)
self.ndimCheckBox = ndim_cb
self.select_button = QtModeRadioButton(
layer,
'select_points',
Mode.SELECT,
)
action_manager.bind_button('napari:activate_points_select_mode',
self.select_button)
self.addition_button = QtModeRadioButton(layer, 'add_points', Mode.ADD)
action_manager.bind_button('napari:activate_points_add_mode',
self.addition_button)
self.panzoom_button = QtModeRadioButton(
layer,
'pan_zoom',
Mode.PAN_ZOOM,
checked=True,
)
action_manager.bind_button('napari:activate_points_pan_zoom_mode',
self.panzoom_button)
self.delete_button = QtModePushButton(
layer,
'delete_shape',
)
action_manager.bind_button('napari:delete_selected_points',
self.delete_button)
text_disp_cb = QCheckBox()
text_disp_cb.setToolTip(trans._('toggle text visibility'))
text_disp_cb.setChecked(self.layer.text.visible)
text_disp_cb.stateChanged.connect(self.change_text_visibility)
self.textDispCheckBox = text_disp_cb
self.button_group = QButtonGroup(self)
self.button_group.addButton(self.select_button)
self.button_group.addButton(self.addition_button)
self.button_group.addButton(self.panzoom_button)
button_row = QHBoxLayout()
button_row.addStretch(1)
button_row.addWidget(self.delete_button)
button_row.addWidget(self.addition_button)
button_row.addWidget(self.select_button)
button_row.addWidget(self.panzoom_button)
button_row.setContentsMargins(0, 0, 0, 5)
button_row.setSpacing(4)
# grid_layout created in QtLayerControls
# addWidget(widget, row, column, [row_span, column_span])
self.grid_layout.addLayout(button_row, 0, 1)
self.grid_layout.addWidget(QLabel(trans._('opacity:')), 1, 0)
self.grid_layout.addWidget(self.opacitySlider, 1, 1)
self.grid_layout.addWidget(QLabel(trans._('point size:')), 2, 0)
self.grid_layout.addWidget(self.sizeSlider, 2, 1)
self.grid_layout.addWidget(QLabel(trans._('blending:')), 3, 0)
self.grid_layout.addWidget(self.blendComboBox, 3, 1)
self.grid_layout.addWidget(QLabel(trans._('symbol:')), 4, 0)
self.grid_layout.addWidget(self.symbolComboBox, 4, 1)
self.grid_layout.addWidget(QLabel(trans._('face color:')), 5, 0)
self.grid_layout.addWidget(self.faceColorEdit, 5, 1)
self.grid_layout.addWidget(QLabel(trans._('edge color:')), 6, 0)
self.grid_layout.addWidget(self.edgeColorEdit, 6, 1)
self.grid_layout.addWidget(QLabel(trans._('display text:')), 7, 0)
self.grid_layout.addWidget(self.textDispCheckBox, 7, 1)
self.grid_layout.addWidget(QLabel(trans._('n-dim:')), 8, 0)
self.grid_layout.addWidget(self.ndimCheckBox, 8, 1)
self.grid_layout.setRowStretch(9, 1)
self.grid_layout.setColumnStretch(1, 1)
self.grid_layout.setSpacing(4)