def __init__(self): super(mctrack3D, self).__init__() self._productName = 'mctrack3D' self._process = evd.DrawMCTrack3D() self.init() self._mesh = gl.MeshData()
# Qt Setup app = QtGui.QApplication([]) w = gl.GLViewWidget() w.show() w.setWindowTitle('pyqtgraph example: GLIsosurface') w.setCameraPosition(azimuth=0, distance=30) g = gl.GLGridItem() g.scale(0.5, 0.5, 1) w.addItem(g) # Plot a the wavefunction isosurface verts, faces = pg.isosurface(prob, prob.max() / level) md = gl.MeshData(vertexes=verts, faces=faces) colors = np.ones((md.faceCount(), 4), dtype=float) colors[:, 3] = 0.2 colors[:, 2] = np.linspace(1, 1, 1) md.setFaceColors(colors) m1 = gl.GLMeshItem(meshdata=md, smooth=True, shader='balloon') m1.setGLOptions('additive') w.addItem(m1) m1.translate(-L / (2 * dx), -L / (2 * dx), -L / (2 * dx)) #Plot the potential sphere verts, faces = pg.isosurface(V, V.max()) md = gl.MeshData(vertexes=verts, faces=faces) colors = np.ones((md.faceCount(), 4), dtype=float) colors[:, 3] = 0.2
print(mask_diastole.shape) # Create an PyQT4 application object. app = QtGui.QApplication(sys.argv) # Create a window object. window = gl.GLViewWidget() window.resize(500, 500) window.setCameraPosition(distance=100) window.setWindowTitle('pyqtgraph : GLIsosurface') window.show() # uniform_filter() is equivalent to smooth3() in matlab. mask_diastole = scipy.ndimage.uniform_filter(mask_diastole, [5, 5, 20], mode='nearest') # Using marching cubes algorithm to get a polygonal mesh of an isosurface verts, faces = measure.marching_cubes(mask_diastole, 0.1) meshdata = gl.MeshData(vertexes=verts, faces=faces) mesh = gl.GLMeshItem(meshdata=meshdata, smooth=True, color=(1.0, 0.0, 0.0, 0.2), shader='balloon', glOptions='additive') # Translation [avgX, avgY, avgZ] = map(np.mean, zip(*verts)) mesh.translate(-avgX, -avgY, -avgZ) window.addItem(mesh) sys.exit(app.exec_()) plt.show() sys.exit()
def SiPM_QT(self,position,phi,name,photons,max_photons,id=False, show_photons=True, MU_LIN=True, TH=0, color2=[0,0,0]): s = np.array(self.sipm,dtype=float) p = np.array([[s[0]/2,s[1]/2,s[2]/2], [s[0]/2,s[1]/2,-s[2]/2], [-s[0]/2,s[1]/2,s[2]/2], [-s[0]/2,s[1]/2,-s[2]/2], [s[0]/2,-s[1]/2,s[2]/2], [s[0]/2,-s[1]/2,-s[2]/2], [-s[0]/2,-s[1]/2,s[2]/2], [-s[0]/2,-s[1]/2,-s[2]/2]]) p=self.rot_cyl(p,phi) position3d = np.array([position for i in range(p.shape[0])]) p = p + position3d #plt = gl.GLScatterPlotItem(pos=p, color=pg.glColor('w'),size=1) MU=25 if (max_photons == 0): color = 0 else: if MU_LIN==True: color = int(np.log(1+MU*photons/max_photons)/np.log(1+MU)*200.0) else: color = int(photons/max_photons*200) rgb=np.array([0.75*color+55,color+55,0.25*color+55]) color = pg.glColor(*rgb) color2 = pg.glColor(*(np.array(color2))) meshdata = gl.MeshData(vertexes=p, faces=np.array([ [0,1,4], [5,4,1], [2,0,6], [4,6,0], [0,2,3], [1,0,3], [6,2,3], [7,3,6], [7,3,5], [1,3,5]]), faceColors=np.array([ color, color, color2, color2, color2, color2, color, color, color2, color2])) plt = gl.GLMeshItem(meshdata=meshdata, color = None, edgeColor=pg.glColor('w'), drawEdges=False, smooth=False, drawFaces=True, #shader= 'shaded',#'balloon',#None, #'shaded', glOptions='opaque', computeNormals='False') #plt.setGLOptions('additive') self.w.addItem(plt) if (id==True): #and (int(name)==3512 or int(name)==1000 or int(name)==3511)): t = GLTextItem( X=position[0], Y=position[1], Z=position[2], text=str(int(name)),size=8,color=np.array([255,0,0])) t.setGLViewWidget(self.w) self.w.addItem(t) text_color = (np.array([rgb[0],255,255])-rgb)*0.75 text_size = self.w.opts['distance'] if (show_photons==True and photons>TH) : t = GLTextItem( X=position[0], Y=position[1], Z=position[2], text=str(int(photons)),size=8, color=text_color) t.setGLViewWidget(self.w) self.w.addItem(t)
def create_mesh_data(self): return gl.MeshData(vertexes=self.verts, faces=self.faces)
def __init__(self, filename, filename_r): self.filename = filename self.flight = ReadData(self.filename) self.flight_data = self.flight.read_data(); self.app = QtGui.QApplication([]) self.win = QtGui.QMainWindow() self.area = DockArea() self.win.setCentralWidget(self.area) self.win.showMaximized() self.win.setWindowTitle('MPU Simulation') self.win.setGeometry(10, 25, 1920, 1024) #Reference Data self.filename_r = filename_r self.reference = ReadData(self.filename_r) self.reference_data = self.reference.read_data(); # Create docks, place them into the window one at a time. self.d_a = Dock("Animation", size=(500, 400)) self.d_n = Dock("North (Xn)", size=(500, 200)) self.d_e = Dock("East (Yn)", size=(500, 200)) self.d_h = Dock("Height (h)", size=(500, 200)) self.d_v = Dock("Velocity V", size=(500, 200)) self.d_u_ = Dock("Velocity u", size=(500, 200)) self.d_v_ = Dock("Velocity v", size=(500, 200)) self.d_w_ = Dock("Velocity w", size=(500, 200)) self.d_p = Dock("Velocity p", size=(500, 200)) self.d_q = Dock("Velocity q", size=(500, 200)) self.d_r = Dock("Velocity r", size=(500, 200)) self.d_phi = Dock("Roll", size=(500, 200)) self.d_theta = Dock("Pitch", size=(500,200)) self.d_psi = Dock("Yaw", size=(500,200)) self.d_w = Dock("Motors Rotation", size=(500, 200)) self.d_t = Dock("Motors Angle", size=(500,200)) self.d_deltae = Dock("Elevons", size=(500,200)) self.area.addDock(self.d_a, 'left') self.area.addDock(self.d_n, 'right') self.area.addDock(self.d_e, 'below', self.d_n) self.area.addDock(self.d_h, 'below', self.d_e) self.area.addDock(self.d_v, 'below', self.d_h) self.area.addDock(self.d_u_, 'below', self.d_v) self.area.addDock(self.d_v_, 'below', self.d_u_) self.area.addDock(self.d_w_, 'below', self.d_v_) self.area.addDock(self.d_phi, 'bottom', self.d_n) self.area.addDock(self.d_theta, 'below', self.d_phi) self.area.addDock(self.d_psi, 'below', self.d_theta) self.area.addDock(self.d_p, 'below', self.d_psi) self.area.addDock(self.d_q, 'below', self.d_p) self.area.addDock(self.d_r, 'below', self.d_q) self.area.addDock(self.d_w, 'bottom', self.d_phi) self.area.addDock(self.d_t, 'below', self.d_w) self.area.addDock(self.d_deltae, 'below', self.d_t) #Animation Window self.d_a.hideTitleBar() self.w = gl.GLViewWidget() self.zgrid = gl.GLGridItem() self.w.addItem(self.zgrid) self.w.setWindowTitle('Animation') self.w.setCameraPosition(distance=20, azimuth=90, elevation=60) self.x0 = self.flight_data[self.flight.i_north][0] self.y0 = -self.flight_data[self.flight.i_east][0] self.h0 = self.flight_data[self.flight.i_height][0] #Fuselage Model self.model_fus = Model("./obj_files/MPUFuselage.obj") self.md_fus = gl.MeshData(vertexes=self.model_fus.returnMesh()) self.fuselage = gl.GLMeshItem(meshdata=self.md_fus, color=(1, 1, 1, 1), smooth=False, shader='shaded', glOptions='opaque') self.d_a.addWidget(self.w) #Waypoint Model self.model_wayp = Model("./obj_files/wayp.obj") self.md_wayp = gl.MeshData(vertexes=self.model_wayp.returnMesh()) self.waypoint = gl.GLMeshItem(meshdata=self.md_wayp, color=(1, 1, 1, 1), smooth=False, shader='shaded', glOptions='opaque') self.d_a.addWidget(self.w) #Plots Setup #North Displacement self.w_n = pg.PlotWidget(title="North Displacement") self.w_n.setDownsampling(mode='peak') self.w_n.setClipToView(True) self.curve_x = self.w_n.plot() self.curve_x_r = self.w_n.plot() self.w_n.setLabel('bottom', 'Time', 's') self.w_n.setLabel('left', 'Xn', 'm') self.d_n.addWidget(self.w_n) #East Displacement self.w_e = pg.PlotWidget(title="East Displacement") self.w_e.setDownsampling(mode='peak') self.w_e.setClipToView(True) self.curve_y = self.w_e.plot() self.w_e.setLabel('bottom', 'Time', 's') self.w_e.setLabel('left', 'Yn', 'm') self.d_e.addWidget(self.w_e) #Height self.w_h = pg.PlotWidget(title="Height Displacement") self.w_h.setDownsampling(mode='peak') self.w_h.setClipToView(True) self.curve_h = self.w_h.plot() self.w_h.setLabel('bottom', 'Time', 's') self.w_h.setLabel('left', 'h', 'm') self.d_h.addWidget(self.w_h) #Velocity V self.w_v = pg.PlotWidget(title="Total Velocity") self.w_v.setDownsampling(mode='peak') self.w_v.setClipToView(True) self.curve_V = self.w_v.plot() self.w_v.setLabel('bottom', 'Time', 's') self.w_v.setLabel('left', 'V', 'm/s') self.d_v.addWidget(self.w_v) #Velocity u self.w_u_ = pg.PlotWidget(title="Velocity u") self.w_u_.setDownsampling(mode='peak') self.w_u_.setClipToView(True) self.curve_u_ = self.w_u_.plot() self.w_u_.setLabel('bottom', 'Time', 's') self.w_u_.setLabel('left', 'u', 'm/s') self.d_u_.addWidget(self.w_u_) #Velocity v self.w_v_ = pg.PlotWidget(title="Velocity v") self.w_v_.setDownsampling(mode='peak') self.w_v_.setClipToView(True) self.curve_v_ = self.w_v_.plot() self.w_v_.setLabel('bottom', 'Time', 's') self.w_v_.setLabel('left', 'v', 'm/s') self.d_v_.addWidget(self.w_v_) #Velocity w self.w_w_ = pg.PlotWidget(title="Velocity w") self.w_w_.setDownsampling(mode='peak') self.w_w_.setClipToView(True) self.curve_w_ = self.w_w_.plot() self.w_w_.setLabel('bottom', 'Time', 's') self.w_w_.setLabel('left', 'w', 'm/s') self.d_w_.addWidget(self.w_w_) #Velocity p self.w_p = pg.PlotWidget(title="Rotational Velocity p") self.w_p.setDownsampling(mode='peak') self.w_p.setClipToView(True) self.curve_p = self.w_p.plot() self.w_p.setLabel('bottom', 'Time', 's') self.w_p.setLabel('left', 'p', 'rad/s') self.d_p.addWidget(self.w_p) #Velocity q self.w_q = pg.PlotWidget(title="Rotational Velocity q") self.w_q.setDownsampling(mode='peak') self.w_q.setClipToView(True) self.curve_q = self.w_q.plot() self.w_q.setLabel('bottom', 'Time', 's') self.w_q.setLabel('left', 'q', 'rad/s') self.d_q.addWidget(self.w_q) #Velocity q self.w_r = pg.PlotWidget(title="Rotational Velocity r") self.w_r.setDownsampling(mode='peak') self.w_r.setClipToView(True) self.curve_r = self.w_r.plot() self.w_r.setLabel('bottom', 'Time', 's') self.w_r.setLabel('left', 'r', 'rad/s') self.d_r.addWidget(self.w_r) #Roll self.w_phi = pg.PlotWidget(title="Roll Angle") self.w_phi.setDownsampling(mode='peak') self.w_phi.setClipToView(True) self.curve_phi = self.w_phi.plot() self.w_phi.setLabel('bottom', 'Time', 's') self.w_phi.setLabel('left', 'Roll Anlge', 'rad') self.d_phi.addWidget(self.w_phi) #Pitch self.w_theta = pg.PlotWidget(title="Pitch Angle") self.w_theta.setDownsampling(mode='peak') self.w_theta.setClipToView(True) self.curve_theta = self.w_theta.plot() self.w_theta.setLabel('bottom', 'Time', 's') self.w_theta.setLabel('left', 'Pitch Angle', 'rad') self.d_theta.addWidget(self.w_theta) #Yaw self.w_psi = pg.PlotWidget(title="Yaw Angle") self.w_psi.setDownsampling(mode='peak') self.w_psi.setClipToView(True) self.curve_psi = self.w_psi.plot() self.w_psi.setLabel('bottom', 'Time', 's') self.w_psi.setLabel('left', 'Yaw Angle', 'rad') self.d_psi.addWidget(self.w_psi) #Motors Rotation self.w_w = pg.PlotWidget(title="Motors Rotational Velocity") self.w_w.setDownsampling(mode='peak') self.w_w.setClipToView(True) self.curve_wl = self.w_w.plot(pen = (255,0,0)) self.curve_wr = self.w_w.plot(pen = (0,255,0)) self.curve_wb = self.w_w.plot(pen = (0,0,255)) self.w_w.setLabel('bottom', 'Time', 's') self.w_w.setLabel('left', 'Rotational Velocity', 'rpm') self.w_w.addLegend() self.l_w = self.w_w.plotItem.legend self.l_w.addItem(self.curve_wl, "Left Motor") self.l_w.addItem(self.curve_wr, "Right Motor") self.l_w.addItem(self.curve_wb, "Rear Motor") self.d_w.addWidget(self.w_w) #Motors Angle self.w_t = pg.PlotWidget(title="Motors Angle") self.w_t.setDownsampling(mode='peak') self.w_t.setClipToView(True) self.curve_tl = self.w_t.plot(pen = (255,0,0)) self.curve_tr = self.w_t.plot(pen = (0,255,0)) self.w_t.setLabel('bottom', 'Time', 's') self.w_t.setLabel('left', 'Motors Angle', 'deg') self.d_t.addWidget(self.w_t) self.w_t.addLegend() self.l_t = self.w_t.plotItem.legend self.l_t.addItem(self.curve_tl, "Left Motor") self.l_t.addItem(self.curve_tr, "Right Motor") self.d_t.addWidget(self.w_t) #Elevons Angle self.w_deltae = pg.PlotWidget(title="Elevons Angle") self.w_deltae.setDownsampling(mode='peak') self.w_deltae.setClipToView(True) self.curve_deltael = self.w_deltae.plot(pen = (255,0,0)) self.curve_deltaer = self.w_deltae.plot(pen = (0,255,0)) self.w_deltae.setLabel('bottom', 'Time', 's') self.w_deltae.setLabel('left', 'Elevons Angle', 'deg') self.d_deltae.addWidget(self.w_deltae) self.w_deltae.addLegend() self.l_deltae = self.w_deltae.plotItem.legend self.l_deltae.addItem(self.curve_deltael, "Left Elevon") self.l_deltae.addItem(self.curve_deltaer, "Right Elevon") self.d_deltae.addWidget(self.w_deltae) #Data Animation self.pts = np.vstack([self.flight_data[self.flight.i_north], -self.flight_data[self.flight.i_east], self.flight_data[self.flight.i_height]]).transpose() self.plt = gl.GLLinePlotItem(pos=self.pts, color=pg.glColor(('b')), width=1, antialias=True) self.w.addItem(self.plt) #Reference self.pts_r = np.stack([self.reference_data[self.reference.i_north_r], -self.reference_data[self.reference.i_east_r], self.reference_data[self.reference.i_height_r]]).transpose() self.plt_r = gl.GLLinePlotItem(pos=self.pts_r, color=pg.glColor(('r')), width=1, antialias=True) # print(self.pts_r[0]) self.w.addItem(self.plt_r) #Add Geometry self.w.addItem(self.fuselage) self.w.addItem(self.waypoint) self.ti_in = 0
def show(self): """ Generate an display widget based on the plot settings and display it. ---- Example: ``app1 = qg.QApplication(sys.argv)`` ``plot1 = Plot(mesh1)`` ``plot1.show()`` ``app1.processEvents()`` ``app1.exec_()`` ---- :return: None """ mesh_data = pgo.MeshData(vertexes=self.mesh.verts, faces=self.mesh.tris, vertexColors=self.mesh.colors, faceColors=None) mesh_item = pgo.GLMeshItem(meshdata=mesh_data, shader='balloon', drawEdges=self.drawEdges, edgeColor=self.edgeColor, smooth=False, computeNormals=False, glOptions='translucent') # mesh_item = pgo.GLMeshItem(meshdata = mesh_data, shader='shaded', drawEdges=False, smooth=True, computeNormals = True, glOptions='opaque') widget = pgo.GLViewWidget() widget.setBackgroundColor('w') widget.addItem(mesh_item) if self.grids: # Add grids gx = pgo.GLGridItem() gx.setSize(x=50, y=50, z=50) gx.rotate(90, 0, 1, 0) gx.translate(-0.5, 24.5, 24.5) widget.addItem(gx) gy = pgo.GLGridItem() gy.setSize(x=50, y=50, z=50) gy.rotate(90, 1, 0, 0) gy.translate(24.5, -0.5, 24.5) widget.addItem(gy) gz = pgo.GLGridItem() gz.setSize(x=50, y=50, z=50) gz.translate(24.5, 24.5, -0.5) widget.addItem(gz) # Add axes ptsx = np.array([[-0.5, -0.5, -0.5], [50, -0.5, -0.5]]) pltx = pgo.GLLinePlotItem(pos=ptsx, color=(1, 0, 0, 1), width=1, antialias=True) widget.addItem(pltx) ptsy = np.array([[-0.5, -0.5, -0.5], [-0.5, 50, -0.5]]) plty = pgo.GLLinePlotItem(pos=ptsy, color=(0, 1, 0, 1), width=1, antialias=True) widget.addItem(plty) ptsz = np.array([[-0.5, -0.5, -0.5], [-0.5, -0.5, 50]]) pltz = pgo.GLLinePlotItem(pos=ptsz, color=(0, 0, 1, 1), width=1, antialias=True) widget.addItem(pltz) # Set plot options widget.opts['center'] = qg.QVector3D(((self.mesh.model.shape[0]/self.mesh.res)/2)+self.pos[0], ((self.mesh.model.shape[1]/self.mesh.res)/2)+self.pos[1], ((self.mesh.model.shape[2]/self.mesh.res)/2)+self.pos[2]) widget.opts['elevation'] = self.angle[0] widget.opts['azimuth'] = self.angle[1] widget.opts['distance'] = self.angle[2] widget.resize(self.res[0], self.res[1]) # Show plot widget.setWindowTitle(str(self.name)) widget.show() self.widget = widget
#ax = gl.GLAxisItem() #ax.setSize(5,5,5) #w.addItem(ax) # compute isosurface for positive and negative isovalues isovals = [+0.2 * data.max(), -0.2 * data.max()] colors = [(1, 0.2, 0.2), (0.2, 0.2, 1)] for isoval, color in zip(isovals, colors): # compute vertices and faces and center around origin verts, faces = pg.isosurface(data, isoval) verts[:, 0] = verts[:, 0] - nx / 2 verts[:, 1] = verts[:, 1] - ny / 2 verts[:, 2] = verts[:, 2] - nz / 2 isosurface = gl.MeshData(vertexes=verts, faces=faces) rgbt = np.zeros((isosurface.faceCount(), 4), dtype=float) for c in range(3): rgbt[:, c] = color[c] rgbt[:, 3] = 1 # transparency (I guess) isosurface.setFaceColors(rgbt) p = gl.GLMeshItem( meshdata=isosurface, smooth=True, shader='edgeHilight' ) # shader options: 'balloon', 'shaded', 'normalColor', 'edgeHilight' p.setGLOptions( 'translucent') # choose between 'opaque', 'translucent' or 'additive' w.addItem(p) # add hemisphere for a given kinetic energy E_kin = 35.0
d3.hideTitleBar() w = gl.GLViewWidget() #w.setBackgroundColor('b') w.show() w.setWindowTitle('Visualizacion del Quadrotor') w.setCameraPosition(distance=8, azimuth=-45, elevation=30) g = gl.GLGridItem() g.scale(3, 3, 1) w.addItem(g) h0 = 0 model = Model("ardrone1.obj") md = gl.MeshData(vertexes=model.returnMesh()) quadr = gl.GLMeshItem(meshdata=md, color=(0.7, 0.7, 1, 1), smooth=False, shader='shaded', glOptions='opaque') quadr.translate(0, 0, h0) arriba = False ardrone = quad() ts = ardrone.ts clog = Control_log(ts)
# TODO label sensor by nearest aparc name # on EEG cap and MEG helmet, avg pos and vtx norm to get sensor positions and normals eegpo = sens_xyz_ori(vc * eeg_scl, fc, vcl) megpo = sens_xyz_ori(vc * meg_scl, fc, vcl) # write sensor files for OpenMEEG np.savetxt(eeg_fname, eegpo[:3]) np.savetxt(meg_fname, megpo) # visualize results if plot: from pyqtgraph import mkQApp app = mkQApp() import pyqtgraph.opengl as gl gvw = gl.GLViewWidget() hs = gl.GLMeshItem(meshdata=gl.MeshData(vl, fl, vertexColors=xyz2rgb(vl)), drawEdges=True) cap = gl.GLMeshItem(meshdata=gl.MeshData(vc*eeg_scl, fc), color=(0, 0, 1.0, 1.0), drawEdges=True) hc = np.c_[np.random.rand(n_sens, 3), np.ones((n_sens, 1))][vcl] helmet = gl.GLMeshItem(meshdata=gl.MeshData(vc*meg_scl, fc, vertexColors=hc), #color=(1, 0, 0.0, 1.0), drawEdges=True) lh = gl.GLMeshItem(meshdata=gl.MeshData(*read_geometry(ctx)), drawEdges=True, drawFaces=False) for item in [hs, cap, helmet, lh]: gvw.addItem(item) for po in (megpo, eegpo): gvw.addItem(gl.GLScatterPlotItem(pos=po[:, :3], size=7)) gvw.addItem(gl.GLScatterPlotItem(pos=po[:, :3] + 8*po[:, 3:], size=4, color=(1, 0, 0, 1))) gvw.show() gvw.readQImage().save('head_sensors.png') app.exec_()
#wireplane_volumes=[('volTPCPlane_PV0x7f868ac5ef50',add_wireplane_surface)], acrylic_detect=True, acrylic_wls=False, read_bvh_cache=True, cache_dir="./../uboone/uboone_cache", dump_node_info=False) sim = Simulation(geom, geant4_processes=0, nthreads_per_block=nthreads_per_block, max_blocks=max_blocks) geom.mesh.vertices geom.mesh.triangles # ============================================ # DRAWING DATA detector_meshdata = gl.MeshData(vertexes=geom.mesh.vertices, faces=geom.mesh.triangles) detector_meshitem = gl.GLMeshItem(meshdata=detector_meshdata, drawFaces=False, drawEdges=True) detector_meshitem.rotate(90, 1, 0, 0) w.addItem(detector_meshitem) detector_angle = 0.0 new_data = [1] nphotons = 10 photon_end_pos = np.zeros((nphotons, 3), dtype=np.float) photon_colors = np.zeros((nphotons, 4), dtype=np.float) pos_plot = gl.GLScatterPlotItem(pos=photon_end_pos, color=photon_colors, size=2.0, pxMode=True)
from matplotlib import cm from matplotlib import colors as mcolors data_path = sample.data_path() filename_inv = data_path + '/MEG/sample/sample_audvis-meg-oct-6-meg-inv.fif' inverse_operator = read_inverse_operator(filename_inv) left_hemi, right_hemi = inverse_operator['src'] vertexes = np.r_[left_hemi['rr'], right_hemi['rr']] lh_vertex_cnt = left_hemi['rr'].shape[0] faces = np.r_[left_hemi['use_tris'], lh_vertex_cnt + right_hemi['use_tris']] submesh_verrtex_idx = np.unique(faces) vertex_idx = np.r_[left_hemi['vertno'], lh_vertex_cnt + right_hemi['vertno']] vertex_cnt = vertex_idx.shape[0] cortex_mesh_data = gl.MeshData(vertexes=vertexes, faces=faces) cortex_mesh_data.setVertexColors(np.ones((vertexes.shape[0], 4))) app = QtGui.QApplication([]) widget = gl.GLViewWidget() widget.show() widget.setWindowTitle('My first pyqtgraph brain mesh') # The largest brain dimension max_dim = max(np.ptp(vertexes, axis=0)) widget.setCameraPosition(distance=2 * max_dim) grid = gl.GLGridItem() grid.scale(2, 2, 1) widget.addItem(grid) # m1 = gl.GLMeshItem(vertexes=vertices, faces=faces,
def init_ui(self): self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) self.setMinimumSize(250, 250) layout = QGridLayout() layout.setContentsMargins(0, 0, 0, 0) self.setLayout(layout) positions = np.vstack([self.x_points, self.y_points, self.z_points]).transpose() self.view = GLViewWidgetFix.GLViewWidgetFix() self.view.setBackgroundColor(119, 181, 254) self.view.setCameraPosition(distance=1950, elevation=90, azimuth=0) self.plot = opengl.GLLinePlotItem(pos=positions, color=[1, 0, 0, 1], width=3) self.plot.setGLOptions("opaque") self.view.addItem(self.plot) # self.grid = opengl.GLGridItem(color="white") # self.grid.setSize(x=(self.lon_max-self.lon_min)*self.meters_per_lon, # y=(self.lat_max-self.lat_min)*self.meters_per_lat) # self.grid.setSpacing(x=100, y=100) # self.view.addItem(self.grid) self.image_file = Image.open(self.image_name) self.image = opengl.GLImageItem(np.asarray(self.image_file)) self.view.addItem(self.image) self.image.scale((self.lat_max - self.lat_min) * self.meters_per_lat / self.image_file.size[1], (self.lon_max - self.lon_min) * self.meters_per_lon / self.image_file.size[0], 1) self.image.translate( -(self.lat_max - self.lat_min) * self.meters_per_lat / 2, -(self.lon_max - self.lon_min) * self.meters_per_lon / 2, 0) flat_earth = opengl.GLMeshItem(meshdata=opengl.MeshData.cylinder( 1, 64, [6371000, 0], 0), color=[84 / 255, 89 / 255, 72 / 255, 1], smooth=True) flat_earth.translate(0, 0, -10000) flat_earth.setGLOptions("opaque") self.view.addItem(flat_earth) crosshair_mesh = mesh.Mesh.from_file("DisplayModels/Crosshairs.stl") crosshair_mesh_data = opengl.MeshData(vertexes=crosshair_mesh.vectors) self.crosshair = opengl.GLMeshItem(meshdata=crosshair_mesh_data, color=[1, 0, 0, 1]) self.set_crosshair_pos(0, 0, 0) self.view.addItem(self.crosshair) self.view_btn = QPushButton("2D") self.view_btn.clicked.connect(self.switch_3d) self.view_btn.setMaximumWidth(30) self.coords_label = QLineEdit("0,0") self.coords_label.setAlignment(Qt.AlignCenter) self.coords_label.setReadOnly(True) self.clear_btn = QPushButton("CLR") self.clear_btn.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed) self.clear_btn.setToolTip("Clear Data") self.clear_btn.setFixedWidth(35) self.clear_btn.setParent(self.view) self.clear_btn.clicked.connect(self.clear_plot) self.sats_label = QLineEdit("0") self.sats_label.setAlignment(Qt.AlignCenter) self.sats_label.setReadOnly(True) self.sats_label.setToolTip("Number of Satellites") self.sats_label.setMaximumWidth(50) layout.addWidget(self.view, 0, 0, 1, 4) layout.addWidget(self.clear_btn, 1, 3) layout.addWidget(self.view_btn, 1, 0) layout.addWidget(self.coords_label, 1, 1) layout.addWidget(self.sats_label, 1, 2)
# reduce to 30000 triangles: points_dec, triangles_dec = decimate_surface(points, triangles, n_triangles=30000) from mayavi import mlab # noqa head_col = (0.95, 0.83, 0.83) # light pink p, t = points_dec, triangles_dec w = gl.GLViewWidget() w.setGeometry(0, 0, 1000, 1000) w.setWindowTitle('Terrain') w.setCameraPosition(distance=50, elevation=8) # s = gl.GLScatterPlotItem(pos=p) mesh_data = gl.MeshData(p, t) mesh_item = gl.GLMeshItem(meshdata=mesh_data, computeNormals=True, shader='viewNormalColor', glOptions='translucent') # mesh_item.translate(i*0.2, j*0.3, 0) mesh_item.setColor([0, 0, 1, 0.6]) # s.setData(=p) w.addItem(mesh_item) w.show() # mlab.triangular_mesh(p[:, 0], p[:, 1], p[:, 2], t, color=head_col) # mlab.showif __name__ == '__main__': if __name__ == '__main__': QtGui.QApplication.instance().exec_()()
def init_ui(self): self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) self.setMinimumSize(250, 250) layout = QGridLayout() layout.setContentsMargins(0, 0, 0, 0) self.setLayout(layout) positions = np.vstack([self.x_points, self.y_points, self.z_points]).transpose() self.view = GLViewWidgetFix.GLViewWidgetFix() self.view.setBackgroundColor(119, 181, 254) self.view.setCameraPosition(distance=2, elevation=45, azimuth=45) self.view.pan(0, 0, 0.73) self.plot = opengl.GLLinePlotItem(pos=positions) self.plot.setGLOptions("opaque") self.view.addItem(self.plot) self.image_file = Image.open(self.image_name) self.image = opengl.GLImageItem(np.asarray(self.image_file)) self.view.addItem(self.image) self.image.scale((self.lat_max - self.lat_min) * self.meters_per_lat / self.image_file.size[1], (self.lon_max - self.lon_min) * self.meters_per_lon / self.image_file.size[0], 1) self.image.translate(-(self.lat_max - self.lat_min) * self.meters_per_lat / 2, -(self.lon_max - self.lon_min) * self.meters_per_lon / 2, 0) flat_earth = opengl.GLMeshItem(meshdata=opengl.MeshData.cylinder(1, 64, [6371000, 0], 0), color=[84/255, 89/255, 72/255, 1], smooth=True) flat_earth.translate(0, 0, -1000) flat_earth.setGLOptions("opaque") self.view.addItem(flat_earth) rocket_mesh = mesh.Mesh.from_file("DisplayModels/Rocket.stl") rocket_mesh_data = opengl.MeshData(vertexes=rocket_mesh.vectors) self.rocket = opengl.GLMeshItem(meshdata=rocket_mesh_data, color=[235 / 255, 193 / 255, 153 / 255, 1], smooth=True) self.rocket.scale(1/1000, 1/1000, 1/1000) self.rocket.rotate(180, 1, 0, 0, local=False) self.rocket.translate(0, 0, 1.5) self.rocket.setShader(self.shader) self.view.addItem(self.rocket) payload_mesh = mesh.Mesh.from_file("DisplayModels/PayloadSection.stl") payload_mesh_data = opengl.MeshData(vertexes=payload_mesh.vectors) self.payload = opengl.GLMeshItem(meshdata=payload_mesh_data, color=[235 / 255, 193 / 255, 153 / 255, 50 / 255]) self.payload.setParentItem(self.rocket) self.payload.setShader(self.shader) self.payload.setGLOptions("additive") self.view.addItem(self.payload) nose_mesh = mesh.Mesh.from_file("DisplayModels/Nosecone.stl") nose_mesh_data = opengl.MeshData(vertexes=nose_mesh.vectors) self.nose = opengl.GLMeshItem(meshdata=nose_mesh_data, color=[240 / 255, 240 / 255, 240 / 255, 1], smooth=True) self.nose.setParentItem(self.rocket) self.nose.setShader(self.shader) self.view.addItem(self.nose) body_mesh = mesh.Mesh.from_file("DisplayModels/Body.stl") body_mesh_data = opengl.MeshData(vertexes=body_mesh.vectors) self.body = opengl.GLMeshItem(meshdata=body_mesh_data, color=[240 / 255, 20 / 255, 20 / 255, 1], smooth=False) self.body.scale(1 / 1000, 1 / 1000, 1 / 1000) self.body.setShader(self.shader) self.view.addItem(self.body) self.body.translate(0, 0, 0.6) rotor_mesh = mesh.Mesh.from_file("DisplayModels/Rotor.stl") rotor_mesh_data = opengl.MeshData(vertexes=rotor_mesh.vectors) self.rotor = opengl.GLMeshItem(meshdata=rotor_mesh_data, color=[200 / 255, 200 / 255, 200 / 255, 1], smooth=False) self.rotor.setParentItem(self.body) self.rotor.setShader(self.shader) self.view.addItem(self.rotor) self.rotor.translate(0, 0, 0.6) blade_mesh = mesh.Mesh.from_file("DisplayModels/Blade.stl") blade_mesh_data = opengl.MeshData(vertexes=blade_mesh.vectors) self.blades = [0]*4 for n in range(0, 4): self.blades[n] = opengl.GLMeshItem(meshdata=blade_mesh_data, color=[200 / 255, 200 / 255, 200 / 255, 1], smooth=False) self.blades[n].setParentItem(self.rotor) self.blades[n].setShader(self.shader) self.view.addItem(self.blades[n]) self.blades[n].rotate(n*90, 0, 0, 1) self.blades[n].translate(0, 0, 0.6) self.blades[n].translate(45, 0, 255, local=True) self.blades[n].rotate(90, 0, 1, 0, local=True) self.blades[n].translate(-45, 0, -255, local=True) self.blades[-1].setColor([50 / 255, 50 / 255, 50 / 255, 1]) fin_holder_mesh = mesh.Mesh.from_file("DisplayModels/FinHolder.stl") fin_holder_mesh_data = opengl.MeshData(vertexes=fin_holder_mesh.vectors) fin_mesh = mesh.Mesh.from_file("DisplayModels/Fin.stl") fin_mesh_data = opengl.MeshData(vertexes=fin_mesh.vectors) self.fins = [0] * 2 self.fin_holders = [0] * 2 for n in range(0, 2): self.fin_holders[n] = opengl.GLMeshItem(meshdata=fin_holder_mesh_data, color=[200 / 255, 200 / 255, 200 / 255, 1], smooth=False) self.fin_holders[n].setParentItem(self.body) self.fin_holders[n].setShader(self.shader) self.view.addItem(self.fin_holders[n]) self.fin_holders[n].rotate(n * 180, 0, 0, 1) self.fins[n] = opengl.GLMeshItem(meshdata=fin_mesh_data, color=[200 / 255, 200 / 255, 200 / 255, 1], smooth=False) self.fins[n].setParentItem(self.fin_holders[n]) self.fins[n].setShader(self.shader) self.view.addItem(self.fins[n]) self.fins[n].translate(0, 0, 0.6) self.fins[n].translate(41.3, 0, 126.5, local=True) self.fins[n].rotate(-90, 0, 1, 0, local=True) self.fins[n].translate(-41.3, 0, -126.5, local=True) can_mesh = mesh.Mesh.from_file("DisplayModels/Container.stl") can_mesh_data = opengl.MeshData(vertexes=can_mesh.vectors) self.can = opengl.GLMeshItem(meshdata=can_mesh_data, color=[255 / 255, 20 / 255, 147 / 255, 50 / 255], smooth=True) self.can.setShader(self.shader) self.can.setGLOptions("additive") self.view.addItem(self.can) self.can.scale(1 / 1000, 1 / 1000, 1 / 1000) self.can.translate(0, 0, 0.6) can_roof_mesh = mesh.Mesh.from_file("DisplayModels/ContainerRoof.stl") can_roof_mesh_data = opengl.MeshData(vertexes=can_roof_mesh.vectors) self.can_roof = opengl.GLMeshItem(meshdata=can_roof_mesh_data, color=[240 / 255, 20 / 255, 20 / 255, 1], smooth=False) self.can_roof.setParentItem(self.can) self.can_roof.setShader(self.shader) self.view.addItem(self.can_roof) self.can_roof.translate(0, 0, 0.6) chute_mesh = mesh.Mesh.from_file("DisplayModels/Chute.stl") chute_mesh_data = opengl.MeshData(vertexes=chute_mesh.vectors) self.chute = opengl.GLMeshItem(meshdata=chute_mesh_data, color=[255 / 255, 20 / 255, 147 / 255, 50 / 255], smooth=False) self.chute.setParentItem(self.can) self.chute.setShader(self.shader) self.view.addItem(self.chute) self.chute.translate(0, 0, 0.6) self.chute.hide() layout.addWidget(self.view) self.view.double_clicked.connect(self.change_speed) self.timer.start(16)
def viewer(self, grids: bool = False, drawEdges: bool = True, edgeColor: Tuple[float, float, float, float] = (0, 0, 0, 0.5), positionOffset: Tuple[int, int, int] = (0, 0, 0), viewAngle: Tuple[int, int, int] = (40, 30, 300), resolution: Tuple[int, int] = (1280, 720), name: str = 'Plot 1', export: bool = False): """ Display the mesh in a 3D viewer window. This function will block program execution until viewer window is closed Args: grids: Enable/disable display of XYZ axes and grids drawEdges: Enable/disable display of voxel edges edgeColor: Set display color of voxel edges positionOffset: Offset of the camera target from the center of the model in voxels viewAngle: Elevation, Azimuth, and Distance of the camera resolution: Window resolution in px name: Plot window name export: Enable/disable exporting a screenshot of the plot Returns: None """ app = qtw.QApplication(sys.argv) mesh_data = pgo.MeshData(vertexes=self.verts, faces=self.tris, vertexColors=self.colors, faceColors=None) mesh_item = pgo.GLMeshItem(meshdata=mesh_data, shader='balloon', drawEdges=drawEdges, edgeColor=edgeColor, smooth=False, computeNormals=False, glOptions='translucent') widget = pgo.GLViewWidget() widget.setBackgroundColor('w') widget.addItem(mesh_item) if grids: # Add grids gx = pgo.GLGridItem() gx.setSize(x=50, y=50, z=50) gx.rotate(90, 0, 1, 0) gx.translate(-0.5, 24.5, 24.5) widget.addItem(gx) gy = pgo.GLGridItem() gy.setSize(x=50, y=50, z=50) gy.rotate(90, 1, 0, 0) gy.translate(24.5, -0.5, 24.5) widget.addItem(gy) gz = pgo.GLGridItem() gz.setSize(x=50, y=50, z=50) gz.translate(24.5, 24.5, -0.5) widget.addItem(gz) # Add axes ptsx = np.array([[-0.5, -0.5, -0.5], [50, -0.5, -0.5]]) pltx = pgo.GLLinePlotItem(pos=ptsx, color=(1, 0, 0, 1), width=1, antialias=True) widget.addItem(pltx) ptsy = np.array([[-0.5, -0.5, -0.5], [-0.5, 50, -0.5]]) plty = pgo.GLLinePlotItem(pos=ptsy, color=(0, 1, 0, 1), width=1, antialias=True) widget.addItem(plty) ptsz = np.array([[-0.5, -0.5, -0.5], [-0.5, -0.5, 50]]) pltz = pgo.GLLinePlotItem(pos=ptsz, color=(0, 0, 1, 1), width=1, antialias=True) widget.addItem(pltz) # Set plot options widget.opts['center'] = qg.QVector3D( ((self.model.shape[0] / self.res) / 2) + positionOffset[0], ((self.model.shape[1] / self.res) / 2) + positionOffset[1], ((self.model.shape[2] / self.res) / 2) + positionOffset[2]) widget.opts['elevation'] = viewAngle[0] widget.opts['azimuth'] = viewAngle[1] widget.opts['distance'] = viewAngle[2] widget.resize(resolution[0], resolution[1]) # Show plot widget.setWindowTitle(str(name)) widget.show() app.processEvents() # if export: # TODO: Fix export code # widget.paintGL() # widget.grabFrameBuffer().save(str(name) + '.png') print('Close viewer to resume program') app.exec_() app.quit()