def _renderScene(self, data):
script = self.script
w = script.get_active_window()
w.size = self.windowSize
script.new_scene()
scene = script.engine.current_scene.scene
scene.disable_render = True
scene.anti_aliasing_frames = self.aaframes
scene.background = self.colorBg
scene.foreground = self.colorFg
script.add_source(VTKDataSource(data=data))
objTop = script.engine.current_object
script.engine.current_object.name = "fault"
warp = WarpVector()
warp.filter.scale_factor = warpScale
script.add_filter(warp)
surf = Surface()
script.add_module(surf)
colorbar = script.engine.current_object.module_manager.scalar_lut_manager
colorbar.data_name = "Velocity (m/s)"
colorbar.lut_mode = self.lut
colorbar.reverse_lut = self.lutReverse
colorbar.scalar_bar.label_format = "%4.2f"
colorbar.scalar_bar.label_text_property.font_size = 18
colorbar.scalar_bar.label_text_property.shadow = True
colorbar.scalar_bar.label_text_property.italic = False
colorbar.scalar_bar.title_text_property.italic = False
colorbar.scalar_bar.title_text_property.shadow = True
colorbar.show_scalar_bar = False
colorbar.data_range = (0.0, 1.0)
#colorbar.number_of_labels = 0
colorbar.scalar_bar.orientation = "horizontal"
scalar_bar = colorbar.scalar_bar_widget.representation
scalar_bar.position2 = (0.33, 0.12)
scalar_bar.position = (0.01, 0.02)
surf = Surface()
script.add_module(surf)
return
def setUp(self):
e = NullEngine()
# Uncomment to see visualization for debugging etc.
#e = Engine()
e.start()
s = e.new_scene()
image_data = BuiltinImage()
e.add_source(image_data)
outline = Outline()
e.add_module(outline)
surface = Surface()
e.add_module(surface)
image_data.data_source.radius = array([80., 80., 80.])
image_data.data_source.center = array([150., 150., 0.])
image_data.data_source.whole_extent = array([10, 245, 10, 245, 0, 0])
self.e = e
self.scene = e.current_scene
return
def test_2d_data(self):
"""Generic tests for 2D data arrays."""
d = self.data
sc, vec = self.make_2d_data()
d.origin = (-1, -1, 0)
d.scalar_data = sc
d.vector_data = vec
d.start() # Start the object so it flushes the pipeline etc.
# Create an outline for the data.
o = Outline()
d.add_child(o)
o.start()
self.assertEqual(tuple(o.actor.actor.bounds),
(-1., 0., -1., 0., 0., 0.))
# Create a surface module.
surf = Surface()
d.add_child(surf)
self.assertEqual(surf.running, True)
tps = numpy.transpose
expect = [tps(sc), tps(vec, (1, 0, 2))]
sc1 = surf.actor.mapper.input.point_data.scalars.to_array()
self.assertEqual(numpy.allclose(sc1.flatten(),
expect[0].flatten()), True)
vec1 = surf.actor.mapper.input.point_data.vectors.to_array()
self.assertEqual(numpy.allclose(vec1.flatten(),
expect[1].flatten()), True)
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()
s = e.new_scene()
poly_data = BuiltinSurface()
e.add_source(poly_data)
outline = Outline()
e.add_module(outline)
surface = Surface()
e.add_module(surface)
poly_data.data_source.shaft_radius = 0.05
poly_data.data_source.shaft_resolution = 7
poly_data.data_source.tip_radius = 0.1
self.e = e
self.scene = e.current_scene
return
def surf_regular(source):
"""Now visualize the data as done in mlab.
"""
w = WarpScalar()
source.add_child(w)
s = Surface()
w.add_child(s)
def test_3d_data(self):
"Test for 3D data arrays."
# Add a 3D data source
d = self.data
sc, vec = self.make_3d_data()
d.scalar_data = sc
d.vector_data = vec
d.start() # Start the object so it flushes the pipeline etc.
# Create an outline for the data.
o = Outline()
d.add_child(o)
o.start()
self.assertEqual(tuple(o.actor.actor.bounds),
(0, 1., 0., 1., 0., 1.))
# Create a surface module.
surf = Surface()
d.add_child(surf)
self.assertEqual(surf.running, True)
tps = numpy.transpose
expect = [tps(sc), tps(vec, (2,1,0,3))]
sc2 = surf.actor.mapper.input.point_data.scalars.to_array()
self.assertEqual(numpy.allclose(sc2.flatten(),
expect[0].flatten()), True)
vec2 = surf.actor.mapper.input.point_data.vectors.to_array()
self.assertEqual(numpy.allclose(vec2.flatten(),
expect[1].flatten()), True)
def view():
col0 = numpy.arange(0, numpts - 1, 1)
col1 = numpy.arange(1, numpts, 1)
lines = array([col0, col1]).transpose()
curve = tvtk.PolyData(points=points, lines=lines)
# assign temperature in sequence so that we now the "direction" of the curve
curve.point_data.scalars = numpy.arange(0, numpts, 1)
curve.point_data.scalars.name = 'temperature'
from enthought.mayavi.sources.vtk_data_source import VTKDataSource
#from enthought.mayavi.modules.outline import Outline
from enthought.mayavi.modules.surface import Surface
from enthought.mayavi.modules.axes import Axes
from enthought.mayavi.modules.text import Text
scene = mayavi.new_scene()
scene.scene.background = (1.0, 1.0, 1.0)
scene.scene.foreground = (0.0, 0.0, 0.0)
src = VTKDataSource(data=curve)
mayavi.add_source(src)
#mayavi.add_module(Outline())
s = Surface()
mayavi.add_module(s)
s.actor.property.set(representation='p', color=(0., 1., 0.), line_width=2)
def view_data(color): s = Surface() mayavi.add_module(s) if (color == "black"): s.actor.property.specular_color = (0.0, 0.0, 0.0) s.actor.property.diffuse_color = (0.0, 0.0, 0.0) s.actor.property.ambient_color = (0.0, 0.0, 0.0) s.actor.property.color = (0.0, 0.0, 0.0)
def surf_regular():
"""Now visualize the data as done in mlab.
"""
w = WarpScalar()
mayavi.add_filter(w)
o = Outline()
s = Surface()
mayavi.add_module(o)
mayavi.add_module(s)
def view():
from enthought.mayavi.sources.vtk_data_source import VTKDataSource
from enthought.mayavi.modules.surface import Surface
mayavi.new_scene()
src = VTKDataSource(data=mesh)
mayavi.add_source(src)
s = Surface()
mayavi.add_module(s)
def view():
from enthought.mayavi.sources.vtk_data_source import VTKDataSource
from enthought.mayavi.modules.outline import Outline
from enthought.mayavi.modules.surface import Surface
from enthought.mayavi.modules.vectors import Vectors
mayavi.new_scene()
# The single type one
src = VTKDataSource(data=ug1)
mayavi.add_source(src)
mayavi.add_module(Outline())
mayavi.add_module(Surface())
mayavi.add_module(Vectors())
# Mixed types.
src = VTKDataSource(data=ug2)
mayavi.add_source(src)
mayavi.add_module(Outline())
mayavi.add_module(Surface())
mayavi.add_module(Vectors())
def addmodules(self, idx, addTextIndexer):
#add Outline module
o = Outline()
mayavi.add_module(o)
#add OrientationAxes module
oa = OrientationAxes()
mayavi.add_module(oa)
"""
#add IsoSurface module if requested
i = IsoSurface()
mayavi.add_module(i)
"""
#add Surface module if requested
s = Surface()
s.enable_contours = True
s.actor.property.opacity = 0.5
mayavi.add_module(s)
#add Text module if requested
t1 = Text()
t1.text = self.title
t1.actor.scaled_text = False
t1.actor.text_property.font_size = 18
mayavi.add_module(t1)
t1.width = 1.0 * t1.actor.mapper.get_width(
t1.scene.renderer) / t1.scene.renderer.size[0]
height = 1.0 * t1.actor.mapper.get_height(
t1.scene.renderer) / t1.scene.renderer.size[1]
t1.x_position = 0.5 - t1.width / 2
t1.y_position = 1 - height
if (addTextIndexer):
#add default Text module for indicating scene index
self.sceneTextCount = Text()
self.sceneTextCount.text = "0"
mayavi.add_module(self.sceneTextCount)
self.sceneTextCount.actor.scaled_text = False
self.sceneTextCount.actor.text_property.font_size = 24
self.sceneTextCount.x_position = .95
self.sceneTextCount.y_position = .05
def add_source_data(self, data):
from enthought.mayavi.filters.poly_data_normals import PolyDataNormals
d = VTKDataSource()
d.data = data
obj = self.scene.add_child(d)
w = WarpScalar()
d.add_child(w)
n = PolyDataNormals()
n.filter.feature_angle = 45
w.add_child(n)
s = Surface()
n.add_child(s)
def view():
from enthought.mayavi.sources.vtk_data_source import VTKDataSource
from enthought.mayavi.filters.warp_scalar import WarpScalar
from enthought.mayavi.filters.poly_data_normals import PolyDataNormals
from enthought.mayavi.modules.surface import Surface
mayavi.new_scene()
src = VTKDataSource(data = spoints)
mayavi.add_source(src)
mayavi.add_filter(WarpScalar())
mayavi.add_filter(PolyDataNormals())
s = Surface()
mayavi.add_module(s)
def run(self):
from enthought.mayavi.sources.vtk_data_source import VTKDataSource
from enthought.mayavi.modules.surface import Surface
self._setupScene(showFault=False, showMaterials=False)
mesh = self._readMesh()
script = self.script
script.add_source(VTKDataSource(data=mesh))
script.engine.current_object.name = "Mesh"
surf = Surface()
script.add_module(surf)
surf.actor.property.color = (0, 1, 0)
surf = Surface()
script.add_module(surf)
surf.actor.property.representation = 'wireframe'
import vtk_geometry
vtk_geometry.setCamera(script.engine.current_scene.scene.camera)
return
def run(self):
from enthought.mayavi.sources.vtk_data_source import VTKDataSource
from enthought.mayavi.filters.threshold import Threshold
from enthought.mayavi.modules.surface import Surface
from enthought.mayavi.modules.scalar_cut_plane import ScalarCutPlane
self._setupScene()
data = self._readData()
script = self.script
script.add_source(VTKDataSource(data=data))
script.engine.current_object.name = "Error"
error = script.engine.current_object
threshold = Threshold()
script.add_filter(threshold)
threshold.lower_threshold = -3.0
surf = Surface()
script.add_filter(surf)
if showSlice:
surf.actor.property.opacity = 0.3
script.engine.current_object = error
slice = ScalarCutPlane()
script.add_module(slice)
slice.actor.property.opacity = 0.5
slice.implicit_plane.origin = (12.0, 12.0, -12.0)
slice.implicit_plane.normal = (0, -1.0, 0.0)
for obj in [slice, surf]:
colorbar = obj.module_manager.scalar_lut_manager
colorbar.data_range = (threshold.lower_threshold, -2.0)
colorbar.lut_mode = "hot"
colorbar.reverse_lut = True
colorbar.show_scalar_bar = True
colorbar.number_of_labels = 6
colorbar.scalar_bar.label_format = "%-3.1f"
w,h = colorbar.scalar_bar.position2
colorbar.scalar_bar.position2 = (w, 0.1)
light = script.engine.current_scene.scene.light_manager.lights[0]
light.elevation = 20.0
light.azimuth = -45.0
import vtk_geometry
vtk_geometry.setCamera(script.engine.current_scene.scene.camera)
return
def add_lines(self, points):
np = len(points) - 1
lines = scipy.zeros((np, 2), "l")
lines[:, 0] = scipy.arange(0, np - 0.5, 1, "l")
lines[:, 1] = scipy.arange(1, np + 0.5, 1, "l")
pd = tvtk.PolyData(points=points, lines=lines)
d = VTKDataSource()
d.data = pd
self.scene.add_child(d)
filter = tvtk.TubeFilter(number_of_sides=6)
filter.radius = 0.01
f = FilterBase(filter=filter, name="TubeFilter")
d.add_child(f)
s = Surface()
s.actor.mapper.scalar_visibility = False
d.add_child(s)
def view_model(): """Sets up the mayavi pipeline for the visualization. """ # 'mayavi' is always defined on the interpreter. s = Surface() mayavi.add_module(s) #Move legend to the bottom, rename it, and chg scale s.module_manager.scalar_lut_manager.lut_mode = 'RdBu' s.module_manager.scalar_lut_manager.show_scalar_bar = True s.module_manager.scalar_lut_manager.show_legend = True s.module_manager.scalar_lut_manager.scalar_bar_representation.orientation = 0 s.module_manager.scalar_lut_manager.scalar_bar_representation.position = array([ 0.1, 0.0]) s.module_manager.scalar_lut_manager.scalar_bar_representation.position2 = array([ 0.8 , 0.17]) s.module_manager.scalar_lut_manager.use_default_name = False s.module_manager.scalar_lut_manager.scalar_bar.title = 'density anomaly' s.module_manager.scalar_lut_manager.data_name = u'density anomaly'
def test_pickle(self):
"Test if pickling works."
# Test if saving a visualization and restoring it works.
d = self.data
sc, vec = self.make_3d_data()
d.scalar_data = sc
d.vector_data = vec
d.spacing = [1, 2, 3]
d.origin = [4, 5, 6]
d.start() # Start the object so it flushes the pipeline etc.
# Create an outline for the data.
o = Outline()
d.add_child(o)
o.start()
# Create a surface module.
surf = Surface()
d.add_child(surf)
data = pickle.dumps(d)
del d, surf, o
d = pickle.loads(data)
# We must explicitly start the object.
d.start()
mm = d.children[0]
o, surf = mm.children
# Test the unpciked state.
self.assertEqual(tuple(o.actor.actor.bounds),
(4., 5., 5., 7., 6., 9.))
self.assertEqual(surf.running, True)
self.assertEqual(o.running, True)
self.assertEqual(d.running, True)
self.assertEqual(numpy.allclose(d.spacing, [1, 2, 3]), True)
self.assertEqual(numpy.allclose(d.origin, [4, 5, 6]), True)
tps = numpy.transpose
expect = [tps(sc), tps(vec, (2,1,0,3))]
sc2 = surf.actor.mapper.input.point_data.scalars.to_array()
self.assertEqual(numpy.allclose(sc2.flatten(),
expect[0].flatten()), True)
vec2 = surf.actor.mapper.input.point_data.vectors.to_array()
self.assertEqual(numpy.allclose(vec2.flatten(),
expect[1].flatten()), True)
def run(self):
from enthought.mayavi.sources.vtk_data_source import VTKDataSource
from enthought.mayavi.filters.warp_vector import WarpVector
from enthought.mayavi.filters.extract_vector_norm import ExtractVectorNorm
from enthought.mayavi.modules.surface import Surface
from enthought.mayavi.modules.glyph import Glyph
self._setupScene(showFault=False, showMaterials=False)
data = self._readData()
script = self.script
script.add_source(VTKDataSource(data=data))
script.engine.current_object.name = "Solution"
warp = WarpVector()
warp.filter.scale_factor = scaleFactor
script.add_filter(warp)
norm = ExtractVectorNorm()
script.add_filter(norm)
surf = Surface()
script.add_module(surf)
glyph = Glyph()
script.add_module(glyph)
glyph.actor.property.color = (1,1,1)
glyph.actor.mapper.scalar_visibility = False
glyph.glyph.glyph_position = 'tail'
glyph.glyph.glyph.scale_factor = scaleFactor
glyph.glyph.glyph_source = glyph.glyph.glyph_list[1]
colorbar = script.engine.current_object.module_manager.scalar_lut_manager
colorbar.show_scalar_bar = True
colorbar.data_range = (0.0, 0.5)
colorbar.number_of_labels = 6
colorbar.scalar_bar.label_format = "%3.1f"
w,h = colorbar.scalar_bar.position2
colorbar.scalar_bar.position2 = (w, 0.1)
colorbar.data_name = "Displacement [m]"
import vtk_geometry
vtk_geometry.setCamera(script.engine.current_scene.scene.camera)
return
def _plotScene(self):
from enthought.mayavi.sources.vtk_data_source import VTKDataSource
from enthought.mayavi.filters.extract_vector_norm import ExtractVectorNorm
from enthought.mayavi.modules.outline import Outline
from enthought.mayavi.modules.axes import Axes
from enthought.mayavi.modules.surface import Surface
from enthought.tvtk.api import tvtk
script = self.script
script.new_scene()
w = script.get_active_window()
w.size = self.windowSize
scene = script.engine.current_scene.scene
scene.disable_render = True
scene.background = self.colorBg
scene.foreground = self.colorFg
t = 0.0
self.dataVtk = self.surfdata.toVtk(t)
script.engine.current_object.name = "Velocity"
script.add_source(VTKDataSource(data=self.dataVtk))
surf = Surface()
surf.actor.property.representation = "wireframe"
script.add_module(surf)
colorbar = script.engine.current_object.module_manager.scalar_lut_manager
colorbar.show_scalar_bar = True
colorbar.scalar_bar.label_format = "%3.1f"
colorbar.use_default_range = False
colorbar.data_range = (-3, 1)
colorbar.number_of_labels = 4
colorbar.data_name = "Velocity (m/s)"
colorbar.lut_mode = "hot"
colorbar.reverse_lut = self.lutReverse
scalar_bar = colorbar.scalar_bar_widget.representation
scalar_bar.position2 = (0.05, 0.33)
scalar_bar.position = (0.05, 0.05)
return
def main():
# Create some random points to view.
pd = tvtk.PolyData()
pd.points = np.random.random((1000, 3))
verts = np.arange(0, 1000, 1)
verts.shape = (1000, 1)
pd.verts = verts
pd.point_data.scalars = np.random.random(1000)
pd.point_data.scalars.name = 'scalars'
# Now visualize it using mayavi2.
from enthought.mayavi.sources.vtk_data_source import VTKDataSource
from enthought.mayavi.modules.outline import Outline
from enthought.mayavi.modules.surface import Surface
mayavi.new_scene()
d = VTKDataSource()
d.data = pd
mayavi.add_source(d)
mayavi.add_module(Outline())
s = Surface()
mayavi.add_module(s)
s.actor.property.set(representation='p', point_size=2)
# module, you should set opacity to a value below 1, in order to see all # isosurfaces. # # Using Surface module is straightforward: # # <codecell> from enthought.mayavi.modules.surface import Surface # <markdowncell> # then # # <codecell> s = Surface() s.enable_contours = True # we want contours enabled s.contour.auto_contours = True # we want isovalues automatically well-defined s.contour.number_of_contours = 10 # self-explanatory ;-) s.actor.property.opacity = 0.2 script.add_module(s) s.contour.minimum_contour = 0 s.contour.maximum_contour = 1 s.module_manager.scalar_lut_manager.data_range = [0, 1] # <markdowncell> # The scene should look like this: # # ScriptingMayavi2(2f)MainModules_attachments/module_surface.png #
savename = filename
scene = engine.new_scene()
scene.scene.off_screen_rendering = True
vtk_file_reader = engine.open(filename, scene)
scene.scene.background = (1.0, 1.0, 1.0)
from enthought.mayavi.filters.contour import Contour
contour = Contour()
engine.add_filter(contour, obj=None)
from enthought.mayavi.filters.set_active_attribute import SetActiveAttribute
set_active_attribute = SetActiveAttribute()
engine.add_filter(set_active_attribute, obj=None)
from enthought.mayavi.modules.surface import Surface
surface = Surface()
engine.add_module(surface, obj=None)
##Orientation axes
orientation_axes = OrientationAxes()
engine.add_module(orientation_axes, obj=None)
orientation_axes.text_property.shadow_offset = array([1, -1])
orientation_axes.text_property.font_family = 'times'
orientation_axes.text_property.shadow_offset = array([1, -1])
orientation_axes.text_property.font_size = 15
orientation_axes.axes.axis_labels = False
##
if os.path.isdir(dir + save_mname) == False:
os.mkdir(dir + save_mname)
def test_script_recording(self):
"Does script recording work correctly."
# Create a mayavi pipeline and record it.
tape = self.tape
e = NullEngine()
e.start()
# Start recording.
tape.recording = True
tape.register(e, known=True, script_id="engine")
e.new_scene()
# print tape.script
self.assertEqual(tape.lines[-1], "dummy_viewer = engine.new_scene()")
src = ParametricSurface()
e.add_source(src)
expect = "from enthought.mayavi.sources.parametric_surface " "import ParametricSurface"
self.assertEqual(tape.lines[-3], expect)
self.assertEqual(tape.lines[-2], "parametric_surface = ParametricSurface()")
self.assertEqual(tape.lines[-1], "engine.add_source(parametric_surface)")
src.function = "dini"
self.assertEqual(tape.lines[-1], "parametric_surface.function = 'dini'")
o = Outline()
e.add_module(o)
expect = "from enthought.mayavi.modules.outline import Outline"
self.assertEqual(tape.lines[-3], expect)
self.assertEqual(tape.lines[-2], "outline = Outline()")
self.assertEqual(tape.lines[-1], "engine.add_module(outline)")
o.actor.property.color = (1, 0, 0)
self.assertEqual(tape.lines[-1], "outline.actor.property.color = (1.0, 0.0, 0.0)")
s = Surface()
e.add_module(s)
expect = "from enthought.mayavi.modules.surface import Surface"
self.assertEqual(tape.lines[-3], expect)
self.assertEqual(tape.lines[-2], "surface = Surface()")
self.assertEqual(tape.lines[-1], "engine.add_module(surface)")
s.actor.property.representation = "wireframe"
self.assertEqual(tape.lines[-1], "surface.actor.property.representation = 'wireframe'")
o.actor.property.representation = "wireframe"
self.assertEqual(tape.lines[-1], "outline.actor.property.representation = 'wireframe'")
s.actor.property.opacity = 0.5
self.assertEqual(tape.lines[-1], "surface.actor.property.opacity = 0.5")
s.actor.mapper.scalar_visibility = False
self.assertEqual(tape.lines[-1], "surface.actor.mapper.scalar_visibility = False")
# print tape.script
# Stop recording and test.
tape.unregister(e)
tape.record("#end") # Placeholder
o.actor.property.opacity = 0.5
self.assertEqual(tape.lines[-1], "#end")
s.actor.property.color = (1, 0, 0)
self.assertEqual(tape.lines[-1], "#end")
s.enable_contours = True
self.assertEqual(tape.lines[-1], "#end")
src.function = "klein"
self.assertEqual(tape.lines[-1], "#end")
def view():
from enthought.mayavi.sources.vtk_data_source import VTKDataSource
#from enthought.mayavi.modules.outline import Outline
from enthought.mayavi.modules.surface import Surface
from enthought.mayavi.modules.axes import Axes
from enthought.mayavi.modules.text import Text
scene = mayavi.new_scene()
scene.scene.background = (1.0, 1.0, 1.0)
scene.scene.foreground = (0.0, 0.0, 0.0)
trj_src = VTKDataSource(data=trj_curve)
mayavi.add_source(trj_src)
# mayavi.add_module(Outline())
s = Surface()
mayavi.add_module(s)
s.actor.property.set(representation='w', color=(1., 0., 0.), line_width=1)
gt_src = VTKDataSource(data=gt_curve)
mayavi.add_source(gt_src)
#mayavi.add_module(Outline())
s = Surface()
mayavi.add_module(s)
s.actor.property.set(representation='w', color=(0., 1., 0.), line_width=2)
# skeleton nodes
if draw_skeleton:
# draw the nodes
skel_node_src = VTKDataSource(data=skel_nodes_pts)
mayavi.add_source(skel_node_src)
#mayavi.add_module(Outline())
s = Surface()
mayavi.add_module(s)
s.actor.property.set(representation='p',
point_size=4,
color=(0., 0., 1.0))
# draw edges between nodes
skel_curve_src = VTKDataSource(data=skel_curve)
mayavi.add_source(skel_curve_src)
#mayavi.add_module(Outline())
s = Surface()
mayavi.add_module(s)
s.actor.property.set(representation='w',
color=(1., 0., 1.0),
line_width=2)
# draw the links
skel_edge_src = VTKDataSource(data=skel_edges)
mayavi.add_source(skel_edge_src)
#mayavi.add_module(Outline())
s = Surface()
mayavi.add_module(s)
s.actor.property.set(representation='w',
color=(0., 0., 1.),
line_width=1)
a = Axes()
mayavi.add_module(a)
# Put up some text.
t = Text(text='VSLAM vs PhaseSpace',
x_position=0.2,
y_position=0.9,
width=0.8)
t.property.color = 1, 1, 0 # Bright yellow, yeah!
mayavi.add_module(t)
# <markdowncell> # then # # <codecell> ### for the metallic parallellepiped script.engine.current_object = src # current object must be set to the source eug1 = ExtractUnstructuredGrid() script.add_filter(eug1) eug1.filter.cell_clipping = True eug1.filter.cell_minimum = 342881 eug1.filter.cell_maximum = 345966 s = Surface() # the metallic is displayed using Surface module eug1.add_module(s) # the module must be added to the current filter s.actor.mapper.scalar_visibility = False s.actor.property.color = (0.509804, 0.5098040, 0.5490196) # grey color for the metallic parallellepiped ### we need also extract the required cells for and only for the vaccum script.engine.current_object = src # current object must be set to the source eug2 = ExtractUnstructuredGrid() script.add_filter(eug2) eug2.filter.cell_clipping = True eug2.filter.cell_minimum = 0 eug2.filter.cell_maximum = 342880 ### here, we can display the EM field using ScalarCutPlane/VectorCutPlane, ### Surface, Vectors modules as usual .../...
def f(x, y):
return numpy.sin(x * y) / (x * y)
x = numpy.arange(-7., 7.05, 0.1)
y = numpy.arange(-5., 5.05, 0.05)
from enthought.tvtk.tools import mlab
s = mlab.SurfRegular(x, y, f)
from enthought.mayavi.sources.vtk_data_source import VTKDataSource
d = VTKDataSource()
d.data = s.data
mayavi.add_source(d)
from enthought.mayavi.filters.warp_scalar import WarpScalar
w = WarpScalar()
mayavi.add_filter(w)
from enthought.mayavi.modules.outline import Outline
from enthought.mayavi.modules.surface import Surface
o = Outline()
s = Surface()
mayavi.add_module(o)
mayavi.add_module(s)
# <markdowncell>
# You can run this script by running "mayavi2 -n -x script.py", loading it
# through the menu (File -\> Open File), and pressing Ctrl+R, or entering
# "execfile('script.py') in the python shell.
#
# Surf_attachments/surf.png
#
# # Using Surface module is straightforward: # # <codecell> from enthought.mayavi.modules.surface import Surface # <markdowncell> # then # # <codecell> s = Surface() s.enable_contours = True # we want contours enabled s.contour.auto_contours = True # we want isovalues automatically well-defined s.contour.number_of_contours = 10 # self-explanatory ;-) s.actor.property.opacity = 0.2 script.add_module(s) s.contour.minimum_contour = 0 s.contour.maximum_contour = 1 s.module_manager.scalar_lut_manager.data_range = [0, 1] # <markdowncell> # The scene should look like this: # # ScriptingMayavi2(2f)MainModules_attachments/module_surface.png #
def _setupScene(self,
showFault=True,
showMaterials=True,
showFaultTaper=False):
"""
Plot axes, fault surface, and materials.
"""
from enthought.mayavi.modules.outline import Outline
from enthought.mayavi.modules.axes import Axes
from enthought.mayavi.modules.surface import Surface
# Create rendering scene
script = self.script
script.new_scene()
script.engine.current_scene.scene.background = (1, 1, 1)
script.engine.current_scene.scene.foreground = (0, 0, 0)
vtk_geometry.setCamera(script.engine.current_scene.scene.camera)
# Domain (axes and outline)
script.add_source(VTKDataSource(data=vtk_geometry.domain()))
script.engine.current_object.name = "Domain"
outline = Outline()
script.add_module(outline)
outline.actor.property.opacity = 0.2
axes = Axes()
axes.axes.x_label = "X (km)"
axes.axes.y_label = "Y (km)"
axes.axes.z_label = "Z (km)"
axes.axes.label_format = "%-0.1f"
script.add_module(axes)
# Fault surface
if showFault:
srcs = vtk_geometry.fault(showTaper=showFaultTaper)
for src in srcs:
script.add_source(VTKDataSource(data=src['object']))
script.engine.current_object.name = "Fault %s" % src['name']
surf = Surface()
script.add_module(surf)
surf.actor.property.color = (1, 0, 0)
if src['name'] == "taper":
surf.actor.property.opacity = 0.1
else:
surf.actor.property.opacity = 0.3
# Materials
if showMaterials:
srcs = vtk_geometry.materials()
for src in srcs:
script.add_source(VTKDataSource(data=src['object']))
script.engine.current_object.name = "Material %s" % src['name']
surf = Surface()
script.add_module(surf)
surf.actor.property.opacity = 0.1
if src['name'] == "elastic":
surf.actor.property.color = (1, 1, 0)
elif src['name'] == "viscoelastic":
surf.actor.property.color = (0, 1, 1)
return
from enthought.mayavi.filters.extract_unstructured_grid import ExtractUnstructuredGrid
# <markdowncell>
# then
#
# <codecell>
### for the metallic parallellepiped
script.engine.current_object = src # current object must be set to the source
eug1 = ExtractUnstructuredGrid()
script.add_filter(eug1)
eug1.filter.cell_clipping = True
eug1.filter.cell_minimum = 342881
eug1.filter.cell_maximum = 345966
s = Surface() # the metallic is displayed using Surface module
eug1.add_module(s) # the module must be added to the current filter
s.actor.mapper.scalar_visibility = False
s.actor.property.color = (0.509804, 0.5098040, 0.5490196
) # grey color for the metallic parallellepiped
### we need also extract the required cells for and only for the vaccum
script.engine.current_object = src # current object must be set to the source
eug2 = ExtractUnstructuredGrid()
script.add_filter(eug2)
eug2.filter.cell_clipping = True
eug2.filter.cell_minimum = 0
eug2.filter.cell_maximum = 342880
### here, we can display the EM field using ScalarCutPlane/VectorCutPlane,
### Surface, Vectors modules as usual
def do(self):
############################################################
# Imports.
script = self.script
from enthought.mayavi.sources.array_source import ArraySource
from enthought.mayavi.modules.outline import Outline
from enthought.mayavi.modules.surface import Surface
from enthought.mayavi.modules.vectors import Vectors
############################################################
# Create a new scene and set up the visualization.
s = self.new_scene()
d = ArraySource()
self.check_input_validation(d)
sc, vec = self.make_2d_data()
d.origin = (-1, -1, 0)
d.scalar_data = sc
d.vector_data = vec
script.add_source(d)
# Create an outline for the data.
o = Outline()
script.add_module(o)
# View the data.
s = Surface()
script.add_module(s)
v = Vectors()
script.add_module(v)
# Add a 3D data source
d = ArraySource()
sc, vec = self.make_3d_data()
d.scalar_data = sc
d.vector_data = vec
script.add_source(d)
# Create an outline for the data.
o = Outline()
script.add_module(o)
# View a slice.
s = Surface()
script.add_module(s)
v = Vectors()
script.add_module(v)
# Set the scene to a suitable view.
s.scene.z_plus_view()
c = s.scene.camera
c.azimuth(-30)
c.elevation(30)
self.check()
############################################################
# Test if saving a visualization and restoring it works.
bg = s.scene.background
# 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
# Set the scene to a suitable view.
s.scene.z_plus_view()
c = s.scene.camera
c.azimuth(-30)
c.elevation(30)
s.scene.background = bg
self.check()
############################################################
# Test if the MayaVi2 visualization can be deepcopied.
# Pop the source object.
sources = s.children
s.children = []
# Add it back to see if that works without error.
s.children.extend(sources)
s.scene.reset_zoom()
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.
sources1 = copy.deepcopy(sources)
s.children[:] = sources
s.scene.reset_zoom()
self.check()
