def create_marker(self, marker_type, value=None):
slider = pg.InfiniteLine(pos=0.2,
movable=True,
label='',
labelOpts={
'position': 0.5,
'rotateAxis': (1, 0),
'anchor': (1, 1)
})
slider.sigPositionChangeFinished.connect(
lambda: self.perform_calculations(save=True))
if value:
slider.setValue(value)
if marker_type == 'notch_rest':
slider.label = pg.InfLineLabel(slider, text="Dicrotic notch")
self.plot_ensemble_rest.addItem(slider)
self.slider_notch_rest = slider
elif marker_type == 'notch_hyp':
slider.label = pg.InfLineLabel(slider, text="Dicrotic notch")
self.plot_ensemble_hyp.addItem(slider)
self.slider_notch_hyp = slider
elif marker_type == 'enddiastole_rest':
slider.label = pg.InfLineLabel(slider, text="End diastole")
self.plot_ensemble_rest.addItem(slider)
self.slider_enddiastole_rest = slider
elif marker_type == 'enddiastole_hyp':
slider.label = pg.InfLineLabel(slider, text="End diastole")
self.plot_ensemble_hyp.addItem(slider)
self.slider_enddiastole_hyp = slider
else:
raise ValueError(f"Unknown button type pressed: {marker_type}")
def _setup_plot(self):
# Get plot item and setup
self.plt = self.getPlotItem()
self.plt.setDownsampling(auto=True)
self.plt.setTitle(
type(self).
__name__ if self.daq_device is None else type(self).__name__ +
' ' + self.daq_device)
self.plt.setLabel('left', text='Proton fluence', units='cm^-2')
self.plt.setLabel('right', text='Neutron fluence', units='cm^-2')
self.plt.setLabel('bottom', text='Scan row')
self.plt.getAxis('right').setScale(self.irrad_setup['kappa'])
self.plt.getAxis('left').enableAutoSIPrefix(False)
self.plt.getAxis('right').enableAutoSIPrefix(False)
self.plt.setLimits(xMin=0, xMax=self.irrad_setup['n_rows'], yMin=0)
self.legend = pg.LegendItem(offset=(80, 80))
self.legend.setParentItem(self.plt)
# Histogram of fluence per row
hist_curve = pg.PlotCurveItem()
hist_curve.setFillLevel(0.33)
hist_curve.setBrush(pg.mkBrush(color=_MPL_COLORS[0]))
# Points at respective row positions
hist_points = pg.ScatterPlotItem()
hist_points.setPen(color=_MPL_COLORS[2], style=pg.QtCore.Qt.SolidLine)
hist_points.setBrush(color=_MPL_COLORS[2])
hist_points.setSymbol('o')
hist_points.setSize(10)
# Errorbars for points; needs to initialized with x, y args, otherwise cnnot be added to PlotItem
hist_errors = pg.ErrorBarItem(x=np.arange(1),
y=np.arange(1),
beam=0.25)
# Horizontal line indication the mean fluence over all rows
mean_curve = pg.InfiniteLine(angle=0)
mean_curve.setPen(color=_MPL_COLORS[1], width=2)
self.p_label = pg.InfLineLabel(mean_curve, position=0.2)
self.n_label = pg.InfLineLabel(mean_curve, position=0.8)
self.curves = OrderedDict([('hist', hist_curve),
('hist_points', hist_points),
('hist_errors', hist_errors),
('mean', mean_curve)])
# Show data and legend
for curve in self.curves:
self.show_data(curve)
def update_order(self, order: OrderData):
if order.status in (Status.NOTTRADED, Status.PARTTRADED):
line = self.order_lines[order.vt_orderid]
candle_plot = self.get_plot("candle")
if line not in candle_plot.items:
candle_plot.addItem(line)
line.setAngle(0)
line.label = pg.InfLineLabel(
line,
text=
f'{order.type.value}:{"↑" if order.direction == Direction.LONG else "↓"}{order.volume - order.traded}@{order.price}',
color='r' if order.direction == Direction.LONG else 'g')
line.setPen(
pg.mkPen(color=UP_COLOR
if order.direction == Direction.LONG else DOWN_COLOR,
width=PEN_WIDTH))
line.setHoverPen(
pg.mkPen(color=UP_COLOR
if order.direction == Direction.LONG else DOWN_COLOR,
width=PEN_WIDTH * 2))
line.setPos(order.price)
elif order.status in (Status.ALLTRADED, Status.CANCELLED,
Status.REJECTED):
if order.vt_orderid in self.order_lines:
line = self.order_lines[order.vt_orderid]
candle_plot = self.get_plot("candle")
candle_plot.removeItem(line)
def createPlot(self):
self.date_axis = CAxisTime(orientation='bottom')
self.plot = self.plotWidget.addPlot(row=0, col=0)
self.plot.mouseOver = False
self.plot.scene().installEventFilter(self)
nontimeaxisItems = {
'bottom': self.plot.axes['bottom']['item'],
'top': self.plot.axes['top']['item'],
'left': self.plot.axes['left']['item'],
'right': self.plot.axes['right']['item']
}
axisItems = {
'bottom': self.date_axis,
'top': self.plot.axes['top']['item'],
'left': self.plot.axes['left']['item'],
'right': self.plot.axes['right']['item']
}
self.plot.axes = {}
for k, pos in (('top', (1, 1)), ('bottom', (3, 1)), ('left', (2, 0)),
('right', (2, 2))):
if k in axisItems:
axis = axisItems[k]
axis.linkToView(self.plot.vb)
self.plot.axes[k] = {'item': axis, 'pos': pos}
self.plot.layout.removeItem(self.plot.layout.itemAt(*pos))
self.plot.layout.addItem(axis, *pos)
axis.setZValue(-1000)
axis.setFlag(axis.ItemNegativeZStacksBehindParent)
self.plot.showGrid(x=True, y=True)
''' Here we create the two lines that form the crosshairs '''
self.vLine = pg.InfiniteLine(angle=90,
movable=False,
pen=pg.mkPen('r'))
self.vLine.setZValue(1000)
self.hLine = pg.InfiniteLine(angle=0, movable=False, pen=pg.mkPen('r'))
self.hLine.setZValue(1000)
''' this is a lina label for the vertical crosshair line. We modify the horizontal position in the signal functions '''
self.hvLineText = pg.InfLineLabel(self.vLine,
color='r',
fill=(200, 200, 200, 130))
self.hvLineText.setZValue(1000)
self.plot.addItem(self.vLine, ignoreBounds=True)
self.plot.addItem(self.hLine, ignoreBounds=True)
self.plot.addItem(self.hvLineText, ignoreBounds=True)
''' define some parameters and instantiate the crosshair signals. We change the crosshairs whenever the sigMouseMoved is triggered,
whilst we must update the vertical axis if the plot autoscales, and also we must also update the horizontal axis if the time changes under the crosshairs'''
self.vb = self.plot.vb
self.mousePos = QtCore.QPointF(0.01, 0.01)
self.proxyMouseMoved = pg.SignalProxy(self.plot.scene().sigMouseMoved,
rateLimit=20,
slot=self.mouseMoved)
self.proxyAxisChanged = pg.SignalProxy(self.plot.vb.sigYRangeChanged,
rateLimit=20,
slot=self.axisChanged)
self.proxyTimeChanged = pg.SignalProxy(self.plotUpdated,
rateLimit=20,
slot=self.timeAxisChanged)
return self.plot
def __init__(self, values, movable, label):
super(LabelledLinearRegionItem, self).__init__(values=values,
movable=movable)
self.label = pg.InfLineLabel(self.lines[1],
label,
position=0.3,
rotateAxis=(1, 0),
anchor=(1, 1))
def xctl_graph_init(self, parent: PlotWidget, xName, data: list):
self.graph_init(parent, [f'{xName} Duty', '%'], ["Temperature", '°C'])
pen = pg.mkPen('w', width=0.2, style=QtCore.Qt.DashLine)
xline = pg.InfiniteLine(pos=0, pen=pen, name="currTemp", angle=270)
yline = pg.InfiniteLine(pos=0, pen=pen, name=f"curr{xName}", angle=0)
pg.InfLineLabel(xline,
text="{value}°C",
position=0.04,
rotateAxis=(0, 0))
pg.InfLineLabel(yline, text="{value}%", position=0, rotateAxis=(0, 0))
graph = EditableGraph(parent, data=data)
parent.addItem(graph)
parent.addItem(xline)
parent.addItem(yline)
def add_segment(self, onset, offset, region_typeindex, brush=None, pen=None, movable=True, text=None):
region = SegmentItem((onset, offset), region_typeindex, self.xrange,
time_bounds=(onset, offset), brush=brush, pen=pen, movable=movable)
if text is not None:
pg.InfLineLabel(region.lines[1], text, position=0.95, rotateAxis=(1,0), anchor=(1, 1))
self.addItem(region)
self.old_items.append(region)
if movable:
region.sigRegionChangeFinished.connect(self.m.on_region_change_finished)
def add_event(self, xx, event_type, pen, movable=False, text=None):
if not len(xx):
return
for x in xx:
line = EventItem(x, event_type, self.xrange, movable=True, angle=90, pen=pen)
if text is not None:
pg.InfLineLabel(line, text, position=0.95, rotateAxis=(1, 0), anchor=(1, 1))
line.sigPositionChangeFinished.connect(self.m.on_position_change_finished)
self.addItem(line)
def resolveConnections(self):
super().resolveConnections()
timeplot = self.parent.addons["xy"].plt
specplot = self.parent.addons["spec"].plt
df = self.parent.df
R = pg.LinearRegionItem()
R.lines[0].label = pg.InfLineLabel(R.lines[0],
text="FFT",
position=.95,
movable=False)
#R.lines[1].label = pg.InfLineLabel(R.lines[1],text="FFT",position=.95,movable=False)
R.setZValue(10)
t0 = df.index[0]
t1 = df.index[-1]
dt = t1 - t0
R.setRegion([t0 + dt / 3, t1 - dt / 3])
R.sigRegionChanged.connect(self.updateFFTRegion)
timeplot.addItem(R)
self.FFTregion = R
self.FFTregion.setVisible(not self.startHidden)
R2 = pg.LinearRegionItem()
R2.lines[0].label = pg.InfLineLabel(R2.lines[0],
text="FFT",
position=.95,
movable=False)
R2.setZValue(10)
t0 = df.index[0]
t1 = df.index[-1]
dt = t1 - t0
R2.setRegion([t0 + dt / 3, t1 - dt / 3])
specplot.addItem(R2)
self.specregion = R2
self.specregion.setVisible(not self.startHidden)
R.sigRegionChanged.connect(self.updateR2)
R2.sigRegionChanged.connect(self.updateR1)
def add_wavelength_marker(self):
self.wavelength_marker = pg.InfiniteLine(
self.central_wavelength,
movable=True,
bounds=[self.wavelengths[0], self.wavelengths[-1]])
self.ui.a_spectrum_graph.addItem(self.wavelength_marker)
self.wavelength_marker.sigPositionChangeFinished.connect(
self.update_kinetics_wavelength)
self.wavelength_marker_label = pg.InfLineLabel(self.wavelength_marker,
text='{value:.2f}nm',
movable=True,
position=0.9)
self.update_kinetics_wavelength()
return
def add_time_marker(self):
self.time_marker = pg.InfiniteLine(
self.times[int(len(self.times) / 2)],
movable=True,
bounds=[min(self.times), max(self.times)])
self.ui.a_kinetics_graph.addItem(self.time_marker)
self.time_marker.sigPositionChangeFinished.connect(
self.update_time_pixel)
self.time_marker_label = pg.InfLineLabel(self.time_marker,
text='{value:.2f}ps',
movable=True,
position=0.9)
self.update_time_pixel()
return
def start_clicked(self):
global data, ECGdata, GSRdata
#RT variables for simulating streaming
global RTStreamTIME, RTStreamECG, RTStreamGSR, RTStreamEVENTS
# Real Time mode
if self.rtMode.isChecked() == True:
# The data that will be used to simulate streaming is loaded
#if ((RTStreamTIME != []) and (RTStreamECG != []) and (RTStreamGSR != []) and (RTStreamEVENTS != [])):
print('started')
self.timer = pg.QtCore.QTimer()
self.timer.timeout.connect(lambda: RTupdate(self))
self.timer.start(5)
#Or:
else:
# system is on static test mode #
if ((ECGdata != []) and (GSRdata != [])):
# both GSR & ECG files has been loaded
data = [GSRdata, ECGdata]
p1 = self.modDataView.addPlot(x=times[1],
y=data[1],
pen=(1, 2))
p2 = pg.PlotCurveItem(x=times[0], y=data[0], pen=(0, 2))
p1.addItem(p2)
for i in range(len(blocks)):
# # add the network workeloads predictons of each data block to the graphic view
blockStart = blocks[i][0]
blockEnd = blocks[i][1]
level = predictBlock(GSRdata[blocks[i][0]:blocks[i][1]],
ECGdata[blocks[i][0]:blocks[i][1]])
lr = pg.LinearRegionItem(values=[blockStart, blockEnd],
brush=pg.intColor(index=level,
alpha=50),
movable=False)
p1.addItem(lr)
label = pg.InfLineLabel(lr.lines[1],
"oveload " + str(level),
position=0.85,
rotateAxis=(1, 0),
anchor=(1, 1))
else:
# either GSR or ECG files has not been loaded
print('error')
def add_qtn_marker(self, start, stop, label):
self.brt_qtn_reg.append(
pg.LinearRegionItem(values=[start, stop], movable=False))
self.gsr_qtn_reg.append(
pg.LinearRegionItem(values=[start, stop], movable=False))
pg.InfLineLabel(self.gsr_qtn_reg[self.num_qtns].lines[1],
label,
position=0.5,
rotateAxis=(1, 0))
self.hrt_qtn_reg.append(
pg.LinearRegionItem(values=[start, stop], movable=False))
self.brt_plot.addItem(self.brt_qtn_reg[self.num_qtns])
self.gsr_plot.addItem(self.gsr_qtn_reg[self.num_qtns])
self.hrt_plot.addItem(self.hrt_qtn_reg[self.num_qtns])
self.num_qtns += 1
def detPredBar(parent):
parent.getPlaytimeChanged = partial(getPlaytimeChanged, parent)
#window
#pg.setConfigOption('background','#303030')
parent.win = pg.GraphicsLayoutWidget(parent=parent)
parent.win.setGeometry(0, 0,
parent.geometry().width() + 2,
parent.geometry().height())
parent.lay = parent.win.addLayout(0, 0)
parent.lay.setBorder()
parent.dettime = pg.AxisItem(orientation='bottom')
parent.dettime.setScale(1 / 3600)
parent.dettime.setTickSpacing(major=1, minor=1 / 6)
parent.dettime.setGrid(255)
parent.dettime.setPen('#A0A0A0')
parent.predtime = pg.AxisItem(orientation='bottom')
parent.predtime.setScale(1 / 3600)
parent.predtime.setTickSpacing(major=1, minor=1 / 6)
parent.predtime.setGrid(255)
parent.predtime.setPen('#A0A0A0')
#DetectPlot
parent.det = parent.lay.addPlot(1, 1, axisItems={"bottom": parent.dettime})
parent.det.showAxis('bottom', show=True)
parent.det.showAxis('left', show=False)
parent.det.enableAutoRange(axis='y', enable=False)
parent.det.setMouseEnabled(x=True, y=False)
parent.det.setLimits(minXRange=30,
minYRange=1,
xMin=0,
xMax=parent.parent.lendy,
yMin=0,
yMax=1)
parent.det.plot(parent.parent.detx,
parent.parent.detData,
stepMode=True,
fillLevel=0,
brush=(255, 0, 0, 255),
pen=pg.mkPen('r'))
#predictPlot
parent.pred = parent.lay.addPlot(2,
1,
axisItems={"bottom": parent.predtime})
parent.pred.showAxis('bottom', show=True)
parent.pred.showAxis('left', show=False)
parent.pred.enableAutoRange(axis='y', enable=False)
parent.pred.setMouseEnabled(x=True, y=False)
parent.pred.setLimits(minXRange=30,
minYRange=1,
xMin=0,
xMax=parent.parent.lenpy,
yMin=0,
yMax=1)
parent.pred.plot(parent.parent.predx,
parent.parent.predData,
stepMode=True,
fillLevel=0,
brush=(255, 0, 0, 255),
pen=pg.mkPen((0, 150, 0, 255)))
#Get Viewbox
parent.detviewbox = parent.det.getViewBox()
parent.predviewbox = parent.pred.getViewBox()
parent.detviewbox.frame = parent
parent.predviewbox.frame = parent
#Timeline
dettimeline = pg.InfiniteLine(pen=pg.mkPen('y', width=2),
hoverPen=pg.mkPen('y', width=2),
movable=True)
parent.detviewbox.timeline = dettimeline
parent.detviewbox.addItem(dettimeline)
predtimeline = pg.InfiniteLine(pen=pg.mkPen('y', width=2),
hoverPen=pg.mkPen('y', width=2),
movable=True)
parent.predviewbox.timeline = predtimeline
parent.detviewbox.addItem(predtimeline)
#InfLabel
pg.InfLineLabel(dettimeline)
pg.InfLineLabel(predtimeline)
parent.det.addItem(dettimeline)
parent.pred.addItem(predtimeline)
def mouseClickEvent(self, e):
fre = self.frame.parent.Frequency
clktime = self.mapSceneToView(e.scenePos()).x()
self.timeline.setPos(clktime)
self.frame.parent.playtime = clktime // (1 / fre) * (1 / fre)
def MoveFinished(self, obj):
self.frame.parent.playtime = (obj.getXPos() // self.frame.parent.unit
) / self.frame.parent.Frequency
parent.detviewbox.mouseClickEvent = partial(mouseClickEvent,
parent.detviewbox)
parent.predviewbox.mouseClickEvent = partial(mouseClickEvent,
parent.predviewbox)
parent.detviewbox.MoveFinished = partial(MoveFinished, parent.detviewbox)
parent.predviewbox.MoveFinished = partial(MoveFinished, parent.predviewbox)
predtimeline.sigPositionChangeFinished.connect(
parent.predviewbox.MoveFinished)
dettimeline.sigPositionChangeFinished.connect(
parent.detviewbox.MoveFinished)
def plot(self):
# Adjust the plot range to the data
self.afrPlot.setRange(xRange=[x[0], x[-1]])
self.afrPlot.setLimits(xMin=x[0], xMax=x[-1])
# ax = self.afrPlot.getAxis('bottom')
# ax.setStyle(
# textFillLimits = [ (0, 0.8), (2, 0.6), (4, 0.4), (6, 0.2)],
# autoExpandTextSpace = False)
# dx = [(value, '{:.0f}'.format(value)) for value in x]
# ax.setTicks([dx, []])
self.tpsPlot.setRange(xRange=[x[0], x[-1]])
self.tpsPlot.setLimits(xMin=x[0], xMax=x[-1])
self.rangePlot.setRange(xRange=[x[0], x[-1]])
self.rangePlot.setLimits(xMin=x[0], xMax=x[-1])
self.region = pg.LinearRegionItem()
self.region.setZValue(10)
self.rangePlot.addItem(self.region, ignoreBounds=True)
# Adjust the range selector
# Generate curve data
self.afrPlot.plot(x, yAfr, pen='c', name='AFR')
self.tpsPlot.plot(x, yTps, pen='m', name='TPS')
self.rangePlot.plot(x, yAfr, pen='y', name='data')
# Crosshair
self.lineAfr = pg.InfiniteLine(movable=True, angle=90)
self.lineTps = pg.InfiniteLine(movable=True, angle=90)
self.lineRange = pg.InfiniteLine(movable=True, angle=90)
self.lineAfr.setPos(x[200])
self.afrPlot.addItem(self.lineAfr)
self.tpsPlot.addItem(self.lineTps)
self.rangePlot.addItem(self.lineRange)
self.lineRange.setZValue(20)
self.labelAFR = pg.InfLineLabel(self.lineAfr,
text="Drag",
movable=True,
position=0.5,
color=(200, 200, 100),
fill=(200, 200, 200, 50))
def afr_line_pos():
self.linePos = self.lineAfr.getPos()
self.lineTps.setPos(self.linePos[0])
self.lineRange.setPos(self.linePos[0])
self.interpAfr = np.interp(self.linePos[0], x, yAfr)
self.interpTps = np.interp(self.linePos[0], x, yTps)
self.interp = [self.interpAfr, self.interpTps]
#print("%0.2f, %0.2f" %(self.interpAfr, self.interpTps))
self.labelAFR.setText("AFR: %0.2f\nTPS: %0.2f%%" %
(self.interp[0], self.interp[1]))
def tps_line_pos():
self.linePos = self.lineTps.getPos()
self.lineAfr.setPos(self.linePos[0])
self.lineRange.setPos(self.linePos[0])
def range_line_pos():
self.linePos = self.lineRange.getPos()
self.lineAfr.setPos(self.linePos[0])
self.lineTps.setPos(self.linePos[0])
def update():
self.region.setZValue(10)
minX, maxX = self.region.getRegion()
self.afrPlot.setXRange(minX, maxX, padding=0)
self.lineAfr.setBounds((minX, maxX))
self.lineTps.setBounds((minX, maxX))
self.lineRange.setBounds((minX, maxX))
self.lineAfr.sigPositionChanged.connect(afr_line_pos)
self.lineTps.sigPositionChanged.connect(tps_line_pos)
self.lineRange.sigPositionChanged.connect(range_line_pos)
self.region.sigRegionChanged.connect(update)
def updateRegion(window, viewRange):
self.rgn = viewRange[0]
self.region.setRegion(self.rgn)
self.afrPlot.sigRangeChanged.connect(updateRegion)
self.region.setRegion([x[100], x[-100]])
def overlayView(self, trace_obj, sample_interval, picks):
# pull in variables from function call
self.trace_obj = trace_obj
self.sample_interval = sample_interval
self.picks = picks
# create an empty array to store the list of pyqtgraph plot objects
self.plot_frames = []
n_aux_plots = 0
n_geo_plots = 0
#work out how many AUX and GEO there are
for i in range(len(self.trace_obj)):
if self.trace_obj[i].Owner < 0:
n_aux_plots += 1
elif self.trace_obj[i].Owner > 0:
n_geo_plots += 1
n_geo_plots = int(n_geo_plots / 3)
#add single aux plots
for i in range(n_aux_plots):
plot = self.addPlot(row=i, col=0)
self.plot_frames.append(plot)
self.plot_frames[i].clear()
y = np.array(self.trace_obj[i].Raw_data)
x = np.arange(0,
len(y) * (self.sample_interval / 1000),
self.sample_interval / 1000)
self.plot_frames[i].plot(x, y)
#left axis stuff decriptors
owner = owner_translate(self.trace_obj[i].Owner)
self.plot_frames[i].showAxis('left')
self.plot_frames[i].getAxis('left').enableAutoSIPrefix(
enable=False)
self.plot_frames[i].getAxis('left').setLabel(text=owner,
units=None)
self.plot_frames[i].getAxis('left').setStyle(tickLength=0,
showValues=False)
#right axis stuff decriptors
desc = description_translate(self.trace_obj[i].Descriptor)
self.plot_frames[i].showAxis('right')
self.plot_frames[i].getAxis('right').enableAutoSIPrefix(
enable=False)
self.plot_frames[i].getAxis('right').setLabel(text=desc,
units=None)
self.plot_frames[i].getAxis('right').setStyle(tickLength=0,
showValues=False)
#add geo overlay plots
for i in range(n_geo_plots):
plot = self.addPlot(row=i + n_aux_plots, col=0)
self.plot_frames.append(plot)
self.plot_frames[i + n_aux_plots].clear()
y1 = np.array(self.trace_obj[(i * 3) + 0 + n_aux_plots].Raw_data)
y2 = np.array(self.trace_obj[(i * 3) + 1 + n_aux_plots].Raw_data)
y3 = np.array(self.trace_obj[(i * 3) + 2 + n_aux_plots].Raw_data)
x = np.arange(0,
len(y1) * (self.sample_interval / 1000),
self.sample_interval / 1000)
self.plot_frames[i + n_aux_plots].plot(x, y1, pen=(255, 0, 0))
self.plot_frames[i + n_aux_plots].plot(x, y2, pen=(0, 255, 0))
self.plot_frames[i + n_aux_plots].plot(x, y3, pen=(0, 0, 255))
#left axis stuff decriptors
owner = owner_translate(self.trace_obj[(i * 3) +
n_aux_plots].Owner)
self.plot_frames[i + n_aux_plots].showAxis('left')
self.plot_frames[i +
n_aux_plots].getAxis('left').enableAutoSIPrefix(
enable=False)
self.plot_frames[i + n_aux_plots].getAxis('left').setLabel(
text=owner, units=None)
self.plot_frames[i + n_aux_plots].getAxis('left').setStyle(
tickLength=0, showValues=False)
#right axis stuff decriptors
desc = "XYZ"
self.plot_frames[i + n_aux_plots].showAxis('right')
self.plot_frames[i +
n_aux_plots].getAxis('right').enableAutoSIPrefix(
enable=False)
self.plot_frames[i + n_aux_plots].getAxis('right').setLabel(
text=desc, units=None)
self.plot_frames[i + n_aux_plots].getAxis('right').setStyle(
tickLength=0, showValues=False)
#Formatting plots
for i in range(len(self.plot_frames)):
# Zero line
zero_line = pg.InfiniteLine(
movable=False, angle=0,
pen=pg.mkColor(0.2)) #add infinte line at zero
self.plot_frames[i].addItem(zero_line)
#Time Picks
if self.picks == True:
vert_line = pg.InfiniteLine(
movable=True, angle=90,
pen=pg.mkColor(0.2)) #add infinte line at zero
self.plot_frames[i].addItem(vert_line)
vert_label = pg.InfLineLabel(vert_line,
text="{value:0.2f}ms",
position=0.9)
self.plot_frames[i].enableAutoRange(pg.ViewBox.XYAxes)
self.plot_frames[i].setMouseEnabled(x=True,
y=False) #lock vertical scroll
self.plot_frames[i].hideButtons() # hide auto scale A button
#hide axis btoom and left
self.plot_frames[i].hideAxis('bottom')
#link all scrolling axis together
if i > 0:
self.plot_frames[i].setXLink(self.plot_frames[i - 1])
# check to allow for an empty plots scenario.
if len(self.plot_frames) != 0:
#show axis and label on top plot
self.plot_frames[0].showAxis('top')
self.plot_frames[0].getAxis('top').setStyle(showValues=True)
#show axis on bottom plot
self.plot_frames[-1].showAxis('bottom')
self.plot_frames[-1].getAxis('bottom').setStyle(showValues=True)
def __init__(self,
plot_item,
x_array=None,
name='array_slicer_name',
slicer_updated_func=lambda: None,
initial=[0, 100],
s_return_on_deactivated=np.s_[:],
brush=QtGui.QColor(0, 255, 0, 70),
ZValue=10,
font=QtGui.QFont("Times", 12),
label_line=1,
activated=False):
"""Create a new LinearRegionItem on plot_item.
====================== ==============================================================
**Arguments:**
plot_item <pyqtgraph.PlotDataItem> (recommended)
or <pyqtgraph.PlotItem> (does not grab x_array data from plot
item: initialize x_array manually
or use :func:`set_x_array <self.set_x_array>`)
x_array use to initialize x_array if plot_item == <pyqtgraph.PlotItem>.
name <str>
slicer_updated_func gets called when region is updated, alternatively use
:sig:region_changed_signal().
initial initial index values [start,stop,step] or [start,stop]
s_return_on_deactivated Object returned if RegionSlicer is not activated.
Slicing with np.s_[:] (default) and np.s_[0] gives the full and
an empty array respectively. Note, <RegionSlicer.slice> always
returns the last determined slice even if slice is deactivated.
brush,ZValue, are passed to the LinearRegionItem
font, passed to the label
label_line '0' or '1' for placement of label onto 'left' or 'right'
bounding line.
activated <bool> state at initialization
====================== ===============================================================
"""
QtWidgets.QWidget.__init__(self)
self.name = name
self.slicer_updated = slicer_updated_func
from ScopeFoundry.logged_quantity import LQCollection
self.settings = LQCollection()
if len(initial) == 2: initial.append(1)
start, stop, step = initial
self.start = self.settings.New('start', int, initial=start, vmin=0)
self.stop = self.settings.New('stop', int, initial=stop, vmin=0)
self.step = self.settings.New('step', int, initial=step)
self.activated = self.settings.New('activated',
bool,
initial=activated)
self.start.add_listener(self.on_change_start_stop)
self.stop.add_listener(self.on_change_start_stop)
self.activated.add_listener(self.on_change_activated)
self.s_return_on_deactivated = s_return_on_deactivated
if type(plot_item) == pg.PlotDataItem:
self.plot_data_item = plot_item
self.plot_data_item.sigPlotChanged.connect(
self.set_x_array_from_data_item)
self.parent_plot_item = plot_item.parentItem()
elif type(plot_item) == pg.PlotItem:
self.plot_data_item = None
self.parent_plot_item = plot_item
self.linear_region_item = pg.LinearRegionItem(brush=brush)
self.linear_region_item.setZValue(ZValue)
self.parent_plot_item.addItem(self.linear_region_item)
self.linear_region_item.sigRegionChangeFinished.connect(
self.on_change_region)
self.inf_line_label = pg.InfLineLabel(
self.linear_region_item.lines[label_line],
self.name,
position=0.78,
anchor=(0.5, 0.5))
#self.inf_line_label = pg.TextItem(self.name, anchor=(0.5, 0.5))
self.inf_line_label.setFont(font)
self.set_label('')
if x_array == None: #give it something to work with.
x_array = np.arange(512)
self.set_x_array(x_array)
def RTupdateSignals(self):
global DataStream, TimeStream, index, counter_seg, reading_block, RTtime, RTdata, blockPredictions, block_num, time_cleard
global ECGcurve, ECGcurveClear, GSRcurve, GSRcurveClear, ECG_cleard_data, GSR_cleard_data, cleardPlot, blockStart, blockEnd, p1, m1
#When we update the plots of the data streaming
display_jump = 10
#flag end of streaming data
# finish = False
# Insert to RTData array ecg and gsr values from the data stream
# RTdata[0].append(DataStream[0])
# if(DataStream[1]!=0):RTdata[1].append(DataStream[1])
# else: RTdata[1].append(5.96)
RTdata[0].append(DataStream[0])
RTdata[1].append(DataStream[1])
RTtime.append(TimeStream[0])
if counter_seg == seg_len: #Finish reading segment
print('Finish reading segment from block number:', block_num)
ECGseg = RTdata[0][index - counter_seg + 1:index + 1]
GSRseg = RTdata[1][index - counter_seg + 1:index + 1]
seg_times = RTtime[index - counter_seg + 1:index + 1]
#Clear the seg signals we read
GSRsegClear = smooth(np.asarray(GSRseg))
ECGsegClear = clearSignal(ECGseg)
#Updating the proceesed data arrays for displays later
ECG_cleard_data.extend(ECGsegClear)
GSR_cleard_data.extend(GSRsegClear)
time_cleard.extend(seg_times)
# #like it was before, but now with the cleared signal
#segment = [GSRsegClear,ECGsegClear]
segment = [ECGseg, GSRseg]
#Predict the segment
cl_result = predictSeg(segment, seg_times, 'CL')
st_result = predictSeg(segment, seg_times, 'condition')
#segment = [RTdata[0][index-counter_seg+1:index+1],RTdata[1][index-counter_seg+1:index+1]]
print('segment', type(segment))
#@Real code
self.lcdNumber.display(cl_result)
self.progressBar.setValue(cl_result)
#graphic display of thr segments prediction
blockPredictions.append(
cl_result
) #Add predict to list of segmentations' predicts in the block
if st_result == 0: #no stress
pixmap = QPixmap('no_stress.png')
stress_scale = self.stress_level.setPixmap(pixmap)
self.stress_level.resize(pixmap.width(), pixmap.height())
elif st_result == 1: #stress
pixmap = QPixmap('stress.png')
stress_scale = self.stress_level.setPixmap(pixmap)
self.stress_level.resize(pixmap.width(), pixmap.height())
print('The result for the segment is:', cl_result) #For check
print('The condition for the segment is:', st_result) # For check
counter_seg = 0 #Reset counter
# Finish reading block data.
# Predict the block:
if DataStream[2] == end_block:
blockEnd = RTtime[index]
pixmap = QPixmap('neutral.png')
stress_scale = self.stress_level.setPixmap(pixmap)
self.stress_level.resize(pixmap.width(), pixmap.height())
# OR: add label specify it's end of the block
print('Finish reading block data. Need to predict the block')
print(blockStart)
print("---------")
print(blockEnd)
block_predict = int(np.median(blockPredictions))
print('Predict of the block', block_num, 'is:', block_predict)
block_num += 1 # count another block
#@Real code
print('from RTupdateSignals: Predict is: ', block_predict) #For check
#Clear predictions
blockPredictions.clear()
#Reset counter
lr = pg.LinearRegionItem(values=[blockStart, blockEnd],
brush=pg.intColor(index=block_predict,
alpha=50),
movable=False)
m1.addItem(lr)
label = pg.InfLineLabel(lr.lines[1],
text=("BLOCK number: ", str(block_num - 1),
" overload " + str(block_predict)),
position=(0.85),
rotateAxis=(1, 0),
anchor=(1, 1))
counter_seg = 0
#Or:
#Do something with predict: on the graph show
#Display what we predict for the block
elif DataStream[2] == start_block: #Starting reading new block's data
blockStart = RTtime[index] #TimeStream
print(blockStart)
#OR: add label specify it's start of block
reading_block = 1 #Change flag
if reading_block == 1:
#Update the counter_seg
counter_seg += 1
#Display plot
if index % display_jump == 0 and index > 0:
ECGcurve.setData(np.asarray(RTtime), np.asarray(RTdata[0]))
GSRcurve.setData(np.asarray(RTtime), np.asarray(RTdata[1]))
ECGcurveClear.setData(time_cleard, ECG_cleard_data)
GSRcurveClear.setData(time_cleard, GSR_cleard_data)
QtGui.QApplication.processEvents()
if DataStream[2] == end_data:
print('finish') #check
#finish = True
# Update index
index += 1
def setup(self):
#self.ui = self.splitter = QtWidgets.QSplitter()
#self.ui.setLayout(QtWidgets.QVBoxLayout())
self.ui = self.dockarea = dockarea.DockArea()
self.imview = pg.ImageView()
self.imview.getView().invertY(False) # lower left origin
#self.splitter.addWidget(self.imview)
self.image_dock = self.dockarea.addDock(name='Image', widget=self.imview)
self.graph_layout = pg.GraphicsLayoutWidget()
#self.splitter.addWidget(self.graph_layout)
self.spec_dock = self.dockarea.addDock(name='Spec Plot', widget=self.graph_layout)
self.line_pens = ['w', 'r']
self.spec_plot = self.graph_layout.addPlot()
self.spec_plot.setLabel('left', 'Intensity', units='counts')
self.rect_plotdata = self.spec_plot.plot(y=[0,2,1,3,2],pen=self.line_pens[0])
self.point_plotdata = self.spec_plot.plot(y=[0,2,1,3,2], pen=self.line_pens[1])
self.point_plotdata.setZValue(-1)
#correlation plot
self.corr_layout = pg.GraphicsLayoutWidget()
self.corr_plot = self.corr_layout.addPlot()
self.corr_plotdata = pg.ScatterPlotItem(x=[0,1,2,3,4], y=[0,2,1,3,2], size=17,
pen=pg.mkPen(None), brush=pg.mkBrush(255, 255, 255, 60))
self.corr_plot.addItem(self.corr_plotdata)
#self.corr_plotdata = self.corr_plot.scatterPlot( x=[0,1,2,3,4], y=[0,2,1,3,2], size=17,
# pen=pg.mkPen(None), brush=pg.mkBrush(255, 255, 255, 60))
self.corr_dock = self.dockarea.addDock(name='correlation', widget=self.corr_layout,
position='below', relativeTo = self.spec_dock)
self.spec_dock.raiseDock()
# Rectangle ROI
self.rect_roi = pg.RectROI([20, 20], [20, 20], pen=(0,9))
self.rect_roi.addTranslateHandle((0.5,0.5))
self.imview.getView().addItem(self.rect_roi)
self.rect_roi.sigRegionChanged[object].connect(self.on_change_rect_roi)
# Point ROI
self.circ_roi = pg.CircleROI( (0,0), (2,2) , movable=True, pen=(0,9))
#self.circ_roi.removeHandle(self.circ_roi.getHandles()[0])
h = self.circ_roi.addTranslateHandle((0.5,.5))
h.pen = pg.mkPen('r')
h.update()
self.imview.getView().addItem(self.circ_roi)
self.circ_roi.removeHandle(0)
self.circ_roi_plotline = pg.PlotCurveItem([0], pen=(0,9))
self.imview.getView().addItem(self.circ_roi_plotline)
self.circ_roi.sigRegionChanged[object].connect(self.on_update_circ_roi)
#font
font = QtGui.QFont("Times", 12)
font.setBold(True)
#settings
self.default_display_image_choices = ['default', 'sum', 'median_map']
self.settings.New('display_image', str, choices = self.default_display_image_choices, initial = 'sum')
self.settings.display_image.add_listener(self.on_change_display_image)
self.default_x_axis_choices = ['default', 'index']
self.x_axis = self.settings.New('x_axis', str, choices = self.default_x_axis_choices)
self.x_axis.add_listener(self.on_change_x_axis)
self.norm_data = self.settings.New('norm_data', bool, initial = False)
self.norm_data.add_listener(self.update_display)
self.settings.New('default_view', bool, initial=True)
self.binning = self.settings.New('binning', int, initial = 1, vmin=1)
self.binning.add_listener(self.update_display)
self.spatial_binning = self.settings.New('spatial_binning', int, initial = 1, vmin=1)
self.spatial_binning.add_listener(self.bin_spatially)
self.cor_X_data = self.settings.New('cor_X_data', str, choices = self.default_display_image_choices,
initial = 'default')
self.cor_Y_data = self.settings.New('cor_Y_data', str, choices = self.default_display_image_choices,
initial = 'sum')
self.cor_X_data.add_listener(self.on_change_corr_settings)
self.cor_Y_data.add_listener(self.on_change_corr_settings)
# data slicers
self.x_slice = np.s_[0:-1]
self.x_slice_LinearRegionItem = pg.LinearRegionItem(brush = QtGui.QColor(0,255,0,70))
self.x_slice_LinearRegionItem.setZValue(+10)
self.spec_plot.addItem(self.x_slice_LinearRegionItem)
self.x_slice_LinearRegionItem.sigRegionChangeFinished.connect(self.on_change_x_slice_LinearRegionItem)
self.x_slice_InfLineLabel = pg.InfLineLabel(self.x_slice_LinearRegionItem.lines[1], "x_slice",
position=0.85, anchor=(0.5, 0.5))
self.x_slice_InfLineLabel.setFont(font)
self.use_x_slice = self.settings.New('use_x_slice', bool, initial = False)
self.use_x_slice.add_listener(self.on_change_x_slice)
self.bg_slice = np.s_[0:10]
self.bg_LinearRegionItem = pg.LinearRegionItem(brush = QtGui.QColor(255,255,255,70))
self.bg_LinearRegionItem.setZValue(+11)
self.spec_plot.addItem(self.bg_LinearRegionItem)
self.bg_LinearRegionItem.sigRegionChangeFinished.connect(self.on_change_bg_LinearRegionItem)
self.bg_InfLineLabel = pg.InfLineLabel(self.bg_LinearRegionItem.lines[0], "bg_subtract",
position=0.95, rotateAxis = (-1,0), anchor=(0.5, 0.5))
self.bg_InfLineLabel.setFont(font)
self.bg_subtract = self.settings.New('bg_subtract', bool, initial = False)
self.bg_subtract.add_listener(self.on_change_bg_subtract)
#self.bg_subtract.update_value(False)
self.show_lines = ['show_circ_line','show_rect_line']
for x in self.show_lines:
lq = self.settings.New(x, bool, initial=True)
lq.add_listener(self.on_change_show_lines)
self.hyperspec_data = None
self.display_image = None
self.spec_x_array = None
self.display_images = dict()
self.spec_x_arrays = dict()
self.settings_widgets = [] # Hack part 1/2: allows to use settings.New_UI() and have settings defined in scan_specific_setup()
self.scan_specific_setup()
self.add_settings_dock() # Hack part 2/2: Need to generate settings after scan_specific_setup()
self.circ_roi_slice = self.rect_roi_slice = np.s_[:,:]
def update_display(self):
"""Called when we need to update displayed results (from self.parent.result)
"""
ModelResultView.update_display(self)
for k in self.plots:
if self.plot_checks[k].isChecked():
self.plots[k].setVisible(True)
self.plots[k].setMaximumHeight(10000)
else:
self.plots[k].setVisible(False)
self.plots[k].setMaximumHeight(0)
full_result = self.parent.result
model = full_result.model
result = full_result.result
pre_state = full_result.pre_spike_state
post_state = full_result.post_spike_state
# color events by likelihood
cmap = pg.ColorMap([0, 1.0], [(0, 0, 0), (255, 0, 0)])
threshold = 10
err_colors = cmap.map((threshold - result['likelihood']) / threshold)
brushes = [pg.mkBrush(c) if np.isfinite(result['likelihood'][i]) else pg.mkBrush(None) for i,c in enumerate(err_colors)]
# log spike intervals to make visualization a little easier
compressed_spike_times = np.empty(len(result['spike_time']))
compressed_spike_times[0] = 0.0
np.cumsum(np.diff(result['spike_time'])**0.25, out=compressed_spike_times[1:])
if self.plot_checks['likelihood'].isChecked():
self.plots['likelihood'].clear()
self.plots['likelihood'].plot(compressed_spike_times, result['likelihood'], pen=None, symbol='o', symbolBrush=brushes)
if self.plot_checks['amplitude'].isChecked():
self.plots['amplitude'].clear()
self.plots['amplitude'].plot(compressed_spike_times, result['expected_amplitude'], pen=None, symbol='x', symbolPen=0.5, symbolBrush=brushes)
amp_sp = self.plots['amplitude'].plot(compressed_spike_times, result['amplitude'], pen=None, symbol='o', symbolBrush=brushes)
amp_sp.scatter.sigClicked.connect(self.amp_sp_clicked)
# show regions for each type of stimulus
last_stim_name = None
rgns = []
for i, stim_name in enumerate(full_result.event_meta['stim_name']):
ev_time = compressed_spike_times[i]
if stim_name != last_stim_name:
rgns.append([stim_name, ev_time, ev_time])
last_stim_name = stim_name
else:
rgns[-1][1] = ev_time
for stim_name, start_time, stop_time in rgns:
rgn = pg.LinearRegionItem(values=[start_time, stop_time], orientation='vertical', brush=(len(self.stim_regions), 10), pen=None, movable=False)
rgn.lines[0].label = pg.InfLineLabel(rgn.lines[1], stim_name, movable=False, rotateAxis=(1, 0), position=0, anchors=[(0, 0), (0, 0)])
rgn.setZValue(-10)
rgn.setOpacity(0.3)
self.plots['amplitude'].addItem(rgn)
self.stim_regions.append(rgn)
for k in self.state_keys:
if not self.plot_checks[k].isChecked():
continue
self.plots[k].clear()
self.plots[k].plot(compressed_spike_times, pre_state[k], pen=None, symbol='t', symbolBrush=brushes)
self.plots[k].plot(compressed_spike_times, post_state[k], pen=None, symbol='o', symbolBrush=brushes)
# plot full distribution of event amplitudes
self.amp_dist_plot.clear()
bins = np.linspace(np.nanmin(result['amplitude']), np.nanmax(result['amplitude']), 40)
d_amp = bins[1] - bins[0]
amp_hist = np.histogram(result['amplitude'], bins=bins)
self.amp_dist_plot.plot(amp_hist[1], amp_hist[0] / (amp_hist[0].sum() * d_amp), stepMode=True, fillLevel=0, brush=0.3)
# plot average model event distribution
amps = self.amp_sample_values
d_amp = amps[1] - amps[0]
total_dist = np.zeros(len(amps))
for i in range(result.shape[0]):
state = pre_state[i]
if not np.all(np.isfinite(tuple(state))):
continue
total_dist += model.likelihood(amps, state)
total_dist /= total_dist.sum() * d_amp
self.amp_dist_plot.plot(amps, total_dist, fillLevel=0, brush=(255, 0, 0, 50))
def standardView(self, trace_obj, sample_interval, picks):
# pull in variables from function call
self.trace_obj = trace_obj
self.sample_interval = sample_interval
self.picks = picks
# create an empty array to store the list of pyqtgraph plot objects
self.plot_frames = []
# style the plots
for i in range(len(self.trace_obj)):
plot = self.addPlot(row=i, col=0)
self.plot_frames.append(plot)
self.plot_frames[i].clear() # clear previous plot
# Zero line
zero_line = pg.InfiniteLine(
movable=False, angle=0,
pen=pg.mkColor(0.2)) #add infinte line at zero
self.plot_frames[i].addItem(zero_line)
#Time Picks
if self.picks == True:
vert_line = pg.InfiniteLine(
movable=True, angle=90,
pen=pg.mkColor(0.2)) #add infinte line at zero
self.plot_frames[i].addItem(vert_line)
vert_label = pg.InfLineLabel(vert_line,
text="{value:0.2f}ms",
position=0.9)
# convert dataset to numpy array and create the calc x-axis value dependant on SI
y = np.array(self.trace_obj[i].Raw_data)
x = np.arange(0,
len(y) * (self.sample_interval / 1000),
self.sample_interval / 1000)
#plot dataset
self.plot_frames[i].plot(x, y, pen=pg.mkColor(0.7))
self.plot_frames[i].enableAutoRange(pg.ViewBox.XYAxes)
self.plot_frames[i].setMouseEnabled(x=True,
y=False) #lock vertical scroll
self.plot_frames[i].hideButtons() # hide auto scale A button
#hide axis btoom and left
self.plot_frames[i].hideAxis('bottom')
self.plot_frames[i].hideAxis('left')
#link all scrolling axis together
if i > 0:
self.plot_frames[i].setXLink(self.plot_frames[i - 1])
#left axis stuff decriptors
owner = owner_translate(self.trace_obj[i].Owner)
self.plot_frames[i].showAxis('left')
self.plot_frames[i].getAxis('left').enableAutoSIPrefix(
enable=False)
self.plot_frames[i].getAxis('left').setLabel(text=owner,
units=None)
self.plot_frames[i].getAxis('left').setStyle(tickLength=0,
showValues=False)
#right axis stuff decriptors
desc = description_translate(self.trace_obj[i].Descriptor)
self.plot_frames[i].showAxis('right')
self.plot_frames[i].getAxis('right').enableAutoSIPrefix(
enable=False)
self.plot_frames[i].getAxis('right').setLabel(text=desc,
units=None)
self.plot_frames[i].getAxis('right').setStyle(tickLength=0,
showValues=False)
# check to allow for an empty plots scenario.
if len(self.plot_frames) != 0:
#show axis and label on top plot
self.plot_frames[0].showAxis('top')
self.plot_frames[0].getAxis('top').setStyle(showValues=True)
#show axis on bottom plot
self.plot_frames[-1].showAxis('bottom')
self.plot_frames[-1].getAxis('bottom').setStyle(showValues=True)
#update it each time you receive data
#here the length is set to 300. 3 means the 3-dimension.
data1 = np.zeros((3, 300))
#contains acc_x, acc_y and acc_z
data2 = np.zeros((3, 300))
#contains gyr_x, gyr_y and gyr_z
data3 = np.zeros((3, 300))
#contains mag_x, mag_y and mag_z
p11 = win.addPlot()
p11.addLegend(offset=(10, 10))
p11.addItem(lr11, name='region11')
label = pg.InfLineLabel(lr11.lines[0],
"x2={value:0.2f}",
position=0.9,
rotateAxis=(1, 0),
anchor=(1, 1))
label = pg.InfLineLabel(lr11.lines[1],
"x1={value:0.2f}",
position=0.9,
rotateAxis=(1, 0),
anchor=(1, 1))
p12 = win.addPlot()
p12.addLegend(offset=(10, 10))
p12.addItem(lr12, name='region12')
label = pg.InfLineLabel(lr12.lines[0],
"x2={value:0.2f}",
position=0.9,
rotateAxis=(1, 0),
anchor=(1, 1))
def mark_line(self):
self.is_current_bar = True
self.htext = pg.InfLineLabel(self.hline)
def setup_figure(self):
self.ui = load_qt_ui_file(sibling_path(__file__, "power_spec_logger.ui"))
self.settings.activation.connect_to_widget(self.ui.run_checkBox)
self.settings.channel.connect_to_widget(self.ui.chan_lineEdit)
self.settings.refresh_time.connect_to_widget(self.ui.time_doubleSpinBox)
auto_connect_widget_in_ui(self.ui, self.settings.update_display)
auto_connect_widget_in_ui(self.ui, self.settings.view_freq_min)
auto_connect_widget_in_ui(self.ui, self.settings.view_freq_max)
auto_connect_widget_in_ui(self.ui, self.settings.log_freq_max)
auto_connect_widget_in_ui(self.ui, self.settings.save_h5)
auto_connect_widget_in_ui(self.ui, self.settings.save_raw)
#### Plots
self.graph_layout = pg.GraphicsLayoutWidget()
self.ui.plot_groupBox.layout().addWidget(self.graph_layout)
p = self.power_spec_plot = self.graph_layout.addPlot(row=0, col=0)
self.dc_plotlines = [None,None,None]
p.setTitle("Power Spectrum")
p.addLegend()
p.current_plotline = p.plot(pen=pg.mkPen('r'), name='Current')
p.avg_plotline = p.plot(name='Running average')
#p.showLabel('top', True)
p.setLabel('bottom', "Frequency", 'Hz')
p.setLabel('left', 'PSD [V<sup>2</sup>/Hz]')
p.setLogMode(x=False, y=True)
self.settings.view_freq_min.add_listener(self.on_update_freq_lims)
self.settings.view_freq_max.add_listener(self.on_update_freq_lims)
self.on_update_freq_lims()
dc_p = self.dc_plot = self.graph_layout.addPlot(row=1, col=0)
dc_p.addLegend()
dc_p.setTitle("DC")
dc_p.setLabel('bottom', "Time", 's')
dc_p.setLabel('left', 'Δ <sub>DC</sub>', units='V')
dc_p.addItem(pg.InfiniteLine(movable=False, angle=0))
for i,name in enumerate('xyz'):
self.dc_plotlines[i] = dc_p.plot(pen=pg.mkPen('rgb'[i]), name=name, autoDownsampleFactor=1.0)
dc_p.setDownsampling(auto=True, mode='subsample',)
p = self.roi_plot = self.graph_layout.addPlot(row=2, col=0)
p.addLegend()
p.setTitle("Frequency Band History")
p.setLabel('bottom', "Time", 's')
p.setXLink(self.dc_plot)
p.setLabel('left', 'V')
p.setLogMode(x=False, y=True)
self.linear_range_items = []
for i in range(2):
color = ['#F005','#0F05'][i]
lr = pg.LinearRegionItem(values=[55*(i+1),65*(i+1)], brush=pg.mkBrush(color))
lr.num = i
self.power_spec_plot.addItem(lr)
lr.label = pg.InfLineLabel(lr.lines[0], "Region {}".format(i), position=0.8, rotateAxis=(1,0), anchor=(1, 1), movable=True)
self.linear_range_items.append(lr)
lr.hist_plotline = self.roi_plot.plot(pen=pg.mkPen(color[:-1]), name='Region {}'.format(i))
lr.hist_plotline.setAlpha(1, auto=False)
self.roi_plot.setDownsampling(auto=True, mode='subsample',)
self.settings.phys_unit.add_listener(self.on_change_phys_unit)
def _setup_plot(self):
# Get plot item and setup
self.plt = self.getPlotItem()
self.plt.setDownsampling(auto=True)
self.plt.setTitle(
type(self).
__name__ if self.daq_device is None else type(self).__name__ +
' ' + self.daq_device)
self.plt.setLabel('left', text='Vertical displacement', units='%')
self.plt.setLabel('bottom', text='Horizontal displacement', units='%')
self.plt.showGrid(x=True, y=True, alpha=0.66)
self.plt.setRange(xRange=[-100, 100], yRange=[-100, 100])
self.plt.setLimits(xMax=110, xMin=-110, yMax=110, yMin=-110)
xyticks = dict([(v, str(abs(v))) for v in range(-120, 130, 20)])
self.plt.getAxis('bottom').setTicks([xyticks.items()])
self.plt.getAxis('left').setTicks([xyticks.items()])
self.plt.hideButtons()
v_line = self.plt.addLine(x=0,
pen={
'color': 'w',
'style': pg.QtCore.Qt.DashLine
})
h_line = self.plt.addLine(y=0.,
pen={
'color': 'w',
'style': pg.QtCore.Qt.DashLine
})
label_left = pg.InfLineLabel(line=h_line,
text='Left',
position=0.05,
movable=False)
label_right = pg.InfLineLabel(line=h_line,
text='Right',
position=0.95,
movable=False)
label_up = pg.InfLineLabel(line=v_line,
text='Up',
position=0.95,
movable=False)
label_down = pg.InfLineLabel(line=v_line,
text='Down',
position=0.05,
movable=False)
self.legend = pg.LegendItem(offset=(80, -50))
self.legend.setParentItem(self.plt)
self.curves = OrderedDict()
if any(x in self.ro_types for x in ('sem_h_shift', 'sem_v_shift')):
sig = 'analog'
self.curves[sig] = BeamPositionItem(color=_MPL_COLORS[0],
name=sig,
horizontal='sem_h_shift'
in self.ro_types,
vertical='sem_v_shift'
in self.ro_types)
if any(
all(x in self.ro_types for x in y)
for y in [('sem_left', 'sem_right'), ('sem_up', 'sem_down')]):
sig = 'digital'
self.curves[sig] = BeamPositionItem(
color=_MPL_COLORS[1],
name=sig,
horizontal='sem_left' in self.ro_types
and 'sem_right' in self.ro_types,
vertical='sem_up' in self.ro_types
and 'sem_down' in self.ro_types)
# Show data and legend
if self.curves:
for curve in self.curves:
self.curves[curve].set_legend(self.legend)
self.curves[curve].set_plotitem(self.plt)
self.show_data(curve)
def setup(self):
self.ui = self.graph_layout = pg.GraphicsLayoutWidget()
p = self.power_spec_plot = self.graph_layout.addPlot(row=0, col=0)
self.dc_plotlines = [None,None,None]
p.setTitle("Power Spectrum")
p.addLegend()
p.current_plotline = p.plot(pen=pg.mkPen('r'), name='Current')
p.avg_plotline = p.plot(name='Running average')
#p.showLabel('top', True)
p.setLabel('bottom', "Frequency", 'Hz')
p.setLabel('left', 'PSD [V<sup>2</sup>/Hz]')
p.setLogMode(x=False, y=True)
#self.settings.view_freq_min.add_listener(self.on_update_freq_lims)
#self.settings.view_freq_max.add_listener(self.on_update_freq_lims)
#self.on_update_freq_lims()
dc_p = self.dc_plot = self.graph_layout.addPlot(row=1, col=0)
dc_p.addLegend()
dc_p.setTitle("DC")
dc_p.setLabel('bottom', "Time", 's')
dc_p.setLabel('left', 'Δ <sub>DC</sub>', units='V')
dc_p.addItem(pg.InfiniteLine(movable=False, angle=0))
for i,name in enumerate('xyz'):
self.dc_plotlines[i] = dc_p.plot(pen=pg.mkPen('rgb'[i]), name=name, autoDownsampleFactor=1.0)
dc_p.setDownsampling(auto=True, mode='subsample',)
p = self.roi_plot = self.graph_layout.addPlot(row=2, col=0)
p.addLegend()
p.setTitle("Frequency Band History")
p.setLabel('bottom', "Time", 's')
p.setXLink(self.dc_plot)
p.setLabel('left', 'V')
p.setLogMode(x=False, y=True)
self.linear_range_items = []
for i in range(2):
color = ['#F005','#0F05'][i]
lr = pg.LinearRegionItem(values=[55*(i+1),65*(i+1)], brush=pg.mkBrush(color))
lr.num = i
self.power_spec_plot.addItem(lr)
lr.label = pg.InfLineLabel(lr.lines[0], "Region {}".format(i), position=0.8, rotateAxis=(1,0), anchor=(1, 1), movable=True)
self.linear_range_items.append(lr)
lr.hist_plotline = self.roi_plot.plot(pen=pg.mkPen(color[:-1]), name='Region {}'.format(i))
lr.hist_plotline.setAlpha(1, auto=False)
### add listenr for linear_range_items changing range
lr.sigRegionChanged.connect(self.update_display)
self.roi_plot.setDownsampling(auto=True, mode='subsample',)
# Enable antialiasing for prettier plots
pg.setConfigOptions(antialias=True)
# Create a plot with some random data
p1 = win.addPlot(title="Plot Items example", y=np.random.normal(size=100, scale=10), pen=0.5)
p1.setYRange(-40, 40)
# Add three infinite lines with labels
inf1 = pg.InfiniteLine(movable=True, angle=90, label='x={value:0.2f}',
labelOpts={'position':0.1, 'color': (200,200,100), 'fill': (200,200,200,50), 'movable': True})
inf2 = pg.InfiniteLine(movable=True, angle=0, pen=(0, 0, 200), bounds = [-20, 20], hoverPen=(0,200,0), label='y={value:0.2f}mm',
labelOpts={'color': (200,0,0), 'movable': True, 'fill': (0, 0, 200, 100)})
inf3 = pg.InfiniteLine(movable=True, angle=45, pen='g', label='diagonal',
labelOpts={'rotateAxis': [1, 0], 'fill': (0, 200, 0, 100), 'movable': True})
inf1.setPos([2,2])
p1.addItem(inf1)
p1.addItem(inf2)
p1.addItem(inf3)
# Add a linear region with a label
lr = pg.LinearRegionItem(values=[70, 80])
p1.addItem(lr)
label = pg.InfLineLabel(lr.lines[1], "region 1", position=0.95, rotateAxis=(1,0), anchor=(1, 1))
## Start Qt event loop unless running in interactive mode or using pyside.
if __name__ == '__main__':
import sys
if (sys.flags.interactive != 1) or not hasattr(QtCore, 'PYQT_VERSION'):
QtGui.QApplication.instance().exec_()
def plot(self):
self.resize(900, 600)
# Center the window in the middle of the screen
frame = self.frameGeometry()
centerPoint = QtGui.QDesktopWidget().availableGeometry().center()
frame.moveCenter(centerPoint)
self.move(frame.topLeft())
# This creates the central widget
self.centralwidget = QtGui.QWidget()
self.centralwidget.setStyleSheet("background-color: rgb(0, 0, 0);")
self.centralgridLayout = QtGui.QGridLayout(self.centralwidget)
self.centralgridLayout.setMargin(0)
# This create the horizontal layout
self.horizontalLayout = QtGui.QHBoxLayout()
self.horizontalLayout.setSpacing(2)
# Create the graphics layout widget
self.win = pg.GraphicsLayoutWidget(self.centralwidget)
pg.setConfigOptions(antialias=True)
self.horizontalLayout.addWidget(self.win)
self.horizontalLayout.setContentsMargins(0, 0, 0, 0)
# Generate afrPlot
self.afrPlot = self.win.addPlot(row=0, col=0)
# Format afrPlot
self.afrPlot.setLabel('left', 'Air-Fuel Ratio')
self.afrPlot.setRange(yRange=[10 - .25, 20 + .25], padding=0.1)
self.afrPlot.setLimits(yMin=10 - .25, yMax=20 + .25)
self.afrPlot.showGrid(x=True, y=True, alpha=0.3)
self.afrPlot.hideButtons() #Disable auto-scale button
self.afrPlot.setContentsMargins(0, 0, 0, 0)
self.afrPlot.hideAxis('bottom')
# Generate tpsPlot
self.tpsPlot = self.win.addPlot(row=1, col=0)
# Format tpsPlot
self.tpsPlot.setLabel('left', 'Throttle (%)')
self.tpsPlot.setRange(yRange=[0 - 2.5, 100 + 2.5], padding=0.1)
self.tpsPlot.setLimits(yMin=0 - 2.5, yMax=100 + 2.5)
self.tpsPlot.showGrid(x=True, y=True, alpha=0.3)
self.tpsPlot.setXLink(self.afrPlot)
self.tpsPlot.hideButtons() #Disable auto-scale button
self.tpsPlot.setContentsMargins(0, 0, 0, 0)
self.tpsPlot.hideAxis('bottom')
# Generate the velocityPlot
self.velocityPlot = self.win.addPlot(row=2, col=0)
# Format velocityPlot
self.velocityPlot.setLabel('left', 'Velocity (MpH)')
self.velocityPlot.setRange(yRange=[0 - 2.5, 100 + 2.5], padding=0.1)
self.velocityPlot.setLimits(yMin=0 - 2.5, yMax=100 + 2.5)
self.velocityPlot.showGrid(x=True, y=True, alpha=0.3)
self.velocityPlot.setXLink(self.afrPlot)
self.velocityPlot.hideButtons() #Disable auto-scale button
self.velocityPlot.setContentsMargins(0, 0, 0, 0)
self.velocityPlot.hideAxis('bottom')
# Generate the rangePlot
self.rangePlot = self.win.addPlot(row=3, col=0)
# Format rangePlot
self.rangePlot.setLabel('left', 'Dataset')
self.rangePlot.setRange(yRange=[10 - .25, 20 + .25], padding=0.1)
self.rangePlot.setLimits(yMin=10 - .25, yMax=20 + .25)
self.rangePlot.showGrid(x=True, y=True, alpha=0.3)
self.rangePlot.hideButtons() #Disable auto-scale button
self.rangePlot.setContentsMargins(0, 0, 0, 0)
# Build the UI
self.centralgridLayout.addLayout(self.horizontalLayout, 0, 0, 1, 1)
self.setCentralWidget(self.centralwidget)
# Adjust the plot range to the data
self.afrPlot.setRange(xRange=[x[0], x[-1]])
self.afrPlot.setLimits(xMin=x[0], xMax=x[-1])
self.tpsPlot.setRange(xRange=[x[0], x[-1]])
self.tpsPlot.setLimits(xMin=x[0], xMax=x[-1])
self.velocityPlot.setRange(xRange=[x[0], x[-1]])
self.velocityPlot.setLimits(xMin=x[0], xMax=x[-1])
self.rangePlot.setRange(xRange=[x[0], x[-1]])
self.rangePlot.setLimits(xMin=x[0], xMax=x[-1])
self.region = pg.LinearRegionItem()
self.region.setZValue(10)
self.rangePlot.addItem(self.region, ignoreBounds=True)
# Adjust the range selector
# Generate curve data
self.afrPlot.plot(x, yAfr, pen='c', name='AFR')
self.tpsPlot.plot(x, yTps, pen='m', name='TPS')
self.velocityPlot.plot(x, velocity, pen='r', name='data')
self.rangePlot.plot(x, yAfr, pen='y', name='data')
# Crosshair
self.lineAfr = pg.InfiniteLine(movable=True, angle=90)
self.lineTps = pg.InfiniteLine(movable=True, angle=90)
self.lineVel = pg.InfiniteLine(movable=True, angle=90)
self.lineRange = pg.InfiniteLine(movable=True, angle=90)
self.lineAfr.setPos(x[200])
self.afrPlot.addItem(self.lineAfr)
self.tpsPlot.addItem(self.lineTps)
self.velocityPlot.addItem(self.lineVel)
self.rangePlot.addItem(self.lineRange)
self.lineRange.setZValue(20)
self.labelAFR = pg.InfLineLabel(self.lineAfr,
text="Drag",
movable=True,
position=0.5,
color=(200, 200, 100),
fill=(200, 200, 200, 50))
def afr_line_pos():
self.linePos = self.lineAfr.getPos()
self.lineTps.setPos(self.linePos[0])
self.lineRange.setPos(self.linePos[0])
self.interpAfr = np.interp(self.linePos[0], x, yAfr)
self.interpTps = np.interp(self.linePos[0], x, yTps)
self.interpTmp = np.interp(self.linePos[0], x, tmpC)
self.interpVel = np.interp(self.linePos[0], x, velocity)
self.interp = [
self.interpAfr, self.interpTps, self.interpTmp, self.interpVel
]
#print("%0.2f, %0.2f" %(self.interpAfr, self.interpTps))
self.labelAFR.setText(
"AFR: %0.2f\nTPS: %0.1f%%\nTMP: %0.1fC\nVEL: %0.1f" %
(self.interp[0], self.interp[1], self.interp[2],
self.interp[3]))
def tps_line_pos():
self.linePos = self.lineTps.getPos()
self.lineAfr.setPos(self.linePos[0])
self.lineVel.setPos(self.linePos[0])
self.lineRange.setPos(self.linePos[0])
def vel_line_pos():
self.linePos = self.lineVel.getPos()
self.lineAfr.setPos(self.linePos[0])
self.lineTps.setPos(self.linePos[0])
self.lineRange.setPos(self.linePos[0])
def range_line_pos():
self.linePos = self.lineRange.getPos()
self.lineAfr.setPos(self.linePos[0])
self.lineTps.setPos(self.linePos[0])
self.lineVel.setPos(self.linePos[0])
def update():
self.region.setZValue(10)
minX, maxX = self.region.getRegion()
self.afrPlot.setXRange(minX, maxX, padding=0)
self.lineAfr.setBounds((minX, maxX))
self.lineTps.setBounds((minX, maxX))
self.lineVel.setBounds((minX, maxX))
self.lineRange.setBounds((minX, maxX))
self.lineAfr.sigPositionChanged.connect(afr_line_pos)
self.lineTps.sigPositionChanged.connect(tps_line_pos)
self.lineVel.sigPositionChanged.connect(vel_line_pos)
self.lineRange.sigPositionChanged.connect(range_line_pos)
self.region.sigRegionChanged.connect(update)
def updateRegion(window, viewRange):
self.rgn = viewRange[0]
self.region.setRegion(self.rgn)
self.afrPlot.sigRangeChanged.connect(updateRegion)
self.region.setRegion([x[100], x[-100]])
