# Font trait:
font_trait = KivaFont(default_font_name)
# Bounds trait
bounds_trait = CList([0.0, 0.0]) # (w,h)
coordinate_trait = CList([0.0, 0.0]) # (x,y)
#bounds_trait = Trait((0.0, 0.0, 20.0, 20.0), valid_bounds, editor=bounds_editor)
# Component minimum size trait
# PZW: Make these just floats, or maybe remove them altogether.
ComponentMinSize = Range(0.0, 99999.0)
ComponentMaxSize = ComponentMinSize(99999.0)
# Pointer shape trait:
Pointer = Trait('arrow', TraitPrefixList(pointer_shapes))
# Cursor style trait:
cursor_style_trait = Trait('default', TraitPrefixMap(cursor_styles))
spacing_trait = Range(0, 63, value=4)
padding_trait = Range(0, 63, value=4)
margin_trait = Range(0, 63)
border_size_trait = Range(0, 8, editor=border_size_editor)
# Time interval trait:
TimeInterval = Trait(None, None, Range(0.0, 3600.0))
# Stretch traits:
Stretch = Range(0.0, 1.0, value=1.0)
NoStretch = Stretch(0.0)
class OddIntegerTrait(HasTraits):
value = Trait(99, odd_integer)
class DelegateTrait(HasTraits):
value = Delegate("delegate")
delegate = Trait(DelegatedFloatTrait())
class PrefixListTrait(HasTraits):
value = Trait("one", TraitPrefixList("one", "two", "three"))
class OldInstanceTrait(HasTraits):
value = Trait(otrait_test1)
class ImaginaryValueTrait(HasTraits):
value = Trait(99.0 - 99.0j)
class EnumTrait(HasTraits):
value = Trait([1, "one", 2, "two", 3, "three", 4.4, "four.four"])
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)
# The movie maker instance.
movie_maker = Instance('tvtk.pyface.movie_maker.MovieMaker', 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))
###########################################################################
# 'event' interface.
###########################################################################
def _closed_fired(self):
self.light_manager = None
self._interactor = None
self.movie_maker = None
###########################################################################
# '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:
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 = self._get_window_to_image()
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 = self._get_window_to_image()
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 = self._get_window_to_image()
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 = self._get_window_to_image()
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 = self._get_window_to_image()
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 is 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 properties.
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()
# Work around for a bug in VTK where it saves the file as a
# .pdf.gz when the file is really a PDF file.
if f_ext == '.pdf' and os.path.exists(f_prefix + '.pdf.gz'):
os.rename(f_prefix + '.pdf.gz', file_name)
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 (Persistence 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.trait_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 _get_window_to_image(self):
w2if = tvtk.WindowToImageFilter(
read_front_buffer=not self.off_screen_rendering
)
set_magnification(w2if, self.magnification)
self._lift()
w2if.input = self._renwin
return w2if
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
if hasattr(rw, 'aa_frames'):
aa_frames = rw.aa_frames
rw.aa_frames = self.anti_aliasing_frames
else:
aa_frames = rw.multi_samples
rw.multi_samples = self.anti_aliasing_frames
rw.render()
ex.update()
ex.write()
# Set the frames back to original setting.
if hasattr(rw, 'aa_frames'):
rw.aa_frames = aa_frames
else:
rw.multi_samples = 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)
def _movie_maker_default(self):
from tvtk.pyface.movie_maker import MovieMaker
return MovieMaker(scene=self)
class ModuleManager(Base):
""" The module manager node (represented as 'Colors and Legends').
"""
# The source object this is connected to.
source = Instance(Base)
# The modules contained by this manager.
children = List(Module, record=True)
# The data type to use for the LUTs. Changing this setting will
# change the data range and name of the lookup table/legend bar.
# If set to 'auto', it automatically looks for cell and point data
# with point data being preferred over cell data and chooses the
# one available. If set to 'point data' it uses the input point
# data for the LUT and if set to 'cell data' it uses the input
# cell data.
lut_data_mode = Trait(
'auto',
TraitPrefixList(LUT_DATA_MODE_TYPES),
desc='specify the data type used by the lookup tables',
)
# The scalar lookup table manager.
scalar_lut_manager = Instance(LUTManager, args=(), record=True)
# The vector lookup table manager.
vector_lut_manager = Instance(LUTManager, args=(), record=True)
# The name of the ModuleManager.
name = Str('Colors and legends')
# The icon
icon = Str('modulemanager.ico')
# The human-readable type for this object
type = Str(' colors and legends')
# Information about what this object can consume.
input_info = PipelineInfo(datasets=['any'])
# Information about what this object can produce.
output_info = PipelineInfo(datasets=['any'])
######################################################################
# `object` interface
######################################################################
def __get_pure_state__(self):
d = super(ModuleManager, self).__get_pure_state__()
# Source is setup dynamically, don't pickle it.
d.pop('source', None)
return d
def __set_pure_state__(self, state):
# Do everything but our kids.
set_state(self, state, ignore=['children'])
# Setup children.
handle_children_state(self.children, state.children)
# Now setup the children.
set_state(self, state, first=['children'], ignore=['*'])
self.update()
######################################################################
# `ModuleManager` interface
######################################################################
def update(self):
"""Update any internal data.
This is invoked when the source changes or when there are
pipeline/data changes upstream.
"""
if len(self.source.outputs) == 0:
return
input = self.source.outputs[0]
helper = DataSetHelper(input)
self._setup_scalar_data(helper)
self._setup_vector_data(helper)
######################################################################
# `Base` interface
######################################################################
def start(self):
"""This is invoked when this object is added to the mayavi
pipeline.
"""
# Do nothing if we are already running.
if self.running:
return
# Setup event handlers.
self._setup_event_handlers()
# Start all our children.
for obj in self.children:
obj.start()
for obj in (self.scalar_lut_manager, self.vector_lut_manager):
obj.start()
# Call parent method to set the running state.
super(ModuleManager, self).start()
def stop(self):
"""Invoked when this object is removed from the mayavi
pipeline.
"""
if not self.running:
return
# Teardown event handlers.
self._teardown_event_handlers()
# Stop all our children.
for obj in self.children:
obj.stop()
for obj in (self.scalar_lut_manager, self.vector_lut_manager):
obj.stop()
# Call parent method to set the running state.
super(ModuleManager, self).stop()
def add_child(self, child):
"""This method intelligently adds a child to this object in
the MayaVi pipeline.
"""
if isinstance(child, Module):
self.children.append(child)
else:
# Ask our source to deal with it.
self.source.add_child(child)
def remove_child(self, child):
"""Remove specified child from our children.
"""
self.children.remove(child)
######################################################################
# `TreeNodeObject` interface
######################################################################
def tno_can_add(self, node, add_object):
""" Returns whether a given object is droppable on the node.
"""
try:
if issubclass(add_object, Module):
return True
except TypeError:
if isinstance(add_object, Module):
return True
return False
def tno_drop_object(self, node, dropped_object):
""" Returns a droppable version of a specified object.
"""
if isinstance(dropped_object, Module):
return dropped_object
######################################################################
# Non-public interface
######################################################################
def _children_changed(self, old, new):
self._handle_children(old, new)
def _children_items_changed(self, list_event):
self._handle_children(list_event.removed, list_event.added)
def _handle_children(self, removed, added):
# Stop all the old children.
for obj in removed:
obj.stop()
# Setup and start the new ones.
for obj in added:
obj.trait_set(module_manager=self, scene=self.scene, parent=self)
if self.running:
# It makes sense to start children only if we are running.
# If not, the children will be started when we start.
try:
obj.start()
except:
exception()
def _source_changed(self):
self.output_info.copy_traits(self.source.output_info)
self.update()
def _setup_event_handlers(self):
src = self.source
src.on_trait_event(self.update, 'pipeline_changed')
src.on_trait_event(self.update, 'data_changed')
def _teardown_event_handlers(self):
src = self.source
src.on_trait_event(self.update, 'pipeline_changed', remove=True)
src.on_trait_event(self.update, 'data_changed', remove=True)
def _scene_changed(self, value):
for obj in self.children:
obj.scene = value
for obj in (self.scalar_lut_manager, self.vector_lut_manager):
obj.scene = value
def _lut_data_mode_changed(self, value):
self.update()
def _setup_scalar_data(self, helper):
"""Computes the scalar range and an appropriate name for the
lookup table."""
data_attr = DataAttributes(name='No scalars')
point_data_attr = DataAttributes(name='No scalars')
point_data_attr.compute_scalar(helper, 'point')
cell_data_attr = DataAttributes(name='No scalars')
cell_data_attr.compute_scalar(helper, 'cell')
if self.lut_data_mode == 'auto':
if len(point_data_attr.range) > 0:
data_attr.copy_traits(point_data_attr)
elif len(cell_data_attr.range) > 0:
data_attr.copy_traits(cell_data_attr)
elif self.lut_data_mode == 'point data':
data_attr.copy_traits(point_data_attr)
elif self.lut_data_mode == 'cell data':
data_attr.copy_traits(cell_data_attr)
data_attr.config_lut(self.scalar_lut_manager)
def _setup_vector_data(self, helper):
data_attr = DataAttributes(name='No vectors')
point_data_attr = DataAttributes(name='No vectors')
point_data_attr.compute_vector(helper, 'point')
cell_data_attr = DataAttributes(name='No vectors')
cell_data_attr.compute_vector(helper, 'cell')
if self.lut_data_mode == 'auto':
if len(point_data_attr.range) > 0:
data_attr.copy_traits(point_data_attr)
elif len(cell_data_attr.range) > 0:
data_attr.copy_traits(cell_data_attr)
elif self.lut_data_mode == 'point data':
data_attr.copy_traits(point_data_attr)
elif self.lut_data_mode == 'cell data':
data_attr.copy_traits(cell_data_attr)
data_attr.config_lut(self.vector_lut_manager)
def _visible_changed(self, value):
for c in self.children:
c.visible = value
self.scalar_lut_manager.visible = value
self.vector_lut_manager.visible = value
super(ModuleManager, self)._visible_changed(value)
def _menu_helper_default(self):
from mayavi.core.traits_menu import ModuleMenuHelper
return ModuleMenuHelper(object=self)
from .item import Item
from .menu import Action
from .table_column import ObjectColumn
from .view import View
# -------------------------------------------------------------------------
# Trait definitions:
# -------------------------------------------------------------------------
GenericTableFilterRuleOperation = Trait(
"=",
{
"=": "eq",
"<>": "ne",
"<": "lt",
"<=": "le",
">": "gt",
">=": "ge",
"contains": "contains",
"starts with": "starts_with",
"ends with": "ends_with",
},
)
class TableFilter(HasPrivateTraits):
"""Filter for items displayed in a table."""
# -------------------------------------------------------------------------
# Trait definitions:
# -------------------------------------------------------------------------
class BoxSelection2D(ctools.BetterSelectingZoom):
""" Zooming tool which allows the user to draw a box which defines the
desired region to zoom in to
"""
# The selection mode:
#
# range:
# Select a range across a single index or value axis.
# box:
# Perform a "box" selection on two axes.
selection_complete = Event
tool_mode = Enum("box")
metadata_name = Str("selections")
# The key press to enter zoom mode, if **always_on** is False. Has no effect
# if **always_on** is True.
enter_zoom_key = Instance(KeySpec, args=("r", ))
# The key press to leave zoom mode, if **always_on** is False. Has no effect
# if **always_on** is True.
exit_zoom_key = Instance(KeySpec, args=("r", ))
#-------------------------------------------------------------------------
# Appearance properties (for Box mode)
#-------------------------------------------------------------------------
# The pointer to use when drawing a zoom box.
pointer = "magnifier"
# The color of the selection box.
color = ColorTrait("lightskyblue")
# The alpha value to apply to **color** when filling in the selection
# region. Because it is almost certainly useless to have an opaque zoom
# rectangle, but it's also extremely useful to be able to use the normal
# named colors from Enable, this attribute allows the specification of a
# separate alpha value that replaces the alpha value of **color** at draw
# time.
alpha = Trait(0.4, None, Float)
# The color of the outside selection rectangle.
border_color = ColorTrait("dodgerblue")
# The thickness of selection rectangle border.
border_size = Int(1)
# The (x,y) screen point where the mouse went down.
_screen_start = Trait(None, None, Tuple)
# The (x,,y) screen point of the last seen mouse move event.
_screen_end = Trait(None, None, Tuple)
# If **always_on** is False, this attribute indicates whether the tool
# is currently enabled.
_enabled = Bool(False)
#-------------------------------------------------------------------------
# Private traits
#-------------------------------------------------------------------------
# the original numerical screen ranges
_orig_low_setting = Tuple
_orig_high_setting = Tuple
#--------------------------------------------------------------------------
# BetterZoom interface
#--------------------------------------------------------------------------
#--------------------------------------------------------------------------
# AbstractOverlay interface
#--------------------------------------------------------------------------
def overlay(self, component, gc, view_bounds=None, mode="normal"):
""" Draws this component overlaid on another component.
Overrides AbstractOverlay.
"""
if self.event_state == "selecting":
if self.tool_mode == "range":
self._overlay_range(component, gc)
else:
self._overlay_box(component, gc)
return
def _end_select(self, event):
""" Ends selection of the zoom region, adds the new zoom range to
the zoom stack, and does the zoom.
"""
self._screen_end = (event.x, event.y)
start = numpy.array(self._screen_start)
end = numpy.array(self._screen_end)
#logger.debug( "COORDINATES (%s to %s)" % (start, end))
#logger.debug(print "data space coordinates (%s to %s) " % self._map_coordinate_box(start, end))
self._end_selecting(event)
event.handled = True
self.selection_complete = True
return
def _end_selecting(self, event=None):
""" Ends selection of zoom region, without zooming.
"""
#self.reset()#removed and exchanged for resetting to normal so that it remembers last selection
self.event_state = "normal"
self._enabled = False
if self.component.active_tool == self:
self.component.active_tool = None
if event and event.window:
event.window.set_pointer("arrow")
self.component.request_redraw()
if event and event.window.mouse_owner == self:
event.window.set_mouse_owner(None)
return
def _overlay_box(self, component, gc):
""" Draws the overlay as a box.
"""
if self._screen_start and self._screen_end:
with gc:
gc.set_antialias(0)
gc.set_line_width(self.border_size)
gc.set_stroke_color(self.border_color_)
gc.clip_to_rect(component.x, component.y, component.width,
component.height)
x, y = self._screen_start
x2, y2 = self._screen_end
rect = (x, y, x2 - x + 1, y2 - y + 1)
if self.color != "transparent":
if self.alpha:
color = list(self.color_)
if len(color) == 4:
color[3] = self.alpha
else:
color += [self.alpha]
else:
color = self.color_
gc.set_fill_color(color)
gc.draw_rect(rect)
else:
gc.rect(*rect)
gc.stroke_path()
return
def _map_coordinate_box(self, start, end):
""" Given start and end points in screen space, returns corresponding
low and high points in data space.
"""
low = [0, 0]
high = [0, 0]
for axis_index, mapper in [(0, self.component.x_mapper), \
(1, self.component.y_mapper)]:
# Ignore missing axis mappers (ColorBar instances only have one).
if not mapper:
continue
low_val = mapper.map_data(start[axis_index])
high_val = mapper.map_data(end[axis_index])
if low_val > high_val:
low_val, high_val = high_val, low_val
low[axis_index] = low_val
high[axis_index] = high_val
return low, high
def _get_coordinate_box(self):
"""returns last selected box """
start = numpy.array(self._screen_start)
end = numpy.array(self._screen_end)
([startX, startY], [endX, endY]) = self._map_coordinate_box(start, end)
return [startX, startY, endX, endY]
class PlotGrid(AbstractOverlay):
""" An overlay that represents a grid.
A grid is a set of parallel lines, horizontal or vertical. You can use
multiple grids with different settings for the horizontal and vertical
lines in a plot.
"""
#------------------------------------------------------------------------
# Data-related traits
#------------------------------------------------------------------------
# The mapper (and associated range) that drive this PlotGrid.
mapper = Instance(AbstractMapper)
# The dataspace interval between grid lines.
grid_interval = Trait('auto', 'auto', Float)
# The dataspace value at which to start this grid. If None, then
# uses the mapper.range.low.
data_min = Trait(None, None, Float)
# The dataspace value at which to end this grid. If None, then uses
# the mapper.range.high.
data_max = Trait(None, None, Float)
# A callable that implements the AbstractTickGenerator Interface.
tick_generator = Instance(AbstractTickGenerator)
#------------------------------------------------------------------------
# Layout traits
#------------------------------------------------------------------------
# The orientation of the grid lines. "horizontal" means that the grid
# lines are parallel to the X axis and the ticker and grid interval
# refer to the Y axis.
orientation = Enum('horizontal', 'vertical')
# Draw the ticks starting at the end of the mapper range? If False, the
# ticks are drawn starting at 0. This setting can be useful to keep the
# grid from from "flashing" as the user resizes the plot area.
flip_axis = Bool(False)
# Optional specification of the grid bounds in the dimension transverse
# to the ticking/gridding dimension, i.e. along the direction specified
# by self.orientation. If this is specified but transverse_mapper is
# not specified, then there is no effect.
#
# None : use self.bounds or self.component.bounds (if overlay)
# Tuple : (low, high) extents, used for every grid line
# Callable : Function that takes an array of dataspace grid ticks
# and returns either an array of shape (N,2) of (starts,ends)
# for each grid point or a single tuple (low, high)
transverse_bounds = Trait(None, Tuple, Callable)
# Mapper in the direction corresponding to self.orientation, i.e. transverse
# to the direction of self.mapper. This is used to compute the screen
# position of transverse_bounds. If this is not specified, then
# transverse_bounds has no effect, and vice versa.
transverse_mapper = Instance(AbstractMapper)
# Dimensions that the grid is resizable in (overrides PlotComponent).
resizable = "hv"
#------------------------------------------------------------------------
# Appearance traits
#------------------------------------------------------------------------
# The color of the grid lines.
line_color = black_color_trait
# The style (i.e., dash pattern) of the grid lines.
line_style = LineStyle('solid')
# The thickness, in pixels, of the grid lines.
line_width = CInt(1)
line_weight = Alias("line_width")
# Default Traits UI View for modifying grid attributes.
traits_view = GridView
#------------------------------------------------------------------------
# Private traits; mostly cached information
#------------------------------------------------------------------------
_cache_valid = Bool(False)
_tick_list = Any
_tick_positions = Any
# An array (N,2) of start,end positions in the transverse direction
# i.e. the direction corresponding to self.orientation
_tick_extents = Any
#_length = Float(0.0)
#------------------------------------------------------------------------
# Public methods
#------------------------------------------------------------------------
def __init__(self, **traits):
# TODO: change this back to a factory in the instance trait some day
self.tick_generator = DefaultTickGenerator()
super(PlotGrid, self).__init__(**traits)
self.bgcolor = "none" #make sure we're transparent
return
@on_trait_change("bounds,bounds_items,position,position_items")
def invalidate(self):
""" Invalidate cached information about the grid.
"""
self._reset_cache()
return
#------------------------------------------------------------------------
# PlotComponent and AbstractOverlay interface
#------------------------------------------------------------------------
def do_layout(self, *args, **kw):
""" Tells this component to do layout at a given size.
Overrides PlotComponent.
"""
if self.use_draw_order and self.component is not None:
self._layout_as_overlay(*args, **kw)
else:
super(PlotGrid, self).do_layout(*args, **kw)
return
#------------------------------------------------------------------------
# Private methods
#------------------------------------------------------------------------
def _do_layout(self):
""" Performs a layout.
Overrides PlotComponent.
"""
return
def _layout_as_overlay(self, size=None, force=False):
""" Lays out the axis as an overlay on another component.
"""
if self.component is not None:
self.position = self.component.position
self.bounds = self.component.bounds
return
def _reset_cache(self):
""" Clears the cached tick positions.
"""
self._tick_positions = array([], dtype=float)
self._tick_extents = array([], dtype=float)
self._cache_valid = False
return
def _compute_ticks(self, component=None):
""" Calculates the positions for the grid lines.
"""
if (self.mapper is None):
self._reset_cache()
self._cache_valid = True
return
if self.data_min is None:
datalow = self.mapper.range.low
else:
datalow = self.data_min
if self.data_max is None:
datahigh = self.mapper.range.high
else:
datahigh = self.data_max
# Map the low and high data points
screenhigh = self.mapper.map_screen(datalow)
screenlow = self.mapper.map_screen(datahigh)
if (datalow == datahigh) or (screenlow == screenhigh) or \
(datalow in [inf, -inf]) or (datahigh in [inf, -inf]):
self._reset_cache()
self._cache_valid = True
return
if component is None:
component = self.component
if component is not None:
bounds = component.bounds
position = component.position
else:
bounds = self.bounds
position = self.position
if isinstance(self.mapper, LogMapper):
scale = 'log'
else:
scale = 'linear'
ticks = self.tick_generator.get_ticks(datalow,
datahigh,
datalow,
datahigh,
self.grid_interval,
use_endpoints=False,
scale=scale)
tick_positions = self.mapper.map_screen(array(ticks, float64))
if self.orientation == 'horizontal':
self._tick_positions = around(
column_stack((zeros_like(tick_positions) + position[0],
tick_positions)))
elif self.orientation == 'vertical':
self._tick_positions = around(
column_stack((tick_positions,
zeros_like(tick_positions) + position[1])))
else:
raise self.NotImplementedError
# Compute the transverse direction extents
self._tick_extents = zeros((len(ticks), 2), dtype=float)
if self.transverse_bounds is None or self.transverse_mapper is None:
# No mapping needed, just use the extents
if self.orientation == 'horizontal':
extents = (position[0], position[0] + bounds[0])
elif self.orientation == 'vertical':
extents = (position[1], position[1] + bounds[1])
self._tick_extents[:] = extents
elif callable(self.transverse_bounds):
data_extents = self.transverse_bounds(ticks)
tmapper = self.transverse_mapper
if isinstance(data_extents, tuple):
self._tick_extents[:] = tmapper.map_screen(
asarray(data_extents))
else:
extents = array([
tmapper.map_screen(data_extents[:, 0]),
tmapper.map_screen(data_extents[:, 1])
]).T
self._tick_extents = extents
else:
# Already a tuple
self._tick_extents[:] = self.transverse_mapper.map_screen(
asarray(self.transverse_bounds))
self._cache_valid = True
def _draw_overlay(self, gc, view_bounds=None, mode='normal'):
""" Draws the overlay layer of a component.
Overrides PlotComponent.
"""
self._draw_component(gc, view_bounds, mode)
return
def overlay(self, other_component, gc, view_bounds=None, mode="normal"):
""" Draws this component overlaid on another component.
Overrides AbstractOverlay.
"""
if not self.visible:
return
self._compute_ticks(other_component)
self._draw_component(gc, view_bounds, mode)
self._cache_valid = False
return
def _draw_component(self, gc, view_bounds=None, mode="normal"):
""" Draws the component.
This method is preserved for backwards compatibility. Overrides
PlotComponent.
"""
# What we're really trying to do with a grid is plot contour lines in
# the space of the plot. In a rectangular plot, these will always be
# straight lines.
if not self.visible:
return
if not self._cache_valid:
self._compute_ticks()
if len(self._tick_positions) == 0:
return
with gc:
gc.set_line_width(self.line_weight)
gc.set_line_dash(self.line_style_)
gc.set_stroke_color(self.line_color_)
gc.set_antialias(False)
if self.component is not None:
gc.clip_to_rect(*(self.component.position +
self.component.bounds))
else:
gc.clip_to_rect(*(self.position + self.bounds))
gc.begin_path()
if self.orientation == "horizontal":
starts = self._tick_positions.copy()
starts[:, 0] = self._tick_extents[:, 0]
ends = self._tick_positions.copy()
ends[:, 0] = self._tick_extents[:, 1]
else:
starts = self._tick_positions.copy()
starts[:, 1] = self._tick_extents[:, 0]
ends = self._tick_positions.copy()
ends[:, 1] = self._tick_extents[:, 1]
if self.flip_axis:
starts, ends = ends, starts
gc.line_set(starts, ends)
gc.stroke_path()
return
def _mapper_changed(self, old, new):
if old is not None:
old.on_trait_change(self.mapper_updated, "updated", remove=True)
if new is not None:
new.on_trait_change(self.mapper_updated, "updated")
self.invalidate()
return
def mapper_updated(self):
"""
Event handler that is bound to this mapper's **updated** event.
"""
self.invalidate()
return
def _position_changed_for_component(self):
self.invalidate()
def _position_items_changed_for_component(self):
self.invalidate()
def _bounds_changed_for_component(self):
self.invalidate()
def _bounds_items_changed_for_component(self):
self.invalidate()
#------------------------------------------------------------------------
# Event handlers for visual attributes. These mostly just call request_redraw()
#------------------------------------------------------------------------
@on_trait_change("visible,line_color,line_style,line_weight")
def visual_attr_changed(self):
""" Called when an attribute that affects the appearance of the grid
is changed.
"""
if self.component:
self.component.invalidate_draw()
self.component.request_redraw()
else:
self.invalidate_draw()
self.request_redraw()
def _grid_interval_changed(self):
self.invalidate()
self.visual_attr_changed()
def _orientation_changed(self):
self.invalidate()
self.visual_attr_changed()
return
### Persistence ###########################################################
#_pickles = ("orientation", "line_color", "line_style", "line_weight",
# "grid_interval", "mapper")
def __getstate__(self):
state = super(PlotGrid, self).__getstate__()
for key in [
'_cache_valid', '_tick_list', '_tick_positions',
'_tick_extents'
]:
if key in state:
del state[key]
return state
def _post_load(self):
super(PlotGrid, self)._post_load()
self._mapper_changed(None, self.mapper)
self._reset_cache()
self._cache_valid = False
return
from .editor_factory import EditorFactory
from .context_value import ContextValue
from .undo import UndoItem
from .item import Item
import six
#-------------------------------------------------------------------------
# Trait definitions:
#-------------------------------------------------------------------------
# Reference to an EditorFactory object
factory_trait = Trait(EditorFactory)
#-------------------------------------------------------------------------
# 'Editor' abstract base class:
#-------------------------------------------------------------------------
class Editor(HasPrivateTraits):
""" Represents an editing control for an object trait in a Traits-based
user interface.
"""
#-------------------------------------------------------------------------
# Trait definitions:
#-------------------------------------------------------------------------
def __line_style_trait(value='solid', **metadata):
return Trait(value,
__line_style_trait_values,
editor=LineStyleEditor,
**metadata)
class HasComparisonMode(HasTraits):
bar = Trait(comparison_mode=ComparisonMode.equality)
class ResNetOfficial(HasPrivateTraits):
avg_pooling_type = Trait(
1, 2
) # 1 -> pooling like in He et al, 2 -> pooling along channels dimension
inputgridsize = Int(2601)
numhiddenlayers = Int(1)
numhiddennodes = Int(256)
average_pooling = Bool(True)
resnet_size = Int(20) # 20, 32, 44, 56 layers...
random_seed = Any(None)
output_shape = Dict({
'1': [-1],
'2': [-1, 2]
},
desc='individual shape of each output')
output_fc_nodes = Dict(
{
'1': 1,
'2': 2
},
desc='nodes of individual last fullyconnected layer of output')
def network_constructor(self, inputs, mode):
"""
function constructs convolutional neural network from class
information
returns all layers as list and output object which provides data
"""
print("construct network...")
is_training = (mode == tf.estimator.ModeKeys.TRAIN)
print("is_training:", is_training)
print("initialized grid size: ", self.inputgridsize)
model = ResNetClass(resnet_size=self.resnet_size,
inputgridsize=self.inputgridsize,
average_pooling=self.average_pooling,
average_pooling_type=self.avg_pooling_type,
random_seed=self.random_seed)
print("final number of filters: ", model.final_size)
resnet_output = model(inputs, mode == tf.estimator.ModeKeys.TRAIN)
# add multiple outputs with dense layer
out = dict()
for output in list(self.output_shape.keys()):
# with tf.name_scope("dense_output{}".format(output)): # layer name scope
inputs = tf.identity(resnet_output,
'resnet_output_{}'.format(output))
for i in range(self.numhiddenlayers):
inputs = tf.layers.dense(
inputs=inputs,
units=self.numhiddennodes,
activation=None,
kernel_initializer=tf.variance_scaling_initializer(
scale=1.0,
mode='fan_avg',
distribution='uniform',
seed=self.random_seed),
name='dense_layer_{}_{}'.format(i, output))
final_layer_output = tf.layers.dense(
inputs=inputs,
units=self.output_fc_nodes[output],
activation=None,
kernel_initializer=tf.variance_scaling_initializer(
scale=1.0,
mode='fan_avg',
distribution='uniform',
seed=self.random_seed),
name="final_layer_output_" + str(output))
# add to output dictionary
out[output] = tf.reshape(final_layer_output,
self.output_shape[output])
### # add some information to output
# print([n.name for n in tf.get_default_graph().as_graph_def().node])
# relu_ops = [n.name for n in tf.get_default_graph().as_graph_def().node if 'Relu' in n.name]
# conv2d_ops = [n.name for n in tf.get_default_graph().as_graph_def().node if 'Conv2D' in n.name]
# regression_ops = [n.name for n in tf.get_default_graph().as_graph_def().node if 'resnet_output' in n.name or 'dense_layer' in n.name]
## kernel_ops = [n.name for n in tf.get_default_graph().as_graph_def().node if 'kernel' in n.name and 'conv2d' in n.name]
# for lt in [relu_ops,conv2d_ops,regression_ops]:
# for op in lt:
# out[op] = tf.get_default_graph().get_tensor_by_name(op+':0')
#
# #out['Relu'] = self.get_tensor_values(relu_ops)
## out['Conv2D'] = self.get_tensor_values(conv2d_ops)
## kernel_ops = [n.name for n in tf.get_default_graph().as_graph_def().node if 'kernel' in n.name and 'conv2d' in n.name]
## out['kernels'] = self.get_tensor_values(kernel_ops)
#
return out
class OldRichCompare(HasTraits):
bar = Trait(rich_compare=True)
except:
pass
raise TraitError(object, name, 'a font descriptor string',
repr(value))
def info(self):
return ("a string describing a font (e.g. '12 pt bold italic "
"swiss family Arial' or 'default 12')")
#-------------------------------------------------------------------------
# Callable that returns an instance of the PyQtToolkitEditorFactory for font
# editors.
#-------------------------------------------------------------------------
### FIXME: We have declared the 'editor' to be a function instead of the
# traitsui.qt4.font_editor.ToolkitEditorFactory class, since the
# latter is leading to too many circular imports. In the future, try to see if
# there is a better way to do this.
def get_font_editor(*args, **traits):
from traitsui.qt4.font_editor import ToolkitEditorFactory
return ToolkitEditorFactory(*args, **traits)
#-------------------------------------------------------------------------
# Define a PyQt specific font trait:
#-------------------------------------------------------------------------
PyQtFont = Trait(TraitsFont(), TraitPyQtFont(), editor=get_font_editor)
class StringTrait(HasTraits):
value = Trait("string")
class LineInspector(BaseTool):
""" A simple tool to draw a line parallel to the index or the value axis of
an X-Y plot.
This tool supports only plots with a 1-D index.
"""
# The axis that this tool is parallel to.
axis = Enum("index", "value", "index_x", "index_y")
# The possible inspection modes of the tool.
#
# space:
# The tool maps from screen space into the data space of the plot.
# indexed:
# The tool maps from screen space to an index into the plot's index array.
inspect_mode = Enum("space", "indexed")
# Respond to user mouse events?
is_interactive = Bool(True)
# Does the tool respond to updates in the metadata on the data source
# and update its own position?
is_listener = Bool(False)
# If interactive, does the line inspector write the current data space point
# to the appropriate data source's metadata?
write_metadata = Bool(False)
# The name of the metadata field to listen or write to.
metadata_name = Str("selections")
#------------------------------------------------------------------------
# Override default values of inherited traits in BaseTool
#------------------------------------------------------------------------
# This tool is visible (overrides BaseTool).
visible = True
# This tool is drawn as an overlay (overrides BaseTool).
draw_mode = "overlay"
# TODO:STYLE
# Color of the line.
color = ColorTrait("black")
# Width in pixels of the line.
line_width = Float(1.0)
# Dash style of the line.
line_style = LineStyle("solid")
# Last recorded position of the mouse
_last_position = Trait(None, Any)
def draw(self, gc, view_bounds=None):
""" Draws this tool on a graphics context.
Overrides BaseTool.
"""
# We draw at different points depending on whether or not we are
# interactive. If both listener and interactive are true, then the
# selection metadata on the plot component takes precendence.
plot = self.component
if plot is None:
return
if self.is_listener:
tmp = self._get_screen_pts()
elif self.is_interactive:
tmp = self._last_position
if tmp:
sx, sy = tmp
else:
return
if self.axis == "index" or self.axis == "index_x":
if plot.orientation == "h" and sx is not None:
self._draw_vertical_line(gc, sx)
elif sy is not None:
self._draw_horizontal_line(gc, sy)
else: # self.axis == "value"
if plot.orientation == "h" and sy is not None:
self._draw_horizontal_line(gc, sy)
elif sx is not None:
self._draw_vertical_line(gc, sx)
return
def do_layout(self, *args, **kw):
pass
def overlay(self, component, gc, view_bounds=None, mode="normal"):
""" Draws this component overlaid on a graphics context.
"""
self.draw(gc, view_bounds)
return
def normal_mouse_move(self, event):
""" Handles the mouse being moved.
"""
if not self.is_interactive:
return
plot = self.component
if plot is not None:
self._last_position = (event.x, event.y)
if isinstance(plot, BaseXYPlot):
if self.write_metadata:
if self.inspect_mode == "space":
index_coord, value_coord = \
self._map_to_data(event.x, event.y)
plot.index.metadata[self.metadata_name] = index_coord
plot.value.metadata[self.metadata_name] = value_coord
else:
ndx = plot.map_index((event.x, event.y),
threshold=5.0, index_only=True)
if ndx:
plot.index.metadata[self.metadata_name] = ndx
plot.value.metadata[self.metadata_name] = ndx
elif isinstance(plot, Base2DPlot):
if self.write_metadata:
try:
old_x_data, old_y_data = \
plot.index.metadata[self.metadata_name]
except:
old_x_data, old_y_data = (None, None)
if self.inspect_mode == "space":
if plot.orientation == "h":
x_coord, y_coord = \
plot.map_data([(event.x, event.y)])[0]
else:
y_coord, x_coord = \
plot.map_data([(event.x, event.y)])[0]
if self.axis == "index_x":
metadata = x_coord, old_y_data
elif self.axis == "index_y":
metadata = old_x_data, y_coord
else:
if plot.orientation == "h":
x_ndx, y_ndx = plot.map_index((event.x, event.y),
threshold=5.0)
else:
y_ndx, x_ndx = plot.map_index((event.x, event.y),
threshold=5.0)
if self.axis == "index_x":
metadata = x_ndx, old_y_data
elif self.axis == "index_y":
metadata = old_x_data, y_ndx
plot.index.metadata[self.metadata_name] = metadata
plot.request_redraw()
return
def normal_mouse_leave(self, event):
""" Handles the mouse leaving the plot.
"""
if not self.is_interactive:
return
self._last_position = None
plot = self.component
if plot is not None:
if self.write_metadata:
if isinstance(plot, BaseXYPlot):
plot.index.metadata.pop(self.metadata_name, None)
plot.value.metadata.pop(self.metadata_name, None)
elif isinstance(plot, Base2DPlot):
plot.index.metadata.pop(self.metadata_name, None)
plot.request_redraw()
return
#------------------------------------------------------------------------
# Private methods
#------------------------------------------------------------------------
def _get_screen_pts(self):
""" Returns the screen-space coordinates of the selected point on
the plot component as a tuple (x, y).
A dimension that doesn't have a selected point has the value None at
its index in the tuple, or won't have the key.
"""
plot = self.component
if plot is None:
return
retval = [None, None]
if isinstance(plot, BaseXYPlot):
index_coord = plot.index.metadata.get(self.metadata_name, None)
value_coord = plot.value.metadata.get(self.metadata_name, None)
if index_coord not in (None, []):
if self.inspect_mode == "indexed":
index_coord = plot.index.get_data()[index_coord]
retval[0] = plot.index_mapper.map_screen(index_coord)
if value_coord not in (None, []):
if self.inspect_mode == "indexed":
value_coord = plot.index.get_data()[value_coord]
retval[1] = plot.value_mapper.map_screen(value_coord)
elif isinstance(plot, Base2DPlot):
try:
x_coord, y_coord = plot.index.metadata[self.metadata_name]
except:
x_coord, y_coord = (None, None)
if x_coord not in (None, []):
if self.inspect_mode == "indexed":
x_coord = plot.index.get_data()[0].get_data()[x_coord]
retval[0] = plot.index_mapper._xmapper.map_screen(x_coord)
if y_coord not in (None, []):
if self.inspect_mode == "indexed":
y_coord = plot.index.get_data()[1].get_data()[y_coord]
retval[1] = plot.index_mapper._ymapper.map_screen(y_coord)
if plot.orientation == "h":
return retval
else:
return retval[1], retval[0]
def _map_to_data(self, x, y):
""" Returns the data space coordinates of the given x and y.
Takes into account orientation of the plot and the axis setting.
"""
plot = self.component
if plot.orientation == "h":
index = plot.index_mapper.map_data(x)
value = plot.value_mapper.map_data(y)
else:
index = plot.index_mapper.map_data(y)
value = plot.value_mapper.map_data(x)
return index, value
def _draw_vertical_line(self, gc, sx):
""" Draws a vertical line through screen point (sx,sy) having the height
of the tool's component.
"""
if sx < self.component.x or sx > self.component.x2:
return
with gc:
gc.set_stroke_color(self.color_)
gc.set_line_width(self.line_width)
gc.set_line_dash(self.line_style_)
gc.move_to(sx, self.component.y)
gc.line_to(sx, self.component.y2)
gc.stroke_path()
return
def _draw_horizontal_line(self, gc, sy):
""" Draws a horizontal line through screen point (sx,sy) having the
width of the tool's component.
"""
if sy < self.component.y or sy > self.component.y2:
return
with gc:
gc.set_stroke_color(self.color_)
gc.set_line_width(self.line_width)
gc.set_line_dash(self.line_style_)
gc.move_to(self.component.x, sy)
gc.line_to(self.component.x2, sy)
gc.stroke_path()
return
class MappedTrait(HasTraits):
value = Trait("one", {"one": 1, "two": 2, "three": 3})
class AxisTool(BaseTool):
# The object to notify when we've been clicked
# We notify by calling its .notify method, which should have the
# signature:
# should_handle_event = notify(axis_tool, axis, down_or_up, event)
#
# It should return a bool indicating whether or not we should process the
# event.
range_controller = Any
down_tick_color = ColorTrait("red")
down_axis_line_color = ColorTrait("red")
down_tick_label_color = ColorTrait("red")
down_bgcolor = ColorTrait("lightgray")
down_border_visible = Bool(True)
down_border_color = Trait(None, None, ColorTrait)
_cached_tick_color = ColorTrait
_cached_axis_line_color = ColorTrait
_cached_tick_labl_color = ColorTrait
_cached_bgcolor = ColorTrait
_cached_border_visible = Bool(True)
_cached_border_color = ColorTrait
attr_list = ("tick_color", "axis_line_color", "tick_label_color",
"bgcolor", "border_visible", "border_color")
def normal_left_down(self, event):
if self.component is None:
return
plot = self.component
if plot.index_axis.is_in(event.x, event.y):
axis = plot.index_axis
rangename = "index_range"
elif plot.value_axis.is_in(event.x, event.y):
axis = plot.value_axis
rangename = "value_range"
else:
return
# If we have a controller, we let it decide whether
# or not we get to handle the event.
if self.range_controller is not None:
should_handle = self.range_controller.notify(
self, rangename, "down", event)
if not should_handle:
return
for attr in self.attr_list:
cached = "_cached_" + attr
down = "down_" + attr
setattr(self, cached, getattr(axis, attr))
if getattr(self, down) is not None:
setattr(axis, attr, getattr(self, down))
axis.request_redraw()
plot._debug = True
event.handled = True
return
def normal_left_up(self, event):
if self.component is None:
return
plot = self.component
if plot.index_axis.is_in(event.x, event.y):
axis = plot.index_axis
rangename = "index_range"
elif plot.value_axis.is_in(event.x, event.y):
axis = plot.value_axis
rangename = "value_range"
else:
return
if self.range_controller is not None:
should_handle = self.range_controller.notify(
self, rangename, "up", event)
if not should_handle:
return
for attr in self.attr_list:
cached = "_cached_" + attr
setattr(axis, attr, getattr(self, cached))
axis.request_redraw()
event.handled = True
return
class PrefixMapTrait(HasTraits):
value = Trait("one", TraitPrefixMap({"one": 1, "two": 2, "three": 3}))
]
class FactoryClass(HasTraits):
pass
class ConsumerClass(HasTraits):
x = Instance(FactoryClass, ())
class ConsumerSubclass(ConsumerClass):
x = FactoryClass()
embedded_instance_trait = Trait("", Str,
Instance("traits.has_traits.HasTraits"))
class Dummy(HasTraits):
x = embedded_instance_trait
xl = List(embedded_instance_trait)
class RegressionTest(unittest.TestCase):
""" Check that fixed bugs stay fixed.
"""
def test_factory_subclass_no_segfault(self):
""" Test that we can provide an instance as a default in the definition
of a subclass.
"""
# There used to be a bug where this would segfault.
class NewInstanceTrait(HasTraits):
value = Trait(ntrait_test1)
class HasComparisonMode(HasTraits):
bar = Trait(comparison_mode=ComparisonMode.none)
class DelegatedFloatTrait(HasTraits):
value = Trait(99.0)
class HasComparisonMode(HasTraits):
bar = Trait(comparison_mode=ComparisonMode.identity)
class DelegateTrait2(DelegateTrait):
delegate = Trait(DelegateTrait())
class OutputList(HasTraits):
"""This class has methods to emulate an file-like output list of strings.
The `max_len` attribute specifies the maximum number of bytes saved by
the object. `max_len` may be set to None.
The `paused` attribute is a bool; when True, text written to the
OutputList is saved in a separate buffer, and the display (if there is
one) does not update. When `paused` returns is set to False, the data is
copied from the paused buffer to the main text string.
"""
# Holds LogItems to display
unfiltered_list = List(LogItem)
# Holds LogItems while self.paused is True.
_paused_buffer = List(LogItem)
# filtered set of messages
filtered_list = List(LogItem)
# state of fiter on messages
log_level_filter = Enum(list(SYSLOG_LEVELS.keys()))
# The maximum allowed length of self.text (and self._paused_buffer).
max_len = Trait(DEFAULT_MAX_LEN, None, Int)
# When True, the 'write' or 'write_level' methods append to self._paused_buffer
# When the value changes from True to False, self._paused_buffer is copied
# back to self.unfiltered_list.
paused = Bool(False)
def __init__(self, tfile=False, outdir=''):
if tfile:
self.logfile = sopen(os.path.join(outdir, LOGFILE), 'w')
self.tfile = True
else:
self.tfile = False
def write(self, s):
"""
Write to the lists OutputList as STDOUT or STDERR.
This method exist to allow STDERR and STDOUT to be redirected into this
display. It should only be called when writing to STDOUT and STDERR.
Any log levels from this method will be LOG_LEVEL_CONSOLE
Ignores spaces.
Parameters
----------
s : str
string to cast as LogItem and write to tables
"""
if s and not s.isspace():
log = LogItem(s, CONSOLE_LOG_LEVEL)
if self.paused:
self.append_truncate(self._paused_buffer, log)
else:
self.append_truncate(self.unfiltered_list, log)
if log.matches_log_level_filter(self.log_level_filter):
self.append_truncate(self.filtered_list, log)
if self.tfile:
self.logfile.write(log.print_to_log())
def write_level(self, s, level):
"""
Write to the lists in OutputList from device or user space.
Parameters
----------
s : str
string to cast as LogItem and write to tables
level : int
Integer log level to use when creating log item.
"""
if s and not s.isspace():
log = LogItem(s, level)
if self.paused:
self.append_truncate(self._paused_buffer, log)
else:
self.append_truncate(self.unfiltered_list, log)
if log.matches_log_level_filter(self.log_level_filter):
self.append_truncate(self.filtered_list, log)
def append_truncate(self, buffer, s):
"""
Append to a front of buffer, keeping overall size less than max_len
Parameters
----------
s : List
Buffer to append
s : LogItem
Log Item to add
"""
if len(buffer) > self.max_len:
assert (len(buffer) -
self.max_len) == 1, "Output list buffer is too long"
buffer.pop()
buffer.insert(0, s)
def clear(self):
"""
Clear all Output_list buffers
"""
self._paused_buffer = []
self.filtered_list = []
self.unfiltered_list = []
def flush(self):
GUI.process_events()
def close(self):
if self.tfile:
self.logfile.close()
def _log_level_filter_changed(self):
"""
Copy items from unfiltered list into filtered list
"""
self.filtered_list = [
item for item in self.unfiltered_list
if item.matches_log_level_filter(self.log_level_filter)
]
def _paused_changed(self):
"""
Swap buffers around when the paused boolean changes state.
"""
if self.paused:
# Copy the current list to _paused_buffer. While the OutputStream
# is paused, the write methods will append its argument to _paused_buffer.
self._paused_buffer = self.unfiltered_list
else:
# No longer paused, so copy the _paused_buffer to the displayed list, and
# reset _paused_buffer.
self.unfiltered_list = self._paused_buffer
# we have to refilter the filtered list too
self._log_level_filter_changed()
self._paused_buffer = []
def traits_view(self):
view = \
View(
UItem('filtered_list',
editor=TabularEditor(adapter=LogItemOutputListAdapter(), editable=False,
vertical_lines=False, horizontal_lines=False))
)
return view
