def play(self, fileroot='Network', mspikes=[], gspikes=[], save_png=False, sim_step=10, windowsize=10): view = mlab.view() f = mlab.gcf() if not mspikes: mspikes = self.mspikes if not gspikes: gspikes = self.gspikes img_counter = 0 ts = sort(array([t for t in set(gspikes[:,0])])) # can use either spike set ts = ts[(ts > self.sim_start) * (ts < self.sim_end)] mqueue = []; gqueue = []; for t in ts[::sim_step]: self.t = t mlab.gcf().scene.disable_render=True timestamp = u"Time: %.1f" % (t) print timestamp if save_png: # Diplay time stamp f.name = timestamp try:ftitle.text = timestamp except:ftitle = mlab.title(timestamp) # Delete old spheres if len(mqueue) >= windowsize: mpts=mqueue.pop(0) mpts.parent.parent.remove() gpts=gqueue.pop(0) gpts.parent.parent.remove() # It would be great to make prevoius arrays dimmer # Plot activate spheres mqueue.append(self.plot_points(self.mx, self.my, self.mz, mspikes, t=t, color=(1., 1., 1.), csize = self.mcsize)) gqueue.append(self.plot_points(self.gx, self.gy, self.gz, gspikes, t=t, color=(1., 1., 1.), csize = self.gcsize)) mlab.view(view [0], view [1], view [2], view [3]) mlab.gcf().scene.disable_render=False if save_png: f.scene.save_png('img/%s_%03d.png' % (fileroot, img_counter)) img_counter += 1 return mqueue, gqueue
def run_mlab_file(filename, image_file): ## XXX: Monkey-patch mlab.show, so that we keep control of the ## the mainloop old_show = mlab.show def my_show(func=None): pass mlab.show = my_show mlab.clf() e = mlab.get_engine() e.close_scene(mlab.gcf()) execfile(filename, {'__name__': '__main__'}) mlab.savefig(image_file) size = mlab.gcf().scene.get_size() for scene in e.scenes: e.close_scene(scene) mlab.show = old_show
def evolve_visual3d(msnake, levelset=None, num_iters=20): """ Visual evolution of a three-dimensional morphological snake. Parameters ---------- msnake : MorphGAC or MorphACWE instance The morphological snake solver. levelset : array-like, optional If given, the levelset of the solver is initialized to this. If not given, the evolution will use the levelset already set in msnake. num_iters : int, optional The number of iterations. """ from enthought.mayavi import mlab if levelset is not None: msnake.levelset = levelset fig = mlab.gcf() mlab.clf() src = mlab.pipeline.scalar_field(msnake.data) mlab.pipeline.image_plane_widget(src, plane_orientation='x_axes', colormap='gray') cnt = mlab.contour3d(msnake.levelset, contours=[0.5]) for i in xrange(num_iters): msnake.step() cnt.mlab_source.scalars = msnake.levelset # Return the last levelset. return msnake.levelset
def m2screenshot(mayavi_fig=None, mpl_axes=None, autocrop=True): """ Capture a screeshot of the Mayavi figure and display it in the matplotlib axes. """ import pylab as pl # Late import to avoid triggering wx imports before needed. from enthought.mayavi import mlab if mayavi_fig is None: mayavi_fig = mlab.gcf() else: mlab.figure(mayavi_fig) if mpl_axes is not None: pl.axes(mpl_axes) filename = tempfile.mktemp(".png") mlab.savefig(filename, figure=mayavi_fig) image3d = pl.imread(filename) if autocrop: bg_color = mayavi_fig.scene.background image3d = autocrop_img(image3d, bg_color) pl.imshow(image3d) pl.axis("off") os.unlink(filename)
def display(self): """ Display Electrode in Mayavi """ f = mlab.figure(figure=mlab.gcf(), bgcolor=(0,0,0), size=(800,600)) # Build Electrode tip x, y, z = self.shaft[0,:].T self.mlab_tip = mlab.points3d(array(x), array(y), array(z), scale_factor=self.diameter, color=(0.5, 0.5, 0.5), name='Electrode Tip') self.mlab_tip.glyph.glyph_source.glyph_source.theta_resolution = 30 self.mlab_tip.glyph.glyph_source.glyph_source.phi_resolution = 16 # Build Electrode Shaft x, y, z = self.shaft.T self.mlab_shaft = mlab.plot3d(x.T, y.T, z.T, color=(0.5, 0.5, 0.5), tube_radius=self.diameter / 2, tube_sides=40, name='Electrode') self.mlab_shaft.parent.parent.filter.capping=True
def autoPositionCamera(): """ Set camera position looking along the x-axis. """ s = mlab.gcf().scene s.disable_render = True mlab.view(90,90,distance='auto',focalpoint='auto') mlab.roll(0) s.disable_render = False
def set_camera(): F = mlab.gcf() F.scene.camera.position = [-4.5084283567916916, 5.0826441241530347, 2.5157264953414766] F.scene.camera.focal_point = [0.0, 0.0, 0.50000002980232239] F.scene.camera.view_angle = 30.0 F.scene.camera.view_up = [0.20751975331326181, -0.19601355433774734, 0.9583914849896602] F.scene.camera.clipping_range = [3.2568212087935651, 11.823288751122519] F.scene.camera.compute_view_plane_normal() F.scene.render()
def plot_anat_3d(anat=None, anat_sform=None, scale=1, sulci_opacity=0.5, gyri_opacity=0.3, opacity=1, outline_color=None): fig = mlab.gcf() disable_render = fig.scene.disable_render fig.scene.disable_render = True if anat is None: anat, anat_sform, anat_max = _AnatCache.get_anat() ########################################################################### # Display the cortical surface (flattenned) anat_src = affine_img_src(anat, anat_sform, scale=scale, name='Anat') anat_src.image_data.point_data.add_array(_AnatCache.get_blurred()) anat_src.image_data.point_data.get_array(1).name = 'blurred' anat_blurred = mlab.pipeline.set_active_attribute( anat_src, point_scalars='blurred') cortex_surf = mlab.pipeline.set_active_attribute( mlab.pipeline.contour(anat_blurred), point_scalars='scalar') # XXX: the choice in vmin and vmax should be tuned to show the # sulci better cortex = mlab.pipeline.surface(cortex_surf, colormap='copper', opacity=opacity, vmin=4800, vmax=5000) cortex.enable_contours = True cortex.contour.filled_contours = True cortex.contour.auto_contours = False cortex.contour.contours = [0, 5000, 7227.8] #cortex.actor.property.backface_culling = True # XXX: Why do we do 'frontface_culling' to see the front. cortex.actor.property.frontface_culling = True cortex.actor.mapper.interpolate_scalars_before_mapping = True cortex.actor.property.interpolation = 'flat' # Add opacity variation to the colormap cmap = cortex.module_manager.scalar_lut_manager.lut.table.to_array() cmap[128:, -1] = gyri_opacity*255 cmap[:128, -1] = sulci_opacity*255 cortex.module_manager.scalar_lut_manager.lut.table = cmap if outline_color is not None: outline = mlab.pipeline.iso_surface( anat_blurred, contours=[0.4], color=outline_color) outline.actor.property.backface_culling = True fig.scene.disable_render = disable_render return cortex
def start_vtk(component): f = mlab.figure(size=(700,500)) m = mlab.test_mesh() scene = mlab.gcf().scene render_window = scene.render_window renderer = scene.renderer rwi = scene.interactor window = EnableVTKWindow(rwi, renderer, component = component, istyle_class = tvtk.InteractorStyleTrackballCamera, bgcolor = "transparent", event_passthrough = True, ) mlab.show()
def main(): # Create some x-y data series to plot x = linspace(-2.0, 10.0, 100) pd = ArrayPlotData(index = x) for i in range(5): pd.set_data("y" + str(i), jn(i,x)) # Create some line plots of some of the data plot = Plot(pd, bgcolor="none", padding=30, border_visible=True, overlay_border=True, use_backbuffer=False) plot.legend.visible = True plot.plot(("index", "y0", "y1", "y2"), name="j_n, n<3", color="auto") plot.plot(("index", "y3"), name="j_3", color="auto") plot.tools.append(PanTool(plot)) zoom = ZoomTool(component=plot, tool_mode="box", always_on=False) plot.overlays.append(zoom) # Create the mlab test mesh and get references to various parts of the # VTK pipeline f = mlab.figure(size=(600,500)) m = mlab.test_mesh() scene = mlab.gcf().scene render_window = scene.render_window renderer = scene.renderer rwi = scene.interactor plot.resizable = "" plot.bounds = [200,200] plot.padding = 25 plot.outer_position = [30,30] plot.tools.append(MoveTool(component=plot,drag_button="right")) container = OverlayPlotContainer(bgcolor = "transparent", fit_window = True) container.add(plot) # Create the Enable Window window = EnableVTKWindow(rwi, renderer, component=container, #istyle_class = tvtk.InteractorStyleSwitch, #istyle_class = tvtk.InteractorStyle, istyle_class = tvtk.InteractorStyleTrackballCamera, bgcolor = "transparent", event_passthrough = True, ) mlab.show() return window, render_window
def createVideo(filename, renderers, tMin, tMax, framerate=25, resolution=None): """ Create a video of a 3D visualisation. The video is created using the current MayaVi figure, which should be setup beforehand to correctly position the camera and any other elements that should be rendered. @param filename: Name of the video file to create. @param renderers: List of L{AnimatedRenderer} objects to use. @param tMin: Time from which to begin rendering. @param tMax: Time at which to stop rendering. @param framerate: Framerate of the video in frames per second. @param resolution: Resolution of the video (width, height). If not specified, the resolution of the current figure is used. """ if not isinstance(renderers, collections.Iterable): renderers = [renderers] figure = mlab.gcf() if resolution is not None: originalResolution = figure.scene.get_size() figure.scene.set_size(resolution) figure.scene.off_screen_rendering = True figure.scene.disable_render = True frameTimes = np.arange(tMin, tMax, 1.0/framerate) try: imageDir = tempfile.mkdtemp() for f,t in enumerate(frameTimes): for r in renderers: r.renderUpdate(t) framefile = os.path.join(imageDir, '%06d.png'%(f)) mlab.savefig(framefile, size=resolution) assert os.path.exists(framefile) retval = subprocess.call(['ffmpeg', '-f','image2', '-r', str(framerate), '-i', '%s'%os.path.join(imageDir,'%06d.png'), '-sameq', filename, '-pass','2']) finally: shutil.rmtree(imageDir) figure.scene.disable_render = False figure.scene.off_screen_rendering = False if resolution is not None: figure.scene.set_size(originalResolution)
def display(self): """ Display Electrode in Mayavi """ f = mlab.figure(figure=mlab.gcf(), bgcolor=(0,0,0), size=(800,600)) # Call Super Class Electrode.display(self) # Build electrode contacts c0 = find_new_point(self.sphere_center, self.direction, self.contact_height * 3 / 2) c1 = find_new_point(self.sphere_center, self.direction, self.contact_height * 7 / 2) c2 = find_new_point(self.sphere_center, self.direction, self.contact_height * 11 / 2) c3 = find_new_point(self.sphere_center, self.direction, self.contact_height * 15 / 2) contactCenters = array([c0, c1, c2, c3]) contact = [] for ii in xrange(4): topContact = find_new_point(contactCenters[ii,:], self.direction, self.contact_height / 2) bottomContact = find_new_point(contactCenters[ii,:], [-1 * ii for ii in self.direction], self.contact_height / 2) contact.append([bottomContact, topContact]) contact_array = array(contact) x, y, z = contact_array.T activity_array = array([ [self.contact0, self.contact0], [self.contact1, self.contact1], [self.contact2, self.contact2], [self.contact3, self.contact3]]) src = pipeline.scalar_scatter(x.T, y.T, z.T, activity_array) src.mlab_source.dataset.lines = array([[0, 1], [2, 3], [4, 5], [6, 7]]) src.name = 'Contacts' self.mlab_contacts = pipeline.tube(src, tube_radius=self.diameter * 1.03 / 2, tube_sides=40, name='DBS Contacts',) stripper = pipeline.stripper(self.mlab_contacts) surface = pipeline.surface(stripper) self.mlab_contacts.filter.capping = True surface.module_manager.scalar_lut_manager.lut_mode = 'RdBu' surface.module_manager.scalar_lut_manager.reverse_lut = True #surface.module_manager.scalar_lut_manager.use_default_range = False surface.module_manager.scalar_lut_manager.use_default_range = True surface.module_manager.scalar_lut_manager.data_range = array([-1., 1.])
def display(self): """ Display Nucleus in Mayavi """ # Create and display a triangular mesh from enthought.mayavi.mlab import triangular_mesh f = mlab.figure(figure=mlab.gcf(), bgcolor=(0,0,0), size=(800,600)) self.mlab_mesh = triangular_mesh(self.pts[:, 0], self.pts[:, 1], self.pts[:, 2], self.tris, color=self.color, name=self.name) # Visual Tweaks #self.mlab_mesh.actor.property.backface_culling = True self.mlab_mesh.parent.parent.filter.splitting = False
def display(self): """ Plot background field """ f = mlab.figure(figure=mlab.gcf(), bgcolor=(0,0,0), size=(800,600)) self.mpts0 = self.plot_points(self.mx, self.my, self.mz, color=(0.1, 0.1, 0.3), csize=self.mcsize) self.gpts0 = self.plot_points(self.gx, self.gy, self.gz, color=(0.1, 0.3, 0.1), csize=self.gcsize) self.mpts0.parent.parent.scene.z_plus_view()
def __init__( self, x0=0, y0=0, z0=0, scale=1.0, color=(0,1,0), line_width=3, **kwargs ): from enthought.mayavi import mlab fig = mlab.gcf() render = fig.scene.disable_render fig.scene.disable_render = True xx = x0 + scale / 200.0 * np.array( [ [ -49, -40, np.nan ], [ 51, 60, np.nan ], [ -60, -51, np.nan ], [ 40, 49, np.nan ], [ -30, 50, np.nan ], [ -40, 40, np.nan ], [ -50, 30, np.nan ], ] ) yy = y0 + scale / 200.0 * np.array( [ [ 10, 90, np.nan ], [ 10, 90, np.nan ], [ -90, -10, np.nan ], [ -90, -10, np.nan ], [ 100, 100, np.nan ], [ 0, 0, np.nan ], [ -100, -100, np.nan ], ] ) zz = z0 * np.ones_like( xx ) glyphs = [5], [0,2,4,5,6], [0,3], [0,2], [2,4,6], [1,2], [1], [0,2,5,6], [], [2] hh = [] for g in glyphs: i = np.array( [ i for i in range(7) if i not in g ] ) h = [] for x in -0.875, 0.125, 0.875: h += [ mlab.plot3d( scale * x + xx[i].flatten(), yy[i].flatten(), zz[i].flatten(), color=color, tube_radius=None, line_width=line_width, **kwargs ) ] hh += [h] self.glyphs = hh x = x0 + scale / 200.0 * np.array( [-81, -79, np.nan, -71, -69] ) y = y0 + scale / 200.0 * np.array( [-60, -40, np.nan, 40, 60] ) z = z0 * np.ones_like( x ) h = mlab.plot3d( x, y, z, color=color, line_width=line_width, tube_radius=None, **kwargs ) self.colon = h fig.scene.disable_render = render return
def __init__(self): HasTraits.__init__(self) self._scene = mlab.gcf().scene #self.q1 = mlab.quiver3d(-2.0,0.0,0.0,1.0,0.0,0.0, colormap='Reds',mode='arrow') #self.q2 = mlab.quiver3d(-1.0,0.0,0.0,1.0,0.0,0.0, colormap='Greens',mode='arrow') #self.q3 = mlab.quiver3d(0.0,0.0,0.0,1.0,0.0,0.0, colormap='Blues',mode='arrow') #self.q4 = mlab.quiver3d(1.0,0.0,0.0,1.0,0.0,0.0, colormap='Reds',mode='arrow') #self.q5 = mlab.quiver3d(2.0,0.0,0.0,1.0,0.0,0.0, colormap='Greens',mode='arrow') #self.q6 = mlab.quiver3d(3.0,0.0,0.0,1.0,0.0,0.0, colormap='Blues',mode='arrow') self.queue = Queue() self.c = CaptureThread("COM4") self.c.start() simModel = loadBVHFile('walk.bvh', conversionFactor=0.01) self.configure_traits()
def __call__( self, time=None ): from enthought.mayavi import mlab fig = mlab.gcf() render = fig.scene.disable_render fig.scene.disable_render = True self.colon.visible = False for hh in self.glyphs: for h in hh: h.visible = False if time is not None: self.colon.visible = True m = int( time / 60 ) d = int( (time % 60) / 10 ) s = int( time % 10 ) self.glyphs[m][0].visible = True self.glyphs[d][1].visible = True self.glyphs[s][2].visible = True fig.scene.disable_render = render return
def __init__(self, tMin, tMax, *renderers): """ Initialise idle animator. @param tMin: Time to start animation. @param tMax: Time at which to wrap back to tMin. @param renderers: List of L{AnimatedRenderer} objects. """ HasTraits.__init__(self) self._renderers = renderers self._tMin = tMin self._tMax = tMax self.speed = 1 self.time = tMin self.playing = False self._scene = mlab.gcf().scene autoPositionCamera() for r in self._renderers: r.renderUpdate(self.time) self.edit_traits()
def main(): from enthought.tvtk.api import tvtk from enthought.mayavi import mlab from enthought.enable.vtk_backend.vtk_window import EnableVTKWindow f = mlab.figure(size=(900, 850)) m = mlab.test_mesh() scene = mlab.gcf().scene render_window = scene.render_window renderer = scene.renderer rwi = scene.interactor # Create the plot timer_controller = TimerController() plots = create_plot_component(timer_controller) specplot, timeplot, spectrogram = plots for i, p in enumerate(plots): p.set(resizable="", bounds=[200, 200], outer_x=0, bgcolor="transparent") p.outer_y = i * 250 p.tools.append(MoveTool(p, drag_button="right")) p.tools.append(PanTool(p)) p.tools.append(ZoomTool(p)) spectrogram.tools[-1].set(tool_mode="range", axis="value") spectrogram.tools[-2].set(constrain=True, constrain_direction="y") container = OverlayPlotContainer(bgcolor="transparent", fit_window=True) container.add(*plots) container.timer_callback = timer_controller.on_timer window = EnableVTKWindow( rwi, renderer, component=container, istyle_class=tvtk.InteractorStyleTrackballCamera, bgcolor="transparent", event_passthrough=True, ) mlab.show()
def m2screenshot(mayavi_fig=None, mpl_axes=None, autocrop=True): """ Capture a screeshot of the Mayavi figure and display it in the matplotlib axes. """ import pylab as pl if mayavi_fig is None: mayavi_fig = mlab.gcf() else: mlab.figure(mayavi_fig) if mpl_axes is not None: pl.axes(mpl_axes) filename = tempfile.mktemp('.png') mlab.savefig(filename, figure=mayavi_fig) image3d = pl.imread(filename) if autocrop: bg_color = mayavi_fig.scene.background image3d = autocrop_img(image3d, bg_color) pl.imshow(image3d) pl.axis('off') os.unlink(filename)
def draw_atoms(at, colours=None, colorbar=None, atom_scale_factor=1.0, cell=True, origin=[0., 0., 0.], shift=[.5, .5, .5], supercell=[1, 1, 1], bonds=True, cutoff_factor=1.2, bond_radius=0.2, bond_colour=(.55, .55, .55), arrows=None, arrow_colour=(0, 0, 0), arrow_scale_factor=1.0, clf=True): if clf: mlab.clf() fig = mlab.gcf() fig.scene.disable_render = True balls = add_balls(at, colours, colorbar, atom_scale_factor) if cell: add_cell(at, balls, origin, shift, supercell) if bonds: add_bonds(at, balls, cutoff_factor, bond_radius, bond_colour) if arrows: arrows = add_arrows(at, arrows, arrow_colour, arrow_scale_factor) fig.scene.disable_render = False if arrows: return (balls, arrows) else: return balls
def doit(): global s global iter if iter == 0: print "plotting the triangular mesh..." s = mlab.triangular_mesh(x, y, z, triangles, scalars=t) print " done." print "adjusting view..." mlab.view(0, 0) print " done." else: print "changing the source..." # This doesn't work due to a bug in mayavi/VTK: # http://github.com/certik/mhd-hermes/issues#issue/1 #s.mlab_source.reset(x=x, y=y, z=z, triangles=triangles, scalars=t) # so until this is fixed, let's call triangular_mesh and delete the # old mesh (this is slow but works): scene = mlab.gcf().scene scene.disable_render = True s = mlab.triangular_mesh(x, y, z, triangles, scalars=t) mlab.get_engine().scenes[0].children[:1] = [] scene.disable_render = False print " done." iter += 1
def play(self, fileroot='cell', show_colorbar=True, show_title=False): ''' Step through cell response over time ''' dt = self.play_dt tstop = self.play_tstop nrn.init() nrn.cvode_active(0) img_counter=0 f = mlab.gcf() if show_colorbar: mlab.colorbar(self.mlab_cell) nrn.initPlot() nrn.init() nrn.initPlot() nrn.init() for x in xrange(0, int(tstop/dt)): timestamp = "TIME: %.1f" % (x*dt) print timestamp if show_title: try: ftitle.text = timestamp except: ftitle = mlab.title(timestamp) nrn.continuerun(x*dt) dataset = self.mlab_cell.mlab_source.dataset v = array(self.calculate_voltage()) dataset.point_data.remove_array('data') array_id = dataset.point_data.add_array(v.T.ravel()) dataset.point_data.get_array(array_id).name = 'data' dataset.point_data.update() self.mlab_cell.update_data() self.mlab_cell.update_pipeline() if self.save_img: f.scene.save_png('img/%s_%03d.png' % (fileroot, img_counter)) img_counter += 1
# -*- coding: utf-8 -*- """ 使用Mayavi绘制多为数组下标存取的演示图像。 """ import numpy as np from enthought.mayavi import mlab x, y, z = np.mgrid[:6,:7,:8] c = np.zeros((6, 7, 8), dtype=np.int) c.fill(1) k = np.random.randint(2,5,size=(6, 7)) idx_i, idx_j, _ = np.ogrid[:6, :7, :8] idx_k = k[:,:, np.newaxis] + np.arange(3) c[idx_i, idx_j, idx_k] = np.random.randint(2,6, size=(6,7,3)) mlab.points3d(x[c>1], y[c>1], z[c>1], c[c>1], mode="cube", scale_factor=0.8, scale_mode="none", transparent=True, vmin=0, vmax=8, colormap="Greys") mlab.points3d(x[c==1], y[c==1], z[c==1], c[c==1], mode="cube", scale_factor=0.8, scale_mode="none", transparent=True, vmin=0, vmax=8, colormap="Greys", opacity = 0.2) mlab.gcf().scene.background = (1,1,1) mlab.figure() x, y, z = np.mgrid[:6,:7,:3] mlab.points3d(x, y, z, c[idx_i, idx_j, idx_k], mode="cube", scale_factor=0.8, scale_mode="none", transparent=True, vmin=0, vmax=8, colormap="Greys", opacity = 1) mlab.gcf().scene.background = (1,1,1) mlab.show()
def display(self, func, segfunc=False, scaling=1, replace=True, clim=None, colormap='jet'): ''' Display current cell in mayavi ''' #from neuron import h from numpy import array, vstack, float_ from enthought.mayavi import mlab from enthought.mayavi.mlab import pipeline if replace: try: self.mlab_cell.parent.parent.parent.parent.parent.parent.remove( ) except AttributeError: pass ### Turn off vtk warnings # # # # # # # # # # # # # # # # # # # # # # # from vtk import vtkObject o = vtkObject o.GetGlobalWarningDisplay() o.SetGlobalWarningDisplay(0) # Turn it off. f = mlab.figure(figure=mlab.gcf(), bgcolor=(1, 1, 1), size=(800, 600)) self.build_tree(func, segfunc) ## xs = self.xyzdv[:,0] ## ys = self.xyzdv[:,1] ## zs = self.xyzdv[:,2] xs = float_(self.xyzdv[:, 0]) ys = float_(self.xyzdv[:, 1]) zs = float_(self.xyzdv[:, 2]) # don't want scaling for soma segments ## diams = self.xyzdv[:,3] diams = float_(self.xyzdv[:, 3]) #nonsoma = (diams < 15) # non-somatic nonsoma = ones(shape(diams)) diams += diams * nonsoma * (scaling - 1) #diams = self.xyzdv[:,3] * scaling # larger scaling makes neurons more visible ## data = self.xyzdv[:,4] data = float_(self.xyzdv[:, 4]) edges = self.connections # Display in mayavi pts = pipeline.scalar_scatter(xs, ys, zs, diams / 2.0, name=str(self)) dataset = pts.mlab_source.dataset dataset.point_data.get_array(0).name = 'diameter' dataset.lines = vstack(edges) array_id = dataset.point_data.add_array(data.T.ravel()) dataset.point_data.get_array(array_id).name = 'data' dataset.point_data.update() #### Create tube with diameter data src = pipeline.set_active_attribute(pts, point_scalars='diameter') stripper = pipeline.stripper(src) tube = pipeline.tube(stripper, tube_sides=8, tube_radius=1) tube.filter.capping = True tube.filter.use_default_normal = False tube.filter.vary_radius = 'vary_radius_by_absolute_scalar' #tube.filter.radius_factor = 90.0 # just for making movies src2 = pipeline.set_active_attribute(tube, point_scalars='data') lines = pipeline.surface(src2, colormap=colormap) if clim: from numpy import array lines.parent.scalar_lut_manager.use_default_range = False lines.parent.scalar_lut_manager.data_range = array(clim) self.mlab_cell = lines
if __name__ == "__main__": k = 4 N = 2 NP = 12 points = pu.uniformcubepoints(NP) v = [[1,1,1]] # v = [[0,0,0]] meshevents = lambda m: pps.stokescubemesh(N, m) # OT = 'obstructiontag' # meshevents = lambda m: pps.cubeobstruction(m, OT) mp = MeshPlotter() meshevents(mp) emm.figure(bgcolor=(1,1,1)) u, p = pps.stokespressure(k,meshevents,{pps.inputbdytag:pps.pfn(0), pps.outputbdytag:pps.pfn(1.0)}, points, False, N==1) pt = points.reshape(NP,NP,NP,3).transpose((3,0,1,2)) ut = u.reshape(NP,NP,NP,3).transpose((3,0,1,2)) emm.quiver3d(pt[0],pt[1],pt[2], ut[0],ut[1],ut[2], opacity = 0.4) # emm.flow(pt[0],pt[1],pt[2], ut[0],ut[1],ut[2], seedtype='plane', seed_resolution=10, seed_visible=True, scalars=p.reshape(NP,NP,NP)) mp.plot(emm.gcf()) mp.plotbdy(emm.gcf(), pps.closedbdytag) # emm.figure() # uut = uu.transpose() # emm.quiver3d(pt[0],pt[1],pt[2], uut[0],uut[1],uut[2]) emm.show()
#Center the atoms about 1/2 the bounds xshft=bndx/2.0-sum(xs)/len(xs) yshft=bndy/2.0-sum(ys)/len(ys) zshft=bndz/2.0-sum(zs)/len(zs) xs=map(lambda x:x+xshft,xs) ys=map(lambda y:y+yshft,ys) zs=map(lambda z:z+zshft,zs) N=len(xs) print "Lattice has %d atoms.\n" % N #Plotting if ploton==1: from enthought.mayavi import mlab fig=mlab.gcf() mlab.points3d(xs,ys,zs) mlab.plot3d([0,bndx],[0,0],[0,0]) mlab.plot3d([0,0],[0,bndy],[0,0]) mlab.plot3d([0,0],[0,0],[0,bndz]) mlab.show() #Ask before overwriting a file. try: val=raw_input("Continue? (y/n): ") if not(val in ('y','Y')): print "Okey dokey, stopping." exit(0) ofil=open(sys.argv[8],"w") except ValueError: exit(0)
# -*- coding: utf-8 -*- import numpy as np from enthought.mayavi import mlab const = 2.19967e34 x, y = np.ogrid[0:7000000:200j, 500:1500:100j] s = const * np.exp(-x / y) * np.sqrt(x) / (y**1.5) surface = mlab.contour3d(s) surface.contour.maximum_contour = 15 surface.contour.number_of_contours = 10 surface.actor.property.opacity = 0.4 mlab.figure() mlab.pipeline.volume(mlab.pipeline.scalar_field(s)) mlab.figure() field = mlab.pipeline.scalar_field(s) mlab.pipeline.volume(field, vmin=1.5, vmax=80) cut = mlab.pipeline.scalar_cut_plane(field.children[0], plane_orientation="y_axes") cut.enable_contours = True cut.contour.number_of_contours = 40 mlab.gcf().scene.background = (0.8, 0.8, 0.8) mlab.show()
def close(): """Close the scene.""" f = mlab.gcf() e = mlab.get_engine() v = e.get_viewer(f) v.close()
from divers import multimedia theta, phi = local.get_grid(50, 25, gtype='triangular') r = np.ones_like(theta) x, y, z = vectors.spher2cart_coord(r, phi, theta) points = np.array([x, y, z]).T grid = Delaunay(points) #keep = phi>pi #theta,phi = theta[keep],phi[keep] l, m = 2, 2 asl = 0.01 for k in [0, 1., 2.]: for l in range(1, 5): for m in range(0, l + 1, 1): mlab.figure(size=(1000, 800)) mlab.gcf().scene.disable_render = True if l == 0 or l == 1: asl = 0.1 else: asl = 0.01 old_center = None for i, t in enumerate(np.linspace(0, 2 * pi, 100)): print k, l, m, i r, th, ph = surface(theta, phi, l, m, t, asl=asl, k=k) center, size, normal = local.surface_normals( r, ph, th, grid, gtype='triangular') if i == 0: colors = r r_c, phi_c, theta_c = vectors.cart2spher_coord( *center.T)
vmax=8, colormap="Greys") mlab.points3d(x[c == 1], y[c == 1], z[c == 1], c[c == 1], mode="cube", scale_factor=0.8, scale_mode="none", transparent=True, vmin=0, vmax=8, colormap="Greys", opacity=0.2) mlab.gcf().scene.background = (1, 1, 1) mlab.figure() x, y, z = np.mgrid[:6, :7, :3] mlab.points3d(x, y, z, c[idx_i, idx_j, idx_k], mode="cube", scale_factor=0.8, scale_mode="none", transparent=True, vmin=0, vmax=8, colormap="Greys", opacity=1)
# -*- coding: utf-8 -*- import numpy as np from enthought.mayavi import mlab x, y = np.ogrid[-2:2:20j, -2:2:20j] z = x * np.exp(-x**2 - y**2) face = mlab.surf(x, y, z, warp_scale=2) mlab.axes(xlabel='x', ylabel='y', zlabel='z') mlab.outline(face) c = 2 * x + y # 获得Array2DSource img = mlab.gcf().children[0].image_data # 注意c的第0轴对应于x,第一轴对应于y,因此需要先将其转置 # 标量数组只接受一维数组,因此调用ravel()方法将数组变成一维的 array_id = img.point_data.add_array(c.T.ravel()) img.point_data.get_array(array_id).name = "color" img.point_data.update() normals = mlab.gcf().children[0].children[0].children[0] surf = normals.children[0] del normals.children[0] active_attr = mlab.pipeline.set_active_attribute(normals, point_scalars="color") active_attr.children.append(surf) mlab.show()
def make_plots(plots,argd=None,figs=None,save=False,overwrite=True,showfigs=True): """ Generate plots and maybe save them. :param plots: A comma-seperated string of plots to show :param argd: The dictionary to use to find the arguments of the plot function. If None, global variables will be used. :param figs: A list of figure numbers to use for each of the figures in `plots`. If None, the current figure will be used as the starting point. :param str save: A directory in which to save the plots. If False, they will not be saved, if True, the current directory will be used. :param bool overwrite: If True and plots are being saved, any existing plot will be overwritten. Otherwise, the figure will not be saved. :parm bool showfigs: If True, the figures will be shown (in whatever GUI is the correct one for the type). """ import os,shutil,inspect,subprocess if save is True: save='.' if isinstance(save,basestring) and not save.endswith(os.sep): save+=os.sep if plots is None: plots = _plotreg.keys() elif isinstance(plots,basestring): if '*' in plots: import re plots = plots.replace('*','.*') regex = re.compile(plots) plots = [p for p in plot_names()[0] if regex.match(p)] else: plots = plots.split(',') if figs is None: figs = arange(len(plots))+1 if len(figs) != len(plots): raise ValueError("plots don't match figs") if argd is None: argd = globals() plotd={} for p,fnum in zip(plots,figs): if p not in _plotreg: raise KeyError('plotname %s not found'%p) plotd[p] = (_plotreg[p][0],fnum,_plotreg[p][1],_plotreg[p][2],_plotreg[p][3]) isinter = plt.isinteractive() plt.ioff() anympl = False try: for fname,(figf,fignum,figsize,ftype,tweakbbox) in plotd.iteritems(): print 'figure',fname if 'mpl' in ftype: anympl = True if isinter: plt.ion() plt.close(fignum) plt.figure(fignum,figsize=figsize) plt.ioff() elif 'mayavi' in ftype: from enthought.mayavi import mlab as M if len(M.get_engine().scenes) > 0: M.gcf().parent.close_scene(M.gcf()) f=M.figure(fignum,size=figsize) #this is buggy #f.scene.set_size(figsize) #M.clf() else: raise ValueError('unrecognized figtype') argsp = inspect.getargspec(figf) if argsp[2] is not None: figf(**argd) else: args=[] for arg in argsp[0]: args.append(argd[arg]) figf(*args) if save: epsconv = False if ftype=='mpltoeps': epsconv = 'png' savefunc = plt.savefig saveexts = ['png'] elif ftype.startswith('mpl'): savefunc = plt.savefig saveexts = ftype[3:].strip() if saveexts=='': saveexts = ['eps','pdf'] else: saveexts = saveexts.split(',') elif ftype.startswith('mayavi'): savefunc = M.savefig saveexts = ftype[6:].strip() if saveexts=='': saveexts = ['png'] else: saveexts = saveexts.split(',') if 'eps' in saveexts: saveexts.remove('eps') if 'png' not in saveexts: saveexts.append('png') epsconv = 'png' else: raise ValueError('unrecognized figtype') for saveext in saveexts: fn = '%s%s.%s'%(save,fname,saveext) epsfns = None if not overwrite and os.path.exists(fn): print fn,'exists, skipping (use -o at command line to overwrite)' else: print 'saving',fn savefunc(fn) if saveext == epsconv: epsfns = (fn,'%s%s.%s'%(save,fname,'eps')) if epsfns is not None: from os import system fn,epsfn = epsfns print 'converting',fn,'to',epsfn retcode = subprocess.call('convert %s %s'%(fn,epsfn),shell=True) if retcode is not 0: raise ValueError('convert failed to convert %s to %s'%(fn,epsfn)) if tweakbbox is not None: print 'updating eps bounding box on',epsfn,'to',tweakbbox with open(epsfn+'.tmpwrite','w') as fw: with open(epsfn,'r') as fr: for l in fr: if 'BoundingBox' in l and 'Page' not in l: newline = l.split(':')[0]+(': %s %s %s %s\n'%tweakbbox) fw.write(newline) else: fw.write(l) shutil.move(epsfn+'.tmpwrite',epsfn) finally: if isinter: plt.ion() if showfigs and anympl: plt.draw()
# -*- coding: utf-8 -*- import numpy as np from enthought.mayavi import mlab x, y = np.ogrid[-2:2:20j, -2:2:20j] z = x * np.exp(-x**2 - y**2) face = mlab.surf(x, y, z, warp_scale=2) mlab.axes(xlabel='x', ylabel='y', zlabel='z') mlab.outline(face) from enthought.tvtk.pipeline.browser import PipelineBrowser b = PipelineBrowser() b.root_object = [mlab.gcf().scene.render_window] b.show() mlab.show() mscene = mlab.gcf() tscene = mscene.scene rw = tscene.render_window a1 = rw.renderers[0].view_props[0]
# -*- coding: utf-8 -*- import numpy as np from enthought.mayavi import mlab x, y, z = np.ogrid[-2:2:40j, -2:2:40j, -2:0:40j] s = 2/np.sqrt((x-1)**2 + y**2 + z**2) + 1/np.sqrt((x+1)**2 + y**2 + z**2) surface = mlab.contour3d(s) surface.contour.maximum_contour = 15 surface.contour.number_of_contours = 10 surface.actor.property.opacity = 0.4 mlab.figure() mlab.pipeline.volume(mlab.pipeline.scalar_field(s)) mlab.figure() field = mlab.pipeline.scalar_field(s) mlab.pipeline.volume(field, vmin=1.5, vmax=10) cut = mlab.pipeline.scalar_cut_plane(field.children[0], plane_orientation="y_axes") cut.enable_contours = True cut.contour.number_of_contours = 40 mlab.gcf().scene.background = (0.8, 0.8, 0.8) mlab.show()
def close(): """Close the scene.""" f = mlab.gcf() e = mlab.get_engine() e.window.close()
from enthought.mayavi import mlab import numpy as np mlab.clf() # Number of lines n_lines = 200 # Number of points per line n_points = 100 # Create Example Coordinates xyz = [] for ii in xrange( n_lines ): xyz.append( np.cumsum( np.random.random( ( n_points, 3 ) ), axis=0 ) ) fig = mlab.gcf() fig.scene.disable_render = True for this_xyz in xyz: x, y, z = this_xyz mlab.plot3d( x, y, z, tube_sides=7, tube_radius=0.1 ) fig.scene.disable_render = False mlab.show()
def plot_anat_3d( anat=None, anat_affine=None, scale=1, sulci_opacity=0.5, gyri_opacity=0.3, opacity=None, outline_color=None ): # Late import to avoid triggering wx imports before needed. from enthought.mayavi import mlab fig = mlab.gcf() disable_render = fig.scene.disable_render fig.scene.disable_render = True if anat is None: anat, anat_affine, anat_max = _AnatCache.get_anat() anat_blurred = _AnatCache.get_blurred() else: from scipy import ndimage # XXX: This should be in a separate function anat_blurred = ndimage.gaussian_filter( ( ndimage.morphology.binary_fill_holes(ndimage.gaussian_filter((anat > 4800).astype(np.float), 6) > 0.5) ).astype(np.float), 2, ).T.ravel() if opacity is None: from enthought.tvtk.api import tvtk version = tvtk.Version() if (version.vtk_major_version, version.vtk_minor_version) < (5, 2): opacity = 0.99 else: opacity = 1 ########################################################################### # Display the cortical surface (flattenned) anat_src = affine_img_src(anat, anat_affine, scale=scale, name="Anat") anat_src.image_data.point_data.add_array(anat_blurred) anat_src.image_data.point_data.get_array(1).name = "blurred" anat_src.image_data.point_data.update() anat_blurred = mlab.pipeline.set_active_attribute(anat_src, point_scalars="blurred") anat_blurred.update_pipeline() # anat_blurred = anat_src cortex_surf = mlab.pipeline.set_active_attribute(mlab.pipeline.contour(anat_blurred), point_scalars="scalar") # XXX: the choice in vmin and vmax should be tuned to show the # sulci better cortex = mlab.pipeline.surface(cortex_surf, colormap="copper", opacity=opacity, vmin=4800, vmax=5000) cortex.enable_contours = True cortex.contour.filled_contours = True cortex.contour.auto_contours = False cortex.contour.contours = [0, 5000, 7227.8] # cortex.actor.property.backface_culling = True # XXX: Why do we do 'frontface_culling' to see the front. cortex.actor.property.frontface_culling = True cortex.actor.mapper.interpolate_scalars_before_mapping = True cortex.actor.property.interpolation = "flat" # Add opacity variation to the colormap cmap = cortex.module_manager.scalar_lut_manager.lut.table.to_array() cmap[128:, -1] = gyri_opacity * 255 cmap[:128, -1] = sulci_opacity * 255 cortex.module_manager.scalar_lut_manager.lut.table = cmap if outline_color is not None: outline = mlab.pipeline.iso_surface(anat_blurred, contours=[0.4], color=outline_color, opacity=0.9) outline.actor.property.backface_culling = True fig.scene.disable_render = disable_render return cortex
number of points per ball, and divide the point id by this number. We use an outline to display which ball was selected by positioning it on the corresponding ball. """ # Author: Gael Varoquaux <gael dot varoquaux at normalesup.org> # Copyright (c) 2009, Enthought, Inc. # License: BSD style. import numpy as np from enthought.mayavi import mlab ################################################################################ # Disable the rendering, to get bring up the figure quicker: figure = mlab.gcf() mlab.clf() figure.scene.disable_render = True # Creates two set of points using mlab.points3d: red point and # white points x1, y1, z1 = np.random.random((3, 10)) red_glyphs = mlab.points3d(x1, y1, z1, color=(1, 0, 0), resolution=20) x2, y2, z2 = np.random.random((3, 10)) white_glyphs = mlab.points3d(x2, y2, z2, color=(0.9, 0.9, 0.9), resolution=20) # Add an outline to show the selected point and center it on the first # data point.
def plot_map_3d( map, affine, cut_coords=None, anat=None, anat_affine=None, threshold=None, offscreen=False, vmin=None, vmax=None, cmap=None, view=(38.5, 70.5, 300, (-2.7, -12, 9.1)), ): """ Plot a 3D volume rendering view of the activation, with an outline of the brain. Parameters ---------- map : 3D ndarray The activation map, as a 3D image. affine : 4x4 ndarray The affine matrix going from image voxel space to MNI space. cut_coords: 3-tuple of floats, optional The MNI coordinates of a 3D cursor to indicate a feature or a cut, in MNI coordinates and order. anat : 3D ndarray, optional The anatomical image to be used as a background. If None, the MNI152 T1 1mm template is used. If False, no anatomical image is used. anat_affine : 4x4 ndarray, optional The affine matrix going from the anatomical image voxel space to MNI space. This parameter is not used when the default anatomical is used, but it is compulsory when using an explicite anatomical image. threshold : float, optional The lower threshold of the positive activation. This parameter is used to threshold the activation map. offscreen: boolean, optional If True, Mayavi attempts to plot offscreen. Will work only with VTK >= 5.2. vmin : float, optional The minimal value, for the colormap vmax : float, optional The maximum value, for the colormap cmap : a callable, or a pylab colormap A callable returning a (n, 4) array for n values between 0 and 1 for the colors. This can be for instance a pylab colormap. Notes ----- If you are using a VTK version below 5.2, there is no way to avoid opening a window during the rendering under Linux. This is necessary to use the graphics card for the rendering. You must maintain this window on top of others and on the screen. """ # Late import to avoid triggering wx imports before needed. from enthought.mayavi import mlab if offscreen: global off_screen_engine if off_screen_engine is None: from enthought.mayavi.core.off_screen_engine import OffScreenEngine off_screen_engine = OffScreenEngine() off_screen_engine.start() fig = mlab.figure( "__private_plot_map_3d__", bgcolor=(1, 1, 1), fgcolor=(0, 0, 0), size=(400, 330), engine=off_screen_engine ) mlab.clf(figure=fig) else: fig = mlab.gcf() fig = mlab.figure(fig, bgcolor=(1, 1, 1), fgcolor=(0, 0, 0), size=(400, 350)) disable_render = fig.scene.disable_render fig.scene.disable_render = True if threshold is None: threshold = stats.scoreatpercentile(np.abs(map).ravel(), 80) contours = [] lower_map = map[map <= -threshold] if np.any(lower_map): contours.append(lower_map.max()) upper_map = map[map >= threshold] if np.any(upper_map): contours.append(map[map > threshold].min()) ########################################################################### # Display the map using iso-surfaces if len(contours) > 0: map_src = affine_img_src(map, affine) module = mlab.pipeline.iso_surface(map_src, contours=contours, vmin=vmin, vmax=vmax) if callable(cmap): # Stick the colormap in mayavi module.module_manager.scalar_lut_manager.lut.table = (255 * cmap(np.linspace(0, 1, 256))).astype(np.int) else: module = None if not anat is False: plot_anat_3d(anat=anat, anat_affine=anat_affine, scale=1.05, outline_color=(0.9, 0.9, 0.9), gyri_opacity=0.2) ########################################################################### # Draw the cursor if cut_coords is not None: x0, y0, z0 = cut_coords mlab.plot3d((-90, 90), (y0, y0), (z0, z0), color=(0.5, 0.5, 0.5), tube_radius=0.25) mlab.plot3d((x0, x0), (-126, 91), (z0, z0), color=(0.5, 0.5, 0.5), tube_radius=0.25) mlab.plot3d((x0, x0), (y0, y0), (-72, 109), color=(0.5, 0.5, 0.5), tube_radius=0.25) mlab.view(*view) fig.scene.disable_render = disable_render return module