def __init__(self, pos, vel, charge, eneg, idempot, dt): pg.setConfigOptions(antialias=True) self.app = QtGui.QApplication([]) self.w = pg.GraphicsWindow() self.w.setWindowTitle('Particles') self.g = pg.GraphItem() self.v = self.w.addPlot() self.v.addItem(self.g) self.view_window = (-11, 11) self.wall_dist = (-10, 10) self.dragged_point_index = None self.dragOffset = None self.dt = dt self.position = pos self.vel = vel self.charge = charge self.eneg = eneg self.idempot = idempot self.n_part = len(pos) self.eq_dist = 1 self.grav_pull = np.array([0, -1]) * 0.00000 self.max_vel = 1 self.cmap = pg.ColorMap([-0.5, 0, 0.5], np.array([[255, 0, 0, 255], [255, 255, 255, 255], [0, 0, 255, 255]])) pg.GraphItem.__init__(self)
def __init__(self, parent=None): self.play = True self.frames = 50 self.xdim = 600 self.ydim = 600 self.noize = 1 self.data = None self.text = custom_graph.CustomGraph() self.item = pg.ImageItem() self.i = None self.mass_centers = pg.GraphItem() self.fps = None self.updateTime = None #self.pos = np.linspace(0, 1, 256) #n = len(self.pos) #self.color = [] #for i in range(n): # self.color.append([((n-i)/n), (i/n), ((n-i)/n), 1]) #self.colmap = pg.ColorMap(self.pos, self.color) #self.lut = self.colmap.getLookupTable(0, 1.0, 256) colormap = cm.get_cmap("plasma") # cm.get_cmap("CMRmap") colormap._init() self.lut = (colormap._lut * 255).view(np.ndarray) super().__init__(parent) self.initUI()
def display_grid(self): # remove previous grid if any if self.parent.grid_view['item']: self.parent.ui.image_view.removeItem(self.parent.grid_view['item']) # if we want a grid if self.parent.ui.grid_display_checkBox.isChecked(): grid_size = self.parent.ui.grid_size_slider.value() [width, height] = np.shape(self.parent.live_image) pos_adj_dict = self.calculate_matrix_grid(grid_size=grid_size, height=height, width=width) pos = pos_adj_dict['pos'] adj = pos_adj_dict['adj'] line_color = self.parent.grid_view['color'] _transparency_value = 255 - (np.float(str(self.parent.ui.transparency_slider.value()))/100) * 255 _list_line_color = list(line_color) _list_line_color[3] = _transparency_value line_color = tuple(_list_line_color) lines = np.array([line_color for n in np.arange(len(pos))], dtype=[('red', np.ubyte), ('green', np.ubyte), ('blue', np.ubyte), ('alpha', np.ubyte), ('width', float)]) grid = pg.GraphItem() self.parent.ui.image_view.addItem(grid) grid.setData(pos=pos, adj=adj, pen=lines, symbol=None, pxMode=False) self.parent.grid_view['item'] = grid
def show(self): if self._view is None: pg.mkQApp() self._view_widget = pg.GraphicsLayoutWidget() self._view = self._view_widget.addViewBox(0, 0) v = self._view cell_ids = sorted(self.cells.keys()) pos = np.array([self.cells[i].position[:2] for i in cell_ids]) if len(self.connections) == 0: adj = np.empty((0, 2), dtype='int') else: adj = np.array(self.connections) - 1 colors = [] for cid in cell_ids: cell = self.cells[cid] color = [0, 0, 0] for i, cre in enumerate(self.cre_types): if cell.labels[cre] == '+': color[i] = 255 colors.append(color) brushes = [pg.mkBrush(c) for c in colors] print(pos) print(adj) print(colors) self._graph = pg.GraphItem(pos=pos, adj=adj, size=30, symbolBrush=brushes) v.addItem(self._graph) self._view_widget.show()
def __init__(self, color=None, tooltip=""): """ :param color: the color for the lines :param tooltip: an optional tooltip to show :return: """ SpectralVisualItemWrapper.__init__(self) # time limits self.indexFrom = 0 self.indexTo = 0 # the freq value self.peak_freq_value = 0 if color is not None and isinstance(color, QtGui.QColor): self.COLOR = color # a line for peak freq self.peak_freq_pos = np.array([[self.indexFrom, self.peak_freq_value], [self.indexTo, self.peak_freq_value]]) self.peak_freq_region = pg.GraphItem() self.tooltip = tooltip self.peak_freq_region.setToolTip(self.tooltip)
def __init__(self, positions, parent=None): super(Widget, self).__init__(parent=parent) p = self.palette() p.setColor(self.backgroundRole(), QtGui.QColor(100, 100, 100)) self.setPalette(p) self.vertical_layout = QVBoxLayout(self) self.win = pg.GraphicsWindow() view_box = self.win.addViewBox() self.graph_item = pg.GraphItem() view_box.addItem(self.graph_item) self.vertical_layout.addWidget(self.win) self.eps_slider = Slider() self.vertical_layout.addWidget(self.eps_slider) self.v_rips_complex = VietorisRipsComplex(positions) self.line_pen = pg.mkPen((238, 130, 238), width=3) self.node_brushes = [pg.mkBrush('k') for _ in positions] self.perim_nodes = [pg.mkBrush(color=(255, 165, 0, 40)) for _ in positions] self.brushes = self.node_brushes + self.perim_nodes self.node_sizes = [0.2 for _ in positions] # Define the symbol to use for each node (this is optional) self.symbols = ['o'] * len(self.v_rips_complex.network.nodes) self.communicate = Communicate() self.communicate.update_simplices.connect(self.update_simplices) self.eps_slider.slider.valueChanged.connect(self.update_graph) self.update_graph(0)
def display_roi(self): if len( np.array(self.parent.data_metadata['normalized'] ['data_live_selection'])) == 0: return pos = self.parent.binning_line_view['pos'] adj = self.parent.binning_line_view['adj'] lines = self.parent.binning_line_view['pen'] if pos is None: return self.parent.fitting_ui.there_is_a_roi = True # define new transparency of roi transparency = self.parent.fitting_ui.slider.value() lines = colors.set_alpha_value(lines=lines, transparency=transparency) if self.parent.fitting_ui.line_view_fitting: self.parent.fitting_ui.image_view.removeItem( self.parent.fitting_ui.line_view_fitting) line_view_fitting = pg.GraphItem() self.parent.fitting_ui.line_view_fitting = line_view_fitting self.parent.fitting_ui.image_view.addItem(line_view_fitting) self.parent.fitting_ui.line_view = line_view_fitting self.parent.fitting_ui.line_view.setData(pos=pos, adj=adj, pen=lines, symbol=None, pxMode=False)
def __init__(self, plot, parent, defaultSize, defaultGain, connectDots): self.parent = parent self.data = VisualizerData(defaultSize, defaultGain) self.frame = 0 self.connectDots = connectDots # Timings used for the output file self.timings = {} # Set the plot up for visualization self.lines = pg.GraphItem(pos=np.array([(-100, -100)])) plot.addItem(self.lines) p = plot.getPlotItem() p.setXRange(0, 10) p.setYRange(0, 10) p.showGrid(False, False) p.showAxis('left', False) p.showAxis('bottom', False) p.setMouseEnabled(False, False) p.hideButtons() self.plotTimer = QtCore.QTimer() self.plotTimer.setTimerType(QtCore.Qt.PreciseTimer) self.plotTimer.timeout.connect(self.plotData) self.audTimer = QtCore.QTimer() self.audTimer.setTimerType(QtCore.Qt.PreciseTimer) self.audTimer.timeout.connect(self.playAudio) self.audComplete = QtCore.QTimer() self.audComplete.timeout.connect(self.progressAudio)
def _define_profile(self): # profile # [x0, y0, width, height] = self.parent.get_item_row(row=self.row) _profile_width = self.parent.get_profile_width(row=self.row) is_x_profile_direction = self.parent.ui.profile_direction_x_axis.isChecked( ) # delta_profile = (_profile_width - 1) / 2. profile_dimension = self.parent.get_profile_dimensions(row=self.row) x_left = profile_dimension.x_left x_right = profile_dimension.x_right y_top = profile_dimension.y_top y_bottom = profile_dimension.y_bottom if is_x_profile_direction: pos = [] pos.append([x_left, y_top]) pos.append([x_right, y_top]) adj = [] adj.append([0, 1]) if y_top != y_bottom: # height == 1 pos.append([x_left, y_bottom]) pos.append([x_right, y_bottom]) adj.append([2, 3]) adj = np.array(adj) pos = np.array(pos) else: # y-profile direction pos = [] pos.append([x_left, y_top]) pos.append([x_left, y_bottom]) adj = [] adj.append([0, 1]) if y_top != y_bottom: # height == 1 pos.append([x_right, y_top]) pos.append([x_right, y_bottom]) adj.append([2, 3]) adj = np.array(adj) pos = np.array(pos) line_color = self.parent.profile_color _list_line_color = list(line_color) line_color = tuple(_list_line_color) lines = np.array([line_color for n in np.arange(len(pos))], dtype=[('red', np.ubyte), ('green', np.ubyte), ('blue', np.ubyte), ('alpha', np.ubyte), ('width', float)]) profile = pg.GraphItem() self.parent.ui.image_view.addItem(profile) profile.setData(pos=pos, adj=adj, pen=lines, symbol=None, pxMode=False) self.__profile = profile
def display_grid(self): [width, height] = [self.width, self.height] bin_size = self.grid_size x0 = 0 y0 = 0 pos_adj_dict = {} nbr_height_bins = np.float(height) / np.float(bin_size) real_height = y0 + np.int(nbr_height_bins) * np.int(bin_size) nbr_width_bins = np.float(width) / np.float(bin_size) read_width = x0 + np.int(nbr_width_bins) * np.int(bin_size) # pos (each matrix is one side of the lines) pos = [] adj = [] # vertical lines x = x0 index = 0 while (x <= x0 + width): one_edge = [x, y0] other_edge = [x, real_height] pos.append(one_edge) pos.append(other_edge) adj.append([index, index + 1]) x += bin_size index += 2 # horizontal lines y = y0 while (y <= y0 + height): one_edge = [x0, y] other_edge = [read_width, y] pos.append(one_edge) pos.append(other_edge) adj.append([index, index + 1]) y += bin_size index += 2 pos = np.array(pos) adj = np.array(adj) line_color = (255, 0, 0, 155, 0.2) lines = np.array([line_color for n in np.arange(len(pos))], dtype=[('red', np.ubyte), ('green', np.ubyte), ('blue', np.ubyte), ('alpha', np.ubyte), ('width', float)]) line_view_binning = pg.GraphItem() self.ui.image_view.addItem(line_view_binning) line_view_binning.setData(pos=pos, adj=adj, pen=lines, symbol=None, pxMode=False) self.line_view_binning = line_view_binning
def makeGraph(self): #g1 = pg.GraphItem(pos=self.pos, adj=self.links[self.rope], pen=0.2, symbol=None) brushes = np.where(self.fixed, pg.mkBrush(0,0,0,255), pg.mkBrush(50,50,200,255)) g2 = pg.GraphItem(pos=self.pos, adj=self.links[self.push & self.pull], pen=0.5, brush=brushes, symbol='o', size=(self.mass**0.33), pxMode=False) p = pg.ItemGroup() #p.addItem(g1) p.addItem(g2) return p
def _qtg_plot_graph(G, edges, vertex_size, title): # TODO handling when G is a list of graphs qtg, gl, QtGui = _import_qtg() if G.is_directed(): raise NotImplementedError else: if G.coords.shape[1] == 2: window = qtg.GraphicsWindow() window.setWindowTitle(title) view = window.addViewBox() view.setAspectLocked() if edges: pen = tuple(np.array(G.plotting['edge_color']) * 255) else: pen = None adj = _get_coords(G, edge_list=True) g = qtg.GraphItem(pos=G.coords, adj=adj, pen=pen, size=vertex_size / 10) view.addItem(g) global _qtg_windows _qtg_windows.append(window) elif G.coords.shape[1] == 3: if not QtGui.QApplication.instance(): QtGui.QApplication([]) # We want only one application. widget = gl.GLViewWidget() widget.opts['distance'] = 10 widget.show() widget.setWindowTitle(title) if edges: x, y, z = _get_coords(G) pos = np.stack((x, y, z), axis=1) g = gl.GLLinePlotItem(pos=pos, mode='lines', color=G.plotting['edge_color']) widget.addItem(g) gp = gl.GLScatterPlotItem(pos=G.coords, size=vertex_size / 3, color=G.plotting['vertex_color']) widget.addItem(gp) global _qtg_widgets _qtg_widgets.append(widget)
def __init__(self,parent=None): QtWidgets.QWidget.__init__(self,parent) self.ui=Ui_normalJoint() self.ui.setupUi(self) self.dialog=QtWidgets.QDialog(self) self.dialog.ui=Ui_normalJointDialog() self.dialog.ui.setupUi(self.dialog) self.num=0 self.fingerName='Pinky' self.jointName='NNNNN' self.type=0 self.pressure=0 self.angle=0 self.pressureMax=180.0 self.angleMax=120.0 self.weight= [10000 ,1, 1, 1, 1, 1, 1, 1, 1, 1] self.angleList= [0, 10,20,30,40,50,60,70,80,90,100,110,120] self.pressureList=[0,27,48,65,79,90,100,109,119,130,145,163,180] self.model=QtGui.QStandardItemModel(self.dialog.ui.table) angleItemList=[] pressureItemList=[] for angle in self.angleList: angleItemList.append(QtGui.QStandardItem('{:d}'.format(angle))) for pressure in self.pressureList: pressureItemList.append(QtGui.QStandardItem('{:d}'.format(pressure))) self.model.appendRow(angleItemList) self.model.appendRow(pressureItemList) self.model.setHeaderData(0,QtCore.Qt.Vertical,'Angle '+u'\N{DEGREE SIGN}') self.model.setHeaderData(1,QtCore.Qt.Vertical,'Pressure (KPa)') self.relationPlotScatter = pg.GraphItem() self.relationPlotCurve=self.dialog.ui.relationPlotWidget.plot() v=self.relationPlotCurve.getViewBox() v.addItem(self.relationPlotScatter) self.dialog.ui.relationPlotWidget.setLabel('bottom', 'Angle', units=u'\N{DEGREE SIGN}') self.dialog.ui.relationPlotWidget.setLabel('left', 'Pressure', units='KPa') self.dialog.ui.table.setModel(self.model) self.dialog.ui.table.setSizeAdjustPolicy(QtWidgets.QAbstractScrollArea.AdjustToContents) self.dialog.ui.table.resizeColumnsToContents() self.model.itemChanged.connect(self.updateAnglePressureRelation) self.relationPlotScatter.scatter.sigPointDragged.connect(self.slotPointDragged) self.xarray=np.array(self.angleList) self.yarray=np.array(self.pressureList) self.updateAnglePressureRelation(None) self.dialog.ui.openingMaxP.sigValueChanged.connect(self.slotMaxPChanged) self.dialog.ui.openingMinP.sigValueChanged.connect(self.slotMinPChanged) self.dialog.ui.openingMaxN.sigValueChanged.connect(self.slotMaxNChanged) self.dialog.ui.openingMinN.sigValueChanged.connect(self.slotMinNChanged)
def _qtg_plot_signal(G, signal, edges, vertex_size, limits, title): qtg, gl, QtGui = _import_qtg() if G.coords.shape[1] == 2: widget = qtg.GraphicsLayoutWidget() view = widget.addViewBox() elif G.coords.shape[1] == 3: if not QtGui.QApplication.instance(): QtGui.QApplication([]) # We want only one application. widget = gl.GLViewWidget() widget.opts['distance'] = 10 if edges: if G.coords.shape[1] == 2: adj = _get_coords(G, edge_list=True) pen = tuple(np.array(G.plotting['edge_color']) * 255) g = qtg.GraphItem(pos=G.coords, adj=adj, symbolBrush=None, symbolPen=None, pen=pen) view.addItem(g) elif G.coords.shape[1] == 3: x, y, z = _get_coords(G) pos = np.stack((x, y, z), axis=1) g = gl.GLLinePlotItem(pos=pos, mode='lines', color=G.plotting['edge_color']) widget.addItem(g) pos = [1, 8, 24, 40, 56, 64] color = np.array([[0, 0, 143, 255], [0, 0, 255, 255], [0, 255, 255, 255], [255, 255, 0, 255], [255, 0, 0, 255], [128, 0, 0, 255]]) cmap = qtg.ColorMap(pos, color) signal = 1 + 63 * (signal - limits[0]) / limits[1] - limits[0] if G.coords.shape[1] == 2: gp = qtg.ScatterPlotItem(G.coords[:, 0], G.coords[:, 1], size=vertex_size/10, brush=cmap.map(signal, 'qcolor')) view.addItem(gp) if G.coords.shape[1] == 3: gp = gl.GLScatterPlotItem(pos=G.coords, size=vertex_size/3, color=cmap.map(signal, 'float')) widget.addItem(gp) widget.setWindowTitle(title) widget.show() global _qtg_widgets _qtg_widgets.append(widget)
def initialize(self, Network_UI): if Network_UI.network['grammar_act', 0] is not None: self.buffertab = Network_UI.Next_Tab('Buffer') alphabet = Network_UI.network['grammar_act'][0].alphabet a_list = [alphabet[i] for i in range(len(alphabet))] a_list[0] = '_' ydict = dict(enumerate(a_list)) win = pg.GraphicsWindow() stringaxis = pg.AxisItem(orientation='left') stringaxis.setTicks([ydict.items()]) p = Network_UI.Add_plot(axisItems={'left': stringaxis}, x_label='buffer steps') self.graph = pg.GraphItem() # p=self.Add_plot('', True) p.addItem(self.graph) source = Network_UI.network['grammar_act'][0] RALN = Reconstruct_Analyze_Label_Network(Network_UI.network) groups = Network_UI.network[ 'prediction_source'] #Network_UI.exc_group_name # , network.NeuronGroups[1] def update(): RALN.label_and_group_neurons( Network_UI.network['prediction_source', 0], [ source.get_activation( char, Network_UI.network['prediction_source', 0]) for char in range(source.get_alphabet_length()) ], 'W', 20) _, self.edges = RALN.visualize_label_and_group_neurons( x_attribute_name='temporal_layer', y_attribute_name='class_label', weight_attribute_name='W', groups=groups, weight_limit=None, n_biggest=1, source=source, return_graph=True) # 1/3#None#1/3#0.5 self.nodes = RALN.get_neuron_positions( Network_UI.network['prediction_source', 0], x_attribute_name='temporal_layer', y_attribute_name='class_label', y_scale=0.0005) self.update_btn = QPushButton('update live buffers', Network_UI.main_window) self.update_btn.clicked.connect(update) Network_UI.Next_H_Block() Network_UI.Add_element(self.update_btn)
def setupPlot(self): self.parseData() self.lines = pg.GraphItem(pos=np.array([(0, 0)])) self.plot.addItem(self.lines) plt = self.plot.getPlotItem() plt.setXRange(0, 10) plt.setYRange(0, 10) plt.showGrid(False, False) plt.showAxis('left', False) plt.showAxis('bottom', False)
def get_no_visible_visual_item(self, start, end): """ Computes and returns the visual items to represents the groups of no visible elements :param start: index of the start elements on invisible region :param end: index of the end elements on invisible region :return: tuple of (list, list) with the visual elements for the group of no visible elements in the range [start, end] for oscilogram and spectrogram widgets respectively """ osc_items, spec_items = [], [] # viewRange of plotWidget [[xmin, xmax], [ymin, ymax]] x_max = self.axesOscilogram.viewRange()[0][1] start_position = self.get_element(start).indexTo if start > 0 else 0 end_position = self.get_element( end).indexFrom if end < len(self.elements) - 1 else x_max max_value = self.signal.maximumValue widget_scene_width, widget_pixel_width = self.axesOscilogram.viewRect( ).width(), self.axesOscilogram.width() * 1.0 # pixel_visible_text if (end_position - start_position) * widget_pixel_width / widget_scene_width > 30: text = u"(" + unicode(start + 1) + u"..." + unicode(end + 1) + u")" \ if end > start else u"(" + unicode(start + 1) + u")" text_item = pg.TextItem(text, color=(255, 255, 255), anchor=(0.5, 0.5)) text_item.setPos(start_position / 2.0 + end_position / 2.0, 0.75 * max_value) osc_items.append(text_item) graph_item = pg.GraphItem() # Define positions of nodes graph_pos = np.array([[start_position, max_value * 0.8], [start_position, max_value * 0.85], [end_position, max_value * 0.85], [end_position, max_value * 0.8]]) graph_adj = np.array([[0, 1], [1, 2], [2, 3]]) options = dict(size=1, symbol='d', pxMode=False, pen=self.NO_VISIBLE_ELEMENTS_PEN) graph_item.setData(pos=graph_pos, adj=graph_adj, **options) osc_items.append(graph_item) return osc_items, spec_items
def __init__(self, signal, indexFrom, indexTo, number=0): VisualElement.__init__(self, number=number, signal=signal,indexFrom=indexFrom, indexTo=indexTo) self.element_region = pg.GraphItem() self.element_region.mouseClickEvent = self.mouseClickEvent # Define positions of nodes self.element_region_pos = np.array([]) self.element_region_adj = np.array([[0, 1], [1, 2], [2, 3]]) self._update_items_pos() # update the visual representation self.visual_figures.append(self.element_region) # item visibility
def plot(self, nodeSize=1): """Plot the graph with pyqtgraph. @nodeSize is the dimension of nodes in the plot""" if not self.plotting: self.plotting = True #Create new plot pg.setConfigOptions(antialias=True) self.w = pg.GraphicsWindow() #Create a window self.w.setWindowTitle('Graph plot') self.v = self.w.addViewBox() self.v.setAspectLocked() self.g = pg.GraphItem() self.v.addItem(self.g) #Update plot N = len(self.vertList) #number of vertices positions = np.zeros((N, 2)) edges = [] weights = [] colors = [] borderColors = [] for i, node in enumerate(self.vertList.values()): positions[i] = node.position new_edges = [[i, j] for j in node.getConnections()] edges.extend(new_edges) weights.extend(node.getWeights()) colors.append(node.color) if node.isolated: borderColors.append(pg.mkPen(color=(0, 0, 255), width=5)) #Blue border else: borderColors.append(pg.mkPen(color=(255, 255, 255), width=5)) #White border lines = plt.cm.rainbow(np.array(weights), bytes=True) self.g.setData(pos=positions, adj=np.array(edges, dtype=int), pen=lines, size=nodeSize, symbol=['o' for i in range(N)], symbolBrush=colors, symbolPen=borderColors, pxMode=False) #pen=lines #symbolSize=500,
def __init__(self, app, robot): super(GoalSelectionMaps, self).__init__() self.main_app = app self.resetWindow() self.setWindowTitle("Selection and control") layout = pg.GraphicsLayout() self.setCentralItem(layout) view = layout.addViewBox(row=0,col=0,colspan=1) self.plot1 = pg.ImageItem(border='w',lut=self.lut) view.addItem(self.plot1) view.setAspectLocked(lock=True, ratio=1) view = layout.addViewBox(row=0,col=1,colspan=1) self.plot3 = pg.ImageItem(border='w',lut=self.lut) view.addItem(self.plot3) view.setAspectLocked(lock=True, ratio=1) view = layout.addViewBox(row=0,col=2,colspan=1) self.plot4 = pg.ImageItem(border='w',lut=self.lut) self.plot6 = pg.ScatterPlotItem() view.addItem(self.plot4) view.addItem(self.plot6) view.setAspectLocked(lock=True, ratio=1) self.plot5view = layout.addViewBox(row=0,col=3, colspan=2) self.plot5 = pg.GraphItem() self.plot5view.addItem(self.plot5) self.plot2 = layout.addPlot(row=2,col=0, rowspan=3, colspan=5) view = layout.addViewBox(row=4,col=2) self.robot = robot self.curves = [] for g in range(self.robot.gs.N_ECHO_UNITS): r = np.random.rand()*255 g = np.random.rand()*255 b = np.random.rand()*255 self.curves.append(self.plot2.plot(pen=(r,g,b))) self.ts_duration = 1
def display_grid(self, data=None): [height, width] = np.shape(data) pos = [] adj = [] # vertical lines x = self.grid_size index = 0 while (x <= width): one_edge = [x, 0] other_edge = [x, height] pos.append(one_edge) pos.append(other_edge) adj.append([index, index + 1]) x += self.grid_size index += 2 # horizontal lines y = self.grid_size while (y <= height): one_edge = [0, y] other_edge = [width, y] pos.append(one_edge) pos.append(other_edge) adj.append([index, index + 1]) y += self.grid_size index += 2 pos = np.array(pos) adj = np.array(adj) line_color = (0, 255, 0, 255, 0.5) lines = np.array([line_color for n in np.arange(len(pos))], dtype=[('red', np.ubyte), ('green', np.ubyte), ('blue', np.ubyte), ('alpha', np.ubyte), ('width', float)]) # remove old line_view if self.ui.line_view: self.ui.image_view.removeItem(self.ui.line_view) line_view = pg.GraphItem() self.ui.image_view.addItem(line_view) line_view.setData(pos=pos, adj=adj, pen=lines, symbol=None, pxMode=False) self.ui.line_view = line_view
def __init__(self, lc=None, parent=None, name=None): super(NetDiagVisWidget, self).__init__(parent) self.lc = lc if name: self.setObjectName(name) self.plot = pg.PlotWidget(title="Network Health") self.plot.hideAxis("left") self.plot.hideAxis("bottom") self.viewBox = self.plot.getViewBox() self.graph = pg.GraphItem() self.viewBox.addItem(self.graph) self.viewBox.setMouseEnabled(x=False, y=False) self.node_to_ind_map = {} self.ind_to_node_list = [] self.next_ind = 0 self.node_pos = np.zeros((0, 2)) self.node_vel = np.zeros((0, 2)) self.color_type = [('red', np.ubyte), ('green', np.ubyte), ('blue', np.ubyte), ('alpha', np.ubyte), ('width', float)] self.AdjacencyInfo = namedtuple( 'AdjacencyInfo', ('color_type', 'est_rtt', 'est_drop_rate')) self.adjacency_info_map = {} self.adjacency_labels = {} self.node_labels = {} vBoxLayout = QtGui.QVBoxLayout() vBoxLayout.addWidget(self.plot) self.setLayout(vBoxLayout) nethealth_sub = self.lc.subscribe("_NSUM", self.handle_net_health_t) self.lastUpdateTime = time.time() self.update_mutex = Lock() self.timer = QtCore.QTimer() self.timer.timeout.connect(self.update) self.timer.start(50)
def __init__(self, toes, *args, **kwargs): super(rasterPlot, self).__init__(*args, **kwargs) # if not isinstance(toes, list) or toes.ndim > 1: # raise ValueError('Event times must be given as ndarray of dimension 2 or less') n_toes = sum(len(t) for t in toes) pos = np.zeros((n_toes * 2, 2)) #array of vertex positions k = 0 for trial_idx, trial_toes in enumerate(toes): pos[k:k + len(trial_toes) * 2, 0] = trial_toes.repeat(2) pos[k:k + len(trial_toes) * 2:2, 1] = 1 + trial_idx - .5 pos[k + 1:k + len(trial_toes) * 2:2, 1] = 1 + trial_idx + .5 k += len(trial_toes) * 2 adj = np.arange(n_toes * 2).reshape(n_toes, 2) #connections of graph self.graph_item = pg.GraphItem(pos=pos, adj=adj, size=0) self.addItem(self.graph_item) self.setMouseEnabled(y=False)
def __init__(self): QDialog.__init__(self) layout = QGridLayout() self.setWindowTitle("openDAQ") impbutton = QPushButton("Import log") showgraphbtn = QPushButton("show graphs") clsbutton = QPushButton("Close") self.tbwidget = QTableWidget() self.tbwidget.setMinimumHeight(100) self.tbwidget.setMinimumSize(400, 400) ScaleUpbtn = QPushButton("Zoom in") ScaleDownbtn = QPushButton("Zoom Out") self.FullScreen = QPushButton("Full screen") #This is what I want but will not work.... self.scene = QGraphicsScene() self.view = QGraphicsView() self.view.setMouseTracking(True) self.view.setScene(self.scene) self.graphItem = pg.GraphItem() self.scene.addItem(self.graphItem) self.view.setMinimumSize(400, 400) layout.addWidget(self.view, 0, 0) layout.addWidget(self.tbwidget, 0, 1) layout.addWidget(clsbutton, 1, 0) layout.addWidget(impbutton, 2, 0) layout.addWidget(showgraphbtn, 1, 1) layout.addWidget(ScaleUpbtn, 3, 0) layout.addWidget(ScaleDownbtn, 3, 1) layout.addWidget(self.FullScreen, 2, 1) self.setLayout(layout) clsbutton.clicked.connect(self.close) impbutton.clicked.connect(self.import_data) showgraphbtn.clicked.connect(self.OpenCharts) ScaleUpbtn.clicked.connect(self.ScaleViewUp) ScaleDownbtn.clicked.connect(self.ScaleViewDown) self.FullScreen.clicked.connect(self.fullscreen) self.ViewScale = 1 self.view.scale(self.ViewScale, self.ViewScale)
def circle_center_changed(self): if self.ui.sector_full_circle.isChecked(): if self.sector_g: self.ui.image_view.removeItem(self.sector_g) return x0 = float(self.ui.circle_x.text()) y0 = float(self.ui.circle_y.text()) from_angle = np.float(str(self.ui.sector_from_value.text())) to_angle = np.float(str(self.ui.sector_to_value.text())) self.calculate_corners_angles() self.update_angle_label_position() [y1, x1] = self.calculate_sector_xy_position(angle=from_angle, x0=x0, y0=y0) [y2, x2] = self.calculate_sector_xy_position(angle=to_angle, x0=x0, y0=y0) pos = np.array([[x0, y0], [x1, y1], [x2, y2]]) adj = np.array([[0, 1], [1, 2], [2, 0]]) symbols = ['+', 'o', 'o'] lines = np.array([(255, 0, 0, 255, 2), (255, 0, 0, 0, 1), (255, 0, 0, 255, 2)], dtype=[('red', np.ubyte), ('green', np.ubyte), ('blue', np.ubyte), ('alpha', np.ubyte), ('width', float)]) if self.sector_g: self.ui.image_view.removeItem(self.sector_g) self.sector_g = pg.GraphItem() self.ui.image_view.addItem(self.sector_g) self.sector_g.setData(pos=pos, adj=adj, pen=lines, size=1, symbol=symbols, pxMode=False)
def update_binning_bins(self): ''' this method takes from the parent file the information necessary to display the selection with bins in the binning window ''' pos = self.parent.binning_line_view['pos'] adj = self.parent.binning_line_view['adj'] lines = self.parent.binning_line_view['pen'] line_view_binning = pg.GraphItem() self.parent.binning_line_view['image_view'].addItem(line_view_binning) line_view = line_view_binning line_view.setData(pos=pos, adj=adj, pen=lines, symbol=None, pxMode=False) self.parent.binning_line_view['ui'] = line_view
def ceate_tab_pointcloud(self): # Create tab_pointcloud tab = QtGui.QTabWidget() self.addTab(tab, "point cloud") layout = QtGui.QGridLayout() tab.setLayout(layout) gv = pg.GraphicsView() layout.addWidget(gv, 0, 0, 1, 5) # Create a viewBox for 2D image self.vb = pg.ViewBox() self.vb.setAspectLocked() gv.setCentralItem(self.vb) #Create ImageItem for map button_play = QtGui.QPushButton('Graph optimization') button_play.setFixedWidth(180) button_play.clicked.connect(self.handleButton_play) button_next = QtGui.QPushButton('Next') button_next.setFixedWidth(110) button_next.clicked.connect(self.handleButton_next) layout.addWidget(button_play, 2, 0) #layout.addWidget(button_next, 2, 1) self.pcd = pg.ScatterPlotItem(size=3, pen=pg.mkPen(None), brush=pg.mkBrush(255, 255, 255, 120)) self.vb.addItem(self.pcd) self.cur_scan = pg.ScatterPlotItem(pen = pg.mkPen(None), brush = pg.mkBrush("g"), size =5, antialias = False) self.vb.addItem(self.cur_scan) self.robot = RobotItem('b') #no robot show #self.robot.setParentItem(self.pcd) self.robot.scale(0.03,0.03) self.graph = pg.GraphItem(size=10, symbol="o", symbolPen="w", symbolBrush="y") self.vb.addItem(self.graph)
def __init__(self, color=None, tooltip="", connect_points=False, point_figure='+', points_size=20): """ :param color: the color for the lines :param tooltip: an optional tooltip to show :return: """ SpectralVisualItemWrapper.__init__(self, color=color, tooltip=tooltip) # time limits self.indexFrom = 0 self.indexTo = 0 self.points_size = points_size self.point_figure = point_figure # 'o' circle, ‘s’ square, ‘t’ triangle, ‘d’ diamond, ‘+’ plus if point_figure not in ['o', 's', 't', 'd', '+']: self.point_figure = "+" # the freq value self.peak_freq_value = 0 self.connect_points = connect_points # a line for peak freq point_positions_list = [[self.indexFrom, self.peak_freq_value]] if connect_points: point_positions_list.append([self.indexTo, self.peak_freq_value]) self.peak_freq_pos = np.array(point_positions_list) self.peak_freq_adj = np.array([[0, 1]]) self.peak_freq_region = pg.GraphItem() self.peak_freq_region.setToolTip(self.tooltip)
def topology_map_build(self): """ Topology map build :return: Widget with topology map """ graphics_widget = pg.GraphicsLayout() view = graphics_widget.addViewBox(col=0, row=0) view.setAspectLocked(True) graph_item = pg.GraphItem() view.addItem(graph_item) l_pen = pg.mkPen(color='w', width=1) graph_item.setPen(l_pen) label_item = graphics_widget.addLabel(text="Epoch number 0", col=0, row=1) return graphics_widget, graph_item, label_item
def Add_Raster_Channel(self): # totalNumber = self.dock_area.findAll() # print(totalNumber) # dock_index = len(totalNumber[0]) # if len(totalNumber[0]) is 0: # dock_index = 1 self.raster_counter = self.raster_counter + 1 raster_dock = Dock( "Raster " + str(self.raster_counter) ) #Figure out how to show the current index of raster raster_layout = pg.LayoutWidget() combo2 = QtGui.QComboBox() for ch_id in range(NCHANNELS): combo2.addItem("{}".format(ch_id + 1)) raster_layout.addWidget(combo2) raster_item = pg.GraphItem(symbolPen=self.mypens[0], symbolBrush=self.mybrush, symbol='s') raster_plot = pg.PlotWidget(name="RASTER") raster_plot.setLimits(xMin=0, xMax=1, yMin=0, yMax=1, minXRange=1.0, maxXRange=1.0, minYRange=1.0, maxYRange=1.0) raster_plot.addItem(raster_item) raster_layout.addWidget(raster_plot) raster_dock.addWidget(raster_layout) self.my_rasters.append(raster_item) self.dock_area3.addDock(raster_dock, position='bottom') self.raster_buffer.append(np.empty((1, ))) self.get_dock_info()