def select_image(self):
'''
Select current image sequence to begin DIC setup.
'''
self.openFolder.setEnabled(False)
self.naprejButton.setEnabled(False)
self.nazajButton.setEnabled(True)
self.calibButton.setEnabled(True)
self.beginButton.setEnabled(True)
self.mode_selection.setEnabled(True)
pathtext = '<b>Selected directory:</b><br>' + self.dir_path
pathtext += '<br>(initial image - specify the region of interest)'
self.pathlabel.setText(pathtext)
self.default_calibration()
self.initialImage = tools.get_sequence(self.mraw_path, file_shape=(self.N_images, self.h, self.w), nmax=1).T
self.imw.setImage(self.initialImage)
self.imw.ui.histogram.hide()
# Add ROI widget to the view:
image_shape = self.initialImage.shape
roi_pos = (image_shape[0]//2 - self.min_roi_size[0], image_shape[1]//2 - self.min_roi_size[1])
ch_roi_pos = tools.get_roi_center(roi_pos, self.initial_roi_size)
roi_bound = QtCore.QRectF(0, 0, image_shape[0], image_shape[1])
self.imw.roi = pg.ROI(roi_pos, self.initial_roi_size, maxBounds=roi_bound, scaleSnap=True, translateSnap=True)
self.imw.CHroi = DotROI(ch_roi_pos, size=1, movable=False)
self.imw.view.addItem(self.imw.roi)
self.imw.view.addItem(self.imw.CHroi)
self.imw.roi.sigRegionChanged.connect(self.imw.roiChanged)
self.imw.roi.sigRegionChanged.connect(self.moving_roi)
self.imw.roi.sigRegionChangeFinished.connect(self.update_roi_position)
self.imw.roi.addScaleHandle(pos=(1, 1), center=(0.5, 0.5))
self.imw.roi.setPen(pg.mkPen(color=pg.mkColor('00FF6F'), width=2))
self.imw.CHroi.setPen(pg.mkPen(color=pg.mkColor('FF0000'), width=2))
self.roi_set = True
def __init__(self, layout):
if not isinstance(layout, pg.GraphicsLayoutWidget):
raise ValueError("layout must be instance of pyqtgraph.GraphicsLayoutWidget")
self.layout = layout
self.main_curve = True
self.main_color = pg.mkColor("y")
self.persistence = False
self.persistence_length = 5
self.persistence_decay = "exponential"
self.persistence_color = pg.mkColor("g")
self.peak_hold = False
self.peak_hold_color = pg.mkColor("r")
self.average = False
self.average_color = pg.mkColor("c")
self.smooth = False
self.smooth_length = 11
self.smooth_window = "hanning"
self.counter = 0
self.peak_hold_data = None
self.average_data = None
self.persistence_data = None
self.persistence_curves = None
self.create_plot()
def change_to_trace(self, trace):
""" Set curTrace to TRACE. Update all the buttons/table_slice
and then highlight the proper row in the table_traces."""
# Deselecting the previous curTrace
if self.curTrace is not None:
index = -1
for row in range(self.table_traces.rowCount()):
item = self.table_traces.item(row, 0)
if str(item.text()) == self.curTrace.name():
index = row
if index != -1:
item = self.table_traces.item(index, 0)
item.setBackgroundColor(pqg.mkColor(255, 255, 255, 255))
# Selecting the current trace
index = -1
for row in range(self.table_traces.rowCount()):
item = self.table_traces.item(row, 0)
if str(item.text()) == trace.name():
index = row
if index != -1:
item = self.table_traces.item(index, 0)
item.setBackgroundColor(pqg.mkColor(0, 200, 200, 200))
self.curTrace = trace
trace.update_slice_table(self.table_slice)
self.sync_buttons()
def pulseOverlayPens(self):
# TGCA
# Color ggrr
# Ampl 2121
return [ mkPen(mkColor("g"), width=4),
mkPen(mkColor("g"), width=2),
mkPen(mkColor("r"), width=4),
mkPen(mkColor("r"), width=2) ]
def show_scatter(self):
spots = [dict(pos=pos,
data=rules,
brush=pg.mkColor(np.clip(1/len(rules), 0, .8)),
pen=pg.mkColor(np.clip(1/len(rules), .1, .8) - .1))
for pos, rules in self.scatter_agg.items()]
self.scatter.scatter.setData(spots=spots)
self.scatter.plot.setRange(xRange=(0, 1), yRange=(0, 1))
self.scatter.show()
def update_state(self, state):
try:
ve = state[self.key + '.V']
vm = state['.'.join(self.key.split('.')[:-1]) + '.V']
self.setVisible(True)
except KeyError:
self.setVisible(False)
return
y = self.voltage.boundingRect().top()
grad = QtGui.QLinearGradient(QtCore.QPointF(0, y), QtCore.QPointF(0, y+25))
grad.setColorAt(0, pg.mkColor(v_color(vm)))
grad.setColorAt(1, pg.mkColor(v_color(ve)))
self.voltage.setBrush(QtGui.QBrush(grad))
self.current.update_state(state)
def _make_header_text(self, txt, rowcol, side, padding=5, font_size=None):
size = self.cell_size
if font_size is None:
font_size = size / 3.
small_font_size = font_size * 0.7
align = pg.QtCore.Qt.AlignLeft if side == 'top' else pg.QtCore.Qt.AlignRight
lines = str(txt).split('\n')
html = '<div style="line-height: 70%%">'
for i,line in enumerate(lines):
fs = font_size if i == 0 else small_font_size
if i > 0:
html += '<br>'
html += '<span style="font-size: %dpx;">%s</span>' % (fs, line)
html += '</div>'
item = pg.QtGui.QGraphicsTextItem("", parent=self)
item.setHtml(html)
item.setTextWidth(item.boundingRect().width())
doc = item.document()
opts = doc.defaultTextOption()
opts.setAlignment(align)
doc.setDefaultTextOption(opts)
if side == 'top':
item.rotate(-90)
br = item.mapRectToParent(item.boundingRect())
if side == 'top':
item.setPos(rowcol * size + size/2 - br.center().x(), -br.bottom() - padding)
elif side == 'left':
item.setPos(-br.right() - padding, rowcol * size + size/2. - br.center().y())
else:
raise ValueError("side must be top or left")
item.setDefaultTextColor(pg.mkColor(self.header_color))
item.setTextWidth(item.boundingRect().width()) # needed to enable text alignment
return item
def processPoint(self,_in_point):
# Check if this point is close to another point (less than some dist)
i = 0
for point in self._drawnPoints:
if point.contains(_in_point):
self._dataPoints.pop(i)
self._polygon.remove(i)
self._view.removeItem(self._drawnPoints[i])
self._drawnPoints.pop(i)
# Refresh the path:
self._path = QtGui.QPainterPath()
self._path.addPolygon(self._polygon)
self._polyGraphicsItem.setPath(self._path)
return
i +=1
# Point wasn't popped, so add it to the list
self._dataPoints.append(_in_point)
r = QtGui.QGraphicsEllipseItem(_in_point.x()-1, _in_point.y()-10, 2,20)
r.setBrush(pg.mkColor((0,0,0)))
self._view.addItem(r)
self._drawnPoints.append(r)
# Refresh the polygon and then update the path
self._polygon.append(_in_point)
# self._polyGraphicsItem.setPolygon(self._polygon)
self._path = QtGui.QPainterPath()
self._path.addPolygon(self._polygon)
self._polyGraphicsItem.setPath(self._path)
def setColor(self, color):
if color != self._color:
self._color = color
self.colorChanged.emit()
# handles different color formats
try:
r,g,b,a = pg.colorTuple(self._color)
except:
r,g,b,a = pg.colorTuple(pg.mkColor(self._color))
if self._color:
self.setStyleSheet('background-color: rgba(%d,%d,%d,%d);' %(r,g,b,a))
self._color = pg.mkColor(self._color)
else:
self.setStyleSheet("")
def __init__(self, kv=15, initial_mode='eds'):
pg.PlotWidget.__init__(self,
viewBox=CustomViewBox(),
labels={'left': ['counts', 'cts']},
axisItems={'left': pg.AxisItem('left'),
'bottom': CustomAxisItem('bottom')},
background=BACKGROUND_COLOR)
#p1 the main plotItem/canvas
#p2 secondary viewbox for EDS preview lines
#p3 third viewbox for EDS marked lines
self.p1 = self.plotItem
self.p2 = pg.ViewBox()
self.p3 = pg.ViewBox()
self.p1.scene().addItem(self.p2)
self.p2.setXLink(self.p1)
self.p3.setXLink(self.p1)
self.p3.setYLink(self.p1)
self.bottom_axis = self.p1.axes['bottom']['item']
self.updateViews()
self.x_axis_mode = initial_mode
self.set_kv(kv)
self.p1.vb.sigResized.connect(self.updateViews)
self.prev_text_size = 12
self.prev_marker_pen = pg.mkPen((255,200,255, 180), width=2)
self.prev_text_color = pg.mkColor((200,200,200))
self.p1.setLimits(yMin=0)
self.p3.setLimits(yMin=0)
self.p2.setLimits(yMin=0)
self.p2.setYRange(0, 1)
self.set_xtal(8.75, 0.000144) # default to PET crystal
self.set_x_mode(self.x_axis_mode)
self.set_connections()
def overlay(self):
alpha = 256.0/(len(self.exp)-len(self.bad))
color = pg.mkColor(0,0,0,alpha)
self.ui.grafo.clear()
for i in xrange(len(self.exp)):
if self.alignFlags[i] and self.exp[i].relevant:
self.ui.grafo.plot(self.exp[i][-1].z,self.exp[i][-1].f,pen=None,symbol='o',symbolSize = 2,symbolPen = color, symbolBrush = color)
def _plot_clicked(self, ev):
item = self.plots.scene().itemAt(ev.scenePos())
r,c = self.plots.item_index(item)
for i in range(self.plots.rows):
for j in range(self.plots.cols):
color = None if (i, j) != (r, c) else pg.mkColor(30, 30, 50)
self.plots[i,j].vb.setBackgroundColor(color)
def __init__(self, size=(40, 40, 40), spacing=(20, 20, 20)):
super(HocGrid, self).__init__()
self.grid = gl.GLGridItem(color=pg.mkColor(128, 128, 128))
self.grid.setSize(x=size[0], y=size[1], z=size[2]) # 100 um grid spacing
self.grid.setSpacing(x=spacing[0], y=spacing[1], z=spacing[2]) # 10 um steps
self.grid.scale(1,1,1) # uniform scale
self.grid.translate(100., 0., 0.)
def update_labels(self):
"""
Trigger an updaet of labels
The method calls `get_labels` which in turn calls the widget's
`get_label_data`. The obtained labels are shown if the corresponding
points are selected or if `label_only_selected` is `false`.
"""
for label in self.labels:
self.plot_widget.removeItem(label)
self.labels = []
if self.scatterplot_item is None \
or self.label_only_selected and self.selection is None:
return
labels = self.get_labels()
if labels is None:
return
black = pg.mkColor(0, 0, 0)
x, y = self.scatterplot_item.getData()
if self.label_only_selected:
selected = np.nonzero(self._filter_visible(self.selection))
labels = labels[selected]
x = x[selected]
y = y[selected]
for label, xp, yp in zip(labels, x, y):
ti = TextItem(label, black)
ti.setPos(xp, yp)
self.plot_widget.addItem(ti)
self.labels.append(ti)
def drawObjects(self, view_manager):
geom = view_manager._geometry
# Just draw the vertex to start:
info = self._process.getData()
vertex = info.vertex()
for view in view_manager.getViewPorts():
self._drawnObjects.append([])
offset = geom.offset(view.plane())
vertexPoint = larutil.GeometryHelper.GetME().Point_3Dto2D(
vertex, view.plane())
# print "VertexPoint in plane {plane}: ({w},{t})".format(
# plane=view.plane(),
# w=vertexPoint.w,
# t=vertexPoint.t)
points = self.makeCross(vertexPoint.w/geom.wire2cm(),
(vertexPoint.t + offset )/geom.time2cm(),
shortDistX=0.05/geom.wire2cm(),
longDistX=1.0/geom.wire2cm(),
shortDistY=0.05/geom.time2cm(),
longDistY=1.0/geom.time2cm(),
)
thisPolyF = QtGui.QPolygonF(points)
thisPoly = QtGui.QGraphicsPolygonItem(thisPolyF)
thisPoly.setBrush(pg.mkColor((200,200,200,200)))
self._drawnObjects[view.plane()].append(thisPoly)
view._view.addItem(thisPoly)
def __init__(self, parent=None):
QtGui.QSplitter.__init__(self, QtCore.Qt.Horizontal)
self.ctrlPanel = QtGui.QSplitter(QtCore.Qt.Vertical)
self.addWidget(self.ctrlPanel)
self.fieldList = QtGui.QListWidget()
self.fieldList.setSelectionMode(self.fieldList.ExtendedSelection)
self.ptree = ptree.ParameterTree(showHeader=False)
self.filter = DataFilterParameter()
self.colorMap = ColorMapParameter()
self.params = ptree.Parameter.create(name="params", type="group", children=[self.filter, self.colorMap])
self.ptree.setParameters(self.params, showTop=False)
self.plot = PlotWidget()
self.ctrlPanel.addWidget(self.fieldList)
self.ctrlPanel.addWidget(self.ptree)
self.addWidget(self.plot)
bg = pg.mkColor(pg.getConfigOption("background"))
bg.setAlpha(150)
self.filterText = pg.TextItem(border=pg.getConfigOption("foreground"), color=bg)
self.filterText.setPos(60, 20)
self.filterText.setParentItem(self.plot.plotItem)
self.data = None
self.mouseOverField = None
self.scatterPlot = None
self.style = dict(pen=None, symbol="o")
self.fieldList.itemSelectionChanged.connect(self.fieldSelectionChanged)
self.filter.sigFilterChanged.connect(self.filterChanged)
self.colorMap.sigColorMapChanged.connect(self.updatePlot)
def drawObjects(self, view_manager):
for view in view_manager.getViewPorts():
thisPlane = view.plane()
self._drawnObjects.append([])
# First get the hit information:
hits = self._process.getDataByPlane(thisPlane)
for i in xrange(len(hits)):
hit = hits[i]
# Draws a rectangle at (x,y,xlength, ylength)
r = QtGui.QGraphicsRectItem(
hit.wire(), hit.time(), 1, hit.rms())
opacity = hit.charge() / self._process.maxCharge(thisPlane)
# opacity = exp( 1 + hit.charge() / self._process.maxCharge(thisPlane))/exp(2);
# # New Way
# r.setPen(pg.mkPen(brush,width=2))
# # r.setBrush(pg.mkColor((255,255,255)))
# Old Way:
r.setPen(pg.mkPen(None))
r.setBrush(pg.mkColor(opacity))
# r.setBrush((0,0,0,opacity))
self._drawnObjects[thisPlane].append(r)
view._view.addItem(r)
def _symbolColor(pw, color=None, lineWidth=1, symbol='', symbolSize=3, fillLevel=None):
# color
color = _color(pw, color)
# line or symbol color
if lineWidth:
pen = pg.mkPen(color, width=lineWidth)
kwd = {'pen': pen}
else:
kwd = {'pen': None}
if symbol or symbolSize:
kwd['symbolBrush'] = color
kwd['symbolPen'] = color
# symbolPen is outline
# symbol
if symbol:
kwd['symbol'] = SYMBOLS[symbol]
if symbolSize:
kwd['symbolSize'] = symbolSize
# fill
if fillLevel is not None:
kwd['fillLevel'] = fillLevel
r, g, b, a = color.red(), color.green(), color.blue(), color.alpha()
if a == 255:
a = 50
else:
a //= 5
fillColor = pg.mkColor((r,g,b,a))
kwd['fillBrush'] = fillColor
return kwd
def refreshScaleBar(self):
if not self.useScaleBar:
return
# First, get the range in x and y:
# [[xmin, xmax], [ymin, ymax]]
dims = self._view.viewRange()
# The view bars get drawn on 10% of the lengths
# if ratio lock is set, only draw X
# Draw the X bar:
xMin = dims[0][0]
xMax = dims[0][1]
yMin = dims[1][0]
yMax = dims[1][1]
width = 0.1*(xMax - xMin)
height = 0.01*(yMax - yMin)
xLoc = xMin + 0.1*(xMax - xMin)
yLoc = yMin + 0.1*(yMax - yMin)
if self._xBar in self._view.addedItems:
self._view.removeItem(self._xBar)
self._view.removeItem(self._xBarText)
self._xBar = QtGui.QGraphicsRectItem(xLoc,yLoc,width,height)
self._xBar.setBrush(pg.mkColor(255,255,255))
self._view.addItem(self._xBar)
xString = ""
if self._cmSpace:
xString = "{0:.0f}".format(round(width*self._geometry.wire2cm()))
xString = xString + " cm"
else:
xString = "{0:.0f}".format(round(width))
xString = xString + " wires"
# Add the text:
self._xBarText = QtGui.QGraphicsSimpleTextItem(xString)
self._xBarText.setBrush(pg.mkColor(255,255,255))
xScale = 0.015* width
yScale = - 0.5* height
self._xBarText.setPos(xLoc,yLoc)
self._xBarText.scale(xScale,yScale)
self._xBarText.font().setPixelSize(15)
self._view.addItem(self._xBarText)
def __init__(self, parent = None):
self.parent = parent
self.d5 = Dock("Mouse", size=(500, 75), closable=False)
## Dock 5 - mouse intensity display
#self.d5.hideTitleBar()
self.w5 = pg.GraphicsView(background=pg.mkColor(color.mouseBackground))
self.d5.addWidget(self.w5)
def coloreaSueno(): print "coloreando barras de sueño" colors = [] num = 0 for i in y: if(i == 2): #Sueño ligero c = pg.mkColor(102, 102, 255) elif(i == 4): #Sueño profundo c = pg.mkColor(0, 0, 204) elif(i == 5): #Sueño muy profundo c = pg.mkColor(0, 0, 102) else: #Despierto c = pg.mkColor(255, 255, 0) colors.append(c) num = num + 1 print "num colores %i" % len(colors) return colors
def getcolor(color_def):
"""Make a QColor"""
try:
color = pg.mkColor(color_def)
except:
color = QColor(color_def)
if not color.isValid():
raise ValueError('Invalid color def {}'.format(color_def))
return color
def __init__(self, x, y, scene_size, parent=None):
super().__init__(parent)
self.arrows = [
pg.ArrowItem(pos=(x - scene_size * 0.07 * np.cos(np.radians(ang)),
y + scene_size * 0.07 * np.sin(np.radians(ang))),
parent=self, angle=ang,
headLen=13, tipAngle=45,
brush=pg.mkColor(128, 128, 128))
for ang in (0, 90, 180, 270)]
def __init__(self, x, y, parent=None, line=QLineF(), scene_size=1, text="", **kwargs):
super().__init__(parent, **kwargs)
self.arrows = [
pg.ArrowItem(pos=(x - scene_size * 0.07 * np.cos(np.radians(angle)),
y + scene_size * 0.07 * np.sin(np.radians(angle))),
parent=self, angle=angle,
headLen=13, tipAngle=45,
brush=pg.mkColor(128, 128, 128))
for angle in (0, 90, 180, 270)]
def __init__(self, text, fgcolor, bgcolor, rows, cols, size=50, border_color='k', header_color='w'):
pg.QtGui.QGraphicsItemGroup.__init__(self)
self._signalHandler = MatrixItem.SignalHandler()
self.sigClicked = self._signalHandler.sigClicked
self.cell_size = size
self.header_color = header_color
self.header_labels = {}
self.group_items = {}
self._make_header(rows, 'left')
self._make_header(cols, 'top')
self.cell_labels = []
self.cells = []
for i,row in enumerate(rows):
self.cells.append([])
self.cell_labels.append([])
for j,col in enumerate(cols):
x = j * size
y = i * size
rect = MatrixElementItem(size, parent=self)
rect.setPos(x, y)
rect.setBrush(pg.mkBrush(bgcolor[i][j]))
rect.setPen(pg.mkPen(border_color[i][j]))
rect.setZValue(-10)
rect.row = i
rect.col = j
rect.sigClicked.connect(self.element_clicked)
self.cells[-1].append(rect)
txt = pg.QtGui.QGraphicsTextItem(text[i][j], parent=self)
br = txt.boundingRect()
txt.setTextWidth(br.width())
txt.setPos(x + size/2 - br.center().x(), y + size/2 - br.center().y())
txt.setDefaultTextColor(pg.mkColor(fgcolor[i][j]))
self.cell_labels[-1].append(txt)
br = pg.QtCore.QRectF()
for item in self.childItems():
br = br.united(self.mapRectFromItem(item, item.boundingRect()))
self._bounding_rect = br
font_size = size / 2
for i in ('Presynaptic', 'Postsynaptic'):
html = '<span style="font-size: %dpx; font-weight: bold">%s</span>' % (font_size, i)
item = pg.QtGui.QGraphicsTextItem("", parent=self)
item.setHtml(html)
if i == 'Presynaptic':
item.rotate(-90)
x = self.boundingRect().left() - item.boundingRect().height()
y = item.boundingRect().width() + ((self.boundingRect().bottom() - item.boundingRect().width()) / 2)
elif i == 'Postsynaptic':
x = (self.boundingRect().right() - item.boundingRect().width()) / 2
y = self.boundingRect().top() - item.boundingRect().height()
item.setPos(x, y)
def createPlotSpec(self):
self.__sCurves = []
p = pg.PlotWidget(title='Spectrum')
p.setLabel('bottom','Wavelength [nm]')
p.setLabel('left','Amplitude [dBm]')
self.__Spectrum = pg.PlotCurveItem(pen=QtGui.QPen(self.specColor,self.lineWidth))
p.setBackground(pg.mkColor(self.backColor))
p.addItem(self.__Spectrum)
self.__sCurves.append(self.__Spectrum)
return p
def update(self):
self.setRowCount(len(self.Main.ROIs.ROI_list))
for i,ROI in enumerate(self.Main.ROIs.ROI_list):
self.setItem(i,0,QtGui.QTableWidgetItem(ROI.label))
if i == self.Main.ROIs.active_ROI_id:
if type(ROI) == myCircleROI:
ROI.setPen(pg.mkPen(pg.mkColor('y'),width=1.8)) ### FIXME layer pen and highlight pen
if type(ROI) == myPolyLineROI:
for segment in ROI.segments:
segment.setPen(pg.mkPen(pg.mkColor('y'),width=1.8)) ### FIXME layer pen and highlight pen
else:
if type(ROI) == myCircleROI:
ROI.setPen(pg.mkPen(self.Main.Data_Display.colors[ROI.layer],width=1.8))
if type(ROI) == myPolyLineROI:
for segment in ROI.segments:
segment.setPen(pg.mkPen(self.Main.Data_Display.colors[ROI.layer],width=1.8))
self.selectRow(self.Main.ROIs.active_ROI_id)
def __init__(self,*args,**kwargs):
super(GLViewWidget,self).__init__(*args,**kwargs)
self.z_zoom=10
self.setCameraPosition(distance=30000)
# self.setMinimumSize(300,300)
self.setSizePolicy(qg.QSizePolicy.Policy.MinimumExpanding,qg.QSizePolicy.Policy.MinimumExpanding)
# c = pg.mkColor(120,120,200)
c = pg.mkColor(1,1,1)
# print(c)
self.setBackgroundColor(c)
def initialize(self):
self.viewBox = MyViewBox()
self.viewBox.gain_zoom.connect(self.gain_zoom)
self.plot = pg.PlotItem(viewBox=self.viewBox)
self.graphicsview.setCentralItem(self.plot)
self.plot.hideButtons()
self.scatters = {}
brush = QtGui.QColor("magenta")
brush.setAlpha(180)
pen = QtGui.QColor("yellow")
self.scatters["sel"] = pg.ScatterPlotItem(pen=pen, brush=brush, size=11, pxMode=True)
self.plot.addItem(self.scatters["sel"])
self.scatters["sel"].setZValue(1000)
# ~ m = np.max(np.abs(self.data.values))
med, mad = median_mad(self.data)
m = 4.0 * np.max(mad.values)
self.limit = m
self.plot.setXRange(-m, m)
self.plot.setYRange(-m, m)
ndim = self.data.shape[1]
self.projection = np.zeros((ndim, 2))
self.projection[0, 0] = 1.0
self.projection[1, 1] = 1.0
self.plot2 = pg.PlotItem(viewBox=MyViewBox(lockAspect=True))
self.graphicsview2.setCentralItem(self.plot2)
self.plot2.hideButtons()
angles = np.arange(0, 360, 0.1)
self.circle = pg.PlotCurveItem(x=np.cos(angles), y=np.sin(angles), pen=(255, 255, 255))
self.plot2.addItem(self.circle)
self.direction_lines = pg.PlotCurveItem(x=[], y=[], pen=(255, 255, 255))
self.direction_data = np.zeros((ndim * 2, 2))
self.plot2.addItem(self.direction_lines)
self.plot2.setXRange(-1, 1)
self.plot2.setYRange(-1, 1)
self.proj_labels = []
for i in range(ndim):
label = pg.TextItem(
self.data.columns[i],
color=(1, 1, 1),
anchor=(0.5, 0.5),
border=None,
fill=pg.mkColor((128, 128, 128, 180)),
)
self.proj_labels.append(label)
self.plot2.addItem(label)
self.graphicsview2.setMaximumSize(200, 200)
# ~ self.hyper_faces = list(itertools.product(range(ndim), range(ndim)))
self.hyper_faces = list(itertools.permutations(range(ndim), 2))
self.n_face = -1
def change_background_color(self):
background_color = self.params['background_color']
try:
self.glview.setBackgroundColor(background_color)
except:
#~ #FIXME this is buggy in pyqtgrap0.9.8
bgcolor = pg.mkColor(QtGui.QColor(background_color))
glClearColor(bgcolor.red()/255., bgcolor.green()/255., bgcolor.blue()/255., 1.0)
glClear( GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT )
self.glview.paintGL()
self.glview.update()
def update_scatter_plots(self):
amp_recs = self._amp_recs
base_recs = self._base_recs
if amp_recs is None:
return
# select fg/bg data
fg_data = amp_recs
bg_data = base_recs[:len(fg_data)]
data_field = str(self.ui.field_combo.currentText())
if data_field != 'crosstalk':
data_field = self.analysis[0] + '_' + data_field
if self.analysis[0] == 'pos':
qc_field = 'ex_qc_pass' if self.analysis[
1] == 'ic' else 'in_qc_pass'
elif self.analysis[0] == 'neg':
qc_field = 'in_qc_pass' if self.analysis[
1] == 'ic' else 'ex_qc_pass'
fg_x = fg_data[data_field]
bg_x = bg_data[data_field]
fg_qc = fg_data[qc_field] == True
bg_qc = bg_data[qc_field] == True
# record data for later use
self.fg_x = fg_x
self.bg_x = bg_x
self.fg_qc = fg_qc
self.bg_qc = bg_qc
self.qc_field = qc_field
self.fg_data = fg_data
self.bg_data = bg_data
# select colors
pass_brush = pg.mkBrush((255, 255, 255, 80))
fail_brush = pg.mkBrush((150, 0, 0, 80))
fg_color = [(pass_brush if qc_pass else fail_brush)
for qc_pass in fg_qc]
bg_color = [(pass_brush if qc_pass else fail_brush)
for qc_pass in bg_qc]
for i in range(len(fg_data)):
# QC failures are colored red
if not fg_qc[i]:
continue
pulse_n = fg_data['pulse_number'][i] - 1
# If a pulse number is deselected, then we just mark it as qc-failed and color the point orange
if not self.pulse_checks[pulse_n].isChecked():
fg_color[i] = pg.mkBrush(255, 150, 0, 80)
fg_qc[i] = False
continue
# Otherwise, we can color by pulse number if requested
if self.ui.color_by_pulse_check.isChecked():
g = pulse_n * 255 / 7.
b = 255 - g
if pulse_n > 7:
color = pg.mkColor(0, 0, 0, 0)
else:
color = pg.mkColor(0, g, b, 80)
fg_color[i] = pg.mkBrush(color)
# clear old plots
self.fg_scatter.setData([])
self.bg_scatter.setData([])
self.hist_plot.clear()
self.hist_plot.setTitle("")
self.clear_trace_plots()
# clear click-selected plots
self._clicked_fg_ids = []
self._clicked_bg_ids = []
if len(fg_x) == 0:
return
# scatter plots of fg/bg data
fg_y = np.linspace(1.8, 1, len(fg_x))
bg_y = np.linspace(0.8, 0, len(bg_x))
self.fg_scatter.setData(fg_x, fg_y, data=fg_data, brush=fg_color)
self.bg_scatter.setData(bg_x, bg_y, data=bg_data, brush=bg_color)
# show only qc-passed data in histogram
fg_x_qc = fg_x[fg_qc]
bg_x_qc = bg_x[bg_qc]
if len(fg_x_qc) == 0 or len(bg_x_qc) == 0:
return
# plot histograms
n_bins = max(5, int(len(fg_x_qc)**0.5))
all_x = np.concatenate([fg_x_qc, bg_x_qc])
bins = np.linspace(np.percentile(all_x, 2), np.percentile(all_x, 98),
n_bins + 1)
fg_hist = np.histogram(fg_x_qc, bins=bins)
bg_hist = np.histogram(bg_x_qc, bins=bins)
self.hist_plot.plot(bg_hist[1],
bg_hist[0],
stepMode=True,
fillLevel=0,
brush=(255, 0, 0, 100),
pen=0.5)
self.hist_plot.plot(fg_hist[1],
fg_hist[0],
stepMode=True,
fillLevel=0,
brush=(0, 255, 255, 100),
pen=1.0)
# measure distance between distributions
ks = scipy.stats.ks_2samp(fg_x_qc, bg_x_qc)
self.hist_plot.setTitle("%s: KS=%0.02g" %
(' '.join(self.analysis), ks.pvalue))
# set event region, but don't update (it's too expensive)
try:
self.event_region.sigRegionChangeFinished.disconnect(
self.region_changed)
self.event_region.setRegion([fg_x_qc.min(), fg_x_qc.max()])
finally:
self.event_region.sigRegionChangeFinished.connect(
self.region_changed)
def __init__(self):
QMainWindow.__init__(self)
self.path = os.path.join(os.getcwd(),
"Projects") # Путь к папке с проектами
self.projects = os.listdir(self.path) # Проекты
self.current_project = "" # Имя проекта
self.current_test = "" # Имя испытания
self.data = pd.DataFrame() # Data from excel
self.x = [] # Data for x
self.x_name = "" # Имя столбца по оси X
self.y = [] # Chosen columns
self.type_flag = False # Необходимо для проверки данных на соответствие типу данных (число)
self.table_ready = False
self.file_path = "" # Отвечает за путь к .xlsx файлу
self.additional_data_flag = False # Флаг, обозначающий, что данные нужно дополнить
self.x_min = 0 # Нижняя граница дополнения
self.x_max = 0 # Верхняя граница дополнения
self.changed_flag = False
self.y_filtered = {} # Фильтрованные данные (y)
self.incorrect_data = {} # Данные с ошибками
self.many_cells = False # Флаг для метода изменения значений в нескольких ячейках
self.is_loading = False # Флаг текущей загрузки
self.setWindowTitle("Excel to data")
self.central_widget = QWidget(self) # Создаём центральный виджет
self.setCentralWidget(self.central_widget)
# Создаём все расположения
main_layout = QHBoxLayout() # Главное
left_layout = QVBoxLayout(
) # Для проектов, испытаний и вывода данных и .data
self.project_layout = QVBoxLayout() # Для проектов
self.tests_layout = QVBoxLayout() # Для испытаний
data_layout = QHBoxLayout() # Для представления данных
graph_layout = QVBoxLayout() # Для графиков
# Часть для окна с данными
self.table = QTableWidget(self) # Пустая таблица
self.table.setMinimumWidth(
int(QApplication.desktop().availableGeometry().width() * 0.3))
self.table.cellChanged.connect(
self.change_cell) # Возможность редактирования данных
# Часть для графиков
pg.setConfigOption('foreground', pg.mkColor("000000"))
# Создаём поле для графика
self.originalGraphWidget = pg.PlotWidget()
self.originalGraphWidget.setBackground('w')
self.originalGraphWidget.setTitle("Исходные данные")
self.originalGraphWidget.setLabel('left', 'Values')
self.originalGraphWidget.setLabel('bottom', 'X')
self.originalGraphWidget.showGrid(x=True, y=True)
self.originalGraphWidget.addLegend() # Описание: цвет - график
# Создаём поле для изменённого графика
self.changedGraphWidget = pg.PlotWidget()
self.changedGraphWidget.setBackground('w')
self.changedGraphWidget.setTitle("Изменённые данные")
self.changedGraphWidget.setLabel('left', 'Values')
self.changedGraphWidget.setLabel('bottom', 'X')
self.changedGraphWidget.showGrid(x=True, y=True)
self.changedGraphWidget.addLegend()
self.original_plt = []
self.changed_plt = []
# Часть для вывода
self.out_text = QTextEdit()
self.out_text.setMaximumHeight(
int(QApplication.desktop().availableGeometry().height() * 0.3))
self.out_text.setReadOnly(True)
# Второй поток
self.threadclass = thread.ThreadClass(self)
self.threadclass.finishSignal.connect(self.finishSignal_process)
data_layout.addLayout(self.project_layout)
data_layout.addLayout(self.tests_layout)
data_layout.addWidget(self.table)
left_layout.addLayout(data_layout)
left_layout.addWidget(self.out_text)
graph_layout.addWidget(self.originalGraphWidget)
graph_layout.addWidget(self.changedGraphWidget)
main_layout.addLayout(left_layout)
main_layout.addLayout(graph_layout)
self.central_widget.setLayout(main_layout)
self.create_menuBar()
self.update_project_layout()
self.update_tests_layout()
def updateTime(self, frame):
if frame == self.previousframe:
return
self.previousframe = frame
idx = self.currentPuff.currentIndex()
currentPuff = self.group.puffs[idx]
image1 = np.copy(self.I[frame])
mmax = np.max(self.I)
image1 = image1 / mmax
image2 = np.copy(self.I_fits[idx][frame])
image2 = image2 / mmax
self.puff_3D.update_images(image1, image2)
rel_frame = frame - (currentPuff.kinetics['t_start'] -
currentPuff.kinetics['before'])
for line in [self.vLine1, self.vLine2,
self.vLine5]: # self.vLine3,self.vLine4,self.vLine5]:
line.setValue(rel_frame)
for bar in self.error_bars:
bar.plot.removeItem(bar)
self.error_bars = []
for item in self.addedItems:
self.imageview.view.removeItem(item)
self.addedItems = []
scatter = pg.ScatterPlotItem(size=8, pen=pg.mkPen(None))
self.imageview.view.addItem(scatter)
self.addedItems.append(scatter)
spots = []
for i in np.arange(len(self.group.puffs)):
rel_frame2 = frame - ((currentPuff.kinetics['t_start'] -
currentPuff.kinetics['before']) -
(self.group.puffs[i].kinetics['t_start'] -
self.group.puffs[i].kinetics['before']))
if self.puffCheckBoxes[i].isChecked(
) and rel_frame2 >= 0 and rel_frame2 < self.params[i].shape[0]:
centers = self.params[i][:, :2] - self.bounds[1:, 0]
center = centers[rel_frame2, :]
amps = np.copy(self.params[i][:, -1])
amps[amps <= 0] = .00000001
amp = amps[rel_frame2]
std = self.group.puffs[0].clusters.standard_deviations[i]
color = np.array(self.colors[i])
color[3] = 50
### FIRST ADD THE POINT TO THE SCATTER PLOT
if 0.8 / amp < std: # if the amplitude>0 and the error (0.8/SNR) is within the fitting bounds
### FIRST PLOT THE
""" WARNING!!! the amp should really be the signal to noise ratio, so it is only valid when the image has been ratiod by the standard deviation of the noise """
sigma = 0.8 / amp
sigmas = 0.8 / amps
# add error bars to x and y
# first add X
color[3] = 255
err = pg.ErrorBarItem(
x=np.array([rel_frame]),
y=np.array([self.params[i][rel_frame2, 0]]),
top=np.array([sigma]),
bottom=np.array([sigma]),
beam=0.5,
pen=pg.mkPen(pg.mkColor(tuple(color))))
self.p3.addItem(err)
err.plot = self.p3
self.error_bars.append(err)
# second add Y
err = pg.ErrorBarItem(
x=np.array([rel_frame]),
y=np.array([self.params[i][rel_frame2, 1]]),
top=np.array([sigma]),
bottom=np.array([sigma]),
beam=0.5,
pen=pg.mkPen(pg.mkColor(tuple(color))))
self.p4.addItem(err)
err.plot = self.p4
self.error_bars.append(err)
reasonable_fit = sigmas < 2 * std
bounds = QRectF(
QPointF(center[0] - sigma, center[1] - sigma),
QSizeF(2 * sigma, 2 * sigma))
### plot outer circle
pathitem = QGraphicsEllipseItem(bounds)
color[-1] = 127 # alpha channel
pathitem.setPen(pg.mkPen(pg.mkColor(tuple(color))))
pathitem.setBrush(pg.mkColor((0, 0, 0, 0)))
self.imageview.view.addItem(pathitem)
self.addedItems.append(pathitem)
### plot line
frame_i = rel_frame2 - 6
if frame_i < 0:
frame_i = 0
alpha = 255
for ii in np.arange(rel_frame2, frame_i, -1) - 1:
if alpha <= 0 or not reasonable_fit[ii]:
break
color[-1] = alpha # alpha channel
alpha = alpha - (255 * 1. / 6.)
pathitem = QGraphicsPathItem()
pathitem.setPen(pg.mkColor(tuple(color)))
path = QPainterPath(QPointF(*centers[ii]))
path.lineTo(QPointF(*centers[ii + 1]))
pathitem.setPath(path)
self.imageview.view.addItem(pathitem)
self.addedItems.append(pathitem)
color[3] = 255 # make the spot transparent
spots.append({
'pos': center,
'brush': pg.mkBrush(pg.mkColor(tuple(color)))
})
scatter.addPoints(spots)
class _TriggerEvent:
"""
Class defining a trigger event.
Parameters
----------
event_type : str
The type of event. Supported: 'LPT'.
event_value : int | float
The value of the event displayed in the TextItem.
position_buffer : float
The time at which the event is positionned in the buffer where:
0 represents the older events exiting the buffer.
_BUFFER_DURATION represents the newer events entering the buffer.
position_plot : float
The time at which the event is positionned in the plotting window.
plot_handler : pyqtgraph.PlotItem
The plot handler.
plot_y_scale : int | float
The currently set signal range/scale.
"""
pens = {'LPT': pg.mkColor(0, 255, 0)}
def __init__(self, event_type, event_value, position_buffer, position_plot,
plot_handler, plot_y_scale):
assert event_type in self.pens.keys()
self.event_type = event_type
self.event_value = event_value
self.position_buffer = position_buffer # In time (s)
self.position_plot = position_plot # In time (s)
self.plot_handler = plot_handler
self.plot_y_scale = plot_y_scale
self.lineItem = None
self.textItem = None
self.plotted = False
def addEventPlot(self):
"""
Plots the event on the handler.
"""
if not self.plotted:
self.lineItem = pg.InfiniteLine(pos=self.position_plot,
pen=self.pens[self.event_type])
self.plot_handler.addItem(self.lineItem)
self.textItem = pg.TextItem(str(self.event_value),
anchor=(0.5, 1),
fill=(0, 0, 0),
color=self.pens[self.event_type])
self.textItem.setPos(self.position_plot, 1.5 * self.plot_y_scale)
self.plot_handler.addItem(self.textItem)
self.plotted = True
def update_scales(self, plot_y_scale):
"""
Update the signal range/scale used to position the TextItem.
"""
self.plot_y_scale = plot_y_scale
self._update()
def update_position(self, position_buffer, position_plot):
"""
Update the position on the plotting window and in the buffer.
"""
self.position_buffer = position_buffer
self.position_plot = position_plot
self._update()
def _update(self):
"""
Updates the plot handler.
"""
if self.lineItem is not None:
self.lineItem.setValue(self.position_plot)
if self.textItem is not None:
self.textItem.setPos(self.position_plot, 1.5 * self.plot_y_scale)
def removeEventPlot(self):
"""
Remove the event from the plot handler.
"""
if self.plotted:
self.plot_handler.removeItem(self.lineItem)
self.plot_handler.removeItem(self.textItem)
self.lineItem = None
self.textItem = None
self.plotted = False
def __del__(self):
try:
self.removeEventPlot()
except Exception:
pass
def contrasting_text_color(self, color):
# (r, g, b) = (hex_str[:2], hex_str[2:4], hex_str[4:])
r, g, b, a = pg.colorTuple(pg.mkColor(color))
return pg.mkBrush(
'000' if 1 -
(r * 0.299 + g * 0.587 + b * 0.114) / 255 < 0.5 else 'fff')
def change_asset(*args, **kwargs):
'''Resets and recalculates everything, and plots for the first time.'''
# save window zoom position before resetting
fplt._savewindata(fplt.windows[0])
symbol = ctrl_panel.symbol.currentText()
interval = ctrl_panel.interval.currentText()
ws.df = None
df = load_price_history(symbol, interval=interval)
ws.reconnect(symbol, interval, df)
# remove any previous plots
ax.reset()
axo.reset()
ax_rsi.reset()
# calculate plot data
indicators = ctrl_panel.indicators.currentText().lower()
data, price_data = calc_plot_data(df, indicators)
# some space for legend
ctrl_panel.move(100 if 'clean' in indicators else 200, 0)
# plot data
global plots
plots = {}
plots['price'] = fplt.candlestick_ochl(data['price'], ax=ax)
plots['volume'] = fplt.volume_ocv(data['volume'], ax=axo)
if data['ma50'] is not None:
plots['ma50'] = fplt.plot(data['ma50'], legend='MA-50', ax=ax)
plots['ma200'] = fplt.plot(data['ma200'], legend='MA-200', ax=ax)
plots['vema24'] = fplt.plot(data['vema24'],
color=4,
legend='V-EMA-24',
ax=axo)
if data['rsi'] is not None:
ax.set_visible(xaxis=False)
ax_rsi.show()
fplt.set_y_range(0, 100, ax=ax_rsi)
fplt.add_band(30, 70, color='#6335', ax=ax_rsi)
plots['sar'] = fplt.plot(data['sar'],
color='#55a',
style='+',
width=0.6,
legend='SAR',
ax=ax)
plots['rsi'] = fplt.plot(data['rsi'], legend='RSI', ax=ax_rsi)
plots['stoch'] = fplt.plot(data['stoch'],
color='#880',
legend='Stoch',
ax=ax_rsi)
plots['stoch_s'] = fplt.plot(data['stoch_s'], color='#650', ax=ax_rsi)
else:
ax.set_visible(xaxis=True)
ax_rsi.hide()
# price line
ax.price_line = pg.InfiniteLine(
angle=0,
movable=False,
pen=fplt._makepen(fplt.candle_bull_body_color, style='.'))
ax.price_line.setPos(price_data['last_close'])
ax.price_line.pen.setColor(pg.mkColor(price_data['last_col']))
ax.addItem(ax.price_line, ignoreBounds=True)
# restores saved zoom position, if in range
fplt.refresh()
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
from pyqtgraph.Qt import QtGui, QtCore
import pyqtgraph as pg
import numpy as np
import time
DISPLAY_TIME = 10
colors = [
pg.mkColor(65, 105, 225),
pg.mkColor(255, 100, 100),
pg.mkColor(255, 255, 100),
pg.mkColor(32, 178, 170),
pg.mkColor(153, 50, 204),
pg.mkColor(255, 250, 250)
]
colors2 = [
pg.mkColor(135, 206, 235),
pg.mkColor(255, 160, 122),
pg.mkColor(255, 255, 150)
]
start_time = time.time()
def __init__(self, recs):
pg.QtCore.QObject.__init__(self)
# Load all records into scatter plot widget
spw = pg.ScatterPlotWidget()
spw.style['symbolPen'] = None
spw.resize(1000, 800)
spw.show()
fields = [
('has_synapse', {
'mode': 'enum',
'values': [True, False, None]
}),
('synapse_type', {
'mode': 'enum',
'values': ['in', 'ex']
}),
('prediction', {
'mode': 'enum',
'values': [True, False, None]
}),
('confidence', {}),
('pre_cre_type', {
'mode': 'enum',
'values': list(set(recs['pre_cre_type']))
}),
('post_cre_type', {
'mode': 'enum',
'values': list(set(recs['post_cre_type']))
}),
('pre_pyramidal', {
'mode': 'enum',
'values': list(set(recs['pre_pyramidal']))
}),
('post_pyramidal', {
'mode': 'enum',
'values': list(set(recs['post_pyramidal']))
}),
('pre_target_layer', {
'mode': 'enum'
}),
('post_target_layer', {
'mode': 'enum'
}),
('ic_n_samples', {}),
('vc_n_samples', {}),
('rig_name', {
'mode': 'enum',
'values': list(set(recs['rig_name']))
}),
('acsf', {
'mode': 'enum',
'values': list(set(recs['acsf']))
}),
('acq_timestamp', {}),
('crosstalk_artifact', {
'units': 'V'
}),
# ('electrode_distance', {}),
('slice_quality', {
'mode': 'enum',
'values': list(range(1, 6))
}),
]
fnames = [f[0] for f in fields]
for f in recs.dtype.names:
if f in fnames:
continue
if 'amp' in f:
if f[:2] == 'vc':
fields.append((f, {'units': 'A'}))
else:
fields.append((f, {'units': 'V'}))
elif 'latency' in f:
fields.append((f, {'units': 's'}))
else:
fields.append((f, {}))
spw.setFields(fields)
spw.setData(recs)
spw.sigScatterPlotClicked.connect(self._conn_clicked)
# Set up scatter plot widget defaults
spw.setSelectedFields('ic_base_deconv_amp_mean', 'ic_deconv_amp_mean')
spw.filter.addNew('has_synapse')
ch = spw.filter.addNew('ic_crosstalk_mean')
ch['Min'] = -1
ch['Max'] = 60e-6
ch = spw.filter.addNew('rig_name')
ch = spw.colorMap.addNew('has_synapse')
ch['Values', 'True'] = pg.mkColor('y')
ch['Values', 'False'] = pg.mkColor(200, 200, 200, 150)
ch['Values', 'None'] = pg.mkColor(200, 100, 100)
ch = spw.colorMap.addNew('ic_latency_mean')
ch['Operation'] = 'Add'
ch['Max'] = 3e-3
cm = pg.ColorMap([0, 1], [[0, 0, 255, 255], [0, 0, 0, 255]])
ch.setValue(cm)
self.spw = spw
def __init__(self, launch_command=None, plan=None, com_method=com.DDS_COM):
super(Visualizer, self).__init__()
self.com_method = com_method
self.launch_command = launch_command
self.plan = plan
self.max_log_length = 500
self.log_updated = False
self.log_lines = 0
self.log_text = ""
self.data = dict()
for d in ekf_data.keys() + truth_data.keys() + ml_data.keys() + of_data.keys() + \
command_data.keys() + traj_data.keys() + shaper_data.keys() + pmc_data.keys():
self.data[d] = np.full(ARRAY_SIZE, 1e-10)
self.columns = [[plot_types.CtlPosPlot, plot_types.FeatureCountPlot, plot_types.ConfidencePlot, \
plot_types.CommandStatusPlot], [plot_types.CtlRotPlot, plot_types.CovPlot], \
[plot_types.Pmc1BlowerPlot, plot_types.Pmc2BlowerPlot, \
plot_types.Pmc1NozzlePlot, plot_types.Pmc2NozzlePlot]]
self.graphics_view = ParentGraphicsView()
self.terminal_graphics_view = TerminalGraphicsView(self.graphics_view)
self.terminal_view = TerminalView(self.terminal_graphics_view)
self.layout = pg.GraphicsLayout(border=(100, 100, 100))
self.layout.setBorder(None)
self.layout.setZValue(-1)
self.graphics_view.setCentralItem(self.layout)
self.graphics_view.scene().addWidget(self.terminal_graphics_view)
self.log_shown = False
self.pmc_enabled = True
self.setCentralWidget(self.graphics_view)
self.create_menu()
row = 0
for c in range(len(self.columns)):
l = self.layout.addLayout(0, c)
l.setBorder(pg.mkColor(150, 150, 150))
for r in range(len(self.columns[c])):
t = self.columns[c][r]
new_item = t() # it gets added to l in constructor
l.addItem(new_item)
if r != len(self.columns[c]) - 1:
l.nextRow()
else:
new_item.show_x_axis(True)
self.layout.nextColumn()
self.setWindowTitle('GNC Visualizer')
self.settings = QtCore.QSettings("NASA", "gnc_visualizer")
self.restoreGeometry(self.settings.value("geometry", "").toByteArray())
self.restoreState(self.settings.value("windowState", "").toByteArray())
QtGui.qApp.installEventFilter(self)
# make sure initial window size includes menubar
QtCore.QTimer.singleShot(0, self.menuBar().hide)
self.started = False
self.paused = False
self.proc = None
self.timer = QtCore.QTimer()
self.timer.timeout.connect(self.tick)
self.timer.start(40)
def drawObjects(self, view_manager):
geom = view_manager._geometry
# Just draw the vertex to start:
mcts = self._process.getData()
if len(mcts) == 0:
return
# Only the first neutrino for now
mct = mcts[0]
vertex = mct.vertex()
for view in view_manager.getViewPorts():
self._drawnObjects.append([])
offset = geom.offset(view.plane())
geo_helper = larutil.SimpleGeometryHelper(geom.getGeometryCore(),
geom.getDetectorProperties(),
geom.getDetectorClocks())
vertexPoint = geo_helper.Point_3Dto2D(vertex, view.plane(),
view.tpc(),
view.cryostat())
points = self.makeCross(vertexPoint.w/geom.wire2cm(),
(vertexPoint.t + offset )/geom.time2cm(),
shortDistX=0.05/geom.wire2cm(),
longDistX=1.0/geom.wire2cm(),
shortDistY=0.05/geom.time2cm(),
longDistY=1.0/geom.time2cm(),
)
thisPolyF = QtGui.QPolygonF(points)
thisPoly = QtGui.QGraphicsPolygonItem(thisPolyF)
thisPoly.setBrush(pg.mkColor((200,200,200,200)))
thisPoly.setToolTip('Neutrino Interaction Vertex')
self._drawnObjects[view.plane()].append(thisPoly)
view._view.addItem(thisPoly)
mb = view_manager.getMessageBar()
message = str()
tooltip = str()
if mct.origin() == 1:
pdg = pdg_to_name[mct.nu_pdg()]
mode = mode_to_name[mct.int_mode()]
message += f'PDG: {mct.nu_pdg()}, Neutrino Energy: {mct.nu_energy():.3} GeV, mode: {mode}'
fs_pdgs = mct.finalstate_pdg()
fs_enes = mct.finalstate_energy()
tooltip += 'Final State Particles'
for p, e in zip(fs_pdgs, fs_enes):
tooltip += f'\n PDG: {p}, Energy: {e:.3} GeV'
elif mct.origin() == 2:
message += f'Cosmic Origin'
elif mct.origin() == 3:
message += f'Supernovae Event'
elif mct.origin() == 4:
# message += f'Single Particle Generation'
message += f'Single particle. PDG: {mct.nu_pdg()}, Energy: {mct.nu_energy():.3} GeV.'
mb.showMessage(message)
mb.setToolTip(tooltip)
def setup(self, win):
win.setWindowTitle("Acconeer Button Press Example")
self.limit_lines = []
dashed_pen = pg.mkPen("k", width=2.5, style=QtCore.Qt.DashLine)
self.sign_hist_plot = win.addPlot(title="Signal history")
self.sign_hist_plot.setMenuEnabled(False)
self.sign_hist_plot.setMouseEnabled(x=False, y=False)
self.sign_hist_plot.hideButtons()
self.sign_hist_plot.addLegend()
self.sign_hist_plot.showGrid(x=True, y=True)
self.sign_hist_plot.setLabel("bottom", "Time (s)")
self.sign_hist_plot.setXRange(-HISTORY_LENGTH_S, 0)
self.sign_hist_plot.setYRange(0, OUTPUT_MAX_SIGNAL)
self.sign_hist_curve = self.sign_hist_plot.plot(
pen=utils.pg_pen_cycler(0),
name="Envelope signal",
)
self.sign_lp_hist_curve = self.sign_hist_plot.plot(
pen=utils.pg_pen_cycler(1),
name="Filtered envelope signal",
)
win.nextRow()
self.rel_dev_hist_plot = win.addPlot(
title="Relative deviation history")
self.rel_dev_hist_plot.setMenuEnabled(False)
self.rel_dev_hist_plot.setMouseEnabled(x=False, y=False)
self.rel_dev_hist_plot.hideButtons()
self.rel_dev_hist_plot.showGrid(x=True, y=True)
self.rel_dev_hist_plot.setLabel("bottom", "Time (s)")
self.rel_dev_hist_plot.setXRange(-HISTORY_LENGTH_S, 0)
self.rel_dev_hist_plot.setYRange(0, OUTPUT_MAX_REL_DEV)
self.rel_dev_lp_hist_curve = self.rel_dev_hist_plot.plot(
pen=utils.pg_pen_cycler(0),
name="Relative deviation",
)
self.detection_dots = self.rel_dev_hist_plot.plot(
pen=None,
symbol="o",
symbolSize=20,
symbolBrush=utils.color_cycler(1),
name="Detections",
)
self.rel_dev_hist_plot.addItem(self.detection_dots)
limit_line = pg.InfiniteLine(angle=0, pen=dashed_pen)
self.rel_dev_hist_plot.addItem(limit_line)
self.limit_lines.append(limit_line)
self.detection_html_format = '<div style="text-align: center">' \
'<span style="color: #FFFFFF;font-size:16pt;">' \
"{}</span></div>"
detection_html = self.detection_html_format.format(
"Button press detected!")
self.detection_text_item = pg.TextItem(
html=detection_html,
fill=pg.mkColor(255, 140, 0),
anchor=(0.5, 0),
)
self.detection_text_item.setPos(-HISTORY_LENGTH_S / 2,
0.95 * OUTPUT_MAX_REL_DEV)
self.rel_dev_hist_plot.addItem(self.detection_text_item)
self.detection_text_item.hide()
self.smooth_max_signal = utils.SmoothMax(
self.sensor_config.update_rate,
hysteresis=0.6,
tau_decay=3,
)
self.smooth_max_rel_dev = utils.SmoothMax(
self.sensor_config.update_rate,
hysteresis=0.6,
tau_decay=3,
)
self.setup_is_done = True
self.update_processing_config()
def plot_finite_element_mesh_onto_plot(plotItem, femesh, win=None, ele_c=None, label='', alpha=255, pw=0.7, copts=None,
):
"""
Plots a finite element mesh object
:param win:
:param femesh:
:param ele_c: array_like or str or None
Specifies how he elements are colored, if None the color based on soil index,
if str, the str must must a soil property and the color is scaled based on the value of the property
if array_like, if shape of soil_grid, then color scale based on value,
if array_like, if shape[:2] == soil_grid.shape(), and shape[2:]==3, then last axis interpreted as color values
:param pw: pen width
:return:
"""
if copts is None:
copts = {}
cscheme = copts.setdefault('scheme', 'red2yellow')
cbal = copts.setdefault('bal', 0)
cunits = copts.setdefault('units', '')
cinc = copts.setdefault('inc', None)
white_mid = copts.setdefault('white_mid', False)
crange = copts.setdefault('crange', None)
palpha = copts.setdefault('palpha', 80)
pen_col = copts.setdefault('pen_col', None)
leg_pen = copts.setdefault('leg_pen', 'w')
x_all = femesh.x_nodes
y_all = femesh.y_nodes
x_inds = []
y_inds = []
if hasattr(y_all[0], '__len__'): # can either have varying y-coordinates or single set
n_y = len(y_all[0])
else:
n_y = 0
ed = {}
cd = {}
active_eles = np.where(femesh.soil_grid != femesh.inactive_value)
for xx in range(len(femesh.soil_grid)):
x_ele = [xx, xx + 1, xx + 1, xx, xx]
x_inds += x_ele * (n_y - 1)
for yy in range(len(femesh.soil_grid[xx])):
sl_ind = femesh.soil_grid[xx][yy]
if sl_ind == femesh.inactive_value:
sl_ind = -1
elif ele_c is not None:
sl_ind = 1
if sl_ind not in ed:
ed[sl_ind] = [[], []]
y_ele = [yy + xx * n_y, yy + (xx + 1) * n_y, yy + 1 + (xx + 1) * n_y, yy + 1 + xx * n_y, yy + xx * n_y]
ed[sl_ind][0].append(x_ele)
ed[sl_ind][1].append(y_ele)
if ele_c is not None:
if sl_ind not in cd:
cd[sl_ind] = []
cd[sl_ind].append(ele_c[xx][yy])
y_inds += y_ele
ele_bis = {}
if ele_c is not None:
if len(ele_c.shape) == 2:
sch_cols = np.array(colors.get_colors(cscheme))
ecol = len(sch_cols)
brush_list = [pg.mkColor(colors.color_by_index(cscheme, i, as255=True, alpha=alpha)) for i in range(ecol)]
if crange is None:
if cbal:
mabs = np.max(abs(ele_c[active_eles]))
y_max = mabs
y_min = -mabs
else:
y_max = np.max(ele_c[active_eles])
y_min = np.min(ele_c[active_eles])
if cinc:
y_max = np.ceil(y_max / cinc) * cinc
y_min = np.floor(y_min / cinc) * cinc
else:
y_min = crange[0]
if y_min is None:
y_min = np.min(ele_c[active_eles])
y_max = crange[1]
if y_max is None:
y_max = np.max(ele_c[active_eles])
inc = (y_max - y_min) * 0.001
for sl_ind in cd:
cd[sl_ind] = np.clip(cd[sl_ind], y_min, y_max)
if inc == 0.0:
ele_bis[sl_ind] = int(ecol / 2) * np.ones_like(cd[sl_ind], dtype=int)
else:
ele_bis[sl_ind] = (cd[sl_ind] - y_min) / (y_max + inc - y_min) * ecol
ele_bis[sl_ind] = np.array(ele_bis[sl_ind], dtype=int)
elif len(ele_c.shape) == 3:
pass
else:
raise ValueError('ele_c must be same dimensions as soil_grid')
yc = y_all.flatten()
xc = x_all.flatten()
if len(xc) == len(yc): # then it is vary_xy
for item in ed:
ed[item][0] = ed[item][1]
for sl_ind in ed:
ed[sl_ind][0] = np.array(ed[sl_ind][0])
ed[sl_ind][1] = np.array(ed[sl_ind][1])
if sl_ind < 0:
pen = pg.mkPen([200, 200, 200, 10], width=pw)
else:
if pen_col is None:
pen = pg.mkPen([200, 200, 200, palpha], width=pw)
else:
pen = pg.mkPen(pen_col, width=pw)
if ele_c is not None:
if len(ele_c.shape) == 3: # colors directly specified
# brushes = np.array(brush_list)[ele_bis[sl_ind]]
brushes_col = ele_c[active_eles]
brushes = np.array([pg.mkColor(col) for col in brushes_col]) # TODO: v. slow
# eles_x_coords = xc[ed[sl_ind][0]]
# eles_y_coords = yc[ed[sl_ind][1]]
# ele_ind = ele
# item = color_grid.ColorGrid(eles_x_coords, eles_y_coords, brushes)
else:
brushes = np.array(brush_list)[ele_bis[sl_ind]]
eles_x_coords = xc[ed[sl_ind][0]]
eles_y_coords = yc[ed[sl_ind][1]]
item = color_grid.ColorGrid(eles_x_coords, eles_y_coords, brushes, pen_col=pen_col)
plotItem.addItem(item)
else:
ed[sl_ind][0] = np.array(ed[sl_ind][0]).flatten()
ed[sl_ind][1] = np.array(ed[sl_ind][1]).flatten()
if sl_ind < 0:
brush = pg.mkBrush([255, 255, 255, 20])
else:
brush = pg.mkColor(cbox(sl_ind, as255=True, alpha=alpha))
ele_x_coords = xc[ed[sl_ind][0]]
# ele_x_coords = xc[ed[sl_ind][1]]
ele_y_coords = yc[ed[sl_ind][1]]
ele_connects = np.array([1, 1, 1, 1, 0] * int(len(ed[sl_ind][0]) / 5))
plotItem.plot(ele_x_coords, ele_y_coords, pen=pen,
connect=ele_connects, fillLevel='enclosed',
fillBrush=brush)
if ele_c is not None and len(ele_c.shape) != 3:
lut = np.zeros((155, 3), dtype=np.ubyte)
lut[:, 0] = np.arange(100, 255)
lut = np.array([colors.color_by_index(cscheme, i, as255=True) for i in range(ecol)], dtype=int)
a_inds = np.where(femesh.soil_grid != femesh.inactive_value)
leg_copts = {
'leg_pen': leg_pen
}
o3ptools.add_color_bar(win, plotItem, lut, vmin=y_min, vmax=y_max,
label=label, n_cols=ecol, units=cunits, bal=cbal, copts=leg_copts)
return win.plotItem
def change_curr_ele_c(self, ele_num_base=0):
ele_c = self.ele_c
leg_pen = self.copts.setdefault('leg_pen', 'w')
cscheme = self.copts.setdefault('scheme', 'red2yellow')
self.color_scheme = cscheme
self.cbal = self.copts.setdefault('bal', 0)
cunits = self.copts.setdefault('units', '')
clabel = self.copts.setdefault('label', 'vals')
crange = self.copts.setdefault('crange', None)
print('selected scheme: ', cscheme)
if self.ele_c is not None:
sch_cols = np.array(colors.get_colors(self.color_scheme))
ecol = len(sch_cols)
self.ele_brush_list = [pg.mkColor(colors.color_by_scheme(self.color_scheme, i, as255=True)) for i in range(ecol)]
active_eles = np.array(list(self.ele2node_tags)) - ele_num_base
if crange is None:
if self.cbal:
mabs = np.nanmax(abs(self.ele_c[active_eles]))
y_max = mabs
y_min = -mabs
else:
y_max = np.nanmax(self.ele_c[active_eles])
y_min = np.nanmin(self.ele_c[active_eles])
if self.cinc:
y_max = np.ceil(y_max / self.cinc) * self.cinc
y_min = np.floor(y_min / self.cinc) * self.cinc
else:
y_min = crange[0]
if y_min is None:
y_min = np.nanmin(self.ele_c[active_eles])
y_max = crange[1]
if y_max is None:
y_max = np.nanmax(self.ele_c[active_eles])
inc = (y_max - y_min) * 0.001
print('ymin, ymax: ', y_min, y_max)
ele_bis = (self.ele_c - y_min) / (y_max + inc - y_min) * ecol
ele_bis = np.clip(ele_bis, 0, ecol - 1)
self.ele_bis = np.array(ele_bis, dtype=int)
unique_bis = np.arange(ecol)
print('ecol: ', ecol)
min_inds = np.argmin(self.ele_c[active_eles], axis=0)
self.min_inds = active_eles[min_inds]
max_inds = np.argmax(self.ele_c[active_eles], axis=0)
self.max_inds = active_eles[max_inds]
else:
unique_bis = []
# clean plots
for i, mat in enumerate(self.mat2node_tags):
for bi in range(100):
if bi not in unique_bis:
if bi in self.p_items[mat]:
self.win.removeItem(self.p_items[mat][bi])
del self.p_items[mat][bi]
continue
if bi in unique_bis and bi not in self.p_items[mat]:
brush = pg.mkBrush(self.ele_brush_list[bi])
self.p_items[mat][bi] = self.win.plot([], [], pen='w', connect=[], fillLevel='enclosed',
fillBrush=brush)
if hasattr(self, 'col_bar'):
print('removing color bar')
# self.col_bar.setParent(None)
self.col_bar.close()
if self.ele_c is not None and len(ele_c.shape) != 3:
lut = np.zeros((155, 3), dtype=np.ubyte)
lut[:, 0] = np.arange(100, 255)
lut = np.array([colors.color_by_index(cscheme, i, as255=True) for i in range(ecol)], dtype=int)
leg_copts = {
'leg_pen': leg_pen
}
self.col_bar = o3ptools.add_color_bar(self.win, self.plotItem, lut, vmin=y_min, vmax=y_max,
label=clabel, n_cols=ecol, units=cunits, bal=self.cbal, copts=leg_copts)
def plot_dynamic(self, x, y, dt, xmag=10.0, ymag=10.0, node_c=None, ele_c=None, t_scale=1, ele_num_base=0):
leg_pen = self.copts.setdefault('leg_pen', 'w')
cscheme = self.copts.setdefault('scheme', 'red2yellow')
cbal = self.copts.setdefault('bal', 0)
cunits = self.copts.setdefault('units', '')
clabel = self.copts.setdefault('label', 'vals')
crange = self.copts.setdefault('crange', None)
self.timer.setInterval(1000. * dt * t_scale) # in milliseconds
self.timer.start()
self.node_c = node_c
self.ele_c = ele_c
self.x = np.array(x) * xmag
self.y = np.array(y) * ymag
if self.x_coords is not None:
self.x += self.x_coords
self.y += self.y_coords
self.time = np.arange(len(self.x)) * dt
self.i_limit = len(self.x) - 1
# Prepare node colors
if self.node_c is not None:
cols = colors.get_colors(self.color_scheme)
ncol = len(cols)
self.node_brush_list = [pg.mkColor(colors.color_by_scheme(self.color_scheme, i, as255=True)) for i in range(ncol)]
node_y_max = np.max(self.node_c)
node_y_min = np.min(self.node_c)
inc = (node_y_max - node_y_min) * 0.001
node_bis = (self.node_c - node_y_min) / (node_y_max + inc - node_y_min) * ncol
self.node_bis = np.array(node_bis, dtype=int)
if self.ele_c is not None:
sch_cols = np.array(colors.get_colors(cscheme))
ecol = len(sch_cols)
self.ele_brush_list = [pg.mkColor(colors.color_by_scheme(self.color_scheme, i, as255=True)) for i in range(ecol)]
active_eles = np.array(list(self.ele2node_tags)) - ele_num_base
if crange is None:
if self.cbal:
mabs = np.nanmax(abs(self.ele_c[active_eles]))
y_max = mabs
y_min = -mabs
else:
y_max = np.nanmax(self.ele_c[active_eles])
y_min = np.nanmin(self.ele_c[active_eles])
if self.cinc:
y_max = np.ceil(y_max / self.cinc) * self.cinc
y_min = np.floor(y_min / self.cinc) * self.cinc
else:
y_min = crange[0]
if y_min is None:
y_min = np.min(self.ele_c[active_eles])
y_max = crange[1]
if y_max is None:
y_max = np.max(self.ele_c[active_eles])
inc = (y_max - y_min) * 0.001
print('ymin, ymax: ', y_min, y_max)
ele_bis = (self.ele_c - y_min) / (y_max + inc - y_min) * ecol
ele_bis = np.clip(ele_bis, 0, ecol - 1)
self.ele_bis = np.array(ele_bis, dtype=int)
min_inds = np.argmin(self.ele_c[active_eles], axis=0)
self.min_inds = active_eles[min_inds]
max_inds = np.argmax(self.ele_c[active_eles], axis=0)
self.max_inds = active_eles[max_inds]
unique_bis = np.arange(ecol)
# TODO: use unique_bis = list(set(self.ele_bis)); unique_bis.sort()
self.p_items = {}
for i, mat in enumerate(self.mat2node_tags):
self.win.removeItem(self.ele_lines_plot[mat])
self.p_items[mat] = {}
for bi in unique_bis:
brush = pg.mkBrush(self.ele_brush_list[bi])
self.p_items[mat][bi] = self.win.plot([], [], pen='w', connect=[], fillLevel='enclosed',
fillBrush=brush)
if self.show_maxmin:
self.p_items['max'] = self.win.plot([], [], pen='r', connect=[], symbol='o', symbolBrush=(255, 0, 0), symbolSize=6) # should be per material
self.p_items['min'] = self.win.plot([], [], pen='g', connect=[], symbol='o', symbolBrush=(0, 255, 0), symbolSize=6)
if hasattr(self, 'col_bar'):
print('removing color bar')
self.col_bar.setParent(None)
self.col_bar.close()
if self.ele_c is not None and len(ele_c.shape) != 3:
lut = np.zeros((155, 3), dtype=np.ubyte)
lut[:, 0] = np.arange(100, 255)
lut = np.array([colors.color_by_index(cscheme, i, as255=True) for i in range(ecol)], dtype=int)
leg_copts = {
'leg_pen': leg_pen
}
print('y_min: ', y_min)
print('y_max: ', y_max)
self.col_bar = o3ptools.add_color_bar(self.win, self.plotItem, lut, vmin=y_min, vmax=y_max,
label=clabel, n_cols=ecol, units=cunits, bal=cbal, copts=leg_copts)
self.timer.timeout.connect(self.updater)
def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent)
self.parent = parent
## Dock 1 - mouse intensity display
self.dock = Dock("Mouse", size=(1, 1), closable=False)
self.dock.hideTitleBar()
self.win = pg.GraphicsView(
background=pg.mkColor(color.mouseBackground))
self.dock.addWidget(self.win)
#self.tm = ThreadsafeTimer(self.parent)
#gifFolder = getGifPath(debug=False)
#self.fnames = []
#for file in os.listdir(gifFolder):
# if file.endswith(".gif"):
# self.fnames.append(os.path.join(gifFolder, file))
#shuffle(self.fnames)
#self.movie_screen = None
#self.movie = None
#self.speed = 120
#self.index = 0
# def addGif(self):
# # Load the file into a QMovie
# fname = self.fnames[self.index % len(self.fnames)]
# self.index += 1
# if self.movie is None:
# # get a frame to get image size
# self.movie = QtGui.QMovie(fname, QtCore.QByteArray(), self)
# self.movie.jumpToFrame(0)
# movie_size = self.movie.currentImage().size()
# movie_aspect = movie_size.width() * 1.0 / movie_size.height()
# # create a new movie with correct aspect ratio
# self.movie = QtGui.QMovie(fname, QtCore.QByteArray(), self)
# size = self.movie.scaledSize()
# self.setGeometry(100, 100, size.width(), size.height())
# self.movie.setScaledSize(QtCore.QSize(int(150*movie_aspect),150)) # pixels
#
# # Create the layout
# if self.layout is None:
# main_layout = QtGui.QVBoxLayout()
# self.setLayout(main_layout)
#
# self.movie_screen = QtGui.QLabel()
# # Make label fit the gif
# self.movie_screen.setSizePolicy(QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Minimum)
# self.movie_screen.setAlignment(QtCore.Qt.AlignCenter)
# self.dock.addWidget(self.movie_screen)
#
# # Add the QMovie object to the label
# self.movie.setCacheMode(QtGui.QMovie.CacheAll)
# self.movie.setSpeed(self.speed)
# self.movie_screen.setMovie(self.movie)
# self.movie.start()
# else:
# pass
#
# def removeGif(self):
# try:
# if self.movie_screen:
# self.movie.stop()
# self.movie = None #self.movie.deleteLater()
# self.movie_screen.setParent(None)
# self.movie_screen = None #self.movie_screen.deleteLater()
# except:
# pass
# class ThreadsafeTimer(QtCore.QObject):
# """
# Thread-safe replacement for QTimer.
# """
# timeout = QtCore.Signal()
# sigTimerStopRequested = QtCore.Signal()
# sigTimerStartRequested = QtCore.Signal(object)
#
# def __init__(self, parent = None):
# QtCore.QObject.__init__(self, parent)
# self.parent = parent
# self.timer = QtCore.QTimer()
# self.timer.timeout.connect(self.timerFinished)
# self.timer.moveToThread(QtCore.QCoreApplication.instance().thread())
# self.moveToThread(QtCore.QCoreApplication.instance().thread())
# self.sigTimerStopRequested.connect(self.stop, QtCore.Qt.QueuedConnection)
# self.sigTimerStartRequested.connect(self.start, QtCore.Qt.QueuedConnection)
#
# def start(self, timeout):
# isGuiThread = QtCore.QThread.currentThread() == QtCore.QCoreApplication.instance().thread()
# if isGuiThread:
# #print "start timer", self, "from gui thread"
# self.timer.start(timeout)
# self.parent.mouse.addGif()
# else:
# #print "start timer", self, "from remote thread"
# self.sigTimerStartRequested.emit(timeout)
#
# def stop(self):
# isGuiThread = QtCore.QThread.currentThread() == QtCore.QCoreApplication.instance().thread()
# if isGuiThread:
# #print "stop timer", self, "from gui thread"
# self.timer.stop()
# self.parent.mouse.removeGif()
# else:
# #print "stop timer", self, "from remote thread"
# self.sigTimerStopRequested.emit()
#
# def timerFinished(self):
# #print "emit!!!!"
# self.timeout.emit()
# self.stop()
def setup(self, win):
win.setWindowTitle("Acconeer Distance Detector")
# Sweep Plot
self.sweep_plot = win.addPlot(title="Sweep and threshold")
self.sweep_plot.showGrid(x=True, y=True)
self.sweep_plot.addLegend()
self.sweep_plot.setLabel("bottom", "Distance (cm)")
self.sweep_plot.setYRange(0, 20000)
self.sweep_plot.setXRange(100.0 * self.r[0], 100.0 * self.r[-1])
self.sweep_curve = self.sweep_plot.plot(
pen=utils.pg_pen_cycler(5),
name="Envelope sweep",
)
self.mean_sweep_curve = self.sweep_plot.plot(
pen=utils.pg_pen_cycler(0, width=3),
name="Mean Envelope sweep",
)
self.threshold_curve = self.sweep_plot.plot(
pen=utils.pg_pen_cycler(1),
name="Threshold",
)
self.smooth_max_sweep = utils.SmoothMax(
self.sensor_config.update_rate,
hysteresis=0.6,
tau_decay=3,
)
self.peak_lines = []
for i in range(3):
color_idx = 1 if i > 0 else 0
width = 2 if i == 0 else 1
color_tuple = utils.hex_to_rgb_tuple(utils.color_cycler(color_idx))
line = pg.InfiniteLine(
pen=pg.mkPen(pg.mkColor(*color_tuple, 150), width=width))
self.sweep_plot.addItem(line)
self.peak_lines.append(line)
self.peak_text = pg.TextItem(
anchor=(0, 1),
color=utils.color_cycler(0),
fill=pg.mkColor(0xFF, 0xFF, 0xFF, 150),
)
self.peak_text.setPos(self.r[0] * 100, 0)
self.peak_text.setZValue(100)
self.sweep_plot.addItem(self.peak_text)
win.nextRow()
# Detection history Plot
self.hist_plot = win.addPlot(title="Detected peaks")
self.hist_plot.showGrid(x=True, y=True)
self.hist_plot.addLegend()
self.hist_plot.setLabel("bottom", "Time history (s)")
self.hist_plot.setLabel("left", "Distance (cm)")
self.hist_plot.setXRange(-10, 0)
self.hist_plot.setYRange(100.0 * self.r[0], 100.0 * self.r[-1])
self.main_peak = self.hist_plot.plot(
pen=None,
symbol="o",
symbolSize=8,
symbolPen='k',
symbolBrush=utils.color_cycler(0),
name="Main peak",
)
self.minor_peaks = self.hist_plot.plot(
pen=None,
symbol='o',
symbolSize=5,
symbolPen='k',
symbolBrush=utils.color_cycler(1),
name="Minor peaks",
)
self.first_distance_above_threshold = self.hist_plot.plot(
pen=None,
symbol='o',
symbolSize=3,
symbolPen='k',
symbolBrush=utils.color_cycler(2),
name="First distance above threshold",
visible=False,
)
self.setup_is_done = True
def __init__(self, parent=None):
super(VisWindow, self).__init__(parent)
pg.setConfigOptions(imageAxisOrder='row-major')
self.setGeometry(70, 70, 1100, 900)
self.setWindowTitle('Visualize data')
self.cwidget = QtGui.QWidget(self)
self.setCentralWidget(self.cwidget)
self.l0 = QtGui.QGridLayout()
#layout = QtGui.QFormLayout()
self.cwidget.setLayout(self.l0)
#self.p0 = pg.ViewBox(lockAspect=False,name='plot1',border=[100,100,100],invertY=True)
self.win = pg.GraphicsLayoutWidget()
# --- cells image
self.win = pg.GraphicsLayoutWidget()
self.win.move(600, 0)
self.win.resize(1000, 500)
self.l0.addWidget(self.win, 0, 0, 14, 14)
layout = self.win.ci.layout
# A plot area (ViewBox + axes) for displaying the image
self.p0 = self.win.addViewBox(row=0, col=0)
self.p0.setMouseEnabled(x=False, y=False)
self.p0.setMenuEnabled(False)
self.p1 = self.win.addPlot(title="FULL VIEW", row=0, col=1)
self.p1.setMouseEnabled(x=False, y=False)
self.img = pg.ImageItem(autoDownsample=True)
self.p1.addItem(self.img)
# cells to plot
if len(parent.imerge) == 1:
icell = parent.iscell[parent.imerge[0]]
self.cells = np.array((parent.iscell == icell).nonzero()).flatten()
else:
self.cells = np.array(parent.imerge).flatten()
# compute spikes
i = parent.activityMode
if i == 0:
sp = parent.Fcell[self.cells, :]
elif i == 1:
sp = parent.Fneu[self.cells, :]
elif i == 2:
sp = parent.Fcell[self.cells, :] - 0.7 * parent.Fneu[self.cells, :]
else:
sp = parent.Spks[self.cells, :]
sp = np.squeeze(sp)
sp = zscore(sp, axis=1)
sp -= sp.min()
sp /= sp.max()
self.sp = np.maximum(0, np.minimum(1, sp))
self.tsort = np.arange(0, sp.shape[1]).astype(np.int32)
# 100 ms bins
self.bin = int(np.maximum(1, int(parent.ops['fs'] / 10)))
# draw axes
self.p1.setXRange(0, sp.shape[1])
self.p1.setYRange(0, sp.shape[0])
self.p1.setLimits(xMin=-10,
xMax=sp.shape[1] + 10,
yMin=-10,
yMax=sp.shape[0] + 10)
self.p1.setLabel('left', 'neurons')
self.p1.setLabel('bottom', 'time')
# zoom in on a selected image region
nt = sp.shape[1]
nn = sp.shape[0]
self.p2 = self.win.addPlot(title='ZOOM IN', row=1, col=0, colspan=2)
self.imgROI = pg.ImageItem(autoDownsample=True)
self.p2.addItem(self.imgROI)
self.p2.setMouseEnabled(x=False, y=False)
#self.p2.setLabel('left', 'neurons')
self.p2.hideAxis('bottom')
self.bloaded = parent.bloaded
self.p3 = self.win.addPlot(title='', row=2, col=0, colspan=2)
self.avg = self.sp.mean(axis=0)
self.p3.plot(np.arange(0, self.avg.size), self.avg)
self.p3.setMouseEnabled(x=False, y=False)
self.p3.getAxis('left').setTicks([[(0, '')]])
self.p3.setLabel('bottom', 'time')
if self.bloaded:
self.beh = parent.beh
self.beh_time = parent.beh_time
self.p3.plot(self.beh_time, self.beh)
self.p3.setXRange(0, sp.shape[1])
# set colormap to viridis
colormap = cm.get_cmap("viridis")
colormap._init()
lut = (colormap._lut * 255).view(
np.ndarray
) # Convert matplotlib colormap from 0-1 to 0 -255 for Qt
lut = lut[0:-3, :]
# apply the colormap
self.img.setLookupTable(lut)
self.imgROI.setLookupTable(lut)
self.img.setLevels([0, 1])
self.imgROI.setLevels([0, 1])
layout.setColumnStretchFactor(1, 3)
layout.setRowStretchFactor(1, 3)
# add slider for levels
self.sl = QtGui.QSlider(QtCore.Qt.Vertical)
self.sl.setMinimum(0)
self.sl.setMaximum(100)
self.sl.setValue(100)
self.sl.setTickPosition(QtGui.QSlider.TicksLeft)
self.sl.setTickInterval(10)
self.sl.valueChanged.connect(self.levelchange)
self.sl.setTracking(False)
self.sat = 1.0
self.l0.addWidget(self.sl, 0, 2, 5, 1)
qlabel = gui.VerticalLabel(text='saturation')
#qlabel.setStyleSheet('color: white;')
self.l0.addWidget(qlabel, 1, 3, 3, 1)
self.isort = np.arange(0, self.cells.size).astype(np.int32)
# ROI on main plot
redpen = pg.mkPen(pg.mkColor(255, 0, 0),
width=3,
style=QtCore.Qt.SolidLine)
self.ROI = pg.RectROI([nt * .25, -1], [nt * .25, nn + 1],
maxBounds=QtCore.QRectF(-1., -1., nt + 1,
nn + 1),
pen=redpen)
self.ROI.handleSize = 10
self.ROI.handlePen = redpen
# Add top and right Handles
self.ROI.addScaleHandle([1, 0.5], [0., 0.5])
self.ROI.addScaleHandle([0.5, 0], [0.5, 1])
self.ROI.sigRegionChangeFinished.connect(self.ROI_position)
self.p1.addItem(self.ROI)
self.ROI.setZValue(10) # make sure ROI is drawn above image
self.neural_sorting(2)
# buttons for computations
self.mapOn = QtGui.QPushButton('compute rastermap + PCs')
self.mapOn.clicked.connect(lambda: self.compute_map(parent))
self.l0.addWidget(self.mapOn, 0, 0, 1, 2)
self.comboBox = QtGui.QComboBox(self)
self.l0.addWidget(self.comboBox, 1, 0, 1, 2)
self.l0.addWidget(QtGui.QLabel(''), 2, 0, 1, 1)
#self.l0.addWidget(QtGui.QLabel(''),4,0,1,1)
self.selectBtn = QtGui.QPushButton('show selected cells in GUI')
self.selectBtn.clicked.connect(lambda: self.select_cells(parent))
self.selectBtn.setEnabled(True)
self.l0.addWidget(self.selectBtn, 3, 0, 1, 2)
self.sortTime = QtGui.QCheckBox('&Time sort')
self.sortTime.setStyleSheet("color: white;")
self.sortTime.stateChanged.connect(self.sort_time)
self.l0.addWidget(self.sortTime, 4, 0, 1, 2)
self.l0.addWidget(QtGui.QLabel(''), 5, 0, 1, 1)
self.l0.setRowStretch(6, 1)
self.raster = False
self.process = QtCore.QProcess(self)
self.process.readyReadStandardOutput.connect(self.stdout_write)
self.process.readyReadStandardError.connect(self.stderr_write)
# disable the button when running the s2p process
#self.process.started.connect(self.started)
self.process.finished.connect(lambda: self.finished(parent))
self.win.show()
self.win.scene().sigMouseClicked.connect(self.plot_clicked)
self.show()
'serv_unit': SETTINGS.serv_unit,
'serv_add': SETTINGS.serv_add,
'serv_port': SETTINGS.serv_port
}
for k, v in classify.items():
settingsData[k] = v
with open("config.json", "w") as jsonFile:
json.dump(data, jsonFile, indent=4)
print("Closed all thread!")
if __name__ == '__main__':
import sys
pg.setConfigOption('foreground', 'w')
pg.setConfigOption('background', pg.mkColor(255, 255, 255, 0))
pg.setConfigOptions(antialias=True)
app = QtWidgets.QApplication(sys.argv)
MainWindow = QtWidgets.QMainWindow()
ui = Ui_MainWindow()
ui.setupUi(MainWindow)
#MainWindow.showFullScreen()
timeUpdateThread = TimeUpdateThread(ui)
MainWindow.show()
dbInsertManagerThread = DBInsertManager()
eventThread = EventThread(ui)
uartCom = UartCom(ui, eventThread, dbInsertManagerThread)
valueUpdateThread = ValueUpdateThread(ui, uartCom, eventThread)
dbFetchManagerThread = DBFetchManager(ui, eventThread)
app.aboutToQuit.connect(
lambda: stopall(eventThread, valueUpdateThread, timeUpdateThread,
def setup(self, win):
num_sensors = len(self.sensor_config.sensor)
self.ampl_plot = win.addPlot(row=0, colspan=num_sensors)
self.ampl_plot.setMenuEnabled(False)
self.ampl_plot.showGrid(x=True, y=True)
self.ampl_plot.setLabel("bottom", "Depth (m)")
self.ampl_plot.setLabel("left", "Amplitude")
self.ampl_plot.setXRange(*self.depths.take((0, -1)))
self.ampl_plot.setYRange(0, 1) # To avoid rendering bug
self.ampl_plot.addLegend(offset=(-10, 10))
self.ampl_curves = []
self.bg_curves = []
self.peak_lines = []
for i, sensor_id in enumerate(self.sensor_config.sensor):
legend = "Sensor {}".format(sensor_id)
ampl_curve = self.ampl_plot.plot(pen=utils.pg_pen_cycler(i),
name=legend)
bg_curve = self.ampl_plot.plot(
pen=utils.pg_pen_cycler(i, style="--"))
color_tuple = utils.hex_to_rgb_tuple(utils.color_cycler(i))
peak_line = pg.InfiniteLine(
pen=pg.mkPen(pg.mkColor(*color_tuple, 150), width=2))
self.ampl_plot.addItem(peak_line)
self.ampl_curves.append(ampl_curve)
self.bg_curves.append(bg_curve)
self.peak_lines.append(peak_line)
bg = pg.mkColor(0xFF, 0xFF, 0xFF, 150)
self.peak_text = pg.TextItem(anchor=(0, 1), color="k", fill=bg)
self.peak_text.setPos(self.depths[0], 0)
self.peak_text.setZValue(100)
self.ampl_plot.addItem(self.peak_text)
rate = self.sensor_config.update_rate
xlabel = "Sweeps" if rate is None else "Time (s)"
x_scale = 1.0 if rate is None else 1.0 / rate
y_scale = self.depth_res
x_offset = -self.processing_config.history_length * x_scale
y_offset = self.depths[0] - 0.5 * self.depth_res
is_single_sensor = len(self.sensor_config.sensor) == 1
self.history_plots = []
self.history_ims = []
for i, sensor_id in enumerate(self.sensor_config.sensor):
title = None if is_single_sensor else "Sensor {}".format(sensor_id)
plot = win.addPlot(row=1, col=i, title=title)
plot.setMenuEnabled(False)
plot.setLabel("bottom", xlabel)
plot.setLabel("left", "Depth (m)")
im = pg.ImageItem(autoDownsample=True)
im.setLookupTable(utils.pg_mpl_cmap("viridis"))
im.resetTransform()
im.translate(x_offset, y_offset)
im.scale(x_scale, y_scale)
plot.addItem(im)
self.history_plots.append(plot)
self.history_ims.append(im)
self.setup_is_done = True
self.update_processing_config()
import numpy as np
from pyqtgraph.Qt import *
import pyqtgraph as pg
import json
import time
from sys import exit
#Widget condiguration
app = QtGui.QApplication([])
w = QtGui.QWidget()
layout = QtGui.QGridLayout()
w.setLayout(layout)
w.setWindowTitle("Procesado de señal de audio")
w.setFixedSize(1000, 600)
p = w.palette()
p.setColor(w.backgroundRole(), pg.mkColor('k'))
w.setPalette(p)
pg.setConfigOptions(antialias=True)
class AudioServer():
HOST = '127.0.0.2'
def __init__(self, port, layout, w):
self.port = port
#Initialize socket connections
self.socketCon = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.socketCon.bind((self.HOST, self.port))
def dark_mode_toggle(dark):
'''Digs into the internals of finplot and pyqtgraph to change the colors of existing
plots, axes, backgronds, etc.'''
# first set the colors we'll be using
if dark:
fplt.foreground = '#777'
fplt.background = '#090c0e'
fplt.candle_bull_color = fplt.candle_bull_body_color = '#0b0'
fplt.candle_bear_color = '#a23'
volume_transparency = '6'
else:
fplt.foreground = '#444'
fplt.background = fplt.candle_bull_body_color = '#fff'
fplt.candle_bull_color = '#380'
fplt.candle_bear_color = '#c50'
volume_transparency = 'c'
fplt.volume_bull_color = fplt.volume_bull_body_color = fplt.candle_bull_color + volume_transparency
fplt.volume_bear_color = fplt.candle_bear_color + volume_transparency
fplt.cross_hair_color = fplt.foreground + '8'
fplt.draw_line_color = '#888'
fplt.draw_done_color = '#555'
pg.setConfigOptions(foreground=fplt.foreground, background=fplt.background)
# control panel color
if ctrl_panel is not None:
p = ctrl_panel.palette()
p.setColor(ctrl_panel.darkmode.foregroundRole(),
pg.mkColor(fplt.foreground))
ctrl_panel.darkmode.setPalette(p)
# window background
for win in fplt.windows:
win.setBackground(fplt.background)
# axis, crosshair, candlesticks, volumes
axs = [ax for win in fplt.windows for ax in win.axs]
vbs = set([ax.vb for ax in axs])
axs += fplt.overlay_axs
axis_pen = fplt._makepen(color=fplt.foreground)
for ax in axs:
ax.axes['left']['item'].setPen(axis_pen)
ax.axes['left']['item'].setTextPen(axis_pen)
ax.axes['bottom']['item'].setPen(axis_pen)
ax.axes['bottom']['item'].setTextPen(axis_pen)
if ax.crosshair is not None:
ax.crosshair.vline.pen.setColor(pg.mkColor(fplt.foreground))
ax.crosshair.hline.pen.setColor(pg.mkColor(fplt.foreground))
ax.crosshair.xtext.setColor(fplt.foreground)
ax.crosshair.ytext.setColor(fplt.foreground)
for item in ax.items:
if isinstance(item, fplt.FinPlotItem):
isvolume = ax in fplt.overlay_axs
if not isvolume:
item.colors.update(
dict(bull_shadow=fplt.candle_bull_color,
bull_frame=fplt.candle_bull_color,
bull_body=fplt.candle_bull_body_color,
bear_shadow=fplt.candle_bear_color,
bear_frame=fplt.candle_bear_color,
bear_body=fplt.candle_bear_color))
else:
item.colors.update(
dict(bull_frame=fplt.volume_bull_color,
bull_body=fplt.volume_bull_body_color,
bear_frame=fplt.volume_bear_color,
bear_body=fplt.volume_bear_color))
item.repaint()
dock_two = Dock("Finished Preview", size=(500, 300))
area.addDock(dock_one, 'left')
area.addDock(dock_two, 'right')
animated_preview_widget = gl.GLViewWidget()
animated_preview_widget.opts['distance'] = 20
animated_preview_widget.show()
preview_widget = gl.GLViewWidget()
preview_widget.opts['distance'] = 20
preview_widget.show()
dock_one.addWidget(animated_preview_widget)
dock_two.addWidget(preview_widget)
animated_preview_widget.setBackgroundColor(mkColor(155, 155, 155, 0))
preview_widget.setBackgroundColor(mkColor(155, 155, 155, 0))
grid = gl.GLGridItem(size=QtGui.QVector3D(8, 9, 1))
grid.setSpacing(spacing=QtGui.QVector3D(0.5, 0.5, 0.5))
grid.translate(4.5, 5, 0)
animated_preview_widget.addItem(grid)
preview_widget.addItem(grid)
x_verts_line = np.array([
[0, 0, 0],
[2, 0, 0]
])
y_verts_line = np.array([
def setup(self, win):
win.setWindowTitle("Acconeer presence detection example")
self.limit_lines = []
dashed_pen = pg.mkPen("k", width=2.5, style=QtCore.Qt.DashLine)
# Data plot
self.data_plot = win.addPlot(
row=0,
col=0,
title="Frame (blue), fast (orange), and slow (green)",
)
self.data_plot.setMenuEnabled(False)
self.data_plot.showGrid(x=True, y=True)
self.data_plot.setLabel("bottom", "Depth (m)")
self.data_plot.setLabel("left", "Amplitude")
self.data_plot.setYRange(0, 2**16)
self.frame_scatter = pg.ScatterPlotItem(
size=10,
brush=utils.pg_brush_cycler(0),
)
self.fast_scatter = pg.ScatterPlotItem(
size=10,
brush=utils.pg_brush_cycler(1),
)
self.slow_scatter = pg.ScatterPlotItem(
size=10,
brush=utils.pg_brush_cycler(2),
)
self.data_plot.addItem(self.frame_scatter)
self.data_plot.addItem(self.fast_scatter)
self.data_plot.addItem(self.slow_scatter)
self.frame_smooth_limits = utils.SmoothLimits(
self.sensor_config.update_rate)
# Noise estimation plot
self.noise_plot = win.addPlot(
row=1,
col=0,
title="Noise",
)
self.noise_plot.setMenuEnabled(False)
self.noise_plot.showGrid(x=True, y=True)
self.noise_plot.setLabel("bottom", "Depth (m)")
self.noise_plot.setLabel("left", "Amplitude")
self.noise_curve = self.noise_plot.plot(pen=utils.pg_pen_cycler())
self.noise_smooth_max = utils.SmoothMax(self.sensor_config.update_rate)
# Depthwise presence plot
self.move_plot = win.addPlot(
row=2,
col=0,
title="Depthwise presence",
)
self.move_plot.setMenuEnabled(False)
self.move_plot.showGrid(x=True, y=True)
self.move_plot.setLabel("bottom", "Depth (m)")
self.move_plot.setLabel("left", "Norm. ampl.")
zero_curve = self.move_plot.plot(self.depths,
np.zeros_like(self.depths))
self.inter_curve = self.move_plot.plot()
self.total_curve = self.move_plot.plot()
self.move_smooth_max = utils.SmoothMax(
self.sensor_config.update_rate,
tau_decay=1.0,
tau_grow=0.25,
)
self.move_depth_line = pg.InfiniteLine(pen=pg.mkPen("k", width=1.5))
self.move_depth_line.hide()
self.move_plot.addItem(self.move_depth_line)
limit_line = pg.InfiniteLine(angle=0, pen=dashed_pen)
self.move_plot.addItem(limit_line)
self.limit_lines.append(limit_line)
fbi = pg.FillBetweenItem(
zero_curve,
self.inter_curve,
brush=utils.pg_brush_cycler(0),
)
self.move_plot.addItem(fbi)
fbi = pg.FillBetweenItem(
self.inter_curve,
self.total_curve,
brush=utils.pg_brush_cycler(1),
)
self.move_plot.addItem(fbi)
# Presence history plot
self.move_hist_plot = pg.PlotItem(title="Presence history")
self.move_hist_plot.setMenuEnabled(False)
self.move_hist_plot.showGrid(x=True, y=True)
self.move_hist_plot.setLabel("bottom", "Time (s)")
self.move_hist_plot.setLabel(
"left", "Score (limited to {})".format(OUTPUT_MAX))
self.move_hist_plot.setXRange(-self.history_length_s, 0)
self.move_hist_plot.setYRange(0, OUTPUT_MAX)
self.move_hist_curve = self.move_hist_plot.plot(
pen=utils.pg_pen_cycler())
limit_line = pg.InfiniteLine(angle=0, pen=dashed_pen)
self.move_hist_plot.addItem(limit_line)
self.limit_lines.append(limit_line)
self.present_html_format = '<div style="text-align: center">' \
'<span style="color: #FFFFFF;font-size:15pt;">' \
'{}</span></div>'
not_present_html = '<div style="text-align: center">' \
'<span style="color: #FFFFFF;font-size:15pt;">' \
'{}</span></div>'.format("No presence detected")
self.present_text_item = pg.TextItem(
fill=pg.mkColor(0xff, 0x7f, 0x0e, 200),
anchor=(0.5, 0),
)
self.not_present_text_item = pg.TextItem(
html=not_present_html,
fill=pg.mkColor(0x1f, 0x77, 0xb4, 180),
anchor=(0.5, 0),
)
pos = (-self.history_length_s / 2, 0.95 * OUTPUT_MAX)
self.present_text_item.setPos(*pos)
self.not_present_text_item.setPos(*pos)
self.move_hist_plot.addItem(self.present_text_item)
self.move_hist_plot.addItem(self.not_present_text_item)
self.present_text_item.hide()
# Sector plot
self.sector_plot = pg.PlotItem()
self.sector_plot.setAspectLocked()
self.sector_plot.hideAxis("left")
self.sector_plot.hideAxis("bottom")
self.sectors = []
pen = pg.mkPen("k", width=1)
span_deg = 25
for r in np.flip(np.arange(self.num_sectors) + 1):
sector = pg.QtGui.QGraphicsEllipseItem(-r, -r, r * 2, r * 2)
sector.setStartAngle(-16 * span_deg)
sector.setSpanAngle(16 * span_deg * 2)
sector.setPen(pen)
self.sector_plot.addItem(sector)
self.sectors.append(sector)
self.sectors.reverse()
sublayout = win.addLayout(row=3, col=0)
sublayout.layout.setColumnStretchFactor(0, 2)
sublayout.addItem(self.move_hist_plot, col=0)
sublayout.addItem(self.sector_plot, col=1)
self.setup_is_done = True
self.update_processing_config()
# use only when FFileDialog.by crashes when opening the dialog windows
DONOT_USE_QFILE_NATIVE_DIALOG = False
# the length of the TimeVector
# TIMEVECTOR_LENGTH = 8
# plotting initialization
PLOT_GRID_ALPHA = 0.7
ROI_PLOT_WIDTH = 2.0
MUSTER_Y_LIMITS = (-32767, 32768)
# transparency of design template overlay
MUSTER_PLOT_ALPHA = 50
MAX_ROI_NAME_LENGTH = 6
ROI_PLOT_COLORS = [
pg.mkColor(0, 0, 255, 255),
pg.mkColor(0, 255, 255, 255),
pg.mkColor(0, 255, 0, 255),
pg.mkColor(255, 0, 255, 255),
pg.mkColor(255, 0, 0, 255),
pg.mkColor(255, 255, 0, 255),
pg.mkColor(140, 200, 240, 255),
pg.mkColor(208, 208, 147, 255),
pg.mkColor(147, 0, 0, 255),
pg.mkColor(0, 0, 0, 255)
]
STAT_PLOT_COLORS = [
pg.mkColor(0, 0, 255, 255),
pg.mkColor(0, 255, 255, 255),
pg.mkColor(0, 255, 0, 255),
pg.mkColor(255, 0, 255, 255),
def __init__(self, model):
super().__init__()
self.setWindowTitle("OpenHRV")
self.setWindowIcon(QIcon(":/logo.png"))
self.setGeometry(50, 50, 1750, 850)
self.model = model
self.signals = ViewSignals()
self.scanner = SensorScanner()
self.scanner_thread = QThread(self)
self.scanner.moveToThread(self.scanner_thread)
self.scanner.mac_update.connect(self.model.set_mac_addresses)
self.sensor = SensorClient()
self.sensor_thread = QThread(self)
self.sensor.moveToThread(self.sensor_thread)
self.sensor.ibi_update.connect(self.model.set_ibis_buffer)
self.sensor_thread.started.connect(self.sensor.run)
self.redis_publisher = RedisPublisher()
self.redis_publisher_thread = QThread(self)
self.redis_publisher.moveToThread(self.redis_publisher_thread)
self.model.ibis_buffer_update.connect(self.redis_publisher.publish)
self.model.mean_hrv_update.connect(self.redis_publisher.publish)
self.model.mac_addresses_update.connect(self.redis_publisher.publish)
self.model.pacer_rate_update.connect(self.redis_publisher.publish)
self.model.hrv_target_update.connect(self.redis_publisher.publish)
self.model.biofeedback_update.connect(self.redis_publisher.publish)
self.signals.annotation.connect(self.redis_publisher.publish)
self.redis_publisher_thread.started.connect(
self.redis_publisher.monitor.start)
self.redis_logger = RedisLogger()
self.redis_logger_thread = QThread(self)
self.redis_logger.moveToThread(self.redis_logger_thread)
self.redis_logger_thread.finished.connect(
self.redis_logger.save_recording)
self.redis_logger.recording_status.connect(self.show_recording_status)
self.ibis_plot = pg.PlotWidget()
self.ibis_plot.setBackground("w")
self.ibis_plot.setLabel("left", "Inter-Beat-Interval (msec)",
**{"font-size": "25px"})
self.ibis_plot.setLabel("bottom", "Seconds", **{"font-size": "25px"})
self.ibis_plot.showGrid(y=True)
self.ibis_plot.setYRange(300, 1500, padding=0)
self.ibis_plot.setMouseEnabled(x=False, y=False)
self.ibis_signal = pg.PlotCurveItem()
pen = pg.mkPen(color=(0, 191, 255), width=7.5)
self.ibis_signal.setPen(pen)
self.ibis_signal.setData(self.model.ibis_seconds,
self.model.ibis_buffer)
self.ibis_plot.addItem(self.ibis_signal)
self.mean_hrv_plot = pg.PlotWidget()
self.mean_hrv_plot.setBackground("w")
self.mean_hrv_plot.setLabel("left", "HRV (msec)",
**{"font-size": "25px"})
self.mean_hrv_plot.setLabel("bottom", "Seconds",
**{"font-size": "25px"})
self.mean_hrv_plot.showGrid(y=True)
self.mean_hrv_plot.setYRange(0, 600, padding=0)
self.mean_hrv_plot.setMouseEnabled(x=False, y=False)
colorgrad = QLinearGradient(0, 0, 0, 1) # horizontal gradient
colorgrad.setCoordinateMode(QGradient.ObjectMode)
colorgrad.setColorAt(0, pg.mkColor("g"))
colorgrad.setColorAt(.5, pg.mkColor("y"))
colorgrad.setColorAt(1, pg.mkColor("r"))
brush = QBrush(colorgrad)
self.mean_hrv_plot.getViewBox().setBackgroundColor(brush)
self.mean_hrv_signal = pg.PlotCurveItem()
pen = pg.mkPen(color="w", width=7.5)
self.mean_hrv_signal.setPen(pen)
self.mean_hrv_signal.setData(self.model.mean_hrv_seconds,
self.model.mean_hrv_buffer)
self.mean_hrv_plot.addItem(self.mean_hrv_signal)
self.pacer_plot = pg.PlotWidget()
self.pacer_plot.setBackground("w")
self.pacer_plot.setAspectLocked(lock=True, ratio=1)
self.pacer_plot.setMouseEnabled(x=False, y=False)
self.pacer_plot.disableAutoRange()
self.pacer_plot.setXRange(-1, 1, padding=0)
self.pacer_plot.setYRange(-1, 1, padding=0)
self.pacer_plot.hideAxis("left")
self.pacer_plot.hideAxis("bottom")
self.pacer_disc = pg.PlotCurveItem()
brush = pg.mkBrush(color=(135, 206, 250))
self.pacer_disc.setBrush(brush)
self.pacer_disc.setFillLevel(1)
self.pacer_plot.addItem(self.pacer_disc)
self.pacer_rate = QSlider(Qt.Horizontal)
self.pacer_rate.setTracking(False)
self.pacer_rate.setRange(
0, 6) # transformed to bpm [4, 7], step .5 by model
self.pacer_rate.valueChanged.connect(self.model.set_breathing_rate)
self.pacer_rate.setSliderPosition(4) # corresponds to 6 bpm
self.pacer_label = QLabel(f"Rate: {self.model.breathing_rate}")
self.pacer_toggle = QCheckBox("Show pacer", self)
self.pacer_toggle.setChecked(True)
self.pacer_toggle.stateChanged.connect(self.toggle_pacer)
self.hrv_target_label = QLabel(f"Target: {self.model.hrv_target}")
self.hrv_target = QSlider(Qt.Horizontal)
self.hrv_target.setRange(50, 600)
self.hrv_target.setSingleStep(10)
self.hrv_target.valueChanged.connect(self.model.set_hrv_target)
self.hrv_target.setSliderPosition(self.model.hrv_target)
self.mean_hrv_plot.setYRange(0, self.model.hrv_target, padding=0)
self.scan_button = QPushButton("Scan")
self.scan_button.clicked.connect(self.scanner.scan)
self.mac_menu = QComboBox()
self.connect_button = QPushButton("Connect")
self.connect_button.clicked.connect(self.connect_sensor)
self.start_recording_button = QPushButton("Start")
self.start_recording_button.clicked.connect(
self.redis_logger.start_recording)
self.save_recording_button = QPushButton("Save")
self.save_recording_button.clicked.connect(
self.redis_logger.save_recording)
self.annotation = QComboBox()
self.annotation.setEditable(True)
self.annotation.setDuplicatesEnabled(False)
self.annotation.addItems([
"start_baseline", "end_baseline", "start_bf", "end_bf",
"start_nobf", "end_nobf"
])
self.annotation.setMaxCount(
10) # user can configure up to 4 additional custom annotations
self.annotation_button = QPushButton("Annotate")
self.annotation_button.clicked.connect(self.emit_annotation)
self.central_widget = QWidget()
self.setCentralWidget(self.central_widget)
self.recording_status_label = QLabel("Status:")
self.recording_statusbar = QProgressBar()
self.recording_statusbar.setRange(0, 1)
self.vlayout0 = QVBoxLayout(self.central_widget)
self.hlayout0 = QHBoxLayout()
self.hlayout0.addWidget(self.ibis_plot, stretch=80)
self.hlayout0.addWidget(self.pacer_plot, stretch=20)
self.vlayout0.addLayout(self.hlayout0)
self.vlayout0.addWidget(self.mean_hrv_plot)
self.hlayout1 = QHBoxLayout()
self.device_config = QFormLayout()
self.device_config.addRow(self.scan_button, self.mac_menu)
self.device_config.addRow(self.connect_button)
self.device_panel = QGroupBox("ECG Devices")
self.device_panel.setLayout(self.device_config)
self.hlayout1.addWidget(self.device_panel, stretch=25)
self.hrv_config = QFormLayout()
self.hrv_config.addRow(self.hrv_target_label, self.hrv_target)
self.hrv_panel = QGroupBox("HRV Settings")
self.hrv_panel.setLayout(self.hrv_config)
self.hlayout1.addWidget(self.hrv_panel, stretch=25)
self.pacer_config = QFormLayout()
self.pacer_config.addRow(self.pacer_label, self.pacer_rate)
self.pacer_config.addRow(self.pacer_toggle)
self.pacer_panel = QGroupBox("Breathing Pacer")
self.pacer_panel.setLayout(self.pacer_config)
self.hlayout1.addWidget(self.pacer_panel, stretch=25)
self.recording_config = QGridLayout()
self.recording_config.addWidget(self.start_recording_button, 0, 0)
self.recording_config.addWidget(self.save_recording_button, 0, 1)
self.recording_config.addWidget(self.recording_statusbar, 0, 2)
self.recording_config.addWidget(self.annotation, 1, 0, 1,
2) # row, column, rowspan, columnspan
self.recording_config.addWidget(self.annotation_button, 1, 2)
self.recording_panel = QGroupBox("Recording")
self.recording_panel.setLayout(self.recording_config)
self.hlayout1.addWidget(self.recording_panel, stretch=25)
self.vlayout0.addLayout(self.hlayout1)
self.model.ibis_buffer_update.connect(self.plot_ibis)
self.model.mean_hrv_update.connect(self.plot_hrv)
self.model.mac_addresses_update.connect(self.list_macs)
self.model.pacer_disk_update.connect(self.plot_pacer_disk)
self.model.pacer_rate_update.connect(self.update_pacer_label)
self.model.hrv_target_update.connect(self.update_hrv_target)
self.scanner_thread.start()
self.sensor_thread.start()
self.redis_publisher_thread.start()
self.redis_logger_thread.start()
def drawObjects(self, view_manager):
# clear any clusters that may be present
for view in view_manager.getViewPorts():
plane = view.plane()
clusters = self._clusters[plane]
for cluster in clusters:
cluster.clearHits(view)
# Showers can get messed up so only draw "good" showers
# This means that if either projection is bad, don't draw that shower
for view in view_manager.getViewPorts():
# get the showers from the process:
self._drawnObjects.append([])
showers = self._process.getDataByPlane(view.plane())
i_color = 0
for i in xrange(len(showers)):
shower = showers[i]
if i_color >= len(self._showerColors):
i_color = 0
color = self._showerColors[i_color]
# construct a polygon for this shower:
points = []
# Remember - everything is in cm, but the display is in
# wire/time!
geom = view_manager._geometry
offset = geom.offset(view.plane()) / geom.time2cm()
x = shower.startPoint().w / geom.wire2cm()
y = shower.startPoint().t / geom.time2cm() + offset
points.append(QtCore.QPoint(x, y))
# next connect the two points at the end of the shower to make
# a cone
#
# We need the vector that's perpendicular to the axis, to make the cone.
# Use 3D vectors to allow the cross product:
zAxis = TVector3(0, 0, 1)
showerAxis = TVector3(
shower.endPoint().w - shower.startPoint().w,
shower.endPoint().t - shower.startPoint().t, 0.0)
perpAxis = zAxis.Cross(showerAxis)
length = showerAxis.Mag() * mt.tan(shower.openingAngle() / 2)
perpAxis *= length / perpAxis.Mag()
x1, y1 = shower.endPoint().w + perpAxis.X(), shower.endPoint().t + \
perpAxis.Y()
x2, y2 = shower.endPoint().w - perpAxis.X(), shower.endPoint().t - \
perpAxis.Y()
# Scale everything to wire/time:
x1 /= geom.wire2cm()
y1 /= geom.time2cm()
x2 /= geom.wire2cm()
y2 /= geom.time2cm()
y1 += offset
y2 += offset
points.append(QtCore.QPoint(x1, y1))
points.append(QtCore.QPoint(x2, y2))
thisPolyF = QtGui.QPolygonF(points)
self.shower_poly = QtGui.QGraphicsPolygonItem(thisPolyF)
self.shower_poly = shower_polygon(thisPolyF)
#thisPoly = QtGui.QGraphicsPolygonItem(thisPolyF)
self.shower_poly._energy = shower.energy()
self.shower_poly._dedx = shower.dedx()
self.shower_poly.setPen(pg.mkPen(None))
self.shower_poly.setBrush(pg.mkColor(color))
# hovering stuff
#self.shower_poly.connectOwnerHoverEnter(self.shower_poly.hoverEnter)
#self.shower_poly.connectOwnerHoverExit (self.shower_poly.hoverExit)
#self.shower_poly.connectToggleHighlight(self.shower_poly.toggleHighlight)
# self.shower_poly.connectToolTip(self.shower_poly.genToolTip)
#self.shower_poly.connectOwnerHoverEnter(self.shower_poly._ownerHoverEnter)
#self.shower_poly.connectOwnerHoverExit(self.shower_poly._ownerHoverExit)
#self.shower_poly.connectToolTip(self.shower_poly.genToolTip)
view._view.addItem(self.shower_poly)
self._drawnObjects[view.plane()].append(self.shower_poly)
# if view.plane() == 0:
# print "dedx: ", shower.dedx()
# now add cluster too
plane = view.plane()
cluster = shower._showerCluster_v[plane]
self._clusters[plane].append(boxCollection())
self._clusters[plane][-1].setColor(color)
self._clusters[plane][-1].setPlane(plane)
self._clusters[plane][-1].drawHits(view, cluster, geom)
i_color += 1
def initialize_plot(self):
self.viewBox = MyViewBox()
self.plot = pg.PlotItem(viewBox=self.viewBox)
self.graphicsview.setCentralItem(self.plot)
self.plot.hideButtons()
self.plot.showAxis('left', False)
self.viewBox.gain_zoom.connect(self.gain_zoom)
self.viewBox.xsize_zoom.connect(self.xsize_zoom)
self.visible_channels = np.zeros(self.controller.nb_channel,
dtype='bool')
self.max_channel = min(16, self.controller.nb_channel)
#~ self.max_channel = min(5, self.controller.nb_channel)
if self.controller.nb_channel > self.max_channel:
self.visible_channels[:self.max_channel] = True
self.scroll_chan.show()
self.scroll_chan.setMinimum(0)
self.scroll_chan.setMaximum(self.controller.nb_channel -
self.max_channel)
self.scroll_chan.setPageStep(self.max_channel)
else:
self.visible_channels[:] = True
self.scroll_chan.hide()
self.signals_curve = pg.PlotCurveItem(pen='#7FFF00', connect='finite')
self.plot.addItem(self.signals_curve)
self.scatter = pg.ScatterPlotItem(size=10, pxMode=True)
self.plot.addItem(self.scatter)
self.scatter.sigClicked.connect(self.scatter_item_clicked)
self.channel_labels = []
self.threshold_lines = []
for i, chan_name in enumerate(self.controller.channel_names):
#TODO label channels
label = pg.TextItem('{}: {}'.format(i, chan_name),
color='#FFFFFF',
anchor=(0, 0.5),
border=None,
fill=pg.mkColor((128, 128, 128, 180)))
self.plot.addItem(label)
self.channel_labels.append(label)
for i in range(self.max_channel):
tc = pg.InfiniteLine(angle=0.,
movable=False,
pen=pg.mkPen(color=(128, 128, 128, 120)))
tc.setPos(0.)
self.threshold_lines.append(tc)
self.plot.addItem(tc)
tc.hide()
pen = pg.mkPen(color=(128, 0, 128, 120), width=3, style=QT.Qt.DashLine)
self.selection_line = pg.InfiniteLine(pos=0.,
angle=90,
movable=False,
pen=pen)
self.plot.addItem(self.selection_line)
self.selection_line.hide()
pen = pg.mkPen(color=(128, 128, 0, 120), width=3, style=QT.Qt.DotLine)
for trigger in self.triggers:
trigger_line = pg.InfiniteLine(pos=trigger / 1e6,
angle=90,
movable=False,
pen=pen)
self.plot.addItem(trigger_line)
trigger_line.show()
self._initialize_plot()
self.gains = None
self.offsets = None
def colorValue(self):
return pg.mkColor(Parameter.value(self))
# set QT_API environment variable
import os
os.environ["QT_API"] = "pyqt5"
import qtpy
# qt libraries
from qtpy.QtCore import *
from qtpy.QtWidgets import *
from qtpy.QtGui import *
# app specific libraries
import gui as gui
import pyqtgraph as pg
# pg.setConfigOption('background', pg.mkColor(186, 227, 230))
pg.setConfigOption('background', pg.mkColor(207, 227, 227))
pg.setConfigOption('foreground', 'k')
if __name__ == "__main__":
app = QApplication([])
win = gui.VentDevGUI()
win.show()
app.exec_() #sys.exit(app.exec_())
def __init__(self, alphaData, gammaData=None, view=None):
super(FanDiagram, self).__init__()
if gammaData is None and isinstance(alphaData, FanCompiler):
alphaData, gammaData = alphaData.build(withErrors=False)[:2]
self.layout = QtWidgets.QHBoxLayout()
self.histAlpha = HistogramLUTWidget(self)
self.centralView = GraphicsView()
self.histGamma = HistogramLUTWidget(self)
self.histAlpha.setMinimumWidth(150)
self.histGamma.setMinimumWidth(150)
self.layout.addWidget(self.histGamma)
self.layout.addWidget(self.centralView)
self.layout.addWidget(self.histAlpha)
self.layout.setContentsMargins(0, 0, 0, 0)
self.layout.setSpacing(0)
self.setLayout(self.layout)
if view is None:
self.view = ViewBox()
else:
self.view = view
self.centralView.setCentralItem(self.view)
self.view.setAspectLocked(True)
self.view.invertY(True)
if isinstance(alphaData, str) and isinstance(gammaData, str):
alphaData = np.genfromtxt(alphaData, delimiter=',')
gammaData = np.genfromtxt(gammaData, delimiter=',')
if alphaData.ndim == gammaData.ndim == 1:
# Assume you just want it to be created, and will later populate it
nirAlphas = alphaData
sbs = gammaData
alphaData = \
np.ones((sbs.shape[0] + 1, nirAlphas.shape[0] + 1)) * -1
alphaData[1:, 0] = sbs
alphaData[0, 1:] = nirAlphas
gammas = np.ones((sbs.shape[0] + 1, nirAlphas.shape[0] + 1)) * -1
gammas[1:, 0] = sbs
gammas[0, 1:] = nirAlphas
sbs = alphaData[1:, 0]
maxSB = sbs.max()
nirAlphas = alphaData[0, 1:]
self.alphaItem = PolarImageItem(r=sbs, theta=nirAlphas)
self.alphaItem.setImage(alphaData[1:, 1:])
# nirAlphas+180 is what causes the gamma angles to appear on the left
# side of the fan. This seemed easier than doing some sort of
# coordinate inversion/flipping on the plot itself.
self.gammaItem = PolarImageItem(sbs, nirAlphas + 180, gammaData[1:,
1:])
self.view.addItem(self.alphaItem)
self.view.addItem(self.gammaItem)
self.histAlpha.setImageItem(self.alphaItem)
self.histGamma.setImageItem(self.gammaItem)
# manually set the default state to the black-gold-white-green-black.
# Not sure if it's necessary to have this be a free parameter vs being
# hardcoded
self.histAlpha.gradient.restoreState({
"mode":
"rgb",
"ticks": [(0, (0, 0, 0, 255)), (.25, (128, 128, 0, 255)),
(.5, (255, 255, 255, 255)), (.75, (0, 128, 0, 255)),
(1, (0, 0, 0, 255))]
})
# Set the default spacings for the alpha color axis. Again, not sure if
# it's better to leave the 18pt font hard-coded or not, but I am
self.histAlpha.axis.setTickFont(QtGui.QFont("Arial", 18))
self.histAlpha.axis.setTickSpacing(30, 15)
self.histAlpha.axis.setLabel(
"α (°)", **{
'font-family': 'Times',
"font-size": "18pt"
})
# As with alpha, hard code the initial color space for gamma
# (blue-white-red) and the font spacings and stuff
self.histGamma.gradient.restoreState({
"mode":
"rgb",
"ticks": [(0, (255, 0, 0, 255)), (.5, (255, 255, 255, 255)),
(1, (0, 0, 255, 255))]
})
self.histGamma.axis.setTickFont(QtGui.QFont("Arial", 18))
self.histGamma.axis.setTickSpacing(15, 15)
self.histGamma.axis.setLabel(
"γ (°)", **{
'font-family': 'Times',
"font-size": "18pt"
})
self.histAlpha.item.setLevels(-90, 90)
self.histGamma.item.setLevels(-45, 45)
self.histAlpha.autoHistogramRange()
self.histGamma.autoHistogramRange()
# Make it the right dimensions, making sure that the width is
# appropriate. This makes it easier to automate plotting/saving fans
# and making sure their dimensions are consistent.
g = self.geometry()
# I found these by eye, there's not very much important about them
g.setWidth(773)
g.setHeight(480)
# Manually center it on the screen, since geometry isn't well defined
# at this point before events are processed
g.moveCenter(
QtWidgets.QApplication.desktop().screenGeometry().center())
self.setGeometry(g)
# Add in the radial axes for it
self.axes = {
"radial": PolarAxis("radial"),
"azimuthal": PolarAxis("azimuthal")
}
# Lighten the radial font to make it distinct from the other
p = self.axes["radial"].pen()
p.setColor(mkColor("#666666"))
self.axes["radial"].setPen(p)
for a in self.axes.values():
# Make sure the axes sit on top of all other items
a.setZValue(10000)
# make sure that they scale appropriately, instead of just floating
# on top
a.linkToView(self.view)
# Ignore bounds prevents the window from resizing to try and fit in
# the axes items
self.addItem(a, ignoreBounds=True)
# manually set the positions and string values for alpha angles.
# [-90, 90] work well. The other half needs the +-180 to make sure the
# gamma angles have the correctly labeled with respect to alpha_nir
self.axes["azimuthal"].setTicks([
# alpha side (Q1+Q4)
[(ii, str(ii)) for ii in np.arange(-90, 91, 30)] +
# Q3
[(ii, str(ii + 180)) for ii in np.arange(-180, -91, 30)] +
# Q1
[(ii, str(ii - 180)) for ii in np.arange(120, 151, 30)],
])
# add a title (without text)
self.titleItem = TextItem()
# anchor on bottom-center
# Again, not sure if it's necessary to have the font color/size being
# a free parameter
self.titleItem.setAnchor(Point(0.5, 1))
self.titleItem.setColor("k")
self.titleItem.setFont(QtGui.QFont("Arial", 15))
# Ignore bounds so that the view won't try to account for it (which
# causes a conflict because the title is placed with respect to the
# view region)
self.view.addItem(self.titleItem, ignoreBounds=True)
self.show()
# Arbitrary forcing updates to try and track down why some things don't
# update correctly
QtWidgets.QApplication.processEvents()
self.view.updateViewRange(True, True)
