def test_object_cache(self): """Test if object cache works.""" cs = tvtk.ConeSource() hash1 = hash(cs) o = cs.output if hasattr(o, 'producer_port'): src = o.producer_port.producer else: src = o.source self.assertEqual(src, cs) self.assertEqual(hash1, hash(src)) del cs, src gc.collect() cs = tvtk.ConeSource() # Force cs to be gc'd! if hasattr(o, 'producer_port'): src = o.producer_port.producer else: src = o.source self.assertEqual(hash1 != hash(src), True) # Test for a bug with collections and the object cache. r = tvtk.Renderer() def _get_props(obj): if hasattr(obj, 'view_props'): return obj.view_props else: return obj.props p = _get_props(r) l1 = len(tvtk_base._object_cache) p1 = _get_props(r) del p1 l2 = len(tvtk_base._object_cache) self.assertEqual(l1, l2)
def run(self): self.vtk_renderer = tvtk.Renderer() self.setup_gui() self.setup_grid() # Handle any deferred configuration # Overlaid polygons for args in self.conf_overlaidPolygons: self.overlay_polygon_internal(*args) # Draw (and maybe alter) the axes if self.vtk_drawAxes: self.vtk_axes = vtkCubeAxesActor2D() # Perform all of the alterations required, by applying func to the vtk_axes instance (with the given args). for func, args in self.conf_axesAlterations: func(*((self.vtk_axes, ) + args)) # Alter the Tk root as necessary. for func, args in self.conf_tkAlterations: func(*((self.tk_root, ) + args)) # Finished with deferred configuration. # Draw Height Quantities for q in self.height_quantities: self.update_height_quantity(q, self.height_dynamic[q]) self.draw_height_quantity(q) self.tk_root.mainloop()
def _create_tvtk_window(self, size=(500, 500)): # create a renderer self.renderer = tvtk.Renderer() # create a render window and hand it the renderer self.render_window = tvtk.RenderWindow(size=size) self.render_window.add_renderer(self.renderer) # create interactor and hand it the render window # This handles mouse interaction with window. self.interactor = tvtk.RenderWindowInteractor( render_window=self.render_window) self.gui = None
def show(d): l = tvtk.LookupTable(table_range=(0, 1)) m = tvtk.PolyDataMapper(input=d.output, scalar_visibility=True, scalar_mode="use_cell_data") p = tvtk.Property(representation="s") a = tvtk.Actor(mapper=m, property=p) ren = tvtk.Renderer(background=(.1, .2, .4)) ren.add_actor(a) rw = tvtk.RenderWindow(size=(600, 600)) rw.add_renderer(ren) rwi = tvtk.RenderWindowInteractor(render_window=rw) rwi.initialize() rwi.start()
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 _create_control(self, parent): """ Create the toolkit-specific control that represents the widget. """ # Create the VTK widget. self._vtk_control = window = _VTKRenderWindowInteractor(self, parent, stereo=self.stereo) # Switch the default interaction style to the trackball one. window.GetInteractorStyle().SetCurrentStyleToTrackballCamera() # Grab the renderwindow. renwin = self._renwin = tvtk.to_tvtk(window.GetRenderWindow()) 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) # 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') renwin.off_screen_rendering = self.off_screen_rendering self._camera.parallel_projection = self.parallel_projection self.sync_trait('parallel_projection', self._camera) 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 = tvtk.to_tvtk(window._Iren) return window
# -*- coding: utf-8 -*- """ Created on Wed Nov 9 08:36:22 2016 @author: Gordon """ from enthought.tvtk.api import tvtk # 创建一个圆锥数据源,并且同时设置其高度,底面半径和底面圆的分辨率(用36边形近似) cs = tvtk.ConeSource(height=3.0, radius=1.0, resolution=36) # 使用PolyDataMapper将数据转换为图形数据 m = tvtk.PolyDataMapper(input = cs.output) # 创建一个Actor a = tvtk.Actor(mapper=m) # 创建一个Renderer,将Actor添加进去 ren = tvtk.Renderer(background=(0.1, 0.2, 0.4)) ren.add_actor(a) # 创建一个RenderWindow(窗口),将Renderer添加进去 rw = tvtk.RenderWindow(size=(300,300)) rw.add_renderer(ren) # 创建一个RenderWindowInteractor(窗口的交互工具) rwi = tvtk.RenderWindowInteractor(render_window=rw) # 开启交互 rwi.initialize() rwi.start()
sp.point_data.scalars = z # Convert this to a PolyData object. geom_filter = tvtk.ImageDataGeometryFilter(input=sp) # Now warp this using the scalar value to generate a carpet plot. warp = tvtk.WarpScalar(input=geom_filter.output) # Smooth the resulting data so it looks good. normals = tvtk.PolyDataNormals(input=warp.output) # The rest of the VTK pipeline. m = tvtk.PolyDataMapper(input=normals.output, scalar_range=(min(z), max(z))) a = tvtk.Actor(mapper=m) ren = tvtk.Renderer(background=(0.5, 0.5, 0.5)) ren.add_actor(a) # Get a nice view. cam = ren.active_camera cam.azimuth(-60) cam.roll(90) # Create a RenderWindow, add the renderer and set its size. rw = tvtk.RenderWindow(size=(600, 600)) rw.add_renderer(ren) # Create the RenderWindowInteractor rwi = tvtk.RenderWindowInteractor(render_window=rw) rwi.initialize()
# License: BSD Style. from enthought.tvtk.api import tvtk from numpy import array ### DATA data = array([[0, 0, 0, 10], [1, 0, 0, 20], [0, 1, 0, 20], [0, 0, 1, 30]], 'f') triangles = array([[0, 1, 3], [0, 3, 2], [1, 2, 3], [0, 2, 1]]) points = data[:, :3] temperature = data[:, -1] ### TVTK PIPELINE # create a renderer renderer = tvtk.Renderer() # create a render window and hand it the renderer render_window = tvtk.RenderWindow(size=(400, 400)) render_window.add_renderer(renderer) # create interactor and hand it the render window # This handles mouse interaction with window. interactor = tvtk.RenderWindowInteractor(render_window=render_window) # Create a mesh from the data created above. mesh = tvtk.PolyData(points=points, polys=triangles) mesh.point_data.scalars = temperature # Set the mapper to scale temperature range # across the entire range of colors
data = tvtk.PolyData(points=points, polys=cells, lines=lines) data.point_data.scalars = numpy.linspace(-5,5,6) lm = LUTManager() #lm.configure_traits() map = tvtk.PolyDataMapper(input=data) map.lookup_table = lm.lut act = tvtk.Actor(mapper=map) x,y = numpy.ogrid[-5:5:0.1, -5:5:0.1] r = x**2 + y**2 z = numpy.cos(r*2) * numpy.exp(-r/3) img = tvtk.ImageData(origin=(2,2,2), spacing=(0.1,0.1,0.1), dimensions = (z.shape[0], z.shape[1],1 )) img.point_data.scalars=z.ravel() img_poly = tvtk.GeometryFilter(input=img) warp = tvtk.WarpScalar(input_connection=img_poly.output_port) norm = tvtk.PolyDataNormals(input_connection = warp.output_port) img_map = tvtk.PolyDataMapper(input_connection=norm.output_port) img_act = tvtk.Actor(mapper=img_map) ren = tvtk.Renderer() #ren.add_actor(act) ren.add_actor(img_act) renwin = tvtk.RenderWindow() renwin.add_renderer(ren) iren = tvtk.RenderWindowInteractor(render_window=renwin) iren.start()
# -*- coding: utf-8 -*- from enthought.tvtk.api import tvtk # 创建一个圆锥数据源,并且同时设置其高度,底面半径和底面圆的分辨率(用36边形近似) cs = tvtk.ConeSource(height=3.0, radius=1.0, resolution=36) # 使用PolyDataMapper将数据转换为图形数据 m = tvtk.PolyDataMapper(input = cs.output) # 创建一个Actor a = tvtk.Actor(mapper=m) # 创建一个Renderer,将Actor添加进去 ren = tvtk.Renderer(background=(1, 1, 1)) ren.add_actor(a) # 创建一个RenderWindow(窗口),将Renderer添加进去 rw = tvtk.RenderWindow(size=(300,300)) rw.add_renderer(ren) # 创建一个RenderWindowInteractor(窗口的交互工具) rwi = tvtk.RenderWindowInteractor(render_window=rw) # 开启交互 rwi.initialize() rwi.start()
def _create_control(self, parent): """ Create the toolkit-specific control that represents the widget. """ # Create the VTK widget. self._vtk_control = window = wxVTKRenderWindowInteractor( parent, -1, stereo=self.stereo) # Override these handlers. wx.EVT_CHAR(window, None) # Remove the default handler. wx.EVT_CHAR(window, self.OnKeyDown) wx.EVT_KEY_UP(window, None) # Remove the default handler. wx.EVT_KEY_UP(window, self.OnKeyUp) wx.EVT_PAINT(window, None) # Remove the default handler. wx.EVT_PAINT(window, self.OnPaint) wx.EVT_SIZE(window, None) # Remove the default handler. wx.EVT_SIZE(window, self.OnSize) # Override the button down and up handlers as well to note the # interaction. This is to toggle the busy status nicely. for evt in (wx.EVT_LEFT_DOWN, wx.EVT_RIGHT_DOWN, wx.EVT_MIDDLE_DOWN): evt(window, None) evt(window, self.OnButtonDown) for evt in (wx.EVT_LEFT_UP, wx.EVT_RIGHT_UP, wx.EVT_MIDDLE_UP): evt(window, None) evt(window, self.OnButtonUp) # Enable the widget. window.Enable(1) # Switch the default interaction style to the trackball one. window.GetInteractorStyle().SetCurrentStyleToTrackballCamera() # Grab the renderwindow. renwin = self._renwin = tvtk.to_tvtk(window.GetRenderWindow()) 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) # 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') def _show_parent_hack(window, parent): """A hack to get the VTK scene properly setup for use.""" # Force the parent to show itself. parent.Show(1) # on some platforms, this SetSize() is necessary to cause # an OnPaint() when the event loop begins; else we get an # empty window until we force a redraw. window.SetSize(parent.GetSize()) # This is necessary on slow machines in order to force the # wx events to be handled. wx.GetApp().Yield(True) window.Render() if wx.Platform == '__WXMSW__': _show_parent_hack(window, parent) else: if (wx.VERSION[0] == 2) and (wx.VERSION[1] < 5): _show_parent_hack(window, parent) window.Update() # Because of the way the VTK widget is setup, and because we # set the size above, the window sizing is usually completely # messed up when the application window is shown. To work # around this a dynamic IDLE event handler is added and # immediately removed once it executes. This event handler # simply forces a resize to occur. The _idle_count allows us # to execute the idle function a few times (this seems to work # better). def _do_idle(event, window=window): w = wx.GetTopLevelParent(window) # Force a resize sz = w.GetSize() w.SetSize((sz[0] - 1, sz[1] - 1)) w.SetSize(sz) window._idle_count -= 1 if window._idle_count < 1: wx.EVT_IDLE(window, None) del window._idle_count window._idle_count = 2 wx.EVT_IDLE(window, _do_idle) self._interactor = tvtk.to_tvtk(window._Iren) return window
from enthought.tvtk.api import tvtk cone = tvtk.ConeSource( height=3.0, radius=1.0, resolution=10 ) cone_mapper = tvtk.PolyDataMapper( input = cone.output ) cone_actor = tvtk.Actor( mapper=cone_mapper ) cone_actor.property.representation = "w" ren1 = tvtk.Renderer() ren1.add_actor( cone_actor ) ren1.background = 0.1, 0.2, 0.4 ren_win = tvtk.RenderWindow() ren_win.add_renderer( ren1 ) ren_win.size = 300, 300 iren = tvtk.RenderWindowInteractor( render_window = ren_win ) iren.initialize() iren.start()