def preview(self): """ Display a preview of the data structure in the preview window. """ self._preview_window.clear() self._preview_window.add_source(self.data_source) data = lambda name: self.data_sources[name] g = Glyph() g.glyph.glyph_source.glyph_source = \ g.glyph.glyph_source.glyph_list[0] g.glyph.scale_mode = 'data_scaling_off' if not (self.has_vector_data or self.data_type_ == 'vector'): g.glyph.glyph_source.glyph_source.glyph_type = 'cross' g.actor.property.representation = 'points' g.actor.property.point_size = 3. self._preview_window.add_module(g) if not self.data_type_ in ('point', 'vector') or self.lines: s = Surface() s.actor.property.opacity = 0.3 self._preview_window.add_module(s) if not self.data_type_ == 'point': self._preview_window.add_filter(ExtractEdges()) s = Surface() s.actor.property.opacity = 0.2 self._preview_window.add_module(s)
def setUp(self): """Initial setting up of test fixture, automatically called by TestCase before any other test method is invoked""" e = NullEngine() # Uncomment to see visualization for debugging etc. #e = Engine() e.start() e.new_scene() self.e = e r = VTKXMLFileReader() r.initialize(get_example_data('pyramid_ug.vtu')) e.add_source(r) r.point_scalars_name = 'temperature' o = Outline() e.add_module(o) c = Contour() e.add_filter(c) n = PolyDataNormals() e.add_filter(n) aa = SetActiveAttribute() e.add_filter(aa) aa.point_scalars_name = 'pressure' s = Surface() e.add_module(s) self.scene = e.current_scene return
def generate_data_mayavi(self): """Shows how you can generate data using mayavi instead of mlab.""" from enthought.mayavi.sources.api import ParametricSurface from enthought.mayavi.modules.api import Outline, Surface e = self.scene.engine s = ParametricSurface() e.add_source(s) e.add_module(Outline()) e.add_module(Surface())
def show_mesh(file_name, ndim): mayavi_engine = Engine() mayavi_engine.start() mayavi_engine.new_scene() # View the MayaVi pipeline engine_view = EngineView(engine=mayavi_engine) ui = engine_view.edit_traits() # Setup MayaVi pipeline src = TriangleReader() if (ndim == 2): src.initialize(file_name+'.edge') # Load the 2D .edge file else: src.initialize(file_name+'.face') # Load the 3D .face file mayavi_engine.add_source(src) # Add any filters, modules here in the order that they are to appear in the pipeline mayavi_engine.add_module(Surface())
def main(): mayavi.new_scene() # Read the example data: fire_ug.vtu. r = VTKXMLFileReader() filename = join(mayavi2.get_data_dir(dirname(abspath(__file__))), 'fire_ug.vtu') r.initialize(filename) mayavi.add_source(r) # Set the active point scalars to 'u'. r.point_scalars_name = 'u' # Simple outline for the data. o = Outline() mayavi.add_module(o) # Branch the pipeline with a contour -- the outline above is # directly attached to the source whereas the contour below is a # filter and will branch the flow of data. An isosurface in the # 'u' data attribute is generated and normals generated for it. c = Contour() mayavi.add_filter(c) n = PolyDataNormals() mayavi.add_filter(n) # Now we want to show the temperature 't' on the surface of the 'u' # iso-contour. This is easily done by using the SetActiveAttribute # filter below. aa = SetActiveAttribute() mayavi.add_filter(aa) aa.point_scalars_name = 't' # Now view the iso-contours of 't' with a Surface filter. s = Surface(enable_contours=True) mayavi.add_module(s)
def setUp(self): """Initial setting up of test fixture, automatically called by TestCase before any other test method is invoked""" e = NullEngine() # Uncomment to see visualization for debugging etc. #e = Engine() e.start() e.new_scene() self.e = e sgrid = datasets.generateStructuredGrid() src = VTKDataSource(data=sgrid) e.add_source(src) c = Contour() # `name` is used for the notebook tabs. n = PolyDataNormals(name='Normals') o = Optional(filter=n, label_text='Compute normals') coll = Collection(filters=[c, o], name='IsoSurface') e.add_filter(coll) s = Surface() e.add_module(s) self.coll = coll self.scene = e.current_scene return
def do(self): ############################################################ # Imports. script = self.script from enthought.mayavi.sources.vtk_file_reader import VTKFileReader from enthought.mayavi.filters.contour import Contour from enthought.mayavi.filters.optional import Optional from enthought.mayavi.filters.collection import Collection from enthought.mayavi.filters.api import PolyDataNormals from enthought.mayavi.modules.api import Surface ############################################################ # Create a new scene and set up the visualization. s = self.new_scene() # Read a VTK (old style) data file. r = VTKFileReader() r.initialize(get_example_data('heart.vtk')) script.add_source(r) c = Contour() # `name` is used for the notebook tabs. n = PolyDataNormals(name='Normals') o = Optional(filter=n, label_text='Compute normals') coll = Collection(filters=[c, o], name='IsoSurface') script.add_filter(coll) s = Surface() script.add_module(s) ######################################## # do the testing. def check(coll): """Check if test status is OK given the collection.""" c, o = coll.filters c = c.filter n = o.filter assert coll.outputs[0].point_data.scalars.range == (127.5, 127.5) # Adding a contour should create the appropriate output in # the collection. c.contours.append(200) assert coll.outputs[0].point_data.scalars.range == (127.5, 200.0) # the collection's output should be that of the normals. assert coll.outputs[0] is n.outputs[0] # disable the optional filter and check. o.enabled = False assert 'disabled' in o.name assert coll.outputs[0] is c.outputs[0] # Set back everything to original state. c.contours.pop() o.enabled = True assert coll.outputs[0].point_data.scalars.range == (127.5, 127.5) assert coll.outputs[0] is n.outputs[0] assert 'disabled' not in o.name check(coll) ############################################################ # Test if saving a visualization and restoring it works. # Save visualization. f = StringIO() f.name = abspath('test.mv2') # We simulate a file. script.save_visualization(f) f.seek(0) # So we can read this saved data. # Remove existing scene. engine = script.engine engine.close_scene(s) # Load visualization script.load_visualization(f) s = engine.current_scene # Now do the check. coll = s.children[0].children[0] check(coll) ############################################################ # Test if the Mayavi2 visualization can be deep-copied. # Pop the source object. source = s.children.pop() # Add it back to see if that works without error. s.children.append(source) # Now do the check. coll = s.children[0].children[0] check(coll) # Now deepcopy the source and replace the existing one with # the copy. This basically simulates cutting/copying the # object from the UI via the right-click menu on the tree # view, and pasting the copy back. source1 = copy.deepcopy(source) s.children[0] = source1 # Now do the check. coll = s.children[0].children[0] check(coll)
#d=VTKDataSource() #d.data=pd #e.add_source(d) #g=Glyph() #e.add_module(g) #g.glyph.glyph_source.glyph_source=g.glyph.glyph_source.glyph_list[4] #g.glyph.glyph_source.glyph_source.radius=0.1 # DEM d = VTKDataSource() d.data = dem_data e.add_source(d) df = Delaunay2D() e.add_filter(df) s = Surface() e.add_module(s) #s.actor.property.set(representation='p', point_size=100) #view(azimuth=-60,elevation=60,distance=120) output_file = "tmp.png" win.scene.save(output_file, size=(800, 600)) # s = Surface() # e.add_module(s) # s.actor.property.set(representation='p', point_size=2)
def do(self): """Test for the SetActiveAttribute filter. """ from enthought.mayavi.sources.api import VTKXMLFileReader from enthought.mayavi.filters.contour import Contour from enthought.mayavi.filters.api import PolyDataNormals from enthought.mayavi.filters.set_active_attribute import SetActiveAttribute from enthought.mayavi.modules.api import Surface, Outline mayavi = script = self.script scene = self.new_scene() r = VTKXMLFileReader() r.initialize(get_example_data('fire_ug.vtu')) mayavi.add_source(r) r.point_scalars_name = 'u' o = Outline() mayavi.add_module(o) c = Contour() mayavi.add_filter(c) n = PolyDataNormals() mayavi.add_filter(n) aa = SetActiveAttribute() mayavi.add_filter(aa) aa.point_scalars_name = 't' s = Surface() mayavi.add_module(s) scene.scene.isometric_view() # Check if things are OK. self.check() ############################################################ # Test if saving a visualization and restoring it works. # Save visualization. f = StringIO() f.name = abspath('test.mv2') # We simulate a file. mayavi.save_visualization(f) f.seek(0) # So we can read this saved data. # Remove existing scene. engine = mayavi.engine engine.close_scene(s) # Load visualization mayavi.load_visualization(f) s = engine.current_scene # Now do the check. s.scene.isometric_view() self.check() ############################################################ # Test if the Mayavi2 visualization can be deep-copied. # Pop the source object. source = s.children.pop() # Add it back to see if that works without error. s.children.append(source) # Now do the check. self.check() # Now deepcopy the source and replace the existing one with # the copy. This basically simulates cutting/copying the # object from the UI via the right-click menu on the tree # view, and pasting the copy back. source1 = copy.deepcopy(source) s.children[0] = source1 # Now do the check. s.scene.isometric_view() self.check()
def add_filter(self, filter): self._engine.add_module(filter) def clear(self): self._engine.current_scene.scene.disable_render = True self._engine.current_scene.children[:] = [] self._engine.current_scene.scene.disable_render = False #----------------------------------------------------------------------- # Private API #----------------------------------------------------------------------- def __engine_default(self): e = Engine() e.start() e.new_scene(self._scene) return e if __name__ == '__main__': from enthought.pyface.api import GUI from enthought.mayavi.sources.api import ParametricSurface from enthought.mayavi.modules.api import Outline, Surface pw = PreviewWindow() pw.add_source(ParametricSurface()) pw.add_module(Outline()) pw.add_module(Surface()) pw.edit_traits()
import numpy as np engine = Engine() engine.start() scene = engine.new_scene() scene.scene.disable_render = True # for speed surfaces = [] for i in range(10): source = ParametricSurface() source.function = 'ellipsoid' engine.add_source(source) surface = Surface() source.add_module(surface) actor = surface.actor # mayavi actor, actor.actor is tvtk actor #actor.property.ambient = 1 # defaults to 0 for some reason, ah don't need it, turn off scalar visibility instead actor.property.opacity = 0.5 actor.property.color = tuple(np.random.rand(3)) actor.mapper.scalar_visibility = False # don't colour ellipses by their scalar indices into colour map actor.property.backface_culling = True # gets rid of weird rendering artifact when opacity is < 1 #actor.property.frontface_culling = True actor.actor.orientation = np.random.rand(3) * 360 # in degrees actor.actor.origin = np.random.rand(3) actor.actor.position = np.random.rand(3) actor.actor.scale = np.random.rand(3) surfaces.append(surface)