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)