def __init__(self): self.app=QtGui.QApplication(sys.argv) self.window = opengl.GLViewWidget() self.window.setGeometry(0,410,800,800) self.window.setCameraPosition(distance=12,azimuth=270) x_axis=opengl.GLGridItem() x_axis.setSize(x=10,y=10) #y_axis=opengl.GLGridItem() #y_axis.rotate(90,0,1,0) #self.window.addItem(y_axis) self.grid=Cell() self.q=Qlearning(no_of_actions,no_of_states,state_combinations) self.window.addItem(x_axis) self.current_node=self.grid.grid_nodes[0] self.nodes=opengl.GLScatterPlotItem(pos=self.grid.grid_nodes,color=glColor((0,255,0)),size=7) self.goal=opengl.GLScatterPlotItem(pos=self.grid.goal_node,color=glColor((0,0,255)),size=15) self.current_node_item=opengl.GLScatterPlotItem(pos=self.current_node,color=glColor((255,0,0)),size=9) self.blocked=opengl.GLScatterPlotItem(pos=self.grid.blocked_nodes,color=glColor((255,255,255)),size=13) self.counter=0 self.generation_counter=0 self.step_counter=0 self.tracker=[] self.window.addItem(self.nodes) self.window.addItem(self.blocked) self.window.addItem(self.current_node_item) self.window.addItem(self.goal) self.window.show()
def render_image(image, metadata=None, feature=None, alpha=1, feature_size=4): pg.mkQApp() view = gl.GLViewWidget() view.show() if isinstance(metadata, type(None)): metadata = {'voxel_size_x': 1, 'voxel_size_y': 1, 'voxel_size_z': 1} image_positions = index2position(image, metadata) view.opts['center'] = QVector3D(image_positions.T[0].flatten().max() / 2, image_positions.T[1].flatten().max() / 2, image_positions.T[2].flatten().max() / 2) # rotation centre of the camera view.opts['distance'] = image_positions.flatten().max( ) * 2 # distance of the camera respect to the center image_color = np.zeros([len(image_positions), 4]) + np.array( [0.1, 0.1, 1, alpha]) point_image = gl.GLScatterPlotItem(pos=image_positions, color=image_color, pxMode=False) view.addItem(point_image) if not isinstance(feature, type(None)): feature = feature.T feature = np.array([ feature[0] * metadata['voxel_size_x'], feature[1] * metadata['voxel_size_y'], feature[2] * metadata['voxel_size_z'] ]) feature_size = np.ones(feature.shape[1]) * feature_size feature_color = np.zeros([feature.shape[1], 1]) + np.array( [1, 0, 0, 1]) point_feature = gl.GLScatterPlotItem(pos=feature.T, color=feature_color, size=feature_size) view.addItem(point_feature) if (sys.flags.interactive != 1) or not hasattr(QtCore, 'PYQT_VERSION'): QtGui.QApplication.instance().exec_()
def initialize(self, agents): start_color = np.array([0.0, 1.0, 0.0, 1.0]).reshape((1, 4)) end_color = np.array([1.0, 0.0, 0.0, 1.0]).reshape((1, 4)) for agent in agents: start = np.array([ agent.sy - self.map.rows // 2, agent.sx - self.map.cols // 2, self.map.grid[agent.sy][agent.sx] ]).reshape((1, 3)) agent_symbol = gl.GLScatterPlotItem(pos=start, color=start_color, size=20) self.agents[agent.num] = agent_symbol self.w.addItem(agent_symbol) end = np.array([ agent.fy - self.map.rows // 2, agent.fx - self.map.cols // 2, self.map.grid[agent.fy][agent.fx] ]).reshape((1, 3)) goal = gl.GLScatterPlotItem(pos=end, color=end_color, size=20) self.w.addItem(goal) self.app.processEvents()
def plotDetectedPointsGraph(data): if not hasattr(plotDetectedPointsGraph,"sp"): plotDetectedPointsGraph.sp = [None, None] # keep 2 copies plotDetectedPointsGraph.spIndex = 0; global widgetDetectedPoints if widgetDetectedPoints == None: widgetDetectedPoints = gl.GLViewWidget() widgetDetectedPoints.opts['distance'] = 20 # distance of camera from center widgetDetectedPoints.opts['fov'] = 60 # horizontal field of view in degrees widgetDetectedPoints.opts['azimuth'] = -75 # camera's azimuthal angle in degrees, 仰俯角 widgetDetectedPoints.opts['elevation'] = 30 # camera's angle of elevation in degrees, 方位角 widgetDetectedPoints.setGeometry(100, 100, 800, 800) widgetDetectedPoints.show() widgetDetectedPoints.setWindowTitle('Detected Points') gridX = gl.GLGridItem() gridX.rotate(0, 0, 1, 0) gridX.translate(0, 0, 0) widgetDetectedPoints.addItem(gridX) # center dot pos = np.array([0.0, 0.0, 0.0]) size = np.array([0.2]) color = np.array([1.0, 0.0, 0.0, 0.5]) center = gl.GLScatterPlotItem(pos=pos, size=size, color=color, pxMode=False) widgetDetectedPoints.addItem(center) # axis axis = gl.GLAxisItem(antialias=True, glOptions='translucent') axis.setSize(x=10, y=10, z=10) widgetDetectedPoints.addItem(axis) if data["type"] == MMWDEMO_OUTPUT_MSG_DETECTED_POINTS and len(data["x"]) > 0: x = data["x"] y = data["y"] z = data["z"] v = data["velocity"] s = data["snr"] n = data["noise"] pos = np.empty((len(data["x"]), 3)) size = np.empty(len(data["x"])) color = np.empty((len(data["x"]), 4)) for i in range(len(x)): pos[i] = (x[i], y[i], z[i]) size[i] = s[i] / 2000 if v[i]>= 0: color[i] = (0.0, v[i], 0.0, 1.0) #color (r,g,b,a) else: color[i] = (-v[i], 0.0, 0.0, 1.0) #color (r,g,b,a) sp1 = gl.GLScatterPlotItem(pos=pos, size=size, color=color, pxMode=False) #sp1.translate(0, 0, 0) if plotDetectedPointsGraph.sp[plotDetectedPointsGraph.spIndex] != None: sp2 = plotDetectedPointsGraph.sp[plotDetectedPointsGraph.spIndex] widgetDetectedPoints.removeItem(sp2) plotDetectedPointsGraph.sp[plotDetectedPointsGraph.spIndex] = sp1 widgetDetectedPoints.addItem(sp1) plotDetectedPointsGraph.spIndex = (plotDetectedPointsGraph.spIndex + 1) % len(plotDetectedPointsGraph.sp)
def __init__(self, N, clusters): self.clusters = clusters self.w = gl.GLViewWidget() self.w.opts['distance'] = 100 self.w.setWindowTitle('RGB space') self.w.setGeometry(100, 100, 500, 500) self.w.show() # create the background grids gx = gl.GLGridItem() gx.rotate(90, 0, 1, 0) gx.translate(0, 10, 10) self.w.addItem(gx) gy = gl.GLGridItem() gy.rotate(90, 1, 0, 0) gy.translate(10, 0, 10) self.w.addItem(gy) gz = gl.GLGridItem() gz.translate(10, 10, 0) self.w.addItem(gz) self.curve1 = gl.GLLinePlotItem() self.curve2 = gl.GLLinePlotItem() self.curve3 = gl.GLLinePlotItem() self.w.addItem(self.curve1) self.w.addItem(self.curve2) self.w.addItem(self.curve3) self.pca = decomposition.PCA(n_components=3) self.centers = [None for _ in range(clusters)] for i in range(clusters): pts = np.array([0, 0, 0]) / 14 self.centers[i] = gl.GLScatterPlotItem(pos=pts, color=pg.glColor( 0, 0, 255, 255)) self.w.addItem(self.centers[i]) self.cyl = [] for i in range(clusters): CYL = gl.MeshData.cylinder(rows=10, cols=20, radius=[1., 1.0], length=5.) self.cyl.append( gl.GLMeshItem(meshdata=CYL, smooth=True, drawEdges=True, edgeColor=(1, 0, 0, 0.1), shader='balloon')) self.cyl[-1].setGLOptions('additive') self.w.addItem(self.cyl[-1]) self.traces = dict() for i in range(N): pts = np.array([0, 0, 0]) / 14 self.traces[i] = gl.GLScatterPlotItem(pos=pts, color=pg.glColor( 100, 100, 100, 100)) self.w.addItem(self.traces[i])
def __init__(self): visual_multiplier = [10, 200 / 120, 5 / 1400] # Get the directory for the data data_dir = dirname(realpath(__file__)) + r"\data\regular" data_file_name = [ "#full_data_path.npy", "#acc_data_path.npy", "break_data_path.npy", "#coast_data_path.npy", ] # Initiate the data array full_data = np.empty((3,)) # iterating through all files and adding them to a huge array for filename in os.listdir(data_dir): if filename not in data_file_name: continue filepath = data_dir + sep + filename # Loading data data = np.load(filepath) full_data = np.vstack((full_data, data)) pos_data_mask = full_data[:, 0] >= 0 self.pos_data = full_data[pos_data_mask] neg_data_mask = full_data[:, 0] < 0 self.neg_data = full_data[neg_data_mask] # PyQtGraph stuff self.app = QtGui.QApplication(sys.argv) self.w = gl.GLViewWidget() self.w.opts["distance"] = 40 self.w.setWindowTitle("RL Throttle Visualized") self.w.setGeometry(0, 30, 1920, 1080) self.w.show() # Adding a grid gz = gl.GLGridItem(QtGui.QVector3D(20, 10, 1)) gz.translate(0, 5, 0) self.w.addItem(gz) gz = gl.GLGridItem(QtGui.QVector3D(10, 20, 1)) gz.rotate(90, 0, 1, 0) gz.rotate(90, 0, 0, 1) gz.translate(0, 0, 0) self.w.addItem(gz) # Create the scatter plot blue_color = [0.1, 0.5, 1, 0.9] self.pos_data[:, 0] = self.pos_data[:, 0] * visual_multiplier[0] self.pos_data[:, 1] = self.pos_data[:, 1] * visual_multiplier[1] self.pos_data[:, 2] = self.pos_data[:, 2] * visual_multiplier[2] scatter = gl.GLScatterPlotItem(pos=self.pos_data, size=1, color=blue_color) self.w.addItem(scatter) red_color = [1, 0.3, 0.05, 0.9] self.neg_data[:, 0] = self.neg_data[:, 0] * visual_multiplier[0] self.neg_data[:, 1] = self.neg_data[:, 1] * visual_multiplier[1] self.neg_data[:, 2] = self.neg_data[:, 2] * visual_multiplier[2] scatter = gl.GLScatterPlotItem(pos=self.neg_data, size=1, color=red_color) self.w.addItem(scatter)
def calibrate(self): # read file and run calibration algorithm (self.acc_offset, self.acc_scale) = cal_lib.calibrate_from_file(acc_file_name) (self.magn_offset, self.magn_scale) = cal_lib.calibrate_from_file(magn_file_name) # map floats into integers self.acc_offset = map(int, self.acc_offset) self.magn_offset = map(int, self.magn_offset) # show calibrated tab self.tabWidget.setCurrentIndex(1) #populate acc calibration output on gui self.calRes_acc_OSx.setText(str(self.acc_offset[0])) self.calRes_acc_OSy.setText(str(self.acc_offset[1])) self.calRes_acc_OSz.setText(str(self.acc_offset[2])) self.calRes_acc_SCx.setText(str(self.acc_scale[0])) self.calRes_acc_SCy.setText(str(self.acc_scale[1])) self.calRes_acc_SCz.setText(str(self.acc_scale[2])) #populate acc calibration output on gui self.calRes_magn_OSx.setText(str(self.magn_offset[0])) self.calRes_magn_OSy.setText(str(self.magn_offset[1])) self.calRes_magn_OSz.setText(str(self.magn_offset[2])) self.calRes_magn_SCx.setText(str(self.magn_scale[0])) self.calRes_magn_SCy.setText(str(self.magn_scale[1])) self.calRes_magn_SCz.setText(str(self.magn_scale[2])) # compute calibrated data self.acc_cal_data = cal_lib.compute_calibrate_data(self.acc_data, self.acc_offset, self.acc_scale) self.magn_cal_data = cal_lib.compute_calibrate_data(self.magn_data, self.magn_offset, self.magn_scale) # populate 2D graphs with calibrated data self.accXY_cal.plot(x = self.acc_cal_data[0], y = self.acc_cal_data[1], clear = True, pen='r') self.accYZ_cal.plot(x = self.acc_cal_data[1], y = self.acc_cal_data[2], clear = True, pen='g') self.accZX_cal.plot(x = self.acc_cal_data[2], y = self.acc_cal_data[0], clear = True, pen='b') self.magnXY_cal.plot(x = self.magn_cal_data[0], y = self.magn_cal_data[1], clear = True, pen='r') self.magnYZ_cal.plot(x = self.magn_cal_data[1], y = self.magn_cal_data[2], clear = True, pen='g') self.magnZX_cal.plot(x = self.magn_cal_data[2], y = self.magn_cal_data[0], clear = True, pen='b') # populate 3D graphs with calibrated data acc3D_cal_data = np.array(self.acc_cal_data).transpose() magn3D_cal_data = np.array(self.magn_cal_data).transpose() sp = gl.GLScatterPlotItem(pos=acc3D_cal_data, color = (1, 1, 1, 1), size=2) self.acc3D_cal.addItem(sp) sp = gl.GLScatterPlotItem(pos=magn3D_cal_data, color = (1, 1, 1, 1), size=2) self.magn3D_cal.addItem(sp) #enable calibration buttons to activate calibration storing functions self.saveCalibrationHeaderButton.setEnabled(True) self.saveCalibrationHeaderButton.clicked.connect(self.save_calibration_header)
def drawDetector(self, meta): _len_x = meta.len_x() _len_y = meta.len_y() _len_z = meta.len_z() self._dims = [_len_x, _len_y, _len_z] # # Draw a cylinder for the detector: cylinderPoints = gl.MeshData.cylinder( 2, 10, radius=[1.5 * meta.radius(), 1.5 * meta.radius()], length=meta.len_z()) cylinder = gl.GLMeshItem(meshdata=cylinderPoints, drawEdges=True, drawFaces=False, smooth=False, glOptions='translucent') # cylinder.translate(0,0,-_len_z*0.5) self.addItem(cylinder) # Draw locations of all sipms and PMTs # Using points to draw pmts and sipms, since a scatter plot is # easy and cheap to draw pmt_data = meta.pmt_data() n_pmts = len(pmt_data.index) _pmt_pts = np.ndarray((n_pmts, 3)) _pmt_pts[:, 0] = pmt_data.X _pmt_pts[:, 1] = pmt_data.Y _pmt_pts[:, 2] = meta.max_z() pmtPointsCollection = gl.GLScatterPlotItem(pos=_pmt_pts, size=20.32, color=[0, 0, 1.0, 1.0], pxMode=False) self.addItem(pmtPointsCollection) _sipm_pts = np.ndarray((len(meta.sipm_data().index), 3)) _sipm_pts[:, 0] = meta.sipm_data().X _sipm_pts[:, 1] = meta.sipm_data().Y _sipm_pts[:, 2] = meta.min_z() sipmPointsCollection = gl.GLScatterPlotItem(pos=_sipm_pts, size=2, color=[0, 1.0, 1.0, 1.0], pxMode=False) self.addItem(sipmPointsCollection) self.setCenter((0, 0, 0.5 * _len_z))
def run(self, data): # check dimensionality of data. add zeros if needed if data.shape[1] < 3: # determine number of zeros to be added missing_dims = 3 - data.shape[1] for d in data: if self.data is None: self.data = np.array([np.append(d, missing_dims * [0])]) else: self.data = np.vstack((self.data, np.append(d, missing_dims * [0]))) else: # store data reference self.data = data # store data dimensionality self.data_dim = data.shape[1] # prepare network self.prepare() # skip viz if not needed if not self.viz: return # number of datapoints n = data.shape[0] # create color and size arrays color = np.array(n * [[1, 0, 0, 0.7]]) size = np.array(n * [0.02]) # plot data distribution self.dist_plot = gl.GLScatterPlotItem(pos=self.data, size=size, color=color, pxMode=False) self.w.addItem(self.dist_plot) # plot nodes self.node_plot = gl.GLScatterPlotItem(pos=self.node_positions, size=self.node_sizes, color=self.node_colors, pxMode=False) self.w.addItem(self.node_plot) # plot network self.draw() # start timer, therefore training self.t.start(self.freq) # run QT App QtGui.QApplication.instance().exec_()
def init_cloud(self): w = gl.GLViewWidget(self) w.opts['pos'] = 1 gx = gl.GLGridItem() self.cloudPlot = gl.GLScatterPlotItem(pos=np.zeros(3), color=np.zeros((1, 3)), size=1, pxMode=True) self.camPlot = gl.GLScatterPlotItem(pos=np.zeros(3), color=np.array([0, 0, 0]), size=1, pxMode=True) w.addItem(self.cloudPlot) w.addItem(self.camPlot) return w
def initialize_plot(self): self.Time = np.array([]) self.X = np.array([]) self.Y = np.array([]) self.Z = np.array([]) self.Zmax = 10 self.Zmin = 0 self.opts['distance'] = 20 self.show() self.axes = gl.GLAxisItem(size=None, antialias=True, glOptions='translucent') self.axes.translate(0, 0, 0) self.addItem(self.axes) self.initialize_grid() #Inital scatter plot pos = np.empty((1, 3)) size = np.empty((1)) color = np.empty((1, 4)) pos[0] = (0, 0, 0) size[0] = 0.0 color[0] = (1.0, 0.0, 0.0, 0.5) self.scatter_plot = gl.GLScatterPlotItem(pos=pos, size=size, color=color, pxMode=False) self.addItem(self.scatter_plot) #Initial marker pos2 = np.empty((1, 3)) size2 = np.empty((1)) color2 = np.empty((1, 4)) pos2[0] = (0, 0, 0) size2[0] = self.size_marker color2[0] = (1.0, 1.0, 1.0, 1.0) self.marker = gl.GLScatterPlotItem(pos=pos2, size=size2, color=color2, pxMode=False) self.addItem(self.marker) self.reset_view()
def drawObjects(self, view_manager): geom = view_manager._geometry view = view_manager.getView() spts = self._process.getData() color = [128, 128, 128, 128] # Make a collection to add the points to: points = np.ndarray((spts.size(), 3)) for i in xrange(len(spts)): thisPoint = spts[i] points[i][0] = thisPoint.X() points[i][1] = thisPoint.Y() points[i][2] = thisPoint.Z() glPointsCollection = gl.GLScatterPlotItem(pos=points, size=5, color=color) view.addItem(glPointsCollection) self._drawnObjects.append(glPointsCollection)
def showMultipleOrbits(self): self.finished = False self.orbitPlot.clear() firstPass = True for orbit, params in self.currentOrbits.items(): if firstPass: # Create the celestial body radius = np.linalg.norm([0, params.body.radius, 0]) md = gl.MeshData.sphere(rows=200, cols=300, radius=radius) m1 = gl.GLMeshItem(meshdata=md,smooth=True,color=params.body.qtColor,shader="balloon",glOptions="additive") self.orbitPlot.plot.addItem(m1) firstPass = False rs = params.getRadiusArray() # Plot the initial point initialPoint = gl.GLScatterPlotItem(pos=np.array([rs[0,0], rs[0,1], rs[0,2]]), size=np.array([13]), color=(1,0,0,1.5)) self.orbitPlot.plot.addItem(initialPoint) # Plot the trajectory orbit1 = np.array([rs[:,0], rs[:,1], rs[:,2]]).transpose() orbit = gl.GLLinePlotItem(pos=orbit1, color=params.color, antialias=True) self.orbitPlot.plot.addItem(orbit) # Adjust the plot self.orbitPlot.plot.setCameraPosition(distance=params.body.radius*10) self.orbitPlot.zgrid.scale(np.max(orbit1),np.max(orbit1),np.max(orbit1)) self.orbitPlot.scaleAxis(params.body.radius*2) self.orbitPlot.createAxis()
def __init__(self): super(PositionGraph, self).__init__() self.setWindowTitle('Anser Position') self.setBackgroundColor('w') anser_mesh = mesh.Mesh.from_file( utils.resource_path('./app/resources/cad/mesh.stl')) anser_mesh = gl.MeshData(vertexes=anser_mesh.vectors) m = gl.GLMeshItem(meshdata=anser_mesh, shader='shaded', color=(0, 1, 0, 0.1)) m.rotate(135, 0, 0, 1) m.translate(240, 0, -240) m.scale(1, 1, 1) self.addItem(m) gx = gl.GLGridItem() gx.setSize(7, 7, 7) gx.scale(45, 45, 45) gx.rotate(45, 0, 0, 1) #self.addItem(gx) self.pos = np.empty((MAX_NUM_OF_SENSORS, 3)) self.color = np.empty((MAX_NUM_OF_SENSORS, 4)) size = np.empty(MAX_NUM_OF_SENSORS) for i in range(MAX_NUM_OF_SENSORS): self.pos[i] = (0, 0, 0) self.color[i] = (0, 0.0, 0.0, 0.0) size[i] = 6 self.sp1 = gl.GLScatterPlotItem(pos=self.pos, size=size, color=self.color[0], pxMode=True) self.sp1.setGLOptions('translucent') self.addItem(self.sp1) self.setCameraPosition(100, 800, 30) self.sp1.rotate(135, 0, 0, 1)
def plot3d(self, dim = "z", point_size=1, cmap='Spectral_r', max_points=5e5, n_bin=8, plot_trees=False): """ Plots the three dimensional point cloud using a `Qt` backend. By default, if the point cloud exceeds 5e5 \ points, then it is downsampled using a uniform random distribution. This is for performance purposes. :param point_size: The size of the rendered points. :param dim: The dimension upon which to color (i.e. "z", "intensity", etc.) :param cmap: The matplotlib color map used to color the height distribution. :param max_points: The maximum number of points to render. """ from pyqtgraph.Qt import QtCore, QtGui import pyqtgraph as pg import pyqtgraph.opengl as gl # Randomly sample down if too large if dim == 'user_data' and plot_trees: dim = 'random_id' self._set_discrete_color(n_bin, self.data.points['user_data']) cmap = self._discrete_cmap(n_bin, base_cmap=cmap) if self.data.count > max_points: sample_mask = np.random.randint(self.data.count, size = int(max_points)) coordinates = np.stack([self.data.points.x, self.data.points.y, self.data.points.z], axis = 1)[sample_mask,:] color_dim = np.copy(self.data.points[dim].iloc[sample_mask].values) print("Too many points, down sampling for 3d plot performance.") else: coordinates = np.stack([self.data.points.x, self.data.points.y, self.data.points.z], axis = 1) color_dim = np.copy(self.data.points[dim].values) # If dim is user data (probably TREE ID or some such thing) then we want a discrete colormap if dim != 'random_id': color_dim = (color_dim - np.min(color_dim)) / (np.max(color_dim) - np.min(color_dim)) cmap = cm.get_cmap(cmap) colors = cmap(color_dim) else: colors = cmap(color_dim) # Start Qt app and widget pg.mkQApp() view = gl.GLViewWidget() # Create the points, change to opaque, set size to 1 points = gl.GLScatterPlotItem(pos = coordinates, color = colors) points.setGLOptions('opaque') points.setData(size = np.repeat(point_size, len(coordinates))) # Add points to the viewer view.addItem(points) # Center on the arithmetic mean of the point cloud and display center = np.mean(coordinates, axis = 0) view.opts['center'] = pg.Vector(center[0], center[1], center[2]) # Very ad-hoc view.opts['distance'] = (self.data.max[0] - self.data.min[0]) * 1.2 #return(view.opts) view.show()
def plotInit(self): # self.getLimitData() # Get ECT cap array data self.getData() # Load default image filter configuraiton self.default_config() # Set color normalization method (self.values_norm, self.color_values_norm) = self.image_filter.color_normalizer( value=self.epsilon_sensing_domain, cmap=self.cmap, base_opacity=self.base_opacity, norm_method=self.norm_method, gamma=self.gamma, initial=True, coordinates=self.fem.sensing_domain_coordinates) # Set opacity filter self.image_filter.opacity_filter( opacity_filter=self.opacity_filter, opacity_param=self.opacity_param, values=self.epsilon_sensing_domain, values_norm=self.values_norm, color_values_norm=self.color_values_norm, coordinates=self.fem.sensing_domain_coordinates) # Create openGL scatter plot and add self.item_dof = gl.GLScatterPlotItem( pos=self.fem.sensing_domain_coordinates, color=self.color_values_norm, size=0.001 * self.unit_scale, pxMode=False) self.item_dof.setGLOptions('additive') self.gl_widget.addItem(self.item_dof) # Add tracker self.trackerInit()
def show_droppoint(self, curve_list): colors = np.zeros((2, 2, 3), dtype=float) colors[..., 0] = 0 colors[..., 2] = 1 colors[..., 1] = 1 self.clear_point() for curve in curve_list: ret = curve.calc_droppoint() if ret is not None: x, y = ret ''' x = int(x) y = int(y) z = np.ones((2,2)) x1 = np.linspace(x-5, x+5, 2) y1 = np.linspace(y-5, y+5, 2) l = gl.GLSurfacePlotItem(x1, y1, z=z, colors=colors.reshape(2*2,3), shader='shaded', smooth=False) ''' pos = np.empty((1, 3)) size = np.empty((1)) color = np.empty((1, 4)) pos[0] = (x, y, 0) size[0] = 10 color[0] = (0., 1., 0., .5) l = gl.GLScatterPlotItem(pos=pos, size=size, color=color, pxMode=False) self.point_item_list.append(l) self.w.addItem(l)
def drawEvent(self): self.colorize() ## 3D Viewport if self.plot3DView is None: self.plot3DView = gl.GLScatterPlotItem( pos=self.parameters["posArray"], color=self.colorArray, size=self.parameters["plWeights"], pxMode=False) else: self.plot3DView.pos = self.parameters["posArray"] self.plot3DView.color = self.colorArray self.plot3DView.size = self.parameters["plWeights"] self.plot3DView.update() ## 2D Viewport self.plotFlatMap.setPosition(self.parameters["posArray"]) self.plotFlatMap.setColor(self.colorArray) self.plotFlatMap.setWeights(self.parameters["plWeights"]) self.plotFlatMap.update() if self.parameters['colorMask'] == 'charge': variable = self.parameters["charge"] else: variable = self.parameters["time"] self.figCanvas.setData(variable) ## Tracking if self.parameters["trackingEnabled"]: self.plotTracks.pos = self.parameters["trackPosition"] self.plotTracks.color = self.parameters["trackColors"] self.plotTracks.update()
def processData(self, xyzData, energy, pos, begin, end): self.xyzData[begin:end] = xyzData[begin:end] self.energy[begin:end] = energy[begin:end] self.pos[begin:end] = pos[begin:end] self.num += 1 print(self.num, "/", self.numThreads) self.progress.setValue(self.num) # self.show() if self.num == self.numThreads: energy = [float(i) for i in self.energy] # This is for python3 compatibility minEnergy = min(energy) maxEnergy = max(energy) # self.normEnergy = map(lambda x:(x - minEnergy)/(maxEnergy - minEnergy), energy) # self.progress.close() self.normEnergy = divide( subtract(energy, minEnergy), subtract(maxEnergy, minEnergy)) self.color = hot(self.normEnergy) maxPos = self.pos[self.previousDataSize - 1] self.xMaxPos = int(maxPos[0]) self.yMaxPos = int(maxPos[1]) self.zMaxPos = int(maxPos[2]) # self.xPlaneLabel.setText("X-Plane: Max %i" % self.xMaxPos) # self.yPlaneLabel.setText("Y-Plane: Max %i" % self.yMaxPos) # self.zPlaneLabel.setText("Z-Plane: Max %i" % self.zMaxPos) self.plot = gl.GLScatterPlotItem( pos=self.pos, size=self.size, color=self.color, pxMode=False) self.plotWidget.addItem(self.plot) self.plotAlreadyThere = True
def __init__(self, path): super(LBViewer,self).__init__() print('PATH PATH PATH',path) self.frametimer = clock() self.input_recorder = InputRecorder() self.cycle = 'Cycle' self.cycle_means = 0 self.framerate = 30 self.lovebug = LoveBug(input_recorder=self.input_recorder, fullShell=False, framerate=self.framerate, path=('../' if len(path) == 1 else path[1])) self.showlist = ['Hearts','Mandel','Triangles','Rainbow Galaxy','Rainbow Molecule','Rainbow Glow','Fire Glow','Yellow Glow', 'Purple Glow','Snow','Water','Rainbow Animals','Fireworks','Flowers','Sunrise','Fire','Bigger Fire', 'Fast Rainbow','Pineapples','Bananas','Reactive Spots'] self.numCycle = 18 self.lightshow = self.showlist[0] #set default light show self.init_ui() self.qt_connections() self.shell = gl.GLScatterPlotItem(pos = self.lovebug.get3DPoints(), size = 20.0, pxMode = False) self.shell.setGLOptions('additive') self.view.addItem(self.shell) self.t = QtCore.QTimer() self.t.timeout.connect(self.update) self.t.start(1)
def render_label(labels, metadata=None, alpha=0.01): """ labels.shape: (x_size, y_size, z_size) """ if isinstance(metadata, type(None)): metadata = {'voxel_size_x': 1, 'voxel_size_y': 1, 'voxel_size_z': 1} pg.mkQApp() view = gl.GLViewWidget() view.show() label_positions = index2position(labels, metadata) view.opts['center'] = QVector3D(label_positions.T[0].flatten().max() / 2, label_positions.T[1].flatten().max() / 2, label_positions.T[2].flatten().max() / 2) # rotation centre of the camera view.opts['distance'] = label_positions.flatten().max( ) * 2 # distance of the camera respect to the center label_color = np.array(label_to_rgba(labels, alpha)) point_label = gl.GLScatterPlotItem(pos=label_positions, color=label_color, pxMode=False) view.addItem(point_label) if (sys.flags.interactive != 1) or not hasattr(QtCore, 'PYQT_VERSION'): QtGui.QApplication.instance().exec_()
def create_3d_cams(view): cam_coords = np.array([c['coord_m'] for c in CAPTURES]) cam_plot = gl.GLScatterPlotItem(pos=cam_coords, color=(1.0, 0.0, 0.0, 1.0), size=20, pxMode=True) view.addItem(cam_plot)
def add_marker(self, pos, color, size=0.1): points = np.array([pos]) p = gl.GLScatterPlotItem(pos=points, color=np.array(color), size=size, pxMode=False) self.glview.addItem(p)
def create_3d_side(view): side_plot = gl.GLScatterPlotItem(pos=np.array([]), color=(0.0, 0.5, 1.0, 1.0), size=5, pxMode=True) view.addItem(side_plot) return side_plot
def visualize_3d(): #app = QtGui.QApplication([]) w = gl.GLViewWidget() w.show() g = gl.GLGridItem() w.addItem(g) df = pd.read_csv('positions_d.txt') df = df[df.columns[0:3]].values / 5 cmap = plt.get_cmap('cool') colors = [] for i in range(df.shape[0]): normal_num = i / df.shape[0] colors.append(cmap(normal_num)) colors = np.array(colors) indexesFinal = np.array([[1, 2]]) sp2 = gl.GLScatterPlotItem(pos=df, size=0.1, pxMode=False, color=colors) w.addItem(sp2) sp2 = gl.GLLinePlotItem(pos=df, width=0.5) w.addItem(sp2) ## Start Qt event loop unless running in interactive mode. if __name__ == '__main__': import sys if (sys.flags.interactive != 1) or not hasattr(QtCore, PYQT_VERSION): QtGui.QApplication.instance().exec_()
def start_graph(): print("Setting up graph") global app, graph_region, w, g, d3, t app = QtGui.QApplication([]) w = gl.GLViewWidget() w.resize(800, 600) w.opts['distance'] = 20 w.show() w.setWindowTitle('LIDAR Point Cloud') g = gl.GLGridItem() #g.translate(0,0,-10) w.addItem(g) #pos3 = np.zeros((100, 100, 3)) #pos3[:, :, :2] = np.mgrid[:100, :100].transpose(1, 2, 0) * [-0.1, 0.1] #pos3 = pos3.reshape(10000, 3) #d3 = (pos3 ** 2).sum(axis=1) ** 0.5 graph_region = gl.GLScatterPlotItem(pos=np.zeros((1, 3), dtype=np.float32), color=(0, 1, 0, 0.5), size=0.1, pxMode=False) #graph_region.rotate(180, 1, 0, 0) #graph_region.translate(0, 0, 2.4) w.addItem(graph_region) t = QtCore.QTimer() t.timeout.connect(update_graph) t.start(50) QtGui.QApplication.instance().exec_() global RUNNING RUNNING = False print("\n[STOP]\tGraph Window closed. Stopping...")
def create_3d_volume(view): volume_plot = gl.GLScatterPlotItem(pos=np.array([]), color=(0.0, 1.0, 0.0, 1.0), size=10, pxMode=True) view.addItem(volume_plot) return volume_plot
def __init__(self, data_shape=1024, color=(1.0, 0.0, 0.0, 1.0), start_angle=-3 * np.pi / 4., stop_angle=3 * np.pi / 4., widget=None): if not widget: self.app = QtGui.QApplication([]) self.widget = gl.GLViewWidget() self.widget.opts['distance'] = 40 self.widget.show() else: self.widget = widget self.axis = gl.GLAxisItem() self.axis.translate(0, 0, 1) self.widget.addItem(self.axis) self.gz = gl.GLGridItem() self.widget.addItem(self.gz) radius = np.ones((data_shape)) * 5 self.start_angle = start_angle self.stop_angle = stop_angle self.angle = np.linspace(self.start_angle, self.stop_angle, data_shape) x = np.sin(self.angle) * radius y = np.cos(self.angle) * radius z = np.ones((data_shape)) pts = np.vstack([x, y, z]).transpose() # self.line_plot = gl.GLLinePlotItem(pos=pts, color=np.array(color * data_shape).reshape((data_shape, 3))) self.line_plot = gl.GLScatterPlotItem( pos=pts, color=np.array(color * data_shape).reshape((data_shape, 4)), size=3.0) self.widget.addItem(self.line_plot)
def make_points(xyzs, point_colours, sizes, pxMode = True): """ This function returns points Item that can be viz by pyqtgraph. Parameters ---------- xyzs : ndarray of shape(Nvertices,3) ndarray of shape(Nvertices,3) of the line. point_colour : ndarray of shape(4), optional array of colours specifying the colours of the line, if a single tuple is given all points assumes that colour. sizes : float, optional list of floats of points sizes, if single val is given all point assumes that size pxMode: bool, option if True size is measured in pixels, if False size is based on units of the xyzs Returns ------- points : point object point for visualisation. """ points = gl.GLScatterPlotItem(pos=xyzs, color=point_colours, size=sizes, pxMode = pxMode) return points
def __init__(self): self.app = QtGui.QApplication([]) self.view = gl.GLViewWidget() self.view.opts['distance'] = 10 self.view.show() self.view.setWindowTitle("Points Visualizer") grid = gl.GLGridItem(size=QtGui.QVector3D(10, 10, 1)) grid.setSpacing(0.5, 0.5, 0.5) self.view.addItem(grid) axis = GLRGBAxisItem(size=QtGui.QVector3D(0.5, 0.5, 0.5)) self.view.addItem(axis) self.gtFrustum = GLFrustumItem(frustumColor=(0.8, 0, 0, 0.6), size=QtGui.QVector3D(0.5, 0.5, 0.5)) self.view.addItem(self.gtFrustum) self.gtLine = gl.GLLinePlotItem(color=(0.8, 0, 0, 0.6)) self.view.addItem(self.gtLine) self.gtPositions = [] self.estimatedFrustum = GLFrustumItem(frustumColor=(1, 1, 1, 0.6), size=QtGui.QVector3D( 0.5, 0.5, 0.5)) self.view.addItem(self.estimatedFrustum) self.estimatedLine = gl.GLLinePlotItem(color=(1, 1, 1, 0.6)) self.view.addItem(self.estimatedLine) self.estimatedPositions = [] self.points = gl.GLScatterPlotItem(color=(0, 0.8, 0, 1), size=3.0) self.points.setData(pos=np.zeros((1, 3))) self.view.addItem(self.points)