def onMarker_1(self, state):
if state == 2:
self.MARKERS[0] = True
self.ui.deltaCheck.setEnabled(True)
self.ui.markerEdit_1.setEnabled(True)
self.ui.markerEdit_1.setRange(1, 1280)
self.ui.markerEdit_1.setValue(self.center/1e6)
self.markerValue[0] = self.ui.markerEdit_1.value()
self.marker_1 = pg.CurvePoint(self.curve)
self.plot.addItem(self.marker_1)
self.markers[0] = self.marker_1
self.markerArrow_1 = pg.ArrowItem(angle=270)
self.markerArrow_1.setParentItem(self.marker_1)
self.markerText_1 = pg.TextItem("Mk1", anchor=(0.5, 1.5))
self.markerText_1.setParentItem(self.marker_1)
self.markerText[0] = self.markerText_1
elif state == 0:
self.MARKERS[0] = False
self.markerIndex[0] = None
self.markerValue[0] = None
self.markerText[0] = None
self.ui.markerEdit_1.setDisabled(True)
self.ui.deltaCheck.setDisabled(True)
self.plot.removeItem(self.marker_1)
self.marker_1.deleteLater()
self.marker_1 = None
def __init__(self, parent, place=0, name ="noname", xdata=[], ydata=[], color=1):
self.name =name
while (parent.colorRotation >= len(COLORS)):
parent.colorRotation = parent.colorRotation - len(COLORS)
#print("color", parent.colorRotation,len(COLORS) )
color = COLORS[color]
parent.colorRotation += 1
#color = (255,0,0)
self.curve = parent.p.plot(pen=color, name=name)
self.dat = ydata
self.xdat = xdata
#print(ydata)
self.maxLen = 1200*10 #1200 1 minut, 72000 en timme 1728000 24h
#print(1, self.curve)
self.curve.setData(x=self.xdat, y=self.dat)
## Set up an animated arrow and text that track the curve
#print(2)
self.curvePoint = pg.CurvePoint(self.curve)
#print(3)
parent.p.addItem(self.curvePoint)
self.arrow = pg.ArrowItem(angle=90)
parent.p.addItem(self.arrow)
self.text = pg.TextItem(self.name, anchor=(0.5, -1.0))
self.text.setParentItem(self.arrow)
def init_view_box(self, view_box):
self.curve = view_box.plot()
self.curve.setData(self.x_data, self.y_data)
self.curve_point = pg.CurvePoint(self.curve)
view_box.addItem(self.curve_point)
self.point_label = pg.TextItem('[?, ?]', anchor=(0.5, -1.0))
self.point_label.setParentItem(self.curve_point)
arrow2 = pg.ArrowItem(angle=90)
arrow2.setParentItem(self.curve_point)
def add_curvepoint_legend(self):
curve_points = []
for ch, (wave_curve, wave_name) \
in enumerate(zip(self.wave_curves, self.gv.waves)):
curve_points.append(pg.CurvePoint(wave_curve))
self.plot.addItem(curve_points[ch])
text = pg.TextItem(wave_name, anchor=(0.5, -1.0))
text.setParentItem(curve_points[ch])
arrow = pg.ArrowItem(angle=90)
arrow.setParentItem(curve_points[ch])
return curve_points
def __init__(self):
global dataPosX
super(pyshine_plot, self).__init__()
self.amplitude = 10
self.init_ui()
self.t = 0
self.qt_connections()
self.num_of_curves = 2
plotCurveIds = ["%d" % x for x in np.arange(self.num_of_curves)]
curvePointsIds = ["%d" % x for x in np.arange(self.num_of_curves)]
textIds = ["%d" % x for x in np.arange(self.num_of_curves)]
arrowIds = ["%d" % x for x in np.arange(self.num_of_curves)]
dataIds = ["%d" % x for x in np.arange(self.num_of_curves)]
self.plotcurves = plotCurveIds
self.curvePoints = curvePointsIds
self.texts = textIds
self.arrows = arrowIds
self.data = dataIds
# Iteration of the num of Curves
for k in range(self.num_of_curves):
self.plotcurves[k] = pg.PlotCurveItem()
# Here we can call an update plot functions
self.updateplot()
# Here we can again use the for loop for the rest of the items
for k in range(self.num_of_curves):
self.plotwidget.addItem(self.plotcurves[k])
self.curvePoints[k] = pg.CurvePoint(self.plotcurves[k])
self.plotwidget.addItem(self.curvePoints[k])
self.texts[k] = pg.TextItem(str(k),
color=Colors_Set[k],
anchor=(0.5, -1.0))
self.texts[k].setParentItem(self.curvePoints[k])
self.arrows[k] = pg.ArrowItem(angle=60,
pen=Colors_Set[k],
brush=Colors_Set[k])
self.arrows[k].setParentItem(self.curvePoints[k])
# Proxy Signal
self.proxy = pg.SignalProxy(self.plotwidget.scene().sigMouseMoved,
rateLimit=60,
slot=self.MouseMoved)
self.timer = pg.QtCore.QTimer()
self.timer.timeout.connect(self.moveplot)
self.timer.start(1000)
def onPeak(self, state):
if state == 2:
self.PEAK = True
self.peak = pg.CurvePoint(self.curve)
self.plot.addItem(self.peak)
self.peakArrow = pg.ArrowItem(angle=270)
self.peakArrow.setParentItem(self.peak)
self.peakText = pg.TextItem("Peak:", anchor=(0.5, 1.5))
self.peakText.setParentItem(self.peak)
elif state == 0:
self.PEAK = False
self.plot.removeItem(self.peak)
self.peak.deleteLater()
self.peak = None
def showLabel(self, item, points):
if self._curvepoint:
self.scene().removeItem(self._arrow)
self.scene().removeItem(self._text)
point = points[0]
self._curvepoint = pg.CurvePoint(item.curve)
self.addItem(self._curvepoint)
self._arrow = pg.ArrowItem(angle=90)
self._arrow.setParentItem(self._curvepoint)
self._arrow.setZValue(10000)
self._text = pg.TextItem(item.name(),
anchor=(0.5, -1.0),
border=pg.mkPen("w"),
fill=pg.mkBrush("k"))
self._text.setParentItem(self._curvepoint)
self._curvepoint.setIndex(list(item.scatter.points()).index(point))
def __init__(self):
super().__init__()
self.x = np.linspace(-20, 20, 1000)
self.y = np.sin(self.x) / self.x
self.k_plt.setYRange(-1, 2)
curve = self.k_plt.plot(self.x, self.y)
arrow = pg.ArrowItem(pos=(0, self.y.max()), angle=-45)
self.k_plt.addItem(arrow)
self.curvePoint = pg.CurvePoint(curve)
self.k_plt.addItem(self.curvePoint)
self.text2 = pg.TextItem("test", anchor=(0.5, -1.0))
self.text2.setParentItem(self.curvePoint)
arrow2 = pg.ArrowItem(angle=90)
arrow2.setParentItem(self.curvePoint)
self.move_slot = pg.SignalProxy(self.k_plt.scene().sigMouseMoved,
rateLimit=60,
slot=self.print_slot)
self.index = 0
def onDelta(self, state):
if state == 2:
self.DELTA = True
self.ui.deltaEdit.setEnabled(True)
self.ui.deltaEdit.setRange(1, 1280)
self.ui.deltaEdit.setValue(self.center/1e6)
self.deltaValue = self.ui.deltaEdit.value()
self.delta = pg.CurvePoint(self.curve)
self.plot.addItem(self.delta)
self.deltaArrow = pg.ArrowItem(angle=270)
self.deltaArrow.setParentItem(self.delta)
self.deltaText = pg.TextItem("Delta:", anchor=(0.5, 1.5))
self.deltaText.setParentItem(self.delta)
elif state == 0:
self.DELTA = False
self.ui.deltaEdit.setDisabled(True)
self.plot.removeItem(self.delta)
self.delta.deleteLater()
self.delta = None
x = np.arange(-(args.sec) + period, period, period)
# == PLOT TEMPERATURES ==
p1 = l.addPlot(name='Plot1', title='Temperatures', col=1, row=1)
p1.addLegend()
p1.setLabel('left', 'temperature', units='oC')
p1.setLabel('bottom', 'time', units='s')
p1.setRange(xRange=(-(args.sec),0), yRange=(0,500))
p1.showGrid(x=False, y=True, alpha=0.5)
datas['tempdc'] = [0] * int(args.sec / period)
curve['tempdc'] = p1.plot(x=x, y=datas['tempdc'], pen=colors['tempdc'], name='curent')
curve['tempdc'].setOpacity(CURVE_A)
datas['target'] = [0] * int(args.sec / period)
curve['target'] = p1.plot(x=x, y=datas['target'], pen=colors['target'], name='target')
curve['target'].setOpacity(CURVE_A)
cp['tempdc'] = pg.CurvePoint(curve['tempdc'])
p1.addItem(cp['tempdc'])
label['tempdc'] = pg.TextItem(text="", anchor=(1, 0.25), color=colors['tempdc'], angle=90)
label['tempdc'].setParentItem(cp['tempdc'])
cp['target'] = pg.CurvePoint(curve['target'])
p1.addItem(cp['target'])
label['target'] = pg.TextItem(text="", anchor=(1, -0.25), color=colors['target'], angle=90)
label['target'].setParentItem(cp['target'])
l.nextRow()
# == PLOT DUTY CYCLE ==
p2 = l.addPlot(name='Plot2', title='Duty cycle', col=1, row=2)
p2.setXLink('Plot1')
p2.setLabel('left', 'DC', units='%')
import pyqtgraph as pg
from pyqtgraph.Qt import QtCore, QtGui
import numpy as np
x = np.linspace(-20, 20, 1000)
y = np.sin(x) / x
plot = pg.plot() ## create an empty plot widget
plot.setYRange(-1, 2)
plot.setWindowTitle('pyqtgraph example: text')
curve = plot.plot(x, y) ## add a single curve
## Set up an animated arrow and text that track the curve
curvePoint = pg.CurvePoint(curve)
plot.addItem(curvePoint)
text2 = pg.TextItem("test", anchor=(0.5, -1.0))
text2.setParentItem(curvePoint)
arrow2 = pg.ArrowItem(angle=90)
arrow2.setParentItem(curvePoint)
## update position every 10ms
index = 0
def update():
global curvePoint, index
# index = (index + 1) % len(x)
index = 100
curvePoint.setPos(float(index) / (len(x) - 1))
text2.setText('Event type 1')
#**********************************************
p0 = win.addPlot()
p0.setRange(xRange=[0, 40], yRange=[0, 2])
p0.setLabel('bottom', 'Breathing Rate FFT(ft0)', 'bpm')
br2t = np.linspace(0, 600, 100)
curve_ft0 = p0.plot(ft0)
p1 = win.addPlot()
p1.setRange(xRange=[0, 200], yRange=[0, 2])
p1.setLabel('bottom', 'Heart Rate FFT(ft1)', 'bpm')
hr2t = np.linspace(0, 600, 100)
curve_ft1 = p1.plot(ft1)
## Set up an animated arrow and text that track the curve
# Breathing rate
curvePoint_br_rt = pg.CurvePoint(curve_ft0)
p0.addItem(curvePoint_br_rt)
text_br_rt = pg.TextItem("", anchor=(0.5, 1.7), color='y')
text_br_rt.setParentItem(curvePoint_br_rt)
arrow0 = pg.ArrowItem(angle=270)
arrow0.setParentItem(curvePoint_br_rt)
# Heart rate
curvePoint_hr_rt = pg.CurvePoint(curve_ft1)
p1.addItem(curvePoint_hr_rt)
text_hr_rt = pg.TextItem("", anchor=(0.5, 1.7), color='y')
text_hr_rt.setParentItem(curvePoint_hr_rt)
arrow1 = pg.ArrowItem(angle=270)
arrow1.setParentItem(curvePoint_hr_rt)
#*******************************
#*************
def _drawSpatialLayout(self, layout, layer=0, existing=[]):
"""Draws a spatial layout"""
# Get a starting list of existing items
items = existing
if not items:
# 0 is series of lines for each constraint, 1 is a dict of mass
# plots for each level, 2 is all labels
items.extend([[], {}, {}])
# Update the constraints (adding if we are missing one)
it = iter(items[0])
for c in layout._constraints:
ps = np.concatenate([m.pos for m in c.masses()])
constraint_plot = next(it, None)
if constraint_plot is None:
constraint_plot = self._plt.plot(ps[::2],
ps[1::2],
pen=_SL_LINES_PEN)
items[0].append(constraint_plot)
else:
constraint_plot.setData(ps[::2], ps[1::2])
# Update the masses by level (adding a level if needed...)
label_parents = {}
for level, g in itertools.groupby(
sorted(layout._masses, key=lambda x: x._level),
lambda x: x._level):
ms = list(g)
level_plot = items[1].get(level, None)
# Draw all of the mass nodes
ps = np.concatenate([m.pos for m in ms])
if level_plot is None:
s_size = 10 if level <= 1 else 10 * _SL_GROWTH_FACTOR * (
level - 1)
s = 'o' if level > sl.MASS_LEVEL_LABEL else 's'
s_pen = (_SL_NODES_PEN if level != sl.MASS_LEVEL_LABEL else
_SL_NODES_FIXED_PEN)
s_brush = (_SL_NODES_BRUSH if level != sl.MASS_LEVEL_LABEL else
_SL_NODES_FIXED_BRUSH)
level_plot = self._plt.plot(ps[::2],
ps[1::2],
pen=None,
symbol=s,
symbolSize=s_size,
symbolPen=s_pen,
symbolBrush=s_brush)
items[1][level] = level_plot
else:
level_plot.setData(ps[::2], ps[1::2])
# Save the data to help in labelling
for i, m in enumerate(ms):
label_parents[m.name] = (level_plot, i)
# Update all of the mass labels
for m in layout._masses:
label_item = items[2].get(m.name, None)
if label_item is None:
label_item = pg.TextItem(text=m.name,
color=_TEXT_COLOUR,
anchor=(0.5, 0))
label_item.setParentItem(pg.CurvePoint(*label_parents[m.name]))
items[2][m.name] = label_item
else:
label_item.setParentItem(pg.CurvePoint(*label_parents[m.name]))
# Add a title if appropriate
if layout._energy_log is not None and layout._energy_log.t:
self._plt.setTitle("t = %f" % (layout._energy_log.t[-1]))
# Finish up
Visualiser._setLayer(tools.flatten(items), layer)
return items
def add_marker(self, plot_title, date, angle=-90, text="", color='blue'):
"""
Add a marker to a plot
Args:
plot_title (str): The plot title to add a marker to
date (datetime.date): x-axis date to add a marker to
angle (int): Angle of the arrow marker. -90 is top down.
color (str): 'blue', 'green', or 'red'
Raises:
IndexError: If the date isn't present in the data set
"""
# get the plot
pl = self.plots[plot_title]
# convert date to timestamp
timestamp = datetime.datetime(date.year, date.month,
date.day).timestamp()
ld = pl.listDataItems()[0]
# get the index containing the nearest timestamp value for this x position
x_data = ld.getData()[0]
matches = np.where(x_data == timestamp)[0]
# if this happens, there is something wrong with the data
if len(matches) > 1:
raise Exception(
"There are more than one x index containing this timestamp")
elif len(matches) < 1:
raise IndexError("The timestamp " + str(date) +
" wasn't found in the data set")
else:
x_index = matches[0]
# a curvepoint refers to an xy point on the plot line
curvePoint = pg.CurvePoint(ld, index=x_index)
# background color
if color == 'blue':
brush = (0, 0, 255, 110) # blue
elif color == 'green':
brush = (0, 255, 0, 110) # green
elif color == 'red':
brush = (255, 0, 0, 150) # red
else:
raise Exception("Color '%s' isn't implemented" % color)
# create an arrow
arrow = pg.ArrowItem(angle=angle, brush=brush)
arrow.setParentItem(curvePoint)
if text != "":
# split into <span> tags
spans = []
for line in text.split("\n"):
spans.append(
'<span style="color: #FF0; font-size: 14pt;">%s</span>' %
line)
# create html text box
html = '<div style="text-align: center">%s</div>' % "<br>".join(
spans)
# Adjust the y anchor point to the number of lines in the text box.
# I don't know how to so this properly.
if len(spans) == 1:
anchor_y = 1.8
elif len(spans) == 2:
anchor_y = 1.45
elif len(spans) == 3:
anchor_y = 1.32
elif len(spans) == 4:
anchor_y = 1.25
elif len(spans) == 5:
anchor_y = 1.2
else:
raise Exception("%d line count text box isn't implemented" %
anchor_y)
# create the text box and attach it to the curve point
text = pg.TextItem(html=html,
anchor=(0.5, anchor_y),
border='w',
fill=brush)
text.setParentItem(curvePoint)
pl.addItem(curvePoint)
def create_dashboard(data, peaks, all_hr, all_br):
"""[summary]
Arguments:
data {numpy.ndarray} -- ECG plot
peaks {list} -- R peaks
all_hr {list} -- Heart rate per minute
all_br {list} -- Breathing rate per minute
"""
global i, rpindex, win, rpeakx, rpeaky, hr, br, hrslid, brslid, slidflaghr, slidflagbr, slidPoshr, slidPosbr, hrindex, chk, chkbr, popflag, trigflag, popwind
class KeyPressWindow(pg.GraphicsLayoutWidget):
sigKeyPress = QtCore.pyqtSignal(object)
def keyPressEvent(self, ev):
self.scene().keyPressEvent(ev)
self.sigKeyPress.emit(ev)
def keyPressed(evt):
if evt.key() == QtCore.Qt.Key_P:
timer.stop()
if evt.key() == QtCore.Qt.Key_S:
timer.start()
timer = QtCore.QTimer()
app = QtGui.QApplication(sys.argv)
mscreen = KeyPressWindow()
mscreen.sigKeyPress.connect(keyPressed)
mscreen.show()
mscreen.resize(tk.Tk().winfo_screenwidth(), tk.Tk().winfo_screenheight())
popwind = QtWidgets.QMessageBox()
popwind.setIcon(QtWidgets.QMessageBox.Critical)
popwind.setWindowTitle("WARNING/COURSE OF ACTION")
popwind.setFont(QtGui.QFont("sans-serif", 16))
changingLabel = QtGui.QLabel()
#########IDENTIFIERS###################
rpindex = 0
win = 37
hrindex = 37
slidPoshr = 0.5
slidPosbr = 0.5
popflag = 0
trigflag = 1
ecg = []
slidflaghr = 0
slidflagbr = 0
hr = all_hr[hrindex]
br = all_br[hrindex]
############ECG PLOT#############
rpeaks = pg.ScatterPlotItem(size=10,
pen=pg.mkPen(0.5),
brush=pg.mkBrush(0, 0, 255, 120))
ecgwind = mscreen.addPlot(row=0, col=0, colspan=3)
ecgwind.hideAxis('left')
ecgwind.hideAxis('bottom')
plt_grid = pg.GridItem()
ecgbg = ecgwind.getViewBox()
ecgbg.setBackgroundColor((255, 255, 255))
curve_ecg = ecgwind.plot(pen=pg.mkPen((0, 0, 0), width=1))
ecgwind.addItem(curve_ecg)
ecgwind.addItem(rpeaks)
ecgwind.addItem(plt_grid)
#####################################3
#####HEART RATE#############
curvex1 = np.linspace(-5, 5, 10)
curvey1 = np.sin(curvex1) / curvex1
hrwind = mscreen.addPlot(row=1, col=0)
hrwind.plot(x=curvex1, y=curvey1, pen=(255, 255, 255))
hrbg = hrwind.getViewBox()
hrbg.setBackgroundColor((255, 255, 255))
fileNamehr = '../images/HR.jpg'
imghr = pg.QtGui.QGraphicsPixmapItem(pg.QtGui.QPixmap(fileNamehr))
imghr.scale(1, -1)
hrwind.hideAxis('left')
hrwind.hideAxis('bottom')
hrwind.addItem(imghr)
hrval = pg.TextItem(color=(0, 0, 0), anchor=(-0.3, 0.5))
fonthrval = changingLabel.font()
fonthrval.setPointSize(86)
hrval.setFont(fonthrval)
fonthrval.setPointSize(40)
texthr = pg.TextItem(color=(0, 0, 0), anchor=(-0.3, 0.5))
fonthr = changingLabel.font()
fonthr.setPointSize(40)
texthr.setFont(fonthr)
texthr.setText("HR")
texthr.setPos(130, curvey1.max() / 2 - 220)
hrwind.addItem(hrval)
hrwind.addItem(texthr)
#################################
#####BREATHING RATE#############
curvex2 = np.linspace(-5, 5, 10)
curvey2 = np.sin(curvex2) / curvex2
brwind = mscreen.addPlot(row=1, col=1)
brwind.plot(x=curvex2, y=curvey2, pen=(255, 255, 255))
brbg = brwind.getViewBox()
brbg.setBackgroundColor((255, 255, 255))
filebr = '../images/BR.jpg'
imgbr = pg.QtGui.QGraphicsPixmapItem(pg.QtGui.QPixmap(filebr))
imgbr.scale(1, -1)
brwind.addItem(imgbr)
brwind.hideAxis('left')
brwind.hideAxis('bottom')
brval = pg.TextItem(color=(0, 0, 0), anchor=(-0.3, 0.5))
font1 = changingLabel.font()
font1.setPointSize(86)
brval.setFont(font1)
textbr = pg.TextItem(color=(0, 0, 0), anchor=(-0.3, 0.5))
fontbr = changingLabel.font()
fontbr.setPointSize(40)
textbr.setFont(fontbr)
textbr.setText("BR")
textbr.setPos(130, curvey2.max() / 2 - 220)
brwind.addItem(brval)
brwind.addItem(textbr)
#################################
###### SLIDER #############
slidwind = mscreen.addPlot(row=1, col=2)
slidbg = slidwind.getViewBox()
slidbg.setBackgroundColor((255, 255, 255))
curvex3 = np.linspace(0, 860, 2)
curvey3 = [-158 for x in curvex3]
fileslider = '../images/Slider.jpg'
imgslid = pg.QtGui.QGraphicsPixmapItem(pg.QtGui.QPixmap(fileslider))
imgslid.scale(1, -1)
slidwind.addItem(imgslid)
linehr = slidwind.plot(x=curvex3, y=curvey3, pen=(255, 255, 255))
hrslid = pg.CurvePoint(linehr)
slidwind.addItem(hrslid)
texthr1 = pg.TextItem(color=(0, 0, 0), anchor=(-0.3, 0.5))
fonthr1 = changingLabel.font()
fonthr1.setPointSize(40)
texthr1.setFont(fonthr1)
texthr1.setText("HR")
texthr1.setPos(320, curvey1.max() - 270)
slidwind.addItem(texthr1)
arrowhr = pg.ArrowItem(angle=90)
arrowhr.setStyle(headLen=30)
arrowhr.setParentItem(hrslid)
hrslid.setPos(slidPoshr)
curvey4 = [-465 for x in curvex3]
linebr = slidwind.plot(x=curvex3, y=curvey4, pen=(255, 255, 255))
brslid = pg.CurvePoint(linebr)
slidwind.addItem(brslid)
textbr1 = pg.TextItem(color=(0, 0, 0), anchor=(-0.3, 0.5))
fontbr1 = changingLabel.font()
fontbr1.setPointSize(40)
textbr1.setFont(fontbr1)
textbr1.setText("BR")
textbr1.setPos(320, curvey1.max() - 570)
slidwind.addItem(textbr1)
arrowbr = pg.ArrowItem(angle=90)
arrowbr.setStyle(headLen=30)
arrowbr.setParentItem(brslid)
brslid.setPos(slidPosbr)
slidwind.hideAxis('left')
slidwind.hideAxis('bottom')
##########################
rpeakx = [x for x in peaks[win] if x <= 1000]
rpeaky = [float(data[win][y]) for y in rpeakx]
chk = 1
chkbr = 1
for i in range(1, 1001):
ecg.append(float(data[win][i]))
rpindex = len(rpeakx)
def update():
global i, win, rpindex, rpeakx, rpeaky, hr, br, hrslid, brslid, slidflaghr, slidflagbr, slidPoshr, slidPosbr, hrindex, chk, chkbr, popflag, trigflag, popwind
rpeaks.clear()
ecg.pop(0)
if (len(rpeakx) != 0 and rpeakx[0] < 1):
rpeakx.pop(0)
rpeaky.pop(0)
rpeakx = [x - 1 for x in rpeakx]
if (i + 1 < len(data[win])):
i += 1
if (rpindex < len(peaks[win]) and i == peaks[win][rpindex]):
rpindex += 1
rpeakx.append(1000)
rpeaky.append(data[win][i])
else:
rpindex = 0
win += 1
i = 0
if 100 <= hr < 110:
meterhr = -1
slidflaghr = 1
elif hr < 100:
popflag = 1
meterhr = -2
slidflaghr = 1
elif 150 < hr < 160:
meterhr = 1
slidflaghr = 1
elif hr >= 160:
popflag = 1
meterhr = 2
slidflaghr = 1
else:
if (slidPoshr != 0.5):
slidflaghr = 1
meterhr = 0
if br > 45:
popflag = 1
slidflagbr = 1
meterbr = 2
if popflag == 1 and trigflag == 1:
trigflag = 0
if hr >= 160:
popwind.setText(
"Heart Rate High\nSeek medical attention if high heart rate persists"
)
elif hr <= 110:
popwind.setText(
"Heart Rate Low\nSeek medical attention if low heart rate persists"
)
else:
popwind.setText(
"Breathing Rate Abnormal\nSeek medical attention if following symptoms are displayed:\n1) Blueness\n2) Severe chest indrawing"
)
popwind.show()
if slidflaghr == 1 and chk == 1:
slidDest, direct = slider(meterhr, slidPoshr)
slidPoshr += direct * 0.002
if (direct == -1):
if slidPoshr <= slidDest:
slidflaghr = 0
chk = 0
elif (direct == 1):
if slidPoshr >= slidDest:
slidflaghr = 0
chk = 0
hrslid.setPos(slidPoshr)
if slidflagbr == 1 and chkbr == 1:
slidDestbr, directbr = slider(meterbr, slidPosbr)
slidPosbr += directbr * 0.002
if (directbr == -1):
if slidPosbr <= slidDestbr:
slidflagbr = 0
chkbr = 0
elif (directbr == 1):
if slidPosbr >= slidDestbr:
slidflagbr = 0
chkbr = 0
brslid.setPos(slidPosbr)
ecg.append(float(data[win][i]))
rpkx = [x - 1 for x in rpeakx]
rpky = rpeaky
if i % 2500 == 0:
hrindex += 1
hr = all_hr[hrindex] - 15
br = all_br[hrindex] + 31
chk = 1
chkbr = 1
trigflag = 1
hrval.setText('{} '.format(hr))
brval.setText('{} '.format(br))
popflag = 0
if hr < 100:
hrval.setPos(95, -159.5253)
else:
hrval.setPos(60, -159.5253)
brval.setPos(95, -159.5253)
rpeaks.addPoints(x=rpkx, y=rpky)
curve_ecg.setData(ecg)
def slider(meter, slidPoshr):
if meter == -2:
slidDest = 0
direct = -1
elif meter == -1:
slidDest = 0.25
if slidPoshr > 0.5:
direct = -1
elif slidPoshr < 0.5:
direct = 1
direct = -1
elif meter == 1:
slidDest = 0.75
if slidPoshr > 0.5:
direct = -1
elif slidPoshr < 0.5:
direct = 1
elif meter == 2:
slidDest = 1
direct = 1
elif meter == 0:
slidDest = 0.5
if slidPoshr > 0.5:
direct = -1
elif slidPoshr < 0.5:
direct = 1
return slidDest, direct
timer.timeout.connect(update)
timer.start(5)
if (sys.flags.interactive != 1) or not hasattr(QtCore, 'PYQT_VERSION'):
QtGui.QApplication.instance().exec_()
plot = win.addPlot(title="Solar System")
#Assign wavlue to orbit
for j in range(-100,101):
orbitX.append(j)
orbitY.append(math.sqrt((1-j*j/10000)*6400))
for j in range(100,-101,-1):
orbitX.append(j)
orbitY.append(math.sqrt((1-j*j/10000)*6400)*(-1))
#plot.plot(orbitX,orbitY)
curve = plot.plot(orbitX,orbitY,pen=pg.mkPen('y', width=2, style=QtCore.Qt.DashLine)) ## add a single curve
curve2=plot.plot(x,y,pen=pg.mkPen('b', width=1,style=QtCore.Qt.DashLine))
curve3=plot.plot(middleX,middleY,pen=pg.mkPen('r', width=1,style=QtCore.Qt.DashLine))
#---------------------------------------
curvePoint = pg.CurvePoint(curve)
curvePoint2=pg.CurvePoint(curve2)
curvePoint3=pg.CurvePoint(curve3)
#---------------------
arrow1 = pg.ArrowItem(angle=90)
arrow1.setParentItem(curvePoint)
text1 = pg.TextItem("test", anchor=(0.5, -1.0))
text1.setParentItem(curvePoint)
#=---------------
arrow2 = pg.ArrowItem(angle=90)
arrow2.setParentItem(curvePoint2)
text2 = pg.TextItem("test", anchor=(0.5, -1.0))
text2.setParentItem(curvePoint2)
#========
arrow3 = pg.ArrowItem(angle=90)
def display_images_and_bragg_edge(self,
tof_array=[],
lambda_array=[],
bragg_edges=[]):
data_type = self.data_type
plot_ui = self.plot_ui[data_type]
plot_ui.clear()
list_files_selected = self.parent.list_file_selected[self.data_type]
linear_region_left = list_files_selected[0]
linear_region_right = list_files_selected[-1]
x_axis = []
plot_ui.setLabel("left", "Total Counts")
_symbol = 't'
if tof_array == []:
plot_ui.setLabel('bottom', 'File Index')
for _key in bragg_edges.keys():
_bragg_edge = bragg_edges[_key]
if _bragg_edge == []:
continue
curve = plot_ui.plot(_bragg_edge,
symbolPen=None,
pen=pen_color[_key],
symbol=_symbol,
symbolSize=5)
x_axis = np.arange(len(_bragg_edge))
curvePoint = pg.CurvePoint(curve)
plot_ui.addItem(curvePoint)
_text = pg.TextItem("Group {}".format(_key), anchor=(0.5, 0))
_text.setParentItem(curvePoint)
arrow = pg.ArrowItem(angle=0)
arrow.setParentItem(curvePoint)
curvePoint.setPos(x_axis[-1])
else:
tof_array = tof_array * 1e6
o_gui = GuiHandler(parent=self.parent)
xaxis_choice = o_gui.get_xaxis_checked(data_type=self.data_type)
first_index = True
for _key in bragg_edges.keys():
_bragg_edge = bragg_edges[_key]
if _bragg_edge == []:
continue
if xaxis_choice == 'file_index':
curve = plot_ui.plot(_bragg_edge,
pen=pen_color[_key],
symbolPen=None,
symbolSize=5,
symbol=_symbol)
x_axis = np.arange(len(_bragg_edge))
elif xaxis_choice == 'tof':
curve = plot_ui.plot(tof_array,
_bragg_edge,
pen=pen_color[_key],
symbolPen=None,
symbolSize=5,
symbol=_symbol)
x_axis = tof_array
linear_region_left = tof_array[linear_region_left]
linear_region_right = tof_array[linear_region_right]
else: #lambda
if first_index:
lambda_array = lambda_array * 1e10
curve = plot_ui.plot(
lambda_array,
_bragg_edge,
pen=pen_color[_key],
symbolPen=None,
symbolSize=5,
)
x_axis = lambda_array
linear_region_left = lambda_array[linear_region_left]
linear_region_right = lambda_array[linear_region_right]
if first_index:
self.display_selected_element_bragg_edges(
plot_ui=plot_ui,
lambda_range=[lambda_array[0], lambda_array[-1]],
ymax=np.max(_bragg_edge))
first_index = False
curvePoint = pg.CurvePoint(curve)
plot_ui.addItem(curvePoint)
_text = pg.TextItem("Group {}".format(_key), anchor=(0.5, 0))
_text.setParentItem(curvePoint)
arrow = pg.ArrowItem(angle=0)
arrow.setParentItem(curvePoint)
if xaxis_choice == 'lambda':
last_position = x_axis[-1]
else:
last_position = x_axis[-1]
curvePoint.setPos(last_position)
return {
'x_axis': x_axis,
'linear_region': [linear_region_left, linear_region_right]
}
def plot_worker_mpl(queue, stop_event):
out_file = self.output_file
step = 1
axs = {}
num_props = len(self.monitor)
rows = np.ceil(num_props / 3)
if backend == "matplotlib":
import matplotlib.pyplot as plt
# only use the TkAgg backend if in console
try:
from IPython import get_ipython
if 'IPKernelApp' not in get_ipython(
).config: # pragma: no cover
raise ImportError("console")
except Exception:
import matplotlib
matplotlib.use("TkAgg")
plt.ion()
fig = plt.figure()
fig.canvas.toolbar.pack_forget()
for i, prop_name in enumerate(self.monitor):
axs[prop_name] = fig.add_subplot(rows, cols,
i + 1) # i + 1)
elif backend == "pyqtgraph":
from pyqtgraph.Qt import QtGui
import pyqtgraph as pg
# pg.setConfigOption('background', 'w')
app = QtGui.QApplication([])
win = pg.GraphicsWindow(title="Properties")
plots = {}
text = {}
# win.ci.setContentsMargins(20, 0, 0, 0)
for i, prop_name in enumerate(self.monitor):
plot_item = win.addPlot(title=prop_name,
row=i // cols,
col=i % cols)
plots[prop_name] = plot_item
axs[prop_name] = plot_item.plot(
pen=pg.mkPen('#FF2400', width=1))
QtGui.QApplication.processEvents()
else:
raise ValueError(
"invalid backed, valid backend options: matplotlib, pyqtgraph"
)
while True:
try:
properties = queue.get_nowait()
for prop_name in properties.keys():
prop_value = properties[prop_name]
ax = axs[prop_name]
# if prop_value is None:
# prop_value = 0
if self.backend == "matplotlib":
if step == 1:
xs = [step]
ys = [prop_value]
else:
line = ax.lines[0]
xs = np.append(line.get_xdata(), [step])
ys = np.append(line.get_ydata(), [prop_value])
line.set_xdata(xs)
line.set_ydata(ys)
ax.plot(xs[step - 1:],
ys[step - 1:],
color="#FF2400",
linestyle="solid")
if step == 1:
plt.tight_layout()
ax.set_title(prop_name)
elif self.backend == "pyqtgraph":
xs, ys = ax.getData()
if prop_value is not None:
if xs is None:
xs = []
ys = []
elif len(xs) == 1:
# create text label
curve_point = pg.CurvePoint(ax)
plots[prop_name].addItem(curve_point)
label = pg.TextItem("test",
color="#FF4200")
label.setParentItem(curve_point)
text[prop_name] = (curve_point, label)
xs = np.append(xs, [step])
ys = np.append(ys, [prop_value])
ax.setData(xs, ys)
if len(xs) > 1:
# update text label
curve_point, label = text[prop_name]
curve_point: pg.CurvePoint = curve_point
# curve point index relative to sample index (last in this case)
curve_point.setIndex(step - 1)
# anchor is relative to parent (top left corner)
label.setAnchor((1.0, 1.0))
label.setText('%0.3f' % (ys[-1]))
if self.backend == "matplotlib":
fig.canvas.draw_idle()
fig.canvas.flush_events()
else:
QtGui.QApplication.processEvents()
step += 1
except Empty:
if stop_event.is_set():
break
else:
if self.backend == "pyqtgraph":
QtGui.QApplication.processEvents()
if self.backend == "matplotlib":
plt.ioff()
if self.keep_open:
plt.show()
if save_plot:
out_file = self.output_file if self.output_file is not None else "train_run_{}.pdf".format(
str(os.getpid()))
plt.savefig(out_file)
plt.close(fig)
else:
if save_plot:
import pyqtgraph.exporters
exporter = pg.exporters.ImageExporter(win.scene())
if out_file is None:
out_file = "train_run_{}.pdf".format(str(os.getpid()))
exporter.export(out_file)
if self.keep_open:
QtGui.QApplication.instance().exec_()
app.closeAllWindows()
