def create_plot(self):
self.stream_scroll = pg.PlotWidget(
title='Stream Monitor',
labels={'left': 'Channel'},
axisItems={'bottom': TimeAxisItem(orientation='bottom')}
)
self.stream_scroll.setMinimumHeight(200)
self.stream_scroll.setYRange(-4,4,padding=.01)
# self.stream_scroll.setXRange(0,100, padding=.01)
self.stream_scroll.setXRange(timestamp(), timestamp() + 100)
self.layout = QtGui.QGridLayout()
self.stream_scroll.plotItem.showGrid(True, True, .5)
self.layout.addWidget(self.stream_scroll,0,0)
C=pg.hsvColor(.7,alpha=.5)
self.pen=pg.mkPen(color=C,width=1)
self.curve = self.stream_scroll.plot(pen=self.pen)
C1=pg.hsvColor(.6,alpha=.5)
self.pen1=pg.mkPen(color=C1,width=1)
self.curve1 = self.stream_scroll.plot(pen=self.pen1)
C2=pg.hsvColor(.5,alpha=.5)
self.pen2=pg.mkPen(color=C2,width=1)
self.curve2 = self.stream_scroll.plot(pen=self.pen2)
C3=pg.hsvColor(.4,alpha=.5)
self.pen3=pg.mkPen(color=C3,width=1)
self.curve3 = self.stream_scroll.plot(pen=self.pen3)
def show_stim(self, x, y, xname, plotwidget):
if xname == 'Time (sec)':
Lbrush = pg.mkBrush(pg.hsvColor(0.0, sat=0.4, alpha=0.3))
Rbrush = pg.mkBrush(pg.hsvColor(0.5, sat=0.4, alpha=0.3))
for onoff in self.bender.Lonoff:
leftplot = pg.LinearRegionItem(onoff,
movable=False,
brush=Lbrush)
plotwidget.addItem(leftplot)
for onoff in self.bender.Ronoff:
rightplot = pg.LinearRegionItem(onoff,
movable=False,
brush=Rbrush)
plotwidget.addItem(rightplot)
else:
Lpen = pg.mkPen(color=pg.hsvColor(0.0, sat=0.4), width=4)
Rpen = pg.mkPen(pg.hsvColor(0.5, sat=0.4), width=4)
t = self.bender.t
for onoff in self.bender.Lonoff:
ison = np.logical_and(t >= onoff[0], t < onoff[1])
plotwidget.plot(pen=Lpen, clear=False, x=x[ison], y=y[ison])
for onoff in self.bender.Ronoff:
ison = np.logical_and(t >= onoff[0], t < onoff[1])
plotwidget.plot(pen=Rpen, clear=False, x=x[ison], y=y[ison])
def set_plotdata(self, name, data_x, data_y):
self.getFrequnzies(self.INTERVALS)
if name in self.traces:
#print(self.frequencies)
if name == 'frequenciesChart':
self.getFrequnzies(self.INTERVALS)
self.bg1.setOpts(height=self.clean(self.frequencies +
[np.sum(self.frequencies)] +
[30]))
#print(self.frequencies)
elif name == 'colorDiagram':
pen = pg.mkPen('y', width=3, style=QtCore.Qt.DashLine)
self.traces[name].setPen(
pg.mkPen(color=pg.hsvColor(self.angle / 360,
sat=1,
val=self.brightness[-1][0],
alpha=1.0),
width=100))
self.traces[name].setData(data_x, data_y)
else:
self.traces[name].setData(data_x, data_y)
else:
if name == 'waveform':
pen = pg.mkPen(
color=pg.hsvColor(0.66, sat=1, val=1.0, alpha=1.0))
self.traces[name] = self.waveform.plot(pen=pen, width=3)
self.waveform.setYRange(0, 255, padding=0)
self.waveform.setXRange(0, 2 * self.CHUNK, padding=0.005)
if name == 'spectrum':
self.traces[name] = self.spectrum.plot(pen='m', width=3)
self.spectrum.setLogMode(x=True, y=True)
self.spectrum.setYRange(-4, 0, padding=0)
self.spectrum.setXRange(np.log10(20),
np.log10(self.RATE / 2),
padding=0.005)
if name == 'frequenciesChart':
self.traces[name] = self.bg1
if name == 'colorDiagram':
self.traces[name] = self.traces[name] = self.colorDiagram.plot(
pen='m', width=3)
self.colorDiagram.setYRange(0, 2, padding=0)
self.colorDiagram.setXRange(0, 3, padding=0.005)
def show_stim(self, x, y, xname, plotwidget):
if xname == 'Time (sec)':
br = pg.mkBrush(pg.hsvColor(0.0, sat=0.4, alpha=0.3))
for onoff in self.bender.actonoff:
actplot = pg.LinearRegionItem(onoff, movable=False, brush=br)
plotwidget.addItem(actplot)
else:
pen = pg.mkPen(color=pg.hsvColor(0.0, sat=0.4), width=4)
t = self.bender.t
for onoff in self.bender.actonoff:
ison = np.logical_and(t >= onoff[0], t < onoff[1])
plotwidget.plot(pen=pen, clear=False, x=x[ison], y=y[ison])
def update(self):
self.X= np.append(self.X,self.index+1)
self.index=self.index+1
print self.X
if self.index<20:
self.Y= np.append(self.Y,0)
elif self.index>60:
self.Y= np.append(self.Y,0)
else:
self.Y= np.append(self.Y,(self.index+1-20)*(self.index+1-20)*1.00/1000)
#for x in self.X:
# print x
print self.Y
t1=time.clock()
points=100 #number of data points
X=np.arange(points)
#print np.sin(np.arange(points))
Y=np.sin(np.arange(points)*3*np.pi+time.time())
#print np.arange(points)
#print np.arange(points)/points*3*np.pi+time.time()
#Y=np.sin(np.arange(points)/points*3*np.pi+time.time())
#print Y
C=pyqtgraph.hsvColor(time.time()/5%1,alpha=.5)
pen=pyqtgraph.mkPen(color=C,width=5)
self.grPlot.plot(self.X,self.Y,pen=pen,clear=True)
print("update took %.02f ms"%((time.clock()-t1)*1000))
time.sleep(0.5)
if self.chkMore.isChecked():
QtCore.QTimer.singleShot(1, self.update) # QUICKLY repeat
def recordScan(self, data):
self.data.append([val for tup in data for val in tup])
x, y = data[1]
amp, phi = data[2]
hue = (phi / 360. + 1.) % 1.
brush = pg.mkBrush(color=pg.hsvColor(hue))
self.traceItem.addPoints([x], [y], brush=brush)
def create_new_axis(self, plt, name, ratio=False):
if name in self.extra_axes.keys():
QtGui.QMessageBox.about(self, "Error %s" % self.current_selected,
"Limited to one additional axis per plot")
else:
new_vb = pg.ViewBox()
self.extra_axes[name] = new_vb
plt.showAxis('right')
plt.scene().addItem(new_vb)
plt.getAxis('right').linkToView(new_vb)
new_vb.setXLink(plt)
def updateViews(plt, new_vb):
new_vb.setGeometry(plt.vb.sceneBoundingRect())
new_vb.linkedViewChanged(plt.vb, new_vb.XAxis)
updateViews(plt, new_vb)
plt.vb.sigResized.connect(lambda: updateViews(plt, new_vb))
if ratio:
self.axis2_curves[name], label = self.plot_ratio_new_axis(new_vb)
else:
self.axis2_curves[name], label = self.plot_data_new_axis(new_vb)
plt.getAxis('right').setLabel(label)
try:
self.axis2_curves[name][0].setPen(pg.hsvColor(0.8, sat=1.0, val=0.8, alpha=1.0))
except IndexError:
pass
def update(self, pos = 0, msg = ""):
C=pyqtgraph.hsvColor(1)
pen=pyqtgraph.mkPen(color=C,width=1)
data = np.zeros(10)
pos = int(self.video_model.get_pos())
self.indicator.setData([pos,pos],[self.indicator_min,self.indicator_max]) #= self.plot_item.plot([pos,pos],[self.indicator_min,self.indicator_max],pen=pyqtgraph.mkPen(color=pyqtgraph.hsvColor(2),width=1))
def create_new_axis(self, plt, name, ratio=False):
if name in self.extra_axes.keys():
QtGui.QMessageBox.about(self, "Error %s" % self.current_selected,
"Limited to one additional axis per plot")
else:
new_vb = pg.ViewBox()
self.extra_axes[name] = new_vb
plt.showAxis('right')
plt.scene().addItem(new_vb)
plt.getAxis('right').linkToView(new_vb)
new_vb.setXLink(plt)
def updateViews(plt, new_vb):
new_vb.setGeometry(plt.vb.sceneBoundingRect())
new_vb.linkedViewChanged(plt.vb, new_vb.XAxis)
updateViews(plt, new_vb)
plt.vb.sigResized.connect(lambda: updateViews(plt, new_vb))
if ratio:
self.axis2_curves[name], label = self.plot_ratio_new_axis(new_vb)
else:
self.axis2_curves[name], label = self.plot_data_new_axis(new_vb)
plt.getAxis('right').setLabel(label)
try:
self.axis2_curves[name][0].setPen(pg.hsvColor(0.8, sat=1.0, val=0.8, alpha=1.0))
except IndexError:
pass
def showUpdate(self):
t = time.clock()
points = 100 #number of data points
X = np.arange(points)
Y = np.sin(np.arange(points) / points * 3 * np.pi + time.time())
C = pyqtgraph.hsvColor(time.time() / 5 % 1, alpha=.5)
pen = pyqtgraph.mkPen(color=C, width=5)
self.AvgPlot.plot(X, Y, pen=pen, clear=True)
def update(self):
t1 = time.clock()
points = 100 #number of data points
X = np.arange(points)
Y = np.sin(np.arange(points) / points * 3 * np.pi + time.time())
C = pyqtgraph.hsvColor(time.time() / 5 % 1, alpha=.5)
pen = pyqtgraph.mkPen(color=C, width=2)
self.plot_ul.plot(X, Y, pen=pen, clear=True)
print("update took %.02f ms" % ((time.clock() - t1) * 1000))
def draw_buffer(self):
self.buff_win = pg.GraphicsLayoutWidget()
self.buff_win.setWindowTitle('Buffer Status')
self.buff_win.resize(800, 700)
self.total_peers = self.number_of_monitors + self.number_of_peers + self.number_of_malicious
self.p4 = self.buff_win.addPlot()
self.p4.showGrid(
x=True, y=True,
alpha=100) # To show grid lines across x axis and y axis
leftaxis = self.p4.getAxis('left') # get left axis i.e y axis
leftaxis.setTickSpacing(
5, 1) # to set ticks at a interval of 5 and grid lines at 1 space
# Get different colors using matplotlib library
if self.total_peers < 8:
colors = cm.Set2(np.linspace(0, 1, 8))
elif self.total_peers < 12:
colors = cm.Set3(np.linspace(0, 1, 12))
else:
colors = cm.rainbow(np.linspace(0, 1, self.total_peers + 1))
self.QColors = [
pg.hsvColor(color[0], color[1], color[2], color[3])
for color in colors
] # Create QtColors, each color would represent a peer
self.Data = [
] # To represent buffer out i.e outgoing data from buffer
self.OutData = [] # To represent buffer in i.e incoming data in buffer
# a single line would reperesent a single color or peer, hence we would not need to pass a list of brushes
self.lineIN = [None] * self.total_peers
for ix in range(self.total_peers):
self.lineIN[ix] = self.p4.plot(pen=(None),
symbolBrush=self.QColors[ix],
name='IN',
symbol='o',
clear=False)
self.Data.append(set())
self.OutData.append(set())
# similiarly one line per peer to represent outgoinf data from buffer
self.lineOUT = self.p4.plot(pen=(None),
symbolBrush=mkColor('#CCCCCC'),
name='OUT',
symbol='o',
clear=False)
self.p4.setRange(xRange=[0, self.total_peers],
yRange=[0, self.get_buffer_size()])
self.buff_win.show() # To actually show create window
self.buffer_order = {}
self.buffer_index = 0
self.buffer_labels = []
self.lastUpdate = pg.ptime.time()
self.avgFps = 0.0
def update(self):
t1 = time.clock()
points = 100 #number of data points
X = np.arange(points)
Y = np.sin(np.arange(points) / points * 3 * np.pi + time.time())
C = pyqtgraph.hsvColor(time.time() / 5 % 1, alpha=.5)
pen = pyqtgraph.mkPen(color=C, width=5)
self.AvgPlot.plot(X, Y, pen=pen, clear=True)
print("update took %.02f ms" % ((time.clock() - t1) * 1000))
QtCore.QTimer.singleShot(1, self.update) # QUICKLY repeat
def plot_hypnogram(self):
use_data = self.dataloader.PRED
sleep_level = ['W', 'N1', 'N2', 'N3', 'REM']
calib = self.status['calib']
brush = pg.mkBrush(pg.hsvColor(0.6, 1, 0.3, 0.3))
lin_space = np.array(
(np.arange(self.dataloader.PRED.shape[0]),
np.arange(self.dataloader.PRED.shape[0])+1))
lin_space = lin_space.transpose().reshape(-1)
# label_temp = np.array((self.dataloader.LABEL, self.dataloader.LABEL))
# label_temp = label_temp.transpose().reshape(-1)
pred_temp = np.array((use_data, use_data))
pred_temp = pred_temp.transpose().reshape(-1)
hypno_temp = np.array((self.user_annotation_record,
self.user_annotation_record))
hypno_temp = hypno_temp.transpose().reshape(-1)
ticks = [[(v, '{}'.format(
self.time_format([23, 0, 0 + int(v*30)]))) for v in (np.arange(
self.dataloader.PRED.shape[0])[0::50])]]
y_ticks = [[(v, '{}'.format(
sleep_level[v])) for v in np.arange(0, 5)]]
y_ticks[0].append((-1, 'Not scored'))
self.hypnogram_ax.clear()
self.hypnogram_ax.setBackground('w')
self.hypnogram_ax.setYRange(-1, 5)
self.hypnogram_ax.setXRange(0, self.dataloader.PRED.shape[0])
self.hypnogram_ax.plot(lin_space, pred_temp,
pen=pg.mkPen(color='b', width=POINTFIVE))
self.hypnogram_ax.plot(lin_space, hypno_temp,
pen=pg.mkPen(color='r', width=POINTFIVE))
# self.hypnogram_ax.plot(lin_space, label_temp,
# pen=pg.mkPen(color='g', width=0.5))
stem1 = pg.PlotDataItem(x=np.ones(5)*(self.status['counter']),
y=np.linspace(-1, 6, 5))
stem2 = pg.PlotDataItem(x=np.ones(5)*(self.status['counter'] + 1),
y=np.linspace(-1, 6, 5))
fbtwn = pg.FillBetweenItem(stem1, stem2, brush=brush)
self.hypnogram_ax.addItem(fbtwn)
x_axis = self.hypnogram_ax.getAxis('bottom')
y_axis = self.hypnogram_ax.getAxis('left')
x_axis.setTicks(ticks)
y_axis.setTicks(y_ticks)
self.annotate.info_pred_label.setText('Annotate as {}'.format(
sleep_level[int(self.dataloader.PRED[self.status['counter']])]))
self.annotate.reannotate_label.setText('Reannotate')
self.hypnogram_ax.setTitle(
'Model Prediction: {}, Epoch: {}/{}'
.format(sleep_level[int(
self.dataloader.PRED[self.status['counter']])],
self.status['counter'] + 1,
len(self.dataloader.PRED)
)
)
def __init__(self, tau=5):
self.axis = pg.PlotWidget(title="Event triggered",
labels={
'left': 'Volts',
'bottom': 'Time (seconds)'
})
self.axis.addLegend(offset=(-10, 10))
self.prev_plot = self.axis.plot(pen=pg.mkPen(
pg.hsvColor(0.6, sat=0, alpha=0.3)),
name='latest')
self.ave_plot = self.axis.plot(pen=pg.mkPen(pg.hsvColor(0.6)),
name='average')
self.axis.addItem(
pg.InfiniteLine(pos=0,
angle=90,
pen=pg.mkPen(style=QtCore.Qt.DotLine)))
self.axis.setXRange(triggered_dur[0], triggered_dur[1], padding=0)
self.alpha = 1 - np.exp(
-1. / tau
) # Learning rate for update of average trace, tau is time constant.
def update(self):
t1=time.clock()
points=100 #number of data points
X=np.arange(points)
Y=np.sin(np.arange(points)/points*3*np.pi+time.time())
C=pyqtgraph.hsvColor(time.time()/5%1,alpha=.5)
pen=pyqtgraph.mkPen(color=C,width=10)
self.grPlot.plot(X,Y,pen=pen,clear=True)
print("update took %.02f ms"%((time.clock()-t1)*1000))
if self.chkMore.isChecked():
QtCore.QTimer.singleShot(1, self.update) # QUICKLY repeat
def plot_data(self, plt, curves=None):
checked = self.model.checked_dict
if curves is None:
curves = []
for folder in checked.keys():
current_df = self.model.data[folder]
for key in checked[folder].keys():
if key in self.model.vr_headers[folder]:
for sweep in checked[folder][key]:
x = current_df['voltage recording']['Time'][sweep]
y = current_df['voltage recording'][key][sweep]
curve = plt.plot(x, y, pen=pg.hsvColor(0.0, sat=0.0, val=0.5, alpha=0.08))
curves.append(curve)
elif key in self.model.ls_headers[folder]:
for sweep in checked[folder][key]:
x = current_df['linescan'][key + ' Time'][sweep]
y = current_df['linescan'][key][sweep]
curve = plt.plot(x, y, pen=pg.hsvColor(0.0, sat=0.0, val=0.5, alpha=0.08))
curves.append(curve)
channel = list(checked[folder])[0]
if folder in self.model.ls_headers.keys():
if channel in self.model.ls_headers[folder]:
plt.setLabel('left', channel)
plt.setLabel('bottom', 'Time (s)')
else:
if channel == 'Primary':
label = channel + ' (' + current_df['file attributes']['File1']['primary']['unit'] + ')'
elif key == 'Secondary':
label = channel + ' (' + current_df['file attributes']['File1']['secondary']['unit'] + ')'
else:
label = channel + ' (V)'
plt.setLabel('left', label)
plt.setLabel('bottom', 'Time (s)')
plt.autoRange()
return curves
def plot_data(self, plt, curves=None):
checked = self.model.checked_dict
if curves is None:
curves = []
for folder in checked.keys():
current_df = self.model.data[folder]
for key in checked[folder].keys():
if key in self.model.vr_headers[folder]:
for sweep in checked[folder][key]:
x = current_df['voltage recording']['Time'][sweep]
y = current_df['voltage recording'][key][sweep]
curve = plt.plot(x, y, pen=pg.hsvColor(0.0, sat=0.0, val=0.5, alpha=0.08))
curves.append(curve)
elif key in self.model.ls_headers[folder]:
for sweep in checked[folder][key]:
x = current_df['linescan'][key + ' Time'][sweep]
y = current_df['linescan'][key][sweep]
curve = plt.plot(x, y, pen=pg.hsvColor(0.0, sat=0.0, val=0.5, alpha=0.08))
curves.append(curve)
channel = list(checked[folder])[0]
if folder in self.model.ls_headers.keys():
if channel in self.model.ls_headers[folder]:
plt.setLabel('left', channel)
plt.setLabel('bottom', 'Time (s)')
else:
if channel == 'Primary':
label = channel + ' (' + current_df['file attributes']['File1']['primary']['unit'] + ')'
elif key == 'Secondary':
label = channel + ' (' + current_df['file attributes']['File1']['secondary']['unit'] + ')'
else:
label = channel + ' (V)'
plt.setLabel('left', label)
plt.setLabel('bottom', 'Time (s)')
plt.autoRange()
return curves
def update(self, pos=0, msg=""):
""" Updates the image, setting the colormap"""
if self.print_indicator and self.indicator and not self.video_model == None:
C = pyqtgraph.hsvColor(1)
pen = pyqtgraph.mkPen(color=C, width=1)
data = np.zeros(10)
pos = int(
self.video_model.get_pos(datatype=self.model.get_datatype()))
self.indicator.setData(
[pos, pos], [self.indicator_min, self.indicator_max]
) #= self.plot_item.plot([pos,pos],[self.indicator_min,self.indicator_max],pen=pyqtgraph.mkPen(color=pyqtgraph.hsvColor(2),width=1))
def update(self, pos):
""" Updates indicator position
Args:
pos: Int describing the current position of the indicator
"""
if self.print_indicator and self.indicator and not self.video_model == None:
C = pyqtgraph.hsvColor(1)
pen = pyqtgraph.mkPen(color=C, width=1)
pos = int(
self.video_model.get_pos(datatype=self.model.get_datatype()))
self.indicator.setData([pos, pos],
[self.indicator_min, self.indicator_max])
def plot_data_new_axis(self, new_vb):
checked = self.model.checked_dict
curves = []
label = ""
for folder in checked.keys():
current_df = self.model.data[folder]
for key in checked[folder].keys():
if key in self.model.vr_headers[folder]:
for sweep in checked[folder][key]:
x = current_df['voltage recording']['Time'][sweep]
y = current_df['voltage recording'][key][sweep]
curve = pg.PlotDataItem(x, y, pen=pg.hsvColor(0.8, sat=1.0, val=0.8, alpha=0.08))
new_vb.addItem(curve)
curves.append(curve)
elif key in self.model.ls_headers[folder]:
for sweep in checked[folder][key]:
x = current_df['linescan'][key + ' Time'][sweep]
y = current_df['linescan'][key][sweep]
curve = pg.PlotDataItem(x, y, pen=pg.hsvColor(0.8, sat=1.0, val=0.8, alpha=0.08))
new_vb.addItem(curve)
curves.append(curve)
channel = list(checked[folder])[0]
if channel in self.model.ls_headers[folder]:
label = channel
else:
if channel == 'Primary':
label = channel + ' (' + current_df['file attributes']['File1']['primary']['unit'] + ')'
elif key == 'Secondary':
label = channel + ' (' + current_df['file attributes']['File1']['secondary']['unit'] + ')'
else:
label = channel + ' (V)'
new_vb.autoRange()
return curves, label
def plot_data_new_axis(self, new_vb):
checked = self.model.checked_dict
curves = []
label = ""
for folder in checked.keys():
current_df = self.model.data[folder]
for key in checked[folder].keys():
if key in self.model.vr_headers[folder]:
for sweep in checked[folder][key]:
x = current_df['voltage recording']['Time'][sweep]
y = current_df['voltage recording'][key][sweep]
curve = pg.PlotDataItem(x, y, pen=pg.hsvColor(0.8, sat=1.0, val=0.8, alpha=0.08))
new_vb.addItem(curve)
curves.append(curve)
elif key in self.model.ls_headers[folder]:
for sweep in checked[folder][key]:
x = current_df['linescan'][key + ' Time'][sweep]
y = current_df['linescan'][key][sweep]
curve = pg.PlotDataItem(x, y, pen=pg.hsvColor(0.8, sat=1.0, val=0.8, alpha=0.08))
new_vb.addItem(curve)
curves.append(curve)
channel = list(checked[folder])[0]
if channel in self.model.ls_headers[folder]:
label = channel
else:
if channel == 'Primary':
label = channel + ' (' + current_df['file attributes']['File1']['primary']['unit'] + ')'
elif key == 'Secondary':
label = channel + ' (' + current_df['file attributes']['File1']['secondary']['unit'] + ')'
else:
label = channel + ' (V)'
new_vb.autoRange()
return curves, label
def run_analysis(self):
times_list, freqs_list, indexes_list, unit = self.get_freq_vals()
if len(times_list) > 0:
if self.spike_plot_check.isChecked():
name = "Plot" + str(self.counter)
title = name + " - Detected spikes"
plt = self.plotWidget.addPlot(row=self.counter,
col=0,
name=name,
title=title)
plt.setXLink(self.current_x_link)
self.curves[name] = self.plot_data(plt)
self.add_analysis_plot(plt, name)
for i, curve in enumerate(self.curves[name]):
data = curve.getData()
x = data[0]
y = data[1]
plt.plot(x[indexes_list[i]],
y[indexes_list[i]],
pen=None,
symbolBrush=pg.mkColor('r'),
symbolPen=pg.mkPen('r'),
symbol="d")
if self.freq_plot_check.isChecked():
curves = []
name = "Plot" + str(self.counter)
title = name + " - Frequency vs. Time"
plt = self.plotWidget.addPlot(row=self.counter,
col=0,
name=name,
title=title)
plt.setXLink(self.current_x_link)
for i in range(len(times_list)):
curve = plt.plot(times_list[i],
freqs_list[i],
pen=pg.hsvColor(0.0,
sat=0.0,
val=0.5,
alpha=0.08))
curves.append(curve)
self.curves[name] = curves
self.add_analysis_plot(plt, name)
plt.setLabel('left', unit)
self.analysis_counter += 1
def __init__(self, parent=None):
self.comm = LLCom("/dev/ttyUSB1", self.update)
pyqtgraph.setConfigOption('background', 'w') #before loading widget
super(TelemetryApp, self).__init__(parent)
uic.loadUi('./telemetry.ui', self)
#Add sliders
self.sliders=[]
for i in range(40):
#~ slide = QtGui.QSlider(self.frame)
slide = SequenceSlider(self.frame)
slide.sequence = i # for reference
slide.setOrientation(QtCore.Qt.Vertical)
slide.setObjectName(("verticalSlider_%d" %(i)))
self.sliders.append(slide)
for slider in self.sliders:
#~ slider.valueChanged.connect(self.sliderchange)
slider.connect(slider,QtCore.SIGNAL("valueChanged(int)"), self,QtCore.SLOT("valueChangedSlot(int)"))
slider.setMaximum(255)
slider.setValue(100)
self.SequenceSliders.addWidget(slider)
#set grid
# self.SequencePlotter.plotItem.showGrid(True, True, 0.7)
self.bufferSize = 50
#data store
self.blade_data = np.zeros(self.bufferSize)
self.speed_data = np.zeros(self.bufferSize)
self.x_data = np.zeros(self.bufferSize)
self.y_data = np.zeros(self.bufferSize)
#curves
self.blade_curve = self.SequencePlotter.plot(pen=pyqtgraph.hsvColor(1.0, sat=1.0, val=1.0, alpha=1.0))
self.speed_curve = self.SequencePlotter.plot(pen=pyqtgraph.hsvColor(0.3, sat=1.0, val=1.0, alpha=1.0))
self.x_curve = self.SequencePlotter.plot(pen=pyqtgraph.hsvColor(0.8, sat=1.0, val=0.5, alpha=1.0))
self.y_curve = self.SequencePlotter.plot(pen=pyqtgraph.hsvColor(0.6, sat=1.0, val=1.0, alpha=1.0))
#vertical follow line
self.line = self.SequencePlotter.addLine(x=0)
#self.SequencePlotter.setRange(xRange=[0, self.bufferSize], yRange=[-50, 50])
self.SequencePlotter.setMouseEnabled(x=False, y=False)
self.SequencePlotter.setRange(rect=None, xRange=[0, 40], yRange=[-50, 50], padding=0.0, update=True, disableAutoRange=True)
self.comm.start()
def print_data(self, data):
""" Prints 1D-Data represented in a numpy array.
Args:
data: 1D Numpy Array containing values to be displayed.
"""
self.print_indicator = True #As soon as there is data we want to print the indicator upon update
self.plot_item = self.getPlotItem()
C = pyqtgraph.hsvColor(1)
pen = pyqtgraph.mkPen(color=C, width=1)
X = np.arange(len(data))
self.indicator_min = int(np.nanmin(data))
self.indicator_max = int(np.nanmax(data))
self.main_plot = self.plot_item.plot(X, data, pen=pen, clear=True)
if self.video_model != None:
pos = int(
self.video_model.get_pos(datatype=self.model.get_datatype()))
self.indicator = self.plot_item.plot(
[pos, pos], [self.indicator_min, self.indicator_max],
pen=pyqtgraph.mkPen(color=pyqtgraph.hsvColor(2), width=1))
def update(self):
X = self.X
t1 = time.clock()
if self.selection.currentText() == "Sine":
Y = self.sine()
elif self.selection.currentText() == "Cosine":
Y = self.cosine()
C = pyqtgraph.hsvColor(time.time() / 5 % 1, alpha=.5)
pen = pyqtgraph.mkPen(color=C, width=5)
self.plotter.plot(X, Y, pen=pen, clear=True)
print("Update took %.02f ms" % ((time.clock() - t1) * 1000))
if self.updatcheckbox.isChecked():
QtCore.QTimer.singleShot(1, self.update) # QUICKLY repeat
def update(self):
input_live = self.lineEditlive.text()
a = [int(si.get_live_price(input_live))]
points = 100 # number of data points
a.append(int(si.get_live_price(input_live)))
X = a
# Y = np.sin(np.arange(points) / points * 3 * np.pi + time.time())
C = pyqtgraph.hsvColor(time.time() / 5 % 1, alpha=.5)
pen = pyqtgraph.mkPen(color=C, width=5)
self.test.plot(X, pen=pen, clear=True)
# print("update took %.02f ms" % ((time.clock() - t1) * 1000))
if self.test1.isChecked():
QtCore.QTimer.singleShot(1, self.update) # QUICKLY repeat
def plot_phaseplot(self):
curves = []
x_data, y_data = self.get_phaseplot_vals()
if len(x_data) > 0:
name = "Plot" + str(self.counter)
title = name + " - Phase Plot"
plt = self.plotWidget.addPlot(row=self.counter, col=0, name=name, title=title)
for i in range(len(x_data)):
curve = plt.plot(x_data[i], y_data[i], pen=pg.hsvColor(0.0, sat=0.0, val=0.5, alpha=0.08))
curves.append(curve)
self.curves[name] = curves
self.add_analysis_plot(plt, name)
def wlPen(wl):
"""Return a pen representing the given wavelength"""
l1 = 400
l2 = 700
hue = np.clip(((l2-l1) - (wl-l1)) * 0.8 / (l2-l1), 0, 0.8)
val = 1.0
if wl > 700:
val = 1.0 * (((700-wl)/700.) + 1)
elif wl < 400:
val = wl * 1.0/400.
#print hue, val
color = pg.hsvColor(hue, 1.0, val)
pen = pg.mkPen(color)
return pen
def wlPen(wl):
"""Return a pen representing the given wavelength"""
l1 = 400
l2 = 700
hue = np.clip(((l2-l1) - (wl-l1)) * 0.8 / (l2-l1), 0, 0.8)
val = 1.0
if wl > 700:
val = 1.0 * (((700-wl)/700.) + 1)
elif wl < 400:
val = wl * 1.0/400.
#print hue, val
color = pg.hsvColor(hue, 1.0, val)
pen = pg.mkPen(color)
return pen
def setVoltages(self):
a = 1.0
h = a * np.sqrt(3) / 2
self.electrodeCoordinates = [[-3 * a / 2, 3 * h], [-a / 2, 3 * h],
[a / 2, 3 * h], [3 * a / 2, 3 * h],
[-2 * a, 2 * h], [-a, 2 * h], [0, 2 * h],
[a, 2 * h], [2 * a, 2 * h],
[-5 * a / 2, h], [-3 * a / 2, h],
[-a / 2, h], [a / 2, h], [3 * a / 2, h],
[5 * a / 2, h], [-3 * a, 0], [-2 * a, 0],
[-a, 0], [0, 0], [a, 0], [2 * a, 0],
[3 * a, 0], [-5 * a / 2, -h],
[-3 * a / 2, -h], [-a / 2, -h],
[a / 2, -h], [3 * a / 2, -h],
[5 * a / 2, -h], [-2 * a, -2 * h],
[-a, -2 * h], [0, -2 * h], [a, -2 * h],
[2 * a, -2 * h], [-3 * a / 2, -3 * h],
[-a / 2, -3 * h], [a / 2, -3 * h],
[3 * a / 2, -3 * h]]
self.electrodeCoordinates = np.array(self.electrodeCoordinates)
spots = []
for i in range(0, 37):
attr_name = 'channel' + str(i)
self.adDevice.write_attribute(
attr_name, self.voltageSliders[i].value() / 73.0)
self.voltageIndicators[i].setText("{:.2f}".format(
self.voltageSliders[i].value()))
#spots.append({'pos': self.electrodeCoordinates[i,:], 'data': 1, 'brush':pq.intColor(np.round(self.voltageSliders[i].value())), 'symbol': 'o', 'size': 50})
spots.append({
'pos':
self.electrodeCoordinates[i, :],
'data':
1,
'brush':
pq.hsvColor(self.voltageSliders[i].value() /
(self.maxVoltage * 5.5),
sat=1.0,
val=1.0,
alpha=1.0),
'symbol':
'o',
'size':
40
})
#spots.append({'pos': self.electrodeCoordinates[i,:], 'data': 1, 'brush':self.map.map(self.voltageSliders[i].value(),mode='qcolor'), 'symbol': 'o', 'size': 40})
self.plot11.addPoints(spots)
def setup_range(self):
self.win = np.hanning(self.bins)
FS = self.sampling_rate
#num_bars = int(round((self.bins - 1) * (self.hi - self.lo) / FS))
num_bars = len(np.zeros(self.bins)[self.lo: self.hi])
#print 'num_bars', num_bars, self.bins * (self.hi - self.lo) / FS
x = np.linspace(self.lo, self.hi, num_bars)
self.bars = pg.BarGraphItem(x=x, height=range(num_bars), width=1.0)
self.bars.setOpts(brushes=[pg.hsvColor(float(x) / num_bars) for x in range(num_bars)])
self.plot.addItem(self.bars)
def update(self):
if(len(ExampleApp.X) > 500):
ExampleApp.X = ExampleApp.X[len(ExampleApp.X)-499:]
ExampleApp.Y_x = ExampleApp.Y_x[len(ExampleApp.Y_x)-499:]
ExampleApp.count = ExampleApp.count + 1
t1=time.clock()
data = udp.update()
print(data)
ExampleApp.X = np.append(ExampleApp.X,ExampleApp.count)
ExampleApp.Y_x = np.append(ExampleApp.Y_x,float(data))
C=pyqtgraph.hsvColor(0,alpha=1)
pen=pyqtgraph.mkPen(color=C,width=2)
self.grPlot.plot(ExampleApp.X,ExampleApp.Y_x,pen=pen,clear=True)
print("update took %.02f ms"%((time.clock()-t1)*1000))
if self.chkMore.isChecked():
QtCore.QTimer.singleShot(1, self.update) # QUICKLY repeat
def print_data(self, data):
""" Prints data to dataplot
Args:
data: 2d float.64 numpy arrays containing values between 0 and 1
"""
self.print_indicator = True
self.imagedata = data
self.setImage(self.imagedata)
self.indicator_min = -200
self.indicator_max = 200
if self.video_model != None:
pos = int(self.video_model.get_pos(datatype="motion"))
self.indicator = self.view.plot(
[pos, pos], [self.indicator_min, self.indicator_max],
pen=pyqtgraph.mkPen(color=pyqtgraph.hsvColor(2), width=1))
def __init__(self, parent=None):
self.port = "/dev/ttyACM0"
self.baudrate = 19200
self.parity = serial.PARITY_NONE
self.stopbits = serial.STOPBITS_ONE
self.bytesize = serial.EIGHTBITS
self.timeout = 1
self.ser = None
#self.connect_to_pump()
self.port2 = "/dev/ttyUSB0"
self.baudrate2 = 115200
self.parity2 = serial.PARITY_NONE
self.stopbits2 = serial.STOPBITS_ONE
self.bytesize2 = serial.EIGHTBITS
self.timeout2 = 0.001
self.ser2 = None
self.connect_to_datalogger()
pyqtgraph.setConfigOption('background', 'w') #before loading widget
super(ExampleApp, self).__init__(parent)
self.setupUi(self)
self.startButton.clicked.connect(self.start_test)
self.stopButton.clicked.connect(self.stop_test)
self.newButton.clicked.connect(self.new_test)
self.StartPumpButton.clicked.connect(self.start_pump)
self.StopPumpButton.clicked.connect(self.stop_pump)
self.pressure_graph.plotItem.showGrid(True, True, 0.7)
self.force_graph.plotItem.showGrid(True, True, 0.7)
self.displacement_graph.plotItem.showGrid(True, True, 0.7)
self.color = pyqtgraph.hsvColor(0.38,0.92,0.47,alpha=.5)
self.pen = pyqtgraph.mkPen(color=self.color,width=10)
self.num_points = 100
self.X = np.arange(self.num_points)
self.pressure = deque([0.0]*self.num_points)
self.force = deque([0.0]*self.num_points)
self.displacement = deque([0.0]*self.num_points)
self.filename = None
self.plainTextEdit.appendPlainText('No filename')
self.test = False
self.pump_running = False
def update(self):
mutex.lock()
global dataHighSpeed
tempData = dataHighSpeed.readData()
mutex.unlock()
tempData = tempData * (5.0 / 1023.0) - average_Voltage
self.yBuffer.writeData(tempData)
C = pyqtgraph.hsvColor(hue=0, sat=0.9, val=1, alpha=0.7)
pen = pyqtgraph.mkPen(color=C, width=4)
self.grPlot.plot(self.X[:200],
self.yBuffer.theWholeRolledTruth()[:self.bufferSize -
200 - 1:-1],
pen=pen,
clear=True)
QtCore.QTimer.singleShot(
100, self.update
) # DO NOT LOWER THIS OR IT WILL CRASH! THIS IS A MAGIC NUMBER! You can increase it though.
def run_analysis(self):
times_list, freqs_list, indexes_list, unit = self.get_freq_vals()
if len(times_list) > 0:
if self.spike_plot_check.isChecked():
name = "Plot" + str(self.counter)
title = name + " - Detected spikes"
plt = self.plotWidget.addPlot(row=self.counter, col=0, name=name, title=title)
plt.setXLink(self.current_x_link)
self.curves[name] = self.plot_data(plt)
self.add_analysis_plot(plt, name)
for i, curve in enumerate(self.curves[name]):
data = curve.getData()
x = data[0]
y = data[1]
plt.plot(
x[indexes_list[i]],
y[indexes_list[i]],
pen=None,
symbolBrush=pg.mkColor("r"),
symbolPen=pg.mkPen("r"),
symbol="d",
)
if self.freq_plot_check.isChecked():
curves = []
name = "Plot" + str(self.counter)
title = name + " - Frequency vs. Time"
plt = self.plotWidget.addPlot(row=self.counter, col=0, name=name, title=title)
plt.setXLink(self.current_x_link)
for i in range(len(times_list)):
curve = plt.plot(times_list[i], freqs_list[i], pen=pg.hsvColor(0.0, sat=0.0, val=0.5, alpha=0.08))
curves.append(curve)
self.curves[name] = curves
self.add_analysis_plot(plt, name)
plt.setLabel("left", unit)
self.analysis_counter += 1
def average_plots(self):
choice_index = self.avg_option_dropdown.currentIndex()
try:
if any(self.curves[self.current_selected]):
if choice_index == 0:
x_data, y_data = self.get_average_data()
self.plot_objects[self.current_selected].clearPlots()
curve = self.plot_objects[self.current_selected].plot(x=x_data, y=y_data, pen=pg.mkPen('r'))
self.curves[self.current_selected] = [curve, ]
elif choice_index == 1:
self.add_new_plot(average_plot=True)
elif choice_index == 2:
x_data, y_data = self.get_average_data()
self.selected_curve[self.current_selected].setPen(pg.hsvColor(0.0, sat=0.0, val=0.5, alpha=0.08))
curve = self.plot_objects[self.current_selected].plot(x=x_data, y=y_data, pen=pg.mkPen('r'))
self.curves[self.current_selected] = [curve, ]
except KeyError:
pass
def init(self, lo=0, hi=125, bins=256, yrange=750, ratio=False):
self.widget = pg.PlotWidget()
self.widget.setLabel('bottom', 'Frequency', units='Hz')
self.bars = pg.BarGraphItem()
self.win = np.hanning(bins)
self.win = np.blackman(bins)
#self.win = np.ones(bins)
self.lo, self.hi = lo, hi
self.ratio = ratio
FS = self.input.sample_rate
self.gr_block.set_history(bins)
#num_bars = int(round((self.bins - 1) * (self.hi - self.lo) / FS))
# This is total bullshit:
num_bars = len(np.zeros(bins)[lo: hi])
x = np.linspace(self.lo, self.hi, num_bars)
self.bars = pg.BarGraphItem(x=x, height=range(num_bars), width=1.0)
self.bars.setOpts(brushes=[pg.hsvColor(float(x) / num_bars) for x in range(num_bars)])
self.widget.addItem(self.bars)
# TODO: Better autoranging features
#self.plot.enableAutoRange('xy', False)
self.widget.setYRange(0, yrange)
self.widget.enableAutoRange('y', 0.95)
self.buffer = np.zeros(bins)
self.timer = pg.QtCore.QTimer()
self.timer.timeout.connect(self.updateGUI)
self.timer.start(10)
ind_plot[f, c].plot(ind_rec_grand_trace.time_values, ind_rec_grand_trace.data, pen={'color': color, 'width': 2})
ind_plot[f, c].setLabels(left=('Vm', 'V'))
ind_plot[f, c].setLabels(bottom=('t', 's'))
if deconv is True:
ind_deconv = deconv_train(ind_pass_qc[:2])
ind_deconv_grand = TraceList(ind_deconv[0]).mean()
ind_rec_deconv_grand = TraceList(ind_deconv[1]).mean()
[deconv_ind_plot[f, c].plot(ind.time_values, ind.data, pen=trace_color) for ind in ind_deconv[0]]
[deconv_ind_plot[f, c].plot(rec.time_values, rec.data, pen=trace_color) for rec in ind_deconv[1]]
deconv_ind_plot[f, c].plot(ind_deconv_grand.time_values, ind_deconv_grand.data,
pen={'color': color, 'width': 2}, name=("n = %d" % n_synapses))
deconv_ind_plot[f, c].plot(ind_rec_deconv_grand.time_values, ind_rec_deconv_grand.data,
pen={'color': color, 'width': 2})
summary_plot[c, 0].setLabels(left=('Norm Amp', ''))
summary_plot[c, 0].setLabels(bottom=('Pulse Number', ''))
f_color = pg.hsvColor(hue=hue, sat=float(f+0.5)/len(freqs), val=1)
summary_plot[c, 0].plot(ind_amp_grand/ind_amp_grand[0], name=(' %d Hz' % freq), pen=f_color, symbol=symbols[f],
symbolBrush=f_color, symbolPen=None)
if connection_types[c] not in ind_amp_summary.keys():
ind_amp_summary[connection_types[c]] = []
ind_uid[connection_types[c]] = []
ind_amp_summary[connection_types[c]].append([freq, ind_amp])
ind_uid[connection_types[c]].append([freq, ind_pass_qc[2]])
for t, delta in enumerate(rec_t):
if delta not in recovery_grand.keys():
print ("%d ms not represented in data set for %s" % (delta, c_type))
continue
rec_offsets = pulse_offset_rec[delta]
rec_pass_qc = train_qc(recovery_grand[delta], rec_offsets, amp=qc_params[1][c], sign=qc_params[0], plot=None)
n_synapses = len(rec_pass_qc[0])
def plot_ratio_new_axis(self, new_vb):
checked = self.model.checked_dict
curves = []
label = ""
for folder in checked.keys():
current_df = self.model.data[folder]
if self.model.profile_ratio:
profile_a = self.model.profile_a
profile_b = self.model.profile_b
label = profile_a + '/' + profile_b
try:
if len(checked[folder][profile_a]) != len(checked[folder][profile_b]):
QtGui.QMessageBox.about(self, "Error",
"Number of selected sweeps must be equal for each profile")
return "error"
else:
for sweep in checked[folder][profile_a]:
x = current_df['linescan'][profile_a + ' Time'][sweep]
y = current_df['linescan'][profile_a][sweep] / current_df['linescan'][profile_b][sweep]
curve = pg.PlotDataItem(x, y, pen=pg.hsvColor(0.0, sat=0.0, val=0.5, alpha=0.08))
new_vb.addItem(curve)
curves.append(curve)
except KeyError as e:
QtGui.QMessageBox.about(self, "Error", "No sweeps for %s selected" % e)
return "error"
else:
label = 'F/F0'
if self.model.f0_from_txt:
try:
f0 = float(self.model.f0_txt)
if self.model.f0_eq1:
for key in checked[folder].keys():
if key in self.model.ls_headers[folder]:
for sweep in checked[folder][key]:
x = current_df['linescan'][key + ' Time'][sweep]
y = (current_df['linescan'][key][sweep] - f0) / f0
curve = pg.PlotDataItem(x, y, pen=pg.hsvColor(0.0, sat=0.0, val=0.5, alpha=0.08))
new_vb.addItem(curve)
curves.append(curve)
else:
for key in checked[folder].keys():
if key in self.model.ls_headers[folder]:
for sweep in checked[folder][key]:
x = current_df['linescan'][key + ' Time'][sweep]
y = current_df['linescan'][key][sweep] / f0
curve = pg.PlotDataItem(x, y, pen=pg.hsvColor(0.0, sat=0.0, val=0.5, alpha=0.08))
new_vb.addItem(curve)
curves.append(curve)
except ValueError:
QtGui.QMessageBox.about(self, "Error", "F0 must be a numeric value")
return "error"
else:
try:
index1 = self.get_marker_vals(self.plot_markers[self.current_selected]["Marker One"],
get_index=True)
index2 = self.get_marker_vals(self.plot_markers[self.current_selected]["Marker Two"],
get_index=True)
if self.model.f0_eq1:
for key in checked[folder].keys():
if key in self.model.ls_headers[folder]:
for sweep in checked[folder][key]:
if index1 < index2:
f0 = current_df['linescan'][key][sweep][index1:index2].mean()
elif index2 < index1:
f0 = current_df['linescan'][key][sweep][index2:index1].mean()
else:
print(index1, index2)
QtGui.QMessageBox.about(self, "Error", "Baseline region is 0\n"
"Set baseline region with markers")
return "error"
x = current_df['linescan'][key + ' Time'][sweep]
y = (current_df['linescan'][key][sweep] - f0) / f0
curve = pg.PlotDataItem(x, y, pen=pg.hsvColor(0.0, sat=0.0, val=0.5, alpha=0.08))
new_vb.addItem(curve)
curves.append(curve)
else:
for key in checked[folder].keys():
if key in self.model.ls_headers[folder]:
for sweep in checked[folder][key]:
if index1 < index2:
f0 = current_df['linescan'][key][sweep][index1:index2].mean()
elif index2 < index1:
f0 = current_df['linescan'][key][sweep][index2:index1].mean()
else:
QtGui.QMessageBox.about(self, "Error", "Baseline region is 0\n"
"Set baseline region with markers")
return "error"
x = current_df['linescan'][key + ' Time'][sweep]
y = current_df['linescan'][key][sweep] / f0
curve = pg.PlotDataItem(x, y, pen=pg.hsvColor(0.0, sat=0.0, val=0.5, alpha=0.08))
new_vb.addItem(curve)
curves.append(curve)
except KeyError:
QtGui.QMessageBox.about(self, "Error", "Add markers to %s to set F0 region"
% self.current_selected)
return "error"
new_vb.autoRange()
return curves, label
def keyPressEvent(self, event):
key = event.key()
try:
all_curves = self.curves[self.current_selected] + self.axis2_curves[self.current_selected]
selected_index = self.current_curve_index[self.current_selected]
if key == QtCore.Qt.Key_Up or key == QtCore.Qt.Key_Left:
try:
if selected_index-1 >= 0:
new_selected_curve = all_curves[selected_index-1]
if new_selected_curve in self.curves[self.current_selected]:
new_selected_curve.setPen(pg.mkPen('b'))
elif new_selected_curve in self.axis2_curves[self.current_selected]:
new_selected_curve.setPen(pg.hsvColor(0.8, sat=1.0, val=0.8, alpha=1.0))
if self.selected_curve[self.current_selected] in self.curves[self.current_selected]:
self.selected_curve[self.current_selected].setPen(pg.hsvColor(0.0, sat=0.0, val=0.5,
alpha=0.08))
elif self.selected_curve[self.current_selected] in self.axis2_curves[self.current_selected]:
self.selected_curve[self.current_selected].setPen(pg.hsvColor(0.8, sat=1.0, val=0.8,
alpha=0.08))
#if new_selected_curve == self.curves[self.current_selected][-1]:
#self.axis2_curves[self.current_selected][0].setPen(pg.hsvColor(0.8, sat=1.0, val=0.8, alpha=1.0))
self.selected_curve[self.current_selected] = new_selected_curve
self.current_curve_index[self.current_selected] -= 1
except IndexError:
pass
try:
self.update_marker_vals(self.plot_markers[self.current_selected]["Marker One"], "Marker One",
self.plot_marker_labels[self.current_selected]["Label One"])
self.update_marker_vals(self.plot_markers[self.current_selected]["Marker Two"], "Marker Two",
self.plot_marker_labels[self.current_selected]["Label Two"])
except KeyError:
pass
elif key == QtCore.Qt.Key_Down or key == QtCore.Qt.Key_Right:
try:
if selected_index+1 < len(all_curves):
new_selected_curve = all_curves[selected_index+1]
if new_selected_curve in self.curves[self.current_selected]:
new_selected_curve.setPen(pg.mkPen('b'))
elif new_selected_curve in self.axis2_curves[self.current_selected]:
new_selected_curve.setPen(pg.hsvColor(0.8, sat=1.0, val=0.8, alpha=1.0))
if self.selected_curve[self.current_selected] in self.curves[self.current_selected]:
self.selected_curve[self.current_selected].setPen(pg.hsvColor(0.0, sat=0.0, val=0.5,
alpha=0.08))
elif self.selected_curve[self.current_selected] in self.axis2_curves[self.current_selected]:
self.selected_curve[self.current_selected].setPen(pen=pg.hsvColor(0.8, sat=1.0, val=0.8,
alpha=0.08))
#if new_selected_curve == self.axis2_curves[self.current_selected][0]:
#self.curves[self.current_selected][-1].setPen(pg.mkPen('b'))
self.selected_curve[self.current_selected] = new_selected_curve
self.current_curve_index[self.current_selected] += 1
except IndexError:
pass
try:
self.update_marker_vals(self.plot_markers[self.current_selected]["Marker One"], "Marker One",
self.plot_marker_labels[self.current_selected]["Label One"])
self.update_marker_vals(self.plot_markers[self.current_selected]["Marker Two"], "Marker Two",
self.plot_marker_labels[self.current_selected]["Label Two"])
except KeyError:
pass
except KeyError:
pass
