def __init__(self, parent):
QWidget.__init__(self, parent)
vert_layout = QVBoxLayout()
# Type frame
type_layout = QHBoxLayout()
type_label = QLabel(_("Import as"))
type_layout.addWidget(type_label)
self.array_btn = array_btn = QRadioButton(_("array"))
array_btn.setEnabled(ndarray is not FakeObject)
array_btn.setChecked(ndarray is not FakeObject)
type_layout.addWidget(array_btn)
list_btn = QRadioButton(_("list"))
list_btn.setChecked(not array_btn.isChecked())
type_layout.addWidget(list_btn)
if pd:
self.df_btn = df_btn = QRadioButton(_("DataFrame"))
df_btn.setChecked(False)
type_layout.addWidget(df_btn)
h_spacer = QSpacerItem(40, 20,
QSizePolicy.Expanding, QSizePolicy.Minimum)
type_layout.addItem(h_spacer)
type_frame = QFrame()
type_frame.setLayout(type_layout)
self._table_view = PreviewTable(self)
vert_layout.addWidget(type_frame)
vert_layout.addWidget(self._table_view)
self.setLayout(vert_layout)
def __init__(self, parent=None):
QFrame.__init__(self, parent)
PyDMPrimitiveWidget.__init__(self)
self._template_filename = ""
self._count_shown_in_designer = 1
self._data_source = ""
self._data = []
self._cached_template = None
self._layout_type = LayoutType.Vertical
self.app = QApplication.instance()
self.rebuild()
def __init__(self, parent):
QFrame.__init__(self, parent)
self._webview = WebView(self)
layout = QHBoxLayout()
layout.addWidget(self._webview)
layout.setContentsMargins(0, 0, 0, 0)
self.setLayout(layout)
self.setFrameStyle(QFrame.StyledPanel | QFrame.Sunken)
self._webview.linkClicked.connect(self.linkClicked)
def __init__(self, parent=None):
QFrame.__init__(self, parent)
PyDMPrimitiveWidget.__init__(self)
self.app = QApplication.instance()
self._filename = None
self._macros = None
self._embedded_widget = None
self._disconnect_when_hidden = True
self._is_connected = False
self.layout = QVBoxLayout(self)
self.err_label = QLabel(self)
self.err_label.setAlignment(Qt.AlignHCenter)
self.layout.addWidget(self.err_label)
self.layout.setContentsMargins(0, 0, 0, 0)
self.err_label.hide()
if not is_pydm_app():
self.setFrameShape(QFrame.Box)
else:
self.setFrameShape(QFrame.NoFrame)
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 setup_ui(self):
self.setWindowTitle("Add New Grain")
self.setWindowIcon(QIcon(RESOURCE_PATH + "icons/nakka-finocyl.gif"))
self.resize(400, 400)
controls = QGridLayout()
gb_frame = QGroupBox(self.tr("Grain Design"))
gb_frame.setLayout(controls)
self.cb_grain_type = QComboBox()
# TODO: make grain types auto propagate combobox
self.cb_grain_type.addItems([self.tr("Cylindrical (BATES)")])
controls.addWidget(QLabel(self.tr("Core Shape")), 0, 0)
controls.addWidget(self.cb_grain_type, 0, 1)
self.cb_propellant_type = QComboBox()
self.cb_propellant_type.addItems(app_context.propellant_db.propellant_names())
controls.addWidget(QLabel(self.tr("Propellant Type")), 1, 0)
controls.addWidget(self.cb_propellant_type, 1, 1)
# ok and cancel buttons
btn_ok = QPushButton(self.tr("Apply"))
btn_ok.clicked.connect(self.confirm_grain)
btn_cancel = QPushButton(self.tr("Close"))
btn_cancel.clicked.connect(self.close)
lay_btns = QHBoxLayout()
lay_btns.addWidget(btn_ok)
lay_btns.addWidget(btn_cancel)
frame_btns = QFrame()
frame_btns.setLayout(lay_btns)
# master layout
master = QVBoxLayout()
master.addWidget(gb_frame)
master.addSpacing(10)
master.addWidget(frame_btns)
self.setLayout(master)
def __init__(self, img, layout='vertical', order=['R', 'G', 'B', 'V']):
QFrame.__init__(self)
r, g, b, v = histograms(img, 100)
self.r_hist = ColorHistogram(r, (255, 0, 0))
self.g_hist = ColorHistogram(g, (0, 255, 0))
self.b_hist = ColorHistogram(b, (0, 0, 255))
self.v_hist = ColorHistogram(v, (0, 0, 0))
self.setFrameStyle(QFrame.StyledPanel | QFrame.Sunken)
self.layout = QGridLayout(self)
self.layout.setContentsMargins(0, 0, 0, 0)
order_map = {'R': self.r_hist, 'G': self.g_hist, 'B': self.b_hist,
'V': self.v_hist}
if layout == 'vertical':
for i in range(len(order)):
self.layout.addWidget(order_map[order[i]], i, 0)
elif layout == 'horizontal':
for i in range(len(order)):
self.layout.addWidget(order_map[order[i]], 0, i)
def setup_ui(self):
"""setup the tab widget UI"""
self.tab_widget = QTabWidget()
self.tab_widget.addTab(DesignTab(), "Design")
self.tab_widget.addTab(QWidget(), "Simulation")
self.tab_widget.addTab(QWidget(), "Propellants")
self.layout = QVBoxLayout()
self.layout.addWidget(self.tab_widget)
self.frame = QFrame()
self.frame.setLayout(self.layout)
self.setCentralWidget(self.frame)
def __init__(self, parent=None, init_channel=None):
QFrame.__init__(self, parent)
PyDMWidget.__init__(self, init_channel=init_channel)
self._show_value = True
self._show_limits = True
self.scale_indicator = QScale()
self.value_label = QLabel()
self.lower_label = QLabel()
self.upper_label = QLabel()
self.value_label.setText('<val>')
self.lower_label.setText('<min>')
self.upper_label.setText('<max>')
self._value_position = Qt.TopEdge
self._limits_from_channel = True
self._user_lower_limit = 0
self._user_upper_limit = 0
self.value_label.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
self.setup_widgets_for_orientation(Qt.Horizontal, False, False, self._value_position)
def __init__(self):
QFrame.__init__(self)
self.setFrameStyle(QFrame.Box | QFrame.Sunken)
self.posx_label = QLabel('X-pos:')
self.posx_value = QLabel()
self.posy_label = QLabel('Y-pos:')
self.posy_value = QLabel()
self.r_label = QLabel('R:')
self.r_value = QLabel()
self.g_label = QLabel('G:')
self.g_value = QLabel()
self.b_label = QLabel('B:')
self.b_value = QLabel()
self.h_label = QLabel('H:')
self.h_value = QLabel()
self.s_label = QLabel('S:')
self.s_value = QLabel()
self.v_label = QLabel('V:')
self.v_value = QLabel()
self.layout = QGridLayout(self)
self.layout.addWidget(self.posx_label, 0, 0)
self.layout.addWidget(self.posx_value, 0, 1)
self.layout.addWidget(self.posy_label, 1, 0)
self.layout.addWidget(self.posy_value, 1, 1)
self.layout.addWidget(self.r_label, 0, 2)
self.layout.addWidget(self.r_value, 0, 3)
self.layout.addWidget(self.g_label, 1, 2)
self.layout.addWidget(self.g_value, 1, 3)
self.layout.addWidget(self.b_label, 2, 2)
self.layout.addWidget(self.b_value, 2, 3)
self.layout.addWidget(self.h_label, 0, 4)
self.layout.addWidget(self.h_value, 0, 5)
self.layout.addWidget(self.s_label, 1, 4)
self.layout.addWidget(self.s_value, 1, 5)
self.layout.addWidget(self.v_label, 2, 4)
self.layout.addWidget(self.v_value, 2, 5)
def __init__(self, arr, mgr):
QMainWindow.__init__(self)
self.arr = arr
self.mgr = mgr
self.main_widget = QWidget()
self.layout = QGridLayout(self.main_widget)
self.setCentralWidget(self.main_widget)
self.label = ImageLabel(self, arr)
self.label_container = QFrame()
self.label_container.setFrameShape(QFrame.StyledPanel | QFrame.Sunken)
self.label_container.setLineWidth(1)
self.label_container.layout = QGridLayout(self.label_container)
self.label_container.layout.setContentsMargins(0, 0, 0, 0)
self.label_container.layout.addWidget(self.label, 0, 0)
self.layout.addWidget(self.label_container, 0, 0)
self.mgr.add_window(self)
self.main_widget.show()
self.setWindowTitle('Skivi - The skimage viewer.')
self.mixer_panel = MixerPanel(self.arr)
self.layout.addWidget(self.mixer_panel, 0, 2)
self.mixer_panel.show()
self.mixer_panel.set_callback(self.refresh_image)
self.rgbv_hist = QuadHistogram(self.arr)
self.layout.addWidget(self.rgbv_hist, 0, 1)
self.rgbv_hist.show()
self.rgb_hsv_disp = RGBHSVDisplay()
self.layout.addWidget(self.rgb_hsv_disp, 1, 0)
self.rgb_hsv_disp.show()
self.layout.setColumnStretch(0, 1)
self.layout.setRowStretch(0, 1)
self.save_file = QtWidgets.QPushButton('Save to File')
self.save_file.clicked.connect(self.save_to_file)
self.save_stack = QtWidgets.QPushButton('Save to Stack')
self.save_stack.clicked.connect(self.save_to_stack)
self.save_file.show()
self.save_stack.show()
self.layout.addWidget(self.save_stack, 1, 1)
self.layout.addWidget(self.save_file, 1, 2)
def drawBorder(self, painter):
"""
Draw the border of the plot canvas
:param QPainter painter: Painter
.. seealso::
:py:meth:`setBorderRadius()`
"""
if self.__data.borderRadius > 0:
if self.frameWidth() > 0:
QwtPainter.drawRoundedFrame(
painter,
QRectF(self.frameRect()),
self.__data.borderRadius,
self.__data.borderRadius,
self.palette(),
self.frameWidth(),
self.frameStyle(),
)
else:
opt = QStyleOptionFrame()
opt.initFrom(self)
try:
shape_mask = QFrame.Shape_Mask.value
shadow_mask = QFrame.Shadow_Mask.value
except AttributeError:
shape_mask = QFrame.Shape_Mask
shadow_mask = QFrame.Shadow_Mask
frameShape = self.frameStyle() & shape_mask
frameShadow = self.frameStyle() & shadow_mask
opt.frameShape = QFrame.Shape(int(opt.frameShape) | frameShape)
if frameShape in (
QFrame.Box,
QFrame.HLine,
QFrame.VLine,
QFrame.StyledPanel,
QFrame.Panel,
):
opt.lineWidth = self.lineWidth()
opt.midLineWidth = self.midLineWidth()
else:
opt.lineWidth = self.frameWidth()
if frameShadow == self.Sunken:
opt.state |= QStyle.State_Sunken
elif frameShadow == self.Raised:
opt.state |= QStyle.State_Raised
self.style().drawControl(QStyle.CE_ShapedFrame, opt, painter, self)
def __init__(self):
QFrame.__init__(self)
self.setLineWidth(1)
self.setFrameStyle(QFrame.Panel | QFrame.Plain)
self.__color = QColor(255, 255, 255)
self.setMinimumHeight(30)
self.__state_order = []
"""@type: list of State"""
self.__states = {}
"""@type: dict of (object, State)"""
self.__shiny = False
self.__count = 0
self.__indeterminate = False
self.__indeterminate_color = QColor(128, 128, 128)
self.__indeterminate_state = 0.5
self.__indeterminate_step_size = 0.05
self.__timer = QTimer(self)
self.__timer.setInterval(100)
self.__timer.timeout.connect(self.update)
def __init__(self, model, *args, **kwargs):
super().__init__(*args, **kwargs)
self.model = model
self.setOrientation(Qt.Vertical)
self._frame_1 = QFrame(self)
self._frame_2 = QFrame(self)
self._frame_3 = QFrame(self)
self._frame_4 = QFrame(self)
self.addWidget(self._frame_1)
self.addWidget(self._frame_2)
self.addWidget(self._frame_3)
self.addWidget(self._frame_4)
self._running_plan = QtReRunningPlan(model)
self._running_plan.monitor_mode = True
self._plan_queue = QtRePlanQueue(model)
self._plan_queue.monitor_mode = True
self._plan_history = QtRePlanHistory(model)
self._plan_history.monitor_mode = True
self._console_monitor = QtReConsoleMonitor(model)
vbox = QVBoxLayout()
vbox.setContentsMargins(0, 0, 0, 0)
vbox.addWidget(self._running_plan)
self._frame_1.setLayout(vbox)
vbox = QVBoxLayout()
vbox.setContentsMargins(0, 0, 0, 0)
vbox.addWidget(self._plan_queue)
self._frame_2.setLayout(vbox)
vbox = QVBoxLayout()
vbox.setContentsMargins(0, 0, 0, 0)
vbox.addWidget(self._plan_history)
self._frame_3.setLayout(vbox)
vbox = QVBoxLayout()
vbox.setContentsMargins(0, 0, 0, 0)
vbox.addWidget(self._console_monitor)
self._frame_4.setLayout(vbox)
h = self.sizeHint().height()
self.setSizes([h, 2 * h, 2 * h, h])
class TwoPanelWidget(QSplitter):
def __init__(self, *, gpc, gui_vars):
super().__init__(Qt.Horizontal)
# Global processing classes
self.gpc = gpc
# Global GUI variables (used for control of GUI state)
self.gui_vars = gui_vars
self.frame_left = QFrame(self)
self.frame_left.setFrameShape(QFrame.StyledPanel)
self.frame_right = QFrame(self)
self.frame_right.setFrameShape(QFrame.StyledPanel)
self.addWidget(self.frame_left)
self.addWidget(self.frame_right)
hbox = QHBoxLayout()
self.left_panel = LeftPanel(gpc=self.gpc, gui_vars=self.gui_vars)
hbox.addWidget(self.left_panel)
self.frame_left.setLayout(hbox)
hbox = QHBoxLayout()
self.right_panel = RightPanel(gpc=self.gpc, gui_vars=self.gui_vars)
hbox.addWidget(self.right_panel)
self.frame_right.setLayout(hbox)
self._show_first_time = True
# Set stretch factor of the left panel to 0 (we want it to keep its width
# as the window is resized. The panel can still be resized manually
self.setStretchFactor(0, 0)
# Set stretch factor for the right panel to some non-zero value, e.g. 1
self.setStretchFactor(1, 1)
def showEvent(self, event):
# Set the ratio for the splitter (only the first time the window is shown)
if self._show_first_time:
self.setSizes([460, self.width() - 460])
self._show_first_time = False
def update_widget_state(self, condition=None):
self.left_panel.update_widget_state(condition)
self.right_panel.update_widget_state(condition)
def __init__(self, parent=None, init_channel=None):
QFrame.__init__(self, parent)
PyDMWidget.__init__(self, init_channel=init_channel)
self._show_value = True
self._show_limits = True
self.scale_indicator = QScale()
self.value_label = QLabel()
self.lower_label = QLabel()
self.upper_label = QLabel()
self.value_label.setText('<val>')
self.lower_label.setText('<min>')
self.upper_label.setText('<max>')
self._value_position = Qt.TopEdge
self._limits_from_channel = True
self._user_lower_limit = 0
self._user_upper_limit = 0
self.value_label.setSizePolicy(QSizePolicy.Minimum,
QSizePolicy.Minimum)
self.setup_widgets_for_orientation(Qt.Horizontal, False, False,
self._value_position)
def __init__(self, parent=None, **kwargs):
super(PCDSSymbolBase, self).__init__(parent=parent, **kwargs)
self._expert_display = None
self.interlock = None
self._channels_prefix = None
self._rotate_icon = False
self._show_icon = True
self._show_status_tooltip = True
self._icon_size = -1
self._icon = None
self._icon_cursor = self.setCursor(
QCursor(IconFont().icon("file").pixmap(16, 16))
)
self._expert_ophyd_class = self.EXPERT_OPHYD_CLASS or ""
self.interlock = QFrame(self)
self.interlock.setObjectName("interlock")
self.interlock.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.controls_frame = QFrame(self)
self.controls_frame.setObjectName("controls")
self.controls_frame.setSizePolicy(QSizePolicy.Maximum,
QSizePolicy.Maximum)
self.setLayout(QVBoxLayout())
self.layout().setSpacing(0)
self.layout().setContentsMargins(0, 0, 0, 0)
self.layout().addWidget(self.interlock)
if not hasattr(self, '_controls_location'):
self._controls_location = ContentLocation.Bottom
self.setup_icon()
self.assemble_layout()
self.update_status_tooltip()
def _create_messages(self):
"""
Creates messages to go within the dialog box
Params:
None
Returns:
(QFrame): A QFrame that has the "Batch processing is completed" message and a info message (QLabel)
"""
# Create frame with messages
frame = QFrame()
frame.setLayout(QVBoxLayout())
message = QLabel()
message.setText("Batch Processing is completed!")
message.setAlignment(Qt.AlignmentFlag.AlignCenter)
desc = QLabel()
desc.setText(
"Please refer to the log.txt file in the output directory for more details."
)
frame.layout().setContentsMargins(15, 0, 15, 0)
frame.layout().addWidget(message)
frame.layout().addWidget(desc)
return frame
def __init__(self, parent: QWidget, axis: int):
super().__init__(parent=parent)
self.axis = axis
self.qt_dims = parent
self.dims = parent.dims
self.axis_label = None
self.slider = None
self.play_button = None
self.curslice_label = QLineEdit(self)
self.curslice_label.setToolTip(
trans._('Current slice for axis {axis}', axis=axis))
# if we set the QIntValidator to actually reflect the range of the data
# then an invalid (i.e. too large) index doesn't actually trigger the
# editingFinished event (the user is expected to change the value)...
# which is confusing to the user, so instead we use an IntValidator
# that makes sure the user can only enter integers, but we do our own
# value validation in self.change_slice
self.curslice_label.setValidator(QIntValidator(0, 999999))
self.curslice_label.editingFinished.connect(self._set_slice_from_label)
self.totslice_label = QLabel(self)
self.totslice_label.setToolTip(
trans._('Total slices for axis {axis}', axis=axis))
self.curslice_label.setObjectName('slice_label')
self.totslice_label.setObjectName('slice_label')
sep = QFrame(self)
sep.setFixedSize(1, 14)
sep.setObjectName('slice_label_sep')
settings = get_settings()
self._fps = settings.application.playback_fps
connect_setattr_value(settings.application.events.playback_fps, self,
"fps")
self._minframe = None
self._maxframe = None
self._loop_mode = settings.application.playback_mode
connect_setattr_value(settings.application.events.playback_mode, self,
"loop_mode")
layout = QHBoxLayout()
self._create_axis_label_widget()
self._create_range_slider_widget()
self._create_play_button_widget()
layout.addWidget(self.axis_label)
layout.addWidget(self.play_button)
layout.addWidget(self.slider, stretch=1)
layout.addWidget(self.curslice_label)
layout.addWidget(sep)
layout.addWidget(self.totslice_label)
layout.setContentsMargins(0, 0, 0, 0)
layout.setSpacing(2)
layout.setAlignment(Qt.AlignVCenter)
self.setLayout(layout)
self.dims.events.axis_labels.connect(self._pull_label)
def __init__(self, parent):
QWidget.__init__(self, parent)
vert_layout = QVBoxLayout()
# Type frame
type_layout = QHBoxLayout()
type_label = QLabel(_("Import as"))
type_layout.addWidget(type_label)
self.array_btn = array_btn = QRadioButton(_("array"))
available_array = (not isinstance(ndarray, FakeObject)
and not isinstance(array, FakeObject))
array_btn.setEnabled(available_array)
array_btn.setChecked(available_array)
type_layout.addWidget(array_btn)
list_btn = QRadioButton(_("list"))
list_btn.setChecked(not array_btn.isChecked())
type_layout.addWidget(list_btn)
if pd:
self.df_btn = df_btn = QRadioButton(_("DataFrame"))
df_btn.setChecked(False)
type_layout.addWidget(df_btn)
h_spacer = QSpacerItem(40, 20, QSizePolicy.Expanding,
QSizePolicy.Minimum)
type_layout.addItem(h_spacer)
type_frame = QFrame()
type_frame.setLayout(type_layout)
self._table_view = PreviewTable(self)
vert_layout.addWidget(type_frame)
vert_layout.addWidget(self._table_view)
self.setLayout(vert_layout)
def __init__(self, viewer):
super().__init__()
self.setProperty("emphasized", True)
self.viewer = viewer
self.setMouseTracking(True)
self.empty_widget = QFrame()
self.widgets = {}
self.addWidget(self.empty_widget)
self._display(None)
self.viewer.layers.events.added.connect(self._add)
self.viewer.layers.events.removed.connect(self._remove)
self.viewer.events.active_layer.connect(self._display)
def __init__(self, parent=None, toggle_button=None):
super().__init__(parent)
self._toggleButton = toggle_button
self.setObjectName('Activity')
self.setMinimumWidth(self.MIN_WIDTH)
self.setMinimumHeight(self.MIN_HEIGHT)
self.setMaximumHeight(self.MIN_HEIGHT)
self.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Fixed)
self.setWindowFlags(Qt.SubWindow | Qt.WindowStaysOnTopHint)
self.setModal(False)
opacityEffect = QGraphicsOpacityEffect(self)
opacityEffect.setOpacity(0.8)
self.setGraphicsEffect(opacityEffect)
self._baseWidget = QWidget()
self._activityLayout = QVBoxLayout()
self._activityLayout.addStretch()
self._baseWidget.setLayout(self._activityLayout)
self._baseWidget.layout().setContentsMargins(0, 0, 0, 0)
self._scrollArea = QScrollArea()
self._scrollArea.setWidgetResizable(True)
self._scrollArea.setWidget(self._baseWidget)
self._titleBar = QLabel()
title = QLabel('activity', self)
title.setObjectName('QtCustomTitleLabel')
title.setSizePolicy(
QSizePolicy(QSizePolicy.Policy.Maximum, QSizePolicy.Policy.Maximum)
)
line = QFrame(self)
line.setObjectName("QtCustomTitleBarLine")
titleLayout = QHBoxLayout()
titleLayout.setSpacing(4)
titleLayout.setContentsMargins(8, 1, 8, 0)
line.setFixedHeight(1)
titleLayout.addWidget(line)
titleLayout.addWidget(title)
self._titleBar.setLayout(titleLayout)
self._baseLayout = QVBoxLayout()
self._baseLayout.addWidget(self._titleBar)
self._baseLayout.addWidget(self._scrollArea)
self.setLayout(self._baseLayout)
self.resize(520, self.MIN_HEIGHT)
self.move_to_bottom_right()
# TODO: what do we do with any existing progress objects in action?
# connect callback to handle new progress objects being added/removed
progress._all_instances.events.changed.connect(
self.handle_progress_change
)
def make_central_column(self):
"""
Creates vtkWidget for the vedo plotter and a few
useful buttons, for the central part of the GUI
"""
# make a vtk widget for the vedo plotter
frame = QFrame()
self.vtkWidget = QVTKRenderWindowInteractor(frame)
# Create layout, add canvas and buttons
layout = QVBoxLayout()
layout.addWidget(self.vtkWidget)
# Make buttons
boxes = [QHBoxLayout(), QHBoxLayout()]
for n, bname in enumerate(self.central_column_button_names):
btn = QPushButton(bname.capitalize(), self)
btn.setObjectName(bname.replace(" ", "_"))
self.buttons[bname.replace(" ", "_")] = btn
if n == 0:
boxes[0].addWidget(btn)
else:
boxes[1].addWidget(btn)
hlayout = QHBoxLayout()
widget = QWidget()
widget.setLayout(boxes[0])
widget.setObjectName("ScreenshotButtonLayout")
hlayout.addWidget(widget)
widget = QWidget()
widget.setLayout(boxes[1])
hlayout.addWidget(widget)
widget = QWidget()
widget.setObjectName("CentralColumn_buttons")
widget.setLayout(hlayout)
layout.addWidget(widget)
# make widget
widget = QWidget()
widget.setObjectName("CentralColumn")
widget.setLayout(layout)
return widget
def __init__(self, parent, vertical=False):
super().__init__(parent)
self.setObjectName("QtCustomTitleBar")
self.setProperty('vertical', str(vertical))
self.vertical = vertical
self.setToolTip('drag to move. double-click to float')
line = QFrame(self)
line.setObjectName("QtCustomTitleBarLine")
self.close_button = QPushButton(self)
self.close_button.setToolTip('hide this panel')
self.close_button.setObjectName("QTitleBarCloseButton")
self.close_button.setCursor(Qt.ArrowCursor)
self.close_button.clicked.connect(
lambda: self.parent().toggleViewAction().trigger()
)
self.float_button = QPushButton(self)
self.float_button.setToolTip('float this panel')
self.float_button.setObjectName("QTitleBarFloatButton")
self.float_button.setCursor(Qt.ArrowCursor)
self.float_button.clicked.connect(
lambda: self.parent().setFloating(not self.parent().isFloating())
)
if vertical:
layout = QVBoxLayout()
layout.setSpacing(4)
layout.setContentsMargins(0, 8, 0, 8)
line.setFixedWidth(1)
layout.addWidget(self.close_button, 0, Qt.AlignHCenter)
layout.addWidget(self.float_button, 0, Qt.AlignHCenter)
layout.addWidget(line, 0, Qt.AlignHCenter)
else:
layout = QHBoxLayout()
layout.setSpacing(4)
layout.setContentsMargins(8, 1, 8, 0)
line.setFixedHeight(1)
layout.addWidget(self.close_button)
layout.addWidget(self.float_button)
layout.addWidget(line)
self.setLayout(layout)
self.setCursor(Qt.OpenHandCursor)
def __init__(self, parent=None):
super(MyTree, self).__init__(parent)
data = MyData.init()
frame = QFrame();
frame.setLayout( QHBoxLayout() );
treeViewModel = TreeViewModel(data)
treeView = TreeView(treeViewModel)
frame.layout().addWidget( treeView );
self.setCentralWidget(frame)
def _create_title_box(self, step_widget):
title_box = QFrame()
title_box_layout = QHBoxLayout()
title_box_layout.setContentsMargins(11, 9, 9, 9)
title_box.setLayout(title_box_layout)
title_box.setFixedHeight(38)
if self.isOpen is False:
title_box.setObjectName("titleBoxClosed")
title = QLabel(self._title)
sweep_button = QPushButton()
sweep_button.setIcon(
QIcon(
QPixmap(
str(Directories.get_assets_dir() /
"icons/icon-parameter-sweep.svg"))))
sweep_button.setToolTip("Open parameter sweep window")
sweep_button.clicked.connect(
lambda: step_widget.steps_view.open_sweep_ui(step_widget.index))
if step_widget.step.function.parameters is None:
sweep_button.setEnabled(False)
self.expand_button = QPushButton()
self.expand_button.setIcon(
QIcon(
QPixmap(
str(Directories.get_assets_dir() /
"icons/expand_more_black_24dp.svg"))))
self.expand_button.setToolTip("Expand to see parameters")
self.expand_button.clicked.connect(self.toggle)
# icon = QLabel()
# icon.setPixmap(QPixmap(str(Directories.get_assets_dir() / "icons/expand_more_black_24dp.svg")))
title_box_layout.addWidget(title)
title_box_layout.addStretch()
title_box_layout.addWidget(sweep_button)
title_box_layout.addWidget(self.expand_button)
# icon = QLabel()
# icon.setPixmap(QPixmap(str(Directories.get_assets_dir() / "icons/warning.png")))
#
# title_box_layout.addWidget(icon)
return title_box
def leaveEvent(self, event, *args, **kwargs):
"""
When the cursor leaves the invisible display area,
this will return it back to the original point that it
was set at. It will then update the positions to accomdate this
so that one drag seems seemless.
"""
if not self._drag_STICKY: return
current_pos = QCursor.pos()
offset = (current_pos - self._cursor_pos)
self._calc_pos = self._calc_pos - offset
# reset cursor
QCursor.setPos(self._cursor_pos)
# update value
self.__setValue()
return QFrame.leaveEvent(self, event, *args, **kwargs)
def _create_buttons(self):
"""
Creates buttons for the bottom of the dialog box, one for opening the output folder, and one for
closing the dialog box
Params:
None
Returns:
(QFrame): A QFrame that has two horizontally laid out buttons, first button is Open output directory,
second button is close.
"""
buttons = QFrame()
buttons.setLayout(QHBoxLayout())
open_output_button = QPushButton("Open output directory")
open_output_button.clicked.connect(self._open_output_folder)
close_button = QPushButton("Close")
close_button.clicked.connect(self.close)
buttons.layout().addWidget(open_output_button)
buttons.layout().addWidget(close_button)
return buttons
def __init__(self, pbar, parent=None) -> None:
super().__init__(parent)
self.setAttribute(QtCore.Qt.WA_DeleteOnClose)
pbr_group_layout = QVBoxLayout()
pbr_group_layout.addWidget(pbar)
pbr_group_layout.setContentsMargins(0, 0, 0, 0)
line = QFrame(self)
line.setObjectName("QtCustomTitleBarLine")
line.setFixedHeight(1)
pbr_group_layout.addWidget(line)
self.setLayout(pbr_group_layout)
def create_sweep_headers(self) -> QFrame:
"""
Create headers for the sweep UI
Params:
none
"""
# headers
header: QFrame = QFrame()
header.setLayout(QHBoxLayout())
label: QLabel = QLabel("min")
label.setAlignment(Qt.AlignCenter)
header.layout().addWidget(label)
label: QLabel = QLabel("max")
label.setAlignment(Qt.AlignCenter)
header.layout().addWidget(label)
label: QLabel = QLabel("step size")
label.setAlignment(Qt.AlignCenter)
header.layout().addWidget(label)
return header
def __init__(self, parent=None, toggle_button=None):
super().__init__(parent)
self._toggleButton = toggle_button
self.setObjectName('Activity')
self.setMinimumWidth(self.MIN_WIDTH)
self.setMinimumHeight(self.MIN_HEIGHT)
self.setMaximumHeight(self.MIN_HEIGHT)
self.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Fixed)
self.setWindowFlags(Qt.SubWindow | Qt.WindowStaysOnTopHint)
self.setModal(False)
opacityEffect = QGraphicsOpacityEffect(self)
opacityEffect.setOpacity(0.8)
self.setGraphicsEffect(opacityEffect)
self._baseWidget = QWidget()
self._activityLayout = QVBoxLayout()
self._activityLayout.addStretch()
self._baseWidget.setLayout(self._activityLayout)
self._baseWidget.layout().setContentsMargins(0, 0, 0, 0)
self._scrollArea = QScrollArea()
self._scrollArea.setWidgetResizable(True)
self._scrollArea.setWidget(self._baseWidget)
self._titleBar = QLabel()
title = QLabel('activity', self)
title.setObjectName('QtCustomTitleLabel')
title.setSizePolicy(
QSizePolicy(QSizePolicy.Policy.Maximum, QSizePolicy.Policy.Maximum)
)
line = QFrame(self)
line.setObjectName("QtCustomTitleBarLine")
titleLayout = QHBoxLayout()
titleLayout.setSpacing(4)
titleLayout.setContentsMargins(8, 1, 8, 0)
line.setFixedHeight(1)
titleLayout.addWidget(line)
titleLayout.addWidget(title)
self._titleBar.setLayout(titleLayout)
self._baseLayout = QVBoxLayout()
self._baseLayout.addWidget(self._titleBar)
self._baseLayout.addWidget(self._scrollArea)
self.setLayout(self._baseLayout)
def _setupUi(self):
monitor = QGroupBox('Monitor')
glay = QGridLayout(monitor)
glay.setAlignment(Qt.AlignTop)
glay.addWidget(QLabel('', self), 0, 0)
sec_lbls = get_status_labels()
for col, sec in enumerate(sec_lbls):
lbl = QLabel(sec, self, alignment=Qt.AlignCenter)
glay.addWidget(lbl, 0, col + 1)
sub_lbls = set()
for sec in sec_lbls:
sub_lbls.update(get_status_labels(sec))
sub_lbls = sorted(sub_lbls)
for row, sub in enumerate(sub_lbls):
lbl = QLabel(sub, self, alignment=Qt.AlignCenter)
glay.addWidget(lbl, row + 1, 0)
line = QFrame(self)
line.setFrameShape(QFrame.HLine)
line.setFrameShadow(QFrame.Sunken)
glay.addWidget(line, row + 2, 0, 1, len(sec_lbls) + 1)
glay.addWidget(QLabel('All', self, alignment=Qt.AlignCenter), row + 3,
0)
for col, sec in enumerate(sec_lbls):
lbls = get_status_labels(sec)
for row, sub in enumerate(sub_lbls):
if sub not in lbls:
continue
bit = lbls.index(sub)
led = SiriusLedAlert(self,
self._inj_prefix.substitute(
propty='DiagStatus' + sec + '-Mon'),
bit=bit)
glay.addWidget(led, row + 1, col + 1)
bit = sec_lbls.index(sec)
led = SiriusLedAlert(
self,
self._inj_prefix.substitute(propty='DiagStatus-Mon'),
bit=bit)
glay.addWidget(led, row + 3, col + 1)
lay = QHBoxLayout(self)
lay.setContentsMargins(0, 0, 0, 0)
lay.addWidget(monitor)
class MainTemplate(ViewTemplate):
def __init__(self):
super().__init__()
self._container = QFrame()
self._container.setObjectName("mainContainer")
def get_container(self) -> QFrame:
return self._container
def load(self):
layout = QVBoxLayout()
self.setLayout(layout)
self.setStyleSheet(Style.get_stylesheet("main.qss"))
# Page
page = QFrame()
page.setObjectName("page")
page.setLayout(QVBoxLayout())
page.layout().setContentsMargins(0, 0, 0, 0)
layout.addWidget(page)
# Scroll
scroll = QScrollArea()
scroll.setVerticalScrollBarPolicy(
Qt.ScrollBarPolicy.ScrollBarAlwaysOn) # ScrollBarAsNeeded
scroll.setHorizontalScrollBarPolicy(
Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
scroll.setWidgetResizable(True)
scroll.setWidget(page)
layout.addWidget(scroll)
# Header
header = QLabel("""
<span>
<b>ALLEN CELL & STRUCTURE SEGMENTER</b><br/>
v1.0 supports static 3D images only
</span>
""")
header.setObjectName("header")
header.setAlignment(Qt.AlignmentFlag.AlignCenter)
page.layout().addWidget(header)
# Container
self._container.setLayout(QVBoxLayout())
self._container.layout().setContentsMargins(0, 0, 0, 0)
page.layout().addWidget(self._container)
page.layout().addStretch()
def __init__(self, width=800, height=600, parent=None):
# Start app
self._app = QApplication.instance()
if self._app is None:
self._app = QApplication([])
super(ViewerQt, self).__init__(parent)
# Window settings
self.setWindowTitle('pyOCCT')
_icon = os.path.dirname(__file__) + '/_resources/icon.png'
_qicon = QIcon(_icon)
self.setWindowIcon(_qicon)
# Create the OCCT view
frame = QFrame(self)
layout = QVBoxLayout(frame)
layout.setContentsMargins(0, 0, 0, 0)
self._the_view = QOpenCascadeWidget()
layout.addWidget(self._the_view)
self.setCentralWidget(frame)
self.show()
self.resize(width, height)
self.view.my_view.MustBeResized()
def __init__(self, parent=None) -> None:
super().__init__(parent)
self.setAttribute(QtCore.Qt.WA_DeleteOnClose)
self.pbar = QProgressBar()
self.description_label = QLabel()
self.eta_label = QLabel()
base_layout = QVBoxLayout()
pbar_layout = QHBoxLayout()
pbar_layout.addWidget(self.description_label)
pbar_layout.addWidget(self.pbar)
pbar_layout.addWidget(self.eta_label)
base_layout.addLayout(pbar_layout)
line = QFrame(self)
line.setObjectName("QtCustomTitleBarLine")
line.setFixedHeight(1)
base_layout.addWidget(line)
self.setLayout(base_layout)
def __init__(self, parent=None, init_channel=None):
QFrame.__init__(self, parent)
PyDMWidget.__init__(self, init_channel=init_channel)
self._disable_on_disconnect = False
self.alarmSensitiveBorder = False
def __init__(self, parent=None):
QFrame.__init__(self, parent)
self.ui = load_ui(__file__, '../../ui/hfir_output.ui', baseinstance=self)
def __init__(self, parent=None):
QFrame.__init__(self, parent)
self.ui = load_ui(__file__, '../../../ui/sans/hfir_detector.ui', baseinstance=self)
def __init__(self, parent=None):
QFrame.__init__(self, parent)
self.ui = load_ui(__file__, '../../../ui/inelastic/dgs_sample_setup.ui', baseinstance=self)
def __init__(self, parent=None):
QFrame.__init__(self, parent)
self.ui = load_ui(__file__, '../../../ui/sans/eqsans_instrument.ui', baseinstance=self)
class MainWindow(QMainWindow):
"""OpenBurn's main window"""
title = "OpenBurn"
def __init__(self):
super(MainWindow, self).__init__()
self.setWindowTitle(self.title)
self.setGeometry(100, 100, 800, 600)
self.setWindowIcon(QIcon(RESOURCE_PATH + "icons/nakka-finocyl.gif"))
self.create_default_widgets()
self.setup_ui()
def create_default_widgets(self):
"""Creates static widgets such as menubar and statusbar"""
def create_menubar():
"""Create menu bar and populate it with sub menu actions"""
def file_menu():
"""Create a file submenu"""
self.file_sub_menu = self.menubar.addMenu('File')
self.open_action = QAction('Open File', self)
self.open_action.setStatusTip('Open a new design')
self.open_action.setShortcut('CTRL+O')
# self.open_action.triggered.connect(self.open_file)
self.exit_action = QAction('Exit', self)
self.exit_action.setStatusTip('Exit the application.')
self.exit_action.setShortcut('CTRL+Q')
self.exit_action.triggered.connect(QApplication.quit)
self.file_sub_menu.addAction(self.open_action)
self.file_sub_menu.addAction(self.exit_action)
def edit_menu():
self.edit_dub_menu = self.menubar.addMenu('Edit')
def tools_menu():
self.edit_dub_menu = self.menubar.addMenu('Tools')
def help_menu():
"""Create help submenu"""
self.help_sub_menu = self.menubar.addMenu('Help')
self.about_action = QAction('About', self)
self.about_action.setStatusTip('About the application.')
self.about_action.setShortcut('CTRL+H')
self.about_action.triggered.connect(self.about_dialog.exec_)
self.help_sub_menu.addAction(self.about_action)
self.menubar = QMenuBar(self)
file_menu()
edit_menu()
tools_menu()
help_menu()
def create_statusbar():
self.statusbar = QStatusBar(self)
self.statusbar.showMessage("Ready", 0)
self.about_dialog = AboutDialog(self)
create_menubar()
self.setMenuBar(self.menubar)
create_statusbar()
self.setStatusBar(self.statusbar)
def setup_ui(self):
"""setup the tab widget UI"""
self.tab_widget = QTabWidget()
self.tab_widget.addTab(DesignTab(), "Design")
self.tab_widget.addTab(QWidget(), "Simulation")
self.tab_widget.addTab(QWidget(), "Propellants")
self.layout = QVBoxLayout()
self.layout.addWidget(self.tab_widget)
self.frame = QFrame()
self.frame.setLayout(self.layout)
self.setCentralWidget(self.frame)
def setup_toolbar(self):
"""Setup the toolbar"""
savefig_btn = create_toolbutton(
self, icon=ima.icon('filesave'),
tip=_("Save Image As..."),
triggered=self.save_figure)
saveall_btn = create_toolbutton(
self, icon=ima.icon('save_all'),
tip=_("Save All Images..."),
triggered=self.save_all_figures)
copyfig_btn = create_toolbutton(
self, icon=ima.icon('editcopy'),
tip=_("Copy plot to clipboard as image (%s)" %
get_shortcut('plots', 'copy')),
triggered=self.copy_figure)
closefig_btn = create_toolbutton(
self, icon=ima.icon('editclear'),
tip=_("Remove image"),
triggered=self.close_figure)
closeall_btn = create_toolbutton(
self, icon=ima.icon('filecloseall'),
tip=_("Remove all images from the explorer"),
triggered=self.close_all_figures)
vsep1 = QFrame()
vsep1.setFrameStyle(53)
goback_btn = create_toolbutton(
self, icon=ima.icon('ArrowBack'),
tip=_("Previous Figure ({})".format(
get_shortcut('plots', 'previous figure'))),
triggered=self.go_previous_thumbnail)
gonext_btn = create_toolbutton(
self, icon=ima.icon('ArrowForward'),
tip=_("Next Figure ({})".format(
get_shortcut('plots', 'next figure'))),
triggered=self.go_next_thumbnail)
vsep2 = QFrame()
vsep2.setFrameStyle(53)
zoom_out_btn = create_toolbutton(
self, icon=ima.icon('zoom_out'),
tip=_("Zoom out (Ctrl + mouse-wheel-down)"),
triggered=self.zoom_out)
zoom_in_btn = create_toolbutton(
self, icon=ima.icon('zoom_in'),
tip=_("Zoom in (Ctrl + mouse-wheel-up)"),
triggered=self.zoom_in)
self.zoom_disp = QSpinBox()
self.zoom_disp.setAlignment(Qt.AlignCenter)
self.zoom_disp.setButtonSymbols(QSpinBox.NoButtons)
self.zoom_disp.setReadOnly(True)
self.zoom_disp.setSuffix(' %')
self.zoom_disp.setRange(0, 9999)
self.zoom_disp.setValue(100)
self.figviewer.sig_zoom_changed.connect(self.zoom_disp.setValue)
zoom_pan = QWidget()
layout = QHBoxLayout(zoom_pan)
layout.setSpacing(0)
layout.setContentsMargins(0, 0, 0, 0)
layout.addWidget(zoom_out_btn)
layout.addWidget(zoom_in_btn)
layout.addWidget(self.zoom_disp)
return [savefig_btn, saveall_btn, copyfig_btn, closefig_btn,
closeall_btn, vsep1, goback_btn, gonext_btn, vsep2, zoom_pan]
def __init__(self, parent, text):
QWidget.__init__(self, parent)
self.text_editor = QTextEdit(self)
self.text_editor.setText(text)
self.text_editor.setReadOnly(True)
# Type frame
type_layout = QHBoxLayout()
type_label = QLabel(_("Import as"))
type_layout.addWidget(type_label)
data_btn = QRadioButton(_("data"))
data_btn.setChecked(True)
self._as_data = True
type_layout.addWidget(data_btn)
code_btn = QRadioButton(_("code"))
self._as_code = False
type_layout.addWidget(code_btn)
txt_btn = QRadioButton(_("text"))
type_layout.addWidget(txt_btn)
h_spacer = QSpacerItem(40, 20, QSizePolicy.Expanding,
QSizePolicy.Minimum)
type_layout.addItem(h_spacer)
type_frame = QFrame()
type_frame.setLayout(type_layout)
# Opts frame
grid_layout = QGridLayout()
grid_layout.setSpacing(0)
col_label = QLabel(_("Column separator:"))
grid_layout.addWidget(col_label, 0, 0)
col_w = QWidget()
col_btn_layout = QHBoxLayout()
self.tab_btn = QRadioButton(_("Tab"))
self.tab_btn.setChecked(False)
col_btn_layout.addWidget(self.tab_btn)
self.ws_btn = QRadioButton(_("Whitespace"))
self.ws_btn.setChecked(False)
col_btn_layout.addWidget(self.ws_btn)
other_btn_col = QRadioButton(_("other"))
other_btn_col.setChecked(True)
col_btn_layout.addWidget(other_btn_col)
col_w.setLayout(col_btn_layout)
grid_layout.addWidget(col_w, 0, 1)
self.line_edt = QLineEdit(",")
self.line_edt.setMaximumWidth(30)
self.line_edt.setEnabled(True)
other_btn_col.toggled.connect(self.line_edt.setEnabled)
grid_layout.addWidget(self.line_edt, 0, 2)
row_label = QLabel(_("Row separator:"))
grid_layout.addWidget(row_label, 1, 0)
row_w = QWidget()
row_btn_layout = QHBoxLayout()
self.eol_btn = QRadioButton(_("EOL"))
self.eol_btn.setChecked(True)
row_btn_layout.addWidget(self.eol_btn)
other_btn_row = QRadioButton(_("other"))
row_btn_layout.addWidget(other_btn_row)
row_w.setLayout(row_btn_layout)
grid_layout.addWidget(row_w, 1, 1)
self.line_edt_row = QLineEdit(";")
self.line_edt_row.setMaximumWidth(30)
self.line_edt_row.setEnabled(False)
other_btn_row.toggled.connect(self.line_edt_row.setEnabled)
grid_layout.addWidget(self.line_edt_row, 1, 2)
grid_layout.setRowMinimumHeight(2, 15)
other_group = QGroupBox(_("Additional options"))
other_layout = QGridLayout()
other_group.setLayout(other_layout)
skiprows_label = QLabel(_("Skip rows:"))
other_layout.addWidget(skiprows_label, 0, 0)
self.skiprows_edt = QLineEdit('0')
self.skiprows_edt.setMaximumWidth(30)
intvalid = QIntValidator(0, len(to_text_string(text).splitlines()),
self.skiprows_edt)
self.skiprows_edt.setValidator(intvalid)
other_layout.addWidget(self.skiprows_edt, 0, 1)
other_layout.setColumnMinimumWidth(2, 5)
comments_label = QLabel(_("Comments:"))
other_layout.addWidget(comments_label, 0, 3)
self.comments_edt = QLineEdit('#')
self.comments_edt.setMaximumWidth(30)
other_layout.addWidget(self.comments_edt, 0, 4)
self.trnsp_box = QCheckBox(_("Transpose"))
#self.trnsp_box.setEnabled(False)
other_layout.addWidget(self.trnsp_box, 1, 0, 2, 0)
grid_layout.addWidget(other_group, 3, 0, 2, 0)
opts_frame = QFrame()
opts_frame.setLayout(grid_layout)
data_btn.toggled.connect(opts_frame.setEnabled)
data_btn.toggled.connect(self.set_as_data)
code_btn.toggled.connect(self.set_as_code)
# self.connect(txt_btn, SIGNAL("toggled(bool)"),
# self, SLOT("is_text(bool)"))
# Final layout
layout = QVBoxLayout()
layout.addWidget(type_frame)
layout.addWidget(self.text_editor)
layout.addWidget(opts_frame)
self.setLayout(layout)
def __init__(self, parent=None):
QFrame.__init__(self, parent)
self.ui = load_ui(__file__,
'../../../ui/sans/hfir_detector.ui',
baseinstance=self)
def __init__(self, parent, text):
QWidget.__init__(self, parent)
self.text_editor = QTextEdit(self)
self.text_editor.setText(text)
self.text_editor.setReadOnly(True)
# Type frame
type_layout = QHBoxLayout()
type_label = QLabel(_("Import as"))
type_layout.addWidget(type_label)
data_btn = QRadioButton(_("data"))
data_btn.setChecked(True)
self._as_data= True
type_layout.addWidget(data_btn)
code_btn = QRadioButton(_("code"))
self._as_code = False
type_layout.addWidget(code_btn)
txt_btn = QRadioButton(_("text"))
type_layout.addWidget(txt_btn)
h_spacer = QSpacerItem(40, 20,
QSizePolicy.Expanding, QSizePolicy.Minimum)
type_layout.addItem(h_spacer)
type_frame = QFrame()
type_frame.setLayout(type_layout)
# Opts frame
grid_layout = QGridLayout()
grid_layout.setSpacing(0)
col_label = QLabel(_("Column separator:"))
grid_layout.addWidget(col_label, 0, 0)
col_w = QWidget()
col_btn_layout = QHBoxLayout()
self.tab_btn = QRadioButton(_("Tab"))
self.tab_btn.setChecked(False)
col_btn_layout.addWidget(self.tab_btn)
other_btn_col = QRadioButton(_("other"))
other_btn_col.setChecked(True)
col_btn_layout.addWidget(other_btn_col)
col_w.setLayout(col_btn_layout)
grid_layout.addWidget(col_w, 0, 1)
self.line_edt = QLineEdit(",")
self.line_edt.setMaximumWidth(30)
self.line_edt.setEnabled(True)
other_btn_col.toggled.connect(self.line_edt.setEnabled)
grid_layout.addWidget(self.line_edt, 0, 2)
row_label = QLabel(_("Row separator:"))
grid_layout.addWidget(row_label, 1, 0)
row_w = QWidget()
row_btn_layout = QHBoxLayout()
self.eol_btn = QRadioButton(_("EOL"))
self.eol_btn.setChecked(True)
row_btn_layout.addWidget(self.eol_btn)
other_btn_row = QRadioButton(_("other"))
row_btn_layout.addWidget(other_btn_row)
row_w.setLayout(row_btn_layout)
grid_layout.addWidget(row_w, 1, 1)
self.line_edt_row = QLineEdit(";")
self.line_edt_row.setMaximumWidth(30)
self.line_edt_row.setEnabled(False)
other_btn_row.toggled.connect(self.line_edt_row.setEnabled)
grid_layout.addWidget(self.line_edt_row, 1, 2)
grid_layout.setRowMinimumHeight(2, 15)
other_group = QGroupBox(_("Additional options"))
other_layout = QGridLayout()
other_group.setLayout(other_layout)
skiprows_label = QLabel(_("Skip rows:"))
other_layout.addWidget(skiprows_label, 0, 0)
self.skiprows_edt = QLineEdit('0')
self.skiprows_edt.setMaximumWidth(30)
intvalid = QIntValidator(0, len(to_text_string(text).splitlines()),
self.skiprows_edt)
self.skiprows_edt.setValidator(intvalid)
other_layout.addWidget(self.skiprows_edt, 0, 1)
other_layout.setColumnMinimumWidth(2, 5)
comments_label = QLabel(_("Comments:"))
other_layout.addWidget(comments_label, 0, 3)
self.comments_edt = QLineEdit('#')
self.comments_edt.setMaximumWidth(30)
other_layout.addWidget(self.comments_edt, 0, 4)
self.trnsp_box = QCheckBox(_("Transpose"))
#self.trnsp_box.setEnabled(False)
other_layout.addWidget(self.trnsp_box, 1, 0, 2, 0)
grid_layout.addWidget(other_group, 3, 0, 2, 0)
opts_frame = QFrame()
opts_frame.setLayout(grid_layout)
data_btn.toggled.connect(opts_frame.setEnabled)
data_btn.toggled.connect(self.set_as_data)
code_btn.toggled.connect(self.set_as_code)
# self.connect(txt_btn, SIGNAL("toggled(bool)"),
# self, SLOT("is_text(bool)"))
# Final layout
layout = QVBoxLayout()
layout.addWidget(type_frame)
layout.addWidget(self.text_editor)
layout.addWidget(opts_frame)
self.setLayout(layout)
def __init__(self, parent=None):
QFrame.__init__(self, parent)
self.ui = load_ui(__file__, '../../../ui/inelastic/dgs_diagnose_detectors.ui', baseinstance=self)
def __init__(self, presenter, parent = None, name = '', isMD=False, noExp = 0):
super(SampleLogsView, self).__init__(parent)
self.presenter = presenter
self.setWindowTitle("{} sample logs".format(name))
self.setWindowFlags(Qt.Window)
# Create sample log table
self.table = QTableView()
self.table.setSelectionBehavior(QAbstractItemView.SelectRows)
self.table.clicked.connect(self.presenter.clicked)
self.table.doubleClicked.connect(self.presenter.doubleClicked)
self.table.contextMenuEvent = self.tableMenu
self.addWidget(self.table)
frame_right = QFrame()
layout_right = QVBoxLayout()
#Add full_time and experimentinfo options
layout_options = QHBoxLayout()
if isMD:
layout_options.addWidget(QLabel("Experiment Info #"))
self.experimentInfo = QSpinBox()
self.experimentInfo.setMaximum(noExp-1)
self.experimentInfo.valueChanged.connect(self.presenter.changeExpInfo)
layout_options.addWidget(self.experimentInfo)
self.full_time = QCheckBox("Relative Time")
self.full_time.setChecked(True)
self.full_time.stateChanged.connect(self.presenter.plot_logs)
layout_options.addWidget(self.full_time)
layout_right.addLayout(layout_options)
# Sample log plot
self.fig = Figure()
self.canvas = FigureCanvas(self.fig)
self.canvas.setSizePolicy(QSizePolicy.Expanding,QSizePolicy.Expanding)
self.canvas.mpl_connect('button_press_event', self.presenter.plot_clicked)
self.ax = self.fig.add_subplot(111, projection='mantid')
layout_right.addWidget(self.canvas)
# Sample stats
self.create_stats_widgets()
layout_stats = QFormLayout()
layout_stats.addRow('', QLabel("Log Statistics"))
layout_stats.addRow('Min:', self.stats_widgets["minimum"])
layout_stats.addRow('Max:', self.stats_widgets["maximum"])
layout_stats.addRow('Mean:', self.stats_widgets["mean"])
layout_stats.addRow('Median:', self.stats_widgets["median"])
layout_stats.addRow('Std Dev:', self.stats_widgets["standard_deviation"])
layout_stats.addRow('Time Avg:', self.stats_widgets["time_mean"])
layout_stats.addRow('Time Std Dev:', self.stats_widgets["time_standard_deviation"])
layout_stats.addRow('Duration:', self.stats_widgets["duration"])
layout_right.addLayout(layout_stats)
frame_right.setLayout(layout_right)
self.addWidget(frame_right)
self.setStretchFactor(0,1)
self.resize(1200,800)
self.show()
def __init__(self, parent=None):
QFrame.__init__(self, parent)
self.ui = load_ui(__file__, '../../../ui/diffraction/diffraction_run_setup.ui', baseinstance=self)
class BackgroundPlotter(QtInteractor):
"""Qt interactive plotter.
Background plotter for pyvista that allows you to maintain an
interactive plotting window without blocking the main python
thread.
Parameters
----------
show :
Show the plotting window. If ``False``, show this window by
running ``show()``
app : optional
Creates a `QApplication` if left as `None`.
window_size :
Window size in pixels. Defaults to ``[1024, 768]``
off_screen :
Renders off screen when True. Useful for automated
screenshots or debug testing.
allow_quit_keypress :
Allow user to exit by pressing ``"q"``.
toolbar : bool
If True, display the default camera toolbar. Defaults to True.
menu_bar : bool
If True, display the default main menu. Defaults to True.
editor: bool
If True, display the VTK object editor. Defaults to True.
update_app_icon :
If True, update_app_icon will be called automatically to update the
Qt app icon based on the current rendering output. If None, the
logo of PyVista will be used. If False, no icon will be set.
Defaults to None.
title : str, optional
Title of plotting window.
multi_samples : int, optional
The number of multi-samples used to mitigate aliasing. 4 is a
good default but 8 will have better results with a potential
impact on performance.
line_smoothing : bool, optional
If True, enable line smothing
point_smoothing : bool, optional
If True, enable point smothing
polygon_smoothing : bool, optional
If True, enable polygon smothing
auto_update : float, bool, optional
Automatic update rate in seconds. Useful for automatically
updating the render window when actors are change without
being automatically ``Modified``. If set to ``True``, update
rate will be 1 second.
Examples
--------
>>> import pyvista as pv
>>> from pyvistaqt import BackgroundPlotter
>>> plotter = BackgroundPlotter()
>>> _ = plotter.add_mesh(pv.Sphere())
"""
# pylint: disable=too-many-ancestors
# pylint: disable=too-many-instance-attributes
# pylint: disable=too-many-statements
ICON_TIME_STEP = 5.0
# pylint: disable=too-many-arguments
# pylint: disable=too-many-locals
def __init__(
self,
show: bool = True,
app: Optional[QApplication] = None,
window_size: Optional[Tuple[int, int]] = None,
off_screen: Optional[bool] = None,
allow_quit_keypress: bool = True,
toolbar: bool = True,
menu_bar: bool = True,
editor: bool = True,
update_app_icon: Optional[bool] = None,
**kwargs: Any,
) -> None:
# pylint: disable=too-many-branches
"""Initialize the qt plotter."""
# avoid recursion of the close() function by setting
# self._closed=True until the BasePlotter.__init__
# is called
self._closed = True
LOG.debug("BackgroundPlotter init start")
_check_type(show, "show", [bool])
_check_type(app, "app", [QApplication, type(None)])
_check_type(window_size, "window_size", [tuple, type(None)])
_check_type(off_screen, "off_screen", [bool, type(None)])
_check_type(allow_quit_keypress, "allow_quit_keypress", [bool])
_check_type(toolbar, "toolbar", [bool])
_check_type(menu_bar, "menu_bar", [bool])
_check_type(editor, "editor", [bool])
_check_type(update_app_icon, "update_app_icon", [bool, type(None)])
# toolbar
self._view_action: QAction = None
self.default_camera_tool_bar: QToolBar = None
self.saved_camera_positions: Optional[list] = None
self.saved_cameras_tool_bar: QToolBar = None
# menu bar
self.main_menu: QMenuBar = None
self._edl_action: QAction = None
self._menu_close_action: QAction = None
self._parallel_projection_action: QAction = None
# editor
self.editor: Optional[Editor] = None
self._editor_action: QAction = None
self.active = True
self.counters: List[Counter] = []
self.allow_quit_keypress = allow_quit_keypress
if window_size is None:
window_size = global_theme.window_size
# Remove notebook argument in case user passed it
kwargs.pop("notebook", None)
self.ipython = _setup_ipython()
self.app = _setup_application(app)
self.off_screen = _setup_off_screen(off_screen)
self.app_window = MainWindow(title=kwargs.get("title", global_theme.title))
self.frame = QFrame(parent=self.app_window)
self.frame.setFrameStyle(QFrame.NoFrame)
vlayout = QVBoxLayout()
super().__init__(parent=self.frame, off_screen=off_screen, **kwargs)
assert not self._closed
vlayout.addWidget(self)
self.frame.setLayout(vlayout)
self.app_window.setCentralWidget(self.frame)
self.app_window.grabGesture(QtCore.Qt.PinchGesture)
self.app_window.signal_gesture.connect(self.gesture_event)
self.app_window.signal_close.connect(self._close)
if menu_bar:
self.add_menu_bar()
if editor:
self.add_editor()
if toolbar:
self.add_toolbars()
if show and not self.off_screen: # pragma: no cover
self.app_window.show()
self.window_size = window_size
self._last_update_time = -np.inf
self._last_window_size = self.window_size
self._last_camera_pos = self.camera_position
if update_app_icon:
self.add_callback(self.update_app_icon)
elif update_app_icon is None:
self.set_icon(
os.path.join(
os.path.dirname(__file__), "data", "pyvista_logo_square.png"
)
)
else:
assert update_app_icon is False
# Keypress events
if self.iren is not None:
self.add_key_event("S", self._qt_screenshot) # shift + s
LOG.debug("BackgroundPlotter init stop")
def reset_key_events(self) -> None:
"""Reset all of the key press events to their defaults.
Handles closing configuration for q-key.
"""
super().reset_key_events()
if self.allow_quit_keypress:
# pylint: disable=unnecessary-lambda
self.add_key_event("q", lambda: self.close())
def scale_axes_dialog(self, show: bool = True) -> ScaleAxesDialog:
"""Open scale axes dialog."""
return ScaleAxesDialog(self.app_window, self, show=show)
def close(self) -> None:
"""Close the plotter.
This function closes the window which in turn will
close the plotter through `signal_close`.
"""
if not self._closed:
# Can get:
#
# RuntimeError: wrapped C/C++ object of type MainWindow has
# been deleted
#
# So let's be safe and try/except this in case of a problem.
try:
self.app_window.close()
except Exception:
pass
def _close(self) -> None:
super().close()
def update_app_icon(self) -> None:
"""Update the app icon if the user is not trying to resize the window."""
if os.name == "nt" or not hasattr(
self, "_last_window_size"
): # pragma: no cover
# DO NOT EVEN ATTEMPT TO UPDATE ICON ON WINDOWS
return
cur_time = time.time()
if self._last_window_size != self.window_size: # pragma: no cover
# Window size hasn't remained constant since last render.
# This means the user is resizing it so ignore update.
pass
elif (
cur_time - self._last_update_time > BackgroundPlotter.ICON_TIME_STEP
) and self._last_camera_pos != self.camera_position:
# its been a while since last update OR
# the camera position has changed and its been at least one second
# Update app icon as preview of the window
self.set_icon(pad_image(self.image))
# Update trackers
self._last_update_time = cur_time
self._last_camera_pos = self.camera_position
# Update trackers
self._last_window_size = self.window_size
def set_icon(self, img: Union[np.ndarray, str]) -> None:
"""Set the icon image.
Parameters
----------
img : ndarray, shape (w, h, c) | str
The image. Should be uint8 and square (w == h).
Can have 3 or 4 color/alpha channels (``c``).
Can also be a string path that QIcon can load.
Notes
-----
Currently string paths can silently fail, so make sure your path
is something that produces a valid ``QIcon(img)``.
"""
if not (
isinstance(img, np.ndarray)
and img.ndim == 3
and img.shape[0] == img.shape[1]
and img.dtype == np.uint8
and img.shape[-1] in (3, 4)
) and not isinstance(img, str):
raise ValueError(
"img must be 3D uint8 ndarray with shape[1] == shape[2] and "
"shape[2] == 3 or 4, or str"
)
if isinstance(img, np.ndarray):
fmt_str = "Format_RGB"
fmt_str += ("A8" if img.shape[2] == 4 else "") + "888"
fmt = getattr(QtGui.QImage, fmt_str)
img = QtGui.QPixmap.fromImage(
QtGui.QImage(img.copy(), img.shape[1], img.shape[0], fmt)
)
# Currently no way to check if str/path is actually correct (want to
# allow resource paths and the like so os.path.isfile is no good)
# and icon.isNull() returns False even if the path is bogus.
self.app.setWindowIcon(QtGui.QIcon(img))
def _qt_screenshot(self, show: bool = True) -> FileDialog:
return FileDialog(
self.app_window,
filefilter=["Image File (*.png)", "JPEG (*.jpeg)"],
show=show,
directory=bool(os.getcwd()),
callback=self.screenshot,
)
def _qt_export_vtkjs(self, show: bool = True) -> FileDialog:
"""Spawn an save file dialog to export a vtkjs file."""
return FileDialog(
self.app_window,
filefilter=["VTK JS File(*.vtkjs)"],
show=show,
directory=bool(os.getcwd()),
callback=self.export_vtkjs,
)
def _toggle_edl(self) -> None:
if hasattr(self.renderer, "edl_pass"):
return self.renderer.disable_eye_dome_lighting()
return self.renderer.enable_eye_dome_lighting()
def _toggle_parallel_projection(self) -> None:
if self.camera.GetParallelProjection():
return self.disable_parallel_projection()
return self.enable_parallel_projection()
@property
def window_size(self) -> Tuple[int, int]:
"""Return render window size."""
the_size = self.app_window.baseSize()
return the_size.width(), the_size.height()
@window_size.setter
def window_size(self, window_size: QSize) -> None:
"""Set the render window size."""
self.app_window.setBaseSize(*window_size)
self.app_window.resize(*window_size)
# NOTE: setting BasePlotter is unnecessary and Segfaults CI
# BasePlotter.window_size.fset(self, window_size)
def __del__(self) -> None: # pragma: no cover
"""Delete the qt plotter."""
if not self._closed:
self.app_window.close()
def add_callback(
self, func: Callable, interval: int = 1000, count: Optional[int] = None
) -> None:
"""Add a function that can update the scene in the background.
Parameters
----------
func :
Function to be called with no arguments.
interval :
Time interval between calls to `func` in milliseconds.
count :
Number of times `func` will be called. If None,
`func` will be called until the main window is closed.
"""
self._callback_timer = QTimer(parent=self.app_window)
self._callback_timer.timeout.connect(func)
self._callback_timer.start(interval)
self.app_window.signal_close.connect(self._callback_timer.stop)
if count is not None:
counter = Counter(count)
counter.signal_finished.connect(self._callback_timer.stop)
self._callback_timer.timeout.connect(counter.decrease)
self.counters.append(counter)
def save_camera_position(self) -> None:
"""Save camera position to saved camera menu for recall."""
if self.saved_camera_positions is not None:
# pylint: disable=attribute-defined-outside-init
self.camera_position: Any
self.saved_camera_positions.append(self.camera_position)
ncam = len(self.saved_camera_positions)
if self.camera_position is not None:
camera_position: Any = self.camera_position[:] # py2.7 copy compatibility
if hasattr(self, "saved_cameras_tool_bar"):
def load_camera_position() -> None:
# pylint: disable=attribute-defined-outside-init
self.camera_position = camera_position
self.saved_cameras_tool_bar.addAction(
"Cam %2d" % ncam, load_camera_position
)
if ncam < 10:
self.add_key_event(str(ncam), load_camera_position)
def clear_camera_positions(self) -> None:
"""Clear all camera positions."""
if hasattr(self, "saved_cameras_tool_bar"):
for action in self.saved_cameras_tool_bar.actions():
if action.text() not in [SAVE_CAM_BUTTON_TEXT, CLEAR_CAMS_BUTTON_TEXT]:
self.saved_cameras_tool_bar.removeAction(action)
self.saved_camera_positions = []
def _add_action(self, tool_bar: QToolBar, key: str, method: Any) -> QAction:
action = QAction(key, self.app_window)
action.triggered.connect(method)
tool_bar.addAction(action)
return action
def add_toolbars(self) -> None:
"""Add the toolbars."""
# Camera toolbar
self.default_camera_tool_bar = self.app_window.addToolBar("Camera Position")
def _view_vector(*args: Any) -> None:
return self.view_vector(*args)
cvec_setters = {
# Viewing vector then view up vector
"Top (-Z)": lambda: _view_vector((0, 0, 1), (0, 1, 0)),
"Bottom (+Z)": lambda: _view_vector((0, 0, -1), (0, 1, 0)),
"Front (-Y)": lambda: _view_vector((0, 1, 0), (0, 0, 1)),
"Back (+Y)": lambda: _view_vector((0, -1, 0), (0, 0, 1)),
"Left (-X)": lambda: _view_vector((1, 0, 0), (0, 0, 1)),
"Right (+X)": lambda: _view_vector((-1, 0, 0), (0, 0, 1)),
"Isometric": lambda: _view_vector((1, 1, 1), (0, 0, 1)),
}
for key, method in cvec_setters.items():
self._view_action = self._add_action(
self.default_camera_tool_bar, key, method
)
# pylint: disable=unnecessary-lambda
self._add_action(
self.default_camera_tool_bar, "Reset", lambda: self.reset_camera()
)
# Saved camera locations toolbar
self.saved_camera_positions = []
self.saved_cameras_tool_bar = self.app_window.addToolBar(
"Saved Camera Positions"
)
self._add_action(
self.saved_cameras_tool_bar, SAVE_CAM_BUTTON_TEXT, self.save_camera_position
)
self._add_action(
self.saved_cameras_tool_bar,
CLEAR_CAMS_BUTTON_TEXT,
self.clear_camera_positions,
)
def add_menu_bar(self) -> None:
"""Add the main menu bar."""
self.main_menu = _create_menu_bar(parent=self.app_window)
self.app_window.signal_close.connect(self.main_menu.clear)
file_menu = self.main_menu.addMenu("File")
file_menu.addAction("Take Screenshot", self._qt_screenshot)
file_menu.addAction("Export as VTKjs", self._qt_export_vtkjs)
file_menu.addSeparator()
# member variable for testing only
self._menu_close_action = file_menu.addAction("Exit", self.app_window.close)
view_menu = self.main_menu.addMenu("View")
self._edl_action = view_menu.addAction(
"Toggle Eye Dome Lighting", self._toggle_edl
)
view_menu.addAction("Scale Axes", self.scale_axes_dialog)
view_menu.addAction("Clear All", self.clear)
tool_menu = self.main_menu.addMenu("Tools")
tool_menu.addAction("Enable Cell Picking (through)", self.enable_cell_picking)
tool_menu.addAction(
"Enable Cell Picking (visible)",
lambda: self.enable_cell_picking(through=False),
)
cam_menu = view_menu.addMenu("Camera")
self._parallel_projection_action = cam_menu.addAction(
"Toggle Parallel Projection", self._toggle_parallel_projection
)
view_menu.addSeparator()
# Orientation marker
orien_menu = view_menu.addMenu("Orientation Marker")
orien_menu.addAction("Show All", self.show_axes_all)
orien_menu.addAction("Hide All", self.hide_axes_all)
# Bounds axes
axes_menu = view_menu.addMenu("Bounds Axes")
axes_menu.addAction("Add Bounds Axes (front)", self.show_bounds)
axes_menu.addAction("Add Bounds Grid (back)", self.show_grid)
axes_menu.addAction("Add Bounding Box", self.add_bounding_box)
axes_menu.addSeparator()
axes_menu.addAction("Remove Bounding Box", self.remove_bounding_box)
axes_menu.addAction("Remove Bounds", self.remove_bounds_axes)
# A final separator to separate OS options
view_menu.addSeparator()
def add_editor(self) -> None:
"""Add the editor."""
self.editor = Editor(parent=self.app_window, renderers=self.renderers)
self._editor_action = self.main_menu.addAction("Editor", self.editor.toggle)
self.app_window.signal_close.connect(self.editor.close)
def __init__(self, img):
QFrame.__init__(self)
# self.setFrameStyle(QFrame.Box | QFrame.Sunken)
self.img = img
self.mixer = ColorMixer(self.img)
self.callback = None
#---------------------------------------------------------------
# ComboBox
#---------------------------------------------------------------
self.combo_box_entries = ['RGB Color', 'HSV Color',
'Brightness/Contrast',
'Gamma',
'Gamma (Sigmoidal)']
self.combo_box = QComboBox()
for entry in self.combo_box_entries:
self.combo_box.addItem(entry)
self.combo_box.currentIndexChanged.connect(self.combo_box_changed)
#---------------------------------------------------------------
# RGB color sliders
#---------------------------------------------------------------
# radio buttons
self.rgb_add = QRadioButton('Additive')
self.rgb_mul = QRadioButton('Multiplicative')
self.rgb_mul.toggled.connect(self.rgb_radio_changed)
self.rgb_add.toggled.connect(self.rgb_radio_changed)
# sliders
rs = IntelligentSlider('R', 0.51, -255, self.rgb_changed)
gs = IntelligentSlider('G', 0.51, -255, self.rgb_changed)
bs = IntelligentSlider('B', 0.51, -255, self.rgb_changed)
self.rs = rs
self.gs = gs
self.bs = bs
self.rgb_widget = QWidget()
self.rgb_widget.layout = QGridLayout(self.rgb_widget)
self.rgb_widget.layout.addWidget(self.rgb_add, 0, 0, 1, 3)
self.rgb_widget.layout.addWidget(self.rgb_mul, 1, 0, 1, 3)
self.rgb_widget.layout.addWidget(self.rs, 2, 0)
self.rgb_widget.layout.addWidget(self.gs, 2, 1)
self.rgb_widget.layout.addWidget(self.bs, 2, 2)
#---------------------------------------------------------------
# HSV sliders
#---------------------------------------------------------------
# radio buttons
self.hsv_add = QRadioButton('Additive')
self.hsv_mul = QRadioButton('Multiplicative')
self.hsv_mul.toggled.connect(self.hsv_radio_changed)
self.hsv_mul.toggled.connect(self.hsv_radio_changed)
# sliders
hs = IntelligentSlider('H', 0.36, -180, self.hsv_changed)
ss = IntelligentSlider('S', 0.002, 0, self.hsv_changed)
vs = IntelligentSlider('V', 0.002, 0, self.hsv_changed)
self.hs = hs
self.ss = ss
self.vs = vs
self.hsv_widget = QWidget()
self.hsv_widget.layout = QGridLayout(self.hsv_widget)
self.hsv_widget.layout.addWidget(self.hsv_add, 0, 0, 1, 3)
self.hsv_widget.layout.addWidget(self.hsv_mul, 1, 0, 1, 3)
self.hsv_widget.layout.addWidget(self.hs, 2, 0)
self.hsv_widget.layout.addWidget(self.ss, 2, 1)
self.hsv_widget.layout.addWidget(self.vs, 2, 2)
#---------------------------------------------------------------
# Brightness/Contrast sliders
#---------------------------------------------------------------
# sliders
cont = IntelligentSlider('x', 0.002, 0, self.bright_changed)
bright = IntelligentSlider('+', 0.51, -255, self.bright_changed)
self.cont = cont
self.bright = bright
# layout
self.bright_widget = QWidget()
self.bright_widget.layout = QGridLayout(self.bright_widget)
self.bright_widget.layout.addWidget(self.cont, 0, 0)
self.bright_widget.layout.addWidget(self.bright, 0, 1)
#----------------------------------------------------------------------
# Gamma Slider
#----------------------------------------------------------------------
gamma = IntelligentSlider('gamma', 0.005, 0, self.gamma_changed)
self.gamma = gamma
# layout
self.gamma_widget = QWidget()
self.gamma_widget.layout = QGridLayout(self.gamma_widget)
self.gamma_widget.layout.addWidget(self.gamma, 0, 0)
#---------------------------------------------------------------
# Sigmoid Gamma sliders
#---------------------------------------------------------------
# sliders
alpha = IntelligentSlider('alpha', 0.011, 1, self.sig_gamma_changed)
beta = IntelligentSlider('beta', 0.012, 0, self.sig_gamma_changed)
self.a_gamma = alpha
self.b_gamma = beta
# layout
self.sig_gamma_widget = QWidget()
self.sig_gamma_widget.layout = QGridLayout(self.sig_gamma_widget)
self.sig_gamma_widget.layout.addWidget(self.a_gamma, 0, 0)
self.sig_gamma_widget.layout.addWidget(self.b_gamma, 0, 1)
#---------------------------------------------------------------
# Buttons
#---------------------------------------------------------------
self.commit_button = QPushButton('Commit')
self.commit_button.clicked.connect(self.commit_changes)
self.revert_button = QPushButton('Revert')
self.revert_button.clicked.connect(self.revert_changes)
#---------------------------------------------------------------
# Mixer Layout
#---------------------------------------------------------------
self.sliders = QStackedWidget()
self.sliders.addWidget(self.rgb_widget)
self.sliders.addWidget(self.hsv_widget)
self.sliders.addWidget(self.bright_widget)
self.sliders.addWidget(self.gamma_widget)
self.sliders.addWidget(self.sig_gamma_widget)
self.layout = QGridLayout(self)
self.layout.addWidget(self.combo_box, 0, 0)
self.layout.addWidget(self.sliders, 1, 0)
self.layout.addWidget(self.commit_button, 2, 0)
self.layout.addWidget(self.revert_button, 3, 0)
#---------------------------------------------------------------
# State Initialization
#---------------------------------------------------------------
self.combo_box.setCurrentIndex(0)
self.rgb_mul.setChecked(True)
self.hsv_mul.setChecked(True)
def setup_grain_design():
# grain table view
master = QHBoxLayout(self)
master.addWidget(QTableView())
# grain design controls
controls = QVBoxLayout(self)
# add a push button
self.btn_new_grain = QPushButton(self.tr("New Grain"))
self.btn_new_grain.setMinimumHeight(50)
controls.addWidget(self.btn_new_grain)
# add a dividing line
line = QFrame()
line.setFrameShape(QFrame.HLine)
line.setFrameShadow(QFrame.Sunken)
controls.addSpacing(5)
controls.addWidget(line)
# rest of the controls buttons
self.btn_edit_grain = QPushButton(self.tr("Edit"))
self.btn_edit_grain.setMinimumHeight(30)
controls.addWidget(self.btn_edit_grain)
self.btn_delete_Grain = QPushButton(self.tr("Delete"))
self.btn_delete_Grain.setMinimumHeight(30)
controls.addWidget(self.btn_delete_Grain)
# move grain up and down
moveup = QHBoxLayout()
self.btn_move_up = QToolButton()
self.btn_move_up.setArrowType(Qt.UpArrow)
moveup.addWidget(self.btn_move_up)
moveup.addWidget(QLabel(self.tr("Move Up")))
controls.addLayout(moveup)
movedown = QHBoxLayout()
self.btn_move_down = QToolButton()
self.btn_move_down.setArrowType(Qt.DownArrow)
movedown.addWidget(self.btn_move_down)
movedown.addWidget(QLabel(self.tr("Move Down")))
controls.addLayout(movedown)
controls.addStretch()
# add info for motor design
fl_propellant_info = QFormLayout()
gb_motor_info = QGroupBox(self.tr("Propellant Info"))
gb_motor_info.setLayout(fl_propellant_info)
self.lbl_num_grains = QLabel()
fl_propellant_info.addRow(QLabel(self.tr("Number of Segments:")), self.lbl_num_grains)
self.lbl_motor_dia = QLabel()
fl_propellant_info.addRow(QLabel(self.tr("Motor Diameter:")), self.lbl_motor_dia)
self.lbl_motor_len = QLabel()
fl_propellant_info.addRow(QLabel(self.tr("Propellant Length:")), self.lbl_motor_len)
self.lbl_prop_mass = QLabel()
fl_propellant_info.addRow(QLabel(self.tr("Propellant Mass:")), self.lbl_prop_mass)
self.lbl_volume_loading = QLabel()
fl_propellant_info.addRow(QLabel(self.tr("Volume Loading:")), self.lbl_volume_loading)
# set group box's layout
controls.addWidget(gb_motor_info)
# setup master layout
master.addLayout(controls)
self.gb_design = QGroupBox(self.tr("Grain Design"))
self.gb_design.setLayout(master)
def __init__(self, parent=None):
QFrame.__init__(self, parent)
self.ui = load_ui(
__file__,
'../../../ui/diffraction/diffraction_run_setup.ui',
baseinstance=self)
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.dir = None
self.runconf = RunConfiguration()
firstrun_o = CONF.get('run', ALWAYS_OPEN_FIRST_RUN_OPTION, False)
# --- Interpreter ---
interpreter_group = QGroupBox(_("Console"))
interpreter_layout = QVBoxLayout()
interpreter_group.setLayout(interpreter_layout)
self.current_radio = QRadioButton(CURRENT_INTERPRETER)
interpreter_layout.addWidget(self.current_radio)
self.dedicated_radio = QRadioButton(DEDICATED_INTERPRETER)
interpreter_layout.addWidget(self.dedicated_radio)
self.systerm_radio = QRadioButton(SYSTERM_INTERPRETER)
interpreter_layout.addWidget(self.systerm_radio)
# --- General settings ----
common_group = QGroupBox(_("General settings"))
common_layout = QGridLayout()
common_group.setLayout(common_layout)
self.clear_var_cb = QCheckBox(CLEAR_ALL_VARIABLES)
common_layout.addWidget(self.clear_var_cb, 0, 0)
self.post_mortem_cb = QCheckBox(POST_MORTEM)
common_layout.addWidget(self.post_mortem_cb, 1, 0)
self.clo_cb = QCheckBox(_("Command line options:"))
common_layout.addWidget(self.clo_cb, 2, 0)
self.clo_edit = QLineEdit()
self.clo_cb.toggled.connect(self.clo_edit.setEnabled)
self.clo_edit.setEnabled(False)
common_layout.addWidget(self.clo_edit, 2, 1)
# --- Working directory ---
wdir_group = QGroupBox(_("Working Directory settings"))
wdir_layout = QVBoxLayout()
wdir_group.setLayout(wdir_layout)
self.file_dir_radio = QRadioButton(FILE_DIR)
wdir_layout.addWidget(self.file_dir_radio)
self.cwd_radio = QRadioButton(CW_DIR)
wdir_layout.addWidget(self.cwd_radio)
fixed_dir_layout = QHBoxLayout()
self.fixed_dir_radio = QRadioButton(FIXED_DIR)
fixed_dir_layout.addWidget(self.fixed_dir_radio)
self.wd_edit = QLineEdit()
self.fixed_dir_radio.toggled.connect(self.wd_edit.setEnabled)
self.wd_edit.setEnabled(False)
fixed_dir_layout.addWidget(self.wd_edit)
browse_btn = QPushButton(ima.icon('DirOpenIcon'), '', self)
browse_btn.setToolTip(_("Select directory"))
browse_btn.clicked.connect(self.select_directory)
fixed_dir_layout.addWidget(browse_btn)
wdir_layout.addLayout(fixed_dir_layout)
# --- System terminal ---
external_group = QGroupBox(_("External system terminal"))
external_group.setDisabled(True)
self.systerm_radio.toggled.connect(external_group.setEnabled)
external_layout = QGridLayout()
external_group.setLayout(external_layout)
self.interact_cb = QCheckBox(INTERACT)
external_layout.addWidget(self.interact_cb, 1, 0, 1, -1)
self.pclo_cb = QCheckBox(_("Command line options:"))
external_layout.addWidget(self.pclo_cb, 3, 0)
self.pclo_edit = QLineEdit()
self.pclo_cb.toggled.connect(self.pclo_edit.setEnabled)
self.pclo_edit.setEnabled(False)
self.pclo_edit.setToolTip(_("<b>-u</b> is added to the "
"other options you set here"))
external_layout.addWidget(self.pclo_edit, 3, 1)
# Checkbox to preserve the old behavior, i.e. always open the dialog
# on first run
hline = QFrame()
hline.setFrameShape(QFrame.HLine)
hline.setFrameShadow(QFrame.Sunken)
self.firstrun_cb = QCheckBox(ALWAYS_OPEN_FIRST_RUN % _("this dialog"))
self.firstrun_cb.clicked.connect(self.set_firstrun_o)
self.firstrun_cb.setChecked(firstrun_o)
layout = QVBoxLayout()
layout.addWidget(interpreter_group)
layout.addWidget(common_group)
layout.addWidget(wdir_group)
layout.addWidget(external_group)
layout.addWidget(hline)
layout.addWidget(self.firstrun_cb)
self.setLayout(layout)
def __init__(self, parent=None):
QFrame.__init__(self, parent)
self.ui = load_ui(__file__, '../../../ui/inelastic/dgs_data_corrections.ui', baseinstance=self)
class SkiviImageWindow(QMainWindow):
def __init__(self, arr, mgr):
QMainWindow.__init__(self)
self.arr = arr
self.mgr = mgr
self.main_widget = QWidget()
self.layout = QGridLayout(self.main_widget)
self.setCentralWidget(self.main_widget)
self.label = ImageLabel(self, arr)
self.label_container = QFrame()
self.label_container.setFrameShape(QFrame.StyledPanel | QFrame.Sunken)
self.label_container.setLineWidth(1)
self.label_container.layout = QGridLayout(self.label_container)
self.label_container.layout.setContentsMargins(0, 0, 0, 0)
self.label_container.layout.addWidget(self.label, 0, 0)
self.layout.addWidget(self.label_container, 0, 0)
self.mgr.add_window(self)
self.main_widget.show()
self.setWindowTitle('Skivi - The skimage viewer.')
self.mixer_panel = MixerPanel(self.arr)
self.layout.addWidget(self.mixer_panel, 0, 2)
self.mixer_panel.show()
self.mixer_panel.set_callback(self.refresh_image)
self.rgbv_hist = QuadHistogram(self.arr)
self.layout.addWidget(self.rgbv_hist, 0, 1)
self.rgbv_hist.show()
self.rgb_hsv_disp = RGBHSVDisplay()
self.layout.addWidget(self.rgb_hsv_disp, 1, 0)
self.rgb_hsv_disp.show()
self.layout.setColumnStretch(0, 1)
self.layout.setRowStretch(0, 1)
self.save_file = QtWidgets.QPushButton('Save to File')
self.save_file.clicked.connect(self.save_to_file)
self.save_stack = QtWidgets.QPushButton('Save to Stack')
self.save_stack.clicked.connect(self.save_to_stack)
self.save_file.show()
self.save_stack.show()
self.layout.addWidget(self.save_stack, 1, 1)
self.layout.addWidget(self.save_file, 1, 2)
def closeEvent(self, event):
# Allow window to be destroyed by removing any
# references to it
self.mgr.remove_window(self)
def update_histograms(self):
self.rgbv_hist.update_hists(self.arr)
def refresh_image(self):
self.label.update_image()
self.update_histograms()
def scale_mouse_pos(self, x, y):
width = self.label.pm.width()
height = self.label.pm.height()
x_frac = 1. * x / width
y_frac = 1. * y / height
width = self.arr.shape[1]
height = self.arr.shape[0]
new_x = int(width * x_frac)
new_y = int(height * y_frac)
return(new_x, new_y)
def label_mouseMoveEvent(self, evt):
x = evt.x()
y = evt.y()
x, y = self.scale_mouse_pos(x, y)
# handle tracking out of array bounds
maxw = self.arr.shape[1]
maxh = self.arr.shape[0]
if x >= maxw or y >= maxh or x < 0 or y < 0:
r = g = b = h = s = v = ''
else:
r = self.arr[y, x, 0]
g = self.arr[y, x, 1]
b = self.arr[y, x, 2]
h, s, v = self.mixer_panel.mixer.rgb_2_hsv_pixel(r, g, b)
self.rgb_hsv_disp.update_vals((x, y, r, g, b, h, s, v))
def save_to_stack(self):
from ... import io
img = self.arr.copy()
io.push(img)
msg = dedent('''
The image has been pushed to the io stack.
Use io.pop() to retrieve the most recently
pushed image.''')
msglabel = QLabel(msg)
dialog = QtWidgets.QDialog()
ok = QtWidgets.QPushButton('OK', dialog)
ok.clicked.connect(dialog.accept)
ok.setDefault(True)
dialog.layout = QGridLayout(dialog)
dialog.layout.addWidget(msglabel, 0, 0, 1, 3)
dialog.layout.addWidget(ok, 1, 1)
dialog.exec_()
def save_to_file(self):
from ... import io
filename = str(QtWidgets.QFileDialog.getSaveFileName())
if len(filename) == 0:
return
io.imsave(filename, self.arr)
def __init__(
self,
show: bool = True,
app: Optional[QApplication] = None,
window_size: Optional[Tuple[int, int]] = None,
off_screen: Optional[bool] = None,
allow_quit_keypress: bool = True,
toolbar: bool = True,
menu_bar: bool = True,
editor: bool = True,
update_app_icon: Optional[bool] = None,
**kwargs: Any,
) -> None:
# pylint: disable=too-many-branches
"""Initialize the qt plotter."""
# avoid recursion of the close() function by setting
# self._closed=True until the BasePlotter.__init__
# is called
self._closed = True
LOG.debug("BackgroundPlotter init start")
_check_type(show, "show", [bool])
_check_type(app, "app", [QApplication, type(None)])
_check_type(window_size, "window_size", [tuple, type(None)])
_check_type(off_screen, "off_screen", [bool, type(None)])
_check_type(allow_quit_keypress, "allow_quit_keypress", [bool])
_check_type(toolbar, "toolbar", [bool])
_check_type(menu_bar, "menu_bar", [bool])
_check_type(editor, "editor", [bool])
_check_type(update_app_icon, "update_app_icon", [bool, type(None)])
# toolbar
self._view_action: QAction = None
self.default_camera_tool_bar: QToolBar = None
self.saved_camera_positions: Optional[list] = None
self.saved_cameras_tool_bar: QToolBar = None
# menu bar
self.main_menu: QMenuBar = None
self._edl_action: QAction = None
self._menu_close_action: QAction = None
self._parallel_projection_action: QAction = None
# editor
self.editor: Optional[Editor] = None
self._editor_action: QAction = None
self.active = True
self.counters: List[Counter] = []
self.allow_quit_keypress = allow_quit_keypress
if window_size is None:
window_size = global_theme.window_size
# Remove notebook argument in case user passed it
kwargs.pop("notebook", None)
self.ipython = _setup_ipython()
self.app = _setup_application(app)
self.off_screen = _setup_off_screen(off_screen)
self.app_window = MainWindow(title=kwargs.get("title", global_theme.title))
self.frame = QFrame(parent=self.app_window)
self.frame.setFrameStyle(QFrame.NoFrame)
vlayout = QVBoxLayout()
super().__init__(parent=self.frame, off_screen=off_screen, **kwargs)
assert not self._closed
vlayout.addWidget(self)
self.frame.setLayout(vlayout)
self.app_window.setCentralWidget(self.frame)
self.app_window.grabGesture(QtCore.Qt.PinchGesture)
self.app_window.signal_gesture.connect(self.gesture_event)
self.app_window.signal_close.connect(self._close)
if menu_bar:
self.add_menu_bar()
if editor:
self.add_editor()
if toolbar:
self.add_toolbars()
if show and not self.off_screen: # pragma: no cover
self.app_window.show()
self.window_size = window_size
self._last_update_time = -np.inf
self._last_window_size = self.window_size
self._last_camera_pos = self.camera_position
if update_app_icon:
self.add_callback(self.update_app_icon)
elif update_app_icon is None:
self.set_icon(
os.path.join(
os.path.dirname(__file__), "data", "pyvista_logo_square.png"
)
)
else:
assert update_app_icon is False
# Keypress events
if self.iren is not None:
self.add_key_event("S", self._qt_screenshot) # shift + s
LOG.debug("BackgroundPlotter init stop")
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.current_radio = None
self.dedicated_radio = None
self.systerm_radio = None
self.runconf = RunConfiguration()
firstrun_o = CONF.get("run", ALWAYS_OPEN_FIRST_RUN_OPTION, False)
# --- General settings ----
common_group = QGroupBox(_("General settings"))
common_layout = QGridLayout()
common_group.setLayout(common_layout)
self.clo_cb = QCheckBox(_("Command line options:"))
common_layout.addWidget(self.clo_cb, 0, 0)
self.clo_edit = QLineEdit()
self.clo_cb.toggled.connect(self.clo_edit.setEnabled)
self.clo_edit.setEnabled(False)
common_layout.addWidget(self.clo_edit, 0, 1)
self.wd_cb = QCheckBox(_("Working directory:"))
common_layout.addWidget(self.wd_cb, 1, 0)
wd_layout = QHBoxLayout()
self.wd_edit = QLineEdit()
self.wd_cb.toggled.connect(self.wd_edit.setEnabled)
self.wd_edit.setEnabled(False)
wd_layout.addWidget(self.wd_edit)
browse_btn = QPushButton(ima.icon("DirOpenIcon"), "", self)
browse_btn.setToolTip(_("Select directory"))
browse_btn.clicked.connect(self.select_directory)
wd_layout.addWidget(browse_btn)
common_layout.addLayout(wd_layout, 1, 1)
self.post_mortem_cb = QCheckBox(_("Enter debugging mode when " "errors appear during execution"))
common_layout.addWidget(self.post_mortem_cb)
# --- Interpreter ---
interpreter_group = QGroupBox(_("Console"))
interpreter_layout = QVBoxLayout()
interpreter_group.setLayout(interpreter_layout)
self.current_radio = QRadioButton(CURRENT_INTERPRETER)
interpreter_layout.addWidget(self.current_radio)
self.dedicated_radio = QRadioButton(DEDICATED_INTERPRETER)
interpreter_layout.addWidget(self.dedicated_radio)
self.systerm_radio = QRadioButton(SYSTERM_INTERPRETER)
interpreter_layout.addWidget(self.systerm_radio)
# --- Dedicated interpreter ---
new_group = QGroupBox(_("Dedicated Python console"))
self.current_radio.toggled.connect(new_group.setDisabled)
new_layout = QGridLayout()
new_group.setLayout(new_layout)
self.interact_cb = QCheckBox(_("Interact with the Python " "console after execution"))
new_layout.addWidget(self.interact_cb, 1, 0, 1, -1)
self.show_kill_warning_cb = QCheckBox(_("Show warning when killing" " running process"))
new_layout.addWidget(self.show_kill_warning_cb, 2, 0, 1, -1)
self.pclo_cb = QCheckBox(_("Command line options:"))
new_layout.addWidget(self.pclo_cb, 3, 0)
self.pclo_edit = QLineEdit()
self.pclo_cb.toggled.connect(self.pclo_edit.setEnabled)
self.pclo_edit.setEnabled(False)
self.pclo_edit.setToolTip(_("<b>-u</b> is added to the " "other options you set here"))
new_layout.addWidget(self.pclo_edit, 3, 1)
# Checkbox to preserve the old behavior, i.e. always open the dialog
# on first run
hline = QFrame()
hline.setFrameShape(QFrame.HLine)
hline.setFrameShadow(QFrame.Sunken)
self.firstrun_cb = QCheckBox(ALWAYS_OPEN_FIRST_RUN % _("this dialog"))
self.firstrun_cb.clicked.connect(self.set_firstrun_o)
self.firstrun_cb.setChecked(firstrun_o)
layout = QVBoxLayout()
layout.addWidget(interpreter_group)
layout.addWidget(common_group)
layout.addWidget(new_group)
layout.addWidget(hline)
layout.addWidget(self.firstrun_cb)
self.setLayout(layout)
def setup_toolbar(self):
"""Setup the toolbar"""
savefig_btn = create_toolbutton(self,
icon=ima.icon('filesave'),
tip=_("Save Image As..."),
triggered=self.save_figure)
saveall_btn = create_toolbutton(self,
icon=ima.icon('save_all'),
tip=_("Save All Images..."),
triggered=self.save_all_figures)
copyfig_btn = create_toolbutton(
self,
icon=ima.icon('editcopy'),
tip=_("Copy plot to clipboard as image (%s)" %
get_shortcut('plots', 'copy')),
triggered=self.copy_figure)
closefig_btn = create_toolbutton(self,
icon=ima.icon('editclear'),
tip=_("Remove image"),
triggered=self.close_figure)
closeall_btn = create_toolbutton(
self,
icon=ima.icon('filecloseall'),
tip=_("Remove all images from the explorer"),
triggered=self.close_all_figures)
vsep1 = QFrame()
vsep1.setFrameStyle(53)
goback_btn = create_toolbutton(self,
icon=ima.icon('ArrowBack'),
tip=_("Previous Figure ({})".format(
get_shortcut(
'plots', 'previous figure'))),
triggered=self.go_previous_thumbnail)
gonext_btn = create_toolbutton(self,
icon=ima.icon('ArrowForward'),
tip=_("Next Figure ({})".format(
get_shortcut(
'plots', 'next figure'))),
triggered=self.go_next_thumbnail)
vsep2 = QFrame()
vsep2.setFrameStyle(53)
zoom_out_btn = create_toolbutton(
self,
icon=ima.icon('zoom_out'),
tip=_("Zoom out (Ctrl + mouse-wheel-down)"),
triggered=self.zoom_out)
zoom_in_btn = create_toolbutton(
self,
icon=ima.icon('zoom_in'),
tip=_("Zoom in (Ctrl + mouse-wheel-up)"),
triggered=self.zoom_in)
self.zoom_disp = QSpinBox()
self.zoom_disp.setAlignment(Qt.AlignCenter)
self.zoom_disp.setButtonSymbols(QSpinBox.NoButtons)
self.zoom_disp.setReadOnly(True)
self.zoom_disp.setSuffix(' %')
self.zoom_disp.setRange(0, 9999)
self.zoom_disp.setValue(100)
self.figviewer.sig_zoom_changed.connect(self.zoom_disp.setValue)
zoom_pan = QWidget()
layout = QHBoxLayout(zoom_pan)
layout.setSpacing(0)
layout.setContentsMargins(0, 0, 0, 0)
layout.addWidget(zoom_out_btn)
layout.addWidget(zoom_in_btn)
layout.addWidget(self.zoom_disp)
return [
savefig_btn, saveall_btn, copyfig_btn, closefig_btn, closeall_btn,
vsep1, goback_btn, gonext_btn, vsep2, zoom_pan
]
def __init__(self, parent=None):
QFrame.__init__(self, parent)
self.ui = load_ui(__file__, '../../../ui/inelastic/dgs_absolute_units.ui', baseinstance=self)
