def create_plot(self):
self.stream_scroll = pg.PlotWidget(title='Stream Monitor')
if not self.parent.daisy_entry.currentIndex():
self.channel_count = 16
self.buffer_size = 1000
samples = 125
self.stream_scroll.setYRange(-.5,16,padding=.01)
else:
self.channel_count = 8
samples = 250
self.buffer_size = 2000
self.stream_scroll.setYRange(-.5,8,padding=.01)
self.stream_scroll_time_axis = np.linspace(-5,0,samples)
self.stream_scroll.setXRange(-5,0, padding=.01)
self.stream_scroll.setLabel('bottom','Time','Seconds')
self.stream_scroll.setLabel('left','Channel')
for i in range(self.channel_count-1,-1,-1):
self.data_buffer['buffer_channel{}'.format(i+1)] = deque([0]*self.buffer_size)
self.filtered_data['filtered_channel{}'.format(i+1)] = deque([0]*samples)
self.curves['curve_channel{}'.format(i+1)] = self.stream_scroll.plot()
self.curves['curve_channel{}'.format(i+1)].setData(x=self.stream_scroll_time_axis,y=([point+i+1 for point in self.filtered_data['filtered_channel{}'.format(i+1)]]))
self.set_layout()
python类PlotWidget()的实例源码
def test_getViewWidget_deleted():
view = pg.PlotWidget()
item = pg.InfiniteLine()
view.addItem(item)
assert item.getViewWidget() is view
# Arrange to have Qt automatically delete the view widget
obj = pg.QtGui.QWidget()
view.setParent(obj)
del obj
gc.collect()
assert not pg.Qt.isQObjectAlive(view)
assert item.getViewWidget() is None
#if __name__ == '__main__':
#view = pg.PlotItem()
#vref = weakref.ref(view)
#item = pg.InfiniteLine()
#view.addItem(item)
#del view
#gc.collect()
def test_PlotWidget():
def mkobjs(*args, **kwds):
w = pg.PlotWidget(*args, **kwds)
data = pg.np.array([1,5,2,4,3])
c = w.plot(data, name='stuff')
w.addLegend()
# test that connections do not keep objects alive
w.plotItem.vb.sigRangeChanged.connect(mkrefs)
app.focusChanged.connect(w.plotItem.vb.invertY)
# return weakrefs to a bunch of objects that should die when the scope exits.
return mkrefs(w, c, data, w.plotItem, w.plotItem.vb, w.plotItem.getMenu(), w.plotItem.getAxis('left'))
for i in range(5):
assert_alldead(mkobjs())
def test_getViewWidget_deleted():
view = pg.PlotWidget()
item = pg.InfiniteLine()
view.addItem(item)
assert item.getViewWidget() is view
# Arrange to have Qt automatically delete the view widget
obj = pg.QtGui.QWidget()
view.setParent(obj)
del obj
gc.collect()
assert not pg.Qt.isQObjectAlive(view)
assert item.getViewWidget() is None
#if __name__ == '__main__':
#view = pg.PlotItem()
#vref = weakref.ref(view)
#item = pg.InfiniteLine()
#view.addItem(item)
#del view
#gc.collect()
def test_PlotWidget():
def mkobjs(*args, **kwds):
w = pg.PlotWidget(*args, **kwds)
data = pg.np.array([1,5,2,4,3])
c = w.plot(data, name='stuff')
w.addLegend()
# test that connections do not keep objects alive
w.plotItem.vb.sigRangeChanged.connect(mkrefs)
app.focusChanged.connect(w.plotItem.vb.invertY)
# return weakrefs to a bunch of objects that should die when the scope exits.
return mkrefs(w, c, data, w.plotItem, w.plotItem.vb, w.plotItem.getMenu(), w.plotItem.getAxis('left'))
for i in range(5):
assert_alldead(mkobjs())
def initplotKline(self):
"""Kline"""
self.pw2 = pg.PlotWidget(name='Plot2') # K??
self.vbl_2.addWidget(self.pw2)
self.pw2.setDownsampling(mode='peak')
self.pw2.setClipToView(True)
self.curve5 = self.pw2.plot()
self.curve6 = self.pw2.plot()
self.candle = self.CandlestickItem(self.listBar)
self.pw2.addItem(self.candle)
## Draw an arrowhead next to the text box
# self.arrow = pg.ArrowItem()
# self.pw2.addItem(self.arrow)
#----------------------------------------------------------------------
def removeCurve(self,plot,curve):
"""
Remove a curve from a plot
.. tabularcolumns:: |p{3cm}|p{11cm}|
=============== ============================================================================================
**Arguments**
=============== ============================================================================================
plot pyqtgraph.PlotWidget created using :func:`add2DPlot`
name pyqtgraph.PlotDataItem created for the specified plot using :func:`addCurve`
=============== ============================================================================================
"""
plot.removeItem(curve)
try:
self.plots2D[plot].pop(self.plots2D[plot].index(curve))
except:
pass
def __init__(self, plot, parent=None):
QtGui.QDialog.__init__(self, parent)
loadUi(get_resource('transect.ui'), baseinstance=self)
pxmap = self.style().standardPixmap
self.closeButton.setIcon(
pxmap(QtGui.QStyle.SP_DialogCloseButton))
self.createButton.setIcon(
pxmap(QtGui.QStyle.SP_ArrowUp))
self.removeButton.setIcon(
pxmap(QtGui.QStyle.SP_DialogDiscardButton))
self.plot = plot
self.poly_line = None
self.trans_plot = pg.PlotDataItem(
antialias=True,
fillLevel=0.,
fillBrush=pg.mkBrush(0, 127, 0, 150))
self.plt_wdgt = pg.PlotWidget()
self.plt_wdgt.setLabels(
bottom={'Distance', 'm'},
left='Displacement [m]')
self.plt_wdgt.showGrid(True, True, alpha=.5)
self.plt_wdgt.enableAutoRange()
self.plt_wdgt.addItem(self.trans_plot)
self.layoutPlot.addWidget(self.plt_wdgt)
self.plot.image.sigImageChanged.connect(self.updateTransPlot)
self.createButton.released.connect(self.addPolyLine)
self.removeButton.released.connect(self.removePolyLine)
parent.model.sigConfigChanged.connect(self.close)
def test_init_spots():
plot = pg.PlotWidget()
# set view range equal to its bounding rect.
# This causes plots to look the same regardless of pxMode.
plot.setRange(rect=plot.boundingRect())
spots = [
{'x': 0, 'y': 1},
{'pos': (1, 2), 'pen': None, 'brush': None, 'data': 'zzz'},
]
s = pg.ScatterPlotItem(spots=spots)
# Check we can display without errors
plot.addItem(s)
app.processEvents()
plot.clear()
# check data is correct
spots = s.points()
defPen = pg.mkPen(pg.getConfigOption('foreground'))
assert spots[0].pos().x() == 0
assert spots[0].pos().y() == 1
assert spots[0].pen() == defPen
assert spots[0].data() is None
assert spots[1].pos().x() == 1
assert spots[1].pos().y() == 2
assert spots[1].pen() == pg.mkPen(None)
assert spots[1].brush() == pg.mkBrush(None)
assert spots[1].data() == 'zzz'
def test_getViewWidget():
view = pg.PlotWidget()
vref = weakref.ref(view)
item = pg.InfiniteLine()
view.addItem(item)
assert item.getViewWidget() is view
del view
gc.collect()
assert vref() is None
assert item.getViewWidget() is None
def test_init_spots():
plot = pg.PlotWidget()
# set view range equal to its bounding rect.
# This causes plots to look the same regardless of pxMode.
plot.setRange(rect=plot.boundingRect())
spots = [
{'x': 0, 'y': 1},
{'pos': (1, 2), 'pen': None, 'brush': None, 'data': 'zzz'},
]
s = pg.ScatterPlotItem(spots=spots)
# Check we can display without errors
plot.addItem(s)
app.processEvents()
plot.clear()
# check data is correct
spots = s.points()
defPen = pg.mkPen(pg.getConfigOption('foreground'))
assert spots[0].pos().x() == 0
assert spots[0].pos().y() == 1
assert spots[0].pen() == defPen
assert spots[0].data() is None
assert spots[1].pos().x() == 1
assert spots[1].pos().y() == 2
assert spots[1].pen() == pg.mkPen(None)
assert spots[1].brush() == pg.mkBrush(None)
assert spots[1].data() == 'zzz'
def test_getViewWidget():
view = pg.PlotWidget()
vref = weakref.ref(view)
item = pg.InfiniteLine()
view.addItem(item)
assert item.getViewWidget() is view
del view
gc.collect()
assert vref() is None
assert item.getViewWidget() is None
def initplotTick(self):
"""Tick"""
self.pw1 = pg.PlotWidget(name='Plot1')
self.vbl_1.addWidget(self.pw1)
self.pw1.setRange(xRange=[-360, 0])
self.pw1.setLimits(xMax=5)
self.pw1.setDownsampling(mode='peak')
self.pw1.setClipToView(True)
self.curve1 = self.pw1.plot()
self.curve2 = self.pw1.plot()
self.curve3 = self.pw1.plot()
self.curve4 = self.pw1.plot()
#----------------------------------------------------------------------
def initplotTendency(self):
"""???"""
self.pw3 = pg.PlotWidget(name='Plot3')
self.vbl_2.addWidget(self.pw3)
self.pw3.setDownsampling(mode='peak')
self.pw3.setClipToView(True)
self.pw3.setMaximumHeight(200)
self.pw3.setXLink('Plot2') # X linked with Plot2
self.curve7 = self.pw3.plot()
#----------------------------------------------------------------------
def initplotKline(self):
"""Kline"""
self.widgetDict['D'].pw = pg.PlotWidget(name='PlotD') # K??
self.widgetDict['D'].vbl.addWidget(self.widgetDict['D'].pw)
self.widgetDict['D'].pw.setDownsampling(mode='peak')
self.widgetDict['D'].pw.setClipToView(True)
self.widgetDict['D'].candle = CandlestickItem(self.listBar)
self.widgetDict['D'].pw.addItem(self.widgetDict['D'].candle)
#----------------------------------------------------------------------
def setupUi(self, CustomWidget):
CustomWidget.setObjectName(_fromUtf8("CustomWidget"))
CustomWidget.resize(400, 300)
self.gridLayout = QtGui.QGridLayout(CustomWidget)
self.gridLayout.setObjectName(_fromUtf8("gridLayout"))
self.plotWidget = PlotWidget(CustomWidget)
self.plotWidget.setObjectName(_fromUtf8("plotWidget"))
self.gridLayout.addWidget(self.plotWidget, 0, 0, 1, 1)
self.checkBox = QtGui.QCheckBox(CustomWidget)
self.checkBox.setChecked(True)
self.checkBox.setObjectName(_fromUtf8("checkBox"))
self.gridLayout.addWidget(self.checkBox, 1, 0, 1, 1)
self.retranslateUi(CustomWidget)
QtCore.QMetaObject.connectSlotsByName(CustomWidget)
def setColorSchemeWhite(self):
"""
Set the plot background to white . This will also automatically change trace colours.
"""
self.properties['colorScheme']='white'
for plot in self.plots2D:
try:
plot.setBackground((252,252,245, 255))
except:
pass
for a in ['left','bottom','right']:
try:
axis = plot.getAxis(a)
axis.setPen('k')
except:
pass
n=0
if isinstance(plot, pg.widgets.PlotWidget.PlotWidget): #Only consider curves part of the main left axis
for c in self.plots2D[plot]: #Change curve colors to match white background
c.setPen(color=self.white_trace_colors[n], width=3)
n+=1
if(n==54):break
try:
for d in self.plots2D[plot].viewBoxes: #Go through the additional axes too
for f in self.plots2D[d]:
f.setPen(color=self.white_trace_colors[n], width=3)
n+=1
if(n==54):break
except: pass
try:
for d in plot.axisItems: #Go through any additional axes, and set colors there too
d.setPen('k')
except Exception as ex: print ('error while changing scheme',ex)
def add2DPlot(self,plot_area,**args):
"""
Add a 2D plot to a specified Qt Layout
.. tabularcolumns:: |p{3cm}|p{11cm}|
=============== ============================================================================================
**Arguments**
=============== ============================================================================================
plot_area QtGui.<some layout> to add a 2D plot to
=============== ============================================================================================
:return: pyqtgraph.PlotWidget
"""
plot=pg.PlotWidget(**args)
plot.setMinimumHeight(250)
plot_area.addWidget(plot)
plot.getAxis('left').setGrid(170)
plot.getAxis('bottom').setGrid(170)
plot.viewBoxes=[]
plot.axisItems=[]
self.plots2D[plot]=[]
if self.properties['colorScheme']=='white':
self.setColorSchemeWhite()
return plot
def addAxis(self,plot,**args):
"""
Add an axis on the right side
.. tabularcolumns:: |p{3cm}|p{11cm}|
=============== ============================================================================================
**Arguments**
=============== ============================================================================================
plot pyqtgraph.PlotWidget
*args
1. label Label of the new axis
=============== ============================================================================================
:return: pg.ViewBox
"""
p3 = pg.ViewBox()
ax3 = pg.AxisItem('right')
plot.plotItem.layout.addItem(ax3, 2, 3+len(plot.axisItems))
plot.plotItem.scene().addItem(p3)
ax3.linkToView(p3)
p3.setXLink(plot.plotItem)
ax3.setZValue(-10000)
if args.get('label',False):
ax3.setLabel(args.get('label',False), color=args.get('color','#ffffff'))
p3.setGeometry(plot.plotItem.vb.sceneBoundingRect())
p3.linkedViewChanged(plot.plotItem.vb, p3.XAxis)
## Handle view resizing
Callback = functools.partial(self.updateViews,plot)
plot.getViewBox().sigStateChanged.connect(Callback)
plot.viewBoxes.append(p3)
plot.axisItems.append(ax3)
self.plots2D[p3]=[] # TODO do not consider a new axis as a plot. simply make it a part of the axisItems array of the main plot
return p3
def __init__(self, data, title=None):
PgDataPlot.__init__(self, data)
self.dim = self._data[0].output_data.shape
self.win = pg.QtGui.QMainWindow()
self.win.resize(800, 800)
self.win.setWindowTitle("PgSlicePlot: {}".format(title))
self.cw = pg.QtGui.QWidget()
self.win.setCentralWidget(self.cw)
self.l = pg.QtGui.QGridLayout()
self.cw.setLayout(self.l)
self.image_view = pg.ImageView(name="img_view")
self.l.addWidget(self.image_view, 0, 0)
self.slice_view = pg.PlotWidget(name="slice")
self.l.addWidget(self.slice_view)
self.win.show()
# self.imv2 = pg.ImageView()
# self.l.addWidget(self.imv2, 1, 0)
self.roi = pg.LineSegmentROI([[0, self.dim[1] - 1], [self.dim[0] - 1, self.dim[1] - 1]], pen='r')
self.image_view.addItem(self.roi)
self.image_view.setImage(self._data[0].output_data)
#
# self.plot_window.showGrid(x=True, y=True, alpha=.5)
# self.plot_window.addLegend()
#
# input_idx = 0 if self.data_slice.shape[0] > self.data_slice.shape[1] else 0
# for data_set in data:
# self.plot_window.plot(data_set.input_data[input_idx], data_set.output_data[self.data_slice],
# name=data.name)
# TODO: alpha
def setupUi(self, MainWindow):
MainWindow.setObjectName(_fromUtf8("MainWindow"))
MainWindow.resize(993, 692)
self.centralwidget = QtGui.QWidget(MainWindow)
self.centralwidget.setObjectName(_fromUtf8("centralwidget"))
self.horizontalLayout = QtGui.QHBoxLayout(self.centralwidget)
self.horizontalLayout.setObjectName(_fromUtf8("horizontalLayout"))
self.pbLevel = QtGui.QProgressBar(self.centralwidget)
self.pbLevel.setMaximum(1000)
self.pbLevel.setProperty("value", 123)
self.pbLevel.setTextVisible(False)
self.pbLevel.setOrientation(QtCore.Qt.Vertical)
self.pbLevel.setObjectName(_fromUtf8("pbLevel"))
self.horizontalLayout.addWidget(self.pbLevel)
self.frame = QtGui.QFrame(self.centralwidget)
self.frame.setFrameShape(QtGui.QFrame.NoFrame)
self.frame.setFrameShadow(QtGui.QFrame.Plain)
self.frame.setObjectName(_fromUtf8("frame"))
self.verticalLayout = QtGui.QVBoxLayout(self.frame)
self.verticalLayout.setMargin(0)
self.verticalLayout.setObjectName(_fromUtf8("verticalLayout"))
self.label = QtGui.QLabel(self.frame)
self.label.setObjectName(_fromUtf8("label"))
self.verticalLayout.addWidget(self.label)
self.grFFT = PlotWidget(self.frame)
self.grFFT.setObjectName(_fromUtf8("grFFT"))
self.verticalLayout.addWidget(self.grFFT)
self.label_2 = QtGui.QLabel(self.frame)
self.label_2.setObjectName(_fromUtf8("label_2"))
self.verticalLayout.addWidget(self.label_2)
self.grPCM = PlotWidget(self.frame)
self.grPCM.setObjectName(_fromUtf8("grPCM"))
self.verticalLayout.addWidget(self.grPCM)
self.horizontalLayout.addWidget(self.frame)
MainWindow.setCentralWidget(self.centralwidget)
self.retranslateUi(MainWindow)
QtCore.QMetaObject.connectSlotsByName(MainWindow)
def setupUi(self, MainWindow):
MainWindow.setObjectName(_fromUtf8("MainWindow"))
MainWindow.resize(820, 650)
MainWindow.setAutoFillBackground(False)
MainWindow.setDocumentMode(False)
self.centralwidget = QtGui.QWidget(MainWindow)
self.centralwidget.setObjectName(_fromUtf8("centralwidget"))
self.verticalLayout = QtGui.QVBoxLayout(self.centralwidget)
self.verticalLayout.setObjectName(_fromUtf8("verticalLayout"))
self.horizontalLayout = QtGui.QHBoxLayout()
self.horizontalLayout.setContentsMargins(-1, -1, 0, 0)
self.horizontalLayout.setSpacing(10)
self.horizontalLayout.setObjectName(_fromUtf8("horizontalLayout"))
self.btnAdd = QtGui.QPushButton(self.centralwidget)
self.btnAdd.setObjectName(_fromUtf8("btnAdd"))
self.horizontalLayout.addWidget(self.btnAdd)
self.chkMore = QtGui.QCheckBox(self.centralwidget)
self.chkMore.setObjectName(_fromUtf8("chkMore"))
self.horizontalLayout.addWidget(self.chkMore)
self.verticalLayout.addLayout(self.horizontalLayout)
self.grPlot = PlotWidget(self.centralwidget)
self.grPlot.setObjectName(_fromUtf8("grPlot"))
self.verticalLayout.addWidget(self.grPlot)
MainWindow.setCentralWidget(self.centralwidget)
self.statusbar = QtGui.QStatusBar(MainWindow)
self.statusbar.setObjectName(_fromUtf8("statusbar"))
MainWindow.setStatusBar(self.statusbar)
self.retranslateUi(MainWindow)
QtCore.QMetaObject.connectSlotsByName(MainWindow)
def __init__(self, parent_plot):
QtGui.QWidget.__init__(self)
self.parent_plot = parent_plot
self.model = parent_plot.model
self.plot = pg.PlotWidget(background='default')
self.plot.showGrid(True, True, alpha=.5)
self.plot.setMenuEnabled(False)
self.plot.enableAutoRange()
self.layout = QtGui.QVBoxLayout(self)
self.layout.addWidget(self.plot)
def test_scatterplotitem():
plot = pg.PlotWidget()
# set view range equal to its bounding rect.
# This causes plots to look the same regardless of pxMode.
plot.setRange(rect=plot.boundingRect())
for i, pxMode in enumerate([True, False]):
for j, useCache in enumerate([True, False]):
s = pg.ScatterPlotItem()
s.opts['useCache'] = useCache
plot.addItem(s)
s.setData(x=np.array([10,40,20,30])+i*100, y=np.array([40,60,10,30])+j*100, pxMode=pxMode)
s.addPoints(x=np.array([60, 70])+i*100, y=np.array([60, 70])+j*100, size=[20, 30])
# Test uniform spot updates
s.setSize(10)
s.setBrush('r')
s.setPen('g')
s.setSymbol('+')
app.processEvents()
# Test list spot updates
s.setSize([10] * 6)
s.setBrush([pg.mkBrush('r')] * 6)
s.setPen([pg.mkPen('g')] * 6)
s.setSymbol(['+'] * 6)
s.setPointData([s] * 6)
app.processEvents()
# Test array spot updates
s.setSize(np.array([10] * 6))
s.setBrush(np.array([pg.mkBrush('r')] * 6))
s.setPen(np.array([pg.mkPen('g')] * 6))
s.setSymbol(np.array(['+'] * 6))
s.setPointData(np.array([s] * 6))
app.processEvents()
# Test per-spot updates
spot = s.points()[0]
spot.setSize(20)
spot.setBrush('b')
spot.setPen('g')
spot.setSymbol('o')
spot.setData(None)
app.processEvents()
plot.clear()
def setColorSchemeBlack(self):
"""
Changes plot background to black. Also changes plot colours
"""
self.properties['colorScheme']='black'
for plot in self.plots2D:
try:
plot.setBackground((0,0,0,255))
except:
pass
for a in ['left','bottom','right']:
try:
axis = plot.getAxis(a)
axis.setPen('w')
except:
pass
n=0
if isinstance(plot, pg.widgets.PlotWidget.PlotWidget): #Only consider curves part of the main left axis
for c in self.plots2D[plot]: #Change curve colors to match black background
c.setPen(color=self.black_trace_colors[n], width=2)
n+=1
if(n==54):break
try:
for d in self.plots2D[plot].viewBoxes: #Go through the additional axes too
for f in self.plots2D[d]:
f.setPen(color=self.black_trace_colors[n], width=2)
n+=1
if(n==54):break
except: pass
try:
for d in plot.axisItems: #Go through any additional axes, and set colors there too
d.setPen('w')
except Exception as ex: print ('error while changing scheme',ex)
for c in self.plots2D[plot]: #Change curve colors to match black background
c.setPen(color=self.black_trace_colors[n], width=3)
n+=1
if(n==54):break
def create_plot(self, item):
"""
Creates a plot widget based on the given item.
If a plot for this item is already open no new plot is created but the
existing one is raised up again.
Args:
item(Qt.ListItem): Item to plot.
"""
title = str(item.text())
if title in self.non_plotting_docks:
self._logger.error("Title '{}' not allowed for a plot window since"
"it would shadow on of the reserved "
"names".format(title))
# check if plot has already been opened
if title in self.area.findAll()[1]:
self.area.docks[title].raiseDock()
return
# collect data
data = self._get_data_by_name(title)
t = self.currentDataset["results"]["time"]
unit = self._get_units(title)
if "." in title:
name = title.split(".")[1]
else:
name = title
# create plot widget
widget = pg.PlotWidget(title=title)
widget.showGrid(True, True)
widget.plot(x=t, y=data)
widget.getPlotItem().getAxis("bottom").setLabel(text="Time", units="s")
widget.getPlotItem().getAxis("left").setLabel(text=name, units=unit)
# add a time line
time_line = pg.InfiniteLine(self.playbackTime,
angle=90,
movable=False,
pen=pg.mkPen("#FF0000", width=2.0))
widget.getPlotItem().addItem(time_line)
# create dock container and add it to dock area
dock = pg.dockarea.Dock(title, closable=True)
dock.addWidget(widget)
self.area.addDock(dock, "above", self.plotDockPlaceholder)
def on_activate(self):
""" Definition and initialisation of the GUI.
"""
self._spectrum_logic = self.get_connector('spectrumlogic1')
# setting up the window
self._mw = SpectrometerWindow()
self._mw.stop_diff_spec_Action.setEnabled(False)
self._mw.resume_diff_spec_Action.setEnabled(False)
# giving the plots names allows us to link their axes together
self._pw = self._mw.plotWidget # pg.PlotWidget(name='Counter1')
self._plot_item = self._pw.plotItem
# create a new ViewBox, link the right axis to its coordinate system
self._right_axis = pg.ViewBox()
self._plot_item.showAxis('right')
self._plot_item.scene().addItem(self._right_axis)
self._plot_item.getAxis('right').linkToView(self._right_axis)
self._right_axis.setXLink(self._plot_item)
# create a new ViewBox, link the right axis to its coordinate system
self._top_axis = pg.ViewBox()
self._plot_item.showAxis('top')
self._plot_item.scene().addItem(self._top_axis)
self._plot_item.getAxis('top').linkToView(self._top_axis)
self._top_axis.setYLink(self._plot_item)
self._top_axis.invertX(b=True)
# handle resizing of any of the elements
self._pw.setLabel('left', 'Fluorescence', units='counts/s')
self._pw.setLabel('right', 'Number of Points', units='#')
self._pw.setLabel('bottom', 'Wavelength', units='nm')
self._pw.setLabel('top', 'Relative Frequency', units='Hz')
self._mw.rec_single_spectrum_Action.triggered.connect(self.record_single_spectrum)
self._mw.start_diff_spec_Action.triggered.connect(self.start_differential_measurement)
self._mw.stop_diff_spec_Action.triggered.connect(self.stop_differential_measurement)
self._mw.resume_diff_spec_Action.triggered.connect(self.resume_differential_measurement)
self._mw.save_spectrum_Action.triggered.connect(self.save_spectrum_data)
self._spectrum_logic.sig_specdata_updated.connect(self.updateData)
self._mw.show()
# Create an empty plot curve to be filled later, set its pen
self._curve1 = self._pw.plot()
self._curve1.setPen(palette.c2, width=2)
self._save_PNG = True
def on_activate(self):
""" Definition and initialisation of the GUI plus staring the measurement.
"""
self._laser_logic = self.get_connector('laserlogic')
#####################
# Configuring the dock widgets
# Use the inherited class 'CounterMainWindow' to create the GUI window
self._mw = LaserWindow()
# Setup dock widgets
self._mw.setDockNestingEnabled(True)
self._mw.actionReset_View.triggered.connect(self.restoreDefaultView)
# set up plot
self._mw.plotWidget = pg.PlotWidget(
axisItems={'bottom': TimeAxisItem(orientation='bottom')})
self._mw.pwContainer.layout().addWidget(self._mw.plotWidget)
plot1 = self._mw.plotWidget.getPlotItem()
plot1.setLabel('left', 'power', units='W', color=palette.c1.name())
plot1.setLabel('bottom', 'Time', units=None)
plot1.setLabel('right', 'Temperature', units='°C', color=palette.c3.name())
plot2 = pg.ViewBox()
plot1.scene().addItem(plot2)
plot1.getAxis('right').linkToView(plot2)
plot2.setXLink(plot1)
self.curves = {}
colorlist = (palette.c2, palette.c3, palette.c4, palette.c5, palette.c6)
i = 0
for name in self._laser_logic.data:
if name != 'time':
curve = pg.PlotDataItem()
if name == 'power':
curve.setPen(palette.c1)
plot1.addItem(curve)
else:
curve.setPen(colorlist[(2*i) % len(colorlist)])
plot2.addItem(curve)
self.curves[name] = curve
i += 1
self.plot1 = plot1
self.plot2 = plot2
self.updateViews()
self.plot1.vb.sigResized.connect(self.updateViews)
self.updateButtonsEnabled()
self._mw.laserButton.clicked.connect(self.changeLaserState)
self._mw.shutterButton.clicked.connect(self.changeShutterState)
self.sigLaser.connect(self._laser_logic.set_laser_state)
self.sigShutter.connect(self._laser_logic.set_shutter_state)
self.sigCurrent.connect(self._laser_logic.set_current)
self.sigPower.connect(self._laser_logic.set_power)
self.sigCtrlMode.connect(self._laser_logic.set_control_mode)
self._mw.controlModeButtonGroup.buttonClicked.connect(self.changeControlMode)
self.sliderProxy = pg.SignalProxy(self._mw.setValueVerticalSlider.valueChanged, 0.1, 5, self.updateFromSlider)
self._mw.setValueDoubleSpinBox.editingFinished.connect(self.updateFromSpinBox)
self._laser_logic.sigUpdate.connect(self.updateGui)
def __init__(self, model, los_arrow=False):
pg.PlotWidget.__init__(self)
self.model = model
self.draw_time = 0.
self._data = None
border_pen = pg.mkPen(255, 255, 255, 50)
self.image = pg.ImageItem(
None,
autoDownsample=False,
border=border_pen,
useOpenGL=True)
self.setAspectLocked(True)
self.plotItem.getAxis('left').setZValue(100)
self.plotItem.getAxis('bottom').setZValue(100)
self.setLabels(
bottom=('Easting', 'm'),
left=('Northing', 'm'))
self.hint = {
'east': 0.,
'north': 0.,
'value': num.nan,
'measure': self.component.title(),
'vlength': '03',
'precision': '3',
}
self.hint_text = pg.LabelItem(
text='',
justify='right', size='8pt',
parent=self.plotItem)
self.hint_text.anchor(
itemPos=(1., 0.),
parentPos=(1., 0.))
self.hint_text.text_template =\
'<span style="font-family: monospace; color: #fff;'\
'background-color: #000;">'\
'East {east:08.2f} m | North {north:08.2f} m | '\
'{measure} {value:{length}.{precision}f}</span>'
self.hint_text.setOpacity(.6)
self.addItem(self.image)
self.update()
self.transFromFrame()
self._move_sig = pg.SignalProxy(
self.image.scene().sigMouseMoved,
rateLimit=25, slot=self.mouseMoved)
if los_arrow:
self.addLOSArrow()
# self.addIsocurve()
# self.scalebar()
def __init__(self, *args, **kwargs):
super(PlotSubWindow, self).__init__(*args, **kwargs)
self._plots = []
self._dynamic_axis = None
self._plot_widget = None
self._plot_item = None
self._plots_units = None
self._rois = []
self._measure_rois = []
self._centroid_roi = None
self._is_selected = True
self._layer_items = []
self.disable_errors = False
self.disable_mask = True
dispatch.setup(self)
self._dynamic_axis = DynamicAxisItem(orientation='top')
self._plot_widget = pg.PlotWidget(
axisItems={'top': self._dynamic_axis})
# self.setCentralWidget(self._plot_widget)
self.vertical_layout.insertWidget(0, self._plot_widget)
self._plot_item = self._plot_widget.getPlotItem()
self._plot_item.showAxis('top', True)
# Add grids to the plot
self._plot_item.showGrid(True, True)
self._setup_connections()
self.linelists = []
# Initial color list for this sub window
self._available_colors = cycle(AVAILABLE_COLORS)
# Incorporate event filter
self.installEventFilter(self)
# Create a single vertical line object that can be used to indicate
# wavelength position
self._disp_line = pg.InfiniteLine(movable=True, pen={'color': 'g'})
self._plot_item.addItem(self._disp_line)
# When the user moves the dispersion vertical line, send an event
self._disp_line.sigPositionChanged.connect(lambda:
dispatch.change_dispersion_position.emit(
pos=self._disp_line.value()))
