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)
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)
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)