def run(self):
# Remove the renderer from the current render window.
self.old_rw.remove_renderer(self.ren)
# Creates renderwindow that should be used ONLY for
# visualization in full screen
full_rw = tvtk.RenderWindow(stereo_capable_window=True,
full_screen=True)
# add the current visualization
full_rw.add_renderer(self.ren)
# provides a simple interactor
style = tvtk.InteractorStyleTrackballCamera()
self.iren = tvtk.RenderWindowInteractor(render_window=full_rw,
interactor_style=style)
# Gets parameters for stereo visualization
if self.old_rw.stereo_render:
full_rw.set(stereo_type=self.old_rw.stereo_type,
stereo_render=True)
# Starts the interactor
self.iren.initialize()
self.iren.render()
self.iren.start()
# Once the full screen window is quit this releases the
# renderer before it is destroyed, and return it to the main
# renderwindow.
full_rw.remove_renderer(self.ren)
self.old_rw.add_renderer(self.ren)
self.old_rw.render()
self.iren.disable()
def _create_control(self, parent):
""" Create the toolkit-specific control that represents the widget. """
if self.off_screen_rendering:
if hasattr(tvtk, 'EGLRenderWindow'):
renwin = tvtk.EGLRenderWindow()
elif hasattr(tvtk, 'OSOpenGLRenderWindow'):
renwin = tvtk.OSOpenGLRenderWindow()
else:
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
renwin.size = (1, 1)
self._renwin = renwin
self._interactor = tvtk.GenericRenderWindowInteractor(
render_window=renwin
)
else:
renwin = self._renwin = tvtk.RenderWindow()
self._interactor = tvtk.RenderWindowInteractor(
render_window=renwin
)
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)
# 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_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 test2(self):
'''展开交互图像窗口的常用流程'''
s = tvtk.CubeSource(x_length=1.0, y_length=2.0, z_length=3.0)
m = tvtk.PolyDataMapper(input_connection=s.output_port)
a = tvtk.Actor(mapper=m)
r = tvtk.Renderer(background=(0.5, 0.5, 0.5))
r.add_actor(a)
w = tvtk.RenderWindow(size=(500, 500))
w.add_renderer(r)
i = tvtk.RenderWindowInteractor(render_window=w)
i.initialize()
i.start()
def show_window(size=(640, 480), snapshot_file='screenshot.png',
timer_callback=None, renderer=renderer, axes=False):
if IPC_VIS:
# we will show window in another process. nothing to do here
return
# Renderer
#renderer = tvtk.Renderer()
#renderer.add_actor(actor)
if axes:
renderer.add_actor(axes_actor(1)) # add axes
renderer.background = (1., 1., 1.)#(0.9, 0.9, 0.8)
#renderer.background = (0.9, 0.9, 0.8)
renderer.reset_camera()
# Render Window
renderWindow = tvtk.RenderWindow()
renderWindow.add_renderer(renderer)
# Interactor
renderWindowInteractor = tvtk.RenderWindowInteractor()
renderWindowInteractor.render_window = renderWindow
def on_key_down(iren_style, key):
rendrr = iren_style.GetCurrentRenderer()
rendrr = tvtk.to_tvtk(rendrr)
if key == '+':
for act in rendrr.actors:
act.property.point_size *= 1.1
elif key == '-':
for act in rendrr.actors:
act.property.point_size /= 1.1
elif key == 's':
ren_win = rendrr.render_window
w2if = tvtk.WindowToImageFilter(input=ren_win)
w2if.update()
writer = tvtk.PNGWriter(file_name=snapshot_file, input=w2if.output)
writer.write()
iren = InteractorStyleModified(key_callback=on_key_down,
timer_callback=timer_callback)
renderWindowInteractor.interactor_style = iren
# Begin Interaction
renderWindow.render()
renderWindow.size = size
#print 'Window size:', renderWindow.size
renderWindowInteractor.create_repeating_timer(500)
renderWindowInteractor.start()
def test01():
s = tvtk.ConeSource(height=6.0, radius=2.0)
m = tvtk.PolyDataMapper(input_connection=s.output_port)
a = tvtk.Actor(mapper=m)
r = tvtk.Renderer(background=(1, 0, 0))
r.add_actor(a)
w = tvtk.RenderWindow(size=(300, 300))
w.add_renderer(r)
i = tvtk.RenderWindowInteractor(render_window=w)
i.initialize()
i.start()
def test01():
# 1. 创建数据源，设置参数，并且将参数映射给数据m
s = tvtk.CubeSource(x_length=1.0, y_length=2.0, z_length=3.0)
m = tvtk.PolyDataMapper(input_connection=s.output_port)
# 2. 创建背景和行为（可以转动），并且将行为送给 背景
a = tvtk.Actor(mapper=m)
r = tvtk.Renderer(background=(0, 0, 0))
r.add_actor(a)
# 3. 创建左面窗口的大小，并且将渲染器放入窗口
w = tvtk.RenderWindow(size=(300, 300))
w.add_renderer(r)
# 4. 创建交互界面，将窗口放入
i = tvtk.RenderWindowInteractor(render_window=w)
i.initialize()
i.start()
def ShowACube(x, y, z, backgroundcolor=(0, 0, 0)):
#立方体源
s = tvtk.CubeSource(x_length=x, y_length=y, z_length=z)
#转换源为图形数据
m = tvtk.PolyDataMapper(input_connection=s.output_port)
#创建Actor，并将图形数据接入
a = tvtk.Actor(mapper=m)
#创建渲染，并将Actor接入
r = tvtk.Renderer(background=backgroundcolor)
r.add_actor(a)
#创建窗口，并将渲染接入
w = tvtk.RenderWindow(size=(900, 900))
w.add_renderer(r)
#创建交互，并将窗口接入
i = tvtk.RenderWindowInteractor(render_window=w)
#开始运行
i.initialize()
i.start()
def test_source():
# 创建一个长方体数据源，并且同时设置其长宽高
s = tvtk.CubeSource(x_length=1.0, y_length=2.0, z_length=3.0)
# 使用PolyDataMapper将数据转换为图形数据
m = tvtk.PolyDataMapper(input_connection=s.output_port)
# 创建一个Actor
a = tvtk.Actor(mapper=m)
# 创建一个Renderer，将Actor添加进去
r = tvtk.Renderer(background=(0, 0, 0))
r.add_actor(a)
# 创建一个RenderWindow(窗口)，将Renderer添加进去
w = tvtk.RenderWindow(size=(300, 300))
w.add_renderer(r)
# 创建一个RenderWindowInteractor（窗口的交互工具)
i = tvtk.RenderWindowInteractor(render_window=w)
# 开启交互
i.initialize()
i.start()
def run(self):
# Remove the renderer from the current render window.
self.old_rw.remove_renderer(self.ren)
# Creates renderwindow tha should be used ONLY for
# visualization in full screen
full_rw = tvtk.RenderWindow(stereo_capable_window=True,
full_screen=True)
# add the current visualization
full_rw.add_renderer(self.ren)
# Under OS X there is no support for creating a full screen
# window so we set the size of the window here.
if sys.platform == 'darwin':
full_rw.size = tuple(wx.GetDisplaySize())
# provides a simple interactor
style = tvtk.InteractorStyleTrackballCamera()
self.iren = tvtk.RenderWindowInteractor(render_window=full_rw,
interactor_style=style)
# Gets parameters for stereo visualization
if self.old_rw.stereo_render:
full_rw.trait_set(stereo_type=self.old_rw.stereo_type,
stereo_render=True)
# Starts the interactor
self.iren.initialize()
self.iren.render()
self.iren.start()
# Once the full screen window is quit this releases the
# renderer before it is destroyed, and return it to the main
# renderwindow.
full_rw.remove_renderer(self.ren)
self.old_rw.add_renderer(self.ren)
self.old_rw.render()
self.iren.disable()
# -*- coding: utf-8 -*- from tvtk.api import tvtk # 创建一个圆锥数据源，并且同时设置其高度，底面半径和底面圆的分辨率(用36边形近似) cs = tvtk.ConeSource(height=3.0, radius=1.0, resolution=36) # 使用PolyDataMapper将数据转换为图形数据 m = tvtk.PolyDataMapper(input_connection=cs.output_port) # 创建一个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 initialize(self, X, Y, initial_data=None, vmin=None, vmax=None):
"""
Create objects to plot on
"""
if initial_data == None:
initial_data = zeros(shape(X))
if vmin == None:
self.vmin = -1.0
if vmax == None:
self.vmax = 1.0
else:
if vmin == None:
self.vmin = np.min(np.min(initial_data))
if vmax == None:
self.vmax = np.max(np.max(initial_data))
x_min = np.min(np.min(X))
y_min = np.min(np.min(Y))
x_max = np.max(np.max(X))
y_max = np.max(np.max(Y))
x_middle = (x_min + x_max) / 2
y_middle = (y_min + y_max) / 2
z_middle = np.mean(np.mean(initial_data))
L = x_max - x_min
diffs = np.shape(X)
x_diff = diffs[0]
y_diff = diffs[1]
z_diff = 1.0 #self.vmax-self.vmin
self.tvtk = tvtk
self.sp = tvtk.StructuredPoints(origin=(x_middle, y_middle, z_middle),
dimensions=(x_diff, y_diff, 1),
spacing=(2 * L / (x_diff - 1),
2 * L / (y_diff - 1), 100.0))
self.z = np.transpose(initial_data).flatten()
self.sp.point_data.scalars = self.z
self.geom_filter = tvtk.ImageDataGeometryFilter(input=self.sp)
self.warp = tvtk.WarpScalar(input=self.geom_filter.output)
self.normals = tvtk.PolyDataNormals(input=self.warp.output)
# The rest of the VTK pipeline.
self.m = tvtk.PolyDataMapper(input=self.normals.output,
scalar_range=(self.vmin, self.vmax))
p = tvtk.Property(opacity=0.5, color=(1, 1, 1), representation="s")
self.a = tvtk.Actor(mapper=self.m, property=p)
self.ren = tvtk.Renderer(background=(0.0, 0.0, 0.0))
self.ren.add_actor(self.a)
# Get a nice view.
self.cam = self.ren.active_camera
self.cam.azimuth(-50)
self.cam.roll(90)
# Create a RenderWindow, add the renderer and set its size.
self.rw = tvtk.RenderWindow(size=(800, 800))
self.rw.add_renderer(self.ren)
# Create the RenderWindowInteractor
self.rwi = tvtk.RenderWindowInteractor(render_window=self.rw)
self.rwi.initialize()
self.ren.reset_camera()
self.rwi.render()
# Create the actor and set its mapper.
a = tvtk.Actor()
a.mapper = m
# Create a Renderer, add the actor and set its background color.
ren = tvtk.Renderer()
ren.add_actor(a)
ren.background = (0.1, 0.2, 0.4)
# Create a RenderWindow, add the renderer and set its size.
rw = tvtk.RenderWindow()
rw.add_renderer(ren)
rw.size = (300, 300)
# Create the RenderWindowInteractor
rwi = tvtk.RenderWindowInteractor()
rwi.render_window = rw
# Setup a box widget.
bw = tvtk.BoxWidget()
bw.interactor = rwi
bw.place_factor = 1.25
bw.prop3d = a
bw.place_widget()
def callback(widget, event):
"""This callback sets the transformation of the cone using that
setup by the the box."""
t = tvtk.Transform()
bw.get_transform(t)
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 mapper = tvtk.PolyDataMapper() configure_input_data(mapper, mesh) mapper.scalar_range = min(temperature), max(temperature) # Create mesh actor for display actor = tvtk.Actor(mapper=mapper) # Create a scalar bar
p1 = seg.origin
p2 = p1 + seg.MAX_RAY_LENGTH * seg.direction
i = self.intersect_with_line(p1, p2)
if i is None:
return None
i = numpy.array(i)
dist = numpy.sqrt(((i - p1)**2).sum())
return dist, i, 0, self
if __name__ == "__main__":
oap = OffAxisParabloid()
mapper = tvtk.PolyDataMapper(input=oap.pipeline.output)
actor = tvtk.Actor(mapper=mapper)
ren = tvtk.Renderer()
ren.add_actor(actor)
ax = tvtk.Axes(origin=(0, 0, 0))
axes_map = tvtk.PolyDataMapper(input=ax.output)
axes_act = tvtk.Actor(mapper=axes_map)
ren.add_actor(axes_act)
ren.background = (0.7, 0.6, 0.5)
renwin = tvtk.RenderWindow()
renwin.add_renderer(ren)
iren = tvtk.RenderWindowInteractor(render_window=renwin)
iren.start()
# coding=utf-8 # @File : E01_cube.py # @Author: aojie654 # @Date : 18-6-10 # @Desc : Cube from tvtk.api import tvtk as tk s = tk.CubeSource(x_length=1.0, y_length=2.0, z_length=3.0) m = tk.PolyDataMapper(input_connection=s.output_port) a = tk.Actor(mapper=m) r = tk.Renderer(background=(0, 0, 0)) r.add_actor(a) w = tk.RenderWindow(size=(3000, 300)) w.add_renderer(r) i = tk.RenderWindowInteractor(render_window=w) i.initialize() i.start()
