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 surf_regular(source):
"""Now visualize the data as done in mlab.
"""
w = WarpScalar()
source.add_child(w)
s = Surface()
w.add_child(s)
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 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 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.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 setup_pipeline(self):
"""Override this method so that it *creates* the tvtk
pipeline.
This method is invoked when the object is initialized via
`__init__`. Note that at the time this method is called, the
tvtk data pipeline will *not* yet be setup. So upstream data
will not be available. The idea is that you simply create the
basic objects and setup those parts of the pipeline not
dependent on upstream sources and filters. You should also
set the `actors` attribute up at this point.
"""
# Create the objects.
self.implicit_plane = ImplicitPlane()
self.cutter = Cutter()
self.contour = Contour(auto_contours=True, number_of_contours=10)
self.warp_scalar = WarpScalar()
self.normals = PolyDataNormals()
self.actor = Actor()
# Setup the actor suitably for this module.
prop = self.actor.property
prop.line_width = 2.0
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
import re
print " done."
frames = glob("output/frame_scal*.vtk")
frames.sort()
max_frame_number = int(re.search("(\d+)", frames[-1]).groups()[0])
print "plotting the main frame..."
width = 640
height = 480
mlab.figure(size=(width, height+32))
mlab.options.offscreen = True
engine = mlab.get_engine()
vtk_file_reader = engine.open(u'output/frame_scal0000.vtk')
warp_scalar = WarpScalar()
engine.add_filter(warp_scalar, vtk_file_reader)
surface = Surface()
engine.add_filter(surface, warp_scalar)
warp_scalar.filter.normal = array([ 0., 0., 1.])
warp_scalar.filter.scale_factor = 10.0
module_manager = engine.scenes[0].children[0].children[0].children[0]
module_manager.scalar_lut_manager.use_default_range = False
module_manager.scalar_lut_manager.data_range = array([-1.5, 1.5])
module_manager.scalar_lut_manager.show_scalar_bar = True
mlab.view(-122, 53, 26, array([7.5, 2.5, -0.11]))
mlab.roll(40)
print " done."
def do(self):
############################################################
# Imports.
script = self.script
from enthought.mayavi.filters.optional import Optional
from enthought.mayavi.filters.warp_scalar import WarpScalar
from enthought.mayavi.filters.cut_plane import CutPlane
from enthought.mayavi.components.poly_data_normals import PolyDataNormals
from enthought.mayavi.components.contour import Contour
from enthought.mayavi.components.actor import Actor
from enthought.mayavi.modules.generic_module import GenericModule
from enthought.mayavi.sources.vtk_xml_file_reader import VTKXMLFileReader
############################################################
# Create a new scene and set up the visualization.
s = self.new_scene()
# Read a VTK (old style) data file.
r = VTKXMLFileReader()
r.initialize(get_example_data('fire_ug.vtu'))
script.add_source(r)
# We now create the complete equivalent of a ScalarCutPlane in
# the next block!
cp = CutPlane()
w = WarpScalar()
warper = Optional(filter=w, label_text='Enable warping', enabled=False)
c = Contour()
ctr = Optional(filter=c, label_text='Enable contours', enabled=False)
p = PolyDataNormals(name='Normals')
normals = Optional(filter=p, label_text='Compute normals', enabled=False)
a = Actor()
components = [cp, warper, ctr, normals, a]
m = GenericModule(name='ScalarCutPlane',
components=components,
contour=c, actor=a)
script.add_module(m)
s.scene.isometric_view()
########################################
# do the testing.
def check(mod):
"""Check if test status is OK for the given module."""
cut, warper, ctr, normals, a = mod.components
c = ctr.filter
# The intermediate ones are disabled.
assert normals.outputs[0] is cut.outputs[0]
# Enable the contours.
ctr.enabled = True
assert ctr.outputs[0] is c.outputs[0]
assert ctr.outputs[0] is normals.outputs[0]
rng = normals.outputs[0].point_data.scalars.range
assert (rng[1] - rng[0]) < 1e-4
# Turn on auto-contours
c.auto_contours = True
assert len(normals.outputs[0].points) == 0
# Increase number of contours and the range should change.
c.number_of_contours = 10
assert len(normals.outputs[0].points) != 0
rng = normals.outputs[0].point_data.scalars.range
assert rng[0] < rng[1]
# Check if pipeline_changed is correctly propagated.
old = normals.outputs[0]
assert a.mapper.scalar_mode == 'default'
c.filled_contours = True
assert normals.outputs[0] != old
assert normals.outputs[0] is c.outputs[0]
# Check if the actor responds correctly to the
# filled_contour change.
assert a.mapper.scalar_mode == 'use_cell_data'
# Set back everything to original state.
c.filled_contours = False
assert a.mapper.scalar_mode == 'default'
c.number_of_contours = 1
c.auto_contours = False
ctr.enabled = False
assert normals.outputs[0] is cut.outputs[0]
check(m)
############################################################
# 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
s.scene.isometric_view()
# Now do the check.
m = s.children[0].children[0].children[0]
check(m)
############################################################
# 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.
m = s.children[0].children[0].children[0]
s.scene.isometric_view()
check(m)
# 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.
m = s.children[0].children[0].children[0]
s.scene.isometric_view()
check(m)
