def show_contrasts(subject, contrasts, side, threshold): x, y, z, triangles = get_geometry(subject, side, "inflated") ## inflated or white curv = get_curvature_sign(subject, side) f = mlab.figure() mlab.clf() # anatomical mesh mlab.triangular_mesh(x, y, z, triangles, transparent=False, opacity=1., name=subject, scalars=curv, colormap="bone", vmin=-1, vmax=2) mlab.title(subject) cmaps = [colormaps[c.split("-")[0]]['colormap'] for c in contrasts] for contrast, colormap in zip(contrasts, cmaps): # functional mesh data = get_contrast(subject, contrast, side) func_mesh = mlab.pipeline.triangular_mesh_source(x, y, z, triangles, scalars=data) # threshold thresh = mlab.pipeline.threshold(func_mesh, low=threshold) surf = mlab.pipeline.surface(thresh, colormap='hot', transparent=True, opacity=.8) # diminuer pour avoir plus de transparence lut = (np.array([colormap(v) for v in np.linspace(.25, 1., 256)]) * 255 ).astype(int) surf.module_manager.scalar_lut_manager.lut.table = lut mlab.draw() return f
def action(u, x, xv, y, yv, t, n): #print 'action, t=',t,'\nu=',u, '\Nx=',x, '\Ny=', y if plot == 1: mesh(xv, yv, u, title='t=%g' %t[n]) time.sleep(0.2) # pause between frames elif plot == 2: # mayavi plotting mlab.clf() extent1 = (0, 20, 0, 20,-2, 2) s = mlab.surf(x , y, u, colormap='Blues', warp_scale=5,extent=extent1) mlab.axes(s, color=(.7, .7, .7), extent=extent1, ranges=(0, 10, 0, 10, -1, 1), xlabel='', ylabel='', zlabel='', x_axis_visibility=False, z_axis_visibility=False) mlab.outline(s, color=(0.7, .7, .7), extent=extent1) mlab.text(2, -2.5, '', z=-4, width=0.1) mlab.colorbar(object=None, title=None, orientation='horizontal', nb_labels=None, nb_colors=None, label_fmt=None) mlab.title('test 1D t=%g' % t[n]) mlab.view(142, -72, 50) f = mlab.gcf() camera = f.scene.camera camera.yaw(0) if plot > 0: path = 'Figures_wave2D' time.sleep(0) # pause between frames if save_plot and plot != 2: filename = '%s/%08d.png' % (path, n) savefig(filename) # time consuming! elif save_plot and plot == 2: filename = '%s/%08d.png' % (path,n) mlab.savefig(filename) # time consuming!
def plotSpherical(dataset, vertices, triangles, ptitle="", tsize=0.4, theight=0.95): """Plot the spherical data given a data set, triangle set and vertex set. The vertex set defines the direction cosines of the individual samples. The triangle set defines how the surfrace must be structured between the samples. The data set defines, for each direction cosine, the length of the vector. Args: | dataset(numpy.array(double)): array of data set values | vertices(numpy.array([])): array of direction cosine vertices as [x y z] | triangles(numpy.array([])): array of triangles as [] | ptitle(string): title or header for this display | tsize(double): title size (units not quite clear) | theight(double): title height (y value) (units not quite clear) Returns: | provides and mlab figure. Raises: | No exception is raised. """ # calculate a (x,y,z) data set from the direction vectors x = dataset * vertices[:, 0] y = dataset * vertices[:, 1] z = dataset * vertices[:, 2] mlab.figure(1, fgcolor=(0, 0, 0), bgcolor=(1, 1, 1)) # Visualize the points pts = mlab.triangular_mesh(x, y, z, triangles) # z, scale_mode='none', scale_factor=0.2) mlab.title(ptitle, size=tsize, height=theight) mlab.show()
def Render(self): t1clock = clock() self.figure = mlab.figure(bgcolor = (1, 1, 1), fgcolor = (0, 0, 0))#, figure = dataset.class_name[3:]) self.figure.scene.disable_render = True nodesToRender = self.leafCount if self.renderToLevel != -1: nodesToRender = 0 for i in range(0, self.renderToLevel): nodesToRender += self.nodesPerLevel[i] vertices = array(zeros((nodesToRender*8, 3))) facets = array(zeros((nodesToRender *6, 4))) self.centroids = array(zeros((nodesToRender , 3))) self.root.Render(self.renderToLevel, vertices, facets, self.centroids, render_points = False) # Print vertices # Print facets if self.renderVerticesAndFacets: dataset = tvtk.PolyData(points = vertices, polys = facets) surf = mlab.pipeline.surface(dataset, opacity = .001) mlab.pipeline.surface(mlab.pipeline.extract_edges(surf), color = (0, 0, 0)) #print 'len 111 = ', len(vertices) #print 'len 222 = ', len(facets) #print 'Rendering took ', clock() - t1clock if self.renderCentroids: print 'self.leafCount = ', self.leafCount scalars = array(ones(self.leafCount)) * 0.05 self.centroid_glyphs = mlab.points3d(self.centroids[:, 0], self.centroids[:, 1], self.centroids[:, 2], scalars, scale_factor=.05, color = (1, 0, 0))#, s, color = (1, 0, 0), ) # outline = mlab.outline(name = str('1'), line_width = 3, color = (0, 1, 0)) # outline.outline_mode = 'full' # center = self.leaves[0].center # radius = self.leaves[0].radius # print 'center = ', center # print 'radius= ', radius # outline.bounds = (center[0] - radius, center[0] + radius, # center[1] - radius, center[1] + radius, # center[2] - radius, center[2] + radius) # temp - rendering points self.RenderPoints() self.RenderOctreeGraph() mlab.title('Click on centroid') picker = self.figure.on_mouse_pick(self.picker_callback) # Decrease the tolerance, so that we can more easily select a precise # point. picker.tolerance = 0.01 self.figure.scene.disable_render = False # Here, we grab the points describing the individual glyph, to figure # out how many points are in an individual glyph. self.glyph_points = self.centroid_glyphs.glyph.glyph_source.glyph_source.output.points.to_array()
def plot_trajectory(perf_data, stimset, stim_class, symbols, post_stim_time=1): net = perf_data.net net.noise_std = 0.0 mlab.figure(bgcolor=(0.5, 0.5, 0.5), fgcolor=(0.0, 0.0, 0.0)) for symbol in symbols: stim_md5 = stimset.symbol_to_md5[symbol][0] stim = stimset.all_stims[stim_md5] net_sims = run_sim(net, {stim_md5:stim}, burn_time=100, pre_stim_time = 1, post_stim_time=max(25, post_stim_time), num_trials=1) sim = net_sims[stim_md5] avg_resp = sim.responses[0, :, :].squeeze() stim_start = 0 record_time = len(stim) + 1 stim_end = len(stim) + post_stim_time stimsym = stimset.md5_to_symbol[stim_md5] #stim_str = '%s:%s (%0.2f)' % (stimsym, ''.join(['%d' % s for s in stim]), perf_data.logit_perf) stim_str = '%s:%s' % (stimsym, ''.join(['%d' % s for s in stim])) t = np.arange(0, stim_end) traj = mlab.plot3d(avg_resp[0:stim_end, 0], avg_resp[0:stim_end, 1], avg_resp[0:stim_end, 2], t, colormap='hot', tube_radius=None) #mlab.points3d(avg_resp[stim_start, 0], avg_resp[stim_start, 1], avg_resp[stim_start, 2], scale_factor=0.300) mlab.points3d(avg_resp[record_time-1, 0], avg_resp[record_time-1, 1], avg_resp[record_time-1, 2], scale_factor=0.900) mlab.colorbar() if len(symbols) == 1: mlab.title(stim_str)
def plot_u(u, x, xv, y, yv, t, n): """User action function for plotting.""" if t[n] == 0: time.sleep(2) if plot_method == 1: # Works well with Gnuplot backend, not with Matplotlib st.mesh(x, y, u, title='t=%g' % t[n], zlim=[-1,1], caxis=[-1,1]) elif plot_method == 2: # Works well with Gnuplot backend, not with Matplotlib st.surfc(xv, yv, u, title='t=%g' % t[n], zlim=[-1, 1], colorbar=True, colormap=st.hot(), caxis=[-1,1], shading='flat') elif plot_method == 3: print 'Experimental 3D matplotlib...under development...' # Probably too slow #plt.clf() ax = fig.add_subplot(111, projection='3d') u_surf = ax.plot_surface(xv, yv, u, alpha=0.3) #ax.contourf(xv, yv, u, zdir='z', offset=-100, cmap=cm.coolwarm) #ax.set_zlim(-1, 1) # Remove old surface before drawing if u_surf is not None: ax.collections.remove(u_surf) plt.draw() time.sleep(1) elif plot_method == 4: # Mayavi visualization mlab.clf() extent1 = (0, 20, 0, 20,-2, 2) s = mlab.surf(x , y, u, colormap='Blues', warp_scale=5,extent=extent1) mlab.axes(s, color=(.7, .7, .7), extent=extent1, ranges=(0, 10, 0, 10, -1, 1), xlabel='', ylabel='', zlabel='', x_axis_visibility=False, z_axis_visibility=False) mlab.outline(s, color=(0.7, .7, .7), extent=extent1) mlab.text(6, -2.5, '', z=-4, width=0.14) mlab.colorbar(object=None, title=None, orientation='horizontal', nb_labels=None, nb_colors=None, label_fmt=None) mlab.title('Gaussian t=%g' % t[n]) mlab.view(142, -72, 50) f = mlab.gcf() camera = f.scene.camera camera.yaw(0) if plot_method > 0: time.sleep(0) # pause between frames if save_plot: filename = 'tmp_%04d.png' % n if plot_method == 4: mlab.savefig(filename) # time consuming! elif plot_method in (1,2): st.savefig(filename) # time consuming!
def _populate_scene(self, scene, title): trajectories = self.data.root.positions.read()[:, :self.end, :] self.plot_uav_trajectories(trajectories, figure=scene.mayavi_scene) area = self.conf['area'] scene.mayavi_scene.children[0].add_child( Outline(manual_bounds=True, bounds=area.flatten())) if not self.plain: mlab.title(title, figure=scene.mayavi_scene)
def test_text(self): """ Test the text module. """ data = np.random.random((3, 3, 3)) src = mlab.pipeline.scalar_field(data) # Some smoke testing mlab.text(0.1, 0.9, 'foo') mlab.text(3, 3, 'foo', z=3) mlab.title('foo') # Check that specifying 2D positions larger than 1 raises an # error self.assertRaises(ValueError, mlab.text, 0, 1.5, 'test')
def plot_graphs(locs,stations,nbsta,CLUSTER,nbmin,threshold): from mayavi import mlab # Event coordinates stack_x,stack_y,stack_z=[],[],[] for loc in locs: stack_x.append(loc['x_mean']) stack_y.append(loc['y_mean']) stack_z.append(-loc['z_mean']) # Extract coordinates xsta,ysta,zsta=[],[],[] for sta in sorted(stations): xsta.append(stations[sta]['x']) ysta.append(stations[sta]['y']) zsta.append(stations[sta]['elev']) # 3D PLOT USING MAYAVI logging.info("Plotting...") s1=mlab.figure(1,bgcolor=(1,1,1),fgcolor=(0,0,0),size=(1000,900)) s1=mlab.points3d(xsta,ysta,zsta,color=(1,0,0),scale_factor=0.05,mode='cube') s1=mlab.axes(extent=[362,370,7647,7653,-0.5,2.5],color=(0,0,0)) s1=mlab.outline(extent=[362,370,7647,7653,-0.5,2.5],color=(0,0,0)) s1=mlab.points3d(stack_x,stack_y,stack_z,scale_factor=0.1,color=(0.8,0.8,0.8)) s1=mlab.title("threshold=%s, nbmin=%s"%(threshold,nbmin),height=0.1,size=0.35,color=(0,0,0)) for i_ev in range(len(nbsta)): for i_c in range(1,len(CLUSTER)+1): if i_ev+1 in CLUSTER[i_c]: s1=mlab.points3d(stack_x[i_ev],stack_y[i_ev],stack_z[i_ev],scale_factor=0.1,color=tuple(CZ_Clust_2_color(100*(len(CLUSTER)-i_c)/len(CLUSTER)))) s1=mlab.text3d(stack_x[i_ev],stack_y[i_ev],stack_z[i_ev],str(i_c),color=(0,0,0),scale=0.1) logging.info("Done!") logging.info("Plotting...") s2=mlab.figure(2,bgcolor=(1,1,1),fgcolor=(0,0,0),size=(1000,900)) mlab.points3d(xsta,ysta,zsta,color=(1,0,0),scale_factor=0.05,mode='cube') mlab.axes(extent=[362,370,7647,7653,-0.5,2.5],color=(0,0,0)) mlab.outline(extent=[362,370,7647,7653,-0.5,2.5],color=(0,0,0)) mlab.points3d(stack_x,stack_y,stack_z,scale_factor=0.1,color=(0.8,0.8,0.8)) mlab.title("threshold=%s, nbmin=%s"%(threshold,nbmin),height=0.1,size=0.35,color=(0,0,0)) for ind_I in range(len(nbsta)): for ind_J in range(ind_I+1,len(nbsta)): W_IJ=nbsta[ind_I,ind_J] if W_IJ >= nbmin: mlab.points3d(stack_x[ind_J],stack_y[ind_J],stack_z[ind_J],scale_factor=0.1,color=(0,0,0)) mlab.points3d(stack_x[ind_I],stack_y[ind_I],stack_z[ind_I],scale_factor=0.1,color=(0,0,0)) d=(stack_x[ind_J]-stack_x[ind_I],stack_y[ind_J]-stack_y[ind_I],stack_z[ind_J]-stack_z[ind_I]) norm=np.sqrt(d[0]**2+d[1]**2+d[2]**2) s2=mlab.quiver3d(stack_x[ind_I],stack_y[ind_I],stack_z[ind_I],d[0],d[1],d[2],color=tuple(CZ_W_2_color(W_IJ)),mode='2ddash',scale_factor=norm,scale_mode='scalar') #mlab.colorbar(s2) logging.info("Done!") mlab.show()
def analyze(): mcs = [] import mayavi.mlab as mlab for gamma_b in linspace(2*pi*1e3, 2*pi*17e3, 5): mc = MonteCarlo() mc.run_stats(35.5e-6, 0.1e-6, 300, gamma_b=gamma_b) mcs.append(mc) mlab.figure() mlab.barchart(mc.cov) mlab.axes() mlab.title("gamma_b/2pi = "+str(gamma_b/(2*pi))) return mcs
def plot_3d_barchart(self, data_dict, Type, Freq): ''' Using the mayavi library, plot a 3D barchart of the data of requested type, and freq.''' extent_dim = self._get_extent(3) Xlocs,Xlabels,Ylocs,Ylabels = self._get_ticks(5,5,extent_dim) data = self.get_data_type(data_dict, Type) v_min,v_max = self.get_data_scale(data_dict, Type) freq_array = data_dict['freq'] freq_ind = self.get_nearest_freq(freq_array,Freq) from mayavi import mlab mlab.figure( bgcolor=(0.5,0.5,0.5) )# grey bg mlab.barchart(data[freq_ind,:,:],vmin=v_min,vmax=v_max,auto_scale=False,colormap='jet',extent = extent_dim) mlab.title('Freq %.3e' %freq_array[freq_ind],size=5,height=0.1) mlab.show()
def animation(): for i in count(): frame = i % all_verts.shape[2] verts = all_verts[:, :, frame].T mlab.clf() mlab.triangular_mesh( verts[:, 0], verts[:, 1], verts[:, 2], faces, color=(.9, .7, .7)) fig.scene.z_minus_view() mlab.view(azimuth=180) mlab.title('mesh %d' % i, size=0.5, height=0, color=(0, 0, 0)) yield
def plotArm(self): """Method that plots SQ in Mayavi""" #If you get error with the axes, do the following replacement: #in mayavi/modules/axes.py change self.configure_input_data(self.axes, src.outputs[0]) to self.configure_input_data(self.axes, src.outputs[0].output) mlab.figure(size=(800, 800), fgcolor=(0, 0, 0), bgcolor=(1, 1, 1)) #mlab.mesh(self.paramx,self.paramy,self.paramz) for primitive in self.links: mlab.mesh(primitive.W[0], primitive.W[1], primitive.W[2]) if primitive == self.links[0]: #give the base SQ axes and outline mlab.axes() mlab.outline() mlab.title('Arm') mlab.show() return 0
def mayavi_addTitle(fig, string, **kwargs): r"""Add a title to mayavi figure t = mayavi_addTitle(fig, string, **kwargs) Parameters ---------- fig : mayavi figure Figure to add the title string : str Title string **kwargs : keyword list matching documentation Height, color, size are useful Returns ------- t : mayavi object Title object Author ------ Shankar Kulumani GWU [email protected] """ t = mlab.title(string, figure=fig, **kwargs) return t
def isosurface(self,vv=[4.0],clim=None,**kwargs): """ 3D isosurfaces of scalar data """ if clim==None: clim = [self.data.min(), self.data.max()] # Create a new scene if there isn't one if not self.__dict__.has_key('fig'): self.newscene() # Convert the cell centred data into a scene source # Need to set use point (vertex) data src = mlab.pipeline.cell_to_point_data(self.ug) # Add the iso_surface module to the scene self.h=mlab.pipeline.iso_surface(src,contours=vv,line_width=1.0,vmin=clim[0],vmax=clim[1],**kwargs) # Add a colorbar if the isn't one if not self.__dict__.has_key('cb'): self.colorbar() # Add a title if there isn't one if not self.__dict__.has_key('title'): self.title=mlab.title(self._SpatialgenTitle(),height=0.95,size=0.15)
def sliceplane(self, plane_orientation='y_axes', **kwargs): """ Applies the image plane widget to the dataset """ if self.clim == None: self.clim = [self.data.min(), self.data.max()] # Create a new scene if there isn't one if 'fig' not in self.__dict__: self.newscene() src = mlab.pipeline.cell_to_point_data(self.ug) self.h = mlab.pipeline.scalar_cut_plane( src, plane_orientation=plane_orientation, view_controls=True, line_width=0.5) # Add a colorbar if the isn't one if 'cb' not in self.__dict__: self.colorbar() # Add a title if there isn't one if 'title' not in self.__dict__: self.title = mlab.title(self._SpatialgenTitle(), height=0.95, size=0.15)
def mlab_title(text, height=0.9, size=0.5): t = mlab.title(text=text, height=height, size=size) # May customize later on further with eg.: # t.width = 0.5 # t.x_position = 0.25 # t.y_position = 0.9 return t
def contour(self, vv=[10], clim=None, **kwargs): """ Filled contour plot of scalar data """ if clim == None: clim = [self.data.min(), self.data.max()] # Create a new scene if there isn't one if 'fig' not in self.__dict__: self.newscene() # Need to set use point (vertex) data src = mlab.pipeline.cell_to_point_data(self.ug) # Add the contour_surface module to the scene self.h = mlab.pipeline.contour_surface(src, contours=vv, line_width=1.0, vmax=clim[1], vmin=clim[0], **kwargs) self.h.contour.filled_contours = True # This is the trick to fill the contours # Add a colorbar if the isn't one if 'cb' not in self.__dict__: self.colorbar() # Add a title if there isn't one if 'title' not in self.__dict__: self.title = mlab.title(self._SpatialgenTitle(), height=0.95, size=0.15)
def volume(self,clim=None,**kwargs): """ 3D volumetric plot of scalar data **Warning** This is really slow and memory hungry! """ if self.clim==None: self.clim = [self.data.min(), self.data.max()] # Create a new scene if there isn't one if not self.__dict__.has_key('fig'): self.newscene() # Convert the cell centred data into a scene source # Need to set use point (vertex) data src = mlab.pipeline.cell_to_point_data(self.ug) # Add the volume module to the scene self.h=mlab.pipeline.volume(src,**kwargs) # Add a colorbar if the isn't one if not self.__dict__.has_key('cb'): self.colorbar() # Add a title if there isn't one if not self.__dict__.has_key('title'): self.title=mlab.title(self._SpatialgenTitle(),height=0.95,size=0.15)
def surface(self, clim=None, **kwargs): """ Surface plot of the scalar in the 'data' attribute with mayavi Works on the 2D and 3D data """ if clim == None: clim = [self.data.min(), self.data.max()] # Create a new scene if there isn't one if 'fig' not in self.__dict__: self.newscene() src = mlab.pipeline.add_dataset(self.ug) self.h = mlab.pipeline.surface(src, vmin=clim[0], vmax=clim[1], **kwargs) # Add a colorbar if the isn't one if 'cb' not in self.__dict__: self.colorbar() # Add a title if there isn't one if 'title' not in self.__dict__: self.title = mlab.title(Spatial.genTitle(self), height=0.95, size=0.15)
def isosurface(self, vv=[4.0], clim=None, **kwargs): """ 3D isosurfaces of scalar data """ if clim == None: clim = [self.data.min(), self.data.max()] # Create a new scene if there isn't one if 'fig' not in self.__dict__: self.newscene() # Convert the cell centred data into a scene source # Need to set use point (vertex) data src = mlab.pipeline.cell_to_point_data(self.ug) # Add the iso_surface module to the scene self.h = mlab.pipeline.iso_surface(src, contours=vv, line_width=1.0, vmin=clim[0], vmax=clim[1], **kwargs) # Add a colorbar if the isn't one if 'cb' not in self.__dict__: self.colorbar() # Add a title if there isn't one if 'title' not in self.__dict__: self.title = mlab.title(self._SpatialgenTitle(), height=0.95, size=0.15)
def contour(self,vv=[10],clim=None,**kwargs): """ Filled contour plot of scalar data """ if clim==None: clim = [self.data.min(), self.data.max()] # Create a new scene if there isn't one if not self.__dict__.has_key('fig'): self.newscene() # Need to set use point (vertex) data src = mlab.pipeline.cell_to_point_data(self.ug) # Add the contour_surface module to the scene self.h=mlab.pipeline.contour_surface(src,contours=vv,line_width=1.0,vmax=clim[1],vmin=clim[0],**kwargs) self.h.contour.filled_contours=True # This is the trick to fill the contours # Add a colorbar if the isn't one if not self.__dict__.has_key('cb'): self.colorbar() # Add a title if there isn't one if not self.__dict__.has_key('title'): self.title=mlab.title(self._SpatialgenTitle(),height=0.95,size=0.15)
def plotSQ(self): """Method that plots SQ in Mayavi""" if self.loaded: mlab.figure(size=(800, 800), fgcolor=(0, 0, 0), bgcolor=(1, 1, 1)) #mlab.mesh(self.paramx,self.paramy,self.paramz) mlab.mesh(self.W[0], self.W[1], self.W[2]) mlab.outline() mlab.title('Superquadric: ' + 'a1: ' + str(self.a1) + '; ' + 'a2: ' \ + str(self.a2) + '; ' + 'a3: ' + str(self.a3) + '; ' + 'epsilon1: ' \ + str(self.epsilon1) + '; ' + 'epsilon2: ' + str(self.epsilon2) + '.') mlab.axes( ) #in mayavi/modules/axes.py change self.configure_input_data(self.axes, src.outputs[0]) to self.configure_input_data(self.axes, src.outputs[0].output) mlab.show() else: self.loadBasicSuperEllipsoid() self.plotSQ()
def update_scene(): mlab.clf(fig1) # 清空figure vis_points = points[file_i] # 取出要显示的点云 vis_points = (vis_points * 1.5 + np.array([1.0, 1.0, 1.0])) * 50 # 对点云进行缩放 # show point clouds colorized with activations activations = mlab.points3d(vis_points[:, 0], vis_points[:, 1], vis_points[:, 2], vis_points[:, 2], scale_factor=3.0, scale_mode='none', figure=fig1) mlab.title(str(file_i), color=(0, 0, 0), size=0.3, height=0.01) text = '<--- (press g for previous' + 50 * '' + '(press h for next)---->' mlab.text(0.01, 0.01, text, color=(0, 0, 0), width=0.98) mlab.orientation_axes() return
def show_obj(surface_points_, title, color='b'): mlab.figure(bgcolor=(0, 0, 0), fgcolor=(0.7, 0.7, 0.7), size=(1000, 1000)) if color == 'b': color_f = (0, 0, 1) elif color == 'r': color_f = (1, 0, 0) elif color == 'g': color_f = (0, 1, 0) else: color_f = (1, 1, 1) points_ = surface_points_ mlab.points3d(points_[:, 0], points_[:, 1], points_[:, 2], color=color_f, scale_factor=.0007) mlab.title(title, size=0.5)
def plot_u(u, x, xv, y, yv, t, n): print " ploting" if t[n] == 0: time.sleep(2) if plot_method == 1: mesh(x, y, u, title='t=%g' % t[n], zlim=[-1,1], caxis=[-1,1]) elif plot_method == 2: surfc(xv, yv, u, title='t=%g' % t[n], zlim=[-1, 1], colorbar=True, colormap=hot(), caxis=[-1,1], shading='flat') elif plot_method == 3: # mayavi plotting mlab.clf() extent1 = (0, 20, 0, 20,-2, 2) s = mlab.surf(x , y, u, colormap='Blues', warp_scale=5, extent=extent1) mlab.axes(s, color=(.7, .7, .7), extent=extent1, ranges=(0, 10, 0, 10, -1, 1), xlabel='', ylabel='', zlabel='', x_axis_visibility=False, z_axis_visibility=False) mlab.outline(s, color=(0.7, .7, .7), extent=extent1) mlab.text(2, -2.5, '', z=-4, width=0.1) mlab.colorbar(object=None, title=None, orientation='horizontal', nb_labels=None, nb_colors=None, label_fmt=None) mlab.title('t=%g' % t[n]) mlab.view(142, -72, 50) f = mlab.gcf() camera = f.scene.camera camera.yaw(0) #g = mlab.figure() #g.scene.movie_maker.record = True if plot_method > 0: if not os.path.exists(path): os.makedirs(path) time.sleep(0) # pause between frames if save_plot and plot_method == 3: filename = '%s/%08d.png'%(path,n) mlab.savefig(filename) # time consuming! elif save_plot and plot_method != 3: filename = '%s/%08d.png'%(path,n) savefig(filename) # time consuming!
def action(u, x, y, t, n): if n > 1: # every timestep exactly 2 cells change. If the wave is at the # boundary, only two cells change. msg = "the plug should travel exactly one cell per time step" cells_with_new_value = (u-last_solution) != 0 print(np.sum(cells_with_new_value)) assert ((np.sum(cells_with_new_value) == 4) | (np.sum(cells_with_new_value) == 2) | (np.sum(cells_with_new_value) == 0)), msg ms2.mlab_source.set(z=u) mlab.title('pulse, t = {:.2f}'.format(t[n])) last_solution[:, :] = u[:, :] # concate filename with zero padded index number as suffix filename = os.path.join(out_path, '{}_{:06d}{}'.format(prefix, n, ext)) print(filename) mlab.savefig(filename=filename) return
def update_scene(): # clear figure mlab.clf(fig1) # Rescale points for visu p1 = (query * 1.5 + np.array([1.0, 1.0, 1.0])) * 50.0 p2 = (supports * 1.5 + np.array([1.0, 1.0, 1.0])) * 50.0 l1 = p1[:, 2] * 0 l1[file_i] = 1 l2 = p2[:, 2] * 0 + 2 l2[neighbors[file_i]] = 3 # Show point clouds colorized with activations activations = mlab.points3d(p1[:, 0], p1[:, 1], p1[:, 2], l1, scale_factor=2.0, scale_mode='none', vmin=0.0, vmax=3.0, figure=fig1) activations = mlab.points3d(p2[:, 0], p2[:, 1], p2[:, 2], l2, scale_factor=3.0, scale_mode='none', vmin=0.0, vmax=3.0, figure=fig1) # New title mlab.title(str(file_i), color=(0, 0, 0), size=0.3, height=0.01) text = '<--- (press g for previous)' + 50 * ' ' + '(press h for next) --->' mlab.text(0.01, 0.01, text, color=(0, 0, 0), width=0.98) mlab.orientation_axes() return
def sph_plot(l,m): theta_range = np.linspace(0,2*np.pi,90,endpoint=True) phi_range = np.linspace(0, np.pi,45,endpoint=True) theta,phi = np.meshgrid(theta_range,phi_range) Ylm = real_sph_harm(m,l,theta,phi) rho = abs(Ylm) X = rho * cos(theta) * sin(phi) Y = rho * sin(theta) * sin(phi) Z = rho * cos(phi) if 0: Ylm_scaled = ( Ylm - np.amin(Ylm) )/(np.amax(Ylm) - np.amin(Ylm)) else: Ylm_scaled = Ylm if len(sys.argv) > 3: # plain old mplot3d fig = figure() ax = Axes3D(fig) ax.plot_surface(X, Y, Z, facecolors=cm.jet(Ylm_scaled), rstride=1, cstride=1, antialiased=True ) gscale = [x * 0.5 for x in [-1, 1]] ax.auto_scale_xyz(gscale, gscale, gscale) show() else: # try fancy mayavi2 stuff from mayavi import mlab s = mlab.mesh(X, Y, Z, scalars=Ylm_scaled, vmax=1,vmin=-1) #, extent=[-1, 1, -1, 1, -1, 1]) mlab.colorbar(s, orientation='vertical',nb_labels=5) mlab.title("Real Ylm, l="+str(l)+" m="+str(m),size=0.35,height=0.9) mlab.outline(s, extent=[-1, 1, -1, 1, -1, 1]) mlab.axes(s, extent=[-1, 1, -1, 1, -1, 1],nb_labels=3) mlab.show()
def save_plot(cur_frame_file, source_pc, target_pc, all_avg_l2_dist, config_params): mlab.figure( bgcolor=(0, 0, 0)) mlab.points3d(source_pc[:, 0], source_pc[:, 1], source_pc[:, 2], color=(0.3, 0.45, 1), mode='sphere', scale_factor=0.007, opacity=0.6) mlab.points3d(target_pc[:, 0], target_pc[:, 1], target_pc[:, 2], color=(0.8, 0.85, 0.45), mode='sphere', scale_factor=0.007, opacity=0.6) if config_params['fid_indices'] is not None: mlab.points3d(source_pc[config_params['fid_indices']['source'], 0], source_pc[config_params['fid_indices']['source'], 1], source_pc[config_params['fid_indices']['source'], 2], color=(0.8, 0.2, 0.2), mode='sphere', scale_factor=0.02) mlab.points3d(target_pc[config_params['fid_indices']['target'], 0], target_pc[config_params['fid_indices']['target'], 1], target_pc[config_params['fid_indices']['target'], 2], color=(0.2, 0.8, 0.2), mode='sphere', scale_factor=0.02) mlab.view(azimuth=135, elevation=55) mlab.title(f'avg l2 dist - {all_avg_l2_dist:9.5f}', size=0.8, height=0.7) mlab.savefig(cur_frame_file, magnification=2) mlab.close()
def action(u, x, xv, y, yv, t, n): #print 'action, t=',t,'\nu=',u, '\Nx=',x, '\Ny=', y if t[n] == 0: time.sleep(2) if plot_u == 1: mesh(x, y, u, title='t=%g' % t[n], zlim=[-1,1], caxis=[-1,1]) elif plot_u == 2: surf(xv, yv, u, title='t=%g' % t[n], zlim=[-1, 1], colorbar=True, colormap=hot(), caxis=[-1,1]) elif plot_u == 3: # mayavi plotting mlab.clf() extent1 = (0, 20, 0, 20,-2, 2) s = mlab.surf(x , y, u, colormap='Blues', warp_scale=5,extent=extent1) mlab.axes(s, color=(.7, .7, .7), extent=extent1, ranges=(0, 10, 0, 10, -1, 1), xlabel='', ylabel='', zlabel='', x_axis_visibility=False, z_axis_visibility=False) mlab.outline(s, color=(0.7, .7, .7), extent=extent1) mlab.text(2, -2.5, '', z=-4, width=0.1) mlab.colorbar(object=None, title=None, orientation='horizontal', nb_labels=None, nb_colors=None, label_fmt=None) mlab.title('Gaussian t=%g' % t[n]) mlab.view(142, -72, 50) f = mlab.gcf() camera = f.scene.camera camera.yaw(0) if plot_u > 0: path = 'Figures_wave2D' if not os.path.exists(path): os.makedirs(path) time.sleep(0) # pause between frames if save_plot and plot_u != 3: filename = '%s/tmp_%08d.png' % (path, n) elif save_plot and plot_u == 3: filename = '%s/tmp_%08d.png' % (path, n) mlab.savefig(filename) # time consuming!
def plot_gamma_motor(subject_name, subjects_dir, dir_n, elec_up, mlabViewX, mlabViewY, saveDataBool): #make info file ch_names = [str(x) for x in np.arange(64)] dig_ch_pos = dict(zip(ch_names, elec_up / 1000)) mon = mne.channels.DigMontage(dig_ch_pos=dig_ch_pos) info = mne.create_info(ch_names, 1000., ch_types='ecog', montage=mon) name = listdir(dir_n) for nam in name: if nam != '.DS_Store': gama_t = loadmat(dir_n + nam) res_re = gama_t['res'] s = np.mean(res_re[:, 15:, 0], axis=1) #gamma s = np.interp(s, (s.min(), s.max()), (0, 1)) fig = mlab.figure('gamma_motor_' + nam, size=(800, 700)) plot_alignment(info, subject=subject_name, subjects_dir=subjects_dir, surfaces=['pial'], ecog=False, fig=fig) obj = mlab.points3d(elec_up[:, 0] / 1000, elec_up[:, 1] / 1000, elec_up[:, 2] / 1000, s, colormap='rainbow', scale_mode='none', scale_factor=0.002) mlab.colorbar(object=obj, title='gamma', orientation='vertical', nb_labels=8, nb_colors=None, label_fmt=None) mlab.title(nam[:-4], size=0.2, height=0.015) #chouse point of view mlab.view(mlabViewX, mlabViewY) if saveDataBool: mlab.savefig(nam[:-4] + '.png') mlab.savefig(nam[:-4] + '.x3d')
def update_scene(): # clear figure mlab.clf(fig1) # Plot new data feature points = clouds[file_i] labels = cloud_labels[file_i] if cloud_normals is not None: normals = cloud_normals[file_i] else: normals = None # Rescale points for visu points = (points * 1.5 + np.array([1.0, 1.0, 1.0])) * 50.0 # Show point clouds colorized with activations activations = mlab.points3d(points[:, 0], points[:, 1], points[:, 2], labels, scale_factor=3.0, scale_mode='none', figure=fig1) if normals is not None and show_normals: activations = mlab.quiver3d(points[:, 0], points[:, 1], points[:, 2], normals[:, 0], normals[:, 1], normals[:, 2], scale_factor=10.0, scale_mode='none', figure=fig1) # New title mlab.title(str(file_i), color=(0, 0, 0), size=0.3, height=0.01) text = '<--- (press g for previous)' + 50 * ' ' + '(press h for next) --->' mlab.text(0.01, 0.01, text, color=(0, 0, 0), width=0.98) mlab.orientation_axes() return
def update_scene(): # 清空当前窗口 mlab.clf(fig1) # 对点云进行缩放以显示 p1 = (query * 1.5 + np.array([1.0, 1.0, 1.0])) * 50.0 p2 = (supports * 1.5 + np.array([1.0, 1.0, 1.0])) * 50.0 l1 = p1[:, 2] * 0 # query中所有点设置为0 l1[file_i] = 1 # 第file_i个中心点,设置为1 l2 = p2[:, 2] * 0 + 2 # supports中所有点设置为2 l2[neighbors[file_i]] = 3 # 第file_i个邻居点组设置为3 # 显示点云 activations = mlab.points3d(p1[:, 0], p1[:, 1], p1[:, 2], l1, scale_factor=2.0, scale_mode='none', vmin=0.0, vmax=3.0, figure=fig1) activations = mlab.points3d(p2[:, 0], p2[:, 1], p2[:, 2], l2, scale_factor=3.0, scale_mode='none', vmin=0.0, vmax=3.0, figure=fig1) mlab.title(str(file_i), color=(0, 0, 0), size=0.3, height=0.01) text = '<--- (press g for previous)' + 50 * ' ' + '(press h for next) --->' mlab.text(0.01, 0.01, text, color=(0, 0, 0), width=0.98) mlab.orientation_axes() return
def test_reconstruct(): """Read a OBJ file, reconstruct it's surface using VTK and plot """ filename = './data/shape_model/ITOKAWA/itokawa_low.obj' ratio = 0.5 v, f = wavefront.read_obj(filename) dv, df = wavefront.decimate_numpy(v, f, ratio) rv, rf = wavefront.reconstruct_numpy(v) # create some figures orig_fig = mlab.figure() reconstruct_fig = mlab.figure() _ = graphics.draw_polyhedron_mayavi(v, f, orig_fig) mlab.title('Original OBJ') _ = graphics.draw_polyhedron_mayavi(rv, rf, reconstruct_fig) mlab.title('Reconstructed OBJ') # display both and complete test print('Now compare the two images')
def show_grasps_range(obj, grasps, ply_name=None, min_score=0.0, max_score=3.2): m = np.array(grasps) m = m[m[:, 1] < max_score] m = m[m[:, 1] >= min_score] if not len(m) > 0: return m = m[np.random.choice(len(m), size=5, replace=True)] # 随机选择25个显示 ags = GpgGraspSampler(gripper, sample_config) mlab.figure(bgcolor=(1, 1, 1), fgcolor=(0.7, 0.7, 0.7), size=(1024, 768)) for grasp in m: ags.display_grasps3d(grasp[0], 'g') if ply_name is None: ags.show_surface_points(obj) else: mlab.pipeline.surface(mlab.pipeline.open(ply_name)) print("Show [%.1f-%.1f)" % (min_score, max_score)) mlab.title("[%.1f-%.1f)" % (min_score, max_score), size=0.5, color=(0, 0, 0)) mlab.show()
def plot_3d(index, data): if not contour_toggle_3d: grid = mlab.pipeline.scalar_field(data) vol = mlab.pipeline.volume(grid, vmin=1e-06) # Change the opacity to something more reasonable otf = PiecewiseFunction() otf.add_point(0.0, 0.0) otf.add_point(0.315, 0.3) vol._otf = otf vol._volume_property.set_scalar_opacity(otf) else: mlab.contour3d(data, transparent=True) mlab.axes() mlab.title(" ".join([field, "mcs = %d" % (index * output_frequency)]), size=1, opacity=0.8) mlab.colorbar(orientation="vertical") mlab.show() return
def title(text, color=(0, 0, 0), size=0.3, height=1): """ Draw a title on a Mayavi figure. .. warning:: Must be called **after** you've plotted something (e.g., prisms) to the figure. This is a bug. Parameters: * text : str The title * color : tuple = (r, g, b) RGB of the color of the text * size : float The size of the text * height : float The height where the title will be placed on the screen """ _lazy_import_mlab() mlab.title(text, color=color, size=size, height=height)
def t_data_plot(data,dataname,title_name,num_contours,zdr_flag=0,data_min=1.01): #camera1=(0.0,0.0,307.7645695540192,np.array([ 79.66195959, 74.22460988,9.96509266])) #camera2=(45.00000000000005,54.735610317245346,389.61669188814807,np.array([61.00005691,87.63795239,6.8619907])) camera3=(45.0,54.735610317245346,607.35769190957262,np.array([89.80421373,137.88978957,7.30599671])) size_x,size_y,size_z=data.shape mlab.figure(dataname,bgcolor=(1,1,1),fgcolor=(0,0,0),size=(700,600)) if zdr_flag==1: fig_data=mlab.contour3d(data[:,:,:],vmin=data_min,colormap='jet') else: fig_data=mlab.contour3d(data[:,:,:],vmin=-30.0,colormap='jet') fig_data.contour.number_of_contours=num_contours fig_data.actor.property.opacity=0.4 mlab.title(dataname) mlab.outline(color=(0,0,0),extent=[0,size_x,0,size_y,0,size_z]) colorbar=mlab.colorbar(title=title_name,orientation='vertical',nb_labels=10) colorbar.scalar_bar_representation.position=[0.85,0.1] colorbar.scalar_bar_representation.position2=[0.12,0.9] mlab.view(*camera3) mlab.show()
def plot_accuracy(subject_name, subjects_dir, dir_n, elec_up, mlabViewX, mlabViewY, saveDataBool): #make info file ch_names = [str(x) for x in np.arange(64)] dig_ch_pos = dict(zip(ch_names, elec_up / 1000)) mon = mne.channels.DigMontage(dig_ch_pos=dig_ch_pos) info = mne.create_info(ch_names, 1000., ch_types='ecog', montage=mon) name = listdir(dir_n) for nam in name: if nam != '.DS_Store': s = np.loadtxt(dir_n + nam) s = np.nan_to_num(s[:, 1]) fig = mlab.figure('accuracy_' + nam, size=(800, 700)) plot_alignment(info, subject=subject_name, subjects_dir=subjects_dir, surfaces=['pial'], ecog=False, fig=fig) obj = mlab.points3d(elec_up[:, 0] / 1000, elec_up[:, 1] / 1000, elec_up[:, 2] / 1000, s, colormap='rainbow', scale_mode='none', scale_factor=0.002) mlab.colorbar(object=obj, title='accuracy', orientation='vertical', nb_labels=8, nb_colors=None, label_fmt=None) mlab.title(nam[:-4], size=0.2, height=0.015) #chouse point of view mlab.view(mlabViewX, mlabViewY) if saveDataBool: mlab.savefig(nam[:-4] + '.png') mlab.savefig(nam[:-4] + '.x3d')
def plot_alpha_touch(subject_name, subjects_dir, file_n, elec_up, mlabViewX, mlabViewY, saveDataBool): #make info file ch_names = [str(x) for x in np.arange(64)] dig_ch_pos = dict(zip(ch_names, elec_up / 1000)) mon = mne.channels.DigMontage(dig_ch_pos=dig_ch_pos) info = mne.create_info(ch_names, 1000., ch_types='ecog', montage=mon) data_t = loadmat(file_n) res_re = data_t['res'] for i in range(5): s = np.mean(res_re[:, :5, i], axis=1) #alpha s = np.interp(s, (s.min(), s.max()), (0, 1)) fig = mlab.figure('alpha_touch_' + str(i), size=(800, 700)) plot_alignment(info, subject=subject_name, subjects_dir=subjects_dir, surfaces=['pial'], ecog=False, fig=fig) obj = mlab.points3d(elec_up[:, 0] / 1000, elec_up[:, 1] / 1000, elec_up[:, 2] / 1000, s, colormap='rainbow', scale_mode='none', scale_factor=0.002) mlab.colorbar(object=obj, title='alpha', orientation='vertical', nb_labels=8, nb_colors=None, label_fmt=None) mlab.title('touch ' + str(i + 1), size=0.2, height=0.015) #chouse point of view mlab.view(mlabViewX, mlabViewY) if saveDataBool: mlab.savefig('alpha_touch_' + str(i + 1) + '.png') mlab.savefig('alpha_touch_' + str(i + 1) + '.x3d')
def plot_u(u, x, y, t, n, do=False, save_plot=False): """User action function for plotting.""" if do == False: return 0 else: if t[n] == 0: time.sleep(2) # Mayavi visualization mlab.clf() extent1 = (0, 20, 0, 20, -2, 2) s = mlab.surf(x, y, u, colormap='Blues', extent=extent1) mlab.axes(s, color=(.7, .7, .7), extent=extent1, ranges=(0, 10, 0, 10, -1, 1), xlabel='', ylabel='', zlabel='', x_axis_visibility=False, z_axis_visibility=False) mlab.outline(s, color=(0.7, .7, .7), extent=extent1) mlab.text(6, -2.5, '', z=-4, width=0.14) mlab.colorbar(object=None, title=None, orientation='horizontal', nb_labels=None, nb_colors=None, label_fmt=None) mlab.title('Waves t=%g' % t[n]) mlab.view(142, -72, 50) f = mlab.gcf() camera = f.scene.camera camera.yaw(0) time.sleep(0) # pause between frames if save_plot: filename = 'tmp_%04d.png' % n mlab.savefig('./animations/' + filename) # time consuming! mlab.show()
def test4_1(): # 场景初始化 figure = mlab.gcf() # 用mlab.points3d建立红色和白色小球的集合 x1, y1, z1 = np.random.random((3, 10)) red_glyphs = mlab.points3d(x1, y1, z1, color = (1, 0, 0), resolution = 10) x2, y2, z2 = np.random.random((3, 10)) white_glyphs = mlab.points3d(x2, y2, z2, color = (0.9, 0.9, 0.9), resolution = 10) outline = mlab.outline(line_width = 3) outline.outline_mode = "cornered" outline.bounds = (x1[0] - 0.1, x1[0] + 0.1, y1[0] - 0.1, y1[0] + 0.1, z1[0] - 0.1, z1[0] + 0.1, ) # 处理选取的事件 glyph_points = red_glyphs.glyph.glyph_source.glyph_source.output.points.to_array() def picker_callback(picker): if picker.actor in red_glyphs.actor.actors: point_id = int(picker.point_id / glyph_points.shape[0]) if point_id != -1: x, y, z = x1[point_id], y1[point_id], z1[point_id] outline.bounds = (x - 0.1, x + 0.1, y - 0.1, y + 0.1, z - 0.1, z + 0.1, ) # 建立相应机制 picker = figure.on_mouse_pick(picker_callback) mlab.title("click on the red balls") mlab.show()
def plot_time_instance(path,t,value,var_num,plot_specs_dict): # make one plot at fixed time with multiple slices #f = mlab.figure(size=(2000,1500)) f = mlab.figure(size=(400,300)) file_list = value.split() num_eqn = int(plot_specs_dict['num_eqn']) minval = plot_specs_dict['minval'][var_num] maxval = plot_specs_dict['maxval'][var_num] for file_name in file_list: plot_slice(path,file_name,f,var_num,num_eqn,minval,maxval) mlab.title('Solution at t=' + str(t) + '\n q ' + str(var_num+1),\ size=0.25) cube_range = [plot_specs_dict['domain'][0][0], plot_specs_dict['domain'][0][1], plot_specs_dict['domain'][1][0], plot_specs_dict['domain'][1][1], plot_specs_dict['domain'][2][0], plot_specs_dict['domain'][2][1]] mlab.axes(extent = cube_range, line_width=3.0) ax = mlab.colorbar(orientation='vertical') mlab.outline(line_width=0.02) #f.scene.x_minus_view() binary_list = [-1,1] for j in binary_list: for k in binary_list: for l in binary_list: f.scene._update_view(j, k, l, 0, 0, 0) save_filename = 'test_output_' + str(j) + '_'\ + str(k) + '_'\ + str(l) + '_'\ + str(t) + '.png' mlab.show() #mlab.savefig(save_filename) f.scene.close() return None
def plot_with_labels(data, label, subsample=None, size=1, color={}, title='', img=None, img_path=None): """ data: Nx3 numpy array label: N, numpy array subsample: number of subsampled input point cloud size: size of points color: dict int->tuple(3) """ if img is not None: img_path = os.path.join(os.environ['HOME'], 'tmp', 'tmp.jpg') cv.imwrite(img_path, img) if img_path is not None: p = subprocess.Popen(['eog', img_path]) if subsample is not None and subsample < data.shape[0]: ids = np.random.choice(data.shape[0], subsample, replace=False) data = data[ids] label = label[ids] _plot_color(data, label, 0.01*size, color=color) if title: mlab.title(title) mlab.show() if img_path is not None: p.wait()
def plot_with_cmap(data, color, num_bins=10, subsample=None, size=1, title=''): """ data: Nx3 numpy array color: N, numpy array num_bins: int, discretize color into num_bins bins subsample: int, number of subsampled input point cloud """ if subsample is not None and subsample < data.shape[0]: ids = np.random.choice(data.shape[0], subsample, replace=False) data = data[ids] color = color[ids] assert data.shape[0] == len(color) cmap = plt.cm.get_cmap('Spectral') c1, c2 = float(min(color)), float(max(color)) color = (color-c1) / (c2-c1) EPS = 1e-4 bins = np.linspace(-EPS, 1+EPS, num_bins+1) for i in xrange(num_bins): x = data[(color >= bins[i]) & (color < bins[i+1])] c = cmap(1-bins[i])[:3] mlab.points3d(x[:,0], x[:,1], x[:,2], color=c, scale_factor=0.01*size) if title: mlab.title(title) mlab.show()
def vis_multiple(multi_points, save_folder, save_name, normalize=True, save_gif=True, delete=False, show=False): # points = np.loadtxt(full_path, delimiter=',') # points = points[:50, :] fig = mlab.figure(size=(1024, 1024)) for idx, points in enumerate(multi_points): if normalize: points[:, :3] = pc_normalize(points[:, :3]) x, y, z = np.split(points[:, :3], 3, axis=-1) # vx, vy, vz = np.split(points[:, 3:], 3, axis=-1) if save_gif: fig.scene.movie_maker.record = True fig.scene.movie_maker.directory = './' selected_color = colors[idx] s = points3d(x, y, z, color=selected_color, scale_factor=0.01, opacity=0.5) # mlab.quiver3d(x, y, z, vx, vy, vz, mode='arrow', scale_factor=0.03) # ms = s.mlab_source # animate(ms, points, transformer) axes = mlab.axes() axes.axes.fly_mode = 'none' axes.axes.bounds = np.array([0, 0.4, 0.4, 0., 0., 0.4]) mlab.title(save_name, size=0.1) if show: mlab.show() if save_gif: save(save_name=save_name, images_folder=save_folder, delete=delete)
def streammesh(self,nx=30,ny=30,color=False,**kwargs): """ Plots streamlines originating from points on a mesh """ # Create a new scene if there isn't one if not self.__dict__.has_key('fig'): self.newscene() if not self.vector_overlay: self.loadVectorVTK() if color: src = mlab.pipeline.cell_to_point_data(self.ug) # This colours the streamlines by the scalar field else: src = mlab.pipeline.add_dataset(self.ug) X = np.linspace(self.xv.min(),self.xv.max(),nx) y0 =self.yv.min() y1 = self.yv.max() streams=[] for x in X: stream=mlab.pipeline.streamline(src,seedtype='line',**kwargs) stream.stream_tracer.initial_integration_step = 0.1 stream.stream_tracer.maximum_propagation=10000.0 stream.stream_tracer.integration_direction = 'both' stream.seed.widget.point1 = [x,y1,0.1] stream.seed.widget.point2 = [x,y0,0.1] stream.seed.widget.resolution = ny streams.append(stream) # Go back through and turn them off for stream in streams: stream.seed.widget.enabled = False # Add a colorbar if the isn't one if not self.__dict__.has_key('cb'): self.h=stream self.colorbar() # Add a title if there isn't one if not self.__dict__.has_key('title'): self.title=mlab.title(self._SpatialgenTitle(),height=0.95,size=0.15) return streams
def plot_events(cluster,locs,stations,x,y,z,i,threshold,nbmin,area,nbsta): from mayavi import mlab # Stations coordinates xsta,ysta,zsta=[],[],[] for sta in sorted(stations): xsta.append(stations[sta]['x']) ysta.append(stations[sta]['y']) zsta.append(stations[sta]['elev']) z_ph=[-elt for elt in z] # Initial hypocentral parameters xini, yini, zini, zini_ph, to_ini = coord_cluster(cluster[i],locs) s=mlab.figure(i,bgcolor=(1,1,1),fgcolor=(0,0,0),size=(1000,900)) mlab.clf() s=mlab.points3d(xini,yini,zini_ph,color=(1,1,0),scale_factor=0.2) # yellow : initial locations s=mlab.points3d(xsta,ysta,zsta,color=(1,0,0),scale_factor=0.05,mode='cube') s=mlab.points3d(x,y,z_ph,color=(0,1,1),scale_factor=0.2) # cyan : new locations s=mlab.axes(extent=area,color=(0,0,0)) # axe des z positif vers le haut s=mlab.outline(extent=area,color=(0,0,0)) s=mlab.title("cluster=%s, threshold=%s, nbmin=%s"%(i,threshold,nbmin),height=0.1,size=0.35,color=(0,0,0)) if len(cluster[i]) < 20: from CZ_W_2_color import * for ind_I in range(len(cluster[i])): for ind_J in range(ind_I+1,len(cluster[i])): ev_I=cluster[i][ind_I]-1 ev_J=cluster[i][ind_J]-1 W_IJ=nbsta[ev_I,ev_J] if W_IJ >= nbmin: mlab.points3d(xini[ind_J],yini[ind_J],zini_ph[ind_J],scale_factor=0.1,color=(0,0,0)) mlab.points3d(xini[ind_I],yini[ind_I],zini_ph[ind_I],scale_factor=0.1,color=(0,0,0)) d=(xini[ind_J]-xini[ind_I],yini[ind_J]-yini[ind_I],zini_ph[ind_J]-zini_ph[ind_I]) norm=np.sqrt(d[0]**2+d[1]**2+d[2]**2) s2=mlab.quiver3d(xini[ind_I],yini[ind_I],zini_ph[ind_I],d[0],d[1],d[2],color=tuple(CZ_W_2_color(W_IJ)),mode='2ddash',scale_factor=norm,scale_mode='scalar') mlab.show()
def sliceplane(self,plane_orientation='y_axes',**kwargs): """ Applies the image plane widget to the dataset """ if self.clim==None: self.clim = [self.data.min(), self.data.max()] # Create a new scene if there isn't one if not self.__dict__.has_key('fig'): self.newscene() src = mlab.pipeline.cell_to_point_data(self.ug) self.h=mlab.pipeline.scalar_cut_plane(src,plane_orientation=plane_orientation,view_controls=True,line_width=0.5) # Add a colorbar if the isn't one if not self.__dict__.has_key('cb'): self.colorbar() # Add a title if there isn't one if not self.__dict__.has_key('title'): self.title=mlab.title(self._SpatialgenTitle(),height=0.95,size=0.15)
def surface(self,clim=None,**kwargs): """ Surface plot of the scalar in the 'data' attribute with mayavi Works on the 2D and 3D data """ if clim==None: clim = [self.data.min(), self.data.max()] # Create a new scene if there isn't one if not self.__dict__.has_key('fig'): self.newscene() src = mlab.pipeline.add_dataset(self.ug) self.h=mlab.pipeline.surface(src,vmin=clim[0],vmax=clim[1],**kwargs) # Add a colorbar if the isn't one if not self.__dict__.has_key('cb'): self.colorbar() # Add a title if there isn't one if not self.__dict__.has_key('title'): self.title=mlab.title(Spatial.genTitle(self),height=0.95,size=0.15)
def plot_dipole_locations(dipoles, trans, subject, subjects_dir=None, bgcolor=(1, 1, 1), opacity=0.3, brain_color=(0.7, 0.7, 0.7), mesh_color=(1, 1, 0), fig_name=None, fig_size=(600, 600), mode='cone', scale_factor=0.1e-1, colors=None, verbose=None): """Plot dipole locations Only the location of the first time point of each dipole is shown. Parameters ---------- dipoles : list of instances of Dipole | Dipole The dipoles to plot. trans : dict The mri to head trans. subject : str The subject name corresponding to FreeSurfer environment variable SUBJECT. subjects_dir : None | str The path to the freesurfer subjects reconstructions. It corresponds to Freesurfer environment variable SUBJECTS_DIR. The default is None. bgcolor : tuple of length 3 Background color in 3D. opacity : float in [0, 1] Opacity of brain mesh. brain_color : tuple of length 3 Brain color. mesh_color : tuple of length 3 Mesh color. fig_name : str Mayavi figure name. fig_size : tuple of length 2 Mayavi figure size. mode : str Should be ``'cone'`` or ``'sphere'`` to specify how the dipoles should be shown. scale_factor : float The scaling applied to amplitudes for the plot. colors: list of colors | None Color to plot with each dipole. If None default colors are used. verbose : bool, str, int, or None If not None, override default verbose level (see mne.verbose). Returns ------- fig : instance of mlab.Figure The mayavi figure. Notes ----- .. versionadded:: 0.9.0 """ from mayavi import mlab from matplotlib.colors import ColorConverter color_converter = ColorConverter() trans = _get_mri_head_t(trans)[0] subjects_dir = get_subjects_dir(subjects_dir=subjects_dir, raise_error=True) fname = os.path.join(subjects_dir, subject, 'bem', 'inner_skull.surf') points, faces = read_surface(fname) points = apply_trans(trans['trans'], points * 1e-3) from .. import Dipole if isinstance(dipoles, Dipole): dipoles = [dipoles] if mode not in ['cone', 'sphere']: raise ValueError('mode must be in "cone" or "sphere"') if colors is None: colors = cycle(COLORS) fig = mlab.figure(size=fig_size, bgcolor=bgcolor, fgcolor=(0, 0, 0)) with warnings.catch_warnings(record=True): # FutureWarning in traits mlab.triangular_mesh(points[:, 0], points[:, 1], points[:, 2], faces, color=mesh_color, opacity=opacity) for dip, color in zip(dipoles, colors): rgb_color = color_converter.to_rgb(color) with warnings.catch_warnings(record=True): # FutureWarning in traits mlab.quiver3d(dip.pos[0, 0], dip.pos[0, 1], dip.pos[0, 2], dip.ori[0, 0], dip.ori[0, 1], dip.ori[0, 2], opacity=1., mode=mode, color=rgb_color, scalars=dip.amplitude.max(), scale_factor=scale_factor) if fig_name is not None: mlab.title(fig_name) if fig.scene is not None: # safe for Travis fig.scene.x_plus_view() return fig
import os.path as op from mayavi import mlab import mne from mne.io import Raw, read_raw_ctf, read_raw_bti, read_raw_kit from mne.datasets import sample, spm_face from mne.viz import plot_trans print(__doc__) bti_path = op.abspath(op.dirname(mne.__file__)) + '/io/bti/tests/data/' kit_path = op.abspath(op.dirname(mne.__file__)) + '/io/kit/tests/data/' raws = dict( Neuromag=Raw(sample.data_path() + '/MEG/sample/sample_audvis_raw.fif'), CTF_275=read_raw_ctf(spm_face.data_path() + '/MEG/spm/SPM_CTF_MEG_example_faces1_3D.ds'), Magnes_3600wh=read_raw_bti(bti_path + 'test_pdf_linux', bti_path + 'test_config_linux', bti_path + 'test_hs_linux'), KIT=read_raw_kit(kit_path + 'test.sqd'), ) for system, raw in raws.items(): # We don't have coil definitions for KIT refs, so exclude them ref_meg = False if system == 'KIT' else True fig = plot_trans(raw.info, trans=None, dig=False, eeg_sensors=False, meg_sensors=True, coord_frame='meg', ref_meg=ref_meg) mlab.title(system)
def title(*args, **kwargs): mlab.title(*args, **kwargs)
def envelopes3d_group_by(results, outcome, groupBy = 'policy', discretesize = None, logSpace=False, ymin = None, ymax = None): ''' Function for making 3d envelopes. In contrast to the envelopes in :mod:`graphs`, this version shows the density for every time step, instead of only for the end state. Note that this function makes an envelope for only 1 outcome. This envelopes will group the results based on the specified uncertainty. The user can supply a discretesize function to control the grouping in case of parameterUncertainties. This function will make a separate envelope for each group. :param results: The return from :meth:`run experiments`. :param outcome: Specify the name of outcome of interest for which you want to make the 3d envelopes. :param groupBy: The uncertainty to group by. (default=policy) :param discretesize: a discretesize function to control the grouping in case of parameterUncertainties :param logSpace: Boolean, if true, the log of the input data is used :param ymin: If provided, lower bound for the KDE, if not, ymin = np.min(results.get(outcome)) :param ymax: If provided, lower bound for the KDE, if not, ymax = np.max(results.get(outcome)) ''' def f(x, y, results): """ function that performs the kde for each timestep """ x1 = x[:,0] y1 = y[0,:] results = np.asarray(results) z = [] for i in range(len(list(x1))): data = results[:, i] try: z1 = kde.gaussian_kde(data) z1 = z1.evaluate(y1) except: z1 = np.zeros(shape=y1.shape) z.append(z1) z = np.asarray(z) z = np.log(z+1) return z #prepare the data experiments, results = results #get time axis try: time = results.pop('TIME')[0, :] except: time = np.arange(0, results.values()[0].shape[1]) def make_logical(cases, criterion, interval=False): if interval: return (cases[groupBy] >= criterion[0]) & (cases[groupBy] < criterion[1]) else: return cases[groupBy]== criterion #get the results for the specific outcome of interest results = results.get(outcome) #log results if logSpace: results = np.log(results+1) #generate the grid if ymin == None: ymin = np.min(results) info("ymin: %s" % ymin) if ymax == None: ymax = np.max(results) info("ymax: %s" % ymax) length = min(100, results.shape[1]) y = np.arange(ymin, ymax, (ymax-ymin)/length) X, Y = np.meshgrid(time, y) z = [] #do the preparation for grouping by interval=False if (experiments[groupBy].dtype == np.float32) |\ (experiments[groupBy].dtype == np.float64) |\ ((experiments[groupBy].dtype == np.int) & (len(set(experiments[groupBy])) > 5)): interval=True if discretesize: categories = discretesize(experiments[groupBy]) else: categories = make_continuous_grouping_specifiers(experiments[groupBy]) else: categories = set(experiments[groupBy]) for category in categories: if interval: info("calculating kde for (%s, %s)" % (category)) else: info("calculating kde for %s" % (category)) logical = make_logical(experiments, category, interval) Z = f(X.T,Y.T, results=results[logical]) z.append(Z) #calculate the kde for the grid #visualize results fig = mlab.figure(1, bgcolor=(1, 1, 1), fgcolor=(0, 0, 0)) fig.scene.disable_render = True for i, category in enumerate(categories): if interval: info("plotting (%s, %s)" % (category)) else: info("plotting %s" % (category)) Z = z[i] extent = (-14+i*10,-6+i*10, 0,10, 0,5) s = mlab.mesh(X,Y, Z.T, extent=extent) mlab.outline(s, color=(.7, .7, .7), extent=extent) if i==0: mlab.axes(s, extent=extent, xlabel = '', ylabel = '', zlabel = 'density', x_axis_visibility=False, y_axis_visibility=False, z_axis_visibility=False) category_name = repr(category) mlab.text(-16+10*i, i+10, category_name, z=-2, width=0.14) fig.scene.disable_render = False mlab.title(outcome, line_width=0.5) mlab.show()
def plot_3D_spectrum(infile="bloch.tmp", outfile=None, trajectory=None, reorder=False, jump=100., mayavi=False, limits=None, sort=False, png=None, full=False, dryrun=False, interpolate=False): """Visualize the eigenvalue spectrum with mayavi.mlab's mesh (3D) and matplotlib's pcolormesh (2D). Parameters: ----------- infile: str Input file. outfile: str Whether to save the reordered and sorted array before plotting. reorder: bool Whether to properly sort the input array. jump: float Whether to remove jump in the eigenvalue surface that exceed a given value. mayavi: bool Whether to produce 3D plots. If false, heatmaps are plotted. limits: list Set the x- and ylim: [xmin, xmax, ymin, ymax] sort: bool Sorts the eigenvalues such that one is larger than the other. png: str Save the heatmap plots in a .png file. full: bool Add additional heatmap plots. trajectory: str Plot a trajectory on top of the heatmap. dryrun: bool Whether to only return the approximate EP position. interpolate: bool Whether to interpolate |K0-K1| before printing the EP position. """ eps, delta, ev0r, ev0i, ev1r, ev1i = np.loadtxt(infile).T ev0 = ev0r + 1j*ev0i ev1 = ev1r + 1j*ev1i # workound if precision changes for multiple runs delta = np.around(delta, decimals=8) len_eps, len_delta = [len(np.unique(x)) for x in eps, delta] if reorder: print "reordering..." eps, delta, ev0, ev1 = reorder_file(infile) if sort: tmp0, tmp1 = 1.*ev0, 1.*ev1 tmp0[ev1 > ev0] = ev1[ev1 > ev0] tmp1[ev1 > ev0] = ev0[ev1 > ev0] ev0, ev1 = 1.*tmp0, 1.*tmp1 # get eps/delta meshgrid try: eps, delta, ev0, ev1 = [x.reshape(len_eps, len_delta) for x in (eps, delta, ev0, ev1)] except ValueError as e: print "Data matrix has missing values. Removing outliers:" mask = find_outliers(eps) len_masked_eps = len(np.unique(eps[mask])) eps, delta, ev0, ev1 = [x[mask].reshape(len_masked_eps, -1) for x in (eps, delta, ev0, ev1)] # set x/y limits if limits: eps_min, eps_max = limits[:2] delta_min, delta_max = limits[2:] limit_mask = ((eps > eps_min) & (eps < eps_max) & (delta > delta_min) & (delta < delta_max)) for X in ev0, ev1: X[~limit_mask] = np.nan if outfile: v = (eps, delta, ev0.real, ev0.imag, ev1.real, ev1.imag) v = np.array([x.flatten() for x in v]) np.savetxt(outfile, v.T, fmt='%.18f') sys.exit() # remove Nan values ev0 = np.ma.masked_where(np.isnan(ev0), ev0) ev1 = np.ma.masked_where(np.isnan(ev1), ev1) # print minimum of eigenvalue difference i, j = np.unravel_index(np.sqrt((ev0.real-ev1.real)**2 + (ev0.imag-ev1.imag)**2).argmin(), ev0.shape) print "Approximate EP location:" print "eps_EP =", eps[i, j] print "delta_EP =", delta[i, j] if dryrun and not interpolate: sys.exit() cmap = plt.get_cmap('Blues_r') cmap = plt.get_cmap('RdBu_r') if mayavi: # extent = (0, 1, 0, 1, 0, 1) # real part for e in ev0, ev1: mask = np.zeros_like(eps).astype(bool) mask[np.abs(np.diff(e.real, axis=0)) > jump] = True mask[np.abs(np.diff(e.real, axis=1)) > jump] = True try: mask = np.logical_or(mask, ~limit_mask) except: pass mlab.figure(0, bgcolor=(0.5, 0.5, 0.5)) m1 = mlab.mesh(eps.real, delta.real, e.real, mask=mask) # extent=extent) m1.actor.actor.scale = (1,1,0.1) mlab.title("Real part", opacity=0.25) mlab.axes(color=(0, 0, 0), nb_labels=3, xlabel="epsilon", ylabel="delta", zlabel="Re(K)") # imag part for e in ev0, ev1: mask = np.zeros_like(eps).astype(bool) mask[np.abs(np.diff(e.imag, axis=0)) > jump] = True mask[np.abs(np.diff(e.imag, axis=1)) > jump] = True mlab.figure(1, bgcolor=(0.5, 0.5, 0.5)) try: mask = np.logical_or(mask, ~limit_mask) except: pass m2 = mlab.mesh(eps.real, delta.real, e.imag, mask=mask) # extent=extent) m2.actor.actor.scale = (1,1,10) mlab.title("Imaginary part", opacity=0.25) mlab.axes(color=(0, 0, 0), nb_labels=3, xlabel="epsilon", ylabel="delta", zlabel="Im(K)") mlab.show() elif full: f, axes = plt.subplots(nrows=4, ncols=2, sharex=True, sharey=True) (ax1, ax2), (ax3, ax4), (ax5, ax6), (ax7, ax8) = axes plt.xticks(rotation=70) plt.suptitle(infile) ax1.set_title(r"$\Re K_0$") im1 = ax1.pcolormesh(eps, delta, ev0.real, cmap=cmap) ax2.set_title(r"$\Im K_0$") im2 = ax2.pcolormesh(eps, delta, ev0.imag, cmap=cmap) ax3.set_title(r"$\Re K_1$") im3 = ax3.pcolormesh(eps, delta, ev1.real, cmap=cmap) ax4.set_title(r"$\Im K_1$") im4 = ax4.pcolormesh(eps, delta, ev1.imag, cmap=cmap) ax5.set_title(r"$|\Re K_0 - \Re K_1|^2$") Z_real = abs(ev1.real - ev0.real) im5 = ax5.pcolormesh(eps, delta, Z_real, cmap=cmap, vmin=0) ax6.set_title(r"$|\Im K_0 - \Im K_1|^2$") Z_imag = abs(ev1.imag - ev0.imag) im6 = ax6.pcolormesh(eps, delta, Z_imag, cmap=cmap, vmin=0) Z = np.sqrt(Z_imag**2 + Z_real**2) ax7.set_title(r"$\sqrt{(\Re K_0 - \Re K_1)^2 + (\Im K_0 - \Im K_1)^2}$") im7 = ax7.pcolormesh(eps, delta, Z, cmap=cmap, vmin=0) Z = (Z_imag**2 + Z_real**2)**0.25 ax8.set_title(r"$\sqrt[4]{(\Re K_0 - \Re K_1)^2 + (\Im K_0 - \Im K_1)^2}$") im8 = ax8.pcolormesh(eps, delta, Z, cmap=cmap, vmin=0) for im, ax in zip((im1, im2, im3, im4, im5, im6, im7, im8), (ax1, ax2, ax3, ax4, ax5, ax6, ax7, ax8)): ax.set_xlabel("epsilon") ax.set_ylabel("delta") ax.set_xlim(eps.min(), eps.max()) ax.set_ylim(delta.min(), delta.max()) f.colorbar(im, ax=ax) plt.setp(ax.xaxis.get_majorticklabels(), rotation=45) plt.tight_layout() if png: plt.savefig(png) else: plt.show() else: f, ax = plt.subplots(nrows=1, ncols=1, sharex=True, sharey=True) plt.xticks(rotation=90) plt.suptitle(infile) Z_real = abs(ev1.real - ev0.real) Z_imag = abs(ev1.imag - ev0.imag) Z = np.sqrt(Z_imag**2 + Z_real**2) ax.set_title(r"$\sqrt{(\Re K_0 - \Re K_1)^2 + (\Im K_0 - \Im K_1)^2}$") # add one column and row to meshgrids such that meshgrid doesn't cut # away any important data eps_u = np.unique(eps) delta_u = np.unique(delta) eps0, delta0 = np.meshgrid(np.concatenate((eps_u, [2*eps.max()])), np.concatenate((delta_u, [2*delta.max()]))) Z0 = np.c_[Z, Z[:, -1]] Z0 = np.vstack((Z0, Z0[-1])) if interpolate: from scipy.interpolate import griddata x = np.linspace(eps.min(), eps.max(), 500) y = np.linspace(delta.min(), delta.max(), 1000) X, Y = np.meshgrid(x, y) Z0 = griddata((eps.ravel(), delta.ravel()), Z.ravel(), (X, Y), method='cubic') i, j = np.unravel_index(Z0.argmin(), Z0.shape) print "eps_EP_interpolated =", X[i, j] print "delta_EP_interpolated =", Y[i, j] eps0, delta0 = X.T, Y.T if dryrun: sys.exit() # im = ax.pcolormesh(eps0.T, delta0.T, np.log(Z0), im = ax.pcolormesh(eps0.T, delta0.T, np.log(Z0), cmap=cmap) # correct ticks xoffset = np.diff(eps_u).mean()/2 yoffset = np.diff(delta_u).mean()/2 ax.set_xticks(eps_u + xoffset) ax.set_yticks(delta_u + yoffset) # ticklabels # ax.set_xticklabels(np.around(eps_u, decimals=4)) # ax.set_yticklabels(np.around(delta_u, decimals=4)) # axis labels ax.set_xlabel("epsilon") ax.set_ylabel("delta") if limits: print limits ax.set_xlim(limits[0], limits[1]) ax.set_ylim(limits[2], limits[3]) else: ax.set_xlim(eps.min(), eps.max() + 2*xoffset) ax.set_ylim(delta.min(), delta.max() + 2*yoffset) f.colorbar(im, ax=ax) plt.setp(ax.xaxis.get_majorticklabels(), rotation=45) plt.subplots_adjust(top=0.875) if trajectory: # n, eps, delta = np.loadtxt(trajectory, unpack=True)[:3] eps, delta = np.loadtxt(trajectory, unpack=True)[:2] plt.plot(eps, delta, "r-") # for n, (eps, delta) in enumerate(zip(eps, delta)): # plt.text(eps, delta, str(n), fontsize=12) if png: plt.savefig(png) else: plt.show()
def ToyModel3d(sample): """ This script configure the 3D render motor (Mayavi) to show an interactive reconstruction of the asphalt mixture sample """ src = mlab.pipeline.scalar_field(sample) inverse_lut = False colors = 5 iso = mlab.pipeline.iso_surface(src, contours=[1], opacity=0.4, colormap = 'blue-red') iso.module_manager.scalar_lut_manager.reverse_lut = inverse_lut iso.module_manager.scalar_lut_manager.number_of_colors = colors ipw = mlab.pipeline.image_plane_widget(src, plane_orientation='y_axes', slice_index=10, colormap = 'blue-red') ipw.module_manager.scalar_lut_manager.reverse_lut = inverse_lut ipw.module_manager.scalar_lut_manager.number_of_colors = colors scp = mlab.pipeline.scalar_cut_plane(src, colormap = 'blue-red') scp.module_manager.scalar_lut_manager.reverse_lut = inverse_lut scp.module_manager.scalar_lut_manager.number_of_colors = colors #Set the Mayavi Colorbar Ranges scp.module_manager.scalar_lut_manager.use_default_range = False scp.module_manager.scalar_lut_manager.scalar_bar.position2 = array([ 0.1, 0.8]) scp.module_manager.scalar_lut_manager.scalar_bar.position = array([ 0.01, 0.15]) scp.module_manager.scalar_lut_manager.data_range = array([ 0., 2.]) scp.module_manager.scalar_lut_manager.scalar_bar.position2 = array([ 0.1, 0.8]) scp.module_manager.scalar_lut_manager.scalar_bar.position = array([ 0.01, 0.15]) scp.module_manager.scalar_lut_manager.data_range = array([ 0., 2.]) engine = mlab.get_engine() textAggregate = Text() textMastic = Text() textVoids = Text() engine.add_filter(textAggregate, scp.module_manager) engine.add_filter(textMastic, ipw.module_manager) engine.add_filter(textVoids, iso.module_manager) textAggregate.text = 'Aggregate' textMastic.text = 'Mastic' textVoids.text = 'Air Voids' textAggregate.actor.text_scale_mode = 'viewport' textMastic.actor.text_scale_mode = 'viewport' textVoids.actor.text_scale_mode = 'viewport' textAggregate.actor.minimum_size = array([ 1, 10]) textMastic.actor.minimum_size = array([ 1, 10]) textVoids.actor.minimum_size = array([ 1, 10]) textAggregate.actor.position = array([ 0.115, 0.7 ]) textMastic.actor.position = array([ 0.115, 0.45]) textVoids.actor.position = array([ 0.115, 0.23]) mlab.orientation_axes() mlab.title("Asphalt Mixture Reconstruction", size=0.25) mlab.colorbar(title='Material', orientation='vertical', nb_labels=0, nb_colors=3) mlab.show()