def __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(
self, module_manager,
vtk.vtkAxes(), 'Processing.',
(), ('vtkPolyData',),
replaceDoc=True,
inputFunctions=None, outputFunctions=None)
def __init__ (self, mod_m):
debug ("In Locator::__init__ ()")
Common.state.busy ()
Base.Objects.Module.__init__ (self, mod_m)
self.root = None
self.axesactor = None
self.slider = []
self.resoln_var = []
self.maxlen=0.0
self.plotline_var = Tkinter.IntVar ()
self.tubesize_var = Tkinter.DoubleVar ()
self.linelenres_var = Tkinter.DoubleVar ()
self.npoints_var = Tkinter.IntVar ()
self.data_out = self.mod_m.GetOutput ()
self.line=vtkpython.vtkLineSource()
self.probe=vtkpython.vtkProbeFilter()
self.plotline = self.actor = vtkpython.vtkXYPlotActor ()
self.tuber = vtkpython.vtkTubeFilter()
self.lineactor = vtkpython.vtkActor()
self.mapper = vtkpython.vtkPolyDataMapper()
self.axes=vtkpython.vtkAxes()
self.trans = vtkpython.vtkTransform()
self.axesactor = vtkpython.vtkActor()
self._initialize ()
self.renwin.add_actors (self.lineactor)
self.renwin.add_actors (self.plotline)
self.pipe_objs = self.plotline
self.renwin.Render ()
Common.state.idle ()
def draw_axes_array(self, point_array, color):
points_vtk = vtk.vtkPoints()
for x, y, z in point_array:
points_vtk.InsertNextPoint(x, -y, z)
points_polydata = vtk.vtkPolyData()
points_polydata.SetPoints(points_vtk)
axes = vtk.vtkAxes()
axes.SetScaleFactor(0.5)
sphere = vtk.vtkSphereSource()
sphere.SetRadius(0.01)
normals_filter = vtk.vtkPolyDataNormals()
normals_filter.FlipNormalsOn()
normals_filter.SetInputConnection(axes.GetOutputPort())
axes_glyph_mapper = vtk.vtkGlyph3DMapper()
axes_glyph_mapper.SetInputData(points_polydata)
axes_glyph_mapper.SetSourceConnection(axes.GetOutputPort())
axes_glyph_actor = vtk.vtkActor()
axes_glyph_actor.SetMapper(axes_glyph_mapper)
axes_glyph_actor.GetProperty().SetPointSize(6)
axes_glyph_actor.GetProperty().SetColor(color)
axes_glyph_actor.GetProperty().SetRepresentationToWireframe()
self.renderer.AddActor(axes_glyph_actor)
def __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(self,
module_manager,
vtk.vtkAxes(),
'Processing.', (), ('vtkPolyData', ),
replaceDoc=True,
inputFunctions=None,
outputFunctions=None)
def CreateAxes():
global xAxis, yAxis, zAxis, popSplatter
# Create axes.
popSplatter.Update()
bounds = popSplatter.GetOutput().GetBounds()
axes = vtk.vtkAxes()
axes.SetOrigin(bounds[0], bounds[2], bounds[4])
axes.SetScaleFactor(popSplatter.GetOutput().GetLength()/5.0)
axesTubes = vtk.vtkTubeFilter()
axesTubes.SetInputConnection(axes.GetOutputPort())
axesTubes.SetRadius(axes.GetScaleFactor()/25.0)
axesTubes.SetNumberOfSides(6)
axesMapper = vtk.vtkPolyDataMapper()
axesMapper.SetInputConnection(axesTubes.GetOutputPort())
axesActor = vtk.vtkActor()
axesActor.SetMapper(axesMapper)
# Label the axes.
XText = vtk.vtkVectorText()
XText.SetText(xAxis)
XTextMapper = vtk.vtkPolyDataMapper()
XTextMapper.SetInputConnection(XText.GetOutputPort())
XActor = vtk.vtkFollower()
XActor.SetMapper(XTextMapper)
XActor.SetScale(0.02, .02, .02)
XActor.SetPosition(0.35, -0.05, -0.05)
XActor.GetProperty().SetColor(0, 0, 0)
YText = vtk.vtkVectorText()
YText.SetText(yAxis)
YTextMapper = vtk.vtkPolyDataMapper()
YTextMapper.SetInputConnection(YText.GetOutputPort())
YActor = vtk.vtkFollower()
YActor.SetMapper(YTextMapper)
YActor.SetScale(0.02, .02, .02)
YActor.SetPosition(-0.05, 0.35, -0.05)
YActor.GetProperty().SetColor(0, 0, 0)
ZText = vtk.vtkVectorText()
ZText.SetText(zAxis)
ZTextMapper = vtk.vtkPolyDataMapper()
ZTextMapper.SetInputConnection(ZText.GetOutputPort())
ZActor = vtk.vtkFollower()
ZActor.SetMapper(ZTextMapper)
ZActor.SetScale(0.02, .02, .02)
ZActor.SetPosition(-0.05, -0.05, 0.35)
ZActor.GetProperty().SetColor(0, 0, 0)
return axesActor, XActor, YActor, ZActor
def CreateAxes():
global xAxis, yAxis, zAxis, popSplatter
# Create axes.
popSplatter.Update()
bounds = popSplatter.GetOutput().GetBounds()
axes = vtk.vtkAxes()
axes.SetOrigin(bounds[0], bounds[2], bounds[4])
axes.SetScaleFactor(popSplatter.GetOutput().GetLength()/5.0)
axesTubes = vtk.vtkTubeFilter()
axesTubes.SetInputConnection(axes.GetOutputPort())
axesTubes.SetRadius(axes.GetScaleFactor()/25.0)
axesTubes.SetNumberOfSides(6)
axesMapper = vtk.vtkPolyDataMapper()
axesMapper.SetInputConnection(axesTubes.GetOutputPort())
axesActor = vtk.vtkActor()
axesActor.SetMapper(axesMapper)
# Label the axes.
XText = vtk.vtkVectorText()
XText.SetText(xAxis)
XTextMapper = vtk.vtkPolyDataMapper()
XTextMapper.SetInputConnection(XText.GetOutputPort())
XActor = vtk.vtkFollower()
XActor.SetMapper(XTextMapper)
XActor.SetScale(0.02, .02, .02)
XActor.SetPosition(0.35, -0.05, -0.05)
XActor.GetProperty().SetColor(0, 0, 0)
YText = vtk.vtkVectorText()
YText.SetText(yAxis)
YTextMapper = vtk.vtkPolyDataMapper()
YTextMapper.SetInputConnection(YText.GetOutputPort())
YActor = vtk.vtkFollower()
YActor.SetMapper(YTextMapper)
YActor.SetScale(0.02, .02, .02)
YActor.SetPosition(-0.05, 0.35, -0.05)
YActor.GetProperty().SetColor(0, 0, 0)
ZText = vtk.vtkVectorText()
ZText.SetText(zAxis)
ZTextMapper = vtk.vtkPolyDataMapper()
ZTextMapper.SetInputConnection(ZText.GetOutputPort())
ZActor = vtk.vtkFollower()
ZActor.SetMapper(ZTextMapper)
ZActor.SetScale(0.02, .02, .02)
ZActor.SetPosition(-0.05, -0.05, 0.35)
ZActor.GetProperty().SetColor(0, 0, 0)
return axesActor, XActor, YActor, ZActor
def __init__(self):
self.scene = Scene()
self.frame = MainWindow(self.scene)
self.camera_style = vtk.vtkInteractorStyleTrackballCamera()
self.camera_style.AddObserver('LeftButtonPressEvent',
self.bimodal_mouse_handler)
self.camera_style.AddObserver('LeftButtonReleaseEvent',
self.bimodal_mouse_handler)
self.camera_style.AddObserver('MiddleButtonPressEvent',
self.bimodal_mouse_handler)
self.camera_style.AddObserver('MiddleButtonReleaseEvent',
self.bimodal_mouse_handler)
self.camera_style.AddObserver('RightButtonPressEvent',
self.bimodal_mouse_handler)
self.camera_style.AddObserver('RightButtonReleaseEvent',
self.bimodal_mouse_handler)
self.camera_style.AddObserver('MouseWheelForwardEvent',
self.bimodal_mouse_handler)
self.camera_style.AddObserver('MouseWheelBackwardEvent',
self.bimodal_mouse_handler)
self.camera_style.AddObserver('KeyPressEvent', lambda a, b: None)
self.actor_style = vtk.vtkInteractorStyleTrackballActor()
self.actor_style.AddObserver('LeftButtonPressEvent',
self.bimodal_mouse_handler)
self.actor_style.AddObserver('LeftButtonReleaseEvent',
self.bimodal_mouse_handler)
self.actor_style.AddObserver('MiddleButtonPressEvent',
self.bimodal_mouse_handler)
self.actor_style.AddObserver('MiddleButtonReleaseEvent',
self.bimodal_mouse_handler)
self.actor_style.AddObserver('RightButtonPressEvent',
self.bimodal_mouse_handler)
self.actor_style.AddObserver('RightButtonReleaseEvent',
self.bimodal_mouse_handler)
self.actor_style.AddObserver('MouseWheelForwardEvent',
self.bimodal_mouse_handler)
self.actor_style.AddObserver('MouseWheelBackwardEvent',
self.bimodal_mouse_handler)
self.actor_style.AddObserver('KeyPressEvent', lambda a, b: None)
self.frame.iren.SetInteractorStyle(self.camera_style)
self.frame.iren.AddObserver('KeyPressEvent', self.keypress_handler)
self.frame.ren.SetBackground(name_to_rgb_float(MAIN_WIN_BG_COLOR))
self.scene.frame = self.frame
axes = vtk.vtkAxes()
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(axes.GetOutputPort())
self.frame.axes_actor = vtk.vtkActor()
self.frame.axes_actor.SetMapper(mapper)
self.frame.axes_actor.GetProperty().SetLineWidth(1)
self.frame.axes_actor.SetVisibility(START_WITH_AXES)
self.frame.ren.AddActor(self.frame.axes_actor)
def __init__(self):
self.scene = Scene()
self.frame = MainWindow(self.scene)
self.camera_style = vtk.vtkInteractorStyleTrackballCamera()
self.camera_style.AddObserver('LeftButtonPressEvent',
self.bimodal_mouse_handler)
self.camera_style.AddObserver('LeftButtonReleaseEvent',
self.bimodal_mouse_handler)
self.camera_style.AddObserver('MiddleButtonPressEvent',
self.bimodal_mouse_handler)
self.camera_style.AddObserver('MiddleButtonReleaseEvent',
self.bimodal_mouse_handler)
self.camera_style.AddObserver('RightButtonPressEvent',
self.bimodal_mouse_handler)
self.camera_style.AddObserver('RightButtonReleaseEvent',
self.bimodal_mouse_handler)
self.camera_style.AddObserver('MouseWheelForwardEvent',
self.bimodal_mouse_handler)
self.camera_style.AddObserver('MouseWheelBackwardEvent',
self.bimodal_mouse_handler)
self.camera_style.AddObserver('KeyPressEvent', lambda a, b: None)
self.actor_style = vtk.vtkInteractorStyleTrackballActor()
self.actor_style.AddObserver('LeftButtonPressEvent',
self.bimodal_mouse_handler)
self.actor_style.AddObserver('LeftButtonReleaseEvent',
self.bimodal_mouse_handler)
self.actor_style.AddObserver('MiddleButtonPressEvent',
self.bimodal_mouse_handler)
self.actor_style.AddObserver('MiddleButtonReleaseEvent',
self.bimodal_mouse_handler)
self.actor_style.AddObserver('RightButtonPressEvent',
self.bimodal_mouse_handler)
self.actor_style.AddObserver('RightButtonReleaseEvent',
self.bimodal_mouse_handler)
self.actor_style.AddObserver('MouseWheelForwardEvent',
self.bimodal_mouse_handler)
self.actor_style.AddObserver('MouseWheelBackwardEvent',
self.bimodal_mouse_handler)
self.actor_style.AddObserver('KeyPressEvent', lambda a, b: None)
self.frame.iren.SetInteractorStyle(self.camera_style)
self.frame.iren.AddObserver('KeyPressEvent', self.keypress_handler)
self.frame.ren.SetBackground(name_to_rgb_float(MAIN_WIN_BG_COLOR))
self.scene.frame = self.frame
axes = vtk.vtkAxes()
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(axes.GetOutputPort())
self.frame.axes_actor = vtk.vtkActor()
self.frame.axes_actor.SetMapper(mapper)
self.frame.axes_actor.GetProperty().SetLineWidth(1)
self.frame.axes_actor.SetVisibility(START_WITH_AXES)
self.frame.ren.AddActor(self.frame.axes_actor)
def __init__(self, center=(0,0,0), color=(0,0,1) ):
""" create axes """
self.src = vtk.vtkAxes()
#self.src.SetCenter(center)
self.mapper = vtk.vtkPolyDataMapper()
self.mapper.SetInput(self.src.GetOutput())
self.SetMapper(self.mapper)
self.SetColor(color)
self.SetOrigin(center)
def __init__(self, center=(0, 0, 0), color=(0, 0, 1)):
""" create axes """
self.src = vtk.vtkAxes()
#self.src.SetCenter(center)
self.mapper = vtk.vtkPolyDataMapper()
self.mapper.SetInputConnection(self.src.GetOutputPort())
self.SetMapper(self.mapper)
self.SetColor(color)
self.SetOrigin(center)
def main():
colors = vtk.vtkNamedColors()
# Create the axes and the associated mapper and actor.
axes = vtk.vtkAxes()
axes.SetOrigin(0, 0, 0)
axesMapper = vtk.vtkPolyDataMapper()
axesMapper.SetInputConnection(axes.GetOutputPort())
axesActor = vtk.vtkActor()
axesActor.SetMapper(axesMapper)
# Create the 3D text and the associated mapper and follower (a type of actor). Position the text so it is displayed over the origin of the axes.
atext = vtk.vtkVectorText()
atext.SetText('Origin')
textMapper = vtk.vtkPolyDataMapper()
textMapper.SetInputConnection(atext.GetOutputPort())
textActor = vtk.vtkFollower()
textActor.SetMapper(textMapper)
textActor.SetScale(0.2, 0.2, 0.2)
textActor.AddPosition(0, -0.1, 0)
textActor.GetProperty().SetColor(colors.GetColor3d('Peacock'))
# Create the Renderer, RenderWindow, and RenderWindowInteractor.
renderer = vtk.vtkRenderer()
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer)
renderWindow.SetSize(640, 480)
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(renderWindow)
style = vtk.vtkInteractorStyleTrackballCamera()
interactor.SetInteractorStyle(style)
# Add the actors to the renderer.
renderer.AddActor(axesActor)
renderer.AddActor(textActor)
renderer.SetBackground(colors.GetColor3d('Silver'))
# Zoom in closer.
renderer.ResetCamera()
renderer.GetActiveCamera().Zoom(1.6)
renderer.SetBackground(colors.GetColor3d('Silver'))
# Reset the clipping range of the camera; set the camera of the follower; render.
renderer.ResetCameraClippingRange()
textActor.SetCamera(renderer.GetActiveCamera())
interactor.Initialize()
renderWindow.SetWindowName('TextOrigin')
renderWindow.Render()
interactor.Start()
def make_axesActor():
axes = vtk.vtkAxes()
axes.SetOrigin(0,0,0)
axes.SetScaleFactor(4)
axesTubes = vtk.vtkTubeFilter()
axesTubes.SetInput(axes.GetOutput())
axesTubes.SetRadius(axes.GetScaleFactor()/25.0)
axesTubes.SetNumberOfSides(6)
axesMapper = vtk.vtkPolyDataMapper()
axesMapper.SetInput(axesTubes.GetOutput())
axesActor = vtk.vtkActor()
axesActor.SetMapper(axesMapper)
#ren.AddActor(axesActor)
return (axesActor)
def showAxis(self):
if self.axis:
xmin, xmax, ymin, ymax, zmin, zmax = self.bounds[:]
axes=vtk.vtkAxes()
axes.SetOrigin(0.0,0.0,0.0)
axes.SetScaleFactor(0.1*max([xmax-xmin,ymax-ymin,zmax-zmin]))
axesTubes=vtk.vtkTubeFilter()
axesTubes.SetInputConnection(axes.GetOutputPort())
axesTubes.SetRadius(0.2)
axesTubes.SetNumberOfSides(6)
axesMapper=vtk.vtkPolyDataMapper()
axesMapper.SetInputConnection(axesTubes.GetOutputPort())
axesActor=vtk.vtkActor()
axesActor.SetMapper(axesMapper)
XText=vtk.vtkVectorText()
XText.SetText("X")
XTextMapper=vtk.vtkPolyDataMapper()
XTextMapper.SetInputConnection(XText.GetOutputPort())
XActor=vtk.vtkFollower()
XActor.SetMapper(XTextMapper)
XActor.SetScale(2.0, 2.0, 2.0)
XActor.SetPosition(1.11*xmax, ymin, zmin)
XActor.GetProperty().SetColor(0,0,0)
XActor.SetCamera(self.cam)
YText=vtk.vtkVectorText()
YText.SetText("Y")
YTextMapper=vtk.vtkPolyDataMapper()
YTextMapper.SetInputConnection(YText.GetOutputPort())
YActor=vtk.vtkFollower()
YActor.SetMapper(YTextMapper)
YActor.SetScale(2.0, 2.0, 2.0)
YActor.SetPosition(xmin, 1.11*ymax, zmin)
YActor.GetProperty().SetColor(0,0,0)
YActor.SetCamera(self.cam)
ZText=vtk.vtkVectorText()
ZText.SetText("Z")
ZTextMapper=vtk.vtkPolyDataMapper()
ZTextMapper.SetInputConnection(ZText.GetOutputPort())
ZActor=vtk.vtkFollower()
ZActor.SetMapper(ZTextMapper)
ZActor.SetScale(2.0, 2.0, 2.0)
ZActor.SetPosition(xmin, ymin, 1.11*zmax)
ZActor.GetProperty().SetColor(0,0,0)
ZActor.SetCamera(self.cam)
self.ren.AddActor(axesActor)
self.ren.AddActor(XActor)
self.ren.AddActor(YActor)
self.ren.AddActor(ZActor)
def setup(self):
self.axes = self.addPart(ObjectBase(vtk.vtkAxes()))
self.xcone = self.addPart(ObjectBase(vtk.vtkConeSource()))
self.xcone._actor.SetScale(0.1,0.05,0.05)
self.xcone._actor.AddPosition(1.0,0.0,0.0)
self.xcone._actor.GetProperty().SetColor(1.0,0.3,0.3)
self.ycone = self.addPart(ObjectBase(vtk.vtkConeSource()))
self.ycone._actor.SetScale(0.1,0.05,0.05)
self.ycone._actor.RotateZ(90.0)
self.ycone._actor.AddPosition(0.0,1.0,0.0)
self.ycone._actor.GetProperty().SetColor(1.0,1.0,0.0)
self.zcone = self.addPart(ObjectBase(vtk.vtkConeSource()))
self.zcone._actor.SetScale(0.1,0.05,0.05)
self.zcone._actor.RotateY(-90.0)
self.zcone._actor.AddPosition(0.0,0.0,1.0)
self.zcone._actor.GetProperty().SetColor(0.3,1.0,0.3)
self.balls = self.addPart(ObjectBase(vtk.vtkSphereSource()))
self.balls._actor.SetScale(0.05,0.05,0.05)
self.balls._actor.GetProperty().SetColor(0.3,0.3,1.0)
self.xtxt = ObjectBase(vtk.vtkVectorText(),
actorType=vtk.vtkFollower)
self.xtxt._source.SetText('X')
self.xtxt._actor.SetScale(0.1,0.1,0.1)
self.xtxt._actor.AddPosition(1.0,0.0,0.0)
self.xtxt._actor.GetProperty().SetColor(1.0,0.3,0.3)
self.addPart(self.xtxt)
self.ytxt = ObjectBase(vtk.vtkVectorText(),
actorType=vtk.vtkFollower)
self.ytxt._source.SetText('Y')
self.ytxt._actor.SetScale(0.1,0.1,0.1)
self.ytxt._actor.AddPosition(0.0,1.0,0.0)
self.ytxt._actor.GetProperty().SetColor(1.0,1.0,0.0)
self.addPart(self.ytxt)
self.ztxt = ObjectBase(vtk.vtkVectorText(),
actorType=vtk.vtkFollower)
self.ztxt._source.SetText('Z')
self.ztxt._actor.SetScale(0.1,0.1,0.1)
self.ztxt._actor.AddPosition(0.0,0.0,1.0)
self.ztxt._actor.GetProperty().SetColor(0.3,1.0,0.3)
self.addPart(self.ztxt)
self.ntxt = ObjectBase(vtk.vtkVectorText(),
actorType=vtk.vtkFollower)
self.ntxt._source.SetText('0')
self.ntxt._actor.SetScale(0.1,0.1,0.1)
self.ntxt._actor.GetProperty().SetColor(0.3,0.3,1.0)
self.addPart(self.ntxt)
def generateAxes(printer):
xmax, ymax, zmax = printer.getPrintingDimensions()
axes = vtk.vtkAxes()
axes.SetOrigin(-xmax/2, -ymax/2, 0)
axes.SetScaleFactor(20)
axesTubes = vtk.vtkTubeFilter()
axesTubes.SetInputConnection(axes.GetOutputPort())
axesTubes.SetRadius(2)
axesTubes.SetNumberOfSides(4)
axesMapper = vtk.vtkPolyDataMapper()
axesMapper.SetInputConnection(axesTubes.GetOutputPort())
axesActor = vtk.vtkActor()
axesActor.SetMapper(axesMapper)
XText = vtk.vtkVectorText()
XText.SetText('X')
XTextMapper = vtk.vtkPolyDataMapper()
XTextMapper.SetInputConnection(XText.GetOutputPort())
XActor = vtk.vtkFollower()
XActor.SetMapper(XTextMapper)
XActor.SetScale(5, 5, 5)
XActor.SetPosition(-xmax/2 + 20, -ymax/2 - 10, 5)
XActor.GetProperty().SetColor(1, 0, 0)
YText = vtk.vtkVectorText()
YText.SetText('Y')
YTextMapper = vtk.vtkPolyDataMapper()
YTextMapper.SetInputConnection(YText.GetOutputPort())
YActor = vtk.vtkFollower()
YActor.SetMapper(YTextMapper)
YActor.SetScale(5, 5, 5)
YActor.SetPosition(-xmax/2 - 5, -ymax/2 + 20, 5)
YActor.GetProperty().SetColor(1, 1, 0)
ZText = vtk.vtkVectorText()
ZText.SetText('Z')
ZTextMapper = vtk.vtkPolyDataMapper()
ZTextMapper.SetInputConnection(ZText.GetOutputPort())
ZActor = vtk.vtkFollower()
ZActor.SetMapper(ZTextMapper)
ZActor.SetScale(5, 5, 5)
ZActor.SetPosition(-xmax/2, -ymax/2, 25)
ZActor.GetProperty().SetColor(0, 1, 0)
return axesActor, XActor, YActor, ZActor
def getAxes(Origin, scale = 1):
axes = vtk.vtkAxes()
axes.SetOrigin(*Origin)
axes.SetScaleFactor(scale)
axesTubes = vtk.vtkTubeFilter()
axesTubes.SetInputConnection(axes.GetOutputPort())
axesTubes.SetRadius(0.01)
axesTubes.SetNumberOfSides(6)
axesMapper = vtk.vtkPolyDataMapper()
axesMapper.SetInputConnection(axesTubes.GetOutputPort())
axesActor = vtk.vtkActor()
axesActor.SetMapper(axesMapper)
XText = vtk.vtkVectorText()
XText.SetText("x")
XTextMapper = vtk.vtkPolyDataMapper()
XTextMapper.SetInputConnection(XText.GetOutputPort())
XActor = vtk.vtkFollower()
XActor.SetMapper(XTextMapper)
XActor.SetScale(.1, .1, .1)
XActor.SetPosition(1, Origin[1], Origin[2])
XActor.GetProperty().SetColor(0, 0, 0)
YText = vtk.vtkVectorText()
YText.SetText("y")
YTextMapper = vtk.vtkPolyDataMapper()
YTextMapper.SetInputConnection(YText.GetOutputPort())
YActor = vtk.vtkFollower()
YActor.SetMapper(YTextMapper)
YActor.SetScale(.1, .1, .1)
YActor.SetPosition(Origin[0], 1, Origin[2])
YActor.GetProperty().SetColor(0, 0, 0)
return axesActor, XActor, YActor
def getAxes(Origin, scale=1):
axes = vtk.vtkAxes()
axes.SetOrigin(*Origin)
axes.SetScaleFactor(scale)
axesTubes = vtk.vtkTubeFilter()
axesTubes.SetInputConnection(axes.GetOutputPort())
axesTubes.SetRadius(0.01)
axesTubes.SetNumberOfSides(6)
axesMapper = vtk.vtkPolyDataMapper()
axesMapper.SetInputConnection(axesTubes.GetOutputPort())
axesActor = vtk.vtkActor()
axesActor.SetMapper(axesMapper)
XText = vtk.vtkVectorText()
XText.SetText("x")
XTextMapper = vtk.vtkPolyDataMapper()
XTextMapper.SetInputConnection(XText.GetOutputPort())
XActor = vtk.vtkFollower()
XActor.SetMapper(XTextMapper)
XActor.SetScale(.1, .1, .1)
XActor.SetPosition(1, Origin[1], Origin[2])
XActor.GetProperty().SetColor(0, 0, 0)
YText = vtk.vtkVectorText()
YText.SetText("y")
YTextMapper = vtk.vtkPolyDataMapper()
YTextMapper.SetInputConnection(YText.GetOutputPort())
YActor = vtk.vtkFollower()
YActor.SetMapper(YTextMapper)
YActor.SetScale(.1, .1, .1)
YActor.SetPosition(Origin[0], 1, Origin[2])
YActor.GetProperty().SetColor(0, 0, 0)
return axesActor, XActor, YActor
def __init__ (self, master, renwin):
debug ("In Picker::__init__ ()")
self.renwin = renwin
self.master = master
self.pointpicker = vtk.vtkPointPicker()
self.cellpicker = vtk.vtkCellPicker()
self.worldpicker = vtk.vtkWorldPointPicker()
self.probe_point = vtk.vtkPoints()
self.probe_data = vtk.vtkPolyData()
self.pick_type_var = Tkinter.IntVar()
self.tol_var = Tkinter.DoubleVar ()
self.tol_var.set(self.pointpicker.GetTolerance())
self.root = None
self.txt = None
# Use a set of axis to show the picked point.
self.p_source = vtk.vtkAxes ()
self.p_mapper = vtk.vtkPolyDataMapper ()
self.p_actor = vtk.vtkActor ()
self._initialize ()
def __init__ (self, mod_m):
debug ("In TensorGlyph::__init__ ()")
Common.state.busy ()
Base.Objects.Module.__init__ (self, mod_m)
self.sphere = vtk.vtkSphereSource ()
self.axes = vtk.vtkAxes ()
self.glyphs = vtk.vtkTensorGlyph ()
# The actual glyph used is controlled using self.glyph_var
self.mapper = vtk.vtkPolyDataMapper ()
self.actor = vtk.vtkActor ()
self.data_out = self.mod_m.GetOutput ()
self.color_mode = 1 # 1 is scalar, -1 none
self._initialize ()
self._gui_init ()
self.do_color_mode()
self.renwin.Render ()
Common.state.idle ()
def __init__(self, **kwargs):
self.poly_data = vtk.vtkPolyData()
self.axes = vtk.vtkAxes()
self.axes.SetScaleFactor(0.01)
self.glyph = vtk.vtkTensorGlyph()
self.glyph.ExtractEigenvaluesOff()
self.glyph.ThreeGlyphsOff()
self.glyph.SymmetricOff()
self.glyph.SetSourceConnection(self.axes.GetOutputPort())
self.glyph.SetInput(self.poly_data)
self.mapper = vtk.vtkPolyDataMapper()
self.mapper.SetInputConnection(self.glyph.GetOutputPort())
self.actor = vtk.vtkActor()
self.actor.SetMapper(self.mapper)
self._process_kwargs(**kwargs)
def __init__(self, **kwargs):
self.poly_data = vtk.vtkPolyData()
self.axes = vtk.vtkAxes()
self.axes.SetScaleFactor(0.01)
self.glyph = vtk.vtkTensorGlyph()
self.glyph.ExtractEigenvaluesOff()
self.glyph.ThreeGlyphsOff()
self.glyph.SymmetricOff()
self.glyph.SetSourceConnection(self.axes.GetOutputPort())
self.glyph.SetInput(self.poly_data)
self.mapper = vtk.vtkPolyDataMapper()
self.mapper.SetInputConnection(self.glyph.GetOutputPort())
self.actor = vtk.vtkActor()
self.actor.SetMapper(self.mapper)
self._process_kwargs(**kwargs)
def show_scene(actors, show_unit_cube=False):
# Create the Renderer, RenderWindow, and RenderWindowInteractor.
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
axes = vtk.vtkAxes()
axes.SetOrigin(0, 0, 0)
axesMapper = vtk.vtkPolyDataMapper()
axesMapper.SetInputConnection(axes.GetOutputPort())
axesActor = vtk.vtkActor()
axesActor.SetMapper(axesMapper)
ren.AddActor(axesActor)
# Add the actors to the renderer.
print('Adding actors to renderer...')
for actor in actors:
ren.AddActor(actor)
# Set the camera of the followers
if actor.IsA('vtkFollower'):
actor.SetCamera(ren.GetActiveCamera())
if show_unit_cube:
ren.AddActor(get_actor_from_poly_data(get_cube_poly_data()))
# Zoom in closer.
# ren.ResetCamera()
# ren.GetActiveCamera().Zoom(1.6)
# Reset the clipping range of the camera; render.
# ren.ResetCameraClippingRange()
iren.Initialize()
renWin.Render()
print('Starting interactor...')
iren.Start()
def vtk_show(_renderer_1, _renderer_2, width=640 * 2, height=480):
# Multiple Viewports
xmins = [0.0, 0.5]
xmaxs = [0.5, 1.0]
ymins = [0.0, 0.0]
ymaxs = [1.0, 1.0]
render_window = vtk.vtkRenderWindow()
render_window.AddRenderer(_renderer_1)
render_window.AddRenderer(_renderer_2)
_renderer_1.ResetCamera()
_renderer_2.ResetCamera()
_renderer_1.SetViewport(xmins[0], ymins[0], xmaxs[0], ymaxs[0])
_renderer_2.SetViewport(xmins[1], ymins[1], xmaxs[1], ymaxs[1])
render_window.SetSize(width, height)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(render_window)
interactor_style = vtk.vtkInteractorStyleTrackballCamera()
iren.SetInteractorStyle(interactor_style)
_renderer_2.SetActiveCamera(_renderer_1.GetActiveCamera())
# Add a x-y-z coordinate to the original point
axes_coor = vtk.vtkAxes()
axes_coor.SetOrigin(0, 0, 0)
mapper_axes_coor = vtk.vtkPolyDataMapper()
mapper_axes_coor.SetInputConnection(axes_coor.GetOutputPort())
actor_axes_coor = vtk.vtkActor()
actor_axes_coor.SetMapper(mapper_axes_coor)
renderer_1.AddActor(actor_axes_coor)
renderer_2.AddActor(actor_axes_coor)
iren.Initialize()
iren.Start()
def showAxes(self):
axes = vtk.vtkAxes()
axes.SetOrigin(-1, -1, -1)
axes.SetScaleFactor(20)
axesMapper = vtk.vtkPolyDataMapper()
axesMapper.SetInputConnection(axes.GetOutputPort())
axesActor.SetMapper(axesMapper)
self.ren.AddActor(axesActor)
atext = vtk.vtkVectorText()
atext.SetText("X-Axis")
textMapper = vtk.vtkPolyDataMapper()
textMapper.SetInputConnection(atext.GetOutputPort())
axisTextActor.SetMapper(textMapper)
#axisTextActor.SetScale(0.2, 0.2, 0.2)
axisTextActor.SetScale(3, 3, 3)
#axisTextActor.RotateY(90)
axisTextActor.AddPosition(0, 0, 0)
self.graphicsFrameWidget.ren.AddActor(axisTextActor)
def showAxes(self):
axes = vtk.vtkAxes()
axes.SetOrigin(-1, -1, -1)
axes.SetScaleFactor(20)
axesMapper = vtk.vtkPolyDataMapper()
axesMapper.SetInputConnection(axes.GetOutputPort())
axesActor.SetMapper(axesMapper)
self.ren.AddActor(axesActor)
atext = vtk.vtkVectorText()
atext.SetText("X-Axis")
textMapper = vtk.vtkPolyDataMapper()
textMapper.SetInputConnection(atext.GetOutputPort())
axisTextActor.SetMapper(textMapper)
#axisTextActor.SetScale(0.2, 0.2, 0.2)
axisTextActor.SetScale(3, 3, 3)
#axisTextActor.RotateY(90)
axisTextActor.AddPosition(0, 0, 0)
self.graphicsFrameWidget.ren.AddActor(axisTextActor)
def SetUp(self):
'''
Set up cursor3D
'''
def OnClosing():
self.root.quit()
def ViewerDown(tkvw):
viewer = tkvw.GetImageViewer()
ViewerSetZSlice(tkvw, viewer.GetZSlice() - 1)
def ViewerUp(tkvw):
viewer = tkvw.GetImageViewer()
ViewerSetZSlice(tkvw, viewer.GetZSlice() + 1)
def ViewerSetZSlice(tkvw, z):
viewer = tkvw.GetImageViewer()
viewer.SetZSlice(z)
txt = 'slice: ' + str(z)
sliceLabel.configure(text=txt)
tkvw.Render()
def SetCursorFromViewer(event):
x = int(event.x)
y = int(event.y)
# We have to flip y axis because tk uses upper right origin.
self.root.update_idletasks()
height = int(self.tkvw.configure()['height'][4])
y = height - y
z = self.tkvw.GetImageViewer().GetZSlice()
SetCursor(x / IMAGE_MAG_X, y / IMAGE_MAG_Y, z / IMAGE_MAG_Z)
def SetCursor(x, y, z):
CURSOR_X = x
CURSOR_Y = y
CURSOR_Z = z
axes.SetOrigin(CURSOR_X, CURSOR_Y, CURSOR_Z)
imageCursor.SetCursorPosition(CURSOR_X * IMAGE_MAG_X,
CURSOR_Y * IMAGE_MAG_Y,
CURSOR_Z * IMAGE_MAG_Z)
self.viewer.Render()
self.tkrw.Render()
# Pipeline stuff.
reader = vtk.vtkSLCReader()
reader.SetFileName(VTK_DATA_ROOT + "/Data/neghip.slc")
# Cursor stuff
magnify = vtk.vtkImageMagnify()
magnify.SetInputConnection(reader.GetOutputPort())
magnify.SetMagnificationFactors(IMAGE_MAG_X, IMAGE_MAG_Y, IMAGE_MAG_Z)
imageCursor = vtk.vtkImageCursor3D()
imageCursor.SetInputConnection(magnify.GetOutputPort())
imageCursor.SetCursorPosition(CURSOR_X * IMAGE_MAG_X,
CURSOR_Y * IMAGE_MAG_Y,
CURSOR_Z * IMAGE_MAG_Z)
imageCursor.SetCursorValue(255)
imageCursor.SetCursorRadius(50 * IMAGE_MAG_X)
axes = vtk.vtkAxes()
axes.SymmetricOn()
axes.SetOrigin(CURSOR_X, CURSOR_Y, CURSOR_Z)
axes.SetScaleFactor(50.0)
axes_mapper = vtk.vtkPolyDataMapper()
axes_mapper.SetInputConnection(axes.GetOutputPort())
axesActor = vtk.vtkActor()
axesActor.SetMapper(axes_mapper)
axesActor.GetProperty().SetAmbient(0.5)
# Image viewer stuff.
viewer = vtk.vtkImageViewer()
viewer.SetInputConnection(imageCursor.GetOutputPort())
viewer.SetZSlice(CURSOR_Z * IMAGE_MAG_Z)
viewer.SetColorWindow(256)
viewer.SetColorLevel(128)
# Create transfer functions for opacity and color.
opacity_transfer_function = vtk.vtkPiecewiseFunction()
opacity_transfer_function.AddPoint(20, 0.0)
opacity_transfer_function.AddPoint(255, 0.2)
color_transfer_function = vtk.vtkColorTransferFunction()
color_transfer_function.AddRGBPoint(0, 0, 0, 0)
color_transfer_function.AddRGBPoint(64, 1, 0, 0)
color_transfer_function.AddRGBPoint(128, 0, 0, 1)
color_transfer_function.AddRGBPoint(192, 0, 1, 0)
color_transfer_function.AddRGBPoint(255, 0, .2, 0)
# Create properties, mappers, volume actors, and ray cast function.
volume_property = vtk.vtkVolumeProperty()
volume_property.SetColor(color_transfer_function)
# volume_property.SetColor(color_transfer_function[0],
# color_transfer_function[1],
# color_transfer_function[2])
volume_property.SetScalarOpacity(opacity_transfer_function)
volume_mapper = vtk.vtkFixedPointVolumeRayCastMapper()
volume_mapper.SetInputConnection(reader.GetOutputPort())
volume = vtk.vtkVolume()
volume.SetMapper(volume_mapper)
volume.SetProperty(volume_property)
# Create outline.
outline = vtk.vtkOutlineFilter()
outline.SetInputConnection(reader.GetOutputPort())
outline_mapper = vtk.vtkPolyDataMapper()
outline_mapper.SetInputConnection(outline.GetOutputPort())
outlineActor = vtk.vtkActor()
outlineActor.SetMapper(outline_mapper)
outlineActor.GetProperty().SetColor(1, 1, 1)
# Create the renderer.
ren = vtk.vtkRenderer()
ren.AddActor(axesActor)
ren.AddVolume(volume)
ren.SetBackground(0.1, 0.2, 0.4)
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
renWin.SetSize(256, 256)
# Create the GUI: two renderer widgets and a quit button.
self.root = tkinter.Tk()
self.root.title("cursor3D")
# Define what to do when the user explicitly closes a window.
self.root.protocol("WM_DELETE_WINDOW", OnClosing)
# Help label, frame and quit button
helpLabel = tkinter.Label(
self.root,
text=
"MiddleMouse (or shift-LeftMouse) in image viewer to place cursor")
displayFrame = tkinter.Frame(self.root)
quitButton = tkinter.Button(self.root, text="Quit", command=OnClosing)
# Pack the GUI.
helpLabel.pack()
displayFrame.pack(fill=BOTH, expand=TRUE)
quitButton.pack(fill=X)
# Create the viewer widget.
viewerFrame = tkinter.Frame(displayFrame)
viewerFrame.pack(padx=3,
pady=3,
side=LEFT,
anchor=N,
fill=BOTH,
expand=FALSE)
self.tkvw = vtkTkImageViewerWidget(viewerFrame,
iv=viewer,
width=264,
height=264)
viewerControls = tkinter.Frame(viewerFrame)
viewerControls.pack(side=BOTTOM, anchor=S, fill=BOTH, expand=TRUE)
self.tkvw.pack(side=TOP, anchor=N, fill=BOTH, expand=FALSE)
downButton = tkinter.Button(viewerControls,
text="Down",
command=[ViewerDown, self.tkvw])
upButton = tkinter.Button(viewerControls,
text="Up",
command=[ViewerUp, self.tkvw])
sliceLabel = tkinter.Label(viewerControls,
text="slice: " +
str(CURSOR_Z * IMAGE_MAG_Z))
downButton.pack(side=LEFT, expand=TRUE, fill=BOTH)
upButton.pack(side=LEFT, expand=TRUE, fill=BOTH)
sliceLabel.pack(side=LEFT, expand=TRUE, fill=BOTH)
# Create the render widget
renderFrame = tkinter.Frame(displayFrame)
renderFrame.pack(padx=3,
pady=3,
side=LEFT,
anchor=N,
fill=BOTH,
expand=TRUE)
self.tkrw = vtkTkRenderWidget(renderFrame,
rw=renWin,
width=264,
height=264)
self.tkrw.pack(side=TOP, anchor=N, fill=BOTH, expand=TRUE)
# Bindings
self.tkvw.BindTkImageViewer()
self.tkrw.BindTkRenderWidget()
# Lets add an extra binding of the middle button in the image viewer
# to set the cursor location.
self.tkvw.bind('<Button-2>', SetCursorFromViewer)
self.tkvw.bind('<Shift-Button-1>', SetCursorFromViewer)
# Associate the functions with the buttons and label.
#
downButton.config(command=partial(ViewerDown, self.tkvw))
upButton.config(command=partial(ViewerUp, self.tkvw))
import vtk
def computeBounds( renderer, normalized_display_position, size ):
upperRight = vtk.vtkCoordinate()
upperRight.SetCoordinateSystemToNormalizedDisplay()
upperRight.SetValue( normalized_display_position[0], normalized_display_position[1] )
bds = [0.0]*6
bds[0] = upperRight.GetComputedDisplayValue(renderer)[0] - size[0]
bds[1] = bds[0] + size[0]
bds[2] = upperRight.GetComputedDisplayValue(renderer)[1] - size[1]
bds[3] = bds[2] + size[1]
return bds
# Create the axes and the associated mapper and actor.
axes = vtk.vtkAxes()
axes.SetOrigin(0, 0, 0)
axesMapper = vtk.vtkPolyDataMapper()
axesMapper.SetInputConnection(axes.GetOutputPort())
axesActor = vtk.vtkActor()
axesActor.SetMapper(axesMapper)
# Create the 3D text and the associated mapper and follower (a type of
# actor). Position the text so it is displayed over the origin of the
# axes.
atext = vtk.vtkVectorText()
atext.SetText("Origin")
textMapper = vtk.vtkPolyDataMapper()
textMapper.SetInputConnection(atext.GetOutputPort())
textActor = vtk.vtkFollower()
textActor.SetMapper(textMapper)
def main():
colors = vtk.vtkNamedColors()
colors.SetColor("PopColor", [230, 230, 230, 255])
# fileName = get_program_parameters()
keys = ['NUMBER_POINTS', 'MONTHLY_PAYMENT', 'INTEREST_RATE', 'LOAN_AMOUNT', 'TIME_LATE']
# Read in the data and make an unstructured data set.
dataSet = make_dataset()
# pts[:,0] = pts[:,0] ** 3
# npData.SetPoints(npData.GetPoints())
# # Construct the pipeline for the original population.
# popSplatter = vtk.vtkGaussianSplatter()
# popSplatter.SetInputData(dataSet)
# popSplatter.SetSampleDimensions(100, 100, 100)
# popSplatter.SetRadius(0.1)
# popSplatter.ScalarWarpingOff()
# popSurface = vtk.vtkContourFilter()
# popSurface.SetInputConnection(popSplatter.GetOutputPort())
# popSurface.SetValue(0, 0.01)
# popMapper = vtk.vtkPolyDataMapper()
# popMapper.SetInputConnection(popSurface.GetOutputPort())
# popMapper.ScalarVisibilityOff()
# popActor = vtk.vtkActor()
# popActor.SetMapper(popMapper)
# popActor.GetProperty().SetOpacity(0.3)
# popActor.GetProperty().SetColor(colors.GetColor3d("PopColor"))
# Construct the pipeline for the delinquent population.
lateSplatter = vtk.vtkGaussianSplatter()
lateSplatter.SetInputData(dataSet)
lateSplatter.SetSampleDimensions(150, 150, 150)
lateSplatter.SetRadius(0.1)
lateSplatter.SetScaleFactor(.001)
lateSurface = vtk.vtkContourFilter()
lateSurface.SetInputConnection(lateSplatter.GetOutputPort())
lateSurface.SetValue(0, 0.01)
lateMapper = vtk.vtkPolyDataMapper()
lateMapper.SetInputConnection(lateSurface.GetOutputPort())
lateMapper.ScalarVisibilityOff()
lateActor = vtk.vtkActor()
lateActor.SetMapper(lateMapper)
lateActor.GetProperty().SetColor(colors.GetColor3d("Red"))
# Create axes.
lateSplatter.Update()
bounds = lateSplatter.GetOutput().GetBounds()
axes = vtk.vtkAxes()
axes.SetOrigin(bounds[0], bounds[2], bounds[4])
axes.SetScaleFactor(lateSplatter.GetOutput().GetLength() / 5)
axesTubes = vtk.vtkTubeFilter()
axesTubes.SetInputConnection(axes.GetOutputPort())
axesTubes.SetRadius(axes.GetScaleFactor() / 25.0)
axesTubes.SetNumberOfSides(6)
axesMapper = vtk.vtkPolyDataMapper()
axesMapper.SetInputConnection(axesTubes.GetOutputPort())
axesActor = vtk.vtkActor()
axesActor.SetMapper(axesMapper)
# Visualize.
renderer = vtk.vtkRenderer()
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer)
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(renderWindow)
renderer.AddActor(axesActor)
renderer.AddActor(lateActor)
renderer.SetBackground(colors.GetColor3d("powder_blue"))
# Enable user interface interactor
renderWindow.Render()
def update(self):
pts = dataSet.GetPoints()
pts.SetPoint(0, [0,0,np.sin(time.time())])
pts.Modified()
interactor.Render()
# Sign up to receive TimerEvent
cb = vtkTimerCallback()
cb.update = update
interactor.AddObserver('TimerEvent', cb.execute)
timerId = interactor.CreateRepeatingTimer(10);
interactor.Start()
def main():
reader = vtk.vtkPolyDataReader()
reader.SetFileName('data/plane.vtk')
prop = vtk.vtkProperty()
prop.SetAmbient(0.05)
prop.SetDiffuse(0.9)
prop.SetSpecular(0.5)
prop.SetSpecularPower(70.0)
prop.SetAmbientColor(0.1, 0.1, 0.1)
prop.SetDiffuseColor(0.6, 0.6, 0.6)
prop.SetSpecularColor(1.0, 1.0, 1.0)
normals = vtk.vtkPolyDataNormals()
normals.SetInputConnection(reader.GetOutputPort())
normals.SetFeatureAngle(60.0)
normals.ConsistencyOn()
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(normals.GetOutputPort())
planeActor = vtk.vtkActor()
planeActor.SetMapper(mapper)
planeActor.SetProperty(prop)
planeActor.SetOrientation(45.0, 67.5, 45.0)
axes = vtk.vtkAxes()
axes.SetOrigin(0.0, 0.0, 0.0)
axes.SymmetricOn()
axes.SetScaleFactor(10.0)
axisProp = vtk.vtkProperty()
axisProp.SetAmbient(0.05)
axisProp.SetDiffuse(0.95)
axisProp.SetSpecular(0.0)
axisProp.SetAmbientColor(0.05, 0.05, 0.05)
axisProp.SetDiffuseColor(0.05, 0.05, 0.05)
aMap = vtk.vtkPolyDataMapper()
aMap.SetInputConnection(axes.GetOutputPort())
aMap.ScalarVisibilityOn()
aAct = vtk.vtkActor()
aAct.SetMapper(aMap)
aAct.SetProperty(axisProp)
# Text für die Achsen
xText = vtk.vtkVectorText()
xText.SetText('x')
yText = vtk.vtkVectorText()
yText.SetText('y')
zText = vtk.vtkVectorText()
zText.SetText('z')
xMap = vtk.vtkPolyDataMapper()
xMap.SetInputConnection(xText.GetOutputPort())
yMap = vtk.vtkPolyDataMapper()
yMap.SetInputConnection(yText.GetOutputPort())
zMap = vtk.vtkPolyDataMapper()
zMap.SetInputConnection(zText.GetOutputPort())
xActor = vtk.vtkFollower()
xActor.SetMapper(xMap)
xActor.SetScale(0.6, 0.6, 0.6)
xActor.AddPosition(9.0, 0.5, 0.0)
xActor.SetProperty(axisProp)
yActor = vtk.vtkFollower()
yActor.SetMapper(yMap)
yActor.SetScale(0.6, 0.6, 0.6)
yActor.AddPosition(-1.0, 9.0, 0.0)
yActor.SetProperty(axisProp)
zActor = vtk.vtkFollower()
zActor.SetMapper(zMap)
zActor.SetScale(0.6, 0.6, 0.6)
zActor.AddPosition(-1.0, 0.0, 9.0)
zActor.SetOrientation(-45.0, 0.0, 0.0)
zActor.SetProperty(axisProp)
ren = vtk.vtkRenderer()
ren.SetBackground(1.0, 1.0, 1.0)
ren.AddActor(planeActor)
ren.AddActor(aAct)
ren.AddActor(xActor)
ren.AddActor(yActor)
ren.AddActor(zActor)
ren.ResetCameraClippingRange()
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(ren)
renderWindow.SetSize(800, 600)
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
renderWindowInteractor.SetRenderWindow(renderWindow)
renderWindow.Render()
renderWindowInteractor.Start()
def SetUp(self):
"""
Set up cursor3D
"""
def OnClosing():
self.root.quit()
def ViewerDown(tkvw):
viewer = tkvw.GetImageViewer()
ViewerSetZSlice(tkvw, viewer.GetZSlice() - 1)
def ViewerUp(tkvw):
viewer = tkvw.GetImageViewer()
ViewerSetZSlice(tkvw, viewer.GetZSlice() + 1)
def ViewerSetZSlice(tkvw, z):
viewer = tkvw.GetImageViewer()
viewer.SetZSlice(z)
txt = "slice: " + str(z)
sliceLabel.configure(text=txt)
tkvw.Render()
def SetCursorFromViewer(event):
x = int(event.x)
y = int(event.y)
# We have to flip y axis because tk uses upper right origin.
self.root.update_idletasks()
height = int(self.tkvw.configure()["height"][4])
y = height - y
z = self.tkvw.GetImageViewer().GetZSlice()
SetCursor(x / IMAGE_MAG_X, y / IMAGE_MAG_Y, z / IMAGE_MAG_Z)
def SetCursor(x, y, z):
CURSOR_X = x
CURSOR_Y = y
CURSOR_Z = z
axes.SetOrigin(CURSOR_X, CURSOR_Y, CURSOR_Z)
imageCursor.SetCursorPosition(CURSOR_X * IMAGE_MAG_X, CURSOR_Y * IMAGE_MAG_Y, CURSOR_Z * IMAGE_MAG_Z)
self.viewer.Render()
self.tkrw.Render()
# Pipeline stuff.
reader = vtk.vtkSLCReader()
reader.SetFileName(VTK_DATA_ROOT + "/Data/neghip.slc")
# Cursor stuff
magnify = vtk.vtkImageMagnify()
magnify.SetInputConnection(reader.GetOutputPort())
magnify.SetMagnificationFactors(IMAGE_MAG_X, IMAGE_MAG_Y, IMAGE_MAG_Z)
imageCursor = vtk.vtkImageCursor3D()
imageCursor.SetInputConnection(magnify.GetOutputPort())
imageCursor.SetCursorPosition(CURSOR_X * IMAGE_MAG_X, CURSOR_Y * IMAGE_MAG_Y, CURSOR_Z * IMAGE_MAG_Z)
imageCursor.SetCursorValue(255)
imageCursor.SetCursorRadius(50 * IMAGE_MAG_X)
axes = vtk.vtkAxes()
axes.SymmetricOn()
axes.SetOrigin(CURSOR_X, CURSOR_Y, CURSOR_Z)
axes.SetScaleFactor(50.0)
axes_mapper = vtk.vtkPolyDataMapper()
axes_mapper.SetInputConnection(axes.GetOutputPort())
axesActor = vtk.vtkActor()
axesActor.SetMapper(axes_mapper)
axesActor.GetProperty().SetAmbient(0.5)
# Image viewer stuff.
viewer = vtk.vtkImageViewer()
viewer.SetInputConnection(imageCursor.GetOutputPort())
viewer.SetZSlice(CURSOR_Z * IMAGE_MAG_Z)
viewer.SetColorWindow(256)
viewer.SetColorLevel(128)
# Create transfer functions for opacity and color.
opacity_transfer_function = vtk.vtkPiecewiseFunction()
opacity_transfer_function.AddPoint(20, 0.0)
opacity_transfer_function.AddPoint(255, 0.2)
color_transfer_function = vtk.vtkColorTransferFunction()
color_transfer_function.AddRGBPoint(0, 0, 0, 0)
color_transfer_function.AddRGBPoint(64, 1, 0, 0)
color_transfer_function.AddRGBPoint(128, 0, 0, 1)
color_transfer_function.AddRGBPoint(192, 0, 1, 0)
color_transfer_function.AddRGBPoint(255, 0, 0.2, 0)
# Create properties, mappers, volume actors, and ray cast function.
volume_property = vtk.vtkVolumeProperty()
volume_property.SetColor(color_transfer_function)
# volume_property.SetColor(color_transfer_function[0],
# color_transfer_function[1],
# color_transfer_function[2])
volume_property.SetScalarOpacity(opacity_transfer_function)
volume_mapper = vtk.vtkFixedPointVolumeRayCastMapper()
volume_mapper.SetInputConnection(reader.GetOutputPort())
volume = vtk.vtkVolume()
volume.SetMapper(volume_mapper)
volume.SetProperty(volume_property)
# Create outline.
outline = vtk.vtkOutlineFilter()
outline.SetInputConnection(reader.GetOutputPort())
outline_mapper = vtk.vtkPolyDataMapper()
outline_mapper.SetInputConnection(outline.GetOutputPort())
outlineActor = vtk.vtkActor()
outlineActor.SetMapper(outline_mapper)
outlineActor.GetProperty().SetColor(1, 1, 1)
# Create the renderer.
ren = vtk.vtkRenderer()
ren.AddActor(axesActor)
ren.AddVolume(volume)
ren.SetBackground(0.1, 0.2, 0.4)
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
renWin.SetSize(256, 256)
# Create the GUI: two renderer widgets and a quit button.
self.root = tkinter.Tk()
self.root.title("cursor3D")
# Define what to do when the user explicitly closes a window.
self.root.protocol("WM_DELETE_WINDOW", OnClosing)
# Help label, frame and quit button
helpLabel = tkinter.Label(self.root, text="MiddleMouse (or shift-LeftMouse) in image viewer to place cursor")
displayFrame = tkinter.Frame(self.root)
quitButton = tkinter.Button(self.root, text="Quit", command=OnClosing)
# Pack the GUI.
helpLabel.pack()
displayFrame.pack(fill=BOTH, expand=TRUE)
quitButton.pack(fill=X)
# Create the viewer widget.
viewerFrame = tkinter.Frame(displayFrame)
viewerFrame.pack(padx=3, pady=3, side=LEFT, anchor=N, fill=BOTH, expand=FALSE)
self.tkvw = vtkTkImageViewerWidget(viewerFrame, iv=viewer, width=264, height=264)
viewerControls = tkinter.Frame(viewerFrame)
viewerControls.pack(side=BOTTOM, anchor=S, fill=BOTH, expand=TRUE)
self.tkvw.pack(side=TOP, anchor=N, fill=BOTH, expand=FALSE)
downButton = tkinter.Button(viewerControls, text="Down", command=[ViewerDown, self.tkvw])
upButton = tkinter.Button(viewerControls, text="Up", command=[ViewerUp, self.tkvw])
sliceLabel = tkinter.Label(viewerControls, text="slice: " + str(CURSOR_Z * IMAGE_MAG_Z))
downButton.pack(side=LEFT, expand=TRUE, fill=BOTH)
upButton.pack(side=LEFT, expand=TRUE, fill=BOTH)
sliceLabel.pack(side=LEFT, expand=TRUE, fill=BOTH)
# Create the render widget
renderFrame = tkinter.Frame(displayFrame)
renderFrame.pack(padx=3, pady=3, side=LEFT, anchor=N, fill=BOTH, expand=TRUE)
self.tkrw = vtkTkRenderWidget(renderFrame, rw=renWin, width=264, height=264)
self.tkrw.pack(side=TOP, anchor=N, fill=BOTH, expand=TRUE)
# Bindings
self.tkvw.BindTkImageViewer()
self.tkrw.BindTkRenderWidget()
# Lets add an extra binding of the middle button in the image viewer
# to set the cursor location.
self.tkvw.bind("<Button-2>", SetCursorFromViewer)
self.tkvw.bind("<Shift-Button-1>", SetCursorFromViewer)
# Associate the functions with the buttons and label.
#
downButton.config(command=partial(ViewerDown, self.tkvw))
upButton.config(command=partial(ViewerUp, self.tkvw))
def show_axes(ren):
# Create the axes and the associated mapper and actor.
axes = vtk.vtkAxes()
axes.SetOrigin(0, 0, 0)
# length - hardwired for our images, which are usually 80 on a side
# (80/2 = 40)
AxisLength = 35.0
TextScale = 1.5
TextR = 0.4
TextG = 0.4
TextB = 0.8
axes.SetScaleFactor(AxisLength)
axesMapper = vtk.vtkPolyDataMapper()
axesMapper.SetInputConnection(axes.GetOutputPort())
axesActor = vtk.vtkActor()
axesActor.SetMapper(axesMapper)
# Label the axes
XText = vtk.vtkVectorText()
XText.SetText("X")
XTextMapper = vtk.vtkPolyDataMapper()
XTextMapper.SetInputConnection(XText.GetOutputPort())
XActor = vtk.vtkFollower()
XActor.SetMapper(XTextMapper)
XActor.SetScale(TextScale, TextScale, TextScale)
XActor.SetPosition(AxisLength, 0.0, 0.0)
XActor.GetProperty().SetColor(TextR, TextG, TextB)
YText = vtk.vtkVectorText()
YText.SetText("Y")
YTextMapper = vtk.vtkPolyDataMapper()
YTextMapper.SetInputConnection(YText.GetOutputPort())
YActor = vtk.vtkFollower()
YActor.SetMapper(YTextMapper)
YActor.SetScale(TextScale, TextScale, TextScale)
YActor.SetPosition(0.0, AxisLength, 0.0)
YActor.GetProperty().SetColor(TextR, TextG, TextB)
ZText = vtk.vtkVectorText()
ZText.SetText("Z")
ZTextMapper = vtk.vtkPolyDataMapper()
ZTextMapper.SetInputConnection(ZText.GetOutputPort())
ZActor = vtk.vtkFollower()
ZActor.SetMapper(ZTextMapper)
ZActor.SetScale(TextScale, TextScale, TextScale)
ZActor.SetPosition(0.0, 0.0, AxisLength)
ZActor.GetProperty().SetColor(TextR, TextG, TextB)
ren.AddActor(axesActor)
ren.AddActor(XActor)
ren.AddActor(YActor)
ren.AddActor(ZActor)
output = reader.GetOutput()
scalar_range = output.GetScalarRange()
# Create the mapper that corresponds the objects of the vtk file
# into graphics elements
mapper = vtkDataSetMapper()
mapper.SetInputConnection(reader.GetOutputPort())
mapper.SetScalarRange(scalar_range)
# Create the Actor
actor = vtkActor()
actor.SetMapper(mapper)
actor.SetScale(100.0, 100.0, 100.0)
# Create the axes and the associated mapper and actor.
axes = vtk.vtkAxes()
axes.SetOrigin(0, 0, 0)
axesMapper = vtk.vtkPolyDataMapper()
axesMapper.SetInputConnection(axes.GetOutputPort())
axesActor = vtk.vtkActor()
axesActor.SetMapper(axesMapper)
# Create the 3D text and the associated mapper and follower (a type of
# actor). Position the text so it is displayed over the origin of the
# axes.
atext = vtk.vtkVectorText()
atext.SetText("Origin")
textMapper = vtk.vtkPolyDataMapper()
textMapper.SetInputConnection(atext.GetOutputPort())
textActor = vtk.vtkFollower()
textActor.SetMapper(textMapper)
#
ren1 = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren1)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# create pipeline
#
cow = vtk.vtkBYUReader()
cow.SetGeometryFileName("" + str(VTK_DATA_ROOT) + "/Data/Viewpoint/cow.g")
cowMapper = vtk.vtkPolyDataMapper()
cowMapper.SetInputConnection(cow.GetOutputPort())
cowActor = vtk.vtkActor()
cowActor.SetMapper(cowMapper)
cowActor.GetProperty().SetDiffuseColor(0.9608, 0.8706, 0.7020)
cowAxesSource = vtk.vtkAxes()
cowAxesSource.SetScaleFactor(10)
cowAxesSource.SetOrigin(0, 0, 0)
cowAxesMapper = vtk.vtkPolyDataMapper()
cowAxesMapper.SetInputConnection(cowAxesSource.GetOutputPort())
cowAxes = vtk.vtkActor()
cowAxes.SetMapper(cowAxesMapper)
ren1.AddActor(cowAxes)
cowAxes.VisibilityOff()
# Add the actors to the renderer, set the background and size
#
ren1.AddActor(cowActor)
ren1.SetBackground(0.1, 0.2, 0.4)
renWin.SetSize(320, 240)
ren1.ResetCamera()
ren1.GetActiveCamera().Azimuth(0)
def testFinancialField(self):
"""
Demonstrate the use and manipulation of fields and use of
vtkProgrammableDataObjectSource. This creates fields the hard way
(as compared to reading a vtk field file), but shows you how to
interface to your own raw data.
The image should be the same as financialField.tcl
"""
xAxis = "INTEREST_RATE"
yAxis = "MONTHLY_PAYMENT"
zAxis = "MONTHLY_INCOME"
scalar = "TIME_LATE"
# Parse an ascii file and manually create a field. Then construct a
# dataset from the field.
dos = vtk.vtkProgrammableDataObjectSource()
def parseFile():
f = open(VTK_DATA_ROOT + "/Data/financial.txt", "r")
line = f.readline().split()
# From the size calculate the number of lines.
numPts = int(line[1])
numLines = (numPts - 1) / 8 + 1
# create the data object
field = vtk.vtkFieldData()
field.AllocateArrays(4)
# read TIME_LATE - dependent variable
while True:
line = f.readline().split()
if len(line) > 0:
break;
timeLate = vtk.vtkFloatArray()
timeLate.SetName(line[0])
for i in range(0, numLines):
line = f.readline().split()
for j in line:
timeLate.InsertNextValue(float(j))
field.AddArray(timeLate)
# MONTHLY_PAYMENT - independent variable
while True:
line = f.readline().split()
if len(line) > 0:
break;
monthlyPayment = vtk.vtkFloatArray()
monthlyPayment.SetName(line[0])
for i in range(0, numLines):
line = f.readline().split()
for j in line:
monthlyPayment.InsertNextValue(float(j))
field.AddArray(monthlyPayment)
# UNPAID_PRINCIPLE - skip
while True:
line = f.readline().split()
if len(line) > 0:
break;
for i in range(0, numLines):
line = f.readline()
# LOAN_AMOUNT - skip
while True:
line = f.readline().split()
if len(line) > 0:
break;
for i in range(0, numLines):
line = f.readline()
# INTEREST_RATE - independent variable
while True:
line = f.readline().split()
if len(line) > 0:
break;
interestRate = vtk.vtkFloatArray()
interestRate.SetName(line[0])
for i in range(0, numLines):
line = f.readline().split()
for j in line:
interestRate.InsertNextValue(float(j))
field.AddArray(interestRate)
# MONTHLY_INCOME - independent variable
while True:
line = f.readline().split()
if len(line) > 0:
break;
monthlyIncome = vtk.vtkFloatArray()
monthlyIncome.SetName(line[0])
for i in range(0, numLines):
line = f.readline().split()
for j in line:
monthlyIncome.InsertNextValue(float(j))
field.AddArray(monthlyIncome)
dos.GetOutput().SetFieldData(field)
dos.SetExecuteMethod(parseFile)
# Create the dataset
do2ds = vtk.vtkDataObjectToDataSetFilter()
do2ds.SetInputConnection(dos.GetOutputPort())
do2ds.SetDataSetTypeToPolyData()
#format: component#, arrayname, arraycomp, minArrayId, maxArrayId, normalize
do2ds.DefaultNormalizeOn()
do2ds.SetPointComponent(0, xAxis, 0)
do2ds.SetPointComponent(1, yAxis, 0)
do2ds.SetPointComponent(2, zAxis, 0)
do2ds.Update()
rf = vtk.vtkRearrangeFields()
rf.SetInputConnection(do2ds.GetOutputPort())
rf.AddOperation("MOVE", scalar, "DATA_OBJECT", "POINT_DATA")
rf.RemoveOperation("MOVE", scalar, "DATA_OBJECT", "POINT_DATA")
rf.AddOperation("MOVE", scalar, "DATA_OBJECT", "POINT_DATA")
rf.RemoveAllOperations()
rf.AddOperation("MOVE", scalar, "DATA_OBJECT", "POINT_DATA")
rf.Update()
max = rf.GetOutput().GetPointData().GetArray(scalar).GetRange(0)[1]
calc = vtk.vtkArrayCalculator()
calc.SetInputConnection(rf.GetOutputPort())
calc.SetAttributeModeToUsePointData()
calc.SetFunction("s / %f" % max)
calc.AddScalarVariable("s", scalar, 0)
calc.SetResultArrayName("resArray")
aa = vtk.vtkAssignAttribute()
aa.SetInputConnection(calc.GetOutputPort())
aa.Assign("resArray", "SCALARS", "POINT_DATA")
aa.Update()
rf2 = vtk.vtkRearrangeFields()
rf2.SetInputConnection(aa.GetOutputPort())
rf2.AddOperation("COPY", "SCALARS", "POINT_DATA", "DATA_OBJECT")
# construct pipeline for original population
popSplatter = vtk.vtkGaussianSplatter()
popSplatter.SetInputConnection(rf2.GetOutputPort())
popSplatter.SetSampleDimensions(50, 50, 50)
popSplatter.SetRadius(0.05)
popSplatter.ScalarWarpingOff()
popSurface = vtk.vtkContourFilter()
popSurface.SetInputConnection(popSplatter.GetOutputPort())
popSurface.SetValue(0, 0.01)
popMapper = vtk.vtkPolyDataMapper()
popMapper.SetInputConnection(popSurface.GetOutputPort())
popMapper.ScalarVisibilityOff()
popMapper.ImmediateModeRenderingOn()
popActor = vtk.vtkActor()
popActor.SetMapper(popMapper)
popActor.GetProperty().SetOpacity(0.3)
popActor.GetProperty().SetColor(.9, .9, .9)
# construct pipeline for delinquent population
lateSplatter = vtk.vtkGaussianSplatter()
lateSplatter.SetInputConnection(aa.GetOutputPort())
lateSplatter.SetSampleDimensions(50, 50, 50)
lateSplatter.SetRadius(0.05)
lateSplatter.SetScaleFactor(0.05)
lateSurface = vtk.vtkContourFilter()
lateSurface.SetInputConnection(lateSplatter.GetOutputPort())
lateSurface.SetValue(0, 0.01)
lateMapper = vtk.vtkPolyDataMapper()
lateMapper.SetInputConnection(lateSurface.GetOutputPort())
lateMapper.ScalarVisibilityOff()
lateActor = vtk.vtkActor()
lateActor.SetMapper(lateMapper)
lateActor.GetProperty().SetColor(1.0, 0.0, 0.0)
# create axes
popSplatter.Update()
bounds = popSplatter.GetOutput().GetBounds()
axes = vtk.vtkAxes()
axes.SetOrigin(bounds[0], bounds[2], bounds[4])
axes.SetScaleFactor(popSplatter.GetOutput().GetLength() / 5.0)
axesTubes = vtk.vtkTubeFilter()
axesTubes.SetInputConnection(axes.GetOutputPort())
axesTubes.SetRadius(axes.GetScaleFactor() / 25.0)
axesTubes.SetNumberOfSides(6)
axesMapper = vtk.vtkPolyDataMapper()
axesMapper.SetInputConnection(axesTubes.GetOutputPort())
axesActor = vtk.vtkActor()
axesActor.SetMapper(axesMapper)
# label the axes
XText = vtk.vtkVectorText()
XText.SetText(xAxis)
XTextMapper = vtk.vtkPolyDataMapper()
XTextMapper.SetInputConnection(XText.GetOutputPort())
XActor = vtk.vtkFollower()
XActor.SetMapper(XTextMapper)
XActor.SetScale(0.02, .02, .02)
XActor.SetPosition(0.35, -0.05, -0.05)
XActor.GetProperty().SetColor(0, 0, 0)
YText = vtk.vtkVectorText()
YText.SetText(yAxis)
YTextMapper = vtk.vtkPolyDataMapper()
YTextMapper.SetInputConnection(YText.GetOutputPort())
YActor = vtk.vtkFollower()
YActor.SetMapper(YTextMapper)
YActor.SetScale(0.02, .02, .02)
YActor.SetPosition(-0.05, 0.35, -0.05)
YActor.GetProperty().SetColor(0, 0, 0)
ZText = vtk.vtkVectorText()
ZText.SetText(zAxis)
ZTextMapper = vtk.vtkPolyDataMapper()
ZTextMapper.SetInputConnection(ZText.GetOutputPort())
ZActor = vtk.vtkFollower()
ZActor.SetMapper(ZTextMapper)
ZActor.SetScale(0.02, .02, .02)
ZActor.SetPosition(-0.05, -0.05, 0.35)
ZActor.GetProperty().SetColor(0, 0, 0)
# Graphics stuff
#
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
renWin.SetWindowName("vtk(-, Field.Data")
renWin.SetSize(300, 300)
# Add the actors to the renderer, set the background and size
#
ren.AddActor(axesActor)
ren.AddActor(lateActor)
ren.AddActor(XActor)
ren.AddActor(YActor)
ren.AddActor(ZActor)
ren.AddActor(popActor) #it's last because its translucent)
ren.SetBackground(1, 1, 1)
camera = vtk.vtkCamera()
camera.SetClippingRange(.274, 13.72)
camera.SetFocalPoint(0.433816, 0.333131, 0.449)
camera.SetPosition(-1.96987, 1.15145, 1.49053)
camera.SetViewUp(0.378927, 0.911821, 0.158107)
ren.SetActiveCamera(camera)
XActor.SetCamera(camera)
YActor.SetCamera(camera)
ZActor.SetCamera(camera)
# render and interact with data
iRen = vtk.vtkRenderWindowInteractor()
iRen.SetRenderWindow(renWin);
renWin.Render()
img_file = "financialField3.png"
vtk.test.Testing.compareImage(iRen.GetRenderWindow(), vtk.test.Testing.getAbsImagePath(img_file), threshold=25)
vtk.test.Testing.interact()
def testFinancialField(self):
size = 3187 #maximum number possible
#set size 100 #maximum number possible
xAxis = "INTEREST_RATE"
yAxis = "MONTHLY_PAYMENT"
zAxis = "MONTHLY_INCOME"
scalar = "TIME_LATE"
# extract data from field as a polydata (just points), then extract scalars
fdr = vtk.vtkDataObjectReader()
fdr.SetFileName(VTK_DATA_ROOT + "/Data/financial.vtk")
do2ds = vtk.vtkDataObjectToDataSetFilter()
do2ds.SetInputConnection(fdr.GetOutputPort())
do2ds.SetDataSetTypeToPolyData()
#format: component#, arrayname, arraycomp, minArrayId, maxArrayId, normalize
do2ds.DefaultNormalizeOn()
do2ds.SetPointComponent(0, xAxis, 0)
do2ds.SetPointComponent(1, yAxis, 0, 0, size, 1)
do2ds.SetPointComponent(2, zAxis, 0)
do2ds.Update()
fd2ad = vtk.vtkFieldDataToAttributeDataFilter()
fd2ad.SetInputConnection(do2ds.GetOutputPort())
fd2ad.SetInputFieldToDataObjectField()
fd2ad.SetOutputAttributeDataToPointData()
fd2ad.DefaultNormalizeOn()
fd2ad.SetScalarComponent(0, scalar, 0)
# construct pipeline for original population
popSplatter = vtk.vtkGaussianSplatter()
popSplatter.SetInputConnection(fd2ad.GetOutputPort())
popSplatter.SetSampleDimensions(50, 50, 50)
popSplatter.SetRadius(0.05)
popSplatter.ScalarWarpingOff()
popSurface = vtk.vtkMarchingContourFilter()
popSurface.SetInputConnection(popSplatter.GetOutputPort())
popSurface.SetValue(0, 0.01)
popMapper = vtk.vtkPolyDataMapper()
popMapper.SetInputConnection(popSurface.GetOutputPort())
popMapper.ScalarVisibilityOff()
popActor = vtk.vtkActor()
popActor.SetMapper(popMapper)
popActor.GetProperty().SetOpacity(0.3)
popActor.GetProperty().SetColor(.9, .9, .9)
# construct pipeline for delinquent population
lateSplatter = vtk.vtkGaussianSplatter()
lateSplatter.SetInputConnection(fd2ad.GetOutputPort())
lateSplatter.SetSampleDimensions(50, 50, 50)
lateSplatter.SetRadius(0.05)
lateSplatter.SetScaleFactor(0.05)
lateSurface = vtk.vtkMarchingContourFilter()
lateSurface.SetInputConnection(lateSplatter.GetOutputPort())
lateSurface.SetValue(0, 0.01)
lateMapper = vtk.vtkPolyDataMapper()
lateMapper.SetInputConnection(lateSurface.GetOutputPort())
lateMapper.ScalarVisibilityOff()
lateActor = vtk.vtkActor()
lateActor.SetMapper(lateMapper)
lateActor.GetProperty().SetColor(1.0, 0.0, 0.0)
# create axes
popSplatter.Update()
bounds = popSplatter.GetOutput().GetBounds()
axes = vtk.vtkAxes()
axes.SetOrigin(bounds[0], bounds[2], bounds[4])
axes.SetScaleFactor(popSplatter.GetOutput().GetLength() / 5.0)
axesTubes = vtk.vtkTubeFilter()
axesTubes.SetInputConnection(axes.GetOutputPort())
axesTubes.SetRadius(axes.GetScaleFactor() / 25.0)
axesTubes.SetNumberOfSides(6)
axesMapper = vtk.vtkPolyDataMapper()
axesMapper.SetInputConnection(axesTubes.GetOutputPort())
axesActor = vtk.vtkActor()
axesActor.SetMapper(axesMapper)
# label the axes
XText = vtk.vtkVectorText()
XText.SetText(xAxis)
XTextMapper = vtk.vtkPolyDataMapper()
XTextMapper.SetInputConnection(XText.GetOutputPort())
XActor = vtk.vtkFollower()
XActor.SetMapper(XTextMapper)
XActor.SetScale(0.02, .02, .02)
XActor.SetPosition(0.35, -0.05, -0.05)
XActor.GetProperty().SetColor(0, 0, 0)
YText = vtk.vtkVectorText()
YText.SetText(yAxis)
YTextMapper = vtk.vtkPolyDataMapper()
YTextMapper.SetInputConnection(YText.GetOutputPort())
YActor = vtk.vtkFollower()
YActor.SetMapper(YTextMapper)
YActor.SetScale(0.02, .02, .02)
YActor.SetPosition(-0.05, 0.35, -0.05)
YActor.GetProperty().SetColor(0, 0, 0)
ZText = vtk.vtkVectorText()
ZText.SetText(zAxis)
ZTextMapper = vtk.vtkPolyDataMapper()
ZTextMapper.SetInputConnection(ZText.GetOutputPort())
ZActor = vtk.vtkFollower()
ZActor.SetMapper(ZTextMapper)
ZActor.SetScale(0.02, .02, .02)
ZActor.SetPosition(-0.05, -0.05, 0.35)
ZActor.GetProperty().SetColor(0, 0, 0)
# Graphics stuff
#
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
renWin.SetWindowName("vtk - Field.Data")
# Add the actors to the renderer, set the background and size
#
ren.AddActor(axesActor)
ren.AddActor(lateActor)
ren.AddActor(XActor)
ren.AddActor(YActor)
ren.AddActor(ZActor)
ren.AddActor(popActor) #it's last because its translucent)
ren.SetBackground(1, 1, 1)
renWin.SetSize(400, 400)
camera = vtk.vtkCamera()
camera.SetClippingRange(.274, 13.72)
camera.SetFocalPoint(0.433816, 0.333131, 0.449)
camera.SetPosition(-1.96987, 1.15145, 1.49053)
camera.SetViewUp(0.378927, 0.911821, 0.158107)
ren.SetActiveCamera(camera)
XActor.SetCamera(camera)
YActor.SetCamera(camera)
ZActor.SetCamera(camera)
# render and interact with data
iRen = vtk.vtkRenderWindowInteractor()
iRen.SetRenderWindow(renWin);
renWin.Render()
img_file = "financialField.png"
vtk.test.Testing.compareImage(iRen.GetRenderWindow(), vtk.test.Testing.getAbsImagePath(img_file), threshold=25)
vtk.test.Testing.interact()
def rotate(file_name, figure, actor_color):
''''
This is where we do the rotations.
'''
# Create renderer stuff
#
colors = vtk.vtkNamedColors()
# Set the background color.
colors.SetColor('BkgColor', [26, 51, 102, 255])
# colors.SetColor('BkgColor', [60, 93, 144, 255])
ren1 = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren1)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# Create the pipeline.
#
polyData = ReadPolyData(file_name)
modelMapper = vtk.vtkPolyDataMapper()
modelMapper.SetInputData(polyData)
modelActor = vtk.vtkActor()
modelActor.SetMapper(modelMapper)
modelActor.GetProperty().SetDiffuseColor(colors.GetColor3d(actor_color))
if actor_color != 'Wheat':
modelActor.GetProperty().SetSpecular(0.6)
modelActor.GetProperty().SetSpecularPower(30)
modelAxesSource = vtk.vtkAxes()
modelAxesSource.SetScaleFactor(10)
modelAxesSource.SetOrigin(0, 0, 0)
modelAxesMapper = vtk.vtkPolyDataMapper()
modelAxesMapper.SetInputConnection(modelAxesSource.GetOutputPort())
modelAxes = vtk.vtkActor()
modelAxes.SetMapper(modelAxesMapper)
ren1.AddActor(modelAxes)
modelAxes.VisibilityOff()
# Add the actors to the renderer, set the background and size.
#
ren1.AddActor(modelActor)
if actor_color == 'Wheat':
ren1.SetBackground(colors.GetColor3d('BkgColor'))
else:
ren1.SetBackground(colors.GetColor3d('Silver'))
renWin.SetSize(640, 480)
renWin.SetWindowName('Rotations')
ren1.ResetCamera()
ren1.GetActiveCamera().Azimuth(0)
ren1.GetActiveCamera().SetClippingRange(0.1, 1000.0)
modelAxes.VisibilityOn()
renWin.Render()
renWin.Render()
if figure == 1:
RotateX(renWin, modelActor)
elif figure == 2:
RotateY(renWin, modelActor)
elif figure == 3:
RotateZ(renWin, modelActor)
else:
RotateXY(renWin, modelActor)
renWin.EraseOff()
iren.Start()
def testFinancialField(self):
size = 3187 #maximum number possible
#set size 100 #maximum number possible
xAxis = "INTEREST_RATE"
yAxis = "MONTHLY_PAYMENT"
zAxis = "MONTHLY_INCOME"
scalar = "TIME_LATE"
# extract data from field as a polydata (just points), then extract scalars
fdr = vtk.vtkDataObjectReader()
fdr.SetFileName(VTK_DATA_ROOT + "/Data/financial.vtk")
do2ds = vtk.vtkDataObjectToDataSetFilter()
do2ds.SetInputConnection(fdr.GetOutputPort())
do2ds.SetDataSetTypeToPolyData()
#format: component#, arrayname, arraycomp, minArrayId, maxArrayId, normalize
do2ds.DefaultNormalizeOn()
do2ds.SetPointComponent(0, xAxis, 0)
do2ds.SetPointComponent(1, yAxis, 0, 0, size, 1)
do2ds.SetPointComponent(2, zAxis, 0)
do2ds.Update()
if fdr.GetOutput().GetFieldData().GetAbstractArray(
"Some Text").GetValue(0) != "Test me":
raise RuntimeError, 'Could not properly read string array "Some Text"'
fd2ad = vtk.vtkFieldDataToAttributeDataFilter()
fd2ad.SetInputConnection(do2ds.GetOutputPort())
fd2ad.SetInputFieldToDataObjectField()
fd2ad.SetOutputAttributeDataToPointData()
fd2ad.DefaultNormalizeOn()
fd2ad.SetScalarComponent(0, scalar, 0)
# construct pipeline for original population
popSplatter = vtk.vtkGaussianSplatter()
popSplatter.SetInputConnection(fd2ad.GetOutputPort())
popSplatter.SetSampleDimensions(50, 50, 50)
popSplatter.SetRadius(0.05)
popSplatter.ScalarWarpingOff()
popSurface = vtk.vtkMarchingContourFilter()
popSurface.SetInputConnection(popSplatter.GetOutputPort())
popSurface.SetValue(0, 0.01)
popMapper = vtk.vtkPolyDataMapper()
popMapper.SetInputConnection(popSurface.GetOutputPort())
popMapper.ScalarVisibilityOff()
popActor = vtk.vtkActor()
popActor.SetMapper(popMapper)
popActor.GetProperty().SetOpacity(0.3)
popActor.GetProperty().SetColor(.9, .9, .9)
# construct pipeline for delinquent population
lateSplatter = vtk.vtkGaussianSplatter()
lateSplatter.SetInputConnection(fd2ad.GetOutputPort())
lateSplatter.SetSampleDimensions(50, 50, 50)
lateSplatter.SetRadius(0.05)
lateSplatter.SetScaleFactor(0.05)
lateSurface = vtk.vtkMarchingContourFilter()
lateSurface.SetInputConnection(lateSplatter.GetOutputPort())
lateSurface.SetValue(0, 0.01)
lateMapper = vtk.vtkPolyDataMapper()
lateMapper.SetInputConnection(lateSurface.GetOutputPort())
lateMapper.ScalarVisibilityOff()
lateActor = vtk.vtkActor()
lateActor.SetMapper(lateMapper)
lateActor.GetProperty().SetColor(1.0, 0.0, 0.0)
# create axes
popSplatter.Update()
bounds = popSplatter.GetOutput().GetBounds()
axes = vtk.vtkAxes()
axes.SetOrigin(bounds[0], bounds[2], bounds[4])
axes.SetScaleFactor(popSplatter.GetOutput().GetLength() / 5.0)
axesTubes = vtk.vtkTubeFilter()
axesTubes.SetInputConnection(axes.GetOutputPort())
axesTubes.SetRadius(axes.GetScaleFactor() / 25.0)
axesTubes.SetNumberOfSides(6)
axesMapper = vtk.vtkPolyDataMapper()
axesMapper.SetInputConnection(axesTubes.GetOutputPort())
axesActor = vtk.vtkActor()
axesActor.SetMapper(axesMapper)
# label the axes
XText = vtk.vtkVectorText()
XText.SetText(xAxis)
XTextMapper = vtk.vtkPolyDataMapper()
XTextMapper.SetInputConnection(XText.GetOutputPort())
XActor = vtk.vtkFollower()
XActor.SetMapper(XTextMapper)
XActor.SetScale(0.02, .02, .02)
XActor.SetPosition(0.35, -0.05, -0.05)
XActor.GetProperty().SetColor(0, 0, 0)
YText = vtk.vtkVectorText()
YText.SetText(yAxis)
YTextMapper = vtk.vtkPolyDataMapper()
YTextMapper.SetInputConnection(YText.GetOutputPort())
YActor = vtk.vtkFollower()
YActor.SetMapper(YTextMapper)
YActor.SetScale(0.02, .02, .02)
YActor.SetPosition(-0.05, 0.35, -0.05)
YActor.GetProperty().SetColor(0, 0, 0)
ZText = vtk.vtkVectorText()
ZText.SetText(zAxis)
ZTextMapper = vtk.vtkPolyDataMapper()
ZTextMapper.SetInputConnection(ZText.GetOutputPort())
ZActor = vtk.vtkFollower()
ZActor.SetMapper(ZTextMapper)
ZActor.SetScale(0.02, .02, .02)
ZActor.SetPosition(-0.05, -0.05, 0.35)
ZActor.GetProperty().SetColor(0, 0, 0)
# Graphics stuff
#
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
renWin.SetWindowName("vtk - Field.Data")
# Add the actors to the renderer, set the background and size
#
ren.AddActor(axesActor)
ren.AddActor(lateActor)
ren.AddActor(XActor)
ren.AddActor(YActor)
ren.AddActor(ZActor)
ren.AddActor(popActor) #it's last because its translucent)
ren.SetBackground(1, 1, 1)
renWin.SetSize(400, 400)
camera = vtk.vtkCamera()
camera.SetClippingRange(.274, 13.72)
camera.SetFocalPoint(0.433816, 0.333131, 0.449)
camera.SetPosition(-1.96987, 1.15145, 1.49053)
camera.SetViewUp(0.378927, 0.911821, 0.158107)
ren.SetActiveCamera(camera)
XActor.SetCamera(camera)
YActor.SetCamera(camera)
ZActor.SetCamera(camera)
# render and interact with data
iRen = vtk.vtkRenderWindowInteractor()
iRen.SetRenderWindow(renWin)
renWin.Render()
img_file = "financialField.png"
vtk.test.Testing.compareImage(
iRen.GetRenderWindow(),
vtk.test.Testing.getAbsImagePath(img_file),
threshold=25)
vtk.test.Testing.interact()
def main():
"""
To match the illustrations in VTKTextbook.pdf, use BkgColor as the background and
Wheat as the cow colour.
Also comment out the lines:
modelActor->GetProperty()->SetSpecular(.6);
modelActor->GetProperty()->SetSpecularPower(30);
and use cow.g as the inout data.
"""
file_name, figure = get_program_parameters()
# Create renderer stuff
#
colors = vtk.vtkNamedColors()
# Set the background color. Match those in VTKTextbook.pdf.
bkg = map(lambda x: x / 256.0, [60, 93, 144])
colors.SetColor("BkgColor", *bkg)
ren1 = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren1)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# create pipeline
#
polyData = ReadPolyData(file_name)
modelMapper = vtk.vtkPolyDataMapper()
modelMapper.SetInputData(polyData)
modelActor = vtk.vtkActor()
modelActor.SetMapper(modelMapper)
# modelActor.GetProperty().SetDiffuseColor(colors.GetColor3d("Wheat"))
modelActor.GetProperty().SetDiffuseColor(colors.GetColor3d("Crimson"))
modelActor.GetProperty().SetSpecular(.6)
modelActor.GetProperty().SetSpecularPower(30)
modelAxesSource = vtk.vtkAxes()
modelAxesSource.SetScaleFactor(10)
modelAxesSource.SetOrigin(0, 0, 0)
modelAxesMapper = vtk.vtkPolyDataMapper()
modelAxesMapper.SetInputConnection(modelAxesSource.GetOutputPort())
modelAxes = vtk.vtkActor()
modelAxes.SetMapper(modelAxesMapper)
ren1.AddActor(modelAxes)
modelAxes.VisibilityOff()
# Add the actors to the renderer, set the background and size
#
ren1.AddActor(modelActor)
# ren1.SetBackground(colors.GetColor3d("BkgColor"))
ren1.SetBackground(colors.GetColor3d("Silver"))
renWin.SetSize(640, 480)
ren1.ResetCamera()
ren1.GetActiveCamera().Azimuth(0)
ren1.GetActiveCamera().SetClippingRange(.1, 1000.0)
modelAxes.VisibilityOn()
renWin.Render()
renWin.Render()
if figure == 1:
RotateX(renWin, modelActor)
elif figure == 2:
RotateY(renWin, modelActor)
elif figure == 3:
RotateZ(renWin, modelActor)
else:
RotateXY(renWin, modelActor)
renWin.EraseOff()
iren.Start()
def main():
colors = vtk.vtkNamedColors()
# Create the RenderWindow, Renderer and interactive renderer.
#
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# Generate the tensors.
ptLoad = vtk.vtkPointLoad()
ptLoad.SetLoadValue(100.0)
ptLoad.SetSampleDimensions(6, 6, 6)
ptLoad.ComputeEffectiveStressOn()
ptLoad.SetModelBounds(-10, 10, -10, 10, -10, 10)
# Extract a plane of data.
plane = vtk.vtkImageDataGeometryFilter()
plane.SetInputConnection(ptLoad.GetOutputPort())
plane.SetExtent(2, 2, 0, 99, 0, 99)
# Generate the tensor axes.
axes = vtk.vtkAxes()
axes.SetScaleFactor(0.5)
tubeAxes = vtk.vtkTubeFilter()
tubeAxes.SetInputConnection(axes.GetOutputPort())
tubeAxes.SetRadius(0.1)
tubeAxes.SetNumberOfSides(6)
tensorAxes = vtk.vtkTensorGlyph()
tensorAxes.SetInputConnection(ptLoad.GetOutputPort())
tensorAxes.SetSourceConnection(axes.GetOutputPort())
tensorAxes.SetScaleFactor(10)
tensorAxes.ClampScalingOn()
# Map contour
lut = vtk.vtkLookupTable()
MakeLogLUT(lut)
# lut.SetHueRange(.6667, 0.0)
tensorAxesMapper = vtk.vtkPolyDataMapper()
tensorAxesMapper.SetInputConnection(tensorAxes.GetOutputPort())
tensorAxesMapper.SetLookupTable(lut)
plane.Update() # force update for scalar range
# This is deprecated from vtk 8.1 onwards.
# tensorAxesMapper.ImmediateModeRenderingOn()
tensorAxesMapper.SetScalarRange(plane.GetOutput().GetScalarRange())
tensorActor = vtk.vtkActor()
tensorActor.SetMapper(tensorAxesMapper)
# Create an outline around the data.
#
outline = vtk.vtkOutlineFilter()
outline.SetInputConnection(ptLoad.GetOutputPort())
outlineMapper = vtk.vtkPolyDataMapper()
outlineMapper.SetInputConnection(outline.GetOutputPort())
outlineActor = vtk.vtkActor()
outlineActor.SetMapper(outlineMapper)
outlineActor.GetProperty().SetColor(colors.GetColor3d("Black"))
#
# Create a cone whose apex indicates the application of load.
#
coneSrc = vtk.vtkConeSource()
coneSrc.SetRadius(.5)
coneSrc.SetHeight(2)
coneMap = vtk.vtkPolyDataMapper()
coneMap.SetInputConnection(coneSrc.GetOutputPort())
coneActor = vtk.vtkActor()
coneActor.SetMapper(coneMap)
coneActor.SetPosition(0, 0, 11)
coneActor.RotateY(90)
coneActor.GetProperty().SetColor(colors.GetColor3d("BurlyWood"))
camera = vtk.vtkCamera()
camera.SetFocalPoint(0.113766, -1.13665, -1.01919)
camera.SetPosition(-29.4886, -63.1488, 26.5807)
camera.SetViewAngle(24.4617)
camera.SetViewUp(0.17138, 0.331163, 0.927879)
camera.SetClippingRange(1, 100)
ren.AddActor(tensorActor)
ren.AddActor(outlineActor)
ren.AddActor(coneActor)
ren.SetBackground(colors.GetColor3d("WhiteSmoke"))
ren.SetActiveCamera(camera)
renWin.SetSize(512, 512)
iren.Initialize()
renWin.Render()
iren.Start()
def render_polydata(self, input_polydata, scalar_range=None,
tube=True, opacity=1, depth_peeling=False,
scalar_bar=False, scalar_bar_title=None,
axes=False, data_mode="Cell", colormap='jet', verbose=True):
# re-do this every time because the user may close the window
# and re-use the object
#self.build_vtk()
if verbose:
print("<render.py> Rendering vtkPolyData.")
# actor and mapper
mapper = vtk.vtkPolyDataMapper()
actor = vtk.vtkActor()
actor.SetMapper(mapper)
# assign actor to the renderer
self.renderer.AddActor(actor)
# lookup table for everything
#self.lut = vtk.vtkLookupTable()
if colormap == 'hot':
lut = get_hot_lookup_table()
else:
lut = get_jet_lookup_table()
mapper.UseLookupTableScalarRangeOn()
mapper.SetLookupTable(lut)
# see if we have RGB data, if so the scalar bar is meaningless
self.render_RGB = False
if input_polydata.GetCellData().GetScalars():
if input_polydata.GetCellData().GetScalars().GetNumberOfComponents() == 3:
self.render_RGB = True
self.renderer.RemoveActor2D(self.scalarbar)
if verbose:
print("<render.py> RGB: ", self.render_RGB)
if data_mode == "Cell":
mapper.SetScalarModeToUseCellData()
elif data_mode == "Point":
mapper.SetScalarModeToUsePointData()
#if input_polydata.GetNumberOfLines() > 0:
# mapper.SetScalarModeToUseCellData()
if tube & (input_polydata.GetNumberOfLines() > 0):
# make a tube filter
tube_filter = vtk.vtkTubeFilter()
tube_filter.SetNumberOfSides(self.number_of_tube_sides)
if (vtk.vtkVersion().GetVTKMajorVersion() > 5.0):
tube_filter.SetInputData(input_polydata)
else:
tube_filter.SetInput(input_polydata)
if (vtk.vtkVersion().GetVTKMajorVersion() >= 6.0):
mapper.SetInputConnection(tube_filter.GetOutputPort())
else:
mapper.SetInput(tube_filter.GetOutput())
else:
if (vtk.vtkVersion().GetVTKMajorVersion() >= 6.0):
mapper.SetInputData(input_polydata)
else:
mapper.SetInput(input_polydata)
if scalar_range is None:
# check polydata scalar range.
range_low, range_high = input_polydata.GetScalarRange()
# if these numbers are between -1 and 1 assume laterality
# data, so make sure colorbar is centered at 0 for clearer
# interpretation
if (range_low >= -1.0 ) and (range_high <= 1.0):
range_final = max(abs(range_low), abs(range_high))
lut.SetRange([-range_final, range_final])
else:
# otherwise just use the range directly
lut.SetRange([range_low, range_high])
else:
lut.SetRange(scalar_range)
if opacity is not 1:
actor.GetProperty().SetOpacity(opacity)
if depth_peeling is not False:
# 1. Use a render window with alpha bits (as initial value is 0 (false)):
self.render_window.SetAlphaBitPlanes(1)
# 2. Force to not pick a framebuffer with a multisample buffer
# (as initial value is 8):
self.render_window.SetMultiSamples(0)
# 3. Choose to use depth peeling (if supported) (initial value is 0 (false)):
self.renderer.SetUseDepthPeeling(1)
# 4. Set depth peeling parameters
# - Set the maximum number of rendering passes (initial value is 4):
#renderer->SetMaximumNumberOfPeels(maxNoOfPeels);
#// - Set the occlusion ratio (initial value is 0.0, exact image):
#renderer->SetOcclusionRatio(occlusionRatio);
if scalar_bar:
self.scalarbar.SetLookupTable(lut)
self.renderer.AddActor2D(self.scalarbar)
if scalar_bar_title is not None:
self.scalarbar.SetTitle(scalar_bar_title)
else:
self.renderer.RemoveActor2D(self.scalarbar)
# Create the axes and the associated mapper and actor.
self.axes = vtk.vtkAxes()
self.axes.SetOrigin(0, 0, 0)
self.axes.SetScaleFactor(100)
self.axes.SymmetricOn()
self.axes_mapper = vtk.vtkPolyDataMapper()
if (vtk.vtkVersion().GetVTKMajorVersion() >= 6.0):
self.axes_mapper.SetInputConnection(self.axes.GetOutputPort())
else:
self.axes_mapper.SetInput(self.axes.GetOutput())
self.axes_actor = vtk.vtkActor()
self.axes_actor.SetMapper(self.axes_mapper)
self.axes_mapper.SetLookupTable(lut)
if axes:
self.renderer.AddActor(self.axes_actor)
else:
self.renderer.RemoveActor(self.axes_actor)
try:
self.render_window.Render()
except Exception:
print("<render.py> ERROR. Failed to render. Check display settings.")
def main():
ifn = get_program_parameters()
colors = vtk.vtkNamedColors()
reader = vtk.vtkDataObjectReader()
reader.SetFileName(ifn)
size = 3187 # maximum number possible
xAxis = "INTEREST_RATE"
yAxis = "MONTHLY_PAYMENT"
zAxis = "MONTHLY_INCOME"
scalar = "TIME_LATE"
# Extract data from field as a polydata (just points), then extract scalars.
do2ds = vtk.vtkDataObjectToDataSetFilter()
do2ds.SetInputConnection(reader.GetOutputPort())
do2ds.SetDataSetTypeToPolyData()
# format: component#, arrayname, arraycomp, minArrayId, maxArrayId, normalize
do2ds.DefaultNormalizeOn()
do2ds.SetPointComponent(0, xAxis, 0)
do2ds.SetPointComponent(1, yAxis, 0, 0, size, 1)
do2ds.SetPointComponent(2, zAxis, 0)
do2ds.Update()
fd2ad = vtk.vtkFieldDataToAttributeDataFilter()
fd2ad.SetInputConnection(do2ds.GetOutputPort())
fd2ad.SetInputFieldToDataObjectField()
fd2ad.SetOutputAttributeDataToPointData()
fd2ad.DefaultNormalizeOn()
fd2ad.SetScalarComponent(0, scalar, 0)
# Construct the pipeline for the original population.
popSplatter = vtk.vtkGaussianSplatter()
popSplatter.SetInputConnection(fd2ad.GetOutputPort())
popSplatter.SetSampleDimensions(150, 150, 150)
popSplatter.SetRadius(0.05)
popSplatter.ScalarWarpingOff()
popSurface = vtk.vtkMarchingContourFilter()
popSurface.SetInputConnection(popSplatter.GetOutputPort())
popSurface.SetValue(0, 0.01)
popMapper = vtk.vtkPolyDataMapper()
popMapper.SetInputConnection(popSurface.GetOutputPort())
popMapper.ScalarVisibilityOff()
popActor = vtk.vtkActor()
popActor.SetMapper(popMapper)
popActor.GetProperty().SetOpacity(0.3)
popActor.GetProperty().SetColor(colors.GetColor3d("Gold"))
# Construct the pipeline for the delinquent population.
lateSplatter = vtk.vtkGaussianSplatter()
lateSplatter.SetInputConnection(fd2ad.GetOutputPort())
lateSplatter.SetSampleDimensions(150, 150, 150)
lateSplatter.SetRadius(0.05)
lateSplatter.SetScaleFactor(0.05)
lateSurface = vtk.vtkMarchingContourFilter()
lateSurface.SetInputConnection(lateSplatter.GetOutputPort())
lateSurface.SetValue(0, 0.01)
lateMapper = vtk.vtkPolyDataMapper()
lateMapper.SetInputConnection(lateSurface.GetOutputPort())
lateMapper.ScalarVisibilityOff()
lateActor = vtk.vtkActor()
lateActor.SetMapper(lateMapper)
lateActor.GetProperty().SetColor(colors.GetColor3d("Tomato"))
# Create the axes.
popSplatter.Update()
bounds = popSplatter.GetOutput().GetBounds()
axes = vtk.vtkAxes()
axes.SetOrigin(bounds[0], bounds[2], bounds[4])
axes.SetScaleFactor(popSplatter.GetOutput().GetLength() / 5.0)
axesTubes = vtk.vtkTubeFilter()
axesTubes.SetInputConnection(axes.GetOutputPort())
axesTubes.SetRadius(axes.GetScaleFactor() / 25.0)
axesTubes.SetNumberOfSides(6)
axesMapper = vtk.vtkPolyDataMapper()
axesMapper.SetInputConnection(axesTubes.GetOutputPort())
axesActor = vtk.vtkActor()
axesActor.SetMapper(axesMapper)
# Label the axes.
XText = vtk.vtkVectorText()
XText.SetText(xAxis)
XTextMapper = vtk.vtkPolyDataMapper()
XTextMapper.SetInputConnection(XText.GetOutputPort())
XActor = vtk.vtkFollower()
XActor.SetMapper(XTextMapper)
XActor.SetScale(0.02, .02, .02)
XActor.SetPosition(0.35, -0.05, -0.05)
XActor.GetProperty().SetColor(0, 0, 0)
YText = vtk.vtkVectorText()
YText.SetText(yAxis)
YTextMapper = vtk.vtkPolyDataMapper()
YTextMapper.SetInputConnection(YText.GetOutputPort())
YActor = vtk.vtkFollower()
YActor.SetMapper(YTextMapper)
YActor.SetScale(0.02, .02, .02)
YActor.SetPosition(-0.05, 0.35, -0.05)
YActor.GetProperty().SetColor(0, 0, 0)
ZText = vtk.vtkVectorText()
ZText.SetText(zAxis)
ZTextMapper = vtk.vtkPolyDataMapper()
ZTextMapper.SetInputConnection(ZText.GetOutputPort())
ZActor = vtk.vtkFollower()
ZActor.SetMapper(ZTextMapper)
ZActor.SetScale(0.02, .02, .02)
ZActor.SetPosition(-0.05, -0.05, 0.35)
ZActor.GetProperty().SetColor(0, 0, 0)
# Graphics stuff.
renderer = vtk.vtkRenderer()
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer)
renderWindow.SetWindowName("vtk - Field.Data")
# Add the actors to the renderer, set the background and size.
renderer.AddActor(axesActor)
renderer.AddActor(lateActor)
renderer.AddActor(XActor)
renderer.AddActor(YActor)
renderer.AddActor(ZActor)
renderer.AddActor(popActor)
renderer.SetBackground(colors.GetColor3d("SlateGray"))
renderWindow.SetSize(650, 480)
camera = vtk.vtkCamera()
camera.SetClippingRange(.274, 13.72)
camera.SetFocalPoint(0.433816, 0.333131, 0.449)
camera.SetPosition(-1.96987, 1.15145, 1.49053)
camera.SetViewUp(0.378927, 0.911821, 0.158107)
renderer.SetActiveCamera(camera)
XActor.SetCamera(camera)
YActor.SetCamera(camera)
ZActor.SetCamera(camera)
# Render and interact with the data.
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(renderWindow)
renderWindow.Render()
interactor.Start()
def testFinancialField(self):
"""
Demonstrate the use and manipulation of fields and use of
vtkProgrammableDataObjectSource. This creates fields the hard way
(as compared to reading a vtk field file), but shows you how to
interface to your own raw data.
The image should be the same as financialField.tcl
"""
xAxis = "INTEREST_RATE"
yAxis = "MONTHLY_PAYMENT"
zAxis = "MONTHLY_INCOME"
scalar = "TIME_LATE"
# Parse an ascii file and manually create a field. Then construct a
# dataset from the field.
dos = vtk.vtkProgrammableDataObjectSource()
def parseFile():
f = open(VTK_DATA_ROOT + "/Data/financial.txt", "r")
line = f.readline().split()
# From the size calculate the number of lines.
numPts = int(line[1])
numLines = (numPts - 1) / 8 + 1
# create the data object
field = vtk.vtkFieldData()
field.AllocateArrays(4)
# read TIME_LATE - dependent variable
while True:
line = f.readline().split()
if len(line) > 0:
break
timeLate = vtk.vtkFloatArray()
timeLate.SetName(line[0])
for i in range(0, numLines):
line = f.readline().split()
for j in line:
timeLate.InsertNextValue(float(j))
field.AddArray(timeLate)
# MONTHLY_PAYMENT - independent variable
while True:
line = f.readline().split()
if len(line) > 0:
break
monthlyPayment = vtk.vtkFloatArray()
monthlyPayment.SetName(line[0])
for i in range(0, numLines):
line = f.readline().split()
for j in line:
monthlyPayment.InsertNextValue(float(j))
field.AddArray(monthlyPayment)
# UNPAID_PRINCIPLE - skip
while True:
line = f.readline().split()
if len(line) > 0:
break
for i in range(0, numLines):
line = f.readline()
# LOAN_AMOUNT - skip
while True:
line = f.readline().split()
if len(line) > 0:
break
for i in range(0, numLines):
line = f.readline()
# INTEREST_RATE - independent variable
while True:
line = f.readline().split()
if len(line) > 0:
break
interestRate = vtk.vtkFloatArray()
interestRate.SetName(line[0])
for i in range(0, numLines):
line = f.readline().split()
for j in line:
interestRate.InsertNextValue(float(j))
field.AddArray(interestRate)
# MONTHLY_INCOME - independent variable
while True:
line = f.readline().split()
if len(line) > 0:
break
monthlyIncome = vtk.vtkFloatArray()
monthlyIncome.SetName(line[0])
for i in range(0, numLines):
line = f.readline().split()
for j in line:
monthlyIncome.InsertNextValue(float(j))
field.AddArray(monthlyIncome)
dos.GetOutput().SetFieldData(field)
dos.SetExecuteMethod(parseFile)
# Create the dataset
do2ds = vtk.vtkDataObjectToDataSetFilter()
do2ds.SetInputConnection(dos.GetOutputPort())
do2ds.SetDataSetTypeToPolyData()
#format: component#, arrayname, arraycomp, minArrayId, maxArrayId, normalize
do2ds.DefaultNormalizeOn()
do2ds.SetPointComponent(0, xAxis, 0)
do2ds.SetPointComponent(1, yAxis, 0)
do2ds.SetPointComponent(2, zAxis, 0)
do2ds.Update()
rf = vtk.vtkRearrangeFields()
rf.SetInputConnection(do2ds.GetOutputPort())
rf.AddOperation("MOVE", scalar, "DATA_OBJECT", "POINT_DATA")
rf.RemoveOperation("MOVE", scalar, "DATA_OBJECT", "POINT_DATA")
rf.AddOperation("MOVE", scalar, "DATA_OBJECT", "POINT_DATA")
rf.RemoveAllOperations()
rf.AddOperation("MOVE", scalar, "DATA_OBJECT", "POINT_DATA")
rf.Update()
max = rf.GetOutput().GetPointData().GetArray(scalar).GetRange(0)[1]
calc = vtk.vtkArrayCalculator()
calc.SetInputConnection(rf.GetOutputPort())
calc.SetAttributeTypeToPointData()
calc.SetFunction("s / %f" % max)
calc.AddScalarVariable("s", scalar, 0)
calc.SetResultArrayName("resArray")
aa = vtk.vtkAssignAttribute()
aa.SetInputConnection(calc.GetOutputPort())
aa.Assign("resArray", "SCALARS", "POINT_DATA")
aa.Update()
rf2 = vtk.vtkRearrangeFields()
rf2.SetInputConnection(aa.GetOutputPort())
rf2.AddOperation("COPY", "SCALARS", "POINT_DATA", "DATA_OBJECT")
# construct pipeline for original population
popSplatter = vtk.vtkGaussianSplatter()
popSplatter.SetInputConnection(rf2.GetOutputPort())
popSplatter.SetSampleDimensions(50, 50, 50)
popSplatter.SetRadius(0.05)
popSplatter.ScalarWarpingOff()
popSurface = vtk.vtkContourFilter()
popSurface.SetInputConnection(popSplatter.GetOutputPort())
popSurface.SetValue(0, 0.01)
popMapper = vtk.vtkPolyDataMapper()
popMapper.SetInputConnection(popSurface.GetOutputPort())
popMapper.ScalarVisibilityOff()
popMapper.ImmediateModeRenderingOn()
popActor = vtk.vtkActor()
popActor.SetMapper(popMapper)
popActor.GetProperty().SetOpacity(0.3)
popActor.GetProperty().SetColor(.9, .9, .9)
# construct pipeline for delinquent population
lateSplatter = vtk.vtkGaussianSplatter()
lateSplatter.SetInputConnection(aa.GetOutputPort())
lateSplatter.SetSampleDimensions(50, 50, 50)
lateSplatter.SetRadius(0.05)
lateSplatter.SetScaleFactor(0.05)
lateSurface = vtk.vtkContourFilter()
lateSurface.SetInputConnection(lateSplatter.GetOutputPort())
lateSurface.SetValue(0, 0.01)
lateMapper = vtk.vtkPolyDataMapper()
lateMapper.SetInputConnection(lateSurface.GetOutputPort())
lateMapper.ScalarVisibilityOff()
lateActor = vtk.vtkActor()
lateActor.SetMapper(lateMapper)
lateActor.GetProperty().SetColor(1.0, 0.0, 0.0)
# create axes
popSplatter.Update()
bounds = popSplatter.GetOutput().GetBounds()
axes = vtk.vtkAxes()
axes.SetOrigin(bounds[0], bounds[2], bounds[4])
axes.SetScaleFactor(popSplatter.GetOutput().GetLength() / 5.0)
axesTubes = vtk.vtkTubeFilter()
axesTubes.SetInputConnection(axes.GetOutputPort())
axesTubes.SetRadius(axes.GetScaleFactor() / 25.0)
axesTubes.SetNumberOfSides(6)
axesMapper = vtk.vtkPolyDataMapper()
axesMapper.SetInputConnection(axesTubes.GetOutputPort())
axesActor = vtk.vtkActor()
axesActor.SetMapper(axesMapper)
# label the axes
XText = vtk.vtkVectorText()
XText.SetText(xAxis)
XTextMapper = vtk.vtkPolyDataMapper()
XTextMapper.SetInputConnection(XText.GetOutputPort())
XActor = vtk.vtkFollower()
XActor.SetMapper(XTextMapper)
XActor.SetScale(0.02, .02, .02)
XActor.SetPosition(0.35, -0.05, -0.05)
XActor.GetProperty().SetColor(0, 0, 0)
YText = vtk.vtkVectorText()
YText.SetText(yAxis)
YTextMapper = vtk.vtkPolyDataMapper()
YTextMapper.SetInputConnection(YText.GetOutputPort())
YActor = vtk.vtkFollower()
YActor.SetMapper(YTextMapper)
YActor.SetScale(0.02, .02, .02)
YActor.SetPosition(-0.05, 0.35, -0.05)
YActor.GetProperty().SetColor(0, 0, 0)
ZText = vtk.vtkVectorText()
ZText.SetText(zAxis)
ZTextMapper = vtk.vtkPolyDataMapper()
ZTextMapper.SetInputConnection(ZText.GetOutputPort())
ZActor = vtk.vtkFollower()
ZActor.SetMapper(ZTextMapper)
ZActor.SetScale(0.02, .02, .02)
ZActor.SetPosition(-0.05, -0.05, 0.35)
ZActor.GetProperty().SetColor(0, 0, 0)
# Graphics stuff
#
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
renWin.SetWindowName("vtk(-, Field.Data")
renWin.SetSize(300, 300)
# Add the actors to the renderer, set the background and size
#
ren.AddActor(axesActor)
ren.AddActor(lateActor)
ren.AddActor(XActor)
ren.AddActor(YActor)
ren.AddActor(ZActor)
ren.AddActor(popActor) #it's last because its translucent)
ren.SetBackground(1, 1, 1)
camera = vtk.vtkCamera()
camera.SetClippingRange(.274, 13.72)
camera.SetFocalPoint(0.433816, 0.333131, 0.449)
camera.SetPosition(-1.96987, 1.15145, 1.49053)
camera.SetViewUp(0.378927, 0.911821, 0.158107)
ren.SetActiveCamera(camera)
XActor.SetCamera(camera)
YActor.SetCamera(camera)
ZActor.SetCamera(camera)
# render and interact with data
iRen = vtk.vtkRenderWindowInteractor()
iRen.SetRenderWindow(renWin)
renWin.Render()
img_file = "financialField3.png"
vtk.test.Testing.compareImage(
iRen.GetRenderWindow(),
vtk.test.Testing.getAbsImagePath(img_file),
threshold=25)
vtk.test.Testing.interact()
def vtk_show(_renderer, window_name='VTK Show Window',
width=640, height=480, has_picker=False):
"""
Show the vtkRenderer in an vtkRenderWindow
Only support ONE vtkRenderer
:return: No return value
"""
# render_window = vtk.vtkRenderWindow()
render_window.AddRenderer(_renderer)
render_window.SetSize(width, height)
render_window.Render()
# It works only after Render() is called
render_window.SetWindowName(window_name)
# iren = vtk.vtkRenderWindowInteractor()
# iren.SetRenderWindow(render_window)
interactor_style = vtk.vtkInteractorStyleTrackballCamera()
iren.SetInteractorStyle(interactor_style)
# Add an Annoted Cube with Arrows
cube = vtk.vtkAnnotatedCubeActor()
cube.SetXPlusFaceText('R')
cube.SetXMinusFaceText('L')
cube.SetYPlusFaceText('A')
cube.SetYMinusFaceText('P')
cube.SetZPlusFaceText('I')
cube.SetZMinusFaceText('S')
cube.SetXFaceTextRotation(180)
cube.SetYFaceTextRotation(180)
cube.SetZFaceTextRotation(-90)
cube.SetFaceTextScale(0.65)
cube.GetCubeProperty().SetColor(0.5, 1.0, 1.0)
cube.GetTextEdgesProperty().SetLineWidth(1)
cube.GetTextEdgesProperty().SetColor(0.18, 0.28, 0.23)
cube.GetTextEdgesProperty().SetDiffuse(0)
cube.GetTextEdgesProperty().SetAmbient(1)
cube.GetXPlusFaceProperty().SetColor(1, 0, 0)
cube.GetXPlusFaceProperty().SetInterpolationToFlat()
cube.GetXMinusFaceProperty().SetColor(1, 0, 0)
cube.GetXMinusFaceProperty().SetInterpolationToFlat()
cube.GetYPlusFaceProperty().SetColor(0, 1, 0)
cube.GetYPlusFaceProperty().SetInterpolationToFlat()
cube.GetYMinusFaceProperty().SetColor(0, 1, 0)
cube.GetYMinusFaceProperty().SetInterpolationToFlat()
cube.GetZPlusFaceProperty().SetColor(0, 0, 1)
cube.GetZPlusFaceProperty().SetInterpolationToFlat()
cube.GetZMinusFaceProperty().SetColor(0, 0, 1)
cube.GetZMinusFaceProperty().SetInterpolationToFlat()
text_property = vtk.vtkTextProperty()
text_property.ItalicOn()
text_property.ShadowOn()
text_property.BoldOn()
text_property.SetFontFamilyToTimes()
text_property.SetColor(1, 0, 0)
text_property_2 = vtk.vtkTextProperty()
text_property_2.ShallowCopy(text_property)
text_property_2.SetColor(0, 1, 0)
text_property_3 = vtk.vtkTextProperty()
text_property_3.ShallowCopy(text_property)
text_property_3.SetColor(0, 0, 1)
axes = vtk.vtkAxesActor()
axes.SetShaftTypeToCylinder()
axes.SetXAxisLabelText('X')
axes.SetYAxisLabelText('Y')
axes.SetZAxisLabelText('Z')
axes.SetTotalLength(1.5, 1.5, 1.5)
axes.GetXAxisCaptionActor2D().SetCaptionTextProperty(text_property)
axes.GetYAxisCaptionActor2D().SetCaptionTextProperty(text_property_2)
axes.GetZAxisCaptionActor2D().SetCaptionTextProperty(text_property_3)
assembly = vtk.vtkPropAssembly()
assembly.AddPart(axes)
assembly.AddPart(cube)
marker = vtk.vtkOrientationMarkerWidget()
marker.SetOutlineColor(0.93, 0.57, 0.13)
marker.SetOrientationMarker(assembly)
marker.SetViewport(0.0, 0.0, 0.15, 0.3)
marker.SetInteractor(iren)
marker.EnabledOn()
marker.InteractiveOn()
# Add a x-y-z coordinate to the original point
axes_coor = vtk.vtkAxes()
axes_coor.SetOrigin(0, 0, 0)
mapper_axes_coor = vtk.vtkPolyDataMapper()
mapper_axes_coor.SetInputConnection(axes_coor.GetOutputPort())
actor_axes_coor = vtk.vtkActor()
actor_axes_coor.SetMapper(mapper_axes_coor)
_renderer.AddActor(actor_axes_coor)
# Add an original point and text
add_point(_renderer, color=[0, 1, 0], radius=2)
add_text(_renderer, position=[0, 0, 0], text="Origin",
color=[0, 1, 0], scale=2)
_renderer.ResetCamera() # Coorperate with vtkFollower
# iren.Initialize() # will be called by Start() autometically
if has_picker:
iren.AddObserver('MouseMoveEvent', MoveCursor)
iren.Start()
def main():
colors = vtk.vtkNamedColors()
colors.SetColor("PopColor", [230, 230, 230, 255])
fileName = get_program_parameters()
keys = [
'NUMBER_POINTS', 'MONTHLY_PAYMENT', 'INTEREST_RATE', 'LOAN_AMOUNT',
'TIME_LATE'
]
# Read in the data and make an unstructured data set.
dataSet = make_dataset(fileName, keys)
# Construct the pipeline for the original population.
popSplatter = vtk.vtkGaussianSplatter()
popSplatter.SetInputData(dataSet)
popSplatter.SetSampleDimensions(100, 100, 100)
popSplatter.SetRadius(0.05)
popSplatter.ScalarWarpingOff()
popSurface = vtk.vtkContourFilter()
popSurface.SetInputConnection(popSplatter.GetOutputPort())
popSurface.SetValue(0, 0.01)
popMapper = vtk.vtkPolyDataMapper()
popMapper.SetInputConnection(popSurface.GetOutputPort())
popMapper.ScalarVisibilityOff()
popActor = vtk.vtkActor()
popActor.SetMapper(popMapper)
popActor.GetProperty().SetOpacity(0.3)
popActor.GetProperty().SetColor(colors.GetColor3d("PopColor"))
# Construct the pipeline for the delinquent population.
lateSplatter = vtk.vtkGaussianSplatter()
lateSplatter.SetInputData(dataSet)
lateSplatter.SetSampleDimensions(50, 50, 50)
lateSplatter.SetRadius(0.05)
lateSplatter.SetScaleFactor(0.005)
lateSurface = vtk.vtkContourFilter()
lateSurface.SetInputConnection(lateSplatter.GetOutputPort())
lateSurface.SetValue(0, 0.01)
lateMapper = vtk.vtkPolyDataMapper()
lateMapper.SetInputConnection(lateSurface.GetOutputPort())
lateMapper.ScalarVisibilityOff()
lateActor = vtk.vtkActor()
lateActor.SetMapper(lateMapper)
lateActor.GetProperty().SetColor(colors.GetColor3d("Red"))
# Create axes.
popSplatter.Update()
bounds = popSplatter.GetOutput().GetBounds()
axes = vtk.vtkAxes()
axes.SetOrigin(bounds[0], bounds[2], bounds[4])
axes.SetScaleFactor(popSplatter.GetOutput().GetLength() / 5)
axesTubes = vtk.vtkTubeFilter()
axesTubes.SetInputConnection(axes.GetOutputPort())
axesTubes.SetRadius(axes.GetScaleFactor() / 25.0)
axesTubes.SetNumberOfSides(6)
axesMapper = vtk.vtkPolyDataMapper()
axesMapper.SetInputConnection(axesTubes.GetOutputPort())
axesActor = vtk.vtkActor()
axesActor.SetMapper(axesMapper)
# Graphics stuff.
renderer = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(renderer)
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(renWin)
# Set up the renderer.
renderer.AddActor(lateActor)
renderer.AddActor(axesActor)
renderer.AddActor(popActor)
renderer.SetBackground(colors.GetColor3d("Wheat"))
renWin.SetSize(640, 480)
renderer.ResetCamera()
renderer.GetActiveCamera().Dolly(1.3)
renderer.ResetCameraClippingRange()
# Interact with the data.
renWin.Render()
interactor.Start()
def walk_cow(file_name, figure):
figure = abs(figure)
if figure > 2:
figure = 0
colors = vtk.vtkNamedColors()
# Set the background color.
colors.SetColor("BkgColor1", [60, 93, 144, 255])
colors.SetColor("BkgColor2", [26, 51, 102, 255])
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# The cow pipeline.
cow = vtk.vtkBYUReader()
cow.SetGeometryFileName(file_name)
cow.Update()
cowMapper = vtk.vtkPolyDataMapper()
cowMapper.SetInputConnection(cow.GetOutputPort())
cowMapper.ScalarVisibilityOff()
cowActor = vtk.vtkActor()
cowActor.SetMapper(cowMapper)
cowActor.GetProperty().SetColor(colors.GetColor3d("Wheat"))
ren.AddActor(cowActor)
# Axes pipeline.
cowAxesSource = vtk.vtkAxes()
cowAxesSource.SetScaleFactor(10.0)
cowAxesSource.SetOrigin(0, 0, 0)
cowAxesMapper = vtk.vtkPolyDataMapper()
cowAxesMapper.SetInputConnection(cowAxesSource.GetOutputPort())
cowAxes = vtk.vtkActor()
cowAxes.SetMapper(cowAxesMapper)
cowAxes.VisibilityOff()
ren.AddActor(cowAxes)
ren.SetBackground(colors.GetColor3d("BkgColor1"))
renWin.SetSize(600, 480)
iren.Initialize()
cowAxes.VisibilityOn()
renWin.Render()
# Activate this if you want to see the Position and Focal point.
# ren.GetActiveCamera().AddObserver('ModifiedEvent', CameraModifiedCallback)
# These four walks use the same camera position.
Rotate_X(cowActor, ren, renWin)
Rotate_Y(cowActor, ren, renWin)
Rotate_Z(cowActor, ren, renWin)
Rotate_XY(cowActor, ren, renWin)
ren.SetBackground(colors.GetColor3d("BkgColor2"))
if figure == 1:
Rotate_V_0(cowActor, ren, renWin)
elif figure == 2:
Rotate_V_V(cowActor, ren, renWin)
else:
Rotate_V_0(cowActor, ren, renWin)
Rotate_V_V(cowActor, ren, renWin)
# Walk() needs to go after Rotate_V_0() or Rotate_V_V().
Walk(cowActor, ren, renWin)
# Interact with data.
renWin.EraseOff()
iren.Start()
#
ren1 = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren1)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# create pipeline
#
cow = vtk.vtkBYUReader()
cow.SetGeometryFileName("" + str(VTK_DATA_ROOT) + "/Data/Viewpoint/cow.g")
cowMapper = vtk.vtkPolyDataMapper()
cowMapper.SetInputConnection(cow.GetOutputPort())
cowActor = vtk.vtkActor()
cowActor.SetMapper(cowMapper)
cowActor.GetProperty().SetDiffuseColor(0.9608,0.8706,0.7020)
cowAxesSource = vtk.vtkAxes()
cowAxesSource.SetScaleFactor(10)
cowAxesSource.SetOrigin(0,0,0)
cowAxesMapper = vtk.vtkPolyDataMapper()
cowAxesMapper.SetInputConnection(cowAxesSource.GetOutputPort())
cowAxes = vtk.vtkActor()
cowAxes.SetMapper(cowAxesMapper)
ren1.AddActor(cowAxes)
cowAxes.VisibilityOff()
# Add the actors to the renderer, set the background and size
#
ren1.AddActor(cowActor)
ren1.SetBackground(0.1,0.2,0.4)
renWin.SetSize(320,240)
ren1.ResetCamera()
ren1.GetActiveCamera().Azimuth(0)
def render_polydata(self, input_polydata, scalar_range=None,
tube=True, opacity=1, depth_peeling=False,
scalar_bar=False, scalar_bar_title=None,
axes=False, data_mode="Cell", colormap='jet', verbose=True):
# re-do this every time because the user may close the window
# and re-use the object
#self.build_vtk()
if verbose:
print "<render.py> Rendering vtkPolyData."
# actor and mapper
mapper = vtk.vtkPolyDataMapper()
actor = vtk.vtkActor()
actor.SetMapper(mapper)
# assign actor to the renderer
self.renderer.AddActor(actor)
# lookup table for everything
#self.lut = vtk.vtkLookupTable()
if colormap == 'hot':
lut = get_hot_lookup_table()
else:
lut = get_jet_lookup_table()
mapper.UseLookupTableScalarRangeOn()
mapper.SetLookupTable(lut)
# see if we have RGB data, if so the scalar bar is meaningless
self.render_RGB = False
if input_polydata.GetCellData().GetScalars():
if input_polydata.GetCellData().GetScalars().GetNumberOfComponents() == 3:
self.render_RGB = True
self.renderer.RemoveActor2D(self.scalarbar)
if verbose:
print "<render.py> RGB: ", self.render_RGB
if data_mode == "Cell":
mapper.SetScalarModeToUseCellData()
elif data_mode == "Point":
mapper.SetScalarModeToUsePointData()
#if input_polydata.GetNumberOfLines() > 0:
# mapper.SetScalarModeToUseCellData()
if tube & (input_polydata.GetNumberOfLines() > 0):
# make a tube filter
tube_filter = vtk.vtkTubeFilter()
tube_filter.SetNumberOfSides(self.number_of_tube_sides)
if (vtk.vtkVersion().GetVTKMajorVersion() > 5.0):
tube_filter.SetInputData(input_polydata)
else:
tube_filter.SetInput(input_polydata)
if (vtk.vtkVersion().GetVTKMajorVersion() >= 6.0):
mapper.SetInputConnection(tube_filter.GetOutputPort())
else:
mapper.SetInput(tube_filter.GetOutput())
else:
if (vtk.vtkVersion().GetVTKMajorVersion() >= 6.0):
mapper.SetInputData(input_polydata)
else:
mapper.SetInput(input_polydata)
if scalar_range is None:
# check polydata scalar range.
range_low, range_high = input_polydata.GetScalarRange()
# if these numbers are between -1 and 1 assume laterality
# data, so make sure colorbar is centered at 0 for clearer
# interpretation
if (range_low >= -1.0 ) and (range_high <= 1.0):
range_final = max(abs(range_low), abs(range_high))
lut.SetRange([-range_final, range_final])
else:
# otherwise just use the range directly
lut.SetRange([range_low, range_high])
else:
lut.SetRange(scalar_range)
if opacity is not 1:
actor.GetProperty().SetOpacity(opacity)
if depth_peeling is not False:
# 1. Use a render window with alpha bits (as initial value is 0 (false)):
self.render_window.SetAlphaBitPlanes(1)
# 2. Force to not pick a framebuffer with a multisample buffer
# (as initial value is 8):
self.render_window.SetMultiSamples(0)
# 3. Choose to use depth peeling (if supported) (initial value is 0 (false)):
self.renderer.SetUseDepthPeeling(1)
# 4. Set depth peeling parameters
# - Set the maximum number of rendering passes (initial value is 4):
#renderer->SetMaximumNumberOfPeels(maxNoOfPeels);
#// - Set the occlusion ratio (initial value is 0.0, exact image):
#renderer->SetOcclusionRatio(occlusionRatio);
if scalar_bar:
self.scalarbar.SetLookupTable(lut)
self.renderer.AddActor2D(self.scalarbar)
if scalar_bar_title is not None:
self.scalarbar.SetTitle(scalar_bar_title)
else:
self.renderer.RemoveActor2D(self.scalarbar)
# Create the axes and the associated mapper and actor.
self.axes = vtk.vtkAxes()
self.axes.SetOrigin(0, 0, 0)
self.axes.SetScaleFactor(100)
self.axes.SymmetricOn()
self.axes_mapper = vtk.vtkPolyDataMapper()
if (vtk.vtkVersion().GetVTKMajorVersion() >= 6.0):
self.axes_mapper.SetInputConnection(self.axes.GetOutputPort())
else:
self.axes_mapper.SetInput(self.axes.GetOutput())
self.axes_actor = vtk.vtkActor()
self.axes_actor.SetMapper(self.axes_mapper)
self.axes_mapper.SetLookupTable(lut)
if axes:
self.renderer.AddActor(self.axes_actor)
else:
self.renderer.RemoveActor(self.axes_actor)
try:
self.render_window.Render()
except Exception:
print "<render.py> ERROR. Failed to render. Check display settings."
def UpdateVTKWindow(self,x,y,z):
self.widget.GetRenderWindow().RemoveRenderer(self.ren)
self.ren = vtk.vtkRenderer()
self.ren.SetBackground(0.1, 0.1, 0.7)
self.widget.GetRenderWindow().AddRenderer(self.ren)
scalars = vtk.vtkIntArray()
self.pnt = vtk.vtkPoints()
cells = vtk.vtkCellArray()
self.pnt.SetNumberOfPoints(self.data.shape[0])
cells.Allocate(self.data.shape[0],32)
for i in xrange(0, self.data.shape[0]):
if self.colors is not None:
if self.cbs[self.colors[i]].IsChecked():
self.pnt.InsertPoint(i,
self.data[i,x],
self.data[i,y],
self.data[i,z])
cells.InsertNextCell(1)
cells.InsertCellPoint(i)
else:
self.pnt.InsertPoint(i,
self.data[i,x],
self.data[i,y],
self.data[i,z])
cells.InsertNextCell(1)
cells.InsertCellPoint(i)
if self.colors is not None:
for i in xrange(0, self.data.shape[0]):
scalars.InsertNextTuple1(self.colors[i])
else:
for i in xrange(0, self.data.shape[0]):
scalars.InsertNextTuple1(0)
# create poly of the points
self.poly = vtk.vtkPolyData()
self.poly.SetPoints(self.pnt)
self.poly.SetVerts(cells)
self.poly.GetPointData().SetScalars(scalars)
self.normals = vtk.vtkPolyDataNormals()
self.normals.SetInput(self.poly)
# add box widget for clipping
# points inside the box are colored green
apd = vtk.vtkAppendPolyData()
apd.AddInput(self.poly)
# create mapper pipline for the poly
pntmapper = vtk.vtkPolyDataMapper()
self.clipper.SetInput(apd.GetOutput())
self.region = vtk.vtkImplicitBoolean()
self.region.SetOperationTypeToUnion()
self.clipper.SetClipFunction(self.region)
self.clipper.InsideOutOn()
selectMapper = vtk.vtkPolyDataMapper()
selectMapper.SetInput(self.clipper.GetOutput())
selectMapper.ScalarVisibilityOff()
self.selectActor.SetMapper(selectMapper)
self.selectActor.GetProperty().SetColor(0, 1, 0)
self.selectActor.VisibilityOff()
self.selectActor.SetScale(1.01, 1.01, 1.01)
if self.colors is not None:
pntmapper.SetLookupTable(self.lut)
pntmapper.SetInput(apd.GetOutput())
pntmapper.SetScalarRange(0, self.maxcolor)
# create and add actor of mapper to renderer
pntactor = vtk.vtkLODActor()
# pntactor.GetProperty().SetColor(1,0,0)
pntactor.SetMapper(pntmapper)
pntactor.VisibilityOn()
# create axes
axes = vtk.vtkAxes()
axes.SetOrigin(0,0,0)
axes.SetScaleFactor(numpy.max(self.data))
axesTubes = vtk.vtkTubeFilter()
axesTubes.SetInput(axes.GetOutput())
axesTubes.SetRadius(axes.GetScaleFactor()/200.0)
axesTubes.SetNumberOfSides(6)
#create axes mapper
axesmapper = vtk.vtkPolyDataMapper()
axesmapper.SetInput(axesTubes.GetOutput())
#create actor and add to renderer
axesactor = vtk.vtkActor()
axesactor.SetMapper(axesmapper)
#create labels
sf = axes.GetScaleFactor()
xactor = self.BuildLabelActor(self.radioX.GetString(x), {})
xactor.SetScale(0.075*sf, 0.075*sf, 0.075*sf)
xactor.SetPosition(0.2*sf, 0.05*sf, -0.05*sf)
xactor.GetProperty().SetColor(0, 0, 0)
yactor = self.BuildLabelActor(self.radioY.GetString(y), {'RotateZ': 90})
yactor.SetScale(0.075*sf, 0.075*sf, 0.075*sf)
yactor.SetPosition(-0.05*sf, 0.2*sf, -0.05*sf)
yactor.GetProperty().SetColor(0, 0, 0)
zactor = self.BuildLabelActor(self.radioZ.GetString(z), {'RotateY': 90})
zactor.SetScale(0.075*sf, 0.075*sf, 0.075*sf)
zactor.SetPosition(-0.05*sf, 0.05*sf, 0.6*sf)
zactor.GetProperty().SetColor(0, 0, 0)
self.ren.AddActor(xactor)
self.ren.AddActor(yactor)
self.ren.AddActor(zactor)
self.ren.AddActor(axesactor)
self.ren.AddActor(pntactor)
self.ren.AddActor(self.selectActor)
self.widget.Update()
self.ren.ResetCamera()
