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 createSlider(self):
slider = QSlider(Qt.Vertical)
slider.setRange(0, 360 * 16)
slider.setSingleStep(16)
slider.setPageStep(15 * 16)
slider.setTickInterval(15 * 16)
slider.setTickPosition(QSlider.TicksRight)
return slider
def createZoomSlider(self):
slider = QSlider(Qt.Vertical)
slider.setRange(1, 1000000)
slider.setSingleStep(1)
slider.setPageStep(10)
slider.setTickInterval(10)
slider.setTickPosition(QSlider.TicksRight)
return slider
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._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)
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.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)
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.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)
class ColorbarEditor(EasyDialog):
NAME = _("Colorbar editor")
HELP_BODY = _("Click a triangle to change its color. <br>"
"Drag triangles to move. <br>"
"Click in an empty area to add a new color. <br>"
"Right click a triangle to remove. <br>"
"Right click axis or region, click View All, to zoom. <br>"
"Mouse wheel zoom in/out when cursor on axis or region. <br>"
"After zoom out, drag the region to move along the axis. <br>"
"Right click the colorbar to select different colormap. <br>"
"One of the four bars can be enabled by set Orientation. <br>"
"The bar widgets can be resized by the move the splitter. <br>")
def __init__(self, parent=None):
EasyDialog.__init__(self, parent=parent, set_tree=True, set_db=True)
self.dob = None
self.clip_min = 0
self.clip_max = 1
self.setup_page()
def setup_page(self):
vbox = QVBoxLayout()
btnWidget = QWidget(self)
btnWidget.setLayout(vbox)
text = _("Object")
geom = ['Point', 'Line', 'Tsurface', 'Gsurface', 'Cube']
self.grabob = self.create_grabob(text, geom=geom)
vbox.addWidget(self.grabob)
text = _("Property")
self.prop = self.create_combobox(text)
btn_load_property = QPushButton(_('Load'))
btn_load_property.clicked.connect(self.load_property)
hbox = QHBoxLayout()
hbox.addWidget(self.prop)
hbox.addWidget(btn_load_property)
vbox.addLayout(hbox)
lbl_orientation = QLabel(_('Orientation'))
rb_top = QRadioButton('Top')
rb_bottom = QRadioButton('Bottom')
rb_left = QRadioButton('Left')
rb_right = QRadioButton('Right')
hbox = QHBoxLayout()
hbox.addWidget(lbl_orientation)
hbox.addWidget(rb_top)
hbox.addWidget(rb_bottom)
hbox.addWidget(rb_left)
hbox.addWidget(rb_right)
vbox.addLayout(hbox)
lbl_clip_min = QLabel(_('Clip minimum'))
lbl_clip_max = QLabel(_('Clip maximum'))
self.le_clip_min = QLineEdit('0')
self.le_clip_max = QLineEdit('1')
hbox = QHBoxLayout()
hbox.addWidget(lbl_clip_min)
hbox.addWidget(self.le_clip_min)
hbox.addWidget(lbl_clip_max)
hbox.addWidget(self.le_clip_max)
vbox.addLayout(hbox)
opacity = QLabel(_('Opacity'))
self.opacity = QSlider(Qt.Horizontal)
self.opacity.setTracking(False)
self.opacity.setTickPosition(QSlider.TicksBelow)
self.opacity.setSingleStep(1)
self.opacity.setRange(0, 255)
self.opacity.setValue(255)
self.opacity.valueChanged.connect(self.opacity_changed)
hbox = QHBoxLayout()
hbox.addWidget(opacity)
hbox.addWidget(self.opacity)
vbox.addLayout(hbox)
action = self.create_action()
vbox.addWidget(action)
hlut_right = HistogramLUTWidget(orientation='right',
gradients=customGradients)
hlut_left = HistogramLUTWidget(orientation='left',
gradients=customGradients)
hlut_bottom = HistogramLUTWidget(orientation='bottom',
gradients=customGradients)
hlut_top = HistogramLUTWidget(orientation='top',
gradients=customGradients)
lbl_hlut_help = QLabel("You can activate any one of the four.")
split1 = QSplitter(Qt.Vertical)
split1.addWidget(hlut_top)
split1.addWidget(lbl_hlut_help)
split1.addWidget(hlut_bottom)
# split1.setStretchFactor(0, 0)
# split1.setStretchFactor(1, 1)
# split1.setStretchFactor(2, 0)
# split1.setSizes([50, 400, 50])
split2 = QSplitter(Qt.Horizontal)
split2.addWidget(hlut_left)
split2.addWidget(split1)
split2.addWidget(hlut_right)
split3 = QSplitter(Qt.Vertical)
split3.addWidget(btnWidget)
split3.addWidget(split2)
self.layout.addWidget(split3)
# self.le_clip_min.editingFinished.connect(self.clip_changed)
# self.le_clip_max.editingFinished.connect(self.clip_changed)
self.hlut_list = [hlut_top, hlut_bottom, hlut_left, hlut_right]
rb_top.toggled.connect(lambda:self.set_orientation(rb_top))
rb_bottom.toggled.connect(lambda:self.set_orientation(rb_bottom))
rb_left.toggled.connect(lambda:self.set_orientation(rb_left))
rb_right.toggled.connect(lambda:self.set_orientation(rb_right))
rb_right.setChecked(True)
def opacity_changed(self):
"""
Potentially can use non-constant opacity e.g. user can define
any opacity gradient, linear interpolate on the color gradient
ticks and set Alpha in the RGBA.
"""
opacity = self.opacity.value()
gradient = self.hlut_active.gradient.saveState()
set_gradient_alpha(gradient, opacity)
prop_name = self.prop_name
self.dob.set_gradient(prop_name, gradient)
self.dob.make_colormap(prop_name)
self.dob.update_plots_by_prop()
def set_orientation(self, rb):
if rb.isChecked():
if rb.text() == "Top":
index = 0
elif rb.text() == "Bottom":
index = 1
elif rb.text() == "Left":
index = 2
elif rb.text() == "Right":
index = 3
else:
raise ValueError("Unknown value")
self.hlut_active = self.hlut_list[index]
self.hlut_active.setEnabled(True)
for i in range(len(self.hlut_list)):
if i != index:
self.hlut_list[i].setEnabled(False)
self.hlut_active.sigLevelChangeFinished.connect(self.level_changed)
self.hlut_active.sigLevelChangeFinished.connect(self.apply)
# self.hlut_active.sigLookupTableChanged.connect(self.apply)
if self.dob is not None:
self.load_hlut()
def level_changed(self):
"""
Level is changed in the hlut by mouse dragging, now sync textbox.
"""
self.clip_min, self.clip_max = self.hlut_active.getLevels()
self.le_clip_min.setText(str(self.clip_min))
self.le_clip_max.setText(str(self.clip_max))
def clip_changed(self):
"""
Clip is changed in the textbox by user typing, now sync hlut.
"""
self.clip_min = float(self.le_clip_min.text())
self.clip_max = float(self.le_clip_max.text())
self.hlut_active.setLevels(self.clip_min, self.clip_max)
def apply(self):
if self.dob is None:
logger.warning('No data object is loaded yet')
return
self.clip_changed()
prop_name = self.prop_name
# save to dob for updating plots of the object
clip = self.hlut_active.getLevels()
self.dob.set_clip(prop_name, clip)
# save the colorbar/gradient as a dictionary
gradient = self.hlut_active.gradient.saveState()
opacity = self.opacity.value()
set_gradient_alpha(gradient, opacity)
self.dob.set_gradient(prop_name, gradient)
self.dob.make_colormap(prop_name)
self.dob.update_plots_by_prop()
# TODO handle points multiple properties
def grab_object_rc(self):
""" Used when dialog is brought up by right click in tree. """
geom = ['Point', 'Line', 'Tsurface', 'Gsurface', 'Cube']
self.dob = self.treebase.grab_object(geom)
self.grabob.lineedit.edit.setText(self.dob.name)
self.propList = list(self.dob.prop.keys())
self.prop.combobox.clear()
self.prop.combobox.addItems(self.propList)
self.grab_property()
def load_object(self):
self.dob = self.object # from EasyDialog grab_object
self.propList = list(self.dob.prop.keys())
self.prop.combobox.clear()
self.prop.combobox.addItems(self.propList)
self.grab_property()
def grab_property(self):
prop_name = self.dob.current_property
index = self.propList.index(prop_name)
self.prop.combobox.setCurrentIndex(index)
def load_property(self):
"""
"""
object_name = self.grabob.lineedit.edit.text()
self.prop_name = self.prop.combobox.currentText()
self.dob = self.database[object_name]
self.load_hlut()
def load_hlut(self):
prop_name = self.prop_name
cg = self.dob.prop[prop_name]['colorGradient']
if cg is not None:
self.hlut_active.gradient.restoreState(cg)
self.clip_min, self.clip_max = self.dob.prop[prop_name]['colorClip']
self.hlut_active.setLevels(self.clip_min, self.clip_max)
# Assume constant alpha, so use the first value
alpha = cg['ticks'][0][1][3]
self.opacity.setValue(alpha)
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 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 create_wwwc_tab(apply_adjust):
Conf = namedtuple("Conf", "min max step default")
ww_conf = Conf(0, 2000, 1, 350)
wc_conf = Conf(-2000, 2000, 1, 50)
tab = QWidget()
tab.layout = QFormLayout()
# BUG: åŖęäøäøŖč“å·ēę¶åä¼åę0ļ¼åŗčÆ„äæēč“å·
ww_edit = QLineEdit()
ww_edit.setValidator(QtGui.QIntValidator(ww_conf.min, ww_conf.max))
ww_edit.setFixedWidth(50)
wc_edit = QLineEdit()
wc_edit.setValidator(QtGui.QIntValidator(wc_conf.min, wc_conf.max))
wc_edit.setFixedWidth(50)
ww_slider = QSlider(Qt.Horizontal) # ēŖ宽ę»åØę”
ww_slider.setMinimum(ww_conf.min)
ww_slider.setMaximum(ww_conf.max)
ww_slider.setSingleStep(ww_conf.step)
ww_slider.setValue(ww_conf.default)
wc_slider = QSlider(Qt.Horizontal) # ēŖä½ę»åØę”
wc_slider.setMinimum(wc_conf.min)
wc_slider.setMaximum(wc_conf.max)
wc_slider.setSingleStep(wc_conf.step)
wc_slider.setValue(wc_conf.default)
ww_label = QLabel()
ww_label.setText("ēŖ宽: ")
wc_label = QLabel()
wc_label.setText("ēŖä½: ")
ww_combo = QHBoxLayout()
ww_combo.addWidget(ww_edit)
ww_combo.addWidget(ww_slider)
wc_combo = QHBoxLayout()
wc_combo.addWidget(wc_edit)
wc_combo.addWidget(wc_slider)
tab.layout.addRow(ww_label, ww_combo)
tab.layout.addRow(wc_label, wc_combo)
tab.setLayout(tab.layout)
def slider_change(slider, editor):
def func():
editor.setText(str(slider.value()))
apply_adjust(
functools.partial(wwwc, ww_slider.value(), wc_slider.value()))
return func
def edit_changed(editor, slider):
def func():
value = editor.text()
if value == "" or value == "-":
value = 0
value = int(value)
slider.setValue(value)
return func
ww_slider.valueChanged.connect(slider_change(ww_slider, ww_edit))
wc_slider.valueChanged.connect(slider_change(wc_slider, wc_edit))
ww_edit.textChanged.connect(edit_changed(ww_edit, ww_slider))
# wc_edit.textChanged.connect(wc_edit_change)
return tab, "WW/WC"
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)
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)
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
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()
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.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__()
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.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)
class PyDMSlider(QFrame, PyDMWritableWidget):
"""
A QSlider with support for Channels and more from PyDM.
Parameters
----------
parent : QWidget
The parent widget for the Label
init_channel : str, optional
The channel to be used by the widget.
"""
actionTriggered = Signal(int)
rangeChanged = Signal(float, float)
sliderMoved = Signal(float)
sliderPressed = Signal()
sliderReleased = Signal()
valueChanged = Signal(float)
def __init__(self, parent=None, init_channel=None):
QFrame.__init__(self, parent)
PyDMWritableWidget.__init__(self, init_channel=init_channel)
self.alarmSensitiveContent = True
self.alarmSensitiveBorder = False
# Internal values for properties
self.set_enable_state()
self._show_limit_labels = True
self._show_value_label = True
self._user_defined_limits = False
self._needs_limit_info = True
self._minimum = None
self._maximum = None
self._user_minimum = -10.0
self._user_maximum = 10.0
self._num_steps = 101
self._orientation = Qt.Horizontal
# Set up all the internal widgets that make up a PyDMSlider.
# We'll add all these things to layouts when we call setup_widgets_for_orientation
label_size_policy = QSizePolicy(QSizePolicy.Maximum, QSizePolicy.Fixed)
self.low_lim_label = QLabel(self)
self.low_lim_label.setObjectName("lowLimLabel")
self.low_lim_label.setSizePolicy(label_size_policy)
self.low_lim_label.setAlignment(Qt.AlignLeft | Qt.AlignTrailing
| Qt.AlignVCenter)
self.value_label = QLabel(self)
self.value_label.setObjectName("valueLabel")
self.value_label.setAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
self.high_lim_label = QLabel(self)
self.high_lim_label.setObjectName("highLimLabel")
self.high_lim_label.setSizePolicy(label_size_policy)
self.high_lim_label.setAlignment(Qt.AlignRight | Qt.AlignTrailing
| Qt.AlignVCenter)
self._slider = QSlider(parent=self)
self._slider.setOrientation(Qt.Horizontal)
self._slider.sliderMoved.connect(self.internal_slider_moved)
self._slider.sliderPressed.connect(self.internal_slider_pressed)
self._slider.sliderReleased.connect(self.internal_slider_released)
self._slider.valueChanged.connect(self.internal_slider_value_changed)
# self.vertical_layout.addWidget(self._slider)
# Other internal variables and final setup steps
self._slider_position_to_value_map = None
self._mute_internal_slider_changes = False
self.setup_widgets_for_orientation(self._orientation)
self.reset_slider_limits()
def init_for_designer(self):
"""
Method called after the constructor to tweak configurations for
when using the widget with the Qt Designer
"""
self.value = 0.0
@Property(Qt.Orientation)
def orientation(self):
"""
The slider orientation (Horizontal or Vertical)
Returns
-------
int
Qt.Horizontal or Qt.Vertical
"""
return self._orientation
@orientation.setter
def orientation(self, new_orientation):
"""
The slider orientation (Horizontal or Vertical)
Parameters
----------
new_orientation : int
Qt.Horizontal or Qt.Vertical
"""
self._orientation = new_orientation
self.setup_widgets_for_orientation(new_orientation)
def setup_widgets_for_orientation(self, new_orientation):
"""
Reconstruct the widget given the orientation.
Parameters
----------
new_orientation : int
Qt.Horizontal or Qt.Vertical
"""
if new_orientation not in (Qt.Horizontal, Qt.Vertical):
logger.error(
"Invalid orientation '{0}'. The existing layout will not change."
.format(new_orientation))
return
layout = None
if new_orientation == Qt.Horizontal:
layout = QVBoxLayout()
layout.setContentsMargins(4, 0, 4, 4)
label_layout = QHBoxLayout()
label_layout.addWidget(self.low_lim_label)
label_layout.addStretch(0)
label_layout.addWidget(self.value_label)
label_layout.addStretch(0)
label_layout.addWidget(self.high_lim_label)
layout.addLayout(label_layout)
self._slider.setOrientation(new_orientation)
layout.addWidget(self._slider)
elif new_orientation == Qt.Vertical:
layout = QHBoxLayout()
layout.setContentsMargins(0, 4, 4, 4)
label_layout = QVBoxLayout()
label_layout.addWidget(self.high_lim_label)
label_layout.addStretch(0)
label_layout.addWidget(self.value_label)
label_layout.addStretch(0)
label_layout.addWidget(self.low_lim_label)
layout.addLayout(label_layout)
self._slider.setOrientation(new_orientation)
layout.addWidget(self._slider)
if self.layout() is not None:
# Trick to remove the existing layout by re-parenting it in an empty widget.
QWidget().setLayout(self.layout())
self.setLayout(layout)
def update_labels(self):
"""
Update the limits and value labels with the correct values.
"""
def set_label(value, label_widget):
if value is None:
label_widget.setText("")
else:
label_widget.setText(self.format_string.format(value))
set_label(self.minimum, self.low_lim_label)
set_label(self.maximum, self.high_lim_label)
set_label(self.value, self.value_label)
def reset_slider_limits(self):
"""
Reset the limits and adjust the labels properly for the slider.
"""
if self.minimum is None or self.maximum is None:
self._needs_limit_info = True
self.set_enable_state()
return
self._needs_limit_info = False
self._slider.setMinimum(0)
self._slider.setMaximum(self._num_steps - 1)
self._slider.setSingleStep(1)
self._slider.setPageStep(10)
self._slider_position_to_value_map = np.linspace(self.minimum,
self.maximum,
num=self._num_steps)
self.update_labels()
self.set_slider_to_closest_value(self.value)
self.rangeChanged.emit(self.minimum, self.maximum)
self.set_enable_state()
def find_closest_slider_position_to_value(self, val):
"""
Find and returns the index for the closest position on the slider
for a given value.
Parameters
----------
val : float
Returns
-------
int
"""
diff = abs(self._slider_position_to_value_map - float(val))
return np.argmin(diff)
def set_slider_to_closest_value(self, val):
"""
Set the value for the slider according to a given value.
Parameters
----------
val : float
"""
if val is None or self._needs_limit_info:
return
# When we set the slider to the closest value, it may end up at a slightly
# different position than val (if val is not in self._slider_position_to_value_map)
# We don't want that slight difference to get broacast out and put the channel
# somewhere new. For example, if the slider can only be at 0.4 or 0.5, but a
# new value comes in of 0.45, its more important to keep the 0.45 than to change
# it to where the slider gets set. Therefore, we mute the internal slider changes
# so that its valueChanged signal doesn't cause us to emit a signal to PyDM to change
# the value of the channel.
self._mute_internal_slider_changes = True
self._slider.setValue(self.find_closest_slider_position_to_value(val))
self._mute_internal_slider_changes = False
def value_changed(self, new_val):
"""
Callback invoked when the Channel value is changed.
Parameters
----------
new_val : int or float
The new value from the channel.
"""
PyDMWritableWidget.value_changed(self, new_val)
if hasattr(self, "value_label"):
self.value_label.setText(self.format_string.format(self.value))
if not self._slider.isSliderDown():
self.set_slider_to_closest_value(self.value)
def ctrl_limit_changed(self, which, new_limit):
"""
Callback invoked when the Channel receives new control limit
values.
Parameters
----------
which : str
Which control limit was changed. "UPPER" or "LOWER"
new_limit : float
New value for the control limit
"""
PyDMWritableWidget.ctrl_limit_changed(self, which, new_limit)
if not self.userDefinedLimits:
self.reset_slider_limits()
def update_format_string(self):
"""
Reconstruct the format string to be used when representing the
output value.
Returns
-------
format_string : str
The format string to be used including or not the precision
and unit
"""
fs = PyDMWritableWidget.update_format_string(self)
self.update_labels()
return fs
def set_enable_state(self):
"""
Determines wether or not the widget must be enabled or not depending
on the write access, connection state and presence of limits information
"""
self.setEnabled(self._write_access and self._connected
and not self._needs_limit_info)
@Slot(int)
def internal_slider_action_triggered(self, action):
self.actionTriggered.emit(action)
@Slot(int)
def internal_slider_moved(self, val):
"""
Method invoked when the slider is moved.
Parameters
----------
val : float
"""
# The user has moved the slider, we need to update our value.
# Only update the underlying value, not the self.value property,
# because we don't need to reset the slider position. If we change
# self.value, we can get into a loop where the position changes, which
# updates the value, which changes the position again, etc etc.
self.value = self._slider_position_to_value_map[val]
self.sliderMoved.emit(self.value)
@Slot()
def internal_slider_pressed(self):
"""
Method invoked when the slider is pressed
"""
self.sliderPressed.emit()
@Slot()
def internal_slider_released(self):
"""
Method invoked when the slider is released
"""
self.sliderReleased.emit()
@Slot(int)
def internal_slider_value_changed(self, val):
"""
Method invoked when a new value is selected on the slider.
This will cause the new value to be emitted to the signal
unless `mute_internal_slider_changes` is True.
Parameters
----------
val : int
"""
# At this point, our local copy of the value reflects the position of the
# slider, now all we need to do is emit a signal to PyDM so that the data
# plugin will send a put to the channel. Don't update self.value or self._value
# in here, it is pointless at best, and could cause an infinite loop at worst.
if not self._mute_internal_slider_changes:
self.send_value_signal[float].emit(self.value)
@Property(bool)
def showLimitLabels(self):
"""
Whether or not the high and low limits should be displayed on the slider.
Returns
-------
bool
"""
return self._show_limit_labels
@showLimitLabels.setter
def showLimitLabels(self, checked):
"""
Whether or not the high and low limits should be displayed on the slider.
Parameters
----------
checked : bool
"""
self._show_limit_labels = checked
if checked:
self.low_lim_label.show()
self.high_lim_label.show()
else:
self.low_lim_label.hide()
self.high_lim_label.hide()
@Property(bool)
def showValueLabel(self):
"""
Whether or not the current value should be displayed on the slider.
Returns
-------
bool
"""
return self._show_value_label
@showValueLabel.setter
def showValueLabel(self, checked):
"""
Whether or not the current value should be displayed on the slider.
Parameters
----------
checked : bool
"""
self._show_value_label = checked
if checked:
self.value_label.show()
else:
self.value_label.hide()
@Property(QSlider.TickPosition)
def tickPosition(self):
"""
Where to draw tick marks for the slider.
Returns
-------
QSlider.TickPosition
"""
return self._slider.tickPosition()
@tickPosition.setter
def tickPosition(self, position):
"""
Where to draw tick marks for the slider.
Parameter
---------
position : QSlider.TickPosition
"""
self._slider.setTickPosition(position)
@Property(bool)
def userDefinedLimits(self):
"""
Wether or not to use limits defined by the user and not from the
channel
Returns
-------
bool
"""
return self._user_defined_limits
@userDefinedLimits.setter
def userDefinedLimits(self, user_defined_limits):
"""
Wether or not to use limits defined by the user and not from the
channel
Parameters
----------
user_defined_limits : bool
"""
self._user_defined_limits = user_defined_limits
self.reset_slider_limits()
@Property(float)
def userMinimum(self):
"""
Lower user defined limit value
Returns
-------
float
"""
return self._user_minimum
@userMinimum.setter
def userMinimum(self, new_min):
"""
Lower user defined limit value
Parameters
----------
new_min : float
"""
self._user_minimum = float(new_min) if new_min is not None else None
if self.userDefinedLimits:
self.reset_slider_limits()
@Property(float)
def userMaximum(self):
"""
Upper user defined limit value
Returns
-------
float
"""
return self._user_maximum
@userMaximum.setter
def userMaximum(self, new_max):
"""
Upper user defined limit value
Parameters
----------
new_max : float
"""
self._user_maximum = float(new_max) if new_max is not None else None
if self.userDefinedLimits:
self.reset_slider_limits()
@property
def minimum(self):
"""
The current value being used for the lower limit
Returns
-------
float
"""
if self.userDefinedLimits:
return self._user_minimum
return self._lower_ctrl_limit
@property
def maximum(self):
"""
The current value being used for the upper limit
Returns
-------
float
"""
if self.userDefinedLimits:
return self._user_maximum
return self._upper_ctrl_limit
@Property(int)
def num_steps(self):
"""
The number of steps on the slider
Returns
-------
int
"""
return self._num_steps
@num_steps.setter
def num_steps(self, new_steps):
"""
The number of steps on the slider
Parameters
----------
new_steps : int
"""
self._num_steps = int(new_steps)
self.reset_slider_limits()
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)
class PyDMSlider(QFrame, TextFormatter, PyDMWritableWidget):
"""
A QSlider with support for Channels and more from PyDM.
Parameters
----------
parent : QWidget
The parent widget for the Label
init_channel : str, optional
The channel to be used by the widget.
"""
actionTriggered = Signal(int)
rangeChanged = Signal(float, float)
sliderMoved = Signal(float)
sliderPressed = Signal()
sliderReleased = Signal()
valueChanged = Signal(float)
def __init__(self, parent=None, init_channel=None):
QFrame.__init__(self, parent)
PyDMWritableWidget.__init__(self, init_channel=init_channel)
self.alarmSensitiveContent = True
self.alarmSensitiveBorder = False
# Internal values for properties
self._show_limit_labels = True
self._show_value_label = True
self._user_defined_limits = False
self._needs_limit_info = True
self._minimum = None
self._maximum = None
self._user_minimum = -10.0
self._user_maximum = 10.0
self._num_steps = 101
self._orientation = Qt.Horizontal
# Set up all the internal widgets that make up a PyDMSlider.
# We'll add all these things to layouts when we call setup_widgets_for_orientation
label_size_policy = QSizePolicy(QSizePolicy.Maximum, QSizePolicy.Fixed)
self.low_lim_label = QLabel(self)
self.low_lim_label.setObjectName("lowLimLabel")
self.low_lim_label.setSizePolicy(label_size_policy)
self.low_lim_label.setAlignment(Qt.AlignLeft | Qt.AlignTrailing | Qt.AlignVCenter)
self.value_label = QLabel(self)
self.value_label.setObjectName("valueLabel")
self.value_label.setAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
self.high_lim_label = QLabel(self)
self.high_lim_label.setObjectName("highLimLabel")
self.high_lim_label.setSizePolicy(label_size_policy)
self.high_lim_label.setAlignment(Qt.AlignRight | Qt.AlignTrailing | Qt.AlignVCenter)
self._slider = QSlider(parent=self)
self._slider.setOrientation(Qt.Horizontal)
self._slider.sliderMoved.connect(self.internal_slider_moved)
self._slider.sliderPressed.connect(self.internal_slider_pressed)
self._slider.sliderReleased.connect(self.internal_slider_released)
self._slider.valueChanged.connect(self.internal_slider_value_changed)
# self.vertical_layout.addWidget(self._slider)
# Other internal variables and final setup steps
self._slider_position_to_value_map = None
self._mute_internal_slider_changes = False
self.setup_widgets_for_orientation(self._orientation)
self.reset_slider_limits()
def init_for_designer(self):
"""
Method called after the constructor to tweak configurations for
when using the widget with the Qt Designer
"""
self.value = 0.0
@Property(Qt.Orientation)
def orientation(self):
"""
The slider orientation (Horizontal or Vertical)
Returns
-------
int
Qt.Horizontal or Qt.Vertical
"""
return self._orientation
@orientation.setter
def orientation(self, new_orientation):
"""
The slider orientation (Horizontal or Vertical)
Parameters
----------
new_orientation : int
Qt.Horizontal or Qt.Vertical
"""
self._orientation = new_orientation
self.setup_widgets_for_orientation(new_orientation)
def setup_widgets_for_orientation(self, new_orientation):
"""
Reconstruct the widget given the orientation.
Parameters
----------
new_orientation : int
Qt.Horizontal or Qt.Vertical
"""
if new_orientation not in (Qt.Horizontal, Qt.Vertical):
logger.error("Invalid orientation '{0}'. The existing layout will not change.".format(new_orientation))
return
layout = None
if new_orientation == Qt.Horizontal:
layout = QVBoxLayout()
layout.setContentsMargins(4, 0, 4, 4)
label_layout = QHBoxLayout()
label_layout.addWidget(self.low_lim_label)
label_layout.addStretch(0)
label_layout.addWidget(self.value_label)
label_layout.addStretch(0)
label_layout.addWidget(self.high_lim_label)
layout.addLayout(label_layout)
self._slider.setOrientation(new_orientation)
layout.addWidget(self._slider)
elif new_orientation == Qt.Vertical:
layout = QHBoxLayout()
layout.setContentsMargins(0, 4, 4, 4)
label_layout = QVBoxLayout()
label_layout.addWidget(self.high_lim_label)
label_layout.addStretch(0)
label_layout.addWidget(self.value_label)
label_layout.addStretch(0)
label_layout.addWidget(self.low_lim_label)
layout.addLayout(label_layout)
self._slider.setOrientation(new_orientation)
layout.addWidget(self._slider)
if self.layout() is not None:
# Trick to remove the existing layout by re-parenting it in an empty widget.
QWidget().setLayout(self.layout())
self.setLayout(layout)
def update_labels(self):
"""
Update the limits and value labels with the correct values.
"""
def set_label(value, label_widget):
if value is None:
label_widget.setText("")
else:
label_widget.setText(self.format_string.format(value))
set_label(self.minimum, self.low_lim_label)
set_label(self.maximum, self.high_lim_label)
set_label(self.value, self.value_label)
def reset_slider_limits(self):
"""
Reset the limits and adjust the labels properly for the slider.
"""
if self.minimum is None or self.maximum is None:
self._needs_limit_info = True
self.set_enable_state()
return
self._needs_limit_info = False
self._slider.setMinimum(0)
self._slider.setMaximum(self._num_steps - 1)
self._slider.setSingleStep(1)
self._slider.setPageStep(10)
self._slider_position_to_value_map = np.linspace(self.minimum, self.maximum, num=self._num_steps)
self.update_labels()
self.set_slider_to_closest_value(self.value)
self.rangeChanged.emit(self.minimum, self.maximum)
self.set_enable_state()
def find_closest_slider_position_to_value(self, val):
"""
Find and returns the index for the closest position on the slider
for a given value.
Parameters
----------
val : float
Returns
-------
int
"""
diff = abs(self._slider_position_to_value_map - float(val))
return np.argmin(diff)
def set_slider_to_closest_value(self, val):
"""
Set the value for the slider according to a given value.
Parameters
----------
val : float
"""
if val is None or self._needs_limit_info:
return
# When we set the slider to the closest value, it may end up at a slightly
# different position than val (if val is not in self._slider_position_to_value_map)
# We don't want that slight difference to get broacast out and put the channel
# somewhere new. For example, if the slider can only be at 0.4 or 0.5, but a
# new value comes in of 0.45, its more important to keep the 0.45 than to change
# it to where the slider gets set. Therefore, we mute the internal slider changes
# so that its valueChanged signal doesn't cause us to emit a signal to PyDM to change
# the value of the channel.
self._mute_internal_slider_changes = True
self._slider.setValue(self.find_closest_slider_position_to_value(val))
self._mute_internal_slider_changes = False
def value_changed(self, new_val):
"""
Callback invoked when the Channel value is changed.
Parameters
----------
new_val : int or float
The new value from the channel.
"""
PyDMWritableWidget.value_changed(self, new_val)
if hasattr(self, "value_label"):
self.value_label.setText(self.format_string.format(self.value))
if not self._slider.isSliderDown():
self.set_slider_to_closest_value(self.value)
def ctrl_limit_changed(self, which, new_limit):
"""
Callback invoked when the Channel receives new control limit
values.
Parameters
----------
which : str
Which control limit was changed. "UPPER" or "LOWER"
new_limit : float
New value for the control limit
"""
PyDMWritableWidget.ctrl_limit_changed(self, which, new_limit)
if not self.userDefinedLimits:
self.reset_slider_limits()
def update_format_string(self):
"""
Reconstruct the format string to be used when representing the
output value.
Returns
-------
format_string : str
The format string to be used including or not the precision
and unit
"""
fs = super(PyDMSlider, self).update_format_string()
self.update_labels()
return fs
def set_enable_state(self):
"""
Determines wether or not the widget must be enabled or not depending
on the write access, connection state and presence of limits information
"""
# Even though by documentation disabling parent QFrame (self), should disable internal
# slider, in practice it still remains interactive (PyQt 5.12.1). Disabling explicitly, solves
# the problem.
should_enable = self._write_access and self._connected and not self._needs_limit_info
self.setEnabled(should_enable)
self._slider.setEnabled(should_enable)
@Slot(int)
def internal_slider_action_triggered(self, action):
self.actionTriggered.emit(action)
@Slot(int)
def internal_slider_moved(self, val):
"""
Method invoked when the slider is moved.
Parameters
----------
val : float
"""
# Avoid potential crash if limits are undefined
if self._slider_position_to_value_map is None:
return
# The user has moved the slider, we need to update our value.
# Only update the underlying value, not the self.value property,
# because we don't need to reset the slider position. If we change
# self.value, we can get into a loop where the position changes, which
# updates the value, which changes the position again, etc etc.
self.value = self._slider_position_to_value_map[val]
self.sliderMoved.emit(self.value)
@Slot()
def internal_slider_pressed(self):
"""
Method invoked when the slider is pressed
"""
self.sliderPressed.emit()
@Slot()
def internal_slider_released(self):
"""
Method invoked when the slider is released
"""
self.sliderReleased.emit()
@Slot(int)
def internal_slider_value_changed(self, val):
"""
Method invoked when a new value is selected on the slider.
This will cause the new value to be emitted to the signal
unless `mute_internal_slider_changes` is True.
Parameters
----------
val : int
"""
# At this point, our local copy of the value reflects the position of the
# slider, now all we need to do is emit a signal to PyDM so that the data
# plugin will send a put to the channel. Don't update self.value or self._value
# in here, it is pointless at best, and could cause an infinite loop at worst.
if not self._mute_internal_slider_changes:
self.send_value_signal[float].emit(self.value)
@Property(bool)
def showLimitLabels(self):
"""
Whether or not the high and low limits should be displayed on the slider.
Returns
-------
bool
"""
return self._show_limit_labels
@showLimitLabels.setter
def showLimitLabels(self, checked):
"""
Whether or not the high and low limits should be displayed on the slider.
Parameters
----------
checked : bool
"""
self._show_limit_labels = checked
if checked:
self.low_lim_label.show()
self.high_lim_label.show()
else:
self.low_lim_label.hide()
self.high_lim_label.hide()
@Property(bool)
def showValueLabel(self):
"""
Whether or not the current value should be displayed on the slider.
Returns
-------
bool
"""
return self._show_value_label
@showValueLabel.setter
def showValueLabel(self, checked):
"""
Whether or not the current value should be displayed on the slider.
Parameters
----------
checked : bool
"""
self._show_value_label = checked
if checked:
self.value_label.show()
else:
self.value_label.hide()
@Property(QSlider.TickPosition)
def tickPosition(self):
"""
Where to draw tick marks for the slider.
Returns
-------
QSlider.TickPosition
"""
return self._slider.tickPosition()
@tickPosition.setter
def tickPosition(self, position):
"""
Where to draw tick marks for the slider.
Parameter
---------
position : QSlider.TickPosition
"""
self._slider.setTickPosition(position)
@Property(bool)
def userDefinedLimits(self):
"""
Wether or not to use limits defined by the user and not from the
channel
Returns
-------
bool
"""
return self._user_defined_limits
@userDefinedLimits.setter
def userDefinedLimits(self, user_defined_limits):
"""
Wether or not to use limits defined by the user and not from the
channel
Parameters
----------
user_defined_limits : bool
"""
self._user_defined_limits = user_defined_limits
self.reset_slider_limits()
@Property(float)
def userMinimum(self):
"""
Lower user defined limit value
Returns
-------
float
"""
return self._user_minimum
@userMinimum.setter
def userMinimum(self, new_min):
"""
Lower user defined limit value
Parameters
----------
new_min : float
"""
self._user_minimum = float(new_min) if new_min is not None else None
if self.userDefinedLimits:
self.reset_slider_limits()
@Property(float)
def userMaximum(self):
"""
Upper user defined limit value
Returns
-------
float
"""
return self._user_maximum
@userMaximum.setter
def userMaximum(self, new_max):
"""
Upper user defined limit value
Parameters
----------
new_max : float
"""
self._user_maximum = float(new_max) if new_max is not None else None
if self.userDefinedLimits:
self.reset_slider_limits()
@property
def minimum(self):
"""
The current value being used for the lower limit
Returns
-------
float
"""
if self.userDefinedLimits:
return self._user_minimum
return self._lower_ctrl_limit
@property
def maximum(self):
"""
The current value being used for the upper limit
Returns
-------
float
"""
if self.userDefinedLimits:
return self._user_maximum
return self._upper_ctrl_limit
@Property(int)
def num_steps(self):
"""
The number of steps on the slider
Returns
-------
int
"""
return self._num_steps
@num_steps.setter
def num_steps(self, new_steps):
"""
The number of steps on the slider
Parameters
----------
new_steps : int
"""
self._num_steps = int(new_steps)
self.reset_slider_limits()
