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))
