import vtk
import os,sys
from numpy import *
#import Tkinter as tk
#from vtk.tk.vtkTkRenderWindowInteractor import vtkTkRenderWindowInteractor
#import threading
#from threading import Thread
## keyboard shortcuts
shortcuts = {'zoom_in':'z',
'zoom_out':'x',
'rotate_L':'Left',
'rotate_R':'Right',
'spin_L':'Up',
'spin_R':'Down',
'toggle_help':'t',
'save_file':'s',
'cam_settings':'c',
'toggle_volume':'v',
'toggle_actors':'p'}
[docs]class vtk_render(object):
"""Class to render particle data with VTK.
Once this class is created you can easily add 'actors'
to the scene via the enclosed methods.
Examples
--------
>>> import visualizer as viz
>>>
>>> obj = viz.vtk_render()
>>> obj.point_render(pos[:,0],pos[:,1],pos[:,2],
color=[0.2,0.3,0.4],opacity=0.8)
>>> obj.sphere(x,y,z,10,color=[1,0,0],alpha=0.2)
>>> obj.renderthis()
"""
def __init__(self):
self.actors = []
self.actorsOn = True
self.volumes = []
self.volumesOn = True
self.helpers = []
self.helpersOn = True
self.create_helpers()
self.stlnum = 0
self.helpersSwitched = False
[docs] def optsWindow(self):
self.root = tk.Tk()
self.frame = tk.Frame(self.root)
self.frame.pack()
self.root.geometry('300x300+0+0')
b = tk.Button(self.frame,text='print stuff',command=self.PRINT)
b.place(x=20,y=20)
[docs] def PRINT(self):
for i in range(0,len(self.actors)):
print self.actors[i]
[docs] def create_helpers(self):
"""creates helper text for keyboard shortcuts"""
helpers = []
tmp = '\t'
helpers.append('Zoom:%sz/x\n' % (tmp*12))
helpers.append('Rotate:%sL/R\n' % (tmp*10))
helpers.append('Spin:%sU/D\n' % (tmp*15))
helpers.append('Save:%ss\n' % (tmp*14))
helpers.append('PrintCam:%sp\n' % (tmp*6))
helpers.append('ToggleHelp:%st\n' % (tmp*4))
helpers.append('Quit:%sq\n' % (tmp*15))
"""
# iterate through dict
for key,value in shortcuts.iteritems():
if 'zoom' in key:
print key,value
if 'rotate' in key:
print key,value
if 'spin' in key:
print key,value
if 'toggle' in key:
print key,value
if 'save' in key:
print key,value
if 'cam' in key:
print key,value
"""
help_text=''
for i in range(0,len(helpers)):
help_text += helpers[i]
self.helper_text = help_text
[docs] def pointRender(self,pos,color=[1,1,1],opacity=1,
alpha=1,size=800,singlepoint=0,psize=1):
self.point_render(pos[:,0],pos[:,1],pos[:,2],color=color,opacity=opacity,
alpha=alpha,size=size,singlepoint=singlepoint,psize=psize)
[docs] def point_render(self,x,y,z,color=[1,1,1],opacity=1,
alpha=1,size=800,singlepoint=0,psize=1):
"""Adds points to the rendering.
Parameters
----------
x : numpy_array or float
x-coordinates of particles to render
y : numpy_array or float
y-coordinates of particles to render
z : numpy_array or float
z-coordinates of particles to render
color : numpy_array or tuple (default=[1,1,1])
color of particles. if array is passed then it must be
the same size as the x/y/z array with each element corresponding
to the color of each particle (ie color[i]=[r,g,b])
opacity : float (default=1)
opacity of said particles
alpha : float (default=1)
interchangable with opacity
singlepoint : int (default=0)
if rendering a single point then this must be set to 1
psize : int (default=1)
size of particles?
"""
vcolors = 0
if len(color) > 3:
vcolors=1
if alpha < 1 and opacity == 1:
opacity = alpha
vtkPoints = vtk.vtkPoints()
if isinstance(x,float):
singlepoint = 1
x = asarray([x])
y = asarray([y])
z = asarray([z])
vtkPoints.SetNumberOfPoints(len(x))
for i in range(len(x)):
vtkPoints.SetPoint(i,x[i],y[i],z[i])
vtkCellArray = vtk.vtkCellArray()
if vcolors:
Colors = vtk.vtkUnsignedCharArray()
Colors.SetNumberOfComponents(3)
Colors.SetName("Colors")
for i in range(len(x)):
vtkCellArray.InsertNextCell(1)
vtkCellArray.InsertCellPoint(i)
if vcolors:
Colors.InsertNextTuple3(color[i,0]*255,color[i,1]*255,color[i,2]*255)
vtkPolyData = vtk.vtkPolyData()
vtkPolyData.SetPoints(vtkPoints)
vtkPolyData.SetVerts(vtkCellArray)
if vcolors:
vtkPolyData.GetPointData().SetScalars(Colors)
vtkPolyData.Modified()
vtkPolyData.Update()
mapper = vtk.vtkPolyDataMapper()
mapper.SetInput(vtkPolyData)
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.GetProperty().SetPointSize(psize)
actor.GetProperty().SetOpacity(opacity)
if vcolors==0:
actor.GetProperty().SetColor(color[0],color[1],color[2])
self.actors.append(actor)
[docs] def volume_render(self, grid):
"""Volume rendering currently bugged and unsupported."""
from vtk.util import numpy_support
n = shape(grid)[0]
v = vtk.vtkStructuredPoints()
v.SetDimensions(n,n,n)
flatarray = grid.flatten()
minval = -log10(min(flatarray[nonzero(flatarray)])) + 1
maxval = log10(max(flatarray)) + minval
for i in range(0,len(flatarray)):
if flatarray[i] > 0:
flatarray[i] = ((log10(flatarray[i]) + minval)/maxval) * 255.
flatarray = flatarray.astype(uint16)
v.GetPointData().SetScalars(numpy_support.numpy_to_vtk(flatarray))
# Create transfer mapping scalar value to opacity
opacityTransferFunction = vtk.vtkPiecewiseFunction()
opacityTransferFunction.AddPoint(20,0)
opac = linspace(0.01,0.8,52)
for i in range(5,50):
opacityTransferFunction.AddPoint(i*5, 0.01)
opacityTransferFunction.AddPoint(255, 0.1)
# Create transfer mapping scalar value to color
colorTransferFunction = vtk.vtkColorTransferFunction()
colorTransferFunction.AddRGBPoint(0.0 , 0.0, 0.0, 0.0)
colorTransferFunction.AddRGBPoint(64.0 , 1.0, 0.0, 0.0)
colorTransferFunction.AddRGBPoint(128.0, 0.0, 0.0, 1.0)
colorTransferFunction.AddRGBPoint(192.0, 0.0, 1.0, 0.0)
colorTransferFunction.AddRGBPoint(255.0, 0.0, 0.2, 0.0)
# The property describes how the data will look
volumeProperty = vtk.vtkVolumeProperty()
volumeProperty.SetColor(colorTransferFunction)
volumeProperty.SetScalarOpacity(opacityTransferFunction)
volumeProperty.ShadeOn()
volumeProperty.SetInterpolationTypeToLinear()
# The mapper / ray cast function know how to render the data
compositeFunction = vtk.vtkVolumeRayCastCompositeFunction()
volumeMapper = vtk.vtkVolumeRayCastMapper()
volumeMapper.SetVolumeRayCastFunction(compositeFunction)
volumeMapper.SetInput(v)
volume = vtk.vtkVolume()
volume.SetMapper(volumeMapper)
volume.SetProperty(volumeProperty)
self.volumes.append(volume)
[docs] def label(self,cmx,cmy,cmz,text,
textcolor=[1,1,1],textfontsize=12,
labelboxcolor=[0,0,0],labelbox=1,
labelboxopacity=0.8):
"""Create label within the VTK object.
Parameters
----------
cmx : float
x-coordinate of the label
cmy : float
y-coordinate of the label
cmz : float
z-coordinate of the label
text : string
what to put in the label
textcolor : tuple (default=[1,1,1])
color of the text
textfontsize : int (default=12)
size of the text
labelboxcolor : tuple (default=[0,0,0])
color of the box enclosing the text
labelbox : int (default=1)
enclose the text in a box?
labelboxopacity : float (default=0.8)
opacity of the enclosing box
"""
pd = vtk.vtkPolyData()
pts = vtk.vtkPoints()
verts = vtk.vtkDoubleArray()
orient = vtk.vtkDoubleArray()
orient.SetName('orientation')
label = vtk.vtkStringArray()
label.SetName('label')
pts.InsertNextPoint(cmx,cmy,cmz)
orient.InsertNextValue(1)
label.InsertNextValue(str(text))
pd.SetPoints(pts)
#pd.SetVerts(verts)
pd.GetPointData().AddArray(label)
pd.GetPointData().AddArray(orient)
hier = vtk.vtkPointSetToLabelHierarchy()
hier.SetInput(pd)
hier.SetOrientationArrayName('orientation')
hier.SetLabelArrayName('label')
hier.GetTextProperty().SetColor(textcolor[0],textcolor[1],textcolor[2])
hier.GetTextProperty().SetFontSize(textfontsize)
lmapper = vtk.vtkLabelPlacementMapper()
lmapper.SetInputConnection(hier.GetOutputPort())
if labelbox:
lmapper.SetShapeToRoundedRect()
lmapper.SetBackgroundColor(labelboxcolor[0],labelboxcolor[1],labelboxcolor[2])
lmapper.SetBackgroundOpacity(labelboxopacity)
lmapper.SetMargin(3)
lactor=vtk.vtkActor2D()
lactor.SetMapper(lmapper)
mapper=vtk.vtkPolyDataMapper()
mapper.SetInput(pd)
actor=vtk.vtkActor()
actor.SetMapper(mapper)
self.actors.append(lactor)
[docs] def placetext(self,text,size=800,fontsize=18,loc=1,textcolor=([1,1,1])):
"""Place text in one of the corners of the render window.
Parameters
----------
text : string
text to stick in the corner
loc : int (default=1)
which corner?
textcolor : tuple (default=[1,1,1])
what color should the text be?
"""
if loc==1:
place=3
if loc==2:
place=2
if loc==3:
place=0
if loc==4:
place=1
txt=vtk.vtkCornerAnnotation()
txt.SetText(place, text)
txtprop=txt.GetTextProperty()
txtprop.SetColor(textcolor)
self.actors.append(txt)
[docs] def sphere(self,x,y,z,r,color=[1,1,1],opacity=1,res=12):
"""Add a sphere to the rendering.
Parameters
----------
x : float
x-coordinate of the sphere center
y : float
y-coordinate of the sphere center
z : float
z-coordinate of the sphere center
r : float
radius of the sphere
color : tuple (default=[1,1,1])
opacity : float (default=1)
res : int (default=12)
resolutuion of the sphere
"""
source = vtk.vtkSphereSource()
source.SetCenter(x,y,z)
source.SetRadius(r)
## default res in phi/theta = 8
source.SetPhiResolution(res)
source.SetThetaResolution(res)
mapper = vtk.vtkPolyDataMapper()
mapper.SetInput(source.GetOutput())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.GetProperty().SetOpacity(opacity)
actor.GetProperty().SetColor(color[0],color[1],color[2])
self.actors.append(actor)
[docs] def resetSTLcounter(self):
self.stlnum = 0
[docs] def arrow(self,p1,p2,shaftR=0.01,tipR=0.05,tipL=0.2,balls=0,ballcolor=([1.0,1.0,0.]),ballradius=1,color=[1,1,1],stl=''):
"""Draw an arrow in the render window.
Parameters
----------
p1 : numpy_array
base of the arrow location
p2 : numpy_array
tip of the arrow location
"""
import random
arrowSource = vtk.vtkArrowSource()
random.seed(8775070)
startPoint = [0 for i in range(3)]
startPoint[0] = p1[0]
startPoint[1] = p1[1]
startPoint[2] = p1[2]
endPoint = [0 for i in range(3)]
endPoint[0] = p2[0]
endPoint[1] = p2[1]
endPoint[2] = p2[2]
# Compute a basis
normalizedX = [0 for i in range(3)]
normalizedY = [0 for i in range(3)]
normalizedZ = [0 for i in range(3)]
# The X axis is a vector from start to end
math = vtk.vtkMath()
math.Subtract(endPoint, startPoint, normalizedX)
length = math.Norm(normalizedX)
math.Normalize(normalizedX)
# The Z axis is an arbitrary vector cross X
arbitrary = [0 for i in range(3)]
arbitrary[0] = random.uniform(-10,10)
arbitrary[1] = random.uniform(-10,10)
arbitrary[2] = random.uniform(-10,10)
math.Cross(normalizedX, arbitrary, normalizedZ)
math.Normalize(normalizedZ)
# The Y axis is Z cross X
math.Cross(normalizedZ, normalizedX, normalizedY)
matrix = vtk.vtkMatrix4x4()
# Create the direction cosine matrix
matrix.Identity()
for i in range(3):
matrix.SetElement(i, 0, normalizedX[i])
matrix.SetElement(i, 1, normalizedY[i])
matrix.SetElement(i, 2, normalizedZ[i])
# Apply the transforms
transform = vtk.vtkTransform()
transform.Translate(startPoint)
transform.Concatenate(matrix)
transform.Scale(length, length, length)
# Transform the polydata
transformPD = vtk.vtkTransformPolyDataFilter()
transformPD.SetTransform(transform)
transformPD.SetInputConnection(arrowSource.GetOutputPort())
mapper = []
actors = []
mapper.append(vtk.vtkPolyDataMapper())
actors.append(vtk.vtkActor())
mapper[0].SetInputConnection(transformPD.GetOutputPort())
arrowSource.SetShaftRadius(shaftR) ##default is 0.03
arrowSource.SetTipRadius(tipR) ##default is 0.1
arrowSource.SetTipLength(tipL) ##default 0.35
actors[0].SetMapper(mapper[0])
actors[0].GetProperty().SetColor(color)
## TEST
"""
if stl != '':
writer = vtk.vtkSTLWriter()
##writer.SetInputConnection(arrowSource.GetOutputPort())
writer.SetInputConnection(transformPD.GetOutputPort())
writer.SetFileName("%s%04d.stl" % (stl,self.stlnum))
writer.Write()
self.stlnum += 1
#######
"""
if balls:
sphereStartSource = vtk.vtkSphereSource()
sphereStartSource.SetRadius(ballradius) ## SET RADIUS VAR
sphereStartSource.SetCenter(startPoint)
mapper.append(vtk.vtkPolyDataMapper())
mapper[1].SetInputConnection(sphereStartSource.GetOutputPort())
actors.append(vtk.vtkActor())
actors[1].SetMapper(mapper[1])
actors[1].GetProperty().SetColor(ballcolor)
sphereEndSource = vtk.vtkSphereSource()
sphereEndSource.SetRadius(ballradius) ## SET RADIUS VAR
sphereEndSource.SetCenter(endPoint)
mapper.append(vtk.vtkPolyDataMapper())
mapper[2].SetInputConnection(sphereEndSource.GetOutputPort())
actors.append(vtk.vtkActor())
actors[2].SetMapper(mapper[2])
actors[2].GetProperty().SetColor(ballcolor) ## SET COLOR
if balls:
self.actors.extend([actors[0],actors[2]])
else:
self.actors.extend([actors[0]])
[docs] def setup_helper(self):
'setup helper text'
txt = vtk.vtkCornerAnnotation()
txt.SetText(2, self.helper_text)
txtprop = txt.GetTextProperty()
txtprop.SetFontSize(1)
txt.SetLinearFontScaleFactor(3) # default is 5
self.helpers.append(txt)
self.helper = txt
#def button(self):
#mybutton = vtk.vtkButtonWidget.New()
[docs] def cube(self,center,size,color=[1,1,1]):
"""Render a cube in the render window."""
lxmin=center[0]-float(size)/2.
lxmax=center[0]+float(size)/2.
lymin=center[1]-float(size)/2.
lymax=center[1]+float(size)/2.
lzmin=center[2]-float(size)/2.
lzmax=center[2]+float(size)/2.
actors=[]
p1=[(lxmin,lymin,lzmin),(lxmin,lymin,lzmin),(lxmin,lymin,lzmin),
(lxmin,lymax,lzmax),(lxmin,lymax,lzmax),(lxmin,lymax,lzmax),
(lxmax,lymax,lzmax),(lxmax,lymax,lzmax),(lxmax,lymin,lzmax),
(lxmax,lymin,lzmax),(lxmax,lymax,lzmin),(lxmax,lymax,lzmin)]
p2=[(lxmax,lymin,lzmin),(lxmin,lymax,lzmin),(lxmin,lymin,lzmax),
(lxmax,lymax,lzmax),(lxmin,lymin,lzmax),(lxmin,lymax,lzmin),
(lxmax,lymax,lzmin),(lxmax,lymin,lzmax),(lxmin,lymin,lzmax),
(lxmax,lymin,lzmin),(lxmin,lymax,lzmin),(lxmax,lymin,lzmin)]
for i in range(12):
source = vtk.vtkLineSource()
source.SetPoint1(p1[i])
source.SetPoint2(p2[i])
mapper = vtk.vtkPolyDataMapper()
mapper.SetInput(source.GetOutput())
# actor
actors.append(vtk.vtkActor())
actors[i].SetMapper(mapper)
# color actor
actors[i].GetProperty().SetColor(color)
self.actors.extend(actors)
[docs] def line(self,p1,p2,color=[1,1,1]):
"""Render a line in the render window"""
actors = []
source = vtk.vtkLineSource()
source.SetPoint1(p1)
source.SetPoint2(p2)
mapper = vtk.vtkPolyDataMapper()
mapper.SetInput(source.GetOutput())
actors.append(vtk.vtkActor())
actors[0].SetMapper(mapper)
actors[0].GetProperty().SetColor(color)
self.actors.extend(actors)
[docs] def setup_orientmarker(self,bgcolor):
self.axes = vtk.vtkAxesActor()
self.axes.SetShaftTypeToCylinder()
def getcolor(val):
if val < 0.5:
val = 1.
else:
val = 0.
return val
rval = getcolor(bgcolor[0])
gval = getcolor(bgcolor[1])
bval = getcolor(bgcolor[2])
#if bgcolor == [1,1,1]:
if 1 > 0:
axisLabelText = vtk.vtkTextProperty()
#axisLabelText.SetFontFamilyToArial()
axisLabelText.SetColor([rval,gval,bval])
axisLabelText.SetFontSize(18)
#axisLabelText.ShadowOn()
self.axes.GetXAxisCaptionActor2D().SetCaptionTextProperty(axisLabelText)
self.axes.GetYAxisCaptionActor2D().SetCaptionTextProperty(axisLabelText)
self.axes.GetZAxisCaptionActor2D().SetCaptionTextProperty(axisLabelText)
self.marker = vtk.vtkOrientationMarkerWidget()
self.marker.SetOrientationMarker(self.axes)
self.marker.SetViewport(0,0,0.15,0.15)
self.marker.SetInteractor(self.iren)
self.marker.EnabledOn()
self.marker.InteractiveOff()
self.marker.KeyPressActivationOff()
self.ren.ResetCamera()
[docs] def setup_axislook(self,axis):
cam = self.ren.GetActiveCamera()
if axis == 2:
cam.Azimuth(90)
cam.Roll(-90)
cam.Azimuth(90)
elif axis == 1:
cam.Azimuth(90)
cam.Roll(-90)
else:
print 'invalid axis choice, looking down z-axis (default)'
return
self.ren.ResetCamera()
[docs] def setup_camera(self,hrotate,vrotate,focalpoint):
cam = self.ren.GetActiveCamera()
## cam rotation
if hrotate != 0:
cam.Azimuth(hrotate)
if vrotate != 0:
cam.Elevation(vrotate)
#self.ren.ResetCamera()
## cam focus
#if focalpoint != None:
if focalpoint is not None:
if len(focalpoint) == 3:
cam.SetFocalPoint(focalpoint)
elif focalpoint==[]:
pass
else:
print 'bad focalpoint:',focalpoint
[docs] def savethis(self,filename):
#self.switch_help(0)
#self.toggle_help() ## turn helper off to save file
saveit = vtk.vtkWindowToImageFilter()
saveit.SetInput(self.renWin)
saveit.Update()
if self.filetype == 'png':
writer = vtk.vtkPNGWriter()
writer.SetFileName('%s.png' % filename)
else:
writer = vtk.vtkTIFFWriter()
writer.SetFileName('%s.tiff' % filename)
writer.SetInputConnection(saveit.GetOutputPort())
writer.Write()
[docs] def quit(self):
sys.exit()
[docs] def renderthis(self, xsize=800, ysize=800, bgcolor=[0,0,0], orientmarker=1,
focalpoint=[], zoom=0, axis=3, hrotate=0, vrotate=0,
savefile=None, filetype='png',get_cam_pos=0,set_cam_pos=[],helptext=1,stl=0):
"""Renders the scene."""
#'function to setup render window, add data, and render/save'
self.frameCounter = 0
self.baseName = 'frame_'
self.filetype = 'png'
self.zoomlevel = zoom
offscreen = 0
if savefile != None:
if isinstance(savefile,str) == False:
print 'savefile is not a string!',savefile
return
else:
offscreen = 1
if not offscreen and helptext == 1:
self.setup_helper()
self.processrender(xsize,ysize,offscreen)
self.ren.SetBackground(bgcolor)
if stl:
writer = vtk.vtkSTLWriter()
writer.SetInputConnection(self.ren.GetOutputPort())
writer.SetFileName("test.stl")
writer.Write()
if orientmarker:
self.setup_orientmarker(bgcolor)
## set axis
if axis!=3:
self.setup_axislook(axis)
## zoom
if self.zoomlevel:
self.ren.GetActiveCamera().Zoom(self.zoomlevel)
#self.ren.ResetCamera()
if len(set_cam_pos) > 0:
self.ren.GetActiveCamera().SetPosition(set_cam_pos[0],
set_cam_pos[1],
set_cam_pos[2])
self.ren.ResetCameraClippingRange()
#self.ren.ResetCamera()
## rotation and focus
#if hrotate!=0 or vrotate!=0 or focalpoint!=None:
if hrotate!=0 or vrotate!=0 or focalpoint is not None:
self.setup_camera(hrotate,vrotate,focalpoint)
#if len(set_cam_pos) > 0:
# self.ren.GetActiveCamera().SetPosition(set_cam_pos[0],
# set_cam_pos[1],
# set_cam_pos[2])
# self.ren.ResetCameraClippingRange()
if get_cam_pos:
campos = self.ren.GetActiveCamera().GetPosition()
print 'camera position = %s' % (campos,)
## zoom
#if self.zoomlevel:
# self.ren.GetActiveCamera().Zoom(self.zoomlevel)
#if not helptext:
# self.toggle_help(manual=0)
#switch_help(self,switch)
if offscreen:
self.renWin.Render()
self.savethis(savefile)
return
self.elevation = 0
#self.button()
self.renWin.Render()
self.iren.Initialize()
self.iren.AddObserver('KeyPressEvent',self.Keypress)
self.iren.Start()
#self.root.mainloop()
[docs] def processrender(self,xsize,ysize,offscreen):
'function to setup VTK render windows and data'
self.ren = vtk.vtkRenderer()
self.renWin = vtk.vtkRenderWindow()
if offscreen:
self.renWin.SetOffScreenRendering(1)
self.renWin.AddRenderer(self.ren)
self.renWin.SetSize(xsize,ysize)
self.iren = vtk.vtkRenderWindowInteractor()
self.iren.SetInteractorStyle(vtk.vtkInteractorStyleTrackballCamera())
#self.iren.SetInteractorStyle(vtk.vtkInteractorStyleJoystickCamera())
self.iren.SetRenderWindow(self.renWin)
for i in range(0,len(self.actors)):
self.ren.AddActor(self.actors[i])
for i in range(0,len(self.volumes)):
self.ren.AddVolume(self.volumes[i])
for i in range(0,len(self.helpers)):
self.ren.AddActor(self.helpers[i])
[docs] def Keypress(self,obj, event):
'function to perform actions on keypress'
key = obj.GetKeySym()
if key == shortcuts.get('cam_settings'):
self.print_camera_settings()
return
if key == shortcuts.get('save_file'):
self.save_frame()
return
if key == shortcuts.get('toggle_help'):
self.toggle_help()
return
if key == shortcuts.get('toggle_volume'):
self.toggle_volumes()
return
if key == shortcuts.get('toggle_actors'):
self.toggle_actors()
return
cam = self.ren.GetActiveCamera()
CAM_MODIFIER = 5
## Dolly > 1 = move towards
## Dolly < 1 = move away
if key == shortcuts.get('zoom_in'):
cam.Dolly(1.1)
if key == shortcuts.get('zoom_out'):
cam.Dolly(0.9)
if key == shortcuts.get('spin_L'):
if self.elevation < 90:
cam.Elevation(CAM_MODIFIER)
self.elevation += CAM_MODIFIER
#cam.Roll(CAM_MODIFIER)
#cam.Pitch(CAM_MODIFIER)
if key == shortcuts.get('spin_R'):
if self.elevation > -90:
cam.Elevation(-CAM_MODIFIER)
self.elevation -= CAM_MODIFIER
#cam.Roll(-CAM_MODIFIER)
#cam.Pitch(-CAM_MODIFIER)
if key == shortcuts.get('rotate_R'):
cam.Azimuth(CAM_MODIFIER)
if key == shortcuts.get('rotate_L'):
cam.Azimuth(-CAM_MODIFIER)
#print 'elevation:',self.elevation
self.ren.ResetCameraClippingRange()
self.renWin.Render()
[docs] def switch_help(self,switch):
'function to turn help on or off entirely'
if self.helpersSwitched == True:
return
## on
if switch:
self.helper.VisibilityOn()
else:
self.helper.VisibilityOff()
self.renWin.Render()
self.helpersSwitched = True
[docs] def toggle_help(self,manual=None):
'function to toggle helper text on/off'
self.helpersOn = not self.helpersOn
if self.helpersOn:
self.helper.VisibilityOn()
else:
self.helper.VisibilityOff()
self.renWin.Render()
[docs] def toggle_actors(self):
self.actorsOn = not self.actorsOn
if self.actorsOn:
for i in range(0,len(self.actors)):
self.actors[i].VisibilityOn()
else:
for i in range(0,len(self.actors)):
self.actors[i].VisibilityOff()
self.renWin.Render()
[docs] def save_frame(self):
'function to save current render'
file_name = '%s%04d.png' % (self.baseName,self.frameCounter)
while(os.path.isfile(file_name)):
self.frameCounter += 1
file_name = '%s%04d.png' % (self.baseName,self.frameCounter)
image = vtk.vtkWindowToImageFilter()
image.SetInput(self.renWin)
png_writer = vtk.vtkPNGWriter()
png_writer.SetInputConnection(image.GetOutputPort())
png_writer.SetFileName(file_name)
self.renWin.Render()
png_writer.Write()
self.frameCounter += 1
print file_name + " has been exported"
[docs] def print_camera_settings(self):
'function to print camera setting to screen'
# ---------------------------------------------------------------
# Print out the current settings of the camera
# ---------------------------------------------------------------
camera = self.ren.GetActiveCamera()
print "Camera settings:"
print " * position: %s" % (camera.GetPosition(),)
print " * focal point: %s" % (camera.GetFocalPoint(),)
print " * up vector: %s" % (camera.GetViewUp(),)
print " * clipping range: %s" % (camera.GetViewUp(),)