def create_slice_dock(self):
widget = QWidget()
dock = QDockWidget("Slice", self)
dock.setAllowedAreas(Qt.TopDockWidgetArea | Qt.BottomDockWidgetArea
| Qt.LeftDockWidgetArea | Qt.RightDockWidgetArea)
self.addDockWidget(Qt.BottomDockWidgetArea, dock)
layout = QGridLayout(widget)
self.slice_index_spin_box = QSpinBox()
index_max = self.map_.measurement.param.axis3.get_length()
self.slice_index_spin_box.setRange(0, index_max - 1)
slice_slider = QSlider(Qt.Horizontal)
slice_slider.setRange(0, index_max - 1)
self.connect(self.slice_index_spin_box, SIGNAL("valueChanged(int)"),
self.set_slice_index)
self.connect(slice_slider, SIGNAL("valueChanged(int)"),
self.slice_index_spin_box.setValue)
self.connect(self.slice_index_spin_box, SIGNAL("valueChanged(int)"),
slice_slider.setValue)
self.slice_value_spin_box = QDoubleSpinBox()
scale = self.map_.measurement.param.axis3.get_scale()
self.slice_value_spin_box.setRange(scale.min(), scale.max())
self.slice_value_spin_box.setValue(scale[0])
self.connect(self.slice_value_spin_box, SIGNAL("valueChanged(double)"),
self.set_slice_value)
unit = self.map_.measurement.param.axis3.unit
self.slice_value_spin_box.setSuffix(unit)
layout.addWidget(slice_slider, 0, 0)
layout.addWidget(self.slice_index_spin_box, 0, 1)
layout.addWidget(self.slice_value_spin_box, 0, 2)
dock.setWidget(widget)
class SubplotWidget(QSplitter):
"""Construct a Widget that helps managing several plots
together handled by the same manager
Since the plots must be added to the manager before the panels
the add_itemlist method can be called after having declared
all the subplots
"""
def __init__(self, manager, parent=None, **kwargs):
super(SubplotWidget, self).__init__(parent, **kwargs)
self.setOrientation(Qt.Horizontal)
self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.manager = manager
self.plots = []
self.itemlist = None
main = QWidget()
self.plotlayout = QGridLayout()
main.setLayout(self.plotlayout)
self.addWidget(main)
def add_itemlist(self, show_itemlist=False):
self.itemlist = PlotItemList(self)
self.itemlist.setVisible(show_itemlist)
self.addWidget(self.itemlist)
configure_plot_splitter(self)
self.manager.add_panel(self.itemlist)
def add_subplot(self, plot, i=0, j=0, plot_id=None):
"""Add a plot to the grid of plots"""
self.plotlayout.addWidget(plot, i, j)
self.plots.append(plot)
if plot_id is None:
plot_id = id(plot)
self.manager.add_plot(plot, plot_id)
def create_slice_dock(self):
widget = QWidget()
dock = QDockWidget("Slice", self)
dock.setAllowedAreas(Qt.TopDockWidgetArea | Qt.BottomDockWidgetArea |
Qt.LeftDockWidgetArea | Qt.RightDockWidgetArea)
self.addDockWidget(Qt.BottomDockWidgetArea, dock)
layout = QGridLayout(widget)
self.slice_index_spin_box = QSpinBox()
index_max = self.map_.measurement.param.axis3.get_length()
self.slice_index_spin_box.setRange(0, index_max-1 )
slice_slider = QSlider(Qt.Horizontal)
slice_slider.setRange(0, index_max-1)
self.connect(self.slice_index_spin_box, SIGNAL("valueChanged(int)"),
self.set_slice_index)
self.connect(slice_slider, SIGNAL("valueChanged(int)"),
self.slice_index_spin_box.setValue)
self.connect(self.slice_index_spin_box, SIGNAL("valueChanged(int)"),
slice_slider.setValue)
self.slice_value_spin_box = QDoubleSpinBox()
scale = self.map_.measurement.param.axis3.get_scale()
self.slice_value_spin_box.setRange(scale.min(),scale.max())
self.slice_value_spin_box.setValue(scale[0])
self.connect(self.slice_value_spin_box, SIGNAL("valueChanged(double)"),
self.set_slice_value)
unit = self.map_.measurement.param.axis3.unit
self.slice_value_spin_box.setSuffix(unit)
layout.addWidget(slice_slider, 0, 0)
layout.addWidget(self.slice_index_spin_box, 0, 1)
layout.addWidget(self.slice_value_spin_box, 0, 2)
dock.setWidget(widget)
class SubplotWidget(QSplitter):
"""Construct a Widget that helps managing several plots
together handled by the same manager
Since the plots must be added to the manager before the panels
the add_itemlist method can be called after having declared
all the subplots
"""
def __init__(self, manager, parent=None, **kwargs):
super(SubplotWidget, self).__init__(parent, **kwargs)
self.setOrientation(Qt.Horizontal)
self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.manager = manager
self.plots = []
self.itemlist = None
main = QWidget()
self.plotlayout = QGridLayout()
main.setLayout(self.plotlayout)
self.addWidget(main)
def add_itemlist(self, show_itemlist=False):
self.itemlist = PlotItemList(self)
self.itemlist.setVisible(show_itemlist)
self.addWidget(self.itemlist)
configure_plot_splitter(self)
self.manager.add_panel(self.itemlist)
def add_subplot(self, plot, i=0, j=0, plot_id=None):
"""Add a plot to the grid of plots"""
self.plotlayout.addWidget(plot, i, j)
self.plots.append(plot)
if plot_id is None:
plot_id = id(plot)
self.manager.add_plot(plot, plot_id)
def __init__(self, parent=None):
QFrame.__init__(self, parent)
layout = QGridLayout()
self.setLayout(layout)
angle = 0
for row in range(7):
for column in range(7):
layout.addWidget(RotatedLabel("Label %03d°" % angle,
angle=angle, color=Qt.blue,
bold=True),
row, column, Qt.AlignCenter)
angle += 10
def __init__(self, parent=None):
QFrame.__init__(self, parent)
layout = QGridLayout()
self.setLayout(layout)
angle = 0
for row in range(7):
for column in range(7):
layout.addWidget(
RotatedLabel("Label %03d°" % angle,
angle=angle,
color=Qt.blue,
bold=True), row, column, Qt.AlignCenter)
angle += 10
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 __init__(self, parent=None, x=[], y=[], data=[]):
QWidget.__init__(self, parent)
if len(x) < 2:
x = np.linspace(0, 1392, 1392)
y = np.linspace(0, 1040, 1040)
data = np.zeros((1040, 1392))
self.x = x
self.y = y
self.data = data
sx = 600
sy = int(sx / 1.338)
stretch_x = 3
stretch_y = 3
#self.setGeometry(QRect(0,0,sx,sy))
layout = QGridLayout(self)
layout.setMargin(0)
self.screen = ImageScreen(self, x, y, data)
self.cutX = CutScreen(self)
self.cutY = CutScreen(self)
layout.addWidget(self.screen, 1, 0)
layout.addWidget(self.cutX, 0, 0)
layout.addWidget(self.cutY, 1, 1)
layout.setColumnStretch(0, stretch_x)
layout.setColumnStretch(1, 1)
layout.setRowStretch(0, 1)
layout.setRowStretch(1, stretch_y)
self.setLayout(layout)
self.updateGeometry()
self.manager = PlotManager(self)
self.manager.add_plot(self.screen.plot)
self.manager.add_plot(self.cutX.plot)
self.manager.add_plot(self.cutY.plot)
#roi = ROISelectTool
#bkgnd = BKGNDSelectTool
self.tools = [tools.SelectTool, tools.RectZoomTool, tools.ColormapTool]
self.manager.register_all_curve_tools()
def __init__(self, parent=None, x=[], y=[], data=[]):
QWidget.__init__(self, parent)
if len(x) < 2:
x = np.linspace(0, 1392, 1392)
y = np.linspace(0, 1040, 1040)
data = np.zeros((1040, 1392))
self.x = x
self.y = y
self.data = data
layout = QGridLayout(self)
'''
self.screen = ImageScreen(self,x,y,data,int(self.sizex*5.0/6.0),int(self.sizey*5.0/6.0))
self.cutX = CutScreen(self,sizex=int(self.sizex*5.0/6.0),sizey=int(self.sizey*1.0/6.0))
self.cutY = CutScreen(self,sizex=int(self.sizex*1.0/6.0),sizey=int(self.sizey*5.0/6.0))
'''
sx = 500
sy = int(sx / 1.338)
a = 0.2
self.screen = ImageScreen(self, x, y, data, sizex=sx, sizey=sy)
self.cutX = CutScreen(self, sizex=sx, sizey=int(a * sy))
self.cutY = CutScreen(self, sizex=int(a * sx), sizey=sy)
layout.addWidget(self.screen, 1, 0)
layout.addWidget(self.cutX, 0, 0)
layout.addWidget(self.cutY, 1, 1)
self.setLayout(layout)
self.updateGeometry()
self.manager = PlotManager(self)
self.manager.add_plot(self.screen.plot)
self.manager.add_plot(self.cutX.plot)
self.manager.add_plot(self.cutY.plot)
roi = RegionSelectTool
self.tools = [
tools.SelectTool, tools.RectZoomTool, roi, tools.ColormapTool
]
self.manager.register_all_curve_tools()
def __init__(self,
name,
instanceId,
widgetList,
dataFunc,
inactivityTimeout=True):
dspWidget.__init__(self,
name,
instanceId,
widgetList,
inactivityTimeout=inactivityTimeout)
self.dataFunc = dataFunc
self.Fs = 2000
layout = QGridLayout()
self.setLayout(layout)
self.resize(1024, 800)
self.refPlotW = dspCurveWidget(mode="PCM",
title="Reference PCM",
show_itemlist=False)
layout.addWidget(self.refPlotW, 1, 0, 1, 1)
self.errPlotW = dspCurveWidget(mode="PCM",
title="Error Mic PCM",
show_itemlist=False)
layout.addWidget(self.errPlotW, 2, 0, 1, 1)
self.mscohPlotW = dspCurveWidget(mode="MSCoh",
title="Magnitude Squared Coherence",
show_itemlist=False)
layout.addWidget(self.mscohPlotW, 3, 0, 1, 2)
def __init__(self, item, parent_layout):
super(MultipleChoiceWidget, self).__init__(item, parent_layout)
self.groupbox = self.group = QGroupBox(item.get_prop_value("display", "label"))
layout = QGridLayout()
self.boxes = []
nx, ny = item.get_prop_value("display", "shape")
cx, cy = 0, 0
_choices = item.get_prop_value("data", "choices")
for _, choice, _img in _choices:
checkbox = QCheckBox(choice)
layout.addWidget(checkbox, cx, cy)
if nx < 0:
cy += 1
if cy >= ny:
cy = 0
cx += 1
else:
cx += 1
if cx >= nx:
cx = 0
cy += 1
self.boxes.append(checkbox)
self.groupbox.setLayout(layout)
def __init__(self, item, parent_layout):
super(MultipleChoiceWidget, self).__init__(item, parent_layout)
self.groupbox = self.group = QGroupBox(item.get_prop_value("display",
"label"))
layout = QGridLayout()
self.boxes = []
nx, ny = item.get_prop_value("display", "shape")
cx, cy = 0, 0
_choices = item.get_prop_value("data", "choices")
for _, choice, _img in _choices:
checkbox = QCheckBox(choice)
layout.addWidget(checkbox, cx, cy)
if nx < 0:
cy += 1
if cy >= ny:
cy = 0
cx += 1
else:
cx += 1
if cx >= nx:
cx = 0
cy += 1
self.boxes.append(checkbox)
self.groupbox.setLayout(layout)
def __init__(self, parent):
QWidget.__init__(self, parent)
layout = QGridLayout()
self.setLayout(layout)
self.plot1 = ImagePlot(self)
layout.addWidget(self.plot1, 0, 0, 1, 1)
self.plot2 = ImagePlot(self)
layout.addWidget(self.plot2, 1, 0, 1, 1)
self.contrast = ContrastAdjustment(self)
layout.addWidget(self.contrast, 2, 0, 1, 2)
self.itemlist = PlotItemList(self)
layout.addWidget(self.itemlist, 0, 1, 2, 1)
self.manager = PlotManager(self)
for plot in (self.plot1, self.plot2):
self.manager.add_plot(plot)
for panel in (self.itemlist, self.contrast):
self.manager.add_panel(panel)
def __init__(self, parent):
QWidget.__init__(self, parent)
layout = QGridLayout()
self.setLayout(layout)
self.plot1 = ImagePlot(self)
layout.addWidget(self.plot1, 0, 0, 1, 1)
self.plot2 = ImagePlot(self)
layout.addWidget(self.plot2, 1, 0, 1, 1)
self.contrast = ContrastAdjustment(self)
layout.addWidget(self.contrast, 2, 0, 1, 2)
self.itemlist = PlotItemList(self)
layout.addWidget(self.itemlist, 0, 1, 2, 1)
self.manager = PlotManager(self)
for plot in (self.plot1, self.plot2):
self.manager.add_plot(plot)
for panel in (self.itemlist, self.contrast):
self.manager.add_panel(panel)
def __init__(self,
name,
instanceId,
widgetList,
dataFunc,
inactivityTimeout=True):
dspWidget.__init__(self,
name,
instanceId,
widgetList,
inactivityTimeout=inactivityTimeout)
self.dataFunc = dataFunc
self.Fs = 2000
layout = QGridLayout()
self.setLayout(layout)
self.refPlotW = dspCurveWidget(title="Reference PCM",
color=1,
show_itemlist=False)
layout.addWidget(self.refPlotW, 0, 0, 1, 1)
self.micPlotW = dspCurveWidget(title="MIC PCM",
color=2,
show_itemlist=False)
layout.addWidget(self.micPlotW, 0, 1, 1, 1)
self.coefPlotW = dspCurveWidget(title="Secondary Path Response",
mode="Freq",
show_buttons=True,
show_itemlist=False)
self.coefPlotW.customCurve = self.updateFilterCurve
self.coefPlotW.plotPoints = 512
layout.addWidget(self.coefPlotW, 1, 0, 1, 2)
self.numberofsamples = QLabel("samples")
layout.addWidget(self.numberofsamples, 2, 2, 1, 1)
self.samples = QLabel("samples")
layout.addWidget(self.samples, 2, 3, 1, 1)
self.Button = QPushButton("Phase (degrees)")
layout.addWidget(self.Button, 1, 2, 1, 1)
self.connect(self.Button, SIGNAL('clicked()'), self.ButtonPressed)
self.flag = False
self.refPlotW.BriefAnalysis.hide()
self.micPlotW.BriefAnalysis.hide()
self.coefPlotW.BriefAnalysis.hide()
self.refPlotW.update_box.hide()
self.micPlotW.update_box.hide()
self.coefPlotW.update_box.hide()
self.refPlotW.update_box1.hide()
self.micPlotW.update_box1.hide()
self.coefPlotW.update_box1.hide()
self.refPlotW.Performance_config.hide()
self.micPlotW.Performance_config.hide()
self.coefPlotW.Performance_config.hide()
self.refPlotW.Performance_off.hide()
self.micPlotW.Performance_off.hide()
self.coefPlotW.Performance_off.hide()
self.refPlotW.samples_label.hide()
self.micPlotW.samples_label.hide()
self.coefPlotW.samples_label.hide()
class Window(QMainWindow):
def __init__(self, wintitle):
super(Window, self).__init__()
self.default_tool = None
self.plots = []
self.itemlist = PlotItemList(None)
self.contrast = ContrastAdjustment(None)
self.xcsw = XCrossSection(None)
self.ycsw = YCrossSection(None)
self.manager = PlotManager(self)
self.toolbar = QToolBar(_("Tools"), self)
self.manager.add_toolbar(self.toolbar, "default")
self.toolbar.setMovable(True)
self.toolbar.setFloatable(True)
self.addToolBar(Qt.TopToolBarArea, self.toolbar)
frame = QFrame(self)
self.setCentralWidget(frame)
self.layout = QGridLayout()
layout = QVBoxLayout(frame)
frame.setLayout(layout)
layout.addLayout(self.layout)
self.frame = frame
self.setWindowTitle(wintitle)
self.setWindowIcon(get_icon('guiqwt.svg'))
def closeEvent(self, event):
global _figures, _current_fig, _current_axes
figure_title = to_text_string(self.windowTitle())
if _figures.pop(figure_title) == _current_fig:
_current_fig = None
_current_axes = None
self.itemlist.close()
self.contrast.close()
self.xcsw.close()
self.ycsw.close()
event.accept()
def add_plot(self, i, j, plot):
self.layout.addWidget(plot, i, j)
self.manager.add_plot(plot)
self.plots.append(plot)
def replot(self):
for plot in self.plots:
plot.replot()
item = plot.get_default_item()
if item is not None:
plot.set_active_item(item)
item.unselect()
def add_panels(self, images=False):
self.manager.add_panel(self.itemlist)
if images:
for panel in (self.ycsw, self.xcsw, self.contrast):
panel.hide()
self.manager.add_panel(panel)
def register_tools(self, images=False):
if images:
self.manager.register_all_image_tools()
else:
self.manager.register_all_curve_tools()
def display(self):
self.show()
self.replot()
self.manager.get_default_tool().activate()
self.manager.update_tools_status()
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)
class CurveWidgetMixin(PlotManager):
def __init__(self,
wintitle="guiqwt plot",
icon="guiqwt.svg",
toolbar=False,
options=None,
panels=None):
PlotManager.__init__(self, main=self)
self.plot_layout = QGridLayout()
if options is None:
options = {}
self.plot_widget = None
self.create_plot(options)
if panels is not None:
for panel in panels:
self.add_panel(panel)
self.toolbar = QToolBar(_("Tools"))
if not toolbar:
self.toolbar.hide()
# Configuring widget layout
self.setup_widget_properties(wintitle=wintitle, icon=icon)
self.setup_widget_layout()
# Configuring plot manager
self.add_toolbar(self.toolbar, "default")
self.register_tools()
def setup_widget_layout(self):
raise NotImplementedError
def setup_widget_properties(self, wintitle, icon):
self.setWindowTitle(wintitle)
if is_text_string(icon):
icon = get_icon(icon)
if icon is not None:
self.setWindowIcon(icon)
self.setMinimumSize(320, 240)
self.resize(640, 480)
def register_tools(self):
"""
Register the plotting dialog box tools: the base implementation
provides standard, curve-related and other tools - i.e. calling
this method is exactly the same as calling
:py:meth:`guiqwt.plot.CurveDialog.register_all_curve_tools`
This method may be overriden to provide a fully customized set of tools
"""
self.register_all_curve_tools()
def create_plot(self, options):
"""
Create the plotting widget (which is an instance of class
:py:class:`guiqwt.plot.BaseCurveWidget`), add it to the dialog box
main layout (:py:attr:`guiqwt.plot.CurveDialog.plot_layout`) and
then add the `item list` panel
May be overriden to customize the plot layout
(:py:attr:`guiqwt.plot.CurveDialog.plot_layout`)
"""
self.plot_widget = BaseCurveWidget(self, **options)
self.plot_layout.addWidget(self.plot_widget, 0, 0)
# Configuring plot manager
self.add_plot(self.plot_widget.plot)
self.add_panel(self.plot_widget.itemlist)
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 __init__(self, name, instanceId, widgetList, dataFunc, inactivityTimeout = True):
dspWidget.__init__(self, name, instanceId, widgetList, inactivityTimeout = inactivityTimeout)
self.dataFunc = dataFunc
self.Fs = 2000
layout = QGridLayout()
self.setLayout(layout)
self.resize(1024, 800)
self.refPlotW = dspCurveWidget(mode="Freq",title="Reference PCM", show_itemlist=False)
layout.addWidget(self.refPlotW, 1, 1, 1, 1)
self.refExitButton = QPushButton("Hide")
layout.addWidget(self.refExitButton, 1,0,1,1)
self.connect(self.refExitButton, SIGNAL('clicked()'), self.refExitButtonPressed)
self.errPlotW = dspCurveWidget(mode="Freq",title="Error Mic PCM", show_itemlist=False)
layout.addWidget(self.errPlotW, 2, 1, 1, 1)
self.errExitButton = QPushButton("Hide")
layout.addWidget(self.errExitButton, 2,0,1,1)
self.connect(self.errExitButton, SIGNAL('clicked()'), self.errExitButtonPressed)
self.outPlotW = dspCurveWidget(mode="Freq",title="ANC Output", show_itemlist=False)
layout.addWidget(self.outPlotW, 3, 1, 1, 1)
self.outExitButton = QPushButton("Hide")
layout.addWidget(self.outExitButton, 3,0,1,1)
self.connect(self.outExitButton, SIGNAL('clicked()'), self.outExitButtonPressed)
self.coefPlotW = dspCurveWidget(title="ANC Filter", mode="Freq", show_buttons=False, show_itemlist=True)
self.coefPlotW.customCurve = self.updateFilterCurve
self.coefPlotW.plotPoints = 1024
layout.addWidget(self.coefPlotW, 4, 1, 1, 1)
self.coefExitButton = QPushButton("Hide")
layout.addWidget(self.coefExitButton, 4,0,1,1)
self.connect(self.coefExitButton, SIGNAL('clicked()'), self.coefExitButtonPressed)
class CurveWidgetMixin(PlotManager):
def __init__(self, wintitle="guiqwt plot", icon="guiqwt.svg",
toolbar=False, options=None, panels=None):
PlotManager.__init__(self, main=self)
self.plot_layout = QGridLayout()
if options is None:
options = {}
self.plot_widget = None
self.create_plot(options)
if panels is not None:
for panel in panels:
self.add_panel(panel)
self.toolbar = QToolBar(_("Tools"))
if not toolbar:
self.toolbar.hide()
# Configuring widget layout
self.setup_widget_properties(wintitle=wintitle, icon=icon)
self.setup_widget_layout()
# Configuring plot manager
self.add_toolbar(self.toolbar, "default")
self.register_tools()
def setup_widget_layout(self):
raise NotImplementedError
def setup_widget_properties(self, wintitle, icon):
self.setWindowTitle(wintitle)
if is_text_string(icon):
icon = get_icon(icon)
if icon is not None:
self.setWindowIcon(icon)
self.setMinimumSize(320, 240)
self.resize(640, 480)
def register_tools(self):
"""
Register the plotting dialog box tools: the base implementation
provides standard, curve-related and other tools - i.e. calling
this method is exactly the same as calling
:py:meth:`guiqwt.plot.CurveDialog.register_all_curve_tools`
This method may be overriden to provide a fully customized set of tools
"""
self.register_all_curve_tools()
def create_plot(self, options, row=0, column=0, rowspan=1, columnspan=1):
"""
Create the plotting widget (which is an instance of class
:py:class:`guiqwt.plot.BaseCurveWidget`), add it to the dialog box
main layout (:py:attr:`guiqwt.plot.CurveDialog.plot_layout`) and
then add the `item list` panel
May be overriden to customize the plot layout
(:py:attr:`guiqwt.plot.CurveDialog.plot_layout`)
"""
self.plot_widget = BaseCurveWidget(self, **options)
self.plot_layout.addWidget(self.plot_widget,
row, column, rowspan, columnspan)
# Configuring plot manager
self.add_plot(self.plot_widget.plot)
self.add_panel(self.plot_widget.itemlist)
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)
class dspPcmWidget(dspWidget):
def __init__(self, name, instanceId, widgetList, dataFunc, inactivityTimeout = True):
dspWidget.__init__(self, name, instanceId, widgetList, inactivityTimeout = inactivityTimeout)
self.dataFunc = dataFunc
self.Fs = 2000
self.sample_rate = 5333
self.pascal_constant=2*10**-5
self.pcm =[]
self.layout = QGridLayout()
self.setLayout(self.layout)
self.pcmPlotW = dspCurveWidget(title="Monitor Mic Data", show_itemlist=False)
self.layout.addWidget(self.pcmPlotW, 1, 0, 1, 1)
self.resize(1000, 300)
self.Button1 = QPushButton("Level")
self.layout.addWidget(self.Button1, 1,1,1,1)
self.connect(self.Button1, SIGNAL('clicked()'), self.Button1Pressed)
def A_weighting(self, fs):
f1 = 20.598997
f2 = 107.65265
f3 = 737.86223
f4 = 12194.217
A1000 = 1.9997
NUMs = [(2*pi * f4)**2 * (10**(A1000/20)), 0, 0, 0, 0]
DENs = polymul([1, 4*pi * f4, (2*pi * f4)**2],
[1, 4*pi * f1, (2*pi * f1)**2])
DENs = polymul(polymul(DENs, [1, 2*pi * f3]),
[1, 2*pi * f2])
return bilinear(NUMs, DENs, fs)
def C_weighting(self, fs):
f1 = 20.598997
f4 = 12194.217
C1000 = 0.0619
NUMs = [(2*pi*f4)**2*(10**(C1000/20.0)),0,0]
DENs = polymul([1,4*pi*f4,(2*pi*f4)**2.0],[1,4*pi*f1,(2*pi*f1)**2])
return bilinear(NUMs,DENs,fs)
def properties(self, signal, samplerate):
signal_level = self.ac_rms(signal)
weighted = self.A_weight(signal, samplerate)
weighted1= self.C_weight(signal, samplerate)
weighted_level = self.ac_rms(weighted)
weighted_level1= self.ac_rms(weighted1)
return [
'RMS level: %.3f (%.3f dB SPL)' % (signal_level, self.dB(signal_level)+10),
'A-weighted: %.3f (%.3f dB(A))' % (weighted_level, self.dB(weighted_level)+10),
'C-weighted: %.3f (%.3f dB(C))' % (weighted_level1, self.dB(weighted_level1)+10)
#'A-difference: %.3f dB' % self.dB(weighted_level/signal_level),
#'-----------------',
]
def ac_rms(self, signal):
return self.rms_flat(signal - mean(signal))
def rms_flat(self, a):
return np.sqrt(np.mean(np.absolute(a)**2))
def dB(self, level):
return 20 * log10(self.rms_flat(level)/self.pascal_constant)
def A_weight(self, signal, samplerate):
B, A = self.A_weighting(samplerate)
return lfilter(B, A, signal)
def C_weight(self, signal, samplerate):
B, A = self.C_weighting(samplerate)
return lfilter(B, A, signal)
def Button1Pressed(self):
elements = np.asarray(self.pcm)
rms_pcm = np.sqrt(np.mean(elements**2))
dB = 20*scipy.log10(np.abs(rms_pcm/self.pascal_constant))
#print (str(dB)+" "+'dB SPL')
Sound_properties = self.properties(elements, self.sample_rate)
print colored("Sound Properties:", 'yellow')
print colored(Sound_properties[0], 'yellow')
print colored(Sound_properties[1], 'yellow')
print colored(Sound_properties[2], 'yellow')
#print colored(Sound_properties[3], 'blue')
def update(self):
try:
data = self.dataFunc(self.instanceId, self.preferredSamples)
except RuntimeError:
return
channels = data.get('chn')
blockSize = data.get('frm')
self.pcm = data.get('pcm')
#elements = np.asarray(pcm)
#this will calculate the signal to noise ratio of monitor microphone placed in the point of interest(in between two micrphones)
#snr = scipy.stats.signaltonoise(elements)
#extracting list of pcm data into another list with two elements for taking first element and use for that finding rms value
#two_elements=[pcm[2*i:2*i+2] for i in range(int(0),int(math.ceil(len(pcm)/2.0)))]
# Conditional to keep backwards compatibility with old SPI logs.
Fs = data.get('Fs') if (data.get('Fs') != 0) else self.Fs
if Fs == 96:
Fs = 96000
self.sample_rate= Fs
samples = len(self.pcm) / channels
self.pcmPlotW.update(Fs, channels, blockSize, samples, self.pcm)
#self.updatesamples(str(samples))
def rescale(self):
self.pcmPlotW.rescale()
class Window(QMainWindow):
def __init__(self, wintitle):
super(Window, self).__init__()
self.default_tool = None
self.plots = []
self.itemlist = PlotItemList(None)
self.contrast = ContrastAdjustment(None)
self.xcsw = XCrossSection(None)
self.ycsw = YCrossSection(None)
self.manager = PlotManager(self)
self.toolbar = QToolBar(_("Tools"), self)
self.manager.add_toolbar(self.toolbar, "default")
self.toolbar.setMovable(True)
self.toolbar.setFloatable(True)
self.addToolBar(Qt.TopToolBarArea, self.toolbar)
frame = QFrame(self)
self.setCentralWidget(frame)
self.layout = QGridLayout()
layout = QVBoxLayout(frame)
frame.setLayout(layout)
layout.addLayout(self.layout)
self.frame = frame
self.setWindowTitle(wintitle)
self.setWindowIcon(get_icon('guiqwt.svg'))
def closeEvent(self, event):
global _figures, _current_fig, _current_axes
figure_title = to_text_string(self.windowTitle())
if _figures.pop(figure_title) == _current_fig:
_current_fig = None
_current_axes = None
self.itemlist.close()
self.contrast.close()
self.xcsw.close()
self.ycsw.close()
event.accept()
def add_plot(self, i, j, plot):
self.layout.addWidget(plot, i, j)
self.manager.add_plot(plot)
self.plots.append(plot)
def replot(self):
for plot in self.plots:
plot.replot()
item = plot.get_default_item()
if item is not None:
plot.set_active_item(item)
item.unselect()
def add_panels(self, images=False):
self.manager.add_panel(self.itemlist)
if images:
for panel in (self.ycsw, self.xcsw, self.contrast):
panel.hide()
self.manager.add_panel(panel)
def register_tools(self, images=False):
if images:
self.manager.register_all_image_tools()
else:
self.manager.register_all_curve_tools()
def display(self):
self.show()
self.replot()
self.manager.get_default_tool().activate()
self.manager.update_tools_status()
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)
