def QVTKRenderWidgetConeExample():
"""A simple example that uses the QVTKRenderWindowInteractor class."""
# every QT app needs an app
app = QtGui.QApplication(['QVTKRenderWindowInteractor'])
# create the widget
widget = QVTKRenderWindowInteractor()
widget.Initialize()
widget.Start()
# if you dont want the 'q' key to exit comment this.
widget.AddObserver("ExitEvent", lambda o, e, a=app: a.quit())
ren = vtk.vtkRenderer()
widget.GetRenderWindow().AddRenderer(ren)
cone = vtk.vtkConeSource()
cone.SetResolution(8)
coneMapper = vtk.vtkPolyDataMapper()
coneMapper.SetInputConnection(cone.GetOutputPort())
coneActor = vtk.vtkActor()
coneActor.SetMapper(coneMapper)
ren.AddActor(coneActor)
# show the widget
widget.show()
# start event processing
app.exec_()
class VTKCanvas(QtGui.QFrame):
''' the Qt4 frame that holds the main VTK canvas '''
def __init__(self, parent, Qt4GUI):
super(VTKCanvas, self).__init__(parent)
# dictionary to keep track of tree widget items that correspond to actors/icons - used to handle vtk->Qt4 scene changes
self.actors_to_tree_widget_items = {}
# Qt4 GUI that this canvas is associated with
self.Qt4GUI = Qt4GUI
# camera perspective type check
self.camera_perspective = False
# setup the vtk renderers - one for objects, one for overlay icons/text (which always renders on top)
self.vtk_renderer = vtk.vtkRenderer()
# setup the vtk interactor
self.vtk_interactor = QVTKRenderWindowInteractor(self)
# setup the vtk render window
self.vtk_render_window = self.vtk_interactor.GetRenderWindow()
self.vtk_render_window.AddRenderer(self.vtk_renderer)
self.vtk_render_window.SetInteractor(self.vtk_interactor)
#setup the layout of the vtk interactor in Qt
self.layout = QtGui.QHBoxLayout()
self.layout.addWidget(self.vtk_interactor)
self.layout.setContentsMargins(0, 0, 0, 0)
self.setLayout(self.layout)
def setupTimerCallback(self, targetFPS=30):
# calling this function will setup a timer and callback to continuously render the scene at the target FPS
self.vtk_interactor.AddObserver('TimerEvent', self.requestUpdate)
self.vtk_interactor.CreateRepeatingTimer(long(targetFPS))
def requestUpdate(self, obj, event):
# request a render update of the scene
self.vtk_render_window.Render()
def start(self):
# setup the vtk background - as default, set to light
self.vtk_renderer.GradientBackgroundOn()
self.setBackgroundLight()
# setup the default camera
self.camera_perspective = False
self.defaultPerspectiveCamera()
# setup a default light kit (simple sun illumination + camera spotlight)
self.light_kit = vtk.vtkLightKit()
self.light_kit.MaintainLuminanceOn()
self.light_kit.AddLightsToRenderer(self.vtk_renderer)
# add the orientation axes to the bottom left of the canvas
self.Qt4GUI.addOrientationAxes()
# setup the default base grid - 1x1km, 10m squares
self.Qt4GUI.addGrid(['grids', '1 km x 1 km, 10 m'], 1000, 10)
# startup vtk
self.vtk_interactor.Initialize()
self.vtk_interactor.Start()
def resetCamera(self):
if self.camera_perspective:
self.camera_perspective = False
self.defaultPerspectiveCamera()
else:
self.camera_perspective = True
self.defaultTopDownCamera()
def defaultPerspectiveCamera(self):
self.Qt4GUI.camera_perspective_signal.emit(True)
if not self.camera_perspective:
self.vtk_renderer.SetActiveCamera(vtk.vtkCamera())
self.vtk_interactor.SetInteractorStyle(TerrainInteractorStyle())
self.vtk_renderer.GetActiveCamera().SetViewUp(0, 0, 1)
self.vtk_renderer.GetActiveCamera().SetPosition(0, 1, 10)
self.vtk_renderer.GetActiveCamera().SetFocalPoint(0, 0, 0)
self.vtk_renderer.GetActiveCamera().Azimuth(135)
self.vtk_renderer.GetActiveCamera().Elevation(86)
self.vtk_renderer.GetActiveCamera().Dolly(0.4)
self.vtk_renderer.GetActiveCamera().Zoom(1)
self.vtk_renderer.ResetCameraClippingRange()
self.camera_perspective = True
self.vtk_interactor.Render()
def perspectiveCamera(self):
self.Qt4GUI.camera_perspective_signal.emit(True)
if not self.camera_perspective:
curr_fp = self.vtk_renderer.GetActiveCamera().GetFocalPoint()
curr_pos = [curr_fp[0], curr_fp[1] + 1, 10]
curr_fp = [curr_fp[0], curr_fp[1], 0]
self.vtk_renderer.SetActiveCamera(vtk.vtkCamera())
self.vtk_interactor.SetInteractorStyle(TerrainInteractorStyle())
self.vtk_renderer.GetActiveCamera().SetViewUp(0, 0, 1)
self.vtk_renderer.GetActiveCamera().SetPosition(curr_pos)
self.vtk_renderer.GetActiveCamera().SetFocalPoint(curr_fp)
self.vtk_renderer.GetActiveCamera().Azimuth(135)
self.vtk_renderer.GetActiveCamera().Elevation(86)
self.vtk_renderer.GetActiveCamera().Dolly(0.4)
self.vtk_renderer.GetActiveCamera().Zoom(1)
self.vtk_renderer.ResetCameraClippingRange()
self.camera_perspective = True
self.vtk_interactor.Render()
def defaultTopDownCamera(self):
self.Qt4GUI.camera_perspective_signal.emit(False)
if self.camera_perspective:
self.vtk_renderer.SetActiveCamera(vtk.vtkCamera())
self.vtk_interactor.SetInteractorStyle(TopDownInteractorStyle())
self.vtk_renderer.GetActiveCamera().SetViewUp(0, 1, 0)
self.vtk_renderer.GetActiveCamera().ParallelProjectionOn()
self.vtk_renderer.GetActiveCamera().SetParallelScale(1000)
self.vtk_renderer.GetActiveCamera().SetPosition(0, 0, 1e4)
self.vtk_renderer.GetActiveCamera().SetFocalPoint(0, 0, 0)
self.vtk_renderer.GetActiveCamera().Elevation(0)
self.vtk_renderer.GetActiveCamera().Azimuth(0)
self.vtk_renderer.GetActiveCamera().Dolly(0.4)
self.vtk_renderer.GetActiveCamera().Zoom(100)
self.vtk_renderer.ResetCameraClippingRange()
self.camera_perspective = False
self.vtk_interactor.Render()
def topDownCamera(self):
self.Qt4GUI.camera_perspective_signal.emit(False)
if self.camera_perspective:
curr_fp = self.vtk_renderer.GetActiveCamera().GetFocalPoint()
curr_pos = [curr_fp[0], curr_fp[1], 1e4]
curr_fp = [curr_fp[0], curr_fp[1], 0]
self.vtk_renderer.SetActiveCamera(vtk.vtkCamera())
self.vtk_interactor.SetInteractorStyle(TopDownInteractorStyle())
self.vtk_renderer.GetActiveCamera().SetViewUp(0, 1, 0)
self.vtk_renderer.GetActiveCamera().ParallelProjectionOn()
self.vtk_renderer.GetActiveCamera().SetParallelScale(1000)
self.vtk_renderer.GetActiveCamera().SetPosition(curr_pos)
self.vtk_renderer.GetActiveCamera().SetFocalPoint(curr_fp)
self.vtk_renderer.GetActiveCamera().Elevation(0)
self.vtk_renderer.GetActiveCamera().Azimuth(0)
self.vtk_renderer.GetActiveCamera().Dolly(0.4)
self.vtk_renderer.GetActiveCamera().Zoom(100)
self.vtk_renderer.ResetCameraClippingRange()
self.camera_perspective = False
self.vtk_interactor.Render()
def setBackgroundLight(self):
self.Qt4GUI.background_light_signal.emit(True)
self.vtk_renderer.SetBackground2(220.0 / 255, 225.0 / 255, 235.0 / 255)
self.vtk_renderer.SetBackground(105.0 / 255, 135.0 / 255, 155.0 / 255)
self.vtk_interactor.Render()
def setBackgroundDark(self):
self.Qt4GUI.background_light_signal.emit(False)
self.vtk_renderer.SetBackground(0.0 / 255, 10.0 / 255, 15.0 / 255)
self.vtk_renderer.SetBackground2(60.0 / 255, 80.0 / 255, 110.0 / 255)
self.vtk_interactor.Render()
def addActorFrameAxes(self, tree_widget):
frame_axes = Primitives.Axes()
frame_axes.AxisLabelsOff()
frame_axes.VisibilityOff()
self.vtk_renderer.AddActor(frame_axes)
self.vtk_interactor.Render()
return frame_axes
def removeActorFrameAxes(self, actor):
self.vtk_renderer.RemoveActor(actor)
self.vtk_interactor.Render()
def addActor(self, tree_widget, actor):
self.actors_to_tree_widget_items[actor] = tree_widget
self.vtk_renderer.AddActor(actor)
self.vtk_interactor.Render()
def removeActor(self, actor):
del self.actors_to_tree_widget_items[actor]
self.vtk_renderer.RemoveActor(actor)
self.vtk_interactor.Render()
def replaceActor(self, remove_actor, tree_widget, actor):
self.removeActor(remove_actor)
self.addActor(tree_widget, actor)
def setActorVisibility(self, actor, visible):
if visible:
actor.VisibilityOn()
else:
actor.VisibilityOff()
self.vtk_interactor.Render()
def setActorScale(self, actor, scale):
if actor.GetClassName() == "vtkAxesActor":
actor.SetTotalLength(scale, scale, scale)
else:
if actor.__class__ == Billboards.TextBillboard or actor.__class__ == Billboards.ImageBillboard:
# billboards have no scaling
return
actor.SetScale(scale)
self.vtk_interactor.Render()
def getActorScale(self, actor):
if actor.GetClassName() == "vtkAxesActor":
return actor.GetTotalLength()
else:
if actor.__class__ == Billboards.TextBillboard or actor.__class__ == Billboards.ImageBillboard:
# billboards have no scaling
return [1, 1, 1]
return actor.GetScale()
def setActorOpacity(self, actor, opacity):
actor.GetProperty().SetOpacity(opacity)
self.vtk_interactor.Render()
def getActorOpacity(self, actor):
return actor.GetProperty().GetOpacity()
def setActorPointSize(self, actor, size):
actor.GetProperty().SetPointSize(size)
self.vtk_interactor.Render()
def getActorPointSize(self, actor):
return actor.GetProperty().GetPointSize()
def setActorLineWidth(self, actor, width):
actor.GetProperty().SetLineWidth(width)
self.vtk_interactor.Render()
def getActorLineWidth(self, actor):
return actor.GetProperty().GetLineWidth()
def setActorToSurface(self, actor):
if actor.__class__ == Billboards.TextBillboard or actor.__class__ == Billboards.ImageBillboard:
# billboards have no render mode
return
actor.GetProperty().EdgeVisibilityOff()
actor.GetProperty().SetRepresentationToSurface()
self.vtk_interactor.Render()
def setActorToWireframe(self, actor):
if actor.__class__ == Billboards.TextBillboard or actor.__class__ == Billboards.ImageBillboard:
# billboards have no render mode
return
actor.GetProperty().EdgeVisibilityOff()
actor.GetProperty().SetRepresentationToWireframe()
self.vtk_interactor.Render()
def setActorToSurfaceEdges(self, actor):
if actor.__class__ == Billboards.TextBillboard or actor.__class__ == Billboards.ImageBillboard:
# billboards have no render mode
return
actor.GetProperty().EdgeVisibilityOn()
actor.GetProperty().SetRepresentationToSurface()
self.vtk_interactor.Render()
def setActorToPoints(self, actor):
if actor.__class__ == Billboards.TextBillboard or actor.__class__ == Billboards.ImageBillboard:
# billboards have no render mode
return
actor.GetProperty().EdgeVisibilityOff()
actor.GetProperty().SetRepresentationToPoints()
self.vtk_interactor.Render()
def getActorRenderMode(self, actor):
if actor.__class__ == Billboards.TextBillboard or actor.__class__ == Billboards.ImageBillboard:
# billboards have no render mode
return None, None
edge = actor.GetProperty().GetEdgeVisibility()
mode = actor.GetProperty().GetRepresentation()
return edge, mode
def getActorColor(self, actor):
return actor.GetProperty().GetColor()
def setActorColor(self, actor, r, g, b):
actor.GetProperty().SetColor(r, g, b)
self.vtk_interactor.Render()
def setActorTexture(self, actor, image_path):
if actor.__class__ == Billboards.TextBillboard:
# text billboards have no texture
return
if image_path[-4:].lower() == '.jpg' or image_path[-4:].lower(
) == '.jpeg':
reader = vtk.vtkJPEGReader()
reader.SetFileName(image_path)
reader.Update()
elif image_path[-4:].lower() == '.png':
reader = vtk.vtkPNGReader()
reader.SetFileName(image_path)
reader.Update()
texture = vtk.vtkTexture()
texture.RepeatOn()
texture.SetInputConnection(reader.GetOutputPort())
actor.SetTexture(texture)
# polydata = actor.GetMapper().GetInput()
# pointdata = polydata.GetPointData()
# celldata = polydata.GetCellData()
# numtuples = celldata.GetNumberOfTuples()
# numpolygons = polydata.GetNumberOfPolys()
self.vtk_interactor.Render()
def removeActorTexture(self, actor):
actor.SetTexture(None)
self.vtk_interactor.Render()
def setActorOffset(self, actor, x_offset, y_offset, z_offset):
if actor.__class__ == Billboards.TextBillboard or actor.__class__ == Billboards.ImageBillboard:
# billboards are unaffected by offset changes
pass
else:
actor.SetPosition(x_offset, y_offset, z_offset)
self.vtk_interactor.Render()
def setActorOrientation(self, actor, roll, pitch, yaw):
actor.SetOrientation(roll, pitch, yaw)
self.vtk_interactor.Render()
class VtkWindow(QtGui.QFrame):
"""
VtkWindow integrates a QVTKRenderWindowInteractor for Python and Qt. Uses a
vtkGenericRenderWindowInteractor to handle the interactions. Use
GetRenderWindow() to get the vtkRenderWindow. Create with the
keyword stereo=1 in order to generate a stereo-capable window.
The user interface is summarized in vtkInteractorStyle.h:
- Keypress j / Keypress t: toggle between joystick (position
sensitive) and trackball (motion sensitive) styles. In joystick
style, motion occurs continuously as long as a mouse button is
pressed. In trackball style, motion occurs when the mouse button
is pressed and the mouse pointer moves.
- Keypress c / Keypress o: toggle between camera and object
(actor) modes. In camera mode, mouse events affect the camera
position and focal point. In object mode, mouse events affect
the actor that is under the mouse pointer.
- Button 1: rotate the camera around its focal point (if camera
mode) or rotate the actor around its origin (if actor mode). The
rotation is in the direction defined from the center of the
renderer's viewport towards the mouse position. In joystick mode,
the magnitude of the rotation is determined by the distance the
mouse is from the center of the render window.
- Button 2: pan the camera (if camera mode) or translate the actor
(if object mode). In joystick mode, the direction of pan or
translation is from the center of the viewport towards the mouse
position. In trackball mode, the direction of motion is the
direction the mouse moves. (Note: with 2-button mice, pan is
defined as <Shift>-Button 1.)
- Button 3: zoom the camera (if camera mode) or scale the actor
(if object mode). Zoom in/increase scale if the mouse position is
in the top half of the viewport; zoom out/decrease scale if the
mouse position is in the bottom half. In joystick mode, the amount
of zoom is controlled by the distance of the mouse pointer from
the horizontal centerline of the window.
- Keypress 3: toggle the render window into and out of stereo
mode. By default, red-blue stereo pairs are created. Some systems
support Crystal Eyes LCD stereo glasses; you have to invoke
SetStereoTypeToCrystalEyes() on the rendering window. Note: to
use stereo you also need to pass a stereo=1 keyword argument to
the constructor.
- Keypress e: exit the application.
- Keypress f: fly to the picked point
- Keypress p: perform a pick operation. The render window interactor
has an internal instance of vtkCellPicker that it uses to pick.
- Keypress r: reset the camera view along the current view
direction. Centers the actors and moves the camera so that all actors
are visible.
- Keypress s: modify the representation of all actors so that they
are surfaces.
- Keypress u: invoke the user-defined function. Typically, this
keypress will bring up an interactor that you can type commands in.
- Keypress w: modify the representation of all actors so that they
are wireframe.
"""
def __init__(self, parent=None):
super(VtkWindow, self).__init__(parent)
self.parent = parent
self.outline = False
self.vl = QtGui.QVBoxLayout()
self.vtkWidget = QVTKRenderWindowInteractor(self)
self.vl.addWidget(self.vtkWidget)
self.setLayout(self.vl)
self.renderer = vtk.vtkRenderer()
self.vtkwindow = self.vtkWidget.GetRenderWindow()
self.vtkwindow.AddRenderer(self.renderer)
self.interactor = self.vtkWidget.GetRenderWindow().GetInteractor()
self.renderer.GradientBackgroundOn()
self.renderer.SetBackground(1, 1, 1)
self.renderer.SetBackground2(0, 0, 1)
self.interactor.Initialize()
self.vtkWidget.AddObserver('KeyPressEvent', self.onKeyPress)
def onKeyPress(self, obj, event):
""""Define hotkeys. Partially overwriting base functionality of
QVTKRenderWindowInteractor.
"""
key = obj.GetKeyCode()
# logger.log.debug('Key code returned is %s' % (key))
if key == 'o':
self.toggleOutline()
elif key == 'p':
self.setDisplay('points')
elif key == 'w':
self.setDisplay('wireframe')
elif key == 's':
self.setDisplay('shaded')
elif key == 'f':
self.setShading('flat')
elif key == 'g':
self.setShading('gouraud')
elif key == 'W':
# FIXME
# FIXME add dialog for filename
# FIXME
self.writeStl('test_writing_STL.stl')
elif key == 'h':
self.makeScreenshot()
def readStl(self, name):
self.reader = vtk.vtkSTLReader()
self.reader.SetFileName(str(name))
logger.log.info('STL file <b><font color=%s>' % (LOGCOLOR) +
str(name) + '</b> loaded')
self.mapper = vtk.vtkPolyDataMapper()
self.mapper.SetInputConnection(self.reader.GetOutputPort())
self.actor = vtk.vtkActor()
self.actor.SetMapper(self.mapper)
self.actor.GetProperty().SetColor(0, 1, 0.2) # (R,G,B)
self.actor.GetProperty().SetLineWidth(2.0)
# create outline mapper
self.outl = vtk.vtkOutlineFilter()
self.outl.SetInputConnection(self.reader.GetOutputPort())
self.outlineMapper = vtk.vtkPolyDataMapper()
self.outlineMapper.SetInputConnection(self.outl.GetOutputPort())
# create outline actor
self.outlineActor = vtk.vtkActor()
self.outlineActor.SetMapper(self.outlineMapper)
self.renderer.AddActor(self.actor)
self.renderer.ResetCamera()
self.setDisplay('shaded')
self.setShading('gouraud')
# set tab to VTK window after loading an STL file
ntabs = self.parent.centralwidget.tabs.count()
self.parent.centralwidget.tabs.setCurrentIndex(ntabs - 1)
def writeStl(self, name):
# Write the stl file to disk
self.writer = vtk.vtkSTLWriter()
self.writer.SetFileName(name)
# self.writer.SetFileTypeToASCII()
self.writer.SetFileTypeToBinary()
self.writer.SetInputConnection(self.reader.GetOutputPort())
self.writer.Write()
def setShading(self, style):
if style.lower() == 'flat':
self.actor.GetProperty().SetInterpolationToFlat()
if style.lower() == 'gouraud':
self.actor.GetProperty().SetInterpolationToGouraud()
if style.lower() == 'phong':
self.actor.GetProperty().SetInterpolationToPhong()
def setDisplay(self, style):
if style.lower() == 'points':
self.actor.GetProperty().SetRepresentationToPoints()
if style.lower() == 'wireframe':
self.actor.GetProperty().SetRepresentationToWireframe()
if style.lower() == 'shaded':
self.actor.GetProperty().SetRepresentationToSurface()
def edgesOn(self):
self.actor.GetProperty().EdgeVisibilityOn()
def toggleOutline(self):
self.outline = not self.outline
if self.outline:
self.renderer.AddActor(self.outlineActor)
else:
self.renderer.RemoveActor(self.outlineActor)
# redraw everything
self.vtkWidget.Render()
def makeScreenshot(self):
w2if = vtk.vtkWindowToImageFilter()
w2if.SetInput(self.vtkwindow)
w2if.Update()
title = PyAero.__appname__ + ' - Message'
dlg = QtGui.QInputDialog(self)
dlg.resize(400, 200)
dlg.setWindowTitle(title)
dlg.setInputMode(QtGui.QInputDialog.TextInput)
dlg.setLabelText('Enter screenshot name (*.png):')
dlg.exec_()
if not dlg.result():
return
fname = str(dlg.textValue())
if not fname.endswith('.png'):
fname = fname + '.png'
writer = vtk.vtkPNGWriter()
writer.SetFileName(fname)
writer.SetInputData(w2if.GetOutput())
writer.Write()
text = 'Screenshot <b>%s</b> generated in current folder.' % (fname)
msgbox = QtGui.QMessageBox()
msgbox.setWindowTitle(title)
msgbox.setText(text)
msgbox.exec_()
logger.log.info(text)
