def filter(self, text): self.setRowCount(0) self.resizeColumnsToContents() text = text.strip() if not text: records = self.records_all elif '=' not in text: records = self.search_database_for_string(text) else: records = self.get_records(text) if not records: return self.setRowCount(len(records)) for row, record in enumerate(records): for col, element in enumerate(record.to_xml()): if element.tag == 'connection' and record.connection is not None: self.setItem(row, col, QtWidgets.QTableWidgetItem('True')) elif element.tag == 'properties': text = u'' if not element: self.setItem(row, col, QtWidgets.QTableWidgetItem(text)) else: for sub_element in element: text += u'{}={}; '.format(sub_element.tag, sub_element.text) self.setItem(row, col, QtWidgets.QTableWidgetItem(text)) else: self.setItem(row, col, QtWidgets.QTableWidgetItem(element.text)) self.resizeColumnsToContents()
def test_screen_geometry(): # just check that these don't raise an exception assert isinstance(utils.screen_geometry(), QtCore.QRect) assert isinstance(utils.screen_geometry(QtWidgets.QLabel()), QtCore.QRect) assert isinstance( utils.screen_geometry(QtWidgets.QLabel(parent=QtWidgets.QLabel())), QtCore.QRect)
def add_qt_tab(self, label, icons): """Add the Qt icons.""" tab = QtWidgets.QWidget() self.tab_widget.addTab(tab, label) layout = QtWidgets.QGridLayout() self.update_message('Loading Qt icons...') count = 0 num_cols = 4 for i in icons: button = QtWidgets.QPushButton(i) ico = convert.to_qicon(getattr(QtWidgets.QStyle, i)) button.setIcon(ico) button.clicked.connect(lambda *args, ic=ico, n=i: self.zoom(ic, n)) layout.addWidget(button, count // num_cols, count % num_cols) count += 1 self.num_icons += 1 tab.setLayout(layout) self.file_index += 1 self.progress_bar.setValue(self.file_index)
def _create_row(self, index=None): """Create a new row. Parameters ---------- index : :class:`int` or :obj:`None` If :obj:`None` then append a row, else the index number (0 based) for where to create and insert the row. """ cb = QtWidgets.QComboBox() cb.addItems(self._actions) sb = QtWidgets.QSpinBox() sb.setRange(0, 999999) msg = QtWidgets.QLineEdit() reply = QtWidgets.QLineEdit() reply.setReadOnly(True) index = index if index is not None else self._table.rowCount() self._table.insertRow(index) self._table.setCellWidget(index, 0, cb) self._table.setCellWidget(index, 1, sb) self._table.setCellWidget(index, 2, msg) self._table.setCellWidget(index, 3, reply) cb.currentTextChanged.connect( lambda text: self._update_row_appearance(text, index)) self._update_row_appearance(cb.currentText(), index)
def show_record(record): """Create a :class:`QtWidgets.QDialog` to display the information about a record. Parameters ---------- record : :class:`~msl.equipment.record_types.EquipmentRecord` or :class:`~msl.equipment.record_types.ConnectionRecord` An Equipment Record or a Connection Record. """ dialog = QtWidgets.QDialog() dialog.setWindowFlags(QtCore.Qt.WindowCloseButtonHint) dialog.setWindowTitle(record.__class__.__name__.replace('R', ' R')) widget = QtWidgets.QTextEdit() widget.setReadOnly(True) widget.setLineWrapMode(QtWidgets.QTextEdit.NoWrap) widget.setText(record.to_yaml()) hbox = QtWidgets.QHBoxLayout() hbox.addWidget(widget) dialog.setLayout(hbox) size = widget.document().size() sb = widget.horizontalScrollBar().size().height() dialog.resize(int((size.width() + sb) * 1.1), int((size.height() + sb) * 1.1)) # add 10% dialog.exec_()
def update_table(self, root): items = [(e.tag, e.text, e.attrib) for e in root if not e.tag.startswith('equipment')] self.setRowCount(len(items)) for i, item in enumerate(items): self.setItem(i, 0, QtWidgets.QTableWidgetItem(item[0])) self.setItem(i, 1, QtWidgets.QTableWidgetItem(item[1])) text = '; '.join('{}={}'.format(k, v) for k, v in item[2].items()) self.setItem(i, 2, QtWidgets.QTableWidgetItem(text)) self.resizeColumnsToContents()
def show(): app = application() window = QtWidgets.QWidget() window.setWindowTitle('Toggle Switch Example') hbox = QtWidgets.QHBoxLayout() ts = ToggleSwitch(window) ts.toggled.connect(print_state) hbox.addWidget(ts) window.setLayout(hbox) window.show() app.exec_()
def read_n_raw_readings(self, n_meas=250, trig_interval=0.02): """ Parameters ---------- n_meas : int number of measurements to collect Returns ------- tuple of t0_s, data. t0_s is the initial time in number of seconds passed since epoch; data is a list of n_meas raw values from the RF counter, in Hz """ # set up for fast graphing app = application() mw = QtWidgets.QMainWindow() mw.setWindowTitle("Capacitor raw data") cw = QtWidgets.QWidget() mw.setCentralWidget(cw) layout = QtWidgets.QVBoxLayout() cw.setLayout(layout) pw1 = pg.PlotWidget(name='Capacitor raw data') curve = pw1.plot() layout.addWidget(pw1) mw.show() self.rfcounter.write("INPUT:LEVEL:AUTO ONCE") # only need to get frequency level once self.rfcounter.write("INIT") # starts waiting for a trigger data = np.empty(n_meas) if self.triggerer is not None: self.triggerer.start_trigger() t0_s = time_ns()/1e9 rdgs_per_s = 1/trig_interval for i in range(n_meas): a = self.rfcounter.query("DATA:REM? 1,WAIT") # a is a string # read one data value taken from memory to buffer; remove value from memory after reading data[i] = float(a.strip("\n")) if i % rdgs_per_s == 0: # update plot every second curve.setData(data[:i]) # show only the collected data app.processEvents() if self.triggerer is not None: self.triggerer.stop_trigger() t1_s = time_ns() / 1e9 print("Elapsed time: {}".format(t1_s - t0_s)) return t0_s, data
def test_save_image(): file = NamedTemporaryFile() # no file extension is specified so cannot determine the image format with pytest.raises(OSError, match=r'Cannot save image'): utils.save_image(QtWidgets.QWidget(), file.name) path = file.name + '.png' assert not os.path.isfile(path) pixmap = utils.save_image(QtWidgets.QWidget(), path) assert os.path.isfile(path) assert isinstance(pixmap, QtGui.QPixmap) file.close()
def _show_vertical_popup_menu(self): """Handles a right-click on the selected row button(s)""" selected = self._table.selectionModel().selectedRows() if selected: r = 'row' if len(selected) == 1 else 'rows' t = 'the' if len(selected) == 1 else 'each' menu = QtWidgets.QMenu(self) remove = menu.addAction(self._remove_icon, 'Delete the selected ' + r) remove.triggered.connect( lambda: self._remove_selected_rows(selected)) insert_before = menu.addAction( self._insert_before_icon, 'Insert a row before %s selected row' % t) insert_before.triggered.connect( lambda: self._insert_selected(selected, 0)) insert_after = menu.addAction( self._insert_after_icon, 'Insert a row after %s selected row' % t) insert_after.triggered.connect( lambda: self._insert_selected(selected, 1)) clear = menu.addAction(self._clear_icon, 'Remove all of the empty rows') clear.triggered.connect(self._remove_empty_rows) menu.exec_(QtGui.QCursor.pos())
def _show_horizontal_popup_menu(self): """handles a right-click on the selected column button(s)""" selected = self._table.selectionModel().selectedColumns() if len(selected) == len(self._header): menu = QtWidgets.QMenu(self) clear = menu.addAction(self._clear_icon, 'Clear the table') clear.triggered.connect(self._clear_table) menu.exec_(QtGui.QCursor.pos())
def show_hardware_info(connection): """Displays the hardware information about a Thorlabs_ :class:`~msl.equipment.resources.thorlabs.kinesis.motion_control.MotionControl` device in a :class:`QtWidgets.QDialog`. Parameters ---------- connection : :class:`~msl.equipment.resources.thorlabs.kinesis.motion_control.MotionControl` A Thorlabs Motion Control subclass. """ info = connection.get_hardware_info() dialog = QtWidgets.QDialog() dialog.setWindowFlags(QtCore.Qt.WindowCloseButtonHint) dialog.setWindowTitle(connection.__class__.__name__) widget = QtWidgets.QTextEdit() widget.setReadOnly(True) widget.setLineWrapMode(QtWidgets.QTextEdit.NoWrap) text = 'Serial Number: {}\n'.format(info.serialNumber) text += 'Model Number: {}\n'.format(info.modelNumber.decode('utf-8')) text += 'Type: {}\n'.format(info.type) text += 'Number of Channels: {}\n'.format(info.numChannels) text += 'Notes: {}\n'.format(info.notes.decode('utf-8')) text += 'Firmware Version: {}\n'.format( connection.to_version(info.firmwareVersion)) text += 'Hardware Version: {}\n'.format( connection.to_version(info.hardwareVersion)) text += 'Modification State: {}'.format(info.modificationState) widget.setText(text) hbox = QtWidgets.QHBoxLayout() hbox.addWidget(widget) dialog.setLayout(hbox) size = widget.document().size() pad = widget.horizontalScrollBar().size().height() * 1.1 dialog.resize(int(size.width() + pad), int(size.height() + pad)) dialog.exec_()
def create_top_level(self): top_level_names = [] for name in self.equipment_table.header: if name in self.skip_names: continue if name in self.rename_map: name = self.rename_map[name] top_level_names.append(name) top_level_names.extend(['Backend', 'Interface']) # for ConnectionRecord's for item in sorted(top_level_names): QtWidgets.QTreeWidgetItem(self, [item])
def add_windows_tab(self): """Add the icons from the Windows DLL and EXE files.""" num_cols = 16 filename = self.windows_files[self.windows_index] self.update_message('Loading icons from {}...'.format(filename)) tab = QtWidgets.QWidget() self.tab_widget.addTab(tab, filename) layout = QtWidgets.QGridLayout() index = 0 while True: button = QtWidgets.QPushButton(str(index)) try: name = '{}|{}'.format(filename, str(index)) ico = convert.to_qicon(name) except OSError: break button.setIcon(ico) button.clicked.connect( lambda *args, ic=ico, n=name: self.zoom(ic, n)) layout.addWidget(button, index // num_cols, index % num_cols) index += 1 self.num_icons += 1 self.file_index += 1 self.progress_bar.setValue(self.file_index) tab.setLayout(layout) self.windows_index += 1 if self.windows_index == len(self.windows_files): self.timer.stop() self.update_message('Loaded {} icons.'.format(self.num_icons)) self.progress_bar.hide()
def __init__(self): app = application() self.tab_widget = QtWidgets.QTabWidget() self.main_window = QtWidgets.QMainWindow() self.main_window.setWindowTitle('Standard Icons') self.main_window.setCentralWidget(self.tab_widget) self.main_window.closeEvent = self.close_event # add a progress bar to the status bar self.progress_bar = QtWidgets.QProgressBar( self.main_window.statusBar()) self.progress_bar.setAlignment(QtCore.Qt.AlignCenter) self.main_window.statusBar().addPermanentWidget(self.progress_bar) self.main_window.showMaximized() self.num_icons = 0 self.file_index = 0 self.zoom_widget = QtWidgets.QDialog() self.zoom_widget.setSizeGripEnabled(True) self.zoom_widget.resize(QtCore.QSize(256, 256)) self.zoom_widget.setWindowFlags(QtCore.Qt.WindowCloseButtonHint) vbox = QtWidgets.QVBoxLayout() self.zoom_label = QtWidgets.QLabel() self.zoom_label.setScaledContents(True) vbox.addWidget(self.zoom_label) self.zoom_widget.setLayout(vbox) qt_icons = [sp for sp in dir(QtWidgets.QStyle) if sp.startswith('SP_')] self.windows_files = [ 'accessibilitycpl', 'compstui', 'ddores', 'dmdskres', 'explorer', 'gameux', 'ieframe', 'imageres', 'mmcndmgr', 'mmres', 'moricons', 'netcenter', 'netshell', 'networkexplorer', 'pifmgr', 'pnidui', 'sensorscpl', 'setupapi', 'shell32', 'wmploc', 'wpdshext' ] self.num_files = 1 + len(self.windows_files) self.progress_bar.setRange(0, self.num_files) self.add_qt_tab('Qt Icons', qt_icons) if has_clr: self.windows_index = 0 self.timer = QtCore.QTimer() self.timer.timeout.connect(self.add_windows_tab) self.timer.start(0) else: self.update_message('Loaded {} icons.'.format(self.num_icons)) self.progress_bar.hide() app.exec()
def __init__(self, parent=None): super(BlinkingLEDs, self).__init__(parent) self.setWindowTitle('Blinking LEDs') # The shape can be an enum value or member name (case in-sensitive) # The color can be anything that msl.qt.utils.to_qcolor() accepts params = [ { 'shape': LED.Circle, 'on_color': Qt.darkGreen, 'clickable': True }, { 'shape': 'rouNDed', 'on_color': (78, 82, 107) }, { 'shape': 2, 'on_color': 'cyan', 'clickable': True }, { 'shape': 'Triangle', 'on_color': '#6b3064' }, ] self.leds = [] layout = QtWidgets.QHBoxLayout() for kwargs in params: led = LED(**kwargs) led.toggled.connect(self.led_state_changed) led.clicked.connect(self.led_was_clicked) layout.addWidget(led) self.leds.append(led) self.setLayout(layout) self._timer = QtCore.QTimer() self._timer.timeout.connect(self.toggle_random_led) self._timer.start(200)
def paintEvent(self, event): """Overrides :meth:`QtWidgets.QWidget.paintEvent`.""" option = QtWidgets.QStyleOption() option.initFrom(self) h = option.rect.height() w = option.rect.width() if self._shape == Shapes.Triangle or self._shape == Shapes.Rounded: aspect = self._triangle_factor if self._shape == Shapes.Triangle else self._rounded_factor ah = w / aspect aw = w if ah > h: ah = h aw = h * aspect x = abs(aw - w) / 2.0 y = abs(ah - h) / 2.0 bounds = QtCore.QRectF(x, y, aw, ah) else: size = min(w, h) x = abs(size - w) / 2.0 y = abs(size - h) / 2.0 bounds = QtCore.QRectF(x, y, size, size) painter = QtGui.QPainter(self) painter.setRenderHint(QtGui.QPainter.Antialiasing, True) if self.isEnabled(): color = self._on_color if self._is_on else self._off_color else: color = QtGui.QColor('#BDBDBD') lighter = QtGui.QColor(color).lighter(150) # 150 -> 50% brighter color_str = 'rgb(%d,%d,%d)' % (color.red(), color.green(), color.blue()) lighter_str = 'rgb(%d,%d,%d)' % (lighter.red(), lighter.green(), lighter.blue()) svg = (SVG_MAP[self._shape] % (color_str, lighter_str)).encode('utf8') self._renderer.load(QtCore.QByteArray(svg)) self._renderer.render(painter, bounds)
def __init__(self, connection, parent=None): """ A :class:`~QtWidgets.QWidget` for a :class:`~msl.equipment.connection_message_based.ConnectionMessageBased` connection. This widget allows for reading/writing messages from/to equipment. Parameters ---------- connection : :class:`~msl.equipment.connection_message_based.ConnectionMessageBased` The connection to the equipment. parent : :class:`QtWidgets.QWidget` The parent widget. Example ------- To view an example of the :class:`MessageBased` widget that will send messages to a *dummy* :class:`~msl.equipment.record_types.EquipmentRecord` in demo mode, run: >>> from msl.examples.qt.equipment import message_based # doctest: +SKIP >>> message_based.show() # doctest: +SKIP """ super(MessageBased, self).__init__(parent=parent) r = connection.equipment_record self.setWindowTitle('{} || {} || {}'.format(r.manufacturer, r.model, r.serial)) self.setAcceptDrops(True) self._conn = connection self._dropped_commands = [] self._abort_execution = False self._command_list = [] self._header = ['Action', 'Delay', 'Message', 'Reply'] self._actions = ['write', 'read', 'query', 'delay'] self._table = QtWidgets.QTableWidget(0, len(self._header), self) self._table.setHorizontalHeaderLabels(self._header) self._table.horizontalHeader().setStretchLastSection(True) self._table.horizontalHeader().setContextMenuPolicy( QtCore.Qt.CustomContextMenu) self._table.horizontalHeader().customContextMenuRequested.connect( self._show_horizontal_popup_menu) self._table.verticalHeader().setContextMenuPolicy( QtCore.Qt.CustomContextMenu) self._table.verticalHeader().customContextMenuRequested.connect( self._show_vertical_popup_menu) self._timeout_spinbox = QtWidgets.QDoubleSpinBox() self._timeout_spinbox.setToolTip( '<html>The timeout value to use for <i>read</i> commands</html>') self._timeout_spinbox.setRange(0, 999999999) if 'ConnectionPyVISA' in '{}'.format( connection.__class__.__bases__): # a PyVISA connection self._timeout_spinbox.setSuffix(' ms') self._timeout_spinbox.setDecimals(0) else: self._timeout_spinbox.setSuffix(' s') self._timeout_spinbox.setDecimals(2) try: self._timeout_spinbox.setValue(self._conn.timeout) except TypeError: # in case the connection is established in demo mode self._timeout_spinbox.setValue(0) self._timeout_spinbox.valueChanged.connect(self._update_timeout) self._use_rows = QtWidgets.QLineEdit() self._use_rows.setToolTip( 'Enter the rows to execute or leave blank to execute all rows.\nFor example: 1,3,5-8' ) self._execute_icon = get_icon(QtWidgets.QStyle.SP_ArrowRight) self._continuous_icon = get_icon(QtWidgets.QStyle.SP_BrowserReload) self._abort_icon = get_icon(QtWidgets.QStyle.SP_BrowserStop) self._clear_icon = get_icon(QtWidgets.QStyle.SP_DialogResetButton) self._remove_icon = get_icon(QtWidgets.QStyle.SP_DialogCancelButton) self._insert_before_icon = get_icon(QtWidgets.QStyle.SP_DialogOkButton) # create an insert_after_icon by transforming the insert_before_icon size = self._insert_before_icon.availableSizes()[-1] pixmap = self._insert_before_icon.pixmap(size).transformed( QtGui.QTransform().scale(-1, 1)) self._insert_after_icon = QtGui.QIcon(pixmap) self._execute_thread = _Execute(self) self._execute_thread.finished.connect(self._check_if_looping) self._execute_thread.sig_error.connect(self._execute_error) self._execute_thread.sig_update_row_color.connect( self._update_row_appearance) self._execute_thread.sig_highlight_row.connect(self._highlight_row) self._execute_thread.sig_update_reply.connect(self._update_reply) self._execute_thread.sig_show_execute_icon.connect( self._show_execute_icon) self._loop_checkbox = QtWidgets.QCheckBox() self._loop_checkbox.setToolTip('Run continuously?') self._loop_checkbox.clicked.connect(self._show_execute_icon) save_icon = get_icon(QtWidgets.QStyle.SP_DriveFDIcon) self._save_button = QtWidgets.QPushButton(save_icon, 'Save') self._save_button.setToolTip('Save the table to a tab-delimited file') self._save_button.clicked.connect(self._save) self._info_button = QtWidgets.QPushButton( get_icon(QtWidgets.QStyle.SP_FileDialogInfoView), '') self._info_button.setToolTip( 'Display the information about the equipment') self._info_button.clicked.connect( lambda clicked, record=r: show_record(record)) self._status_label = QtWidgets.QLabel() self._execute_button = QtWidgets.QPushButton() self._execute_button.clicked.connect(self._execute_start) self._show_execute_icon() self._status_label.setText('Create a new Execution Table or\n' 'Drag & Drop or Copy & Paste\n' 'a previous Execution Table') execute_widget = QtWidgets.QWidget() grid = QtWidgets.QGridLayout() grid.addWidget(QtWidgets.QLabel('Timeout'), 1, 0, alignment=QtCore.Qt.AlignRight) grid.addWidget(self._timeout_spinbox, 1, 1, 1, 2) grid.addWidget(QtWidgets.QLabel('Rows'), 2, 0, alignment=QtCore.Qt.AlignRight) grid.addWidget(self._use_rows, 2, 1, 1, 2) grid.addWidget(self._execute_button, 3, 0, 1, 2) grid.addWidget(self._loop_checkbox, 3, 2, 1, 1, alignment=QtCore.Qt.AlignLeft) grid.addWidget(self._save_button, 4, 0, 1, 2) grid.addWidget(self._info_button, 4, 2, 1, 1) grid.addWidget(self._status_label, 5, 0, 1, 3, alignment=QtCore.Qt.AlignBottom) grid.setRowStretch(5, 1) execute_widget.setLayout(grid) self._create_row() self._table.resizeColumnsToContents() splitter = QtWidgets.QSplitter() splitter.addWidget(self._table) splitter.addWidget(execute_widget) splitter.setStretchFactor(0, 1) splitter.setChildrenCollapsible(False) splitter.setSizes([1, 0]) hbox = QtWidgets.QHBoxLayout() hbox.addWidget(splitter) self.setLayout(hbox)
import os from datetime import datetime from time import time, time_ns, sleep import numpy as np import matplotlib.pyplot as plt import pyqtgraph as pg from msl.qt import QtWidgets, application from equip import CetoniSP from data_handling import fit_sinusoid app = application() mw = QtWidgets.QMainWindow() mw.setWindowTitle("Syringe pump fill level") cw = QtWidgets.QWidget() mw.setCentralWidget(cw) layout = QtWidgets.QVBoxLayout() cw.setLayout(layout) pw1 = pg.PlotWidget(name='Syringe pump fill level') curve = pw1.plot() layout.addWidget(pw1) class Experimenter(object): def __init__(self): self.sp = None self.t_data = [] # time in seconds self.fl_data = [] # syringe plunger fill level in unit set (mL)
def __init__(self, parent=None): """A :class:`~QtWidgets.QWidget` to view a :ref:`Configuration File <msl.equipment:configuration_file>`. Parameters ---------- parent : :class:`QtWidgets.QWidget`, optional The parent :class:`QtWidgets.QWidget`. Example ------- To view an example of the :class:`ConfigurationViewer`, run: >>> from msl.examples.qt.equipment import configuration_viewer # doctest: +SKIP >>> configuration_viewer.show() # doctest: +SKIP """ super(ConfigurationViewer, self).__init__(parent=parent) if not has_msl_equipment: raise ImportError( 'This class requires that MSL Equipment is installed') self.setAcceptDrops(True) self._dropped_path = None self._database = None # # selecting a configuration file # browse = Button(icon=QtWidgets.QStyle.SP_DialogOpenButton) browse.setToolTip('Select a configuration file') browse.set_left_click(self._browse_file) self._filebox = QtWidgets.QLineEdit() self._filebox.setToolTip('Drag \'n drop a configuration file') self._filebox.setReadOnly(True) select_layout = QtWidgets.QHBoxLayout() select_layout.addWidget(browse) select_layout.addWidget(self._filebox) select_layout.setSpacing(1) # # the filter field # self._filter = QtWidgets.QLineEdit() self._filter.setToolTip('Search filter for the database') self._filter.returnPressed.connect(self._apply_filter) filter_button = Button(icon=QtWidgets.QStyle.SP_FileDialogContentsView, tooltip='Apply filter') filter_button.set_left_click(self._apply_filter) clear_button = Button(icon=QtWidgets.QStyle.SP_LineEditClearButton, tooltip='Clear filter') clear_button.set_left_click(self._clear_filter) filter_layout = QtWidgets.QHBoxLayout() filter_layout.addWidget(filter_button) filter_layout.addWidget(self._filter) filter_layout.addWidget(clear_button) filter_layout.setSpacing(1) # # the Tree and Tables # self._equipment_records_table = _RecordTable(EquipmentRecord, self) self._connection_records_table = _RecordTable(ConnectionRecord, self) self._equipment_table = _RecordTable(EquipmentRecord, self, is_dict=True) self._constants_table = _ConstantsTable(self) self._tree = _Tree(self._equipment_records_table, self._connection_records_table) self._tree.sig_selected.connect(self._tree_item_selected) self._tree.setToolTip( 'Double click an item to select it.\n\nHold the CTRL key to select multiple items.' ) tab = QtWidgets.QTabWidget() tab.addTab(self._equipment_records_table, 'Equipment Records') tab.addTab(self._connection_records_table, 'Connection Records') tab.addTab(self._equipment_table, 'Equipment Tags') tab.addTab(self._constants_table, 'Constants') tab.addTab(Logger(), 'Log') splitter = QtWidgets.QSplitter() splitter.addWidget(self._tree) splitter.addWidget(tab) splitter.setStretchFactor(1, 1) # the tab expands to fill the full width splitter.setSizes((self._tree.sizeHint().width() * 1.1, 1)) main_layout = QtWidgets.QVBoxLayout() main_layout.addLayout(select_layout) main_layout.addLayout(filter_layout) main_layout.addWidget(splitter) self.setLayout(main_layout)
def populate_tree(self): self.clear() self.create_top_level() for index in range(self.topLevelItemCount()): item = self.topLevelItem(index) name = item.text(0) if name == 'Manufacturer': values = {} for record in self.equipment_table.records_all: if record.manufacturer and record.manufacturer not in values: values[record.manufacturer] = [record.model] else: if record.model and record.model not in values[ record.manufacturer]: values[record.manufacturer].append(record.model) item.setText(0, name + ' ({})'.format(len(values))) for manufacturer in sorted(values): model_item = QtWidgets.QTreeWidgetItem( item, [manufacturer]) for model in sorted(values[manufacturer]): QtWidgets.QTreeWidgetItem(model_item, [model]) elif name == 'Year Calibrated': years = [] for record in self.equipment_table.records_all: year = record.date_calibrated.year if year > 1 and year not in years: years.append(year) item.setText(0, name + ' ({})'.format(len(years))) for year in sorted(years)[::-1]: QtWidgets.QTreeWidgetItem(item, [str(year)]) elif name == 'Connection': bools = {'True': 0, 'False': 0} for record in self.equipment_table.records_all: bools[str(record.connection is not None)] += 1 item.setText(0, name + ' (2)') for key in sorted(bools): QtWidgets.QTreeWidgetItem(item, [key]) elif name == 'Calibration Cycle': cycles = [] for record in self.equipment_table.records_all: if record.calibration_cycle == 0: continue if int(record.calibration_cycle ) == record.calibration_cycle: cycle = int(record.calibration_cycle) else: cycle = record.calibration_cycle if cycle not in cycles: cycles.append(cycle) item.setText(0, name + ' ({})'.format(len(cycles))) for c in sorted(cycles): QtWidgets.QTreeWidgetItem(item, [str(c)]) else: if name == 'Backend' or name == 'Interface': values = self._get_distinct_connection_records(name) else: values = self._get_distinct_equipment_records(name) item.setText(0, name + ' ({})'.format(len(values))) for value in sorted(values): QtWidgets.QTreeWidgetItem(item, [value])
def __init__(self, client, **kwargs): super(Gui, self).__init__() self.path = kwargs.pop('path', None) self.client = client self.original_image = None self.delta = 0.01 # the amount to translate image on UP DOWN LEFT RIGHT key presses self.client_queue = {} # a queue of requests to send to the RPi zoom = kwargs.get('zoom') if zoom: self.zoom_history = [zoom] # (x, y, width, height) values between 0.0 and 1.0 else: self.zoom_history = [] self.ocr_params = { 'zoom': zoom, 'rotate': kwargs.get('rotate'), 'threshold': kwargs.get('threshold'), 'dilate': kwargs.get('dilate'), 'erode': kwargs.get('erode'), 'blur': kwargs.get('blur'), 'algorithm': kwargs.get('algorithm', 'tesseract').lower(), 'lang': kwargs.get('lang', 'eng').lower(), } self.ocr_label = QtWidgets.QLabel() self.ocr_label.setFont(QtGui.QFont('Helvetica', 14)) # the canvas widget to display the image self.graphics_view = pg.GraphicsView(background=None) self.view_box = pg.ViewBox(invertY=True, lockAspect=True, enableMouse=False, enableMenu=False) self.graphics_view.setCentralItem(self.view_box) self.canvas = pg.ImageItem(axisOrder='row-major') self.view_box.setMouseMode(pg.ViewBox.RectMode) self.view_box.addItem(self.canvas) self.view_box.mouseDragEvent = self.select_zoom graphing_layout = QtWidgets.QVBoxLayout() graphing_layout.addWidget(self.ocr_label, alignment=QtCore.Qt.AlignCenter) graphing_layout.addWidget(self.graphics_view) # the container for all the image-processing widgets self.image_processing_group = QtWidgets.QGroupBox('Image Processing') # rotate self.rotate_label = QtWidgets.QLabel('<html>Rotate [0°]</html>') self.rotate_slider = QtWidgets.QSlider(orientation=QtCore.Qt.Horizontal) self.rotate_slider.setToolTip('The angle to rotate the image') self.rotate_slider.setMinimum(-180) self.rotate_slider.setMaximum(180) self.rotate_slider.setSingleStep(1) self.rotate_slider.setPageStep(15) self.rotate_slider.valueChanged.connect(self.update_rotate) if self.ocr_params['rotate']: self.rotate_slider.setValue(self.ocr_params['rotate']) # Gaussian blur self.blur_label = QtWidgets.QLabel('Gaussian Blur [0]') self.blur_slider = QtWidgets.QSlider(orientation=QtCore.Qt.Horizontal) self.blur_slider.setToolTip('The pixel radius to use for the Gaussian blur') self.blur_slider.setMinimum(0) self.blur_slider.setMaximum(kwargs.pop('max_blur', 9)) self.blur_slider.setSingleStep(1) self.blur_slider.valueChanged.connect(self.update_blur) if self.ocr_params['blur']: self.blur_slider.setValue(self.ocr_params['blur']) # threshold self.threshold_label = QtWidgets.QLabel('Threshold [0]') self.threshold_checkbox = QtWidgets.QCheckBox() self.threshold_checkbox.setToolTip('Apply thresholding?') self.threshold_checkbox.clicked.connect(self.update_threshold_checkbox) self.threshold_slider = QtWidgets.QSlider(orientation=QtCore.Qt.Horizontal) self.threshold_slider.setToolTip('The threshold value') self.threshold_slider.setMinimum(0) self.threshold_slider.setMaximum(255) self.threshold_slider.setSingleStep(1) self.threshold_slider.valueChanged.connect(self.update_threshold) if self.ocr_params['threshold']: self.threshold_slider.setValue(self.ocr_params['threshold']) self.threshold_checkbox.setChecked(True) else: self.threshold_slider.setEnabled(False) self.threshold_checkbox.setChecked(False) # dilate self.dilate_label = QtWidgets.QLabel('Dilate [0]') self.dilate_slider = QtWidgets.QSlider(orientation=QtCore.Qt.Horizontal) self.dilate_spinbox = QtWidgets.QSpinBox() self.dilate_spinbox.setToolTip('The number of iterations to apply dilation at the specified radius') self.dilate_spinbox.setMinimum(1) self.dilate_spinbox.setMaximum(99) self.dilate_spinbox.setSingleStep(1) self.dilate_spinbox.valueChanged.connect(self.update_dilate_iter) self.dilate_slider.setToolTip('The pixel radius to use for dilation') self.dilate_slider.setMinimum(0) self.dilate_slider.setMaximum(kwargs.pop('max_dilate', 9)) self.dilate_slider.setSingleStep(1) self.dilate_slider.valueChanged.connect(self.update_dilate) if self.ocr_params['dilate']: self.dilate_slider.setValue(self.ocr_params['dilate']) # erode self.erode_label = QtWidgets.QLabel('Erode [0]') self.erode_slider = QtWidgets.QSlider(orientation=QtCore.Qt.Horizontal) self.erode_spinbox = QtWidgets.QSpinBox() self.erode_spinbox.setToolTip('The number of iterations to apply erosion at the specified radius') self.erode_spinbox.setMinimum(1) self.erode_spinbox.setMaximum(99) self.erode_spinbox.setSingleStep(1) self.erode_spinbox.valueChanged.connect(self.update_erode_iter) self.erode_slider.setToolTip('The pixel radius to use for erosion') self.erode_slider.setMinimum(0) self.erode_slider.setMaximum(kwargs.pop('max_erode', 9)) self.erode_slider.setSingleStep(1) self.erode_slider.valueChanged.connect(self.update_erode) if self.ocr_params['erode']: self.erode_slider.setValue(self.ocr_params['erode']) # image-processing layout ip_layout = QtWidgets.QGridLayout() ip_layout.addWidget(self.rotate_label, 0, 0) ip_layout.addWidget(self.rotate_slider, 0, 1) ip_layout.addWidget(self.blur_label, 1, 0) ip_layout.addWidget(self.blur_slider, 1, 1) ip_layout.addWidget(self.threshold_label, 2, 0) ip_layout.addWidget(self.threshold_slider, 2, 1) ip_layout.addWidget(self.threshold_checkbox, 2, 2) ip_layout.addWidget(self.dilate_label, 3, 0) ip_layout.addWidget(self.dilate_slider, 3, 1) ip_layout.addWidget(self.dilate_spinbox, 3, 2) ip_layout.addWidget(self.erode_label, 4, 0) ip_layout.addWidget(self.erode_slider, 4, 1) ip_layout.addWidget(self.erode_spinbox, 4, 2) self.image_processing_group.setLayout(ip_layout) # the container for all the camera widgets self.camera_config_group = QtWidgets.QGroupBox('Camera Settings') # ISO self.iso_combobox = QtWidgets.QComboBox() self.iso_combobox.setToolTip('The ISO setting of the camera') self.iso_combobox.addItems(['auto', '100', '200', '320', '400', '500', '640', '800']) iso = str(kwargs.pop('iso', 'auto')) if iso == '0': iso = 'auto' self.iso_combobox.setCurrentText(iso) self.update_iso(self.iso_combobox.currentText()) self.iso_combobox.currentTextChanged.connect(self.update_iso) self.iso_combobox.setEnabled(not self.path) # resolution self.resolution_combobox = QtWidgets.QComboBox() self.resolution_combobox.setToolTip('The resolution of the camera') self.resolution_combobox.addItems(['VGA', 'SVGA', 'XGA', '720p', 'SXGA', 'UXGA', '1080p', 'MAX']) self.resolution_combobox.setCurrentText(str(kwargs.pop('resolution', 'VGA'))) self.update_resolution(self.resolution_combobox.currentText()) self.resolution_combobox.currentTextChanged.connect(self.update_resolution) self.resolution_combobox.setEnabled(not self.path) # exposure mode self.exposure_mode_combobox = QtWidgets.QComboBox() self.exposure_mode_combobox.setToolTip('The exposure mode of the camera') self.exposure_mode_combobox.addItems(['off', 'auto', 'night', 'nightpreview', 'backlight', 'spotlight', 'sports', 'snow', 'beach', 'verylong', 'fixedfps', 'antishake', 'fireworks']) self.exposure_mode_combobox.setCurrentText(str(kwargs.pop('exposure_mode', 'auto'))) self.update_exposure_mode(self.exposure_mode_combobox.currentText()) self.exposure_mode_combobox.currentTextChanged.connect(self.update_exposure_mode) self.exposure_mode_combobox.setEnabled(not self.path) camera_layout = QtWidgets.QGridLayout() camera_layout.addWidget(QtWidgets.QLabel('ISO'), 0, 0) camera_layout.addWidget(self.iso_combobox, 0, 1) camera_layout.addItem(QtWidgets.QSpacerItem(1, 1, QtWidgets.QSizePolicy.MinimumExpanding), 0, 2) camera_layout.addWidget(QtWidgets.QLabel('Resolution'), 1, 0) camera_layout.addWidget(self.resolution_combobox, 1, 1) camera_layout.addWidget(QtWidgets.QLabel('Exposure Mode'), 2, 0) camera_layout.addWidget(self.exposure_mode_combobox, 2, 1) self.camera_config_group.setLayout(camera_layout) if self.client is None: self.iso_combobox.setEnabled(False) self.resolution_combobox.setEnabled(False) self.exposure_mode_combobox.setEnabled(False) # the container for all the OCR algorithm widgets self.ocr_config_group = QtWidgets.QGroupBox('OCR Algorithm Settings') # tesseract languages self.tess_lang_combobox = QtWidgets.QComboBox() self.tess_lang_combobox.addItems(['eng', 'letsgodigital']) self.tess_lang_combobox.currentTextChanged.connect(self.update_tess_lang) self.tess_lang_combobox.setToolTip('The language to use for Tesseract') # tesseract or ssocr self.tess_radio = QtWidgets.QRadioButton('Tesseract') self.tess_radio.setToolTip('Use Tesseract') self.tess_radio.toggled.connect(self.update_algorithm) self.ssocr_radio = QtWidgets.QRadioButton('SSOCR') self.ssocr_radio.setToolTip('Use SSOCR') self.ssocr_radio.toggled.connect(self.update_algorithm) if self.ocr_params['algorithm'] == 'ssocr': self.ssocr_radio.setChecked(True) else: self.tess_radio.setChecked(True) algo_layout = QtWidgets.QGridLayout() algo_layout.addWidget(self.tess_radio, 0, 0) algo_layout.addWidget(self.tess_lang_combobox, 0, 1) algo_layout.addItem(QtWidgets.QSpacerItem(1, 1, QtWidgets.QSizePolicy.MinimumExpanding), 0, 2) algo_layout.addWidget(self.ssocr_radio, 1, 0) self.ocr_config_group.setLayout(algo_layout) options_layout = QtWidgets.QVBoxLayout() options_layout.addWidget(self.image_processing_group) options_layout.addWidget(self.camera_config_group) options_layout.addWidget(self.ocr_config_group) options_layout.addStretch(1) layout = QtWidgets.QHBoxLayout() layout.addLayout(graphing_layout) layout.addLayout(options_layout) self.setLayout(layout) if self.path: self.setAcceptDrops(True) self.capture_thread = None self.original_image = utils.to_cv2(self.path) height, width = self.original_image.shape[:2] try: # could pass in an already-opened image object (which isn't a path) basename = os.path.basename(self.path) except OSError: basename = 'UNKNOWN' self.setWindowTitle('OCR || {} [{} x {}]'.format(basename, width, height)) else: self.setAcceptDrops(False) self.original_image = None self.capture_index = 0 self.setWindowTitle('OCR || Capture 0') self.capture_thread = Capture() self.capture_thread.add_callback(self.capture) self.capture_thread.start(self.client) self.apply_ocr()
def __init__(self, parent): """Display a QDialog to edit the settings""" super(_Settings, self).__init__(flags=QtCore.Qt.WindowCloseButtonHint) self.conn = parent._connection info = self.conn.get_hardware_info() self.setWindowTitle( info.modelNumber.decode('utf-8') + ' || ' + info.notes.decode('utf-8')) # move info max_vel, max_acc = self.conn.get_motor_velocity_limits() vel, acc = self.conn.get_vel_params() vel = self.conn.get_real_value_from_device_unit(vel, UnitType.VELOCITY) acc = self.conn.get_real_value_from_device_unit( acc, UnitType.ACCELERATION) backlash = self.conn.get_real_value_from_device_unit( self.conn.get_backlash(), UnitType.DISTANCE) # move widgets self.acc_spinbox = QtWidgets.QDoubleSpinBox() self.acc_spinbox.setMinimum(0) self.acc_spinbox.setMaximum(max_acc) self.acc_spinbox.setValue(acc) self.acc_spinbox.setToolTip( '<html><b>Range:</b><br>0 - {} mm/s<sup>2</sup></html>'.format( max_acc)) self.vel_spinbox = QtWidgets.QDoubleSpinBox() self.vel_spinbox.setMinimum(0) self.vel_spinbox.setMaximum(max_vel) self.vel_spinbox.setValue(vel) self.vel_spinbox.setToolTip( '<html><b>Range:</b><br>0 - {} mm/s</html>'.format(max_vel)) self.backlash_spinbox = QtWidgets.QDoubleSpinBox() self.backlash_spinbox.setMinimum(0) self.backlash_spinbox.setMaximum(5) self.backlash_spinbox.setValue(backlash) self.backlash_spinbox.setToolTip( '<html><b>Range:</b><br>0 - 5 mm</html>') move_group = QtWidgets.QGroupBox('Move Parameters') move_grid = QtWidgets.QGridLayout() move_grid.addWidget(QtWidgets.QLabel('Backlash'), 0, 0, alignment=QtCore.Qt.AlignRight) move_grid.addWidget(self.backlash_spinbox, 0, 1) move_grid.addWidget(QtWidgets.QLabel('mm'), 0, 2, alignment=QtCore.Qt.AlignLeft) move_grid.addWidget(QtWidgets.QLabel('Maximum Velocity'), 1, 0, alignment=QtCore.Qt.AlignRight) move_grid.addWidget(self.vel_spinbox, 1, 1) move_grid.addWidget(QtWidgets.QLabel('mm/s'), 1, 2, alignment=QtCore.Qt.AlignLeft) move_grid.addWidget(QtWidgets.QLabel('Acceleration'), 2, 0, alignment=QtCore.Qt.AlignRight) move_grid.addWidget(self.acc_spinbox, 2, 1) move_grid.addWidget(QtWidgets.QLabel('mm/s<sup>2</sup>'), 2, 2, alignment=QtCore.Qt.AlignLeft) move_group.setLayout(move_grid) # jog info jog_size = self.conn.get_real_value_from_device_unit( self.conn.get_jog_step_size(), UnitType.DISTANCE) vel, acc = self.conn.get_jog_vel_params() jog_vel = self.conn.get_real_value_from_device_unit( vel, UnitType.VELOCITY) jog_acc = self.conn.get_real_value_from_device_unit( acc, UnitType.ACCELERATION) # jog widgets min_jog, max_jog = 0.002, parent._max_pos_mm / 2.0 self.jog_size_spinbox = QtWidgets.QDoubleSpinBox() self.jog_size_spinbox.setMinimum(min_jog) self.jog_size_spinbox.setMaximum(max_jog) self.jog_size_spinbox.setDecimals(3) self.jog_size_spinbox.setValue(jog_size) self.jog_size_spinbox.setToolTip( '<html><b>Range:</b><br>{} - {} mm</html>'.format( min_jog, max_jog)) self.jog_acc_spinbox = QtWidgets.QDoubleSpinBox() self.jog_acc_spinbox.setMinimum(0) self.jog_acc_spinbox.setMaximum(max_acc) self.jog_acc_spinbox.setValue(jog_acc) self.jog_acc_spinbox.setToolTip( '<html><b>Range:</b><br>0 - {} mm/s<sup>2</sup></html>'.format( max_acc)) self.jog_vel_spinbox = QtWidgets.QDoubleSpinBox() self.jog_vel_spinbox.setMinimum(0) self.jog_vel_spinbox.setMaximum(max_vel) self.jog_vel_spinbox.setValue(jog_vel) self.jog_vel_spinbox.setToolTip( '<html><b>Range:</b><br>0 - {} mm/s</html>'.format(max_vel)) jog_group = QtWidgets.QGroupBox('Jog Parameters') jog_grid = QtWidgets.QGridLayout() jog_grid.addWidget(QtWidgets.QLabel('Step Size'), 0, 0, alignment=QtCore.Qt.AlignRight) jog_grid.addWidget(self.jog_size_spinbox, 0, 1) jog_grid.addWidget(QtWidgets.QLabel('mm'), 0, 2, alignment=QtCore.Qt.AlignLeft) jog_grid.addWidget(QtWidgets.QLabel('Maximum Velocity'), 1, 0, alignment=QtCore.Qt.AlignRight) jog_grid.addWidget(self.jog_vel_spinbox, 1, 1) jog_grid.addWidget(QtWidgets.QLabel('mm/s'), 1, 2, alignment=QtCore.Qt.AlignLeft) jog_grid.addWidget(QtWidgets.QLabel('Acceleration'), 2, 0, alignment=QtCore.Qt.AlignRight) jog_grid.addWidget(self.jog_acc_spinbox, 2, 1) jog_grid.addWidget(QtWidgets.QLabel('mm/s<sup>2</sup>'), 2, 2, alignment=QtCore.Qt.AlignLeft) jog_group.setLayout(jog_grid) hbox = QtWidgets.QHBoxLayout() hbox.addWidget(move_group) hbox.addWidget(jog_group) update_button = QtWidgets.QPushButton('Update') update_button.setToolTip('Update the device settings') update_button.clicked.connect(self.update_settings) cancel_button = QtWidgets.QPushButton('Cancel') cancel_button.setToolTip('Update the device settings') cancel_button.clicked.connect(self.close) info_button = QtWidgets.QPushButton() info_button.setIcon(get_icon('imageres|109')) info_button.clicked.connect( lambda: show_hardware_info(parent._connection)) info_button.setToolTip('Display the hardware information') button_layout = QtWidgets.QGridLayout() button_layout.addWidget(cancel_button, 0, 0) button_layout.addItem( QtWidgets.QSpacerItem(1, 1, QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Expanding), 0, 1) button_layout.addWidget(update_button, 0, 2) button_layout.addWidget(info_button, 0, 3) vbox = QtWidgets.QVBoxLayout() vbox.addLayout(hbox) vbox.addLayout(button_layout) self.setLayout(vbox)
def __init__(self, connection, config=None, parent=None): """A :class:`~QtWidgets.QWidget` for controlling a Thorlabs translation stage. Parameters ---------- connection : :class:`~msl.equipment.connection.Connection` The connection to the translational stage motor controller (e.g., LTS150, LTS300, KST101, KDC101, ...). config : :class:`~msl.equipment.config.Config`, optional A configuration file. The following elements can be defined in a :class:`~msl.equipment.config.Config` file to initialize a :class:`TranslationStage`: .. code-block:: xml <!-- The following attributes can be defined for a "preset" and a "jog size" element. For a "preset" you must define a name attribute: units - can be either "mm" or "device". If omitted then the default unit value is "mm" name - the text that will displayed in the GUI as the name of the preset If multiple translation stages are being used then you can uniquely identify which stage will have its properties updated by including one of the additional attributes: serial - the serial number of the translation stage motor controller alias - the same alias that is used in the <equipment> XML tag If you do not include one of 'serial' or 'alias' then all stages will be updated to the XML element value. --> <thorlabs_translation_stage_preset name='Si-PD' serial="123456789">54.232</thorlabs_translation_stage_preset> <thorlabs_translation_stage_preset name='InGaAs-PD' units="mm" serial="123456789">75.2</thorlabs_translation_stage_preset> <thorlabs_translation_stage_preset name='Reference' units="device" serial="123456789">10503037</thorlabs_translation_stage_preset> <!-- Note: In the following you can also specify the calibration path to be a path relative to the configuration file --> <thorlabs_translation_stage_calibration_path serial="123456789">path/to/calibration/file.dat</thorlabs_translation_stage_calibration_path> <!-- Since the 'serial', 'alias' and 'unit' attributes are not defined then all stages will have the jog size set to 2.0 mm --> <thorlabs_translation_stage_jog_size>2.0</thorlabs_translation_stage_jog_size> parent : :class:`QtWidgets.QWidget`, optional The parent widget. """ super(TranslationStage, self).__init__(parent=parent) if signaler is None: raise ImportError( 'This widget requires that the MSL-Equipment package is installed' ) if config is not None and not issubclass(config.__class__, Config): raise TypeError( 'Must pass in a MSL Equipment configuration object. Received {}' .format(config.__class__)) self._connection = connection self._supports_calibration = hasattr(self._connection, 'set_calibration_file') self._uncalibrated_mm = np.array([]) self._calibrated_mm = np.array([]) self._calibration_label = '' # set the calibration file if config is not None and self._supports_calibration: elements = self._find_xml_elements( config, 'thorlabs_translation_stage_calibration_path') if elements: cal_path = elements[0].text rel_path = os.path.join(os.path.dirname(config.path), cal_path) if os.path.isfile(cal_path): self.set_calibration_file(cal_path) elif os.path.isfile(rel_path): self.set_calibration_file(rel_path) else: prompt.critical('Cannot find calibration file\n' + cal_path) # set the presets self._preset_combobox = QtWidgets.QComboBox() self._preset_combobox.setToolTip('Preset positions') self._preset_combobox.addItems(['', 'Home']) self.preset_positions = {} if config is not None: for element in self._find_xml_elements( config, 'thorlabs_translation_stage_preset'): self.add_preset(element.attrib['name'], float(element.text), element.attrib.get('units', 'mm') == 'mm') self._min_pos_mm, self._max_pos_mm = self._connection.get_motor_travel_limits( ) self._position_display = QtWidgets.QLineEdit() self._position_display.setReadOnly(True) self._position_display.setFont(QtGui.QFont('Helvetica', 24)) self._position_display.mouseDoubleClickEvent = self._ask_move_to fm = QtGui.QFontMetrics(self._position_display.font()) self._position_display.setFixedWidth( fm.width(' {}.xxx'.format(int(self._max_pos_mm)))) self._home_button = QtWidgets.QPushButton() self._home_button.setToolTip('Go to the Home position') self._home_button.clicked.connect(self.go_home) self._home_button.setIcon(get_icon('ieframe|0')) self._stop_button = QtWidgets.QPushButton('Stop') self._stop_button.setToolTip('Stop moving immediately') self._stop_button.clicked.connect(self._connection.stop_immediate) self._stop_button.setIcon(get_icon('wmploc|155')) if config is not None: elements = self._find_xml_elements( config, 'thorlabs_translation_stage_jog_size') if elements: element = elements[0] if element.attrib.get('units', 'mm') == 'mm': jog_mm = float(element.text) jog = self._connection.get_device_unit_from_real_value( jog_mm, UnitType.DISTANCE) s = element.text + ' mm' else: jog = int(float(element.text)) jog_mm = self._connection.get_real_value_from_device_unit( jog, UnitType.DISTANCE) s = element.text + ' device units' if jog_mm > self._max_pos_mm or jog_mm < self._min_pos_mm: prompt.critical('Invalid jog size of ' + s) else: self._connection.set_jog_step_size(jog) self._jog_forward_button = QtWidgets.QPushButton() self._jog_forward_button.clicked.connect( lambda: self.jog_forward(False)) self._jog_forward_button.setIcon(get_icon(QtWidgets.QStyle.SP_ArrowUp)) self._jog_backward_button = QtWidgets.QPushButton() self._jog_backward_button.clicked.connect( lambda: self.jog_backward(False)) self._jog_backward_button.setIcon( get_icon(QtWidgets.QStyle.SP_ArrowDown)) settings_button = QtWidgets.QPushButton() settings_button.clicked.connect(self._show_settings) settings_button.setIcon(get_icon('shell32|71')) settings_button.setToolTip('Edit the jog and move settings') grid = QtWidgets.QGridLayout() grid.addWidget(QtWidgets.QLabel('Presets:'), 0, 0, alignment=QtCore.Qt.AlignRight) grid.addWidget(self._preset_combobox, 0, 1) grid.addWidget(self._stop_button, 0, 2, 1, 2) grid.addWidget(self._position_display, 1, 0, 2, 2) grid.addWidget(self._home_button, 1, 2) grid.addWidget(self._jog_forward_button, 1, 3) grid.addWidget(settings_button, 2, 2) grid.addWidget(self._jog_backward_button, 2, 3) grid.setSpacing(0) grid.setRowStretch(3, 1) grid.setColumnStretch(4, 1) self.setLayout(grid) self._connection.start_polling(200) self._polling_duration = self._connection.polling_duration() * 1e-3 self._connection.register_message_callback(callback) signaler.signal.connect(self._update_display) self._requested_mm = None self._update_jog_tooltip() self._update_display() self._requested_mm = float(self._position_display.text()) self._preset_combobox.setCurrentText( self._get_preset_name(self._requested_mm)) self._preset_combobox.currentIndexChanged[str].connect( self._go_to_preset)