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 view3d(sgrid):
from enthought.mayavi.sources.vtk_data_source import VTKDataSource
from enthought.mayavi.modules.api import Outline, GridPlane
mayavi.new_scene()
src = VTKDataSource(data=sgrid)
mayavi.add_source(src)
mayavi.add_module(Outline())
g = GridPlane()
g.grid_plane.axis = 'x'
mayavi.add_module(g)
def offscreen_render(filename, do_volume_rendering):
# Create the MayaVi offscreen engine and start it.
e = OffScreenEngine()
# Starting the engine registers the engine with the registry and
# notifies others that the engine is ready.
e.start()
# Create a new scene.
win = e.new_scene()
# Now setup a normal MayaVi pipeline.
src = VTKXMLFileReader()
src.initialize(filename)
e.add_source(src)
# outline (make it black, enlarge width)
o = Outline()
e.add_module(o)
o.actor.property.color = (0, 0, 0)
o.actor.property.line_width = 1.5
if (do_volume_rendering == 0):
# image plane widgets
ipwx = ImagePlaneWidget()
e.add_module(ipwx)
ipwy = ImagePlaneWidget()
e.add_module(ipwy)
ipwy.ipw.plane_orientation = 'y_axes'
ipwz = ImagePlaneWidget()
e.add_module(ipwz)
ipwz.ipw.plane_orientation = 'z_axes'
else:
# volume rendering
volren = Volume()
e.add_module(volren)
win.scene.isometric_view()
# Set the view.
s = e.current_scene
cam = s.scene.camera
#cam.azimuth(45)
#cam.elevation(15)
cam.zoom(1.0)
cam.view_up = [-0.1, 0.89, -0.546]
# Change the size argument to anything you want.
win.scene.save(filename + '.jpg', size=(600, 600))
def main():
mayavi.new_scene()
# Read the data:
r = VTKXMLFileReader()
filename = sys.argv[1]
#'implode3d_gpu_d_0000380.vti'
r.initialize(filename)
mayavi.add_source(r)
# Simple outline for the data.
o = Outline()
mayavi.add_module(o)
# load the Volume rendering module
v = Volume()
mayavi.add_module(v)
def main():
# Create the MayaVi offscreen engine and start it.
e = OffScreenEngine()
# Starting the engine registers the engine with the registry and
# notifies others that the engine is ready.
e.start()
# Create a new scene.
win = e.new_scene()
# Now setup a normal MayaVi pipeline.
src = VTKXMLFileReader()
src.initialize(
join(get_data_dir(dirname(abspath(__file__))), 'fire_ug.vtu'))
e.add_source(src)
e.add_module(Outline())
e.add_module(ScalarCutPlane())
e.add_module(Streamline())
win.scene.isometric_view()
# Change the size argument to anything you want.
win.scene.save('offscreen.png', size=(800, 800))
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 main():
# Create the MayaVi engine and start it.
e = Engine()
# Starting the engine registers the engine with the registry and
# notifies others that the engine is ready.
e.start()
# Do this if you need to see the MayaVi tree view UI.
ev = EngineView(engine=e)
ui = ev.edit_traits()
# Create a new scene.
scene = e.new_scene()
# Now create a new scene just for kicks.
scene1 = e.new_scene()
# Now setup a normal MayaVi pipeline.
src = VTKXMLFileReader()
src.initialize(join(get_data_dir(abspath(__file__)), 'fire_ug.vtu'))
e.add_source(src)
e.add_module(Outline())
e.add_module(ScalarCutPlane())
e.add_module(Streamline())
return e, ui
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()
def plot_slice_mayavi(dat_filename, output_file, hyp_x, hyp_y, hyp_z,
search_grid_file_name, max_stack_value):
base_path = os.getenv('WAVELOC_PATH')
lib_path = "%s/lib" % base_path
# grid geometry
hdr_file = lib_path + os.sep + search_grid_file_name
# detection
detection = 50
# stations
stations_file = "%s/coord_stations_piton" % lib_path
sta = StationList()
sta.read_from_file(stations_file)
# create the object to contain the stations
pd = tvtk.PolyData()
pd.points = [[s.x / 1000.0, s.y / 1000.0, -s.elev / 1000.0]
for s in sta.stations.values()]
# create the object to contain the stations
try:
pd_hyp = tvtk.PolyData()
pd_hyp.points = [[hyp_x, hyp_y, hyp_z]]
except TypeError:
pass
# read the dat file
print dat_filename
data = QDGrid()
data.read_NLL_hdr_file(hdr_file)
data.buf = numpy.fromfile(dat_filename, dtype=numpy.int16)
max_ib = numpy.argmax(data.buf)
print max_ib
max_val = data.buf[max_ib]
ix, iy, iz = data.get_ix_iy_iz(max_ib)
#data.buf=numpy.array(data.buf, dtype=numpy.float)
data.buf.shape = (data.nx, data.ny, data.nz)
# 'mayavi' is always defined on the interpreter.
e = OffScreenEngine()
#e = Engine()
e.start()
win = e.new_scene(magnification=1)
e.current_scene.scene.off_screen_rendering = True
win.scene.isometric_view()
# Make the data and add it to the pipeline.
src = ArraySource(transpose_input_array=True)
src.scalar_data = data.buf
src.spacing = (data.dx, data.dy, -data.dz)
src.origin = (data.x_orig, data.y_orig, -data.z_orig)
e.add_source(src)
# Visualize the data.
o = Outline()
e.add_module(o)
lut = e.scenes[0].children[0].children[0].scalar_lut_manager
lut.data_range = [-1, max_stack_value]
lut.show_legend = True
lut.data_name = 'Stack'
# Create one ContourGridPlane normal to the 'x' axis.
cgp = ContourGridPlane()
e.add_module(cgp)
# Set the position to the middle of the data.
if max_val > detection:
cgp.grid_plane.position = ix
else:
cgp.grid_plane.position = data.nx / 2
cgp.contour.filled_contours = True
cgp.actor.property.opacity = 0.6
output = cgp.grid_plane.outputs[0]
x_data = numpy.array(output.point_data.scalars.to_array())
# Another with filled contours normal to 'y' axis.
cgp = ContourGridPlane()
e.add_module(cgp)
# Set the axis and position to the middle of the data.
cgp.grid_plane.axis = 'y'
if max_val > detection:
cgp.grid_plane.position = iy
else:
cgp.grid_plane.position = data.ny / 2
cgp.contour.filled_contours = True
cgp.actor.property.opacity = 0.6
output = cgp.grid_plane.outputs[0]
y_data = numpy.array(output.point_data.scalars.to_array())
# Another with filled contours normal to 'z' axis.
cgp = ContourGridPlane()
e.add_module(cgp)
# Set the axis and position to the middle of the data.
cgp.grid_plane.axis = 'z'
if max_val > detection:
cgp.grid_plane.position = iz
else:
cgp.grid_plane.position = data.nz / 2
cgp.contour.filled_contours = True
cgp.actor.property.opacity = 0.6
output = cgp.grid_plane.outputs[0]
z_data = numpy.array(output.point_data.scalars.to_array())
a = Axes()
e.add_module(a)
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
d = VTKDataSource()
d.data = pd_hyp
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.5
g.actor.property.color = (0.0, 0.0, 0.0)
#view(azimuth=-60,elevation=60,distance=120)
win.scene.save(output_file, size=(800, 800))
e.stop()
del win
del e
return (x_data, y_data, z_data)