class QtDragHandler(DragHandler): #: Signal emitted by QtDragHandler when starting tracking SIG_START_TRACKING = Signal("PyQt_PyObject", "QEvent") #: Signal emitted by QtDragHandler when stopping tracking and not moving SIG_STOP_NOT_MOVING = Signal("PyQt_PyObject", "QEvent") #: Signal emitted by QtDragHandler when stopping tracking and moving SIG_STOP_MOVING = Signal("PyQt_PyObject", "QEvent") #: Signal emitted by QtDragHandler when moving SIG_MOVE = Signal("PyQt_PyObject", "QEvent") def start_tracking(self, filter, event): DragHandler.start_tracking(self, filter, event) self.SIG_START_TRACKING.emit(filter, event) def stop_notmoving(self, filter, event): self.SIG_STOP_NOT_MOVING.emit(filter, event) def stop_moving(self, filter, event): self.SIG_STOP_MOVING.emit(filter, event) def move(self, filter, event): self.SIG_MOVE.emit(filter, event)
class RectZoomToolsig(RectZoomTool): SIG_PLOT_AXIS_CHANGED = Signal() def validate(self, filter, event): self.SIG_VALIDATE_TOOL.emit(filter) self.SIG_PLOT_AXIS_CHANGED.emit() self.SIG_TOOL_JOB_FINISHED.emit()
class PanelWidget(DockableWidget): """Panel Widget base class""" PANEL_ID = None # string PANEL_TITLE = None # string PANEL_ICON = None # string #: Signal emitted by PanelWidget when its visibility has changed (arg: bool) SIG_VISIBILITY_CHANGED = Signal(bool) def __init__(self, parent=None): super(PanelWidget, self).__init__(parent) assert self.PANEL_ID is not None if self.PANEL_TITLE is not None: self.setWindowTitle(self.PANEL_TITLE) if self.PANEL_ICON is not None: from guidata.configtools import get_icon self.setWindowIcon(get_icon(self.PANEL_ICON)) def showEvent(self, event): DockableWidget.showEvent(self, event) if self.dockwidget is None: self.SIG_VISIBILITY_CHANGED.emit(True) def hideEvent(self, event): DockableWidget.hideEvent(self, event) if self.dockwidget is None: self.SIG_VISIBILITY_CHANGED.emit(False) def visibility_changed(self, enable): """DockWidget visibility has changed""" DockableWidget.visibility_changed(self, enable) # For compatibility with the guiqwt.panels.PanelWidget interface: self.SIG_VISIBILITY_CHANGED.emit(self._isvisible)
class RectangularSelectionHandler(DragHandler): #: Signal emitted by RectangularSelectionHandler when ending selection SIG_END_RECT = Signal("PyQt_PyObject", "QPoint", "QPoint") def __init__(self, filter, btn, mods=Qt.NoModifier, start_state=0): super(RectangularSelectionHandler, self).__init__(filter, btn, mods, start_state) self.avoid_null_shape = False def set_shape(self, shape, h0, h1, setup_shape_cb=None, avoid_null_shape=False): self.shape = shape self.shape_h0 = h0 self.shape_h1 = h1 self.setup_shape_cb = setup_shape_cb self.avoid_null_shape = avoid_null_shape def start_tracking(self, filter, event): self.start = self.last = QPoint(event.pos()) def start_moving(self, filter, event): self.shape.attach(filter.plot) self.shape.setZ(filter.plot.get_max_z() + 1) if self.avoid_null_shape: self.start -= QPoint(1, 1) self.shape.move_local_point_to(self.shape_h0, self.start) self.shape.move_local_point_to(self.shape_h1, event.pos()) self.start_moving_action(filter, event) if self.setup_shape_cb is not None: self.setup_shape_cb(self.shape) self.shape.show() filter.plot.replot() def start_moving_action(self, filter, event): """Les classes derivees peuvent surcharger cette methode""" pass def move(self, filter, event): self.shape.move_local_point_to(self.shape_h1, event.pos()) self.move_action(filter, event) filter.plot.replot() def move_action(self, filter, event): """Les classes derivees peuvent surcharger cette methode""" pass def stop_moving(self, filter, event): self.shape.detach() self.stop_moving_action(filter, event) filter.plot.replot() def stop_moving_action(self, filter, event): """Les classes derivees peuvent surcharger cette methode""" self.SIG_END_RECT.emit(filter, self.start, event.pos())
class QtDragHandler(DragHandler): SIG_START_TRACKING = Signal("PyQt_PyObject", "QEvent") SIG_STOP_NOT_MOVING = Signal("PyQt_PyObject", "QEvent") SIG_STOP_MOVING = Signal("PyQt_PyObject", "QEvent") SIG_MOVE = Signal("PyQt_PyObject", "QEvent") def start_tracking(self, filter, event): DragHandler.start_tracking(self, filter, event) self.SIG_START_TRACKING.emit(filter, event) def stop_notmoving(self, filter, event): self.SIG_STOP_NOT_MOVING.emit(filter, event) def stop_moving(self, filter, event): self.SIG_STOP_MOVING.emit(filter, event) def move(self, filter, event): self.SIG_MOVE.emit(filter, event)
class DataSetEditGroupBox(DataSetShowGroupBox): """ Group box widget including a DataSet label: group box label (string) klass: guidata.DataSet class button_text: action button text (default: "Apply") button_icon: QIcon object or string (default "apply.png") """ #: Signal emitted when Apply button is clicked SIG_APPLY_BUTTON_CLICKED = Signal() def __init__(self, label, klass, button_text=None, button_icon=None, show_button=True, wordwrap=False, **kwargs): DataSetShowGroupBox.__init__(self, label, klass, wordwrap=wordwrap, **kwargs) if show_button: if button_text is None: button_text = _("Apply") if button_icon is None: button_icon = get_icon("apply.png") elif is_text_string(button_icon): button_icon = get_icon(button_icon) apply_btn = QPushButton(button_icon, button_text, self) apply_btn.clicked.connect(self.set) layout = self.edit.layout layout.addWidget(apply_btn, layout.rowCount(), 0, 1, -1, Qt.AlignRight) def get_edit_layout(self): """Return edit layout""" return DataSetEditLayout(self, self.dataset, self.grid_layout) def set(self): """Update data item values from layout contents""" for widget in self.edit.widgets: if widget.is_active() and widget.check(): widget.set() self.SIG_APPLY_BUTTON_CLICKED.emit() def child_title(self, item): """Return data item title combined with QApplication title""" app_name = QApplication.applicationName() if not app_name: app_name = to_text_string(self.title()) return "%s - %s" % (app_name, item.label())
class GenericWorker(QObject): ''' http://stackoverflow.com/questions/20324804/how-to-use-qthread-correctly-in-pyqt-with-movetothread http://ilearnstuff.blogspot.de/2012/09/qthread-best-practices-when-qthread.html ''' start = Signal() finished = Signal() def __init__(self, function, *args, **kwargs): super(GenericWorker, self).__init__() self.function = function self.args = args self.kwargs = kwargs self.running = False self.start.connect(self.run) self.finished.connect(self.__changeRunning) @Slot() def run(self, *args, **kwargs): #print(args, kwargs) self.running = True self.function(*self.args, **self.kwargs) self.finished.emit() @Slot() def __changeRunning(self): ''' Change running status variable ''' self.running = False def isRunning(self): ''' Query status of worker ''' return self.running
class XAxeCalc(QComboBox): idxChanged = Signal(object) def __init__(self, parent): super(QComboBox, self).__init__(parent) self.functions = [] self.setEditable(True) self.lineEdit().setReadOnly(True) self.lineEdit().setAlignment(Qt.AlignCenter) self.currentIndexChanged.connect(self.changed) def addFun(self, name, fun, funInv): self.functions.append((fun, funInv)) self.addItem(name) def changed(self, idx): self.idxChanged.emit(self.functions[idx])
class ClickHandler(QObject): """Classe de base pour les gestionnaires d'événements du type click - release """ SIG_CLICK_EVENT = Signal("PyQt_PyObject", "QEvent") def __init__(self, filter, btn, mods=Qt.NoModifier, start_state=0): super(ClickHandler, self).__init__() self.state0 = filter.add_event(start_state, filter.mouse_press(btn, mods), filter.nothing) filter.add_event(self.state0, filter.mouse_release(btn, mods), self.click, start_state) def click(self, filter, event): self.SIG_CLICK_EVENT.emit(filter, event)
class MainWindow(QMainWindow): updateOsciPlot = Signal(object) updateTdPlot = Signal(object) updateFdPlot = Signal(object) def __init__(self): QMainWindow.__init__(self) self.stage = None self.stopOsci = False self.stopMeasure = False self.setWindowTitle(APP_NAME) ############### # Powermeter record curveplot_toolbar = self.addToolBar(_("Curve Plotting Toolbar")) self.curveWidget1 = DockablePlotWidget(self, CurveWidget, curveplot_toolbar) self.curveWidget1.calcFun.addFun('s', lambda x: x, lambda x: x) self.curveWidget1.calcFun.addFun('min', lambda x: x / 60, lambda x: x * 60) self.curveWidget1.calcFun.addFun('hour', lambda x: x / 3600, lambda x: x * 3600) plot1 = self.curveWidget1.get_plot() self.signal1 = SignalFT(self, plot=plot1) ############## # Main window widgets self.tabwidget = DockableTabWidget(self) #self.tabwidget.setMaximumWidth(500) self.maestroUi = MaestroUi(self) self.fileUi = FileUi(self) self.tabwidget.addTab(self.maestroUi, QIcon('icons/Handyscope_HS4.png'), _("Maestro")) self.tabwidget.addTab(self.fileUi, get_icon('filesave.png'), _('File')) self.add_dockwidget(self.tabwidget, _("Inst. sett.")) # self.setCentralWidget(self.tabwidget) self.dock1 = self.add_dockwidget(self.curveWidget1, title=_("Powermeter")) ################ # connect signals self.maestroUi.newPlotData.connect(self.signal1.updatePlot) self.curveWidget1.calcFun.idxChanged.connect(self.signal1.funChanged) self.fileUi.saveTxtBtn.released.connect(self.saveDataTxt) self.fileUi.saveHdfBtn.released.connect(self.saveDataHDF5) ''' self.piUi.startScanBtn.released.connect(self.startMeasureThr) self.piUi.stopScanBtn.released.connect(self.stopMeasureThr) self.piUi.xAxeChanged.connect(self.tdSignal.updateXAxe) self.piUi.xAxeChanged.connect(self.fdSignal.updateXAxe) self.piUi.niceBtn.released.connect(self.showMakeNicerWidget) self.tiepieUi.scpConnected.connect(self.startOsciThr) self.tiepieUi.xAxeChanged.connect(self.osciSignal.updateXAxe) self.tiepieUi.yAxeChanged.connect(self.osciSignal.updateYAxe) self.tiepieUi.triggLevelChanged.connect(self.osciSignal.setHCursor) #self.piUi.centerBtn.released.connect( # lambda x=None: self.piUi.setCenter(self.tdSignal.getVCursor())) self.tdSignal.plot.SIG_MARKER_CHANGED.connect( lambda x=None: self.piUi.newOffset(self.tdSignal.getVCursor())) self.tdWidget.calcFun.idxChanged.connect(self.tdSignal.funChanged) self.fdWidget.calcFun.idxChanged.connect(self.fdSignal.funChanged) self.updateOsciPlot.connect(self.osciSignal.updatePlot) self.updateTdPlot.connect(self.tdSignal.updatePlot) self.updateFdPlot.connect(lambda data: self.fdSignal.updatePlot(self.fdSignal.computeFFT(data))) ''' ################ # create threads #self.osciThr = GenericThread(self.getOsciData) ''' self.osciThr = QThread() self.osciThr.start() self.osciWorker = GenericWorker(self.getOsciData) self.osciWorker.moveToThread(self.osciThr) #self.measureThr = GenericThread(self.getMeasureData) self.measureThr = QThread() self.measureThr.start() self.measureWorker = GenericWorker(self.getMeasureData) self.measureWorker.moveToThread(self.measureThr) ''' ################ # File menu file_menu = self.menuBar().addMenu(_("File")) self.quit_action = create_action( self, _("Quit"), shortcut="Ctrl+Q", icon=get_std_icon("DialogCloseButton"), tip=_("Quit application"), triggered=self.close) saveData = create_action(self, _("Save"), shortcut="Ctrl+S", icon=get_std_icon("DialogSaveButton"), tip=_("Save data"), triggered=self.saveDataHDF5) #add_actions(file_menu, (triggerTest_action, saveData, None, self.quit_action)) ############## # Eventually add an internal console (requires 'spyderlib') self.sift_proxy = SiftProxy(self) if DockableConsole is None: self.console = None else: import time, scipy.signal as sps, scipy.ndimage as spi ns = { 'ftir': self.sift_proxy, 'np': np, 'sps': sps, 'spi': spi, 'os': os, 'sys': sys, 'osp': osp, 'time': time } msg = "Example: ftir.s[0] returns signal object #0\n"\ "Modules imported at startup: "\ "os, sys, os.path as osp, time, "\ "numpy as np, scipy.signal as sps, scipy.ndimage as spi" self.console = DockableConsole(self, namespace=ns, message=msg) self.add_dockwidget(self.console, _("Console")) ''' try: self.console.interpreter.widget_proxy.sig_new_prompt.connect( lambda txt: self.refresh_lists()) except AttributeError: print('sift: spyderlib is outdated', file=sys.stderr) ''' # Show main window and raise the signal plot panel self.show() #------GUI refresh/setup def add_dockwidget(self, child, title): """Add QDockWidget and toggleViewAction""" dockwidget, location = child.create_dockwidget(title) self.addDockWidget(location, dockwidget) return dockwidget def closeEvent(self, event): self.maestroUi.closeEvent(event) if self.console is not None: self.console.exit_interpreter() event.accept() def saveDataTxt(self): import datetime now = datetime.datetime.now().strftime('%Y%m%d-%H%M%S_Maestro') # save time domain foo = self.tdWidget.calcFun.functions texts = [self.tdWidget.calcFun.itemText(i) for i in range(len(foo))] tmp = ['td_x_{:s},td_y_{:s}'.format(i, i) for i in texts] header = ','.join(tmp) dataTd = np.zeros( (self.tdSignal.getData(foo[0][0])[0].shape[0], 2 * len(foo))) for i, fun in enumerate(foo): x, y = self.tdSignal.getData(fun[0]) # [0]: fun, [1]: inverse fun dataTd[:, 2 * i] = x dataTd[:, 2 * i + 1] = y np.savetxt('data/{:s}_TD.txt'.format(now), dataTd, header=header) self.tdSignal.plot.save_widget('data/{:s}_TD.png'.format(now)) # save frequency domain foo = self.fdWidget.calcFun.functions texts = [self.fdWidget.calcFun.itemText(i) for i in range(len(foo))] tmp = ['fd_x_{:s},fd_y_{:s}'.format(i, i) for i in texts] header += ','.join(tmp) dataFd = np.zeros( (self.fdSignal.getData(foo[0][0])[0].shape[0], 2 * len(foo))) for i, fun in enumerate(foo): x, y = self.fdSignal.getData(fun[0]) dataFd[:, 2 * i] = x dataFd[:, 2 * i + 1] = y np.savetxt('data/{:s}_FD.txt'.format(now), dataFd, header=header) self.fdSignal.plot.save_widget('data/{:s}_FD.png'.format(now)) # TODO: maybe put this in status bar msg = QMessageBox() msg.setIcon(QMessageBox.Information) msg.setText('Data saved') msg.exec_() def saveDataHDF5(self): import datetime import h5py fileName = self.fileUi.fileName print(fileName) if fileName is None: now = datetime.datetime.now().strftime('%Y%m%d-%H%M%S_Power') else: now = fileName + '_Power' with h5py.File('data/{:s}.h5'.format(now), 'w') as f: f.attrs['comments'] = self.fileUi.comment.toPlainText() f.attrs['detector'] = '' f.attrs['detector_settings'] = '' # save powermeter data dt = np.dtype([('iso_time', 'S26'), ('seconds', np.float), ('power', np.float)]) data = np.asarray(self.maestroUi.measureData, dtype=dt) dset = f.create_dataset('power', data=data) dset.attrs['device'] = 'Gentec Maestro' dset.attrs['device_serial'] = '1234' self.signal1.plot.save_widget('data/{:s}.png'.format(now)) # TODO: maybe put this in status bar '''
class TiePieUi(QSplitter): ''' Handling user interface to manage TiePie HS4/Diff Oscilloscope ''' scpConnected = Signal() xAxeChanged = Signal(object, object) yAxeChanged = Signal(object, object) triggLevelChanged = Signal(object) def __init__(self, parent): #super(ObjectFT, self).__init__(Qt.Vertical, parent) super().__init__(parent) self.scp = None # variable to hold oscilloscope object self.mutex = QMutex() layoutWidget = QWidget() layout = QGridLayout() layoutWidget.setLayout(layout) self.openDevBtn = QPushButton('Open Osci') # channel stuff self.measCh = QComboBox() self.chSens = QComboBox() self.triggCh = QComboBox() self.frequency = QLineEdit() self.frequency.setValidator(QIntValidator()) self.recordLen = QLineEdit() self.recordLen.setValidator(QIntValidator()) self.delay = QLineEdit() self.delay.setValidator(QDoubleValidator()) # trigger stuff self.triggLevel = QLineEdit() self.triggLevel.setToolTip( 'http://api.tiepie.com/libtiepie/0.5/triggering_scpch.html#triggering_scpch_level' ) self.triggLevel.setText( '0.5' ) # init value otherwise there's trouble with signal changing index of sensitivity self.triggLevel.setValidator(QDoubleValidator(0., 1., 3)) self.hystereses = QLineEdit() self.hystereses.setText('0.05') self.hystereses.setToolTip( 'http://api.tiepie.com/libtiepie/0.5/triggering_scpch.html#triggering_scpch_hysteresis' ) self.hystereses.setValidator(QDoubleValidator(0., 1., 3)) self.triggKind = QComboBox() # do averages self.averages = QSpinBox() self.averages.setValue(1) self.averages.setRange(1, 10000) # put layout together layout.addWidget(self.openDevBtn, 0, 0) layout.addWidget(QLabel('Measuring Ch'), 1, 0) layout.addWidget(self.measCh, 1, 1) layout.addWidget(QLabel('Ch sensitivity'), 2, 0) layout.addWidget(self.chSens, 2, 1) layout.addWidget(QLabel('Sample freq. (kHz)'), 3, 0) layout.addWidget(self.frequency, 3, 1) layout.addWidget(QLabel('Record length'), 4, 0) layout.addWidget(self.recordLen, 4, 1) layout.addWidget(QLabel('Delay'), 5, 0) layout.addWidget(self.delay, 5, 1) layout.addWidget(QLabel('Trigger Ch'), 6, 0) layout.addWidget(self.triggCh, 6, 1) layout.addWidget(QLabel('Trigger Level (%)'), 7, 0) layout.addWidget(self.triggLevel, 7, 1) layout.addWidget(QLabel('Hystereses'), 8, 0) layout.addWidget(self.hystereses, 8, 1) layout.addWidget(QLabel('Trigger kind'), 9, 0) layout.addWidget(self.triggKind, 9, 1) layout.addWidget(QLabel('Averages'), 10, 0) layout.addWidget(self.averages, 10, 1) layout.setRowStretch(11, 10) layout.setColumnStretch(2, 10) self.addWidget(layoutWidget) # connect UI to get things working self.openDevBtn.released.connect(self.openDev) self.chSens.currentIndexChanged.connect(self._changeSens) self.frequency.returnPressed.connect(self._changeFreq) self.recordLen.returnPressed.connect(self._changeRecordLength) self.triggCh.currentIndexChanged.connect(self._changeTrigCh) self.triggLevel.returnPressed.connect(self._triggLevelChanged) self.triggLevel.textChanged.connect(self._check_state) self.hystereses.returnPressed.connect(self._setHystereses) self.hystereses.textChanged.connect(self._check_state) def openDev(self): # search for devices libtiepie.device_list.update() # try to open an oscilloscope with block measurement support for item in libtiepie.device_list: if item.can_open(libtiepie.DEVICETYPE_OSCILLOSCOPE): self.scp = item.open_oscilloscope() if self.scp.measure_modes & libtiepie.MM_BLOCK: break else: self.scp = None # init UI #print(self.scp.name, 'found') if self.scp is not None: # Set measure mode: self.scp.measure_mode = libtiepie.MM_BLOCK # Set sample frequency: self.scp.sample_frequency = 1e6 # 1 MHz # Set record length: self.scp.record_length = 10000 # 10000 samples # Set pre sample ratio: self.scp.pre_sample_ratio = 0 # 0 % # Set trigger timeout: self.scp.trigger_time_out = 100e-3 # 100 ms # Enable channel 1 for measurement # http://api.tiepie.com/libtiepie/0.5/group__scp__ch__enabled.html self.scp.channels[ 0].enabled = True # by default all channels are enabled self.scp.range = 0.2 self.scp.coupling = libtiepie.CK_DCV # DC Volt # Disable all channel trigger sources for ch in self.scp.channels: ch.trigger.enabled = False # Setup channel trigger on 1 ch = self.scp.channels[0] ch.trigger.enabled = True ch.trigger.kind = libtiepie.TK_RISINGEDGE ch.trigger.levels[0] = 0.5 # 50% ch.trigger.hystereses[0] = 0.05 # 5% # update UI # channel self.measCh.addItems( ['Ch{:d}'.format(i) for i in range(self.scp.channels.count)]) self.chSens.addItems( ['{:.1f} V'.format(i) for i in self.scp.channels[0].ranges]) self.frequency.setValidator( QIntValidator(1, 1e-3 * self.scp.sample_frequency_max)) self.frequency.setText('{:d}'.format( int(self.scp.sample_frequency * 1e-3))) self.recordLen.setValidator( QIntValidator(1, self.scp.record_length_max)) self.recordLen.setText('{:d}'.format(self.scp.record_length)) # trigger self.triggCh.addItems( ['Ch{:d}'.format(i) for i in range(self.scp.channels.count)]) # TODO: doen't work in module anymore!! #self.triggLevel.setText(str(ch.trigger.levels[0])) #self.hystereses.setText(str(ch.trigger.hystereses[0])) self.triggKind.addItems([ '{:s}'.format(i) for i in libtiepie.trigger_kind_str( ch.trigger.kinds).split(', ') ]) self.openDevBtn.setEnabled(False) # tell the world that the scope is connected self.xAxeChanged.emit( 0, 1 / int(self.frequency.text()) * 1e-3 * int(self.recordLen.text())) self.yAxeChanged.emit(-1 * self.scp.range, self.scp.range) self.triggLevelChanged.emit(ch.trigger.levels[0] * 2 * self.scp.range - self.scp.range) self.scpConnected.emit() else: msg = QMessageBox() msg.setIcon(QMessageBox.Critical) msg.setText('No supported device found') msg.exec_() def getData(self): # function called thread for updating plot avg = int(self.averages.text()) with QMutexLocker(self.mutex): x = np.linspace( 0, 1 / self.scp.sample_frequency * self.scp.record_length, self.scp.record_length) y = np.zeros((avg, self.scp.record_length)) for i in range(avg): self.scp.start() while not self.scp.is_data_ready: time.sleep(0.01) y[i, :] = self.scp.get_data()[self.measCh.currentIndex()] return np.column_stack((x, y.mean(axis=0))) #@Slot def _changeSens(self, i): with QMutexLocker(self.mutex): yMax = self.scp.channels[0].ranges[i] self.scp.range = yMax self.yAxeChanged.emit(-1 * yMax, yMax) self.triggLevelChanged.emit( float(self.triggLevel.text()) * 2 * yMax - yMax) def _changeTrigCh(self, newTrig): print('new trigger channel', newTrig) scope = self.scp with QMutexLocker(self.mutex): # Disable all channel trigger sources for ch in scope.channels: ch.trigger.enabled = False # enable trigger on newly selected channel ch = scope.channels[newTrig] ch.trigger.enabled = True ch.trigger.kind = libtiepie.TK_RISINGEDGE ch.trigger.levels[0] = float(self.triggLevel.text()) ch.trigger.hystereses[0] = float(self.hystereses.text()) def _triggLevelChanged(self): with QMutexLocker(self.mutex): idx = self.triggCh.currentIndex() ch = self.scp.channels[idx] ch.trigger.levels[0] = float(self.triggLevel.text()) self.triggLevelChanged.emit( float(self.triggLevel.text()) * 2 * self.scp.range - self.scp.range) def _changeFreq(self): with QMutexLocker(self.mutex): self.scp.sample_frequency = int(self.frequency.text()) * 1e3 self.xAxeChanged.emit( 0, 1 / self.scp.sample_frequency * self.scp.record_length) def _changeRecordLength(self): with QMutexLocker(self.mutex): self.scp.record_length = int(self.recordLen.text()) self.xAxeChanged.emit( 0, 1 / self.scp.sample_frequency * self.scp.record_length) def _setHystereses(self): with QMutexLocker(self.mutex): self.scp.hystereses = float(self.hystereses.text()) def _check_state(self, *args, **kwargs): '''https://snorfalorpagus.net/blog/2014/08/09/validating-user-input-in-pyqt4-using-qvalidator/''' sender = self.sender() validator = sender.validator() state = validator.validate(sender.text(), 0)[0] if state == QValidator.Acceptable: color = '#FFFFFF' # green elif state == QValidator.Intermediate: color = '#fff79a' # yellow else: color = '#f6989d' # red sender.setStyleSheet('QLineEdit { background-color: %s }' % color)
class MakeNicerWidget(DockableTabWidget): LOCATION = Qt.LeftDockWidgetArea updateTdPlot = Signal(object) updateTdFitPlot = Signal(object) updateFdPlot = Signal(object) updateFdFitPlot = Signal(object) def __init__(self, parent): super(MakeNicerWidget, self).__init__(parent) self.data = np.array([]) # array which holds data # Time domain plot self.tdWidget = DockablePlotWidget(self, CurveWidget) self.tdWidget.calcFun.addFun('fs', lambda x: x, lambda x: x) self.tdWidget.calcFun.addFun('µm', lambda x: x*fsDelay*1e3, lambda x: x/fsDelay*1e-3) self.tdWidget.calcFun.addFun('mm', lambda x: x*fsDelay, lambda x: x/fsDelay) tdPlot = self.tdWidget.get_plot() self.tdSignal = SignalFT(self, plot=tdPlot) self.tdFit = SignalFT(self, plot=tdPlot, col='r') # Frequency domain plot self.fdWidget = DockablePlotWidget(self, CurveWidget) self.fdWidget.calcFun.addFun('PHz', lambda x: x, lambda x: x) self.fdWidget.calcFun.addFun('THz', lambda x: x*1e3, lambda x: x*1e-3) self.fdWidget.calcFun.addFun('µm', lambda x: c0/x*1e-9, lambda x: c0/x*1e-9) self.fdWidget.calcFun.addFun('eV', lambda x: x, lambda x: x) fdplot = self.fdWidget.get_plot() self.fdSignal = SignalFT(self, plot=fdplot) self.fdFit = SignalFT(self, plot=fdplot, col='r') self.smoothNum = QSpinBox() # gives number of smoothin points self.smoothNum.setMinimum(1) self.smoothNum.setSingleStep(2) # Put things together in layouts buttonLayout = QGridLayout() plotLayout = QVBoxLayout() layout = QHBoxLayout() plotLayout.addWidget(self.tdWidget) plotLayout.addWidget(self.fdWidget) buttonLayout.addWidget(QLabel('Fitting function'), 0, 0) buttonLayout.addWidget( QLineEdit("lambda x,A,f,phi: np.sin(2*np.pi*f*x+phi)"), 1, 0, 1, 2) buttonLayout.addWidget(QLabel('Smooth'), 2, 0) buttonLayout.addWidget(self.smoothNum, 2, 1) buttonLayout.setRowStretch(3, 20) layout.addLayout(buttonLayout) layout.addLayout(plotLayout) self.setLayout(layout) # connect signals self.updateTdPlot.connect(self.tdSignal.updatePlot) self.updateTdFitPlot.connect(self.tdFit.updatePlot) self.updateFdPlot.connect(lambda data: self.fdSignal.updatePlot(self.fdSignal.computeFFT(data))) self.updateFdFitPlot.connect(lambda data: self.fdFit.updatePlot(self.fdFit.computeFFT(data))) self.smoothNum.valueChanged.connect(self.smoothData) self.setData() def setData(self): data = np.loadtxt('testData.txt', delimiter=',') data[:,1] = (data[:,1]-data[:,1].min())/(data[:,1]-data[:,1].min()).max() self.data = data self.updateTdPlot.emit(data) self.updateFdPlot.emit(data) def smoothData(self, i): x = self.data[:,0] x = np.linspace(x[0], x[-1], x.shape[0]+i-1) # get x axis for smooth y = self.data[:,1] self.updateTdPlot.emit(np.column_stack((x, self.tdSignal.smooth(y, i)))) self.updateFdPlot.emit(self.fdSignal.computeFFT( np.column_stack((x, self.fdSignal.smooth(y, i))))) def runFitDialog(self): x = self.plot4Curve.get_data()[0] y = self.plot4Curve.get_data()[1] def fit(x, params): y0, a, x0, s, tau= params return y0+a*0.5*(erf((x-x0)/(s/(2*np.sqrt(2*np.log(2)))))+1)*np.exp(-(x-x0)/tau) y0 = FitParam("Offset", 0., -100., 100.) a = FitParam("Amplitude", y.max(), 0., 10000.) x0 = FitParam("x0", x[y.argmax()], -10., 10.) s = FitParam("FWHM", 0.5, 0., 10.) tau = FitParam("tau", 0.5, 0., 10.) params = [y0, a, x0, s, tau] values = guifit(x, y, fit, params, xlabel="Time (s)", ylabel="Power (a.u.)") self.fitParam = values
class MainWindow(QMainWindow): updateOsciPlot = Signal(object) updateTdPlot = Signal(object) updateFdPlot = Signal(object) def __init__(self): QMainWindow.__init__(self) self.stage = None self.stopOsci = False self.stopMeasure = False self.setWindowTitle(APP_NAME) ############### # Osci live curveplot_toolbar = self.addToolBar(_("Curve Plotting Toolbar")) self.osciCurveWidget = DockablePlotWidget(self, CurveWidget, curveplot_toolbar) self.osciCurveWidget.calcFun.addFun('s', lambda x: x, lambda x: x) self.osciCurveWidget.calcFun.addFun('ms', lambda x: x*1e3, lambda x: x*1e-3) self.osciCurveWidget.calcFun.addFun('µs', lambda x: x*1e6, lambda x: x*1e-6) osciPlot = self.osciCurveWidget.get_plot() #osciPlot.set_axis_title('bottom', 'Time (s)') #osciplot.add_item(make.legend("TR")) self.osciSignal = SignalFT(self, plot=osciPlot) self.osciSignal.addHCursor(0) self.osciSignal.addBounds() ############## # Time domain plot self.tdWidget = DockablePlotWidget(self, CurveWidget, curveplot_toolbar) self.tdWidget.calcFun.addFun('fs', lambda x: x, lambda x: x) self.tdWidget.calcFun.addFun('µm', lambda x: x*fsDelay*1e3, lambda x: x/fsDelay*1e-3) self.tdWidget.calcFun.addFun('mm', lambda x: x*fsDelay, lambda x: x/fsDelay) tdPlot = self.tdWidget.get_plot() #tdPlot.add_item(make.legend("TR")) self.tdSignal = SignalFT(self, plot=tdPlot) self.tdSignal.addVCursor(0) ################## # Frequency domain plot self.fdWidget = DockablePlotWidget(self, CurveWidget, curveplot_toolbar) self.fdWidget.calcFun.addFun('PHz', lambda x: x, lambda x: x) self.fdWidget.calcFun.addFun('THz', lambda x: x*1e3, lambda x: x*1e-3) # x = PHz -> 1e15, µm = 1e-6 self.fdWidget.calcFun.addFun('µm', lambda x: c0/x*1e-9, lambda x: c0/x*1e-9) self.fdWidget.calcFun.addFun('eV', lambda x: x, lambda x: x) fdplot = self.fdWidget.get_plot() #fqdplot.add_item(make.legend("TR")) self.fdSignal = SignalFT(self, plot=fdplot) ############## # Main window widgets self.tabwidget = DockableTabWidget(self) #self.tabwidget.setMaximumWidth(500) self.tiepieUi = TiePieUi(self) self.piUi = PiStageUi(self) #self.stage = self.piUi.stage self.tabwidget.addTab(self.tiepieUi, QIcon('icons/Handyscope_HS4.png'), _("Osci")) self.tabwidget.addTab(self.piUi, QIcon('icons/piController.png'), _("Stage")) self.add_dockwidget(self.tabwidget, _("Inst. sett.")) # self.setCentralWidget(self.tabwidget) self.osci_dock = self.add_dockwidget(self.osciCurveWidget, title=_("Osciloscope")) self.td_dock = self.add_dockwidget(self.tdWidget, title=_("Time Domain")) self.fd_dock = self.add_dockwidget(self.fdWidget, title=_("Frequency Domain")) ################ # connect signals self.piUi.startScanBtn.released.connect(self.startMeasureThr) self.piUi.stopScanBtn.released.connect(self.stopMeasureThr) self.piUi.xAxeChanged.connect(self.tdSignal.updateXAxe) self.piUi.xAxeChanged.connect(self.fdSignal.updateXAxe) self.piUi.niceBtn.released.connect(self.showMakeNicerWidget) self.tiepieUi.scpConnected.connect(self.startOsciThr) self.tiepieUi.xAxeChanged.connect(self.osciSignal.updateXAxe) self.tiepieUi.yAxeChanged.connect(self.osciSignal.updateYAxe) self.tiepieUi.triggLevelChanged.connect(self.osciSignal.setHCursor) #self.piUi.centerBtn.released.connect( # lambda x=None: self.piUi.setCenter(self.tdSignal.getVCursor())) self.tdSignal.plot.SIG_MARKER_CHANGED.connect( lambda x=None: self.piUi.newOffset(self.tdSignal.getVCursor())) self.osciCurveWidget.calcFun.idxChanged.connect(self.osciSignal.funChanged) self.tdWidget.calcFun.idxChanged.connect(self.tdSignal.funChanged) self.fdWidget.calcFun.idxChanged.connect(self.fdSignal.funChanged) self.updateOsciPlot.connect(self.osciSignal.updatePlot) self.updateTdPlot.connect(self.tdSignal.updatePlot) self.updateFdPlot.connect(lambda data: self.fdSignal.updatePlot(self.fdSignal.computeFFT(data))) ################ # create threads #self.osciThr = GenericThread(self.getOsciData) self.osciThr = QThread() self.osciThr.start() self.osciWorker = GenericWorker(self.getOsciData) self.osciWorker.moveToThread(self.osciThr) #self.measureThr = GenericThread(self.getMeasureData) self.measureThr = QThread() self.measureThr.start() self.measureWorker = GenericWorker(self.getMeasureData) self.measureWorker.moveToThread(self.measureThr) ################ # File menu file_menu = self.menuBar().addMenu(_("File")) self.quit_action = create_action(self, _("Quit"), shortcut="Ctrl+Q", icon=get_std_icon("DialogCloseButton"), tip=_("Quit application"), triggered=self.close) saveData = create_action(self, _("Save"), shortcut="Ctrl+S", icon=get_std_icon("DialogSaveButton"), tip=_("Save data"), triggered=self.saveData) triggerTest_action = create_action(self, _("Stop Osci"), shortcut="Ctrl+O", icon=get_icon('fileopen.png'), tip=_("Open an image"), triggered=self.stopOsciThr) add_actions(file_menu, (triggerTest_action, saveData, None, self.quit_action)) ############## # Eventually add an internal console (requires 'spyderlib') self.sift_proxy = SiftProxy(self) if DockableConsole is None: self.console = None else: import time, scipy.signal as sps, scipy.ndimage as spi ns = {'ftir': self.sift_proxy, 'np': np, 'sps': sps, 'spi': spi, 'os': os, 'sys': sys, 'osp': osp, 'time': time} msg = "Example: ftir.s[0] returns signal object #0\n"\ "Modules imported at startup: "\ "os, sys, os.path as osp, time, "\ "numpy as np, scipy.signal as sps, scipy.ndimage as spi" self.console = DockableConsole(self, namespace=ns, message=msg) self.add_dockwidget(self.console, _("Console")) ''' try: self.console.interpreter.widget_proxy.sig_new_prompt.connect( lambda txt: self.refresh_lists()) except AttributeError: print('sift: spyderlib is outdated', file=sys.stderr) ''' # Show main window and raise the signal plot panel self.show() #------GUI refresh/setup def add_dockwidget(self, child, title): """Add QDockWidget and toggleViewAction""" dockwidget, location = child.create_dockwidget(title) self.addDockWidget(location, dockwidget) return dockwidget def showMakeNicerWidget(self): self.makeNicerWidget = MakeNicerWidget(self) self.makeNicerDock = self.add_dockwidget(self.makeNicerWidget, 'Make FFT nicer') #self.makeNicerDock.setFloating(True) #self.fsBrowser = QDockWidget("4D Fermi Surface Browser", self) #self.fsWidget = FermiSurface_Widget(self) #self.fsBrowser.setWidget(self.fsWidget) #self.fsBrowser.setFloating(True) #self.addDockWidget(Qt.RightDockWidgetArea, self.fsBrowser) def closeEvent(self, event): if self.stage is not None: self.stage.CloseConnection() if self.console is not None: self.console.exit_interpreter() event.accept() def saveData(self): import datetime now = datetime.datetime.now().strftime('%Y%m%d-%H%M%S') # save time domain foo = self.tdWidget.calcFun.functions texts = [self.tdWidget.calcFun.itemText(i) for i in range(len(foo))] tmp = ['td_x_{:s},td_y_{:s}'.format(i, i) for i in texts] header = ','.join(tmp) dataTd = np.zeros((self.tdSignal.getData(foo[0][0])[0].shape[0], 2*len(foo))) for i, fun in enumerate(foo): x, y = self.tdSignal.getData(fun[0])# [0]: fun, [1]: inverse fun dataTd[:,2*i] = x dataTd[:,2*i+1] = y np.savetxt('data/{:s}_TD.txt'.format(now), dataTd, header=header) self.tdSignal.plot.save_widget('data/{:s}_TD.png'.format(now)) # save frequency domain foo = self.fdWidget.calcFun.functions texts = [self.fdWidget.calcFun.itemText(i) for i in range(len(foo))] tmp = ['fd_x_{:s},fd_y_{:s}'.format(i, i) for i in texts] header += ','.join(tmp) dataFd = np.zeros((self.fdSignal.getData(foo[0][0])[0].shape[0], 2*len(foo))) for fun in foo: x, y = self.fdSignal.getData(fun[0]) dataFd[:,2*i] = x dataFd[:,2*i+1] = y np.savetxt('data/{:s}_FD.txt'.format(now), dataFd, header=header) self.fdSignal.plot.save_widget('data/{:s}_FD.png'.format(now)) # TODO: maybe put this in status bar msg = QMessageBox() msg.setIcon(QMessageBox.Information) msg.setText('Data saved') msg.exec_() #def getStage(self, gcs): # self.stage = gcs # print(dir(self.stage)) # print(self.stage.qPOS()) def startOsciThr(self): self.stopOsci = False #self.osciThr.start() self.osciWorker.start.emit() def stopOsciThr(self): self.stopOsci = True # TODO: not quite shure how to do this with the worker solution. # finished signal is emitted but this function should wait for worker to finish?!? while(self.osciWorker.isRunning()): time.sleep(0.03) def getOsciData(self): while not self.stopOsci: data = self.tiepieUi.getData() self.updateOsciPlot.emit(data) time.sleep(0.5) def startMeasureThr(self): # stop osci thread and start measure thread self.stopOsciThr() # rescale tdPlot (updateXAxe) self.piUi._xAxeChanged() # set vCursor to 0 self.tdSignal.setVCursor(0) self.piUi.setCenter() # init x axe frequency domain plot to a min and max delays = self.piUi.getDelays_fs() data = np.column_stack((delays, np.zeros(len(delays)))) fdAxe = self.fdSignal.computeFFT(data) self.fdSignal.updateXAxe(fdAxe[0,0], fdAxe[-1,0]) self.stopMeasure = False #self.measureThr.start() self.measureWorker.start.emit() def stopMeasureThr(self): self.stopMeasure = True while(self.measureWorker.isRunning()): time.sleep(0.03) self.startOsciThr() def getMeasureData(self): delays = self.piUi.getDelays_fs() data = np.column_stack((delays, np.zeros(len(delays)))) for i, delay in enumerate(delays): if not self.stopMeasure: self.piUi.gotoPos_fs(delay) tmp = self.tiepieUi.getData() self.updateOsciPlot.emit(tmp) #print('measuring at', delay) #y = dummyPulse(delay) #data[i,1] = y #data[i,1] = tmp[:,1].mean() data[i,1] = self.osciSignal.computeSum() #time.sleep(0.05) self.updateTdPlot.emit(data) self.updateFdPlot.emit(data) else: break self.startOsciThr() """
class GreatEyesUi(QSplitter): ''' Handling user interface to manage greateys cameras ''' newPlotData = Signal(object, object) message = Signal(object) def __init__(self, parent): super().__init__(parent) self.camera = None self.cameraSettings = None self.aquireData = False self.directory = 'N:/4all/mpsd_drive/xtsfasta/Data' layoutWidget = QWidget() layout = QGridLayout() layoutWidget.setLayout(layout) ############### # GUI elements self.openCamBtn = QPushButton('Connect camera') self.startAquBtn = QPushButton('Start aquisiton') self.readoutSpeedCombo = QComboBox() # this really should not be hard coded but received from dll self.readoutSpeedCombo.addItems(["1 MHz", "1.8 MHz", "2.3 MHz", "2.8 MHz", "250 kHz", "500 kHz"]) self.exposureTimeSpin = QSpinBox() self.exposureTimeSpin.setRange(1, 1e6) self.exposureTimeSpin.setValue(1e3) # default exposure 1s self.exposureTimeSpin.setSingleStep(100) self.exposureTimeSpin.setSuffix(' ms') #self.exposureTimeSpin.setValidator(QIntValidator(1, 2**31)) # ms self.binningXCombo = QComboBox() self.binningXCombo.addItems(["No binning", "Binning of 2 columns", "Binning of 4 columns", "Binning of 8 columns", "Binning of 16 columns", "Binning of 32 columns", "Binning of 64 columns", "Binning of 128 columns", "Full horizontal binning"]) self.binningYCombo = QComboBox() self.binningYCombo.addItems(["No binning", "Binning of 2 lines", "Binning of 4 lines", "Binning of 8 lines", "Binning of 16 lines", "Binning of 32 lines", "Binning of 64 lines", "Binning of 128 lines", "Binning of 256 lines"]) self.temperatureSpin = QSpinBox() self.temperatureSpin.setRange(-100, 20) self.temperatureSpin.setValue(-10) self.temperatureSpin.setSuffix('°C') self.updateInterSpin = QSpinBox() self.updateInterSpin.setRange(1, 3600) self.updateInterSpin.setValue(5) self.updateInterSpin.setSuffix(' s') #self.updateInterSpin.setText("2") #self.updateInterEdit.setValidator(QIntValidator(1, 3600)) self.loi = QSpinBox() self.loi.setRange(1, 511) # one pixel less as the camera has self.deltaPixels = QSpinBox() self.deltaPixels.setRange(0, 256) self.autoSave = QCheckBox("Auto save") self.getDirectory = QPushButton('Choose Dir') self.dirPath = QLineEdit(self.directory) self.comment = QPlainTextEdit() ############## # put elements in layout layout.addWidget(self.openCamBtn, 0, 0) layout.addWidget(self.startAquBtn, 0, 1) layout.addWidget(QLabel('readout speed'), 1, 0) layout.addWidget(self.readoutSpeedCombo, 1, 1) layout.addWidget(QLabel('exposure time'), 2, 0) layout.addWidget(self.exposureTimeSpin, 2, 1) layout.addWidget(QLabel('binning X'), 3, 0) layout.addWidget(self.binningXCombo, 3, 1) layout.addWidget(QLabel('binning Y'), 4, 0) layout.addWidget(self.binningYCombo, 4, 1) layout.addWidget(QLabel('temperature'), 5, 0) layout.addWidget(self.temperatureSpin, 5, 1) layout.addWidget(QLabel('update every n-seconds'), 6, 0) layout.addWidget(self.updateInterSpin, 6, 1) layout.addWidget(QLabel('Pixel of interest'), 7, 0) layout.addWidget(self.loi, 7, 1) layout.addWidget(QLabel('Δ pixels'), 8, 0) layout.addWidget(self.deltaPixels, 8, 1) layout.addWidget(self.autoSave, 9, 1) layout.addWidget(self.getDirectory, 10, 0) layout.addWidget(self.dirPath, 10, 1) layout.addWidget(QLabel('Comment:'), 11, 0) layout.addWidget(self.comment, 12, 0, 1, 2) layout.setRowStretch(13, 10) self.addWidget(layoutWidget) ################# # connect elements for functionality self.openCamBtn.released.connect(self.__openCam) self.getDirectory.released.connect(self.__chooseDir) self.temperatureSpin.valueChanged.connect(self.__setTemperature) self.exposureTimeSpin.valueChanged.connect(self.__setCamParameter) self.readoutSpeedCombo.currentIndexChanged.connect(self.__setCamParameter) self.startAquBtn.released.connect(self.__startCurrImageThr) ################ # thread for updating position self.currImage_thread = QThread() # create the QThread self.currImage_thread.start() # This causes my_worker.run() to eventually execute in my_thread: self.currImage_worker = GenericWorker(self.__getCurrImage) self.currImage_worker.moveToThread(self.currImage_thread) self.startAquBtn.setEnabled(False) self.readoutSpeedCombo.setEnabled(False) self.exposureTimeSpin.setEnabled(False) self.binningXCombo.setEnabled(False) self.binningYCombo.setEnabled(False) self.temperatureSpin.setEnabled(False) self.updateInterSpin.setEnabled(False) def __openCam(self): self.camera = greatEyes() if not self.camera.connected: msg = QMessageBox() msg.setIcon(QMessageBox.Critical) msg.setText('Sorry, could not connect to camera :(\n' + self.camera.status) msg.exec_() return self.openCamBtn.setText('Connected') self.message.emit('Camera connected') self.openCamBtn.setStyleSheet('QPushButton {color: green;}') self.readoutSpeedCombo.setEnabled(True) self.exposureTimeSpin.setEnabled(True) self.binningXCombo.setEnabled(False) self.binningYCombo.setEnabled(False) self.temperatureSpin.setEnabled(True) self.updateInterSpin.setEnabled(True) self.openCamBtn.setEnabled(False) self.startAquBtn.setEnabled(True) def __chooseDir(self): self.directory = QFileDialog.getExistingDirectory(self, "Choose directory", self.directory) self.dirPath.setText(self.directory) def __startCurrImageThr(self): if not self.aquireData: self.aquireData = True self.currImage_worker.start.emit() self.startAquBtn.setText('Stop aquisition') self.message.emit('Starting aqusition') else: self.__stopCurrImageThr() self.startAquBtn.setText('Start aquisition') self.message.emit('Stopping aqusition') def __stopCurrImageThr(self): self.aquireData = False #while(self.currPosThr.isRunning()): # time.sleep(0.03) def __getCurrImage(self): #from scipy import mgrid #import numpy as np #X, Y = mgrid[-256:256, -1024:1025] i = self.updateInterSpin.value() while self.aquireData: # seconds over which to record a new image imageIntervall = self.updateInterSpin.value() # sleep for n seconds to check if intervall was changed sleepy = 1 if i >= imageIntervall: # dummy image #z = np.exp(-0.5*(X**2+Y**2)/np.random.uniform(30000, 40000))*np.cos(0.1*X+0.1*Y) z = self.camera.getImage() timeStamp = datetime.datetime.now() self.cameraSettings = { 'temperature': self.camera.getTemperature(), 'exposure_time': self.exposureTimeSpin.value(), 'readout_speed': self.readoutSpeedCombo.currentText() 'time_stamp': timeStamp} self.newPlotData.emit(z, timeStamp) i = 0 # restart counter i += sleepy time.sleep(sleepy) def __setTemperature(self, temp): self.camera.setTemperture(temp) self.message.emit('Temperature set to {:d}°C'.format(temp)) def __setCamParameter(self, param): self.camera.setCameraParameter( self.readoutSpeedCombo.currentIndex(), self.exposureTimeSpin.value(), 0, 0) self.message.emit('Readout: {:s}, Exposure: {:d}, binningX: 0, binningY: 0'.format(self.readoutSpeedCombo.currentText(), self.exposureTimeSpin.value()))
class BasePlot(QwtPlot): """ An enhanced QwtPlot class that provides methods for handling plotitems and axes better It distinguishes activatable items from basic QwtPlotItems. Activatable items must support IBasePlotItem interface and should be added to the plot using add_item methods. """ Y_LEFT, Y_RIGHT, X_BOTTOM, X_TOP = (QwtPlot.yLeft, QwtPlot.yRight, QwtPlot.xBottom, QwtPlot.xTop) # # To be replaced by (in the near future): # Y_LEFT, Y_RIGHT, X_BOTTOM, X_TOP = range(4) AXIS_IDS = (Y_LEFT, Y_RIGHT, X_BOTTOM, X_TOP) AXIS_NAMES = { 'left': Y_LEFT, 'right': Y_RIGHT, 'bottom': X_BOTTOM, 'top': X_TOP } AXIS_TYPES = {"lin": QwtLinearScaleEngine, "log": QwtLogScaleEngine} AXIS_CONF_OPTIONS = ("axis", "axis", "axis", "axis") DEFAULT_ACTIVE_XAXIS = X_BOTTOM DEFAULT_ACTIVE_YAXIS = Y_LEFT #: Signal emitted by plot when an IBasePlotItem object was moved (args: x0, y0, x1, y1) SIG_ITEM_MOVED = Signal("PyQt_PyObject", float, float, float, float) #: Signal emitted by plot when a shapes.Marker position changes SIG_MARKER_CHANGED = Signal("PyQt_PyObject") #: Signal emitted by plot when a shapes.Axes position (or the angle) changes SIG_AXES_CHANGED = Signal("PyQt_PyObject") #: Signal emitted by plot when an annotation.AnnotatedShape position changes SIG_ANNOTATION_CHANGED = Signal("PyQt_PyObject") #: Signal emitted by plot when the a shapes.XRangeSelection range changes SIG_RANGE_CHANGED = Signal("PyQt_PyObject", float, float) #: Signal emitted by plot when item list has changed (item removed, added, ...) SIG_ITEMS_CHANGED = Signal('PyQt_PyObject') #: Signal emitted by plot when selected item has changed SIG_ACTIVE_ITEM_CHANGED = Signal('PyQt_PyObject') #: Signal emitted by plot when an item was deleted from the item list or using the #: delete item tool SIG_ITEM_REMOVED = Signal('PyQt_PyObject') #: Signal emitted by plot when an item is selected SIG_ITEM_SELECTION_CHANGED = Signal('PyQt_PyObject') #: Signal emitted by plot when plot's title or any axis label has changed SIG_PLOT_LABELS_CHANGED = Signal('PyQt_PyObject') #: Signal emitted by plot when any plot axis direction has changed SIG_AXIS_DIRECTION_CHANGED = Signal('PyQt_PyObject', 'PyQt_PyObject') #: Signal emitted by plot when LUT has been changed by the user SIG_LUT_CHANGED = Signal("PyQt_PyObject") #: Signal emitted by plot when image mask has changed SIG_MASK_CHANGED = Signal("PyQt_PyObject") #: Signal emitted by cross section plot when cross section curve data has changed SIG_CS_CURVE_CHANGED = Signal("PyQt_PyObject") def __init__(self, parent=None, section="plot"): super(BasePlot, self).__init__(parent) self._start_autoscaled = True self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) self.manager = None self.plot_id = None # id assigned by it's manager self.filter = StatefulEventFilter(self) self.items = [] self.active_item = None self.last_selected = { } # a mapping from item type to last selected item self.axes_styles = [ AxeStyleParam(_("Left")), AxeStyleParam(_("Right")), AxeStyleParam(_("Bottom")), AxeStyleParam(_("Top")) ] self._active_xaxis = self.DEFAULT_ACTIVE_XAXIS self._active_yaxis = self.DEFAULT_ACTIVE_YAXIS self.read_axes_styles(section, self.AXIS_CONF_OPTIONS) self.font_title = get_font(CONF, section, "title") canvas = self.canvas() canvas.setFocusPolicy(Qt.StrongFocus) canvas.setFocusIndicator(QwtPlotCanvas.ItemFocusIndicator) self.SIG_ITEM_MOVED.connect(self._move_selected_items_together) self.legendDataChanged.connect( lambda item, _legdata: item.update_item_parameters()) #---- QWidget API --------------------------------------------------------- def mouseDoubleClickEvent(self, event): """Reimplement QWidget method""" for axis_id in self.AXIS_IDS: widget = self.axisWidget(axis_id) if widget.geometry().contains(event.pos()): self.edit_axis_parameters(axis_id) break else: QwtPlot.mouseDoubleClickEvent(self, event) #---- QwtPlot API --------------------------------------------------------- def showEvent(self, event): """Reimplement Qwt method""" QwtPlot.showEvent(self, event) if self._start_autoscaled: self.do_autoscale() #---- Public API ---------------------------------------------------------- def _move_selected_items_together(self, item, x0, y0, x1, y1): """Selected items move together""" for selitem in self.get_selected_items(): if selitem is not item and selitem.can_move(): selitem.move_with_selection(x1 - x0, y1 - y0) def set_manager(self, manager, plot_id): """Set the associated :py:class:`guiqwt.plot.PlotManager` instance""" self.manager = manager self.plot_id = plot_id def sizeHint(self): """Preferred size""" return QSize(400, 300) def get_title(self): """Get plot title""" return to_text_string(self.title().text()) def set_title(self, title): """Set plot title""" text = QwtText(title) text.setFont(self.font_title) self.setTitle(text) self.SIG_PLOT_LABELS_CHANGED.emit(self) def get_axis_id(self, axis_name): """Return axis ID from axis name If axis ID is passed directly, check the ID""" assert axis_name in self.AXIS_NAMES or axis_name in self.AXIS_IDS return self.AXIS_NAMES.get(axis_name, axis_name) def read_axes_styles(self, section, options): """ Read axes styles from section and options (one option for each axis in the order left, right, bottom, top) Skip axis if option is None """ for prm, option in zip(self.axes_styles, options): if option is None: continue prm.read_config(CONF, section, option) self.update_all_axes_styles() def get_axis_title(self, axis_id): """Get axis title""" axis_id = self.get_axis_id(axis_id) return self.axes_styles[axis_id].title def set_axis_title(self, axis_id, text): """Set axis title""" axis_id = self.get_axis_id(axis_id) self.axes_styles[axis_id].title = text self.update_axis_style(axis_id) def get_axis_unit(self, axis_id): """Get axis unit""" axis_id = self.get_axis_id(axis_id) return self.axes_styles[axis_id].unit def set_axis_unit(self, axis_id, text): """Set axis unit""" axis_id = self.get_axis_id(axis_id) self.axes_styles[axis_id].unit = text self.update_axis_style(axis_id) def get_axis_font(self, axis_id): """Get axis font""" axis_id = self.get_axis_id(axis_id) return self.axes_styles[axis_id].title_font.build_font() def set_axis_font(self, axis_id, font): """Set axis font""" axis_id = self.get_axis_id(axis_id) self.axes_styles[axis_id].title_font.update_param(font) self.axes_styles[axis_id].ticks_font.update_param(font) self.update_axis_style(axis_id) def get_axis_color(self, axis_id): """Get axis color (color name, i.e. string)""" axis_id = self.get_axis_id(axis_id) return self.axes_styles[axis_id].color def set_axis_color(self, axis_id, color): """ Set axis color color: color name (string) or QColor instance """ axis_id = self.get_axis_id(axis_id) if is_text_string(color): color = QColor(color) self.axes_styles[axis_id].color = str(color.name()) self.update_axis_style(axis_id) def update_axis_style(self, axis_id): """Update axis style""" axis_id = self.get_axis_id(axis_id) style = self.axes_styles[axis_id] title_font = style.title_font.build_font() ticks_font = style.ticks_font.build_font() self.setAxisFont(axis_id, ticks_font) if style.title and style.unit: title = "%s (%s)" % (style.title, style.unit) elif style.title: title = style.title else: title = style.unit axis_text = self.axisTitle(axis_id) axis_text.setFont(title_font) axis_text.setText(title) axis_text.setColor(QColor(style.color)) self.setAxisTitle(axis_id, axis_text) self.SIG_PLOT_LABELS_CHANGED.emit(self) def update_all_axes_styles(self): """Update all axes styles""" for axis_id in self.AXIS_IDS: self.update_axis_style(axis_id) def get_axis_limits(self, axis_id): """Return axis limits (minimum and maximum values)""" axis_id = self.get_axis_id(axis_id) sdiv = self.axisScaleDiv(axis_id) return sdiv.lowerBound(), sdiv.upperBound() def set_axis_limits(self, axis_id, vmin, vmax, stepsize=0): """Set axis limits (minimum and maximum values) and optional step size""" axis_id = self.get_axis_id(axis_id) self.setAxisScale(axis_id, vmin, vmax, stepsize) self._start_autoscaled = False def set_axis_ticks(self, axis_id, nmajor=None, nminor=None): """Set axis maximum number of major ticks and maximum of minor ticks""" axis_id = self.get_axis_id(axis_id) if nmajor is not None: self.setAxisMaxMajor(axis_id, nmajor) if nminor is not None: self.setAxisMaxMinor(axis_id, nminor) def get_axis_scale(self, axis_id): """Return the name ('lin' or 'log') of the scale used by axis""" axis_id = self.get_axis_id(axis_id) engine = self.axisScaleEngine(axis_id) for axis_label, axis_type in list(self.AXIS_TYPES.items()): if isinstance(engine, axis_type): return axis_label return "lin" # unknown default to linear def set_axis_scale(self, axis_id, scale, autoscale=True): """Set axis scale Example: self.set_axis_scale(curve.yAxis(), 'lin')""" axis_id = self.get_axis_id(axis_id) self.setAxisScaleEngine(axis_id, self.AXIS_TYPES[scale]()) if autoscale: self.do_autoscale(replot=False) def get_scales(self): """Return active curve scales""" ax, ay = self.get_active_axes() return self.get_axis_scale(ax), self.get_axis_scale(ay) def set_scales(self, xscale, yscale): """Set active curve scales Example: self.set_scales('lin', 'lin')""" ax, ay = self.get_active_axes() self.set_axis_scale(ax, xscale) self.set_axis_scale(ay, yscale) self.replot() def enable_used_axes(self): """ Enable only used axes For now, this is needed only by the pyplot interface """ for axis in self.AXIS_IDS: self.enableAxis(axis, True) self.disable_unused_axes() def disable_unused_axes(self): """Disable unused axes""" used_axes = set() for item in self.get_items(): used_axes.add(item.xAxis()) used_axes.add(item.yAxis()) unused_axes = set(self.AXIS_IDS) - set(used_axes) for axis in unused_axes: self.enableAxis(axis, False) def get_items(self, z_sorted=False, item_type=None): """Return widget's item list (items are based on IBasePlotItem's interface)""" if z_sorted: items = sorted(self.items, reverse=True, key=lambda x: x.z()) else: items = self.items if item_type is None: return items else: assert issubclass(item_type, IItemType) return [item for item in items if item_type in item.types()] def get_public_items(self, z_sorted=False, item_type=None): """Return widget's public item list (items are based on IBasePlotItem's interface)""" return [ item for item in self.get_items(z_sorted=z_sorted, item_type=item_type) if not item.is_private() ] def get_private_items(self, z_sorted=False, item_type=None): """Return widget's private item list (items are based on IBasePlotItem's interface)""" return [ item for item in self.get_items(z_sorted=z_sorted, item_type=item_type) if item.is_private() ] def copy_to_clipboard(self): """Copy widget's window to clipboard""" clipboard = QApplication.clipboard() if PYQT5: pixmap = self.grab() else: pixmap = QPixmap.grabWidget(self) clipboard.setPixmap(pixmap) def save_widget(self, fname): """Grab widget's window and save it to filename (\*.png, \*.pdf)""" fname = to_text_string(fname) if fname.lower().endswith('.pdf'): printer = QPrinter() printer.setOutputFormat(QPrinter.PdfFormat) printer.setOrientation(QPrinter.Landscape) printer.setOutputFileName(fname) printer.setCreator('guidata') self.print_(printer) elif fname.lower().endswith('.png'): if PYQT5: pixmap = self.grab() else: pixmap = QPixmap.grabWidget(self) pixmap.save(fname, 'PNG') else: raise RuntimeError(_("Unknown file extension")) def get_selected_items(self, z_sorted=False, item_type=None): """Return selected items""" return [ item for item in self.get_items(item_type=item_type, z_sorted=z_sorted) if item.selected ] def get_max_z(self): """ Return maximum z-order for all items registered in plot If there is no item, return 0 """ if self.items: return max([_it.z() for _it in self.items]) else: return 0 def add_item(self, item, z=None): """ Add a *plot item* instance to this *plot widget* item: :py:data:`qwt.QwtPlotItem` object implementing the IBasePlotItem interface (guiqwt.interfaces) """ assert hasattr(item, "__implements__") assert IBasePlotItem in item.__implements__ item.attach(self) if z is not None: item.setZ(z) else: item.setZ(self.get_max_z() + 1) if item in self.items: print("Warning: item %r is already attached to plot" % item, file=sys.stderr) else: self.items.append(item) self.SIG_ITEMS_CHANGED.emit(self) def add_item_with_z_offset(self, item, zoffset): """ Add a plot *item* instance within a specified z range, over *zmin* """ zlist = sorted([_it.z() for _it in self.items if _it.z() >= zoffset] + [zoffset - 1]) dzlist = np.argwhere(np.diff(zlist) > 1) if len(dzlist) == 0: z = max(zlist) + 1 else: z = zlist[dzlist] + 1 self.add_item(item, z=z) def __clean_item_references(self, item): """Remove all reference to this item (active, last_selected""" if item is self.active_item: self.active_item = None self._active_xaxis = self.DEFAULT_ACTIVE_XAXIS self._active_yaxis = self.DEFAULT_ACTIVE_YAXIS for key, it in list(self.last_selected.items()): if item is it: del self.last_selected[key] def del_items(self, items): """Remove item from widget""" items = items[:] # copy the list to avoid side effects when we empty it active_item = self.get_active_item() while items: item = items.pop() item.detach() # raises ValueError if item not in list self.items.remove(item) self.__clean_item_references(item) self.SIG_ITEM_REMOVED.emit(item) self.SIG_ITEMS_CHANGED.emit(self) if active_item is not self.get_active_item(): self.SIG_ACTIVE_ITEM_CHANGED.emit(self) def del_item(self, item): """ Remove item from widget Convenience function (see 'del_items') """ try: self.del_items([item]) except ValueError: raise ValueError("item not in plot") def set_item_visible(self, item, state, notify=True, replot=True): """Show/hide *item* and emit a SIG_ITEMS_CHANGED signal""" item.setVisible(state) if item is self.active_item and not state: self.set_active_item(None) # Notify the item list (see baseplot) if notify: self.SIG_ITEMS_CHANGED.emit(self) if replot: self.replot() def __set_items_visible(self, state, items=None, item_type=None): """Show/hide items (if *items* is None, show/hide all items)""" if items is None: items = self.get_items(item_type=item_type) for item in items: self.set_item_visible(item, state, notify=False, replot=False) self.SIG_ITEMS_CHANGED.emit(self) self.replot() def show_items(self, items=None, item_type=None): """Show items (if *items* is None, show all items)""" self.__set_items_visible(True, items, item_type=item_type) def hide_items(self, items=None, item_type=None): """Hide items (if *items* is None, hide all items)""" self.__set_items_visible(False, items, item_type=item_type) def save_items(self, iofile, selected=False): """ Save (serializable) items to file using the :py:mod:`pickle` protocol * iofile: file object or filename * selected=False: if True, will save only selected items See also :py:meth:`guiqwt.baseplot.BasePlot.restore_items` """ if selected: items = self.get_selected_items() else: items = self.items[:] items = [item for item in items if ISerializableType in item.types()] import pickle pickle.dump(items, iofile) def restore_items(self, iofile): """ Restore items from file using the :py:mod:`pickle` protocol * iofile: file object or filename See also :py:meth:`guiqwt.baseplot.BasePlot.save_items` """ import pickle items = pickle.load(iofile) for item in items: self.add_item(item) def serialize(self, writer, selected=False): """ Save (serializable) items to HDF5 file: * writer: :py:class:`guidata.hdf5io.HDF5Writer` object * selected=False: if True, will save only selected items See also :py:meth:`guiqwt.baseplot.BasePlot.restore_items_from_hdf5` """ if selected: items = self.get_selected_items() else: items = self.items[:] items = [item for item in items if ISerializableType in item.types()] io.save_items(writer, items) def deserialize(self, reader): """ Restore items from HDF5 file: * reader: :py:class:`guidata.hdf5io.HDF5Reader` object See also :py:meth:`guiqwt.baseplot.BasePlot.save_items_to_hdf5` """ for item in io.load_items(reader): self.add_item(item) def set_items(self, *args): """Utility function used to quickly setup a plot with a set of items""" self.del_all_items() for item in args: self.add_item(item) def del_all_items(self): """Remove (detach) all attached items""" self.del_items(self.items) def __swap_items_z(self, item1, item2): old_item1_z, old_item2_z = item1.z(), item2.z() item1.setZ(max([_it.z() for _it in self.items]) + 1) item2.setZ(old_item1_z) item1.setZ(old_item2_z) def move_up(self, item_list): """Move item(s) up, i.e. to the foreground (swap item with the next item in z-order) item: plot item *or* list of plot items Return True if items have been moved effectively""" objects = self.get_items(z_sorted=True) items = sorted(list(item_list), reverse=True, key=lambda x: objects.index(x)) changed = False if objects.index(items[-1]) > 0: for item in items: index = objects.index(item) self.__swap_items_z(item, objects[index - 1]) changed = True if changed: self.SIG_ITEMS_CHANGED.emit(self) return changed def move_down(self, item_list): """Move item(s) down, i.e. to the background (swap item with the previous item in z-order) item: plot item *or* list of plot items Return True if items have been moved effectively""" objects = self.get_items(z_sorted=True) items = sorted(list(item_list), reverse=False, key=lambda x: objects.index(x)) changed = False if objects.index(items[-1]) < len(objects) - 1: for item in items: index = objects.index(item) self.__swap_items_z(item, objects[index + 1]) changed = True if changed: self.SIG_ITEMS_CHANGED.emit(self) return changed def set_items_readonly(self, state): """Set all items readonly state to *state* Default item's readonly state: False (items may be deleted)""" for item in self.get_items(): item.set_readonly(state) self.SIG_ITEMS_CHANGED.emit(self) def select_item(self, item): """Select item""" item.select() for itype in item.types(): self.last_selected[itype] = item self.SIG_ITEM_SELECTION_CHANGED.emit(self) def unselect_item(self, item): """Unselect item""" item.unselect() self.SIG_ITEM_SELECTION_CHANGED.emit(self) def get_last_active_item(self, item_type): """Return last active item corresponding to passed `item_type`""" assert issubclass(item_type, IItemType) return self.last_selected.get(item_type) def select_all(self): """Select all selectable items""" last_item = None block = self.blockSignals(True) for item in self.items: if item.can_select(): self.select_item(item) last_item = item self.blockSignals(block) self.SIG_ITEM_SELECTION_CHANGED.emit(self) self.set_active_item(last_item) def unselect_all(self): """Unselect all selected items""" for item in self.items: if item.can_select(): item.unselect() self.set_active_item(None) self.SIG_ITEM_SELECTION_CHANGED.emit(self) def select_some_items(self, items): """Select items""" active = self.active_item block = self.blockSignals(True) self.unselect_all() if items: new_active_item = items[-1] else: new_active_item = None for item in items: self.select_item(item) if active is item: new_active_item = item self.set_active_item(new_active_item) self.blockSignals(block) if new_active_item is not active: # if the new selection doesn't include the # previously active item self.SIG_ACTIVE_ITEM_CHANGED.emit(self) self.SIG_ITEM_SELECTION_CHANGED.emit(self) def set_active_item(self, item): """Set active item, and unselect the old active item""" self.active_item = item if self.active_item is not None: if not item.selected: self.select_item(self.active_item) self._active_xaxis = item.xAxis() self._active_yaxis = item.yAxis() self.SIG_ACTIVE_ITEM_CHANGED.emit(self) def get_active_axes(self): """Return active axes""" item = self.active_item if item is not None: self._active_xaxis = item.xAxis() self._active_yaxis = item.yAxis() return self._active_xaxis, self._active_yaxis def get_active_item(self, force=False): """ Return active item Force item activation if there is no active item """ if force and not self.active_item: for item in self.get_items(): if item.can_select(): self.set_active_item(item) break return self.active_item def get_nearest_object(self, pos, close_dist=0): """ Return nearest item from position 'pos' If close_dist > 0: Return the first found item (higher z) which distance to 'pos' is less than close_dist else: Return the closest item """ selobj, distance, inside, handle = None, maxsize, None, None for obj in self.get_items(z_sorted=True): if not obj.isVisible() or not obj.can_select(): continue d, _handle, _inside, other = obj.hit_test(pos) if d < distance: selobj, distance, handle, inside = obj, d, _handle, _inside if d < close_dist: break if other is not None: # e.g. LegendBoxItem: selecting a curve ('other') instead of # legend box ('obj') return other, 0, None, True return selobj, distance, handle, inside def get_nearest_object_in_z(self, pos): """ Return nearest item for which position 'pos' is inside of it (iterate over items with respect to their 'z' coordinate) """ selobj, distance, inside, handle = None, maxsize, None, None for obj in self.get_items(z_sorted=True): if not obj.isVisible() or not obj.can_select(): continue d, _handle, _inside, _other = obj.hit_test(pos) if _inside: selobj, distance, handle, inside = obj, d, _handle, _inside break return selobj, distance, handle, inside def get_context_menu(self): """Return widget context menu""" return self.manager.get_context_menu(self) def get_plot_parameters_status(self, key): if key == "item": return self.get_active_item() is not None else: return True def get_selected_item_parameters(self, itemparams): for item in self.get_selected_items(): item.get_item_parameters(itemparams) # Retrieving active_item's parameters after every other item: # this way, the common datasets will be based on its parameters active_item = self.get_active_item() active_item.get_item_parameters(itemparams) def get_axesparam_class(self, item): """Return AxesParam dataset class associated to item's type""" return AxesParam def get_plot_parameters(self, key, itemparams): """ Return a list of DataSets for a given parameter key the datasets will be edited and passed back to set_plot_parameters this is a generic interface to help building context menus using the BasePlotMenuTool """ if key == "axes": for i, axeparam in enumerate(self.axes_styles): itemparams.add("AxeStyleParam%d" % i, self, axeparam) elif key == "item": active_item = self.get_active_item() if not active_item: return self.get_selected_item_parameters(itemparams) Param = self.get_axesparam_class(active_item) axesparam = Param(title=_("Axes"), icon='lin_lin.png', comment=_("Axes associated to selected item")) axesparam.update_param(active_item) itemparams.add("AxesParam", self, axesparam) def set_item_parameters(self, itemparams): """Set item (plot, here) parameters""" # Axe styles datasets = [itemparams.get("AxeStyleParam%d" % i) for i in range(4)] if datasets[0] is not None: self.axes_styles = datasets self.update_all_axes_styles() # Changing active item's associated axes dataset = itemparams.get("AxesParam") if dataset is not None: active_item = self.get_active_item() dataset.update_axes(active_item) def edit_plot_parameters(self, key): """ Edit plot parameters """ multiselection = len(self.get_selected_items()) > 1 itemparams = ItemParameters(multiselection=multiselection) self.get_plot_parameters(key, itemparams) title, icon = PARAMETERS_TITLE_ICON[key] itemparams.edit(self, title, icon) def edit_axis_parameters(self, axis_id): """Edit axis parameters""" if axis_id in (self.Y_LEFT, self.Y_RIGHT): title = _("Y Axis") else: title = _("X Axis") param = AxisParam(title=title) param.update_param(self, axis_id) if param.edit(parent=self): param.update_axis(self, axis_id) self.replot() def do_autoscale(self, replot=True): """Do autoscale on all axes""" for axis_id in self.AXIS_IDS: self.setAxisAutoScale(axis_id) if replot: self.replot() def disable_autoscale(self): """Re-apply the axis scales so as to disable autoscaling without changing the view""" for axis_id in self.AXIS_IDS: vmin, vmax = self.get_axis_limits(axis_id) self.set_axis_limits(axis_id, vmin, vmax) def invalidate(self): """Invalidate paint cache and schedule redraw use instead of replot when only the content of the canvas needs redrawing (axes, shouldn't change) """ self.canvas().replot() self.update()
class LevelsHistogram(CurvePlot): """Image levels histogram widget""" #: Signal emitted by LevelsHistogram when LUT range was changed SIG_VOI_CHANGED = Signal() def __init__(self, parent=None): super(LevelsHistogram, self).__init__(parent=parent, title="", section="histogram") self.antialiased = False # a dict of dict : plot -> selected items -> HistogramItem self._tracked_items = {} self.curveparam = CurveParam(_("Curve"), icon="curve.png") self.curveparam.read_config(CONF, "histogram", "curve") self.histparam = HistogramParam(_("Histogram"), icon="histogram.png") self.histparam.logscale = False self.histparam.n_bins = 256 self.range = XRangeSelection(0, 1) self.range_mono_color = self.range.shapeparam.sel_line.color self.range_multi_color = CONF.get("histogram", "range/multi/color", "red") self.add_item(self.range, z=5) self.SIG_RANGE_CHANGED.connect(self.range_changed) self.set_active_item(self.range) self.setMinimumHeight(80) self.setAxisMaxMajor(self.Y_LEFT, 5) self.setAxisMaxMinor(self.Y_LEFT, 0) if parent is None: self.set_axis_title('bottom', 'Levels') def connect_plot(self, plot): if not isinstance(plot, ImagePlot): # Connecting only to image plot widgets (allow mixing image and # curve widgets for the same plot manager -- e.g. in pyplot) return self.SIG_VOI_CHANGED.connect(plot.notify_colormap_changed) plot.SIG_ITEM_SELECTION_CHANGED.connect(self.selection_changed) plot.SIG_ITEM_REMOVED.connect(self.item_removed) plot.SIG_ACTIVE_ITEM_CHANGED.connect(self.active_item_changed) def tracked_items_gen(self): for plot, items in list(self._tracked_items.items()): for item in list(items.items()): yield item # tuple item,curve def __del_known_items(self, known_items, items): del_curves = [] for item in list(known_items.keys()): if item not in items: curve = known_items.pop(item) del_curves.append(curve) self.del_items(del_curves) def selection_changed(self, plot): items = plot.get_selected_items(item_type=IVoiImageItemType) known_items = self._tracked_items.setdefault(plot, {}) if items: self.__del_known_items(known_items, items) if len(items) == 1: # Removing any cached item for other plots for other_plot, _items in list(self._tracked_items.items()): if other_plot is not plot: if not other_plot.get_selected_items( item_type=IVoiImageItemType): other_known_items = self._tracked_items[other_plot] self.__del_known_items(other_known_items, []) else: # if all items are deselected we keep the last known # selection (for one plot only) for other_plot, _items in list(self._tracked_items.items()): if other_plot.get_selected_items(item_type=IVoiImageItemType): self.__del_known_items(known_items, []) break for item in items: if item not in known_items: curve = HistogramItem(self.curveparam, self.histparam) curve.set_hist_source(item) self.add_item(curve, z=0) known_items[item] = curve nb_selected = len(list(self.tracked_items_gen())) if not nb_selected: self.replot() return self.curveparam.shade = 1.0 / nb_selected for item, curve in self.tracked_items_gen(): self.curveparam.update_curve(curve) self.histparam.update_hist(curve) self.active_item_changed(plot) # Rescaling histogram plot axes for better visibility ymax = None for item in known_items: curve = known_items[item] _x, y = curve.get_data() ymax0 = y.mean() + 3 * y.std() if ymax is None or ymax0 > ymax: ymax = ymax0 ymin, _ymax = self.get_axis_limits("left") if ymax is not None: self.set_axis_limits("left", ymin, ymax) self.replot() def item_removed(self, item): for plot, items in list(self._tracked_items.items()): if item in items: curve = items.pop(item) self.del_items([curve]) self.replot() break def active_item_changed(self, plot): items = plot.get_selected_items(item_type=IVoiImageItemType) if not items: #XXX: workaround return active = plot.get_last_active_item(IVoiImageItemType) if active: active_range = active.get_lut_range() else: active_range = None multiple_ranges = False for item, curve in self.tracked_items_gen(): if active_range != item.get_lut_range(): multiple_ranges = True if active_range is not None: _m, _M = active_range self.set_range_style(multiple_ranges) self.range.set_range(_m, _M, dosignal=False) self.replot() def set_range_style(self, multiple_ranges): if multiple_ranges: self.range.shapeparam.sel_line.color = self.range_multi_color else: self.range.shapeparam.sel_line.color = self.range_mono_color self.range.shapeparam.update_range(self.range) def set_range(self, _min, _max): if _min < _max: self.set_range_style(False) self.range.set_range(_min, _max) self.replot() return True else: # Range was not changed return False def range_changed(self, _rangesel, _min, _max): for item, curve in self.tracked_items_gen(): item.set_lut_range([_min, _max]) self.SIG_VOI_CHANGED.emit() def set_full_range(self): """Set range bounds to image min/max levels""" _min = _max = None for item, curve in self.tracked_items_gen(): imin, imax = item.get_lut_range_full() if _min is None or _min > imin: _min = imin if _max is None or _max < imax: _max = imax if _min is not None: self.set_range(_min, _max) def apply_min_func(self, item, curve, min): _min, _max = item.get_lut_range() return min, _max def apply_max_func(self, item, curve, max): _min, _max = item.get_lut_range() return _min, max def reduce_range_func(self, item, curve, percent): return lut_range_threshold(item, curve.bins, percent) def apply_range_function(self, func, *args, **kwargs): item = None for item, curve in self.tracked_items_gen(): _min, _max = func(item, curve, *args, **kwargs) item.set_lut_range([_min, _max]) self.SIG_VOI_CHANGED.emit() if item is not None: self.active_item_changed(item.plot()) def eliminate_outliers(self, percent): """ Eliminate outliers: eliminate percent/2*N counts on each side of the histogram (where N is the total count number) """ self.apply_range_function(self.reduce_range_func, percent) def set_min(self, _min): self.apply_range_function(self.apply_min_func, _min) def set_max(self, _max): self.apply_range_function(self.apply_max_func, _max)
class MainWindow(QMainWindow): updateCameraPlot = Signal(object) updateLineOutPlot = Signal(object) def __init__(self): QMainWindow.__init__(self) self.stopAcqui = False self.setWindowTitle(APP_NAME) ############## # Camera image self.image_toolbar = self.addToolBar(_("Image Processing Toolbar")) imagevis_toolbar = self.addToolBar(_("Image Visualization Toolbar")) self.imageWidget1 = DockablePlotWidget(self, ImageWidget, imagevis_toolbar) self.image1 = ImageFT(self, self.imageWidget1.get_plot()) self.image1.addHCursor(1) self.image1.addRoi(0, 1, 2048, 1) #self.image1.setup(self.image_toolbar) ############### # camera line out curveplot_toolbar = self.addToolBar(_("Curve Plotting Toolbar")) self.curveWidget1 = DockablePlotWidget(self, CurveWidget, curveplot_toolbar) self.curveWidget1.calcFun.addFun('Pixels', lambda x: x, lambda x: x) plot1 = self.curveWidget1.get_plot() self.signal1 = SignalFT(self, plot=plot1) ############## # Main window widgets # status bar self.status = self.statusBar() # widgets self.tabwidget = DockableTabWidget(self) #self.tabwidget.setMaximumWidth(500) self.greateyesUi = GreatEyesUi(self) self.tabwidget.addTab(self.greateyesUi, QIcon('icons/Handyscope_HS4.png'), _("greateyes")) #self.fileUi = FileUi(self) #self.tabwidget.addTab(self.fileUi, get_icon('filesave.png'), _('File')) self.add_dockwidget(self.tabwidget, _("Inst. sett.")) # self.setCentralWidget(self.tabwidget) self.dock1 = self.add_dockwidget(self.imageWidget1, title=_("Camera")) self.dock2 = self.add_dockwidget(self.curveWidget1, title=_("Lineout")) ################ # connect signals self.greateyesUi.newPlotData.connect(self.newData) self.greateyesUi.message.connect(self.updateStatus) self.image1.plot.SIG_MARKER_CHANGED.connect(self.cursorMoved) self.greateyesUi.loi.valueChanged.connect(self.cursorMoved) self.greateyesUi.deltaPixels.valueChanged.connect(self.cursorMoved) #self.curveWidget1.calcFun.idxChanged.connect(self.signal1.funChanged) #self.fileUi.saveTxtBtn.released.connect(self.saveDataTxt) #self.fileUi.saveHdfBtn.released.connect(self.saveDataHDF5) ''' self.piUi.startScanBtn.released.connect(self.startMeasureThr) self.piUi.stopScanBtn.released.connect(self.stopMeasureThr) self.piUi.xAxeChanged.connect(self.tdSignal.updateXAxe) self.piUi.xAxeChanged.connect(self.fdSignal.updateXAxe) self.piUi.niceBtn.released.connect(self.showMakeNicerWidget) self.tiepieUi.scpConnected.connect(self.startOsciThr) self.tiepieUi.xAxeChanged.connect(self.osciSignal.updateXAxe) self.tiepieUi.yAxeChanged.connect(self.osciSignal.updateYAxe) self.tiepieUi.triggLevelChanged.connect(self.osciSignal.setHCursor) #self.piUi.centerBtn.released.connect( # lambda x=None: self.piUi.setCenter(self.tdSignal.getVCursor())) self.tdSignal.plot.SIG_MARKER_CHANGED.connect( lambda x=None: self.piUi.newOffset(self.tdSignal.getVCursor())) self.tdWidget.calcFun.idxChanged.connect(self.tdSignal.funChanged) self.fdWidget.calcFun.idxChanged.connect(self.fdSignal.funChanged) self.updateOsciPlot.connect(self.osciSignal.updatePlot) self.updateTdPlot.connect(self.tdSignal.updatePlot) self.updateFdPlot.connect(lambda data: self.fdSignal.updatePlot(self.fdSignal.computeFFT(data))) ''' ################ # File menu ''' file_menu = self.menuBar().addMenu(_("File")) self.quit_action = create_action(self, _("Quit"), shortcut="Ctrl+Q", icon=get_std_icon("DialogCloseButton"), tip=_("Quit application"), triggered=self.close) saveData = create_action(self, _("Save"), shortcut="Ctrl+S", icon=get_std_icon("DialogSaveButton"), tip=_("Save data"), triggered=self.saveDataHDF5) #add_actions(file_menu, (triggerTest_action, saveData, None, self.quit_action)) ''' ############## # Eventually add an internal console (requires 'spyderlib') self.console = None ''' self.sift_proxy = SiftProxy(self) if DockableConsole is None: self.console = None else: import time, scipy.signal as sps, scipy.ndimage as spi ns = {'ftir': self.sift_proxy, 'np': np, 'sps': sps, 'spi': spi, 'os': os, 'sys': sys, 'osp': osp, 'time': time} msg = "Example: ftir.s[0] returns signal object #0\n"\ "Modules imported at startup: "\ "os, sys, os.path as osp, time, "\ "numpy as np, scipy.signal as sps, scipy.ndimage as spi" self.console = DockableConsole(self, namespace=ns, message=msg) self.add_dockwidget(self.console, _("Console")) ''' ''' try: self.console.interpreter.widget_proxy.sig_new_prompt.connect( lambda txt: self.refresh_lists()) except AttributeError: print('sift: spyderlib is outdated', file=sys.stderr) ''' # Show main window and raise the signal plot panel self.show() #------GUI refresh/setup def add_dockwidget(self, child, title): """Add QDockWidget and toggleViewAction""" dockwidget, location = child.create_dockwidget(title) self.addDockWidget(location, dockwidget) return dockwidget def closeEvent(self, event): self.greateyesUi.closeEvent(event) if self.console is not None: self.console.exit_interpreter() event.accept() def newData(self, image, timeStamp): self.image1.updatePlot( image, timeStamp.isoformat() + ", " + str(self.greateyesUi.cameraSettings['temperature']) + "°C") self.updateLineOut(image) self.saveDataHDF5(image, timeStamp) def updateStatus(self, msg): self.status.showMessage(msg, 10000) def updateLineOut(self, image): loi = self.greateyesUi.loi.value() dLoi = self.greateyesUi.deltaPixels.value() data = image[(loi - dLoi):(loi + dLoi + 1), :] self.signal1.updatePlot( np.column_stack((np.arange(0, data.shape[1]), data.sum(axis=0)))) self.image1.setHCursor(loi) self.image1.setRoi(0, loi - dLoi, 2048, loi + dLoi) def saveDataHDF5(self, image, timeStamp): if not self.greateyesUi.autoSave.isChecked(): return zeit = timeStamp.strftime('%Y%m%d-%H%M%S') fileName = self.greateyesUi.directory + "/" + zeit #fileName = QDir.toNativeSeparators(fileName) print(fileName) # save matlab file savemat( fileName, { 'image': image, 'comment': self.greateyesUi.comment.toPlainText(), 'camera_settings': self.greateyesUi.cameraSettings }) # save images self.image1.plot.save_widget(fileName + '_image.png') self.signal1.plot.save_widget(fileName + '_lineout.png') self.status.showMessage(fileName + " saved", 10000) # TODO: maybe put this in status bar ''' msg = QMessageBox() msg.setIcon(QMessageBox.Information) msg.setText('Data saved') msg.exec_() ''' def cursorMoved(self, mouse): if not isinstance(mouse, int): # true if cursor moved by mouse cursorVal = int(self.image1.getHCursor()) self.greateyesUi.loi.setValue(cursorVal) else: cursorVal = self.greateyesUi.loi.value() self.image1.setHCursor(cursorVal) roi = self.greateyesUi.deltaPixels.value() self.image1.setRoi(0, cursorVal - roi, 2048, cursorVal + roi)
class MaestroUi(QSplitter): connected = Signal() # gets emitted if stage was sucessfully connected newPlotData = Signal(object) updateAvgTxt = Signal(object) def __init__(self, parent): #super(ObjectFT, self).__init__(Qt.Vertical, parent) super().__init__(parent) self.meter = None self.collectData = True # bool for data collection thread self.avgData = Queue() # need data for averaging and set for holding all self.measure = False self.runDataThr = True self.measureData = [] self.startTime = None layoutWidget = QWidget() layout = QGridLayout() layoutWidget.setLayout(layout) ############## # gui elements self.ipEdit = QLineEdit() rx = QRegExp("^(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5]).){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$") self.ipEdit.setValidator(QRegExpValidator(rx)) self.ipEdit.setText('127.0.0.1') self.portEdit = QLineEdit() self.portEdit.setValidator(QIntValidator(1, 65535, self)) self.portEdit.setText('5000') self.connectBtn = QPushButton('Connect') self.avgSpin = QSpinBox() self.avgSpin.setValue(1) self.avgSpin.setRange(1, 10000) self.currValDisp = QLabel('0.0') self.startMeasBtn = QPushButton('Start aq') self.stopMeasBtn = QPushButton('Stop aq') ############## # put layout together layout.addWidget(QLabel('IP Address:'), 0, 0) layout.addWidget(self.ipEdit, 1, 0) layout.addWidget(QLabel('Port:'), 0, 1) layout.addWidget(self.portEdit, 1, 1) layout.addWidget(self.connectBtn, 2, 1) layout.addWidget(QLabel('Averages'), 4, 0) layout.addWidget(self.avgSpin, 5, 0) layout.addWidget(self.currValDisp, 5, 1) layout.addWidget(self.startMeasBtn, 6, 0) layout.addWidget(self.stopMeasBtn, 6, 1) layout.setRowStretch(7, 10) self.addWidget(layoutWidget) ############## # Network stuff self.tcpClient = QtNetwork.QTcpSocket() self.tcpClient.readyRead.connect(self.__getSocketData) self.tcpClient.error.connect(lambda x: print(x)) ############## # make button and stuff functional self.connectBtn.released.connect(self.connectMeter) self.avgSpin.valueChanged.connect(self.changeAverage) self.startMeasBtn.released.connect(self._startMeasure) self.stopMeasBtn.released.connect(self._stopMeasure) ############## # thread for getting data from socket self.updateAvgTxt.connect(self.__updateAvgTxt) self.dataAq_Thr = QThread() self.dataAq_Thr.start() self.dataAq_worker = GenericWorker(self.__getData) self.dataAq_worker.moveToThread(self.dataAq_Thr) def connectMeter(self): print('connected') self.tcpClient.connectToHost(self.ipEdit.text(), int(self.portEdit.text())) self.tcpClient.write('start\n'.encode()) self.dataAq_worker.start.emit() def _startMeasure(self): self.measure = True self.measureData = [] # reinitialize measure data array time.sleep(0.1) # time to wait for first data to arrive self.startTime = datetime.now() # datetime object def _stopMeasure(self): self.measure = False #@Slot def __updateAvgTxt(self, text): ''' update current value label ''' self.currValDisp.setText(text) def changeAverage(self): shape = int(self.avgSpin.value()) self.dispData = np.zeros(shape) def __getData(self): ''' Function run in thread ''' while self.runDataThr: tmpData = np.array(int(self.avgSpin.text())*[[datetime.now(), 0]]) for i in range(len(tmpData)): tmpData[i] = self.avgData.get() if self.measure: self.measureData.append( (tmpData[i,0].isoformat().encode(), (tmpData[i,0]-self.startTime).total_seconds(), tmpData[i,1])) #print('mean', tmpData.mean()) self.updateAvgTxt.emit(str(tmpData[:,1].mean())) if self.measure: self.newPlotData.emit(np.float_(np.asarray(self.measureData)[:,1:])) self.avgData.task_done() #@Slot() def __getSocketData(self): ''' to be called if network buffer has more data push data to queue ''' self.avgData.put([datetime.now(), float(self.tcpClient.readLine(1024).decode().rstrip())]) def closeEvent(self, event): if self.tcpClient.isOpen(): self.RunDataThr = False self.tcpClient.write('stop\n'.encode()) time.sleep(0.1) self.tcpClient.close() print(self.tcpClient.isOpen()) #if self.console is not None: # self.console.exit_interpreter() event.accept()
class PiStageUi(QSplitter): stageConnected = Signal( ) # gets emitted if stage was sucessfully connected stopScan = Signal() xAxeChanged = Signal(object, object) updateCurrPos = Signal(object) def __init__(self, parent): #super(ObjectFT, self).__init__(Qt.Vertical, parent) super().__init__(parent) self.stage = None self.offset = 0. # offset from 0 where t0 is (mm) self.newOff = 0. self.stageRange = (0, 0) layoutWidget = QWidget() layout = QGridLayout() layoutWidget.setLayout(layout) # put layout together self.openStageBtn = QPushButton("Open stage") self.initStageBtn = QPushButton("Init stage") #absolute move #current position self.currentPos = QLabel('') #self.currentPos.setValidator(QDoubleValidator()) #relative move (mm) self.deltaMove_mm = QLineEdit() self.deltaMove_mm.setText('0') self.deltaMove_mm.setValidator(QDoubleValidator()) self.deltaMovePlus_mm = QPushButton('+') self.deltaMoveMinus_mm = QPushButton('-') #relative move (fs) self.deltaMove_fs = QLineEdit() self.deltaMovePlus_fs = QPushButton('+') self.deltaMoveMinus_fs = QPushButton('-') #velocity self.velocityLabel = QLabel('Velocity:') self.velocity = QSlider(Qt.Horizontal) self.velocity.setMinimum(0) self.velocity.setMaximum( 2000) # unit in µm; TODO: try to get max vel. from controller # scan from (fs) self.scanFrom = QLineEdit() self.scanFrom.setText('-100') self.scanFrom.setValidator(QIntValidator()) # scan to (fs) self.scanTo = QLineEdit() self.scanTo.setText('100') self.scanTo.setValidator(QIntValidator()) # scan stepsize (fs) self.scanStep = QLineEdit() self.scanStep.setText('10') self.scanStep.setValidator(QDoubleValidator()) # center here button self.centerBtn = QPushButton('Center here') self.centerBtn.setToolTip('Center scan at current stage position') self.startScanBtn = QPushButton("Start scan") self.stopScanBtn = QPushButton("Stop scan") self.niceBtn = QPushButton('Make it nice') # spacer line hLine = QFrame() hLine.setFrameStyle(QFrame.HLine) hLine.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Expanding) # put layout together layout.addWidget(self.openStageBtn, 0, 0) layout.addWidget(self.initStageBtn, 0, 1) layout.addWidget(QLabel("Current pos (mm):"), 1, 0) layout.addWidget(self.currentPos, 1, 1) layout.addWidget(self.velocityLabel, 2, 0) layout.addWidget(self.velocity, 3, 0, 1, 2) layout.addWidget(QLabel('Move relative (mm)'), 4, 0) layout.addWidget(self.deltaMove_mm, 5, 0, 1, 2) layout.addWidget(self.deltaMoveMinus_mm, 6, 0) layout.addWidget(self.deltaMovePlus_mm, 6, 1) layout.addWidget(QLabel('Move relative (fs)'), 7, 0) layout.addWidget(self.deltaMove_fs, 8, 0, 1, 2) layout.addWidget(self.deltaMoveMinus_fs, 9, 0) layout.addWidget(self.deltaMovePlus_fs, 9, 1) layout.addWidget(hLine, 10, 0, 1, 2) layout.addWidget(QLabel('Scan from (fs)'), 11, 0) layout.addWidget(self.scanFrom, 11, 1) layout.addWidget(QLabel('Scan to (fs)'), 12, 0) layout.addWidget(self.scanTo, 12, 1) layout.addWidget(QLabel('Stepsize (fs)'), 13, 0) layout.addWidget(self.scanStep, 13, 1) layout.addWidget(self.startScanBtn, 14, 0) layout.addWidget(self.stopScanBtn, 14, 1) layout.addWidget(self.centerBtn, 15, 1) layout.addWidget(self.niceBtn, 16, 1) layout.setRowStretch(17, 10) layout.setColumnStretch(2, 10) self.addWidget(layoutWidget) # make button and stuff functional self.openStageBtn.released.connect(self.connectStage) self.initStageBtn.released.connect(self.initStage) self.scanFrom.returnPressed.connect(self._xAxeChanged) self.scanTo.returnPressed.connect(self._xAxeChanged) self.centerBtn.released.connect(self._centerHere) self.deltaMovePlus_mm.released.connect( lambda x=1: self.moveRel_mm(float(self.deltaMove_mm.text()))) self.deltaMoveMinus_mm.released.connect( lambda x=-1: self.moveRel_mm(float(self.deltaMove_mm.text()), x)) ################ # thread for updating position #self.currPosThr = GenericThread(self.__getCurrPos) self.updateCurrPos.connect(self.__updateCurrPos) self.currPos_thread = QThread() # create the QThread self.currPos_thread.start() # This causes my_worker.run() to eventually execute in my_thread: self.currPos_worker = GenericWorker(self.__getCurrPos) self.currPos_worker.moveToThread(self.currPos_thread) # my_worker.finished.connect(self.xxx) #self.threadPool.append(my_thread) #self.my_worker = my_worker def connectStage(self): gcs = GCSDevice() try: gcs.InterfaceSetupDlg() msg = QMessageBox() msg.setIcon(QMessageBox.Information) msg.setText(gcs.qIDN()) msg.exec_() self.stage = gcs self.openStageBtn.setEnabled(False) except: msg = QMessageBox() msg.setIcon(QMessageBox.Critical) msg.setText('Could not connect stage') msg.exec_() def initStage(self): # TODO put this in thread and show egg clock if self.stage is not None: ## Create and display the splash screen #splash_pix = QPixmap('icons/piController.png') #splash = QSplashScreen(splash_pix, Qt.WindowStaysOnTopHint) #splash.setMask(splash_pix.mask()) #splash.show() # TODO: give choice to select stage pitools.startup(self.stage, stages='M-112.1DG-NEW', refmode='FNL') #splash.close() # TODO: show dialog for waiting self.velocityLabel.setText('Velocity: {:f}mm/s'.format( self.stage.qVEL()['1'])) self.velocity.setValue(int(1000 * self.stage.qVEL()['1'])) self.stageConnected.emit() self._xAxeChanged() self.currentPos.setText('{:.7f}'.format(self.stage.qPOS()['1'])) self.__startCurrPosThr() self.stageRange = (self.stage.qTMN()['1'], self.stage.qTMX()['1']) self.scanStep.validator().setBottom(0) self.initStageBtn.setEnabled(False) else: msg = QMessageBox() msg.setIcon(QMessageBox.Critical) msg.setText('No stage connected') msg.exec_() def gotoPos_mm(self, x): '''Move stage to absolute position in mm''' if self.stageRange[0] <= x <= self.stageRange[1]: self.stage.MOV(self.stage.axes, x) while not pitools.ontarget(self.stage, '1')['1']: time.sleep(0.05) else: print('Requested postition', x, 'outside of range', self.stageRange) def gotoPos_fs(self, x): '''Move stage to absolute position in mm''' self.gotoPos_mm(self._calcAbsPos(x)) def moveRel_mm(self, x=0, sign=1): '''Moves stage relative to current position''' # TODO raise message if outside of range currPos = float(self.currentPos.text()) if self.stageRange[0] <= sign * x + currPos <= self.stageRange[1]: self.stage.MVR(self.stage.axes, sign * x) else: print('Requested postition', x, 'outside of range', self.stageRange) def moveRel_fs(self, x=0, sign=1): '''Moves stage relative to current position; expexts fs''' # TODO raise message if outside of range self.moveRel_mm(self._calcAbsPos(x), sign) def _calcAbsPos(self, x): '''Calculate absolute position on stage from given femtosecond value gets x in fs and returns position mm''' return (x * fsDelay) + self.offset def getDelays_mm(self): '''expects fs and returns mm''' von = self._calcAbsPos(float(self.scanFrom.text())) bis = self._calcAbsPos(float(self.scanTo.text())) #stepSize = int(self.scanStep.text()) stepSize = float(self.scanStep.text()) * fsDelay return np.linspace(von, bis, (np.abs(von) + bis) / stepSize) def getDelays_fs(self): '''expects fs and returns mm''' von = float(self.scanFrom.text()) bis = float(self.scanTo.text()) #stepSize = int(self.scanStep.text()) stepSize = float(self.scanStep.text()) return np.linspace(von, bis, (np.abs(von) + bis) / stepSize) def _xAxeChanged(self): self.xAxeChanged.emit(int(self.scanFrom.text()), int(self.scanTo.text())) def setCenter(self): '''Slot which recieves the new center position in fs and sets offset in mm ''' if self.newOff != 0: self.offset += (self.newOff * fsDelay) print('offset', self.offset, self.newOff) self.newOff = 0. def newOffset(self, newOffset): self.newOff = newOffset def _centerHere(self): self.offset = self.stage.qPOS()['1'] def __startCurrPosThr(self): self.stopCurrPosThr = False #self.currPosThr.start() self.currPos_worker.start.emit() def __stopCurrPosThr(self): self.stopCurrPosThr = True while (self.currPosThr.isRunning()): time.sleep(0.03) def __getCurrPos(self): oldPos = self.stage.qPOS()['1'] while not self.stopCurrPosThr: newPos = self.stage.qPOS()['1'] if oldPos != newPos: oldPos = newPos self.updateCurrPos.emit(newPos) time.sleep(0.5) def __updateCurrPos(self, newPos): self.currentPos.setText('{:.7f}'.format(newPos))