def check(self):
""" Configures the scalar cut plane and checks the cutter output
changes when the plane is changed.
"""
e = self.e
# An interactive scalar cut plane.
cp = ScalarCutPlane()
e.add_module(cp)
self.cp = cp
ip = cp.implicit_plane
ip.origin = -1.5, -1.5, -1.5
poly_data = cp.cutter.outputs[0].output
initial_cells = poly_data.number_of_cells
# Change the plane normal
ip.normal = 1, 1, 1
updated_cells = poly_data.number_of_cells
self.assertNotEqual(initial_cells, updated_cells)
# Change the plane origin
ip.normal = 1, 1, 1
updated_cells = poly_data.number_of_cells
self.assertNotEqual(initial_cells, updated_cells)
def _cut_plane(self, axis, slice_at=None, ratio=None):
"""
Slice the data at a certain depth, or for a given depth cross section,
dependent on choice. Format of depth is positive
:type axis: str
:param axis: choice of axis to slice along, 'X', 'Y' or 'Z'
:type slice_at: float
:param slice_at: depth or distance value in meters to slice at
:type ratio: float
:param ratio: ratio of the axis bounds to slice at, from 0 to 1
"""
assert (slice_at is not None or ratio is not None)
cut = ScalarCutPlane()
self.engine.add_filter(cut, self.vtkfr)
# Set some attributes of the cut plane
origin = cut.implicit_plane.origin
if axis == "X":
cut.implicit_plane.origin = array([slice_at, origin[1], origin[2]])
cut.implicit_plane.normal = array([1, 0, 0])
elif axis == "Y":
cut.implicit_plane.origin = array([origin[0], slice_at, origin[2]])
cut.implicit_plane.normal = array([0, 1, 0])
elif axis == "Z":
cut.implicit_plane.origin = array([origin[0], origin[1], slice_at])
cut.implicit_plane.normal = array([0, 0, 1])
cut.implicit_plane.widget.enabled = False
return cut
def contour():
"""The script itself. We needn't have defined a function but
having a function makes this more reusable.
"""
# 'mayavi' is always defined on the interpreter.
# Create a new scene.
mayavi.new_scene()
# Read a VTK (old style) data file.
r = VTKFileReader()
filename = join(mayavi2.get_data_dir(dirname(abspath(__file__))),
'heart.vtk')
r.initialize(filename)
mayavi.add_source(r)
# Create an outline for the data.
o = Outline()
mayavi.add_module(o)
# Create three simple grid plane modules.
# First normal to 'x' axis.
gp = GridPlane()
mayavi.add_module(gp)
# Second normal to 'y' axis.
gp = GridPlane()
mayavi.add_module(gp)
gp.grid_plane.axis = 'y'
# Third normal to 'z' axis.
gp = GridPlane()
mayavi.add_module(gp)
gp.grid_plane.axis = 'z'
# Create one ContourGridPlane normal to the 'x' axis.
cgp = ContourGridPlane()
mayavi.add_module(cgp)
# Set the position to the middle of the data.
cgp.grid_plane.position = 15
# Another with filled contours normal to 'y' axis.
cgp = ContourGridPlane()
mayavi.add_module(cgp)
# Set the axis and position to the middle of the data.
cgp.grid_plane.axis = 'y'
cgp.grid_plane.position = 15
cgp.contour.filled_contours = True
# An isosurface module.
iso = IsoSurface(compute_normals=True)
mayavi.add_module(iso)
iso.contour.contours = [220.0]
# An interactive scalar cut plane.
cp = ScalarCutPlane()
mayavi.add_module(cp)
cp.implicit_plane.normal = 0, 0, 1
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)
# Create an outline for the data.
o = Outline()
e.add_module(o)
# Create one ContourGridPlane normal to the 'x' axis.
cgp1 = ContourGridPlane()
e.add_module(cgp1)
# Set the position to the middle of the data.
cgp1.grid_plane.position = 15
# Another with filled contours normal to 'y' axis.
cgp2 = ContourGridPlane()
cgp2.contour.filled_contours = True
# Set the axis and position to the middle of the data.
cgp2.grid_plane.axis = 'y'
cgp2.grid_plane.position = 15
e.add_module(cgp2)
# An isosurface module.
iso = IsoSurface(compute_normals=True)
e.add_module(iso)
iso.contour.contours = [5]
# An interactive scalar cut plane.
cp = ScalarCutPlane()
e.add_module(cp)
ip = cp.implicit_plane
ip.normal = 0, 0, 1
ip.origin = 0.5, 0.5, 1.0
# Since this is running offscreen this seems necessary.
ip.widget.origin = 0.5, 0.5, 1.0
ip.widget.enabled = False
self.scene = e.current_scene
self.cgp2 = cgp2
self.iso = iso
self.cp = cp
return
def setUp(self):
e = NullEngine()
# Uncomment to see visualization for debugging etc.
#e = Engine()
e.start()
e.new_scene()
self.e=e
# Read a VTK XML data file.
r = VTKXMLFileReader()
r.initialize(get_example_data('cube.vti'))
e.add_source(r)
# Create an outline for the data.
o = Outline()
e.add_module(o)
# Create one ContourGridPlane normal to the 'x' axis.
cgp1 = ContourGridPlane()
e.add_module(cgp1)
# Set the position to the middle of the data.
cgp1.grid_plane.position = 1
# Another with filled contours normal to 'y' axis.
cgp2 = ContourGridPlane()
cgp2.contour.filled_contours = True
# Set the axis and position to the middle of the data.
cgp2.grid_plane.axis = 'y'
cgp2.grid_plane.position = 1
e.add_module(cgp2)
# An interactive scalar cut plane.
cp = ScalarCutPlane()
e.add_module(cp)
ip = cp.implicit_plane
ip.normal = 0,0,1
ip.origin = 0.5, 0.5, 1.0
# Since this is running offscreen this seems necessary.
ip.widget.origin = 0.5, 0.5, 1.0
ip.widget.enabled = False
self.scene = e.current_scene
self.cgp2=cgp2
self.cp=cp
return
def do(self):
############################################################
# Imports.
script = self.script
from mayavi.sources.vtk_file_reader import VTKFileReader
from mayavi.modules.outline import Outline
from mayavi.modules.iso_surface import IsoSurface
from mayavi.modules.contour_grid_plane \
import ContourGridPlane
from mayavi.modules.scalar_cut_plane import ScalarCutPlane
############################################################
# 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)
# Create an outline for the data.
o = Outline()
script.add_module(o)
# Create one ContourGridPlane normal to the 'x' axis.
cgp1 = ContourGridPlane()
script.add_module(cgp1)
# Set the position to the middle of the data.
cgp1.grid_plane.position = 15
# Another with filled contours normal to 'y' axis.
cgp2 = ContourGridPlane()
cgp2.contour.filled_contours = True
# Set the axis and position to the middle of the data.
cgp2.grid_plane.axis = 'y'
cgp2.grid_plane.position = 15
script.add_module(cgp2)
# An isosurface module.
iso = IsoSurface(compute_normals=True)
script.add_module(iso)
iso.contour.contours = [200.0]
# An interactive scalar cut plane.
cp = ScalarCutPlane()
script.add_module(cp)
ip = cp.implicit_plane
ip.normal = 0, 0, 1
ip.origin = 0, 0, 5
ip.widget.enabled = False
# Set the scene to an isometric view.
s.scene.isometric_view()
# Now test.
self.check()
############################################################
# Test if the modules respond correctly when the components
# are changed.
ctr = cgp2.contour
cgp2.contour = ctr.__class__()
cgp2.contour = ctr
cgp2.actor = cgp2.actor.__class__()
iso.contour = iso.contour.__class__()
iso.contour.contours = [200.0]
iso.actor = iso.actor.__class__()
iso.normals = iso.normals.__class__()
ip = cp.implicit_plane
cp.implicit_plane = cp.implicit_plane.__class__()
cp.implicit_plane = ip
ip.widget.enabled = False
cp.contour = cp.contour.__class__()
cp.cutter = cp.cutter.__class__()
cp.actor = cp.actor.__class__()
s.render()
# Now check.
self.check()
############################################################
# 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
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 set the enabled status of the widget, this is impossible
# to get correctly.
cp = source.children[0].children[-1]
cp.implicit_plane.widget.enabled = False
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
cp = source1.children[0].children[-1]
cp.implicit_plane.widget.enabled = False
self.check()
def plot(self):
'''
Plot a 3D visualisation of the Voronoi grid using mayavi.
This method requires mayavi to be installed and also needs the vertices
information to be available (see the class constructor).
Note that in order for this method to work in an interactive IPython session,
a series of environment variables and proper switches need to be used
depending on your system configuration. For instance, on a Linux machine
with PyQt4 and a recent IPython version, the following bash startup
command for IPython can be used:
``ETS_TOOLKIT=qt4 QT_API=pyqt ipython --gui=qt4``
This sets both the mayavi and the IPython GUI toolkit to qt4, and the ``QT_API``
variable is used to specify that we want the ``pyqt`` API (as opposed to the
``pyside`` alternative API - PySide is an alternative implementation of PyQt).
It should be possible to get this method working on different configurations,
but the details will be highly system-dependent.
'''
if not self._with_vertices:
raise ValueError(
'the class must be constructed with \'with_vertices=True\' in order to support plotting'
)
import numpy as np
try:
from tvtk.api import tvtk
from mayavi.api import Engine
from mayavi import mlab
from mayavi.sources.vtk_data_source import VTKDataSource
from mayavi.modules.surface import Surface
from mayavi.modules.scalar_cut_plane import ScalarCutPlane
except ImportError:
raise ImportError(
'the plot method requires Mayavi, please make sure it is correctly installed'
)
# Shortcut.
vertices = self._neighbours_table['vertices']
# This is a list of all the vertices composing all voronoi cells.
# points = [[x1,y1,z1],[x2,y2,z2],...]
points = []
# Array to describe each voronoi cell in terms of the points list above. E.g.,
# cells = [4,0,1,2,3,5,4,5,6,7,8]
# This describes two cells, the first with 4 vertices whose indices in the points array
# are 0,1,2,3, the second with 5 vertices whose indices are 4,5,6,7,8.
cells = []
cur_cell_idx = 0
# Indices in the cells array where each new cell starts. In the example above,
# offset = [0,5]
offset = []
cur_offset = 0
# Array of cell types. Cells will all be of the same type.
cell_types = []
# Build the above quantities.
for v in vertices:
# Drop the empty vertices coordinates, signalled by NaN.
arr = v[~np.isnan(v)]
assert (len(arr) % 3 == 0)
tmp = np.split(arr, len(arr) / 3)
# Append the vertices.
points = points + tmp
# Append the cell description.
cells = cells + \
[len(tmp)] + range(cur_cell_idx, cur_cell_idx + len(tmp))
cur_cell_idx += len(tmp)
# Append the offset info.
offset.append(cur_offset)
cur_offset += len(tmp) + 1
# Append the cell type.
cell_types.append(tvtk.ConvexPointSet().cell_type)
# Cache the sites' positions.
sites_arr = self._neighbours_table['coordinates']
# Setup the Mayavi engine and figure.
e = Engine()
e.start()
fig = mlab.figure(engine=e)
# Plot the sites.
mlab.points3d(sites_arr[:, 0],
sites_arr[:, 1],
sites_arr[:, 2],
figure=fig)
# Plot the cells with coloured surfaces.
# This is just an array of scalars to assign a "temperature" to each cell vertex, which will be
# used for coloring purposes.
temperature = np.arange(0, len(points) * 10, 10, 'd')
# Initialise the array of cells.
cell_array = tvtk.CellArray()
cell_array.set_cells(len(vertices), np.array(cells))
# Initialise the unstructured grid object.
ug = tvtk.UnstructuredGrid(points=np.array(points))
ug.set_cells(np.array(cell_types), np.array(offset), cell_array)
ug.point_data.scalars = temperature
ug.point_data.scalars.name = 'temperature'
# Create a data source from the unstructured grid object.
src = VTKDataSource(data=ug)
# Add the source to the engine.
e.add_source(src)
# Create a surface object with opacity 0.5
surf = Surface()
surf.actor.property.opacity = 0.5
# Add the surface object to the engine.
e.add_module(surf)
# Add a cut plane as well.
e.add_module(ScalarCutPlane())
# Create another representation of the grid, this time using only white wireframe
# to highlight to shape of the cells.
# Rebuild the ug.
ug = tvtk.UnstructuredGrid(points=np.array(points))
ug.set_cells(np.array(cell_types), np.array(offset), cell_array)
src = VTKDataSource(data=ug)
e.add_source(src)
surf = Surface()
surf.actor.property.representation = 'wireframe'
e.add_module(surf)
cp = ScalarCutPlane()
e.add_module(cp)
@author: Schmulius """ from mayavi.modules.scalar_cut_plane import ScalarCutPlane from pyface.timer.api import Timer from mayavi.core.api import Engine from mayavi.core.base import Base from mayavi.core.module import Module from mayavi.core.lut_manager import LUTManager from mayavi.core.common import handle_children_state, exception from mayavi.core.pipeline_info import PipelineInfo scp = Engine() scp.start() scene = scp.new_scene() scp = ScalarCutPlane() # set scp as ScalarCutPlane() module # add module to the scene scp.implicit_plane.normal = (1, 0, 0) # set normal to Ox axis # set origin to (i=10, j=25, k=25) i.e. integers for a structured grid scp.implicit_plane.origin = (10, 25, 25) # set origin to (x=1.0, y=2.5, z=2.5) i.e. reals for unstructured grids # scp.implicit_plane.origin = (1.0, 2.5, 2.5) scp.implicit_plane.widget.enabled = True scp.actor.property.diffuse = 0.0 # set some color properties scp.actor.property.ambient = 1.0 # scp.actor.property.opacity = 1.0 # #scp.module_manager.scalar_lut_manager.data_range = [0, 1]
def do(self):
# Setup the source.
self.make_data()
from mayavi.modules.outline import Outline
from mayavi.modules.iso_surface import IsoSurface
from mayavi.modules.contour_grid_plane \
import ContourGridPlane
from mayavi.modules.scalar_cut_plane import ScalarCutPlane
script = self.script
s = script.engine.current_scene
# Create an outline for the data.
o = Outline()
script.add_module(o)
# Create one ContourGridPlane normal to the 'x' axis.
cgp = ContourGridPlane()
script.add_module(cgp)
# Set the position to the middle of the data.
cgp.grid_plane.position = 15
# Another with filled contours normal to 'y' axis.
cgp = ContourGridPlane()
cgp.contour.filled_contours = True
# Set the axis and position to the middle of the data.
cgp.grid_plane.axis = 'y'
cgp.grid_plane.position = 15
script.add_module(cgp)
# An isosurface module.
iso = IsoSurface(compute_normals=True)
script.add_module(iso)
iso.contour.contours = [200.0]
# An interactive scalar cut plane.
cp = ScalarCutPlane()
script.add_module(cp)
ip = cp.implicit_plane
ip.normal = 0, 0, 1
ip.origin = 0, 0, 5
ip.widget.enabled = False
# Set the scene to an isometric view.
s.scene.isometric_view()
self.check()
############################################################
# Test if saving a visualization and restoring it works.
# Save visualization.
f = BytesIO()
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
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 set the enabled status of the widget, this is impossible
# to get correctly.
cp = source.children[0].children[-1]
cp.implicit_plane.widget.enabled = False
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
cp = source1.children[0].children[-1]
cp.implicit_plane.widget.enabled = False
self.check()
def do(self):
############################################################
# Imports.
script = self.script
from mayavi.sources.vtk_file_reader import VTKFileReader
from mayavi.modules.outline import Outline
from mayavi.modules.iso_surface import IsoSurface
from mayavi.modules.contour_grid_plane \
import ContourGridPlane
from mayavi.modules.scalar_cut_plane import ScalarCutPlane
############################################################
# 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)
# Create an outline for the data.
o = Outline()
script.add_module(o)
# Create one ContourGridPlane normal to the 'x' axis.
cgp1 = ContourGridPlane()
script.add_module(cgp1)
# Set the position to the middle of the data.
cgp1.grid_plane.position = 15
# Another with filled contours normal to 'y' axis.
cgp2 = ContourGridPlane()
cgp2.contour.filled_contours = True
# Set the axis and position to the middle of the data.
cgp2.grid_plane.axis = 'y'
cgp2.grid_plane.position = 15
script.add_module(cgp2)
# An isosurface module.
iso = IsoSurface(compute_normals=True)
script.add_module(iso)
iso.contour.contours = [200.0]
# An interactive scalar cut plane.
cp = ScalarCutPlane()
script.add_module(cp)
ip = cp.implicit_plane
ip.normal = 0,0,1
ip.origin = 0,0,5
ip.widget.enabled = False
# Set the scene to an isometric view.
s.scene.isometric_view()
# Now test.
self.check()
############################################################
# Test if the modules respond correctly when the components
# are changed.
ctr = cgp2.contour
cgp2.contour = ctr.__class__()
cgp2.contour = ctr
cgp2.actor = cgp2.actor.__class__()
iso.contour = iso.contour.__class__()
iso.contour.contours = [200.0]
iso.actor = iso.actor.__class__()
iso.normals = iso.normals.__class__()
ip = cp.implicit_plane
cp.implicit_plane = cp.implicit_plane.__class__()
cp.implicit_plane = ip
ip.widget.enabled = False
cp.contour = cp.contour.__class__()
cp.cutter = cp.cutter.__class__()
cp.actor = cp.actor.__class__()
s.render()
# Now check.
self.check()
############################################################
# 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
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 set the enabled status of the widget, this is impossible
# to get correctly.
cp = source.children[0].children[-1]
cp.implicit_plane.widget.enabled = False
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
cp = source1.children[0].children[-1]
cp.implicit_plane.widget.enabled = False
self.check()
def do_profile(self):
############################################################
# Imports.
############################################################
script = self.script
from mayavi.sources.vtk_file_reader import VTKFileReader
from mayavi.modules.outline import Outline
from mayavi.modules.iso_surface import IsoSurface
from mayavi.modules.contour_grid_plane \
import ContourGridPlane
from mayavi.modules.scalar_cut_plane import ScalarCutPlane
############################################################
# 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)
# Create an outline for the data.
o = Outline()
script.add_module(o)
# Create one ContourGridPlane normal to the 'x' axis.
cgp1 = ContourGridPlane()
script.add_module(cgp1)
# Set the position to the middle of the data.
cgp1.grid_plane.position = 15
# Another with filled contours normal to 'y' axis.
cgp2 = ContourGridPlane()
cgp2.contour.filled_contours = True
# Set the axis and position to the middle of the data.
cgp2.grid_plane.axis = 'y'
cgp2.grid_plane.position = 15
script.add_module(cgp2)
# An isosurface module.
iso = IsoSurface(compute_normals=True)
script.add_module(iso)
iso.contour.contours = [200.0]
# An interactive scalar cut plane.
cp = ScalarCutPlane()
script.add_module(cp)
ip = cp.implicit_plane
ip.normal = 0, 0, 1
ip.origin = 0, 0, 5
ip.widget.enabled = False
# Set the scene to an isometric view.
s.scene.isometric_view()
s.render()
# Remove existing scene.
engine = script.engine
engine.close_scene(s)
