class Prop(tvtk_base.TVTKBase):
def __init__(self, obj=None, update=1, **traits):
tvtk_base.TVTKBase.__init__(
self, vtk.vtkProperty, obj, update, **traits
)
edge_visibility = tvtk_base.false_bool_trait
def _edge_visibility_changed(self, old_val, new_val):
self._do_change(self._vtk_obj.SetEdgeVisibility, self.edge_visibility_)
representation = tvtk_base.RevPrefixMap(
{'points': 0, 'wireframe': 1, 'surface': 2},
4, 5, default_value='surface')
def _representation_changed(self, old_val, new_val):
self._do_change(self._vtk_obj.SetRepresentation, self.representation_)
opacity = traits.Trait(1.0, traits.Range(0.0, 1.0))
def _opacity_changed(self, old_val, new_val):
self._do_change(self._vtk_obj.SetOpacity,
self.opacity)
specular_color = tvtk_base.vtk_color_trait((1.0, 1.0, 1.0))
def _specular_color_changed(self, old_val, new_val):
self._do_change(self._vtk_obj.SetSpecularColor,
self.specular_color, 1)
diffuse_color = tvtk_base.vtk_color_trait((1.0, 1.0, 1.0))
def _diffuse_color_changed(self, old_val, new_val):
self._do_change(self._vtk_obj.SetDiffuseColor,
self.diffuse_color, 1)
color = tvtk_base.vtk_color_trait((1.0, 1.0, 1.0))
def _color_changed(self, old_val, new_val):
self._do_change(self._vtk_obj.SetColor,
self.color)
_updateable_traits_ = (('edge_visibility', 'GetEdgeVisibility'),
('opacity', 'GetOpacity'),
('specular_color', 'GetSpecularColor'),
('color', 'GetColor'),
('diffuse_color', 'GetDiffuseColor'),
('representation', 'GetRepresentation'))
class Glyphs(MLabBase):
# The source glyph which is placed at various locations.
glyph_source = Any
# A Glyph3D instance replicates the glyph_sources at various
# points.
glyph = Instance(tvtk.Glyph3D, (), {
'vector_mode': 'use_vector',
'scale_mode': 'data_scaling_off'
})
# Color of the glyphs.
color = vtk_color_trait((1.0, 1.0, 1.0))
def __init__(self, points, vectors=None, scalars=None, **traits):
super(Glyphs, self).__init__(**traits)
if vectors is not None:
assert len(points) == len(vectors)
if scalars is not None:
assert len(points) == len(scalars)
self.points = points
self.vectors = vectors
self.scalars = scalars
polys = numpy.arange(0, len(points), 1, 'l')
polys = numpy.reshape(polys, (len(points), 1))
pd = tvtk.PolyData(points=points, polys=polys)
if self.vectors is not None:
pd.point_data.vectors = vectors
pd.point_data.vectors.name = 'vectors'
if self.scalars is not None:
pd.point_data.scalars = scalars
pd.point_data.scalars.name = 'scalars'
self.poly_data = pd
configure_input_data(self.glyph, pd)
if self.glyph_source:
self.glyph.source = self.glyph_source.output
mapper = tvtk.PolyDataMapper(input=self.glyph.output)
actor = _make_actor(mapper=mapper)
actor.property.color = self.color
self.actors.append(actor)
def update(self):
self.poly_data.update()
self.renwin.render()
def _color_changed(self, val):
if self.actors:
self.actors[0].property.color = val
self.render()
def _glyph_source_changed(self, val):
self.glyph.source = val.output
self.render()
class ScenePreferencesPage(PreferencesPage):
""" Preferences page for a TVTK scene. """
#### 'PreferencesPage' interface ##########################################
# The page's category (e.g. 'General/Appearance'). The empty string means
# that this is a top-level page.
category = ''
# The page's help identifier (optional). If a help Id *is* provided then
# there will be a 'Help' button shown on the preference page.
help_id = ''
# The page name (this is what is shown in the preferences dialog.
name = 'TVTK Scene'
# The path to the preferences node that contains the preferences.
preferences_path = 'tvtk.scene'
#### Preferences ##########################################################
# Turn on/off stereo rendering. Note that this is useful only at startup
# and not at runtime.
stereo = false_bool_trait(
desc='specifies if stereo rendering is turned on')
# The magnification to use when dumping the screen to an image.
magnification = Range(
1,
2048,
1,
desc='specifies the magnification to use while generating images')
# The background color of the renderer.
background_color = vtk_color_trait((0.5, 0.5, 0.5))
# The foreground color of the renderer.
foreground_color = vtk_color_trait((1.0, 1.0, 1.0))
#### Traits UI views ######################################################
traits_view = View(
Group(Item(name='background_color'), Item(name='foreground_color'),
Item(name='stereo'), Item(name='magnification')))
class Surf(LUTBase):
# Disables/enables scalar visibility.
scalar_visibility = Bool(True, desc='show scalar visibility')
# Color of the mesh.
color = vtk_color_trait((0.5, 1.0, 0.5))
def __init__(self, x, y, z, scalars=None, **traits):
"""
Parameters
----------
- x : array
A list of x coordinate values formed using numpy.mgrid.
- y : array
A list of y coordinate values formed using numpy.mgrid.
- z : array
A list of z coordinate values formed using numpy.mgrid.
- scalars : array (optional)
Scalars to associate with the points.
"""
super(Surf, self).__init__(**traits)
triangles, points = make_triangles_points(x, y, z, scalars)
self.pd = make_triangle_polydata(triangles, points, scalars)
mapper = tvtk.PolyDataMapper(input=self.pd,
lookup_table=self.lut,
scalar_visibility=self.scalar_visibility)
if scalars is not None:
rs = numpy.ravel(scalars)
dr = min(rs), max(rs)
mapper.scalar_range = dr
self.lut.table_range = dr
actor = _make_actor(mapper=mapper)
actor.property.trait_set(color=self.color)
self.actors.append(actor)
def _scalar_visibility_changed(self, val):
if self.actors:
mapper = self.actors[0].mapper
mapper.scalar_visibility = val
self.render()
def _surface_changed(self, val):
if self.actors:
representation = 'w'
if val:
representation = 's'
self.actors[0].property.representation = representation
self.render()
def _color_changed(self, val):
if self.actors:
self.actors[0].property.color = val
self.render()
class Line3(MLabBase):
# Radius of the tube filter.
radius = Float(0.01, desc='radius of the tubes')
# Should a tube filter be used or not.
use_tubes = Bool(True,
desc='specifies if the tube filter should be used')
# The Tube filter used to generate tubes from the lines.
tube_filter = Instance(tvtk.TubeFilter, (), {'number_of_sides':6})
# Color of the actor.
color = vtk_color_trait((1.0, 1.0, 1.0))
def __init__(self, points, **traits):
super(MLabBase, self).__init__(**traits)
assert len(points[0]) == 3, "The points must be 3D"
self.points = points
np = len(points) - 1
lines = numpy.zeros((np, 2), 'l')
lines[:,0] = numpy.arange(0, np-0.5, 1, 'l')
lines[:,1] = numpy.arange(1, np+0.5, 1, 'l')
pd = tvtk.PolyData(points=points, lines=lines)
self.poly_data = pd
mapper = tvtk.PolyDataMapper()
self.mapper = mapper
tf = self.tube_filter
tf.radius = self.radius
if self.use_tubes:
tf.input = pd
mapper.input = tf.output
a = _make_actor(mapper=mapper)
a.property.color = self.color
self.actors.append(a)
def _radius_changed(self, val):
self.tube_filter.radius = val
self.render()
def _use_tubes_changed(self, val):
if val:
tf = self.tube_filter
tf.input = self.poly_data
self.mapper.input = tf.output
else:
self.mapper.input = self.poly_data
self.render()
def _color_changed(self, val):
if self.actors:
self.actors[0].property.color = val
self.render()
class FancyTriMesh(LUTBase):
"""Shows a mesh of triangles and draws the edges as tubes and
points as balls."""
# Disables/enables scalar visibility.
scalar_visibility = Bool(False, desc='show scalar visibility')
# Color of the mesh.
color = vtk_color_trait((0.5, 1.0, 0.5))
# The radius of the tubes.
tube_radius = Float(0.0, desc='radius of the tubes')
# The radius of the spheres.
sphere_radius = Float(0.0, desc='radius of the spheres')
# The TubeFilter used to make the tubes for the edges.
tube_filter = Instance(tvtk.TubeFilter, (), {
'vary_radius': 'vary_radius_off',
'number_of_sides': 6
})
# The sphere source for the points.
sphere_source = Instance(tvtk.SphereSource, (), {
'theta_resolution': 12,
'phi_resolution': 12
})
def __init__(self, triangles, points, scalars=None, **traits):
"""
Parameters
----------
- triangles : array
This contains a list of vertex indices forming the triangles.
- points : array
Contains the list of points referred to in the triangle list.
- scalars : array (optional)
Scalars to associate with the points.
"""
super(FancyTriMesh, self).__init__(**traits)
self.points = points
self.pd = make_triangle_polydata(triangles, points, scalars)
# Update the radii so the default is computed correctly.
self._tube_radius_changed(self.tube_radius)
self._sphere_radius_changed(self.sphere_radius)
scalar_vis = self.scalar_visibility
# Extract the edges and show the lines as tubes.
self.extract_filter = tvtk.ExtractEdges(input=self.pd)
extract_f = self.extract_filter
self.tube_filter.trait_set(input=extract_f.output,
radius=self.tube_radius)
edge_mapper = tvtk.PolyDataMapper(input=self.tube_filter.output,
lookup_table=self.lut,
scalar_visibility=scalar_vis)
edge_actor = _make_actor(mapper=edge_mapper)
edge_actor.property.color = self.color
# Create the spheres for the points.
self.sphere_source.radius = self.sphere_radius
spheres = tvtk.Glyph3D(scaling=0,
source=self.sphere_source.output,
input=extract_f.output)
sphere_mapper = tvtk.PolyDataMapper(input=spheres.output,
lookup_table=self.lut,
scalar_visibility=scalar_vis)
sphere_actor = _make_actor(mapper=sphere_mapper)
sphere_actor.property.color = self.color
if scalars is not None:
rs = numpy.ravel(scalars)
dr = min(rs), max(rs)
self.lut.table_range = dr
edge_mapper.scalar_range = dr
sphere_mapper.scalar_range = dr
self.actors.extend([edge_actor, sphere_actor])
def _scalar_visibility_changed(self, val):
if self.actors:
for i in self.actors:
i.mapper.scalar_visibility = val
self.render()
def _tube_radius_changed(self, val):
points = self.points
if val < 1.0e-9:
val = (max(numpy.ravel(points)) - min(numpy.ravel(points))) / 250.0
self.tube_radius = val
self.tube_filter.radius = val
self.render()
def _sphere_radius_changed(self, val):
points = self.points
if val < 1.0e-9:
val = (max(numpy.ravel(points)) - min(numpy.ravel(points))) / 100.0
self.sphere_radius = val
self.sphere_source.radius = val
self.render()
def _color_changed(self, val):
if self.actors:
self.actors[0].property.color = val
self.render()
class TriMesh(LUTBase):
# Disables/enables scalar visibility.
scalar_visibility = Bool(False, desc='show scalar visibility')
# Representation of the mesh as surface or wireframe.
surface = Bool(False, desc='show as surface or wireframe')
# Color of the mesh.
color = vtk_color_trait((0.5, 1.0, 0.5))
def __init__(self, triangles, points, scalars=None, **traits):
"""
Parameters
----------
- triangles : array
This contains a list of vertex indices forming the triangles.
- points : array
Contains the list of points referred to in the triangle list.
- scalars : array (optional)
Scalars to associate with the points.
"""
super(TriMesh, self).__init__(**traits)
self.pd = make_triangle_polydata(triangles, points, scalars)
mapper = tvtk.PolyDataMapper(input=self.pd,
lookup_table=self.lut,
scalar_visibility=self.scalar_visibility)
if scalars is not None:
rs = numpy.ravel(scalars)
dr = min(rs), max(rs)
mapper.scalar_range = dr
self.lut.table_range = dr
actor = _make_actor(mapper=mapper)
representation = 'w'
if self.surface:
representation = 's'
if representation == 'w':
actor.property.trait_set(diffuse=0.0,
ambient=1.0,
color=self.color,
representation=representation)
else:
actor.property.trait_set(diffuse=1.0,
ambient=0.0,
color=self.color,
representation=representation)
self.actors.append(actor)
def _scalar_visibility_changed(self, val):
if self.actors:
mapper = self.actors[0].mapper
mapper.scalar_visibility = val
self.render()
def _surface_changed(self, val):
if self.actors:
representation = 'w'
if val:
representation = 's'
actor = self.actors[0]
if representation == 'w':
actor.property.trait_set(diffuse=0.0,
ambient=1.0,
representation=representation)
else:
actor.property.trait_set(diffuse=1.0,
ambient=0.0,
representation=representation)
self.render()
def _color_changed(self, val):
if self.actors:
self.actors[0].property.color = val
self.render()
class TVTKScene(HasPrivateTraits):
"""A TVTK interactor scene widget.
This widget uses a RenderWindowInteractor and therefore supports
interaction with VTK widgets. The widget uses TVTK. The widget
also supports the following:
- Save the scene to a bunch of common (and not so common) image
formats.
- save the rendered scene to the clipboard.
- adding/removing lists/tuples of actors
- setting the view to useful predefined views (just like in
MayaVi).
- If one passes `stereo=1` to the constructor, stereo rendering is
enabled. By default this is disabled. Changing the stereo trait
has no effect during runtime.
- One can disable rendering by setting `disable_render` to True.
"""
# The version of this class. Used for persistence.
__version__ = 0
###########################################################################
# Traits.
###########################################################################
# Turn on/off stereo rendering. This is set on initialization and
# has no effect once the widget is realized.
stereo = Bool(False)
# Perform line smoothing for all renderered lines. This produces
# much nicer looking lines but renders slower. This setting works
# only when called before the first render.
line_smoothing = Bool(False)
# Perform point smoothing for all renderered points. This
# produces much nicer looking points but renders slower. This
# setting works only when called before the first render.
point_smoothing = Bool(False)
# Perform polygon smoothing (anti-aliasing) for all rendered
# polygons. This produces much nicer looking points but renders
# slower. This setting works only when called before the first
# render.
polygon_smoothing = Bool(False)
# Enable parallel projection. This trait is synchronized with
# that of the camera.
parallel_projection = Bool(False,
desc='if the camera uses parallel projection')
# Disable rendering.
disable_render = Bool(False, desc='if rendering is to be disabled')
# Enable off-screen rendering. This allows a user to render the
# scene to an image without the need to have the window active.
# For example, the application can be minimized and the saved
# scene should be generated correctly. This is handy for batch
# scripts and the like. This works under Win32. Under Mac OS X
# and Linux it requires a recent VTK version (later than Oct 2005
# and ideally later than March 2006) to work correctly.
off_screen_rendering = Bool(False,
desc='if off-screen rendering is enabled')
# The background color of the window. This is really a shadow
# trait of the renderer's background. Delegation does not seem to
# work nicely for this.
background = Trait(vtk_color_trait((0.5, 0.5, 0.5)),
desc='the background color of the window')
# The default foreground color of any actors. This basically
# saves the preference and actors will listen to changes --
# the scene itself does not use this.
foreground = Trait(vtk_color_trait((1.0, 1.0, 1.0)),
desc='the default foreground color of actors')
# The magnification to use when generating images from the render
# window.
magnification = Range(
1,
2048,
1,
desc='the magnification used when the screen is saved to an image')
# Specifies the number of frames to use for anti-aliasing when
# saving a scene. This basically increases
# `self.render_window.aa_frames` in order to produce anti-aliased
# figures when a scene is saved to an image. It then restores the
# `aa_frames` in order to get interactive rendering rates.
anti_aliasing_frames = Range(
0,
20,
8,
desc='number of frames to use for anti-aliasing when saving a scene')
# Default JPEG quality.
jpeg_quality = Range(10,
100,
95,
desc='the quality of the JPEG image to produce')
# Default JPEG progressive setting.
jpeg_progressive = Bool(True,
desc='if the generated JPEG should be progressive')
# The light manager.
light_manager = Instance(light_manager.LightManager, record=True)
# Is the scene busy or not.
busy = Property(Bool, record=False)
########################################
# Events
# Lifecycle events: there are no opening/opened events since the
# control is actually created in __init__.
# The control is going to be closed.
closing = Event(record=False)
# The control has been closed.
closed = Event(record=False)
# Event fired when an actor is added to the scene.
actor_added = Event(record=False)
# Event fired when any actor is removed from the scene.
actor_removed = Event(record=False)
########################################
# Properties.
# The interactor used by the scene.
interactor = Property(Instance(tvtk.GenericRenderWindowInteractor))
# The render_window.
render_window = Property(Instance(tvtk.RenderWindow))
# The renderer.
renderer = Property(Instance(tvtk.Renderer))
# The camera.
camera = Property(Instance(tvtk.Camera))
# The control to mimic the Widget behavior.
control = Any
########################################
# Private traits.
# A recorder for script recording.
recorder = Instance(HasTraits, record=False, transient=True)
# Cached last camera state.
_last_camera_state = Any(transient=True)
_camera_observer_id = Int(transient=True)
_script_id = Str(transient=True)
# The renderer instance.
_renderer = Instance(tvtk.Renderer)
_renwin = Instance(tvtk.RenderWindow)
_interactor = Instance(tvtk.RenderWindowInteractor)
_camera = Instance(tvtk.Camera)
_busy_count = Int(0)
###########################################################################
# 'object' interface.
###########################################################################
def __init__(self, parent=None, **traits):
""" Initializes the object. """
# Base class constructor.
super(TVTKScene, self).__init__(**traits)
# Used to set the view of the scene.
self._def_pos = 1
self.control = self._create_control(parent)
self._renwin.update_traits()
def __get_pure_state__(self):
"""Allows us to pickle the scene."""
# The control attribute is not picklable since it is a VTK
# object so we remove it.
d = self.__dict__.copy()
for x in [
'control', '_renwin', '_interactor', '_camera', '_busy_count',
'__sync_trait__', 'recorder', '_last_camera_state',
'_camera_observer_id', '_script_id', '__traits_listener__'
]:
d.pop(x, None)
# Additionally pickle these.
d['camera'] = self.camera
return d
def __getstate__(self):
return state_pickler.dumps(self)
def __setstate__(self, str_state):
# This method is unnecessary since this object will almost
# never be pickled by itself and only via an object that
# contains it, therefore __init__ will be called when the
# scene is constructed. However, setstate is defined just for
# completeness.
state_pickler.set_state(self, state_pickler.loads_state(str_state))
###########################################################################
# 'Scene' interface.
###########################################################################
def render(self):
""" Force the scene to be rendered. Nothing is done if the
`disable_render` trait is set to True."""
if not self.disable_render:
self._renwin.render()
def add_actors(self, actors):
""" Adds a single actor or a tuple or list of actors to the
renderer."""
# Reset the zoom if this is the first actor.
reset_zoom = (len(self._renderer.actors) == 0
and len(self._renderer.volumes) == 0)
if hasattr(actors, '__iter__'):
for actor in actors:
self._renderer.add_actor(actor)
else:
self._renderer.add_actor(actors)
self.actor_added = actors
if reset_zoom:
self.reset_zoom()
else:
self.render()
def remove_actors(self, actors):
""" Removes a single actor or a tuple or list of actors from
the renderer."""
if hasattr(actors, '__iter__'):
for actor in actors:
self._renderer.remove_actor(actor)
else:
self._renderer.remove_actor(actors)
self.actor_removed = actors
self.render()
# Conevenience methods.
add_actor = add_actors
remove_actor = remove_actors
def add_widgets(self, widgets, enabled=True):
"""Adds a single 3D widget or a sequence of widgets to the renderer.
If `enabled` is True the widget is also enabled once it is added."""
if not hasattr(widgets, '__iter__'):
widgets = [widgets]
iren = self._interactor
for widget in widgets:
widget.interactor = iren
widget.enabled = enabled
self.render()
def remove_widgets(self, widgets):
"""Removes a single 3D widget or a sequence of widgets from the
renderer."""
if not hasattr(widgets, '__iter__'):
widgets = [widgets]
iren = self._interactor
for widget in widgets:
if widget.interactor is not None:
widget.enabled = False
widget.interactor = None
self.render()
def close(self):
"""Close the scene cleanly. This ensures that the scene is
shutdown cleanly. This should be called if you are getting
async errors when closing a scene from a UI. This is based on
the observations of Charl Botha here:
http://public.kitware.com/pipermail/vtkusers/2008-May/095291.html
"""
# Return if we are already closed.
if self._renwin is None:
return
# Fire the "closing" event.
self.closing = True
# Disable any renders through traits listner callbacks.
self.disable_render = True
# Remove sync trait listeners.
self.sync_trait('background', self._renderer, remove=True)
self.sync_trait('parallel_projection', self.camera, remove=True)
self.sync_trait('off_screen_rendering', self._renwin, remove=True)
# Remove all the renderer's props.
self._renderer.remove_all_view_props()
# Set the renderwindow to release all resources and the OpenGL
# context.
self._renwin.finalize()
# Disconnect the interactor from the renderwindow.
self._interactor.render_window = None
# Remove the reference to the render window.
del self._renwin
# Fire the "closed" event.
self.closed = True
def x_plus_view(self):
"""View scene down the +X axis. """
self._update_view(self._def_pos, 0, 0, 0, 0, 1)
self._record_methods('x_plus_view()')
def x_minus_view(self):
"""View scene down the -X axis. """
self._update_view(-self._def_pos, 0, 0, 0, 0, 1)
self._record_methods('x_minus_view()')
def z_plus_view(self):
"""View scene down the +Z axis. """
self._update_view(0, 0, self._def_pos, 0, 1, 0)
self._record_methods('z_plus_view()')
def z_minus_view(self):
"""View scene down the -Z axis. """
self._update_view(0, 0, -self._def_pos, 0, 1, 0)
self._record_methods('z_minus_view()')
def y_plus_view(self):
"""View scene down the +Y axis. """
self._update_view(0, self._def_pos, 0, 1, 0, 0)
self._record_methods('y_plus_view()')
def y_minus_view(self):
"""View scene down the -Y axis. """
self._update_view(0, -self._def_pos, 0, 1, 0, 0)
self._record_methods('y_minus_view()')
def isometric_view(self):
"""Set the view to an iso-metric view. """
self._update_view(self._def_pos, self._def_pos, self._def_pos, 0, 0, 1)
self._record_methods('isometric_view()')
def reset_zoom(self):
"""Reset the camera so everything in the scene fits."""
self._renderer.reset_camera()
self.render()
self._record_methods('reset_zoom()')
def save(self, file_name, size=None, **kw_args):
"""Saves rendered scene to one of several image formats
depending on the specified extension of the filename.
If an additional size (2-tuple) argument is passed the window
is resized to the specified size in order to produce a
suitably sized output image. Please note that when the window
is resized, the window may be obscured by other widgets and
the camera zoom is not reset which is likely to produce an
image that does not reflect what is seen on screen.
Any extra keyword arguments are passed along to the respective
image format's save method.
"""
ext = os.path.splitext(file_name)[1]
meth_map = {
'.ps': 'ps',
'.bmp': 'bmp',
'.tiff': 'tiff',
'.png': 'png',
'.jpg': 'jpg',
'.jpeg': 'jpg',
'.iv': 'iv',
'.wrl': 'vrml',
'.vrml': 'vrml',
'.oogl': 'oogl',
'.rib': 'rib',
'.obj': 'wavefront',
'.eps': 'gl2ps',
'.pdf': 'gl2ps',
'.tex': 'gl2ps',
'.x3d': 'x3d',
'.pov': 'povray'
}
if ext.lower() not in meth_map.keys():
raise ValueError, \
'Unable to find suitable image type for given file extension.'
meth = getattr(self, 'save_' + meth_map[ext])
if size is not None:
orig_size = self.get_size()
self.set_size(size)
meth(file_name, **kw_args)
self.set_size(orig_size)
self._record_methods('save(%r, %r)' % (file_name, size))
else:
meth(file_name, **kw_args)
self._record_methods('save(%r)' % (file_name))
def save_ps(self, file_name):
"""Saves the rendered scene to a rasterized PostScript image.
For vector graphics use the save_gl2ps method."""
if len(file_name) != 0:
w2if = tvtk.WindowToImageFilter(
read_front_buffer=not self.off_screen_rendering)
w2if.magnification = self.magnification
self._lift()
w2if.input = self._renwin
ex = tvtk.PostScriptWriter()
ex.file_name = file_name
configure_input(ex, w2if)
self._exporter_write(ex)
def save_bmp(self, file_name):
"""Save to a BMP image file."""
if len(file_name) != 0:
w2if = tvtk.WindowToImageFilter(
read_front_buffer=not self.off_screen_rendering)
w2if.magnification = self.magnification
self._lift()
w2if.input = self._renwin
ex = tvtk.BMPWriter()
ex.file_name = file_name
configure_input(ex, w2if)
self._exporter_write(ex)
def save_tiff(self, file_name):
"""Save to a TIFF image file."""
if len(file_name) != 0:
w2if = tvtk.WindowToImageFilter(
read_front_buffer=not self.off_screen_rendering)
w2if.magnification = self.magnification
self._lift()
w2if.input = self._renwin
ex = tvtk.TIFFWriter()
ex.file_name = file_name
configure_input(ex, w2if)
self._exporter_write(ex)
def save_png(self, file_name):
"""Save to a PNG image file."""
if len(file_name) != 0:
w2if = tvtk.WindowToImageFilter(
read_front_buffer=not self.off_screen_rendering)
w2if.magnification = self.magnification
self._lift()
w2if.input = self._renwin
ex = tvtk.PNGWriter()
ex.file_name = file_name
configure_input(ex, w2if)
self._exporter_write(ex)
def save_jpg(self, file_name, quality=None, progressive=None):
"""Arguments: file_name if passed will be used, quality is the
quality of the JPEG(10-100) are valid, the progressive
arguments toggles progressive jpegs."""
if len(file_name) != 0:
if not quality and not progressive:
quality, progressive = self.jpeg_quality, self.jpeg_progressive
w2if = tvtk.WindowToImageFilter(
read_front_buffer=not self.off_screen_rendering)
w2if.magnification = self.magnification
self._lift()
w2if.input = self._renwin
ex = tvtk.JPEGWriter()
ex.quality = quality
ex.progressive = progressive
ex.file_name = file_name
configure_input(ex, w2if)
self._exporter_write(ex)
def save_iv(self, file_name):
"""Save to an OpenInventor file."""
if len(file_name) != 0:
ex = tvtk.IVExporter()
self._lift()
ex.input = self._renwin
ex.file_name = file_name
self._exporter_write(ex)
def save_vrml(self, file_name):
"""Save to a VRML file."""
if len(file_name) != 0:
ex = tvtk.VRMLExporter()
self._lift()
ex.input = self._renwin
ex.file_name = file_name
self._exporter_write(ex)
def save_oogl(self, file_name):
"""Saves the scene to a Geomview OOGL file. Requires VTK 4 to
work."""
if len(file_name) != 0:
ex = tvtk.OOGLExporter()
self._lift()
ex.input = self._renwin
ex.file_name = file_name
self._exporter_write(ex)
def save_rib(self, file_name, bg=0, resolution=None, resfactor=1.0):
"""Save scene to a RenderMan RIB file.
Keyword Arguments:
file_name -- File name to save to.
bg -- Optional background option. If 0 then no background is
saved. If non-None then a background is saved. If left alone
(defaults to None) it will result in a pop-up window asking
for yes/no.
resolution -- Specify the resolution of the generated image in
the form of a tuple (nx, ny).
resfactor -- The resolution factor which scales the resolution.
"""
if resolution == None:
# get present window size
Nx, Ny = self.render_window.size
else:
try:
Nx, Ny = resolution
except TypeError:
raise TypeError, \
"Resolution (%s) should be a sequence with two elements"%resolution
if len(file_name) == 0:
return
f_pref = os.path.splitext(file_name)[0]
ex = tvtk.RIBExporter()
ex.size = int(resfactor * Nx), int(resfactor * Ny)
ex.file_prefix = f_pref
ex.texture_prefix = f_pref + "_tex"
self._lift()
ex.render_window = self._renwin
ex.background = bg
if VTK_VER[:3] in ['4.2', '4.4']:
# The vtkRIBExporter is broken in respect to VTK light
# types. Therefore we need to convert all lights into
# scene lights before the save and later convert them
# back.
########################################
# Internal functions
def x3to4(x):
# convert 3-vector to 4-vector (w=1 -> point in space)
return (x[0], x[1], x[2], 1.0)
def x4to3(x):
# convert 4-vector to 3-vector
return (x[0], x[1], x[2])
def cameralight_transform(light, xform, light_type):
# transform light by 4x4 matrix xform
origin = x3to4(light.position)
focus = x3to4(light.focal_point)
neworigin = xform.multiply_point(origin)
newfocus = xform.multiply_point(focus)
light.position = x4to3(neworigin)
light.focal_point = x4to3(newfocus)
light.light_type = light_type
########################################
save_lights_type = []
for light in self.light_manager.lights:
save_lights_type.append(light.source.light_type)
# Convert lights to scene lights.
cam = self.camera
xform = tvtk.Matrix4x4()
xform.deep_copy(cam.camera_light_transform_matrix)
for light in self.light_manager.lights:
cameralight_transform(light.source, xform, "scene_light")
# Write the RIB file.
self._exporter_write(ex)
# Now re-convert lights to camera lights.
xform.invert()
for i, light in enumerate(self.light_manager.lights):
cameralight_transform(light.source, xform, save_lights_type[i])
# Change the camera position. Otherwise VTK would render
# one broken frame after the export.
cam.roll(0.5)
cam.roll(-0.5)
else:
self._exporter_write(ex)
def save_wavefront(self, file_name):
"""Save scene to a Wavefront OBJ file. Two files are
generated. One with a .obj extension and another with a .mtl
extension which contains the material proerties.
Keyword Arguments:
file_name -- File name to save to
"""
if len(file_name) != 0:
ex = tvtk.OBJExporter()
self._lift()
ex.input = self._renwin
f_pref = os.path.splitext(file_name)[0]
ex.file_prefix = f_pref
self._exporter_write(ex)
def save_gl2ps(self, file_name, exp=None):
"""Save scene to a vector PostScript/EPS/PDF/TeX file using
GL2PS. If you choose to use a TeX file then note that only
the text output is saved to the file. You will need to save
the graphics separately.
Keyword Arguments:
file_name -- File name to save to.
exp -- Optionally configured vtkGL2PSExporter object.
Defaults to None and this will use the default settings with
the output file type chosen based on the extention of the file
name.
"""
# Make sure the exporter is available.
if not hasattr(tvtk, 'GL2PSExporter'):
msg = "Saving as a vector PS/EPS/PDF/TeX file using GL2PS is "\
"either not supported by your version of VTK or "\
"you have not configured VTK to work with GL2PS -- read "\
"the documentation for the vtkGL2PSExporter class."
print msg
return
if len(file_name) != 0:
f_prefix, f_ext = os.path.splitext(file_name)
ex = None
if exp:
ex = exp
if not isinstance(exp, tvtk.GL2PSExporter):
msg = "Need a vtkGL2PSExporter you passed a "\
"%s"%exp.__class__.__name__
raise TypeError, msg
ex.file_prefix = f_prefix
else:
ex = tvtk.GL2PSExporter()
# defaults
ex.file_prefix = f_prefix
if f_ext == ".ps":
ex.file_format = 'ps'
elif f_ext == ".tex":
ex.file_format = 'tex'
elif f_ext == ".pdf":
ex.file_format = 'pdf'
else:
ex.file_format = 'eps'
ex.sort = 'bsp'
ex.compress = 1
ex.edit_traits(kind='livemodal')
self._lift()
ex.render_window = self._renwin
if ex.write3d_props_as_raster_image:
self._exporter_write(ex)
else:
ex.write()
def save_x3d(self, file_name):
"""Save scene to an X3D file (http://www.web3d.org/x3d/).
Keyword Arguments:
file_name -- File name to save to.
"""
# Make sure the exporter is available.
if not hasattr(tvtk, 'X3DExporter'):
msg = "Saving as a X3D file does not appear to be "\
"supported by your version of VTK."
print msg
return
if len(file_name) != 0:
ex = tvtk.X3DExporter()
ex.input = self._renwin
ex.file_name = file_name
ex.update()
ex.write()
def save_povray(self, file_name):
"""Save scene to a POVRAY (Persistance of Vision Raytracer),
file (http://www.povray.org).
Keyword Arguments:
file_name -- File name to save to.
"""
# Make sure the exporter is available.
if not hasattr(tvtk, 'POVExporter'):
msg = "Saving as a POVRAY file does not appear to be "\
"supported by your version of VTK."
print msg
return
if len(file_name) != 0:
ex = tvtk.POVExporter()
ex.input = self._renwin
if hasattr(ex, 'file_name'):
ex.file_name = file_name
else:
ex.file_prefix = os.path.splitext(file_name)[0]
ex.update()
ex.write()
def get_size(self):
"""Return size of the render window."""
return self._interactor.size
def set_size(self, size):
"""Set the size of the window."""
self._interactor.size = size
self._renwin.size = size
###########################################################################
# Properties.
###########################################################################
def _get_interactor(self):
"""Returns the vtkRenderWindowInteractor of the parent class"""
return self._interactor
def _get_render_window(self):
"""Returns the scene's render window."""
return self._renwin
def _get_renderer(self):
"""Returns the scene's renderer."""
return self._renderer
def _get_camera(self):
""" Returns the active camera. """
return self._renderer.active_camera
def _get_busy(self):
return self._busy_count > 0
def _set_busy(self, value):
"""The `busy` trait is either `True` or `False`. However,
this could be problematic since we could have two methods
`foo` and `bar that both set `scene.busy = True`. As soon as
`bar` is done it sets `busy` back to `False`. This is wrong
since the UI is still busy as `foo` is not done yet. We
therefore store the number of busy calls and either increment
it or decrement it and change the state back to `False` only
when the count is zero.
"""
bc = self._busy_count
if value:
bc += 1
else:
bc -= 1
bc = max(0, bc)
self._busy_count = bc
if bc == 1:
self.trait_property_changed('busy', False, True)
if bc == 0:
self.trait_property_changed('busy', True, False)
###########################################################################
# Non-public interface.
###########################################################################
def _create_control(self, parent):
""" Create the toolkit-specific control that represents the widget. """
# Create the renderwindow.
renwin = self._renwin = tvtk.RenderWindow()
# If we are doing offscreen rendering we set the window size to
# (1,1) so the window does not appear at all
if self.off_screen_rendering:
renwin.size = (1, 1)
renwin.set(point_smoothing=self.point_smoothing,
line_smoothing=self.line_smoothing,
polygon_smoothing=self.polygon_smoothing)
# Create a renderer and add it to the renderwindow
self._renderer = tvtk.Renderer()
renwin.add_renderer(self._renderer)
self._interactor = tvtk.RenderWindowInteractor(render_window=renwin)
# Save a reference to our camera so it is not GC'd -- needed for
# the sync_traits to work.
self._camera = self.camera
# Sync various traits.
self._renderer.background = self.background
self.sync_trait('background', self._renderer)
self._renderer.on_trait_change(self.render, 'background')
self._camera.parallel_projection = self.parallel_projection
self.sync_trait('parallel_projection', self._camera)
renwin.off_screen_rendering = self.off_screen_rendering
self.sync_trait('off_screen_rendering', self._renwin)
self.render_window.on_trait_change(self.render, 'off_screen_rendering')
self.render_window.on_trait_change(self.render, 'stereo_render')
self.render_window.on_trait_change(self.render, 'stereo_type')
self.camera.on_trait_change(self.render, 'parallel_projection')
self._interactor.initialize()
self._interactor.render()
self.light_manager = light_manager.LightManager(self)
if self.off_screen_rendering:
# We want the default size to be the normal (300, 300).
# Setting the size now should not resize the window if
# offscreen is working properly in VTK.
renwin.size = (300, 300)
return self._interactor
def _lift(self):
"""Lift the window to the top. Useful when saving screen to an
image."""
return
def _exporter_write(self, ex):
"""Abstracts the exporter's write method."""
# Bumps up the anti-aliasing frames when the image is saved so
# that the saved picture looks nicer.
rw = self.render_window
aa_frames = rw.aa_frames
rw.aa_frames = self.anti_aliasing_frames
rw.render()
ex.update()
ex.write()
# Set the frames back to original setting.
rw.aa_frames = aa_frames
rw.render()
def _update_view(self, x, y, z, vx, vy, vz):
"""Used internally to set the view."""
camera = self.camera
camera.focal_point = 0.0, 0.0, 0.0
camera.position = x, y, z
camera.view_up = vx, vy, vz
self._renderer.reset_camera()
self.render()
def _disable_render_changed(self, val):
if not val and self._renwin is not None:
self.render()
def _record_methods(self, calls):
"""A method to record a simple method called on self. We need a
more powerful and less intrusive way like decorators to do this.
Note that calls can be a string with new lines in which case we
interpret this as multiple calls.
"""
r = self.recorder
if r is not None:
sid = self._script_id
for call in calls.split('\n'):
r.record('%s.%s' % (sid, call))
def _record_camera_position(self, vtk_obj=None, event=None):
"""Callback to record the camera position."""
r = self.recorder
if r is not None:
state = self._get_camera_state()
lcs = self._last_camera_state
if state != lcs:
self._last_camera_state = state
sid = self._script_id
for key, value in state:
r.record('%s.camera.%s = %r' % (sid, key, value))
r.record('%s.camera.compute_view_plane_normal()' % sid)
r.record('%s.render()' % sid)
def _get_camera_state(self):
c = self.camera
state = []
state.append(('position', list(c.position)))
state.append(('focal_point', list(c.focal_point)))
state.append(('view_angle', c.view_angle))
state.append(('view_up', list(c.view_up)))
state.append(('clipping_range', list(c.clipping_range)))
return state
def _recorder_changed(self, r):
"""When the recorder is set we add an event handler so we can
record the change to the camera position after the interaction.
"""
iren = self._interactor
if r is not None:
self._script_id = r.get_script_id(self)
id = iren.add_observer('EndInteractionEvent', messenger.send)
self._camera_observer_id = id
i_vtk = tvtk.to_vtk(iren)
messenger.connect(i_vtk, 'EndInteractionEvent',
self._record_camera_position)
else:
self._script_id = ''
iren.remove_observer(self._camera_observer_id)
i_vtk = tvtk.to_vtk(iren)
messenger.disconnect(i_vtk, 'EndInteractionEvent',
self._record_camera_position)
class CameraLight(HasTraits):
"""This class manages a tvtk.Light object and a LightGlyph object."""
# The version of this class. Used for persistence.
__version__ = 0
#################################################################
# Traits.
#################################################################
elevation = Range(-90.0, 90.0, 0.0, desc="the elevation of the light")
azimuth = Range(-180.0,
180.0,
0.0,
desc="the aziumthal angle of the light")
activate = Trait(False,
false,
desc="specifies if the light is enabled or not")
source = Instance(tvtk.Light, ())
# FIXME: Traits Delegation does not work correctly and changes to
# this object are not reflected in the delegate nicely.
#color = Delegate('source', modify=True)
#intensity = Delegate('source', modify=True)
# For now we mirror these traits from the source.
intensity = Range(0.0, 1.0, 1.0, desc="the intensity of the light")
color = vtk_color_trait((1.0, 1.0, 1.0))
color.desc = "the color of the light"
default_view = View(Item(name='activate'), Item(name='elevation'),
Item(name='azimuth'), Item(name='intensity'),
Item(name='color'))
#################################################################
# `object` interface.
#################################################################
def __init__(self, renwin, **traits):
self.glyph = LightGlyph()
super(CameraLight, self).__init__(**traits)
self.source.light_type = 'camera_light'
self._intensity_changed(self.intensity)
self._activate_changed(self.activate)
self._color_changed(self.color)
renwin.renderer.add_light(self.source)
self.on_trait_change(renwin.render)
def __get_pure_state__(self):
d = self.__dict__.copy()
for name in ['__sync_trait__', '__traits_listener__']:
d.pop(name, None)
return d
def __getstate__(self):
return state_pickler.dumps(self)
def __setstate__(self, str_state):
#self.__init__()
state_pickler.set_state(self, state_pickler.loads_state(str_state))
#################################################################
# `LightGlyph` interface.
#################################################################
def close(self, renwin):
"""Remove the light source and the glyph from the
renderwindow. This is usually to be called when the Light is
removed from the scene."""
ren = renwin.renderer
self.on_trait_change(renwin.render, remove=True)
ren.remove_light(self.source)
self.remove_glyph(ren)
def add_glyph(self, ren, bounds):
"""Add the light glyph to the passed renderer ('ren'). Scale
the actors using the bounds (`bounds`) provided."""
self.glyph.add(ren, bounds)
def remove_glyph(self, ren):
"""Remove the light glyph from the passed renderer."""
self.glyph.remove(ren)
def move_to(self, elevation, azimuth):
"""Move the light to the specified elevation and azimuthal
angles (in degrees)."""
self.elevation = elevation
self.azimuth = azimuth
#################################################################
# Trait handlers.
#################################################################
def _activate_changed(self, val):
if val:
self.source.switch = 1
self.glyph.show()
else:
self.source.switch = 0
self.glyph.hide()
def _intensity_changed(self, val):
self.source.intensity = val
def _color_changed(self, val):
if is_old_pipeline():
self.source.color = val
else:
self.source.set_color(val)
self.glyph.set_color(val)
def _elevation_changed(self, val):
self.glyph.move_to(val, self.azimuth)
self.source.position = self._to_pos(val, self.azimuth)
def _azimuth_changed(self, val):
self.glyph.move_to(self.elevation, val)
self.source.position = self._to_pos(self.elevation, val)
#################################################################
# Non-public interface.
#################################################################
def _to_pos(self, elevation, azimuth):
"""Convert the given elevation and azimuth angles (degrees) to
a position vector."""
theta = azimuth * pi / 180.0
phi = (90.0 - elevation) * pi / 180.0
x = sin(theta) * sin(phi)
y = cos(phi)
z = cos(theta) * sin(phi)
return x, y, z
def _from_pos(self, x, y, z):
"""Given the position vector, return an elevation and azimuth
angle (in degrees)."""
theta = atan2(x, z)
phi = atan2(sqrt(x**2 + z**2), y)
az = theta * 180.0 / pi
el = 90.0 - phi * 180.0 / pi
return el, az
