def FirstOpen(self):
#create annotated cube anchor actor
self.axesActor = vtk.vtkAnnotatedCubeActor()
self.axesActor.SetXPlusFaceText('Right')
self.axesActor.SetXMinusFaceText('Left')
self.axesActor.SetYMinusFaceText('Front')
self.axesActor.SetYPlusFaceText('Back')
self.axesActor.SetZMinusFaceText('Bot')
self.axesActor.SetZPlusFaceText('Top')
self.axesActor.GetTextEdgesProperty().SetColor(.8, .8, .8)
self.axesActor.GetZPlusFaceProperty().SetColor(.8, .8, .8)
self.axesActor.GetZMinusFaceProperty().SetColor(.8, .8, .8)
self.axesActor.GetXPlusFaceProperty().SetColor(.8, .8, .8)
self.axesActor.GetXMinusFaceProperty().SetColor(.8, .8, .8)
self.axesActor.GetYPlusFaceProperty().SetColor(.8, .8, .8)
self.axesActor.GetYMinusFaceProperty().SetColor(.8, .8, .8)
self.axesActor.GetTextEdgesProperty().SetLineWidth(2)
self.axesActor.GetCubeProperty().SetColor(.2, .2, .2)
self.axesActor.SetFaceTextScale(0.25)
self.axesActor.SetZFaceTextRotation(90)
#create orientation markers
self.axes = vtk.vtkOrientationMarkerWidget()
self.axes.SetOrientationMarker(self.axesActor)
self.axes.SetInteractor(self.ModelView)
self.axes.EnabledOn()
self.axes.InteractiveOff()
self.ui.Transform_groupbox.setEnabled(True)
def __init__(self, parent = None):
QtGui.QMainWindow.__init__(self, parent)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ren = vtk.vtkRenderer()
self.ui.vtkWidget.GetRenderWindow().AddRenderer(self.ren)
self.iren = self.ui.vtkWidget.GetRenderWindow().GetInteractor()
cube = vtk.vtkCubeSource()
cube.SetXLength(200)
cube.SetYLength(200)
cube.SetZLength(200)
cube.Update()
cm = vtk.vtkPolyDataMapper()
cm.SetInputConnection(cube.GetOutputPort())
ca = vtk.vtkActor()
ca.SetMapper(cm)
self.ren.AddActor(ca)
self.axesActor = vtk.vtkAnnotatedCubeActor();
self.axesActor.SetXPlusFaceText('R')
self.axesActor.SetXMinusFaceText('L')
self.axesActor.SetYMinusFaceText('H')
self.axesActor.SetYPlusFaceText('F')
self.axesActor.SetZMinusFaceText('P')
self.axesActor.SetZPlusFaceText('A')
self.axesActor.GetTextEdgesProperty().SetColor(1,1,0)
self.axesActor.GetTextEdgesProperty().SetLineWidth(2)
self.axesActor.GetCubeProperty().SetColor(0,0,1)
self.axes = vtk.vtkOrientationMarkerWidget()
self.axes.SetOrientationMarker(self.axesActor)
self.axes.SetInteractor(self.iren)
self.axes.EnabledOn()
self.axes.InteractiveOn()
self.ren.ResetCamera()
def __init__(self, renWinInteract):
# create axes
self._axes = vtk.vtkAxesActor()
self._axes.SetShaftTypeToCylinder()
self._axes.GetXAxisCaptionActor2D().GetCaptionTextProperty().SetColor(
1, 0, 0)
self._axes.GetXAxisCaptionActor2D().GetCaptionTextProperty(
).SetFontFamilyToArial()
self._axes.GetXAxisCaptionActor2D().GetCaptionTextProperty().ShadowOff(
)
self._axes.GetYAxisCaptionActor2D().GetCaptionTextProperty().SetColor(
0, 1, 0)
self._axes.GetYAxisCaptionActor2D().GetCaptionTextProperty(
).SetFontFamilyToArial()
self._axes.GetYAxisCaptionActor2D().GetCaptionTextProperty().ShadowOff(
)
self._axes.GetZAxisCaptionActor2D().GetCaptionTextProperty().SetColor(
0, 0, 1)
self._axes.GetZAxisCaptionActor2D().GetCaptionTextProperty(
).SetFontFamilyToArial()
self._axes.GetZAxisCaptionActor2D().GetCaptionTextProperty().ShadowOff(
)
# create axes marker
self._marker = vtk.vtkOrientationMarkerWidget()
self._marker.SetInteractor(renWinInteract)
self._marker.SetOrientationMarker(self._axes)
self._marker.SetViewport(0, 0, 0.25, 0.25)
self._marker.SetEnabled(0)
self._enabled = False
def _createAxes(self):
axesActor = vtk.vtkAxesActor()
self.axes = vtk.vtkOrientationMarkerWidget()
self.axes.SetOrientationMarker(axesActor)
self.axes.SetInteractor(self)
self.axes.EnabledOn()
self.axes.InteractiveOff()
def add_axes(self):
axes = vtk.vtkAxesActor()
self.marker = vtk.vtkOrientationMarkerWidget()
self.marker.SetInteractor(self.Interactor)
self.marker.SetOrientationMarker(axes)
self.marker.SetViewport(0.75, 0, 1, 0.25)
self.marker.SetEnabled(1)
def init_vtk_view(self):
# 在之前创建的view_widget上添加vtk控件
self.vtk_vertical_layout = QVBoxLayout(self.view_widget)
self.vtk_widget = QVTKRenderWindowInteractor(self.view_widget)
self.vtk_vertical_layout.addWidget(self.vtk_widget)
# 1.创建RenderWindow窗口
self.render_window = self.vtk_widget.GetRenderWindow()
# 2.创建render
self.renderer = vtk.vtkRenderer()
self.renderer.SetBackground(1.0, 1.0, 1.0) # 设置页面底部颜色值
self.renderer.SetBackground2(0.1, 0.2, 0.4) # 设置页面顶部颜色值
self.renderer.SetGradientBackground(1) # 开启渐变色背景设置
self.render_window.AddRenderer(self.renderer)
self.render_window.Render()
# 3.设置交互方式
self.iren = self.render_window.GetInteractor() # 获取交互器
self.style = vtk.vtkInteractorStyleTrackballCamera(
) # 交互器样式的一种，该样式下，用户是通过控制相机对物体作旋转、放大、缩小等操作
# self.style = MyInteractor(self)
self.style.SetDefaultRenderer(self.renderer)
self.iren.SetInteractorStyle(self.style)
# 拾取器
cellPicker = vtk.vtkCellPicker()
self.iren.SetPicker(cellPicker)
# 4.添加坐标轴(加self,血的教训）
axesActor = vtk.vtkAxesActor()
self.axes_widget = vtk.vtkOrientationMarkerWidget()
self.axes_widget.SetOrientationMarker(axesActor)
self.axes_widget.SetInteractor(self.iren)
self.axes_widget.EnabledOn()
self.axes_widget.InteractiveOff() # 坐标系是否可移动
# 5.添加Actor
self.original_actor = vtk.vtkActor()
def renderthis(self):
# open a window and create a renderer
ren = vtk.vtkRenderer()
self.widget.GetRenderWindow().AddRenderer(ren)
# to generate polygonal data for a cone.
cone = vtk.vtkConeSource()
cone.SetResolution(25)
# o take the polygonal data from the vtkConeSource and
# create a rendering for the renderer.
coneMapper = vtk.vtkPolyDataMapper()
coneMapper.SetInput(cone.GetOutput())
# create an actor for our scene
coneActor = vtk.vtkActor()
coneActor.SetMapper(coneMapper)
# Add actor
ren.AddActor(coneActor)
axes = vtk.vtkAxesActor()
self.marker = vtk.vtkOrientationMarkerWidget()
self.marker.SetInteractor(self.widget._Iren)
self.marker.SetOrientationMarker(axes)
self.marker.SetViewport(0.75, 0, 1, 0.25)
self.marker.SetEnabled(1)
ren.ResetCamera()
ren.ResetCameraClippingRange()
cam = ren.GetActiveCamera()
cam.Elevation(10)
cam.Azimuth(70)
self.isploted = True
def show(self):
axesActor = vtk.vtkAxesActor()
axes = vtk.vtkOrientationMarkerWidget()
axes.SetOrientationMarker(axesActor)
axes.SetInteractor(self.interactor)
axes.EnabledOn()
self.interactor.RemoveObservers('CharEvent')
self.balloonRep = vtk.vtkBalloonRepresentation()
self.balloonRep.SetBalloonLayoutToImageRight()
self.balloonRep = vtk.vtkBalloonRepresentation()
self.balloonRep.SetBalloonLayoutToImageRight()
self.balloonWidget = vtk.vtkBalloonWidget()
self.balloonWidget.SetInteractor(self.interactor)
self.balloonWidget.SetRepresentation(self.balloonRep)
self.balloonWidget.EnabledOn()
self.add_blocks()
self.add_points()
self.renwin.Render()
self.renwin.SetWindowName("blockMeshBuilder v0.0.1")
self.modeTextEdit("Block & Point")
self.interactor.Initialize()
self.interactor.Start()
def renderthis(self):
# open a window and create a renderer
self.ren = vtk.vtkRenderer()
self.widget.GetRenderWindow().AddRenderer(self.ren)
# Background colour lightgrey
self.ren.SetBackground(0.9,0.9,0.9)
#create a X,Y,Z axes to show 3d position:
# create axes variable and load vtk axes actor
self.axes = vtk.vtkAxesActor()
self.marker = vtk.vtkOrientationMarkerWidget()
# set the interactor. self.widget._Iren is inbuilt python mechanism for current renderer window.
self.marker.SetInteractor(self.widget._Iren )
self.marker.SetOrientationMarker(self.axes )
# set size and position of window (Xmin,Ymin,Xmax,Ymax)
self.marker.SetViewport(0.75,0,1,0.25)
#Allow user input
self.marker.SetEnabled(1)
# #settings for renderer window
self.ren.ResetCamera()
self.ren.ResetCameraClippingRange()
self.isplotted = True
self.p=0
def ShowOrientationCube(self):
cube = vtk.vtkAnnotatedCubeActor()
cube.GetXMinusFaceProperty().SetColor(1,0,0)
cube.GetXPlusFaceProperty().SetColor(1,0,0)
cube.GetYMinusFaceProperty().SetColor(0,1,0)
cube.GetYPlusFaceProperty().SetColor(0,1,0)
cube.GetZMinusFaceProperty().SetColor(0,0,1)
cube.GetZPlusFaceProperty().SetColor(0,0,1)
cube.GetTextEdgesProperty().SetColor(0,0,0)
# anatomic labelling
cube.SetXPlusFaceText ("A")
cube.SetXMinusFaceText("P")
cube.SetYPlusFaceText ("L")
cube.SetYMinusFaceText("R")
cube.SetZPlusFaceText ("S")
cube.SetZMinusFaceText("I")
axes = vtk.vtkAxesActor()
axes.SetShaftTypeToCylinder()
axes.SetTipTypeToCone()
axes.SetXAxisLabelText("X")
axes.SetYAxisLabelText("Y")
axes.SetZAxisLabelText("Z")
#axes.SetNormalizedLabelPosition(.5, .5, .5)
orientation_widget = vtk.vtkOrientationMarkerWidget()
orientation_widget.SetOrientationMarker(cube)
orientation_widget.SetViewport(0.85,0.85,1.0,1.0)
#orientation_widget.SetOrientationMarker(axes)
orientation_widget.SetInteractor(self.interactor)
orientation_widget.SetEnabled(1)
orientation_widget.On()
orientation_widget.InteractiveOff()
def add_widgets(self):
# axes
axes = vtk.vtkAxesActor()
self.marker_widget = vtk.vtkOrientationMarkerWidget()
self.marker_widget.SetInteractor(self.iren)
self.marker_widget.SetOrientationMarker(axes)
self.marker_widget.SetViewport(0.0, 0.0, 0.25, 0.25)
# scalar bar
self.scalarbar_actor = vtk.vtkScalarBarActor()
self.scalarbar_actor.SetLookupTable(self.lut)
self.scalarbar_widget = vtk.vtkScalarBarWidget()
self.scalarbar_widget.SetInteractor(self.iren)
self.scalarbar_widget.SetScalarBarActor(self.scalarbar_actor)
# contour slider
self.slider_rep = vtk.vtkSliderRepresentation2D()
self.slider_rep.SetTitleText("contour")
self.slider_rep.GetPoint1Coordinate(
).SetCoordinateSystemToNormalizedViewport()
self.slider_rep.GetPoint1Coordinate().SetValue(0.65, 0.1)
self.slider_rep.GetPoint2Coordinate(
).SetCoordinateSystemToNormalizedViewport()
self.slider_rep.GetPoint2Coordinate().SetValue(0.95, 0.1)
self.slider_widget = vtk.vtkSliderWidget()
self.slider_widget.SetInteractor(self.iren)
self.slider_widget.SetRepresentation(self.slider_rep)
self.slider_widget.SetAnimationModeToAnimate()
self.slider_widget.AddObserver(vtk.vtkCommand.InteractionEvent,
self.update_contour)
def _create_orientation_widget(self, view3d):
"""setup orientation widget stuff, the axes in the bottom"""
view3d._orientation_widget = vtk.vtkOrientationMarkerWidget()
view3d._axes_actor = vtk.vtkAxesActor()
view3d._orientation_widget.SetOrientationMarker(view3d._axes_actor)
view3d._orientation_widget.SetInteractor(view3d)
def __init__(self, vtk_filename=None, vtk_data=None):
"""
Initiate Viwer
Parameters
----------
vtk_filename : str
Input VTK filename
"""
QDialog.__init__(self)
self.initUI()
ren = vtk.vtkRenderer()
self.vtkWidget.GetRenderWindow().AddRenderer(ren)
iren = self.vtkWidget.GetRenderWindow().GetInteractor()
if vtk_filename is not None:
# VTK file
reader = vtk.vtkUnstructuredGridReader()
reader.SetFileName(vtk_filename)
reader.Update()
vtkdata = reader.GetOutput()
if vtk_data is not None:
vtkdata = vtk_data
# VTK surface
surface = vtk.vtkDataSetSurfaceFilter()
surface.SetInput(vtkdata)
surface.Update()
mapper = vtk.vtkDataSetMapper()
mapper.SetInput(surface.GetOutput())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.GetProperty().EdgeVisibilityOff()
# actor.GetProperty().SetEdgeColor(1,1,1)
# actor.GetProperty().SetLineWidth(0.1)
ren.AddActor(actor)
# annot. cube
axesActor = vtk.vtkAnnotatedCubeActor()
axesActor.SetXPlusFaceText('R')
axesActor.SetXMinusFaceText('L')
axesActor.SetYMinusFaceText('H')
axesActor.SetYPlusFaceText('F')
axesActor.SetZMinusFaceText('A')
axesActor.SetZPlusFaceText('P')
axesActor.GetTextEdgesProperty().SetColor(1, 1, 0)
axesActor.GetCubeProperty().SetColor(0, 0, 1)
self.axes = vtk.vtkOrientationMarkerWidget()
self.axes.SetOrientationMarker(axesActor)
self.axes.SetInteractor(iren)
self.axes.EnabledOn()
self.axes.InteractiveOn()
ren.ResetCamera()
iren.Initialize()
def __init__(self, parent=None):
super(QVolumeViewWidget, self).__init__(parent)
# set up vtk pipeline and create vtkWidget
self.renw = vtk.vtkRenderWindow()
self.iren = vtk.vtkGenericRenderWindowInteractor()
self.iren.SetRenderWindow(self.renw)
kw = {'rw': self.renw, 'iren': self.iren}
self.vtkWidget = QVTKRenderWindowInteractor(parent, **kw)
self.MainLayout = QVBoxLayout()
self.MainLayout.addWidget(self.vtkWidget)
self.setLayout(self.MainLayout)
# self.vtkWidget = QVTKRenderWindowInteractor()
self.ren = vtk.vtkRenderer()
self.vtkWidget.GetRenderWindow().AddRenderer(self.ren)
# add the orientation marker widget
self.axes = vtk.vtkAxesActor()
self.widget = vtk.vtkOrientationMarkerWidget()
xyzLabels = ['R', 'A', 'S']
self.axes.SetXAxisLabelText(xyzLabels[0])
self.axes.SetYAxisLabelText(xyzLabels[1])
self.axes.SetZAxisLabelText(xyzLabels[2])
self.widget.SetOrientationMarker(self.axes)
self.widget.SetInteractor(self.vtkWidget)
self.widget.SetViewport(0.8, 0.0, 1, 0.3)
self.widget.SetEnabled(True)
self.widget.InteractiveOn()
self.picker = vtk.vtkVolumePicker()
def loadTestVTKWindow(parentUI):
cube = vtk.vtkCubeSource()
cube.SetXLength(200)
cube.SetYLength(200)
cube.SetZLength(200)
cube.Update()
cm = vtk.vtkPolyDataMapper()
cm.SetInputConnection(cube.GetOutputPort())
ca = vtk.vtkActor()
ca.SetMapper(cm)
parentUI.vtkInstances[-1].ren.AddActor(ca)
axesActor = vtk.vtkAnnotatedCubeActor()
axesActor.SetXPlusFaceText('R')
axesActor.SetXMinusFaceText('L')
axesActor.SetYMinusFaceText('H')
axesActor.SetYPlusFaceText('F')
axesActor.SetZMinusFaceText('P')
axesActor.SetZPlusFaceText('A')
axesActor.GetTextEdgesProperty().SetColor(1, 1, 0)
axesActor.GetTextEdgesProperty().SetLineWidth(2)
axesActor.GetCubeProperty().SetColor(0, 0, 1)
axes = vtk.vtkOrientationMarkerWidget()
axes.SetOrientationMarker(axesActor)
axes.SetInteractor(parentUI.vtkInstances[-1].iren)
parentUI.vtkInstances[-1].ren.ResetCamera()
parentUI.vtkInstances[-1].iren.Start()
def adicionaeixos(self):
axes = vtk.vtkAxesActor()
self.marker = vtk.vtkOrientationMarkerWidget()
self.marker.SetInteractor( self.Interactor )
self.marker.SetOrientationMarker( axes )
self.marker.SetViewport(0.75,0,1,0.25)
self.marker.SetEnabled(1)
def addIcon(iconActor, pos=3, size=0.08):
vp = settings.plotter_instance
if not vp.renderer:
colors.printc(
"~lightningWarning: Use addIcon() after first rendering the scene.",
c=3)
save_int = vp.interactive
vp.show(interactive=0)
vp.interactive = save_int
widget = vtk.vtkOrientationMarkerWidget()
widget.SetOrientationMarker(iconActor)
widget.SetInteractor(vp.interactor)
if utils.isSequence(pos):
widget.SetViewport(pos[0] - size, pos[1] - size, pos[0] + size,
pos[1] + size)
else:
if pos < 2:
widget.SetViewport(0, 1 - 2 * size, size * 2, 1)
elif pos == 2:
widget.SetViewport(1 - 2 * size, 1 - 2 * size, 1, 1)
elif pos == 3:
widget.SetViewport(0, 0, size * 2, size * 2)
elif pos == 4:
widget.SetViewport(1 - 2 * size, 0, 1, size * 2)
widget.EnabledOn()
widget.InteractiveOff()
vp.widgets.append(widget)
if iconActor in vp.actors:
vp.actors.remove(iconActor)
return widget
def show_structure(self):
self.structure = intialize_structure(self.blueprint)
divided_structure = self.divide_structure()
building_plan = []
for division in divided_structure:
building_plan.append(np.array(spiral_sort(division)).flatten())
self.structure_actors = setup_structure_display(
np.array(building_plan), self.NUM_ROBOTS)
self.pipeline.iren.AddObserver('TimerEvent', self.execute)
# if display_path:
# self.pipeline.add_actor(self._display_path())
xyzLabels = ['X', 'Y', 'Z']
scale = [1.0, 1.0, 1.0]
axes = MakeAxesActor(scale, xyzLabels)
om2 = vtk.vtkOrientationMarkerWidget()
om2.SetOrientationMarker(axes)
# Position lower right in the viewport.
om2.SetViewport(0.8, 0, 1.0, 0.2)
om2.SetInteractor(self.pipeline.iren)
om2.EnabledOn()
om2.InteractiveOn()
self.pipeline.animate()
def renderthis(self):
# open a window and create a renderer
ren = vtk.vtkRenderer()
self.widget.GetRenderWindow().AddRenderer(ren)
# o take the polygonal data from the vtkConeSource and
# create a rendering for the renderer.
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(self.reader.GetOutputPort())
#SetInputConnection(reader.GetOutputPort())
# create an actor for our scene
actor = vtk.vtkActor()
actor.SetMapper(mapper)
# Add actor
ren.AddActor(actor)
axes = vtk.vtkAxesActor()
self.marker = vtk.vtkOrientationMarkerWidget()
self.marker.SetInteractor( self.widget._Iren )
self.marker.SetOrientationMarker( axes )
self.marker.SetViewport(0.75,0,1,0.25)
self.marker.SetEnabled(1)
ren.ResetCamera()
ren.ResetCameraClippingRange()
cam = ren.GetActiveCamera()
cam.Elevation(10)
cam.Azimuth(70)
self.isploted = True
def AddAxes(self):
""" Add axes actor at origin """
axes = vtk.vtkAxesActor()
self.marker = vtk.vtkOrientationMarkerWidget()
self.marker.SetInteractor(self.iren)
self.marker.SetOrientationMarker(axes)
self.marker.SetEnabled(1)
def Init():
global C,R,RW,RWI,OMW,grid_actor
C=vtk.vtkCamera()
R=vtk.vtkRenderer()
R.SetActiveCamera(C)
#R.AddActor(A)
RW=vtk.vtkGenericOpenGLRenderWindow()
RW.AddRenderer(R)
RW.SetIsDirect(True)
RW.SetSupportsOpenGL(True)
RWI = vtk.vtkGenericRenderWindowInteractor()
RWI.SetRenderWindow(RW)
AA = vtk.vtkAxesActor()
OMW = vtk.vtkOrientationMarkerWidget()
OMW.SetOrientationMarker( AA );
OMW.SetInteractor( RWI );
OMW.SetEnabled( 1 );
OMW.SetInteractive(0);
Lights = []
for l in bpy.context.user_preferences.system.solid_lights:
L = vtk.vtkLight()
L.SetLightTypeToCameraLight()
L.SetDiffuseColor( l.diffuse_color )
L.SetSpecularColor( l.specular_color )
L.SetPosition( l.direction )
R.AddLight(L)
Lights.append(L)
grid_actor = None
return R
def attach_pos(self):
pos = self._pos
rad = self._rad
if pos is not None and rad is not None:
positions_vtk = numpy_support.numpy_to_vtk(
num_array=pos.ravel(), deep=True, array_type=vtk.VTK_FLOAT)
positions_vtk.SetName("positions")
radius_vtk = numpy_support.numpy_to_vtk(num_array=rad.ravel(),
deep=True,
array_type=vtk.VTK_FLOAT)
radius_vtk.SetName("radius")
sphere = vtk.vtkSphereSource()
sphere.SetRadius(1.0)
ballGlyph = vtk.vtkGlyph3D()
if vtk.VTK_MAJOR_VERSION <= 5:
ballGlyph.SetSource(sphere.GetOutput())
else:
ballGlyph.SetSourceConnection(sphere.GetOutputPort())
polydata = vtk.vtkPolyData()
polydata.SetPoints(self._points)
polydata.GetPointData().AddArray(radius_vtk)
polydata.GetPointData().SetActiveScalars(
"radius") # this scales the source (sphere) radius (1.0)
ballGlyph.SetInputData(polydata)
#ballGlyph.SetScaleModeToDataScalingOn()
mapper = vtk.vtkPolyDataMapper()
if vtk.VTK_MAJOR_VERSION <= 5:
mapper.SetInput(ballGlyph.GetOutput())
else:
mapper.SetInputConnection(ballGlyph.GetOutputPort())
# Set colors depending on the color transfer functions
# mapper.SetLookupTable(self.colorTransferFunction)
# actor
ballActor = vtk.vtkActor()
ballActor.GetProperty().SetColor(0, 0, 1)
ballActor.SetMapper(mapper)
#self._ren.AddActor(ballActor)
self._marker2 = vtk.vtkOrientationMarkerWidget()
self._marker2.SetInteractor(self.widget._Iren)
self._marker2.SetOrientationMarker(ballActor)
self._marker2.SetViewport(0.75, 0, 1, 0.25)
self._marker2.SetEnabled(1)
else:
print(
"No particles found. Make sure the particles loaded have positions and radii."
)
def Start(self):
## create VTK interactor (this is the most important object)
# this need a Tkinter GUI object (render_frame) and a VTK render window (renWindow) to work
self.renWinInteractor = vtkTkRenderWindowInteractor(self.render_frame,
rw=self.renWindow,
width=600,
height=600)
self.renWinInteractor.SetInteractorStyle(
vtk.vtkInteractorStyleTrackballCamera(
)) # set the trackball behaviour
# we can add additional configurations for this interactor here
axes = vtk.vtkAxesActor()
marker = vtk.vtkOrientationMarkerWidget()
marker.SetOutlineColor(0.93, 0.57, 0.13)
marker.SetOrientationMarker(axes)
marker.SetInteractor(self.renWinInteractor)
marker.SetViewport(0.0, 0.0, 0.4, 0.4)
marker.SetEnabled(1)
marker.InteractiveOff()
## initialize the interactor and align it to the frame
self.renWinInteractor.Initialize()
self.renWinInteractor.pack(side='top', fill='both', expand=1)
self.renWindow.Render()
self.renWinInteractor.Start()
## main loop
self.root.mainloop()
def initialize(self):
self.initializeProtocols()
global renderer, renderWindow, renderWindowInteractor, cone, mapper, actor
# Update authentication key to use
self.updateSecret(Backend.authKey)
# Create default pipeline (Only once for all the session)
if not Backend.view:
# VTK specific code
renderer = vtk.vtkRenderer()
self.setSharedObject("renderer", renderer)
renderer.SetBackground(0.4, 0.4, 0.4)
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer)
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
self.setSharedObject("test", renderWindowInteractor)
renderWindowInteractor.SetRenderWindow(renderWindow)
renderWindowInteractor.GetInteractorStyle().SetCurrentStyleToTrackballCamera()
widget = vtk.vtkOrientationMarkerWidget()
widget.SetInteractor( renderWindowInteractor )
self.setSharedObject("marker", widget)
renderer.ResetCamera()
print("Backend.debug ", Backend.debug)
renderWindow.SetOffScreenRendering(not Backend.debug)
renderWindow.Render()
# VTK Web application specific
Backend.view = renderWindow
self.getApplication().GetObjectIdMap().SetActiveObject("VIEW", renderWindow)
def StartInteractor(self):
print "Starting interactor"
self.renderer=vtk.vtkRenderer()
self.widget.GetRenderWindow().AddRenderer(self.renderer)
camera=self.renderer.GetActiveCamera()
camera.SetFocalPoint(0.,0.,0.)
camera.SetPosition(50.,0.,0.)
camera.Roll(-90)
mouse=vtk.vtkInteractorStyleTrackballCamera()
self.widget.SetInteractorStyle(mouse)
#create some axes to indicate the orientation of the galaxy
axes = vtk.vtkAxesActor()
self.axisw=vtk.vtkOrientationMarkerWidget()
self.axisw.SetOutlineColor( 0.9300, 0.5700, 0.1300 );
self.axisw.SetOrientationMarker( axes );
self.axisw.SetInteractor( self.widget._Iren );
self.axisw.SetViewport( 0.0, 0.0, 0.3, 0.3 );
self.axisw.SetEnabled( 1 );
self.axisw.InteractiveOn();
self.widget.GetRenderWindow().Render()
def ShowOrientationCube(self):
cube = vtk.vtkAnnotatedCubeActor()
cube.GetXMinusFaceProperty().SetColor(1,0,0)
cube.GetXPlusFaceProperty().SetColor(1,0,0)
cube.GetYMinusFaceProperty().SetColor(0,1,0)
cube.GetYPlusFaceProperty().SetColor(0,1,0)
cube.GetZMinusFaceProperty().SetColor(0,0,1)
cube.GetZPlusFaceProperty().SetColor(0,0,1)
cube.GetTextEdgesProperty().SetColor(0,0,0)
# anatomic labelling
cube.SetXPlusFaceText ("A")
cube.SetXMinusFaceText("P")
cube.SetYPlusFaceText ("L")
cube.SetYMinusFaceText("R")
cube.SetZPlusFaceText ("S")
cube.SetZMinusFaceText("I")
axes = vtk.vtkAxesActor()
axes.SetShaftTypeToCylinder()
axes.SetTipTypeToCone()
axes.SetXAxisLabelText("X")
axes.SetYAxisLabelText("Y")
axes.SetZAxisLabelText("Z")
#axes.SetNormalizedLabelPosition(.5, .5, .5)
orientation_widget = vtk.vtkOrientationMarkerWidget()
orientation_widget.SetOrientationMarker(cube)
orientation_widget.SetViewport(0.85,0.85,1.0,1.0)
#orientation_widget.SetOrientationMarker(axes)
orientation_widget.SetInteractor(self.interactor)
orientation_widget.SetEnabled(1)
orientation_widget.On()
orientation_widget.InteractiveOff()
def renderthis(self, data):
ren = vtk.vtkRenderer()
self.ren = ren
self.p1.widget.GetRenderWindow().AddRenderer(ren)
camera = vtk.vtkCamera()
camera.SetPosition(0, 0, 0)
camera.SetFocalPoint(0.255739, 0.207345, 0.439719)
camera.ParallelProjectionOn()
ball = vtk.vtkSphereSource()
ball.SetRadius(0.1)
ball.SetThetaResolution(10)
ball.SetPhiResolution(10)
ballGlyph = vtk.vtkGlyph3D()
self.bglyth = ballGlyph
if self.vtkversion() == 6:
ballGlyph.SetInputData(data)
elif self.vtkversion() == 5:
ballGlyph.SetInput(data)
else:
ballGlyph.SetInputData(data)
ballGlyph.SetSourceConnection(ball.GetOutputPort())
# ballGlyph.SetScaleModeToScaleByScalar()
# ballGlyph.SetColorModeToColorByScalar()
# ballGlyph.SetScaleFactor(1.0)
colorTransferFunction = vtk.vtkColorTransferFunction()
colorTransferFunction.AddRGBPoint(255, 45, 45, 1.0)
ballMapper = vtk.vtkPolyDataMapper()
ballMapper.SetInputConnection(ballGlyph.GetOutputPort())
ballMapper.ScalarVisibilityOff()
ballMapper.SetLookupTable(colorTransferFunction)
ballActor = vtk.vtkActor()
ballActor.SetMapper(ballMapper)
ballActor.GetProperty().SetColor(1, 1, 1)
ren.AddActor(ballActor)
ren.SetActiveCamera(camera)
ren.SetBackground(0.03, 0.1, 0.2)
######################################AXES##################################################
axes = vtk.vtkAxesActor()
self.marker = vtk.vtkOrientationMarkerWidget()
self.marker.SetInteractor(self.p1.widget)
self.marker.SetOrientationMarker(axes)
self.marker.SetViewport(0.75, 0, 1, 0.25)
self.marker.SetEnabled(1)
############################################################################################
pointPicker = vtk.vtkPropPicker()
# pointer=vtk.vtkSmartPointer.pointPicker
# pointPicker.SetTolerance(100)
self.p1.widget.SetPicker(pointPicker)
ren.ResetCamera()
ren.ResetCameraClippingRange()
cam = ren.GetActiveCamera()
cam.Elevation(0)
cam.Azimuth(0)
self.isploted = True
print(self.isploted)
def PlotGrids_wFEM(grids):
""" Plots CFD structured grids with a single FEM """
N = len(grids)
HSV_tuples = [(x*1.0/N, 0.5, 0.5) for x in range(N)]
RGB_tuples = map(lambda x: colorsys.hsv_to_rgb(*x), HSV_tuples)
actors = []
for i in range(len(grids)):
# Create mapper
mapper = vtk.vtkDataSetMapper()
if vtk.vtkVersion().GetVTKMajorVersion() >5:
mapper.SetInput(grids[i])
else:
mapper.SetInputData(grids[i])
# Create actor
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.GetProperty().EdgeVisibilityOn()
if i != 0:
actor.GetProperty().SetRepresentationToWireframe()
actor.GetProperty().SetColor(RGB_tuples[i])
actor.GetProperty().LightingOff()
actors.append(actor)
# Add FEM Actor to renderer window
ren = vtk.vtkRenderer()
# ren.SetBackground(0.3, 0.3, 0.3)
ren.SetBackground(0.8, 0.8, 0.8)
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# Allow user to interact
istyle = vtk.vtkInteractorStyleTrackballCamera()
iren.SetInteractorStyle(istyle)
# Add actor
for actor in actors:
ren.AddActor(actor)
axes = vtk.vtkAxesActor()
widget = vtk.vtkOrientationMarkerWidget()
# widget.SetOutlineColor( 0.9300, 0.5700, 0.1300 )
widget.SetOrientationMarker( axes )
widget.SetInteractor( iren )
widget.SetViewport( 0.0, 0.0, 0.4, 0.4 )
widget.SetEnabled( 1 )
widget.InteractiveOn()
# Render
iren.Initialize()
renWin.Render()
iren.Start()
def _setupOrientationMarker(self):
axes = vtk.vtkAxesActor()
self._ori_marker = vtk.vtkOrientationMarkerWidget()
self._ori_marker.SetOrientationMarker(axes)
self._ori_marker.SetViewport(0.8, 0, 1.0, 0.2)
self._ori_marker.SetInteractor(self._vtk_interactor)
self._ori_marker.SetEnabled(1)
self._ori_marker.SetInteractive(False)
def vtk_visualize(point_list, view_thresh):
point_cloud = VtkPointCloud()
x_thresh = view_thresh[0]
y_thresh = view_thresh[1]
z_thresh = view_thresh[2]
for i in range(len(point_list)):
point_coords = point_list[i]
if (point_coords[0] > x_thresh[0]) and (point_coords[0] < x_thresh[1]) and \
(point_coords[1] > y_thresh[0]) and (point_coords[1] < y_thresh[1]) and \
(point_coords[2] > z_thresh[0]) and (point_coords[2] < z_thresh[1]):
color_num = 0.7
else:
color_num = -1
point_cloud.addPoint(point_list[i], color_num)
# Add the velodyne plane
for x in np.linspace(-4, 4, 100):
for y in np.linspace(0, 2, 25):
tmp_coords = np.array([x, 0, y])
point_cloud.addPoint(tmp_coords, 1)
# Add the floor plane
plane_center = (-4, -4, -0.55)
normal = (0, 0, 1)
point1 = ([-4, 10, -0.55])
point2 = ([4, -4, -0.55])
point_cloud.addPlane(plane_center, normal, point1, point2)
# Renderer
renderer = vtk.vtkRenderer()
renderer.AddActor(point_cloud.point_vtkActor)
renderer.AddActor(point_cloud.plane_vtkActor)
renderer.SetBackground(0.0, 0.0, 0.0)
renderer.ResetCamera()
# Render Window
render_window = vtk.vtkRenderWindow()
render_window.AddRenderer(renderer)
# Interactor
render_window_interactor = vtk.vtkRenderWindowInteractor()
render_window_interactor.SetInteractorStyle(vtk.vtkInteractorStyleTrackballCamera())
render_window_interactor.SetRenderWindow(render_window)
'''Add camera coordinates'''
axes = vtk.vtkAxesActor()
widget = vtk.vtkOrientationMarkerWidget()
widget.SetOutlineColor(0.9300, 0.5700, 0.1300)
widget.SetOrientationMarker(axes)
widget.SetInteractor(render_window_interactor)
widget.SetViewport(0.0, 0.0, 0.4, 0.4)
widget.SetEnabled(1)
widget.InteractiveOn()
render_window.Render()
render_window_interactor.Start()
def vtk_visualize(point_list, view_thresh):
point_cloud = VtkPointCloud()
x_thresh = view_thresh[0]
y_thresh = view_thresh[1]
z_thresh = view_thresh[2]
for i in range(len(point_list)):
point_coords = point_list[i]
if (point_coords[0] > x_thresh[0]) and (point_coords[0] < x_thresh[1]) and \
(point_coords[1] > y_thresh[0]) and (point_coords[1] < y_thresh[1]) and \
(point_coords[2] > z_thresh[0]) and (point_coords[2] < z_thresh[1]):
color_num = 0.7
else:
color_num = -1
point_cloud.addPoint(point_list[i], color_num)
# Add the velodyne plane
for x in np.linspace(-4, 4, 100):
for y in np.linspace(0, 2, 25):
tmp_coords = np.array([x, 0, y])
point_cloud.addPoint(tmp_coords, 1)
# Add the floor plane
plane_center = (-4, -4, -0.55)
normal = (0, 0, 1)
point1 = ([-4, 10, -0.55])
point2 = ([4, -4, -0.55])
point_cloud.addPlane(plane_center, normal, point1, point2)
# Renderer
renderer = vtk.vtkRenderer()
renderer.AddActor(point_cloud.point_vtkActor)
renderer.AddActor(point_cloud.plane_vtkActor)
renderer.SetBackground(0.0, 0.0, 0.0)
renderer.ResetCamera()
# Render Window
render_window = vtk.vtkRenderWindow()
render_window.AddRenderer(renderer)
# Interactor
render_window_interactor = vtk.vtkRenderWindowInteractor()
render_window_interactor.SetInteractorStyle(
vtk.vtkInteractorStyleTrackballCamera())
render_window_interactor.SetRenderWindow(render_window)
'''Add camera coordinates'''
axes = vtk.vtkAxesActor()
widget = vtk.vtkOrientationMarkerWidget()
widget.SetOutlineColor(0.9300, 0.5700, 0.1300)
widget.SetOrientationMarker(axes)
widget.SetInteractor(render_window_interactor)
widget.SetViewport(0.0, 0.0, 0.4, 0.4)
widget.SetEnabled(1)
widget.InteractiveOn()
render_window.Render()
render_window_interactor.Start()
def PlotGrids(grids):
""" Plots CFD structured grids """
N = len(grids)
HSV_tuples = [(x * 1.0 / N, 0.5, 0.5) for x in range(N)]
RGB_tuples = [colorsys.hsv_to_rgb(*x) for x in HSV_tuples]
actors = []
for i in range(len(grids)):
# Create mapper
mapper = vtk.vtkDataSetMapper()
if vtk.vtkVersion().GetVTKMajorVersion() > 5:
mapper.SetInput(grids[i])
else:
mapper.SetInputData(grids[i])
# Create actor
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.GetProperty().SetRepresentationToWireframe()
actor.GetProperty().EdgeVisibilityOn()
actor.GetProperty().SetColor(RGB_tuples[i])
actor.GetProperty().LightingOff()
actors.append(actor)
# Add FEM Actor to renderer window
ren = vtk.vtkRenderer()
ren.SetBackground(0.8, 0.8, 0.8)
# ren.SetBackground(1, 1, 1)
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# Allow user to interact
istyle = vtk.vtkInteractorStyleTrackballCamera()
iren.SetInteractorStyle(istyle)
# Add actor
for actor in actors:
ren.AddActor(actor)
# Add axes
axes = vtk.vtkAxesActor()
widget = vtk.vtkOrientationMarkerWidget()
widget.SetOrientationMarker(axes)
widget.SetInteractor(iren)
widget.SetViewport(0.0, 0.0, 0.4, 0.4)
widget.SetEnabled(1)
widget.InteractiveOn()
# Render
iren.Initialize()
renWin.Render()
iren.Start()
def AddAxes(self):
""" Add axes widget """
axes = vtk.vtkAxesActor()
widget = vtk.vtkOrientationMarkerWidget()
widget.SetOrientationMarker(axes)
widget.SetInteractor(self.iren)
widget.SetViewport(0.0, 0.0, 0.4, 0.4)
widget.SetEnabled(1)
widget.InteractiveOn()
def showAxes():
axes = vtk.vtkAxesActor()
widget = vtk.vtkOrientationMarkerWidget()
widget.SetOrientationMarker(axes)
widget.SetInteractor(iren)
widget.SetEnabled(1)
widget.InteractiveOn()
return(axes, widget)
def _create_orientation_widget(self, view3d):
"""setup orientation widget stuff, the axes in the bottom
"""
view3d._orientation_widget = vtk.vtkOrientationMarkerWidget()
view3d._axes_actor = vtk.vtkAxesActor()
view3d._orientation_widget.SetOrientationMarker(view3d._axes_actor)
view3d._orientation_widget.SetInteractor(view3d)
def addAxisWidget(self):
axes = vtk.vtkAxesActor()
self.axisWidget = vtk.vtkOrientationMarkerWidget()
self.axisWidget.SetOutlineColor(0.9, 0.5, 0.1)
self.axisWidget.SetOrientationMarker(axes)
self.axisWidget.SetInteractor(self.interactor)
#self.axisWidget.SetViewport(0,0,0.4,0.4)
self.axisWidget.EnabledOn()
self.axisWidget.InteractiveOff()
def main():
colors = vtk.vtkNamedColors()
# colors.SetColor('bkg', [0.2, 0.3, 0.7, 1.0])
# create a rendering window and renderer
ren = vtk.vtkRenderer()
ren_win = vtk.vtkRenderWindow()
ren_win.AddRenderer(ren)
ren_win.SetWindowName('OrientationMarkerWidget')
# create a renderwindowinteractor
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(ren_win)
cube = vtk.vtkCubeSource()
cube.SetXLength(200)
cube.SetYLength(200)
cube.SetZLength(200)
cube.Update()
cm = vtk.vtkPolyDataMapper()
cm.SetInputConnection(cube.GetOutputPort())
ca = vtk.vtkActor()
ca.SetMapper(cm)
ca.GetProperty().SetColor(colors.GetColor3d("BurlyWood"))
ca.GetProperty().EdgeVisibilityOn()
ca.GetProperty().SetEdgeColor(colors.GetColor3d("Red"))
# assign actor to the renderer
ren.AddActor(ca)
ren.SetBackground(colors.GetColor3d('CornflowerBlue'))
axes_actor = vtk.vtkAnnotatedCubeActor()
axes_actor.SetXPlusFaceText('L')
axes_actor.SetXMinusFaceText('R')
axes_actor.SetYMinusFaceText('I')
axes_actor.SetYPlusFaceText('S')
axes_actor.SetZMinusFaceText('P')
axes_actor.SetZPlusFaceText('A')
axes_actor.GetTextEdgesProperty().SetColor(colors.GetColor3d("Yellow"))
axes_actor.GetTextEdgesProperty().SetLineWidth(2)
axes_actor.GetCubeProperty().SetColor(colors.GetColor3d("Blue"))
axes = vtk.vtkOrientationMarkerWidget()
axes.SetOrientationMarker(axes_actor)
axes.SetInteractor(iren)
axes.EnabledOn()
axes.InteractiveOn()
ren.ResetCamera()
# enable user interface interactor
iren.Initialize()
ren_win.Render()
ren.GetActiveCamera().Azimuth(45)
ren.GetActiveCamera().Elevation(30)
ren_win.Render()
iren.Start()
def create_corner_axis(self):
"""creates the axes that sits in the corner"""
if not self.gui.run_vtk:
return
axes = vtk.vtkAxesActor()
self.gui.corner_axis = vtk.vtkOrientationMarkerWidget()
self.gui.corner_axis.SetOrientationMarker(axes)
self.gui.corner_axis.SetInteractor(self.vtk_interactor)
self.gui.corner_axis.SetEnabled(1)
self.gui.corner_axis.InteractiveOff()
def add_axisWidget(self):
axes = vtk.vtkAxesActor()
axisWidget = vtk.vtkOrientationMarkerWidget()
axisWidget.SetOutlineColor(0.9,0.5,0.1)
axisWidget.SetOrientationMarker(axes)
iren = self.interactor.GetRenderWindow().GetInteractor()
axisWidget.SetInteractor(iren)
axisWidget.SetViewport(0,0,0.4,0.4)
axisWidget.EnabledOn()
axisWidget.InteractiveOn()
def attach_pos(self):
pos = self._pos
rad = self._rad
if pos is not None and rad is not None:
positions_vtk = numpy_support.numpy_to_vtk(num_array=pos.ravel(), deep=True, array_type=vtk.VTK_FLOAT)
positions_vtk.SetName("positions")
radius_vtk = numpy_support.numpy_to_vtk(num_array=rad.ravel(), deep=True, array_type=vtk.VTK_FLOAT)
radius_vtk.SetName("radius")
sphere = vtk.vtkSphereSource()
sphere.SetRadius(1.0)
ballGlyph = vtk.vtkGlyph3D()
if vtk.VTK_MAJOR_VERSION <= 5:
ballGlyph.SetSource(sphere.GetOutput())
else:
ballGlyph.SetSourceConnection(sphere.GetOutputPort())
polydata = vtk.vtkPolyData()
polydata.SetPoints(self._points)
polydata.GetPointData().AddArray(radius_vtk)
polydata.GetPointData().SetActiveScalars("radius") # this scales the source (sphere) radius (1.0)
ballGlyph.SetInputData(polydata)
#ballGlyph.SetScaleModeToDataScalingOn()
mapper = vtk.vtkPolyDataMapper()
if vtk.VTK_MAJOR_VERSION <= 5:
mapper.SetInput(ballGlyph.GetOutput())
else:
mapper.SetInputConnection(ballGlyph.GetOutputPort())
# Set colors depending on the color transfer functions
# mapper.SetLookupTable(self.colorTransferFunction)
# actor
ballActor = vtk.vtkActor()
ballActor.GetProperty().SetColor(0,0,1)
ballActor.SetMapper(mapper)
#self._ren.AddActor(ballActor)
self._marker2 = vtk.vtkOrientationMarkerWidget()
self._marker2.SetInteractor( self.widget._Iren )
self._marker2.SetOrientationMarker( ballActor )
self._marker2.SetViewport(0.75,0,1,0.25)
self._marker2.SetEnabled(1)
else:
print("No particles found. Make sure the particles loaded have positions and radii.")
def createCubeOrientation(self):
self._cubeOrientationActor = vtk.vtkAnnotatedCubeActor()
self._cubeOrientationActor.SetXPlusFaceText(QtGui.QApplication.translate("ImagePlane",
"L",
None,
QtGui.QApplication.UnicodeUTF8))
self._cubeOrientationActor.SetXMinusFaceText(QtGui.QApplication.translate("ImagePlane",
"R",
None,
QtGui.QApplication.UnicodeUTF8))
self._cubeOrientationActor.SetYPlusFaceText(QtGui.QApplication.translate("ImagePlane",
"P",
None,
QtGui.QApplication.UnicodeUTF8))
self._cubeOrientationActor.SetYMinusFaceText(QtGui.QApplication.translate("ImagePlane",
"A",
None,
QtGui.QApplication.UnicodeUTF8))
self._cubeOrientationActor.SetZPlusFaceText(QtGui.QApplication.translate("ImagePlane",
"S",
None,
QtGui.QApplication.UnicodeUTF8))
self._cubeOrientationActor.SetZMinusFaceText(QtGui.QApplication.translate("ImagePlane",
"I",
None,
QtGui.QApplication.UnicodeUTF8))
self._cubeOrientationActor.SetZFaceTextRotation(90)
self._cubeOrientationActor.SetFaceTextScale(0.67)
property = self._cubeOrientationActor.GetXPlusFaceProperty()
property.SetColor(0, 0, 1)
property = self._cubeOrientationActor.GetXMinusFaceProperty()
property.SetColor(0, 0, 1)
property = self._cubeOrientationActor.GetYPlusFaceProperty()
property.SetColor(0, 1, 0)
property = self._cubeOrientationActor.GetYMinusFaceProperty()
property.SetColor(0, 1, 0)
property = self._cubeOrientationActor.GetZPlusFaceProperty()
property.SetColor(1, 0, 0)
property = self._cubeOrientationActor.GetZMinusFaceProperty()
property.SetColor(1, 0, 0)
self._cubeOrientationActor.SetTextEdgesVisibility(1)
self._cubeOrientationActor.SetCubeVisibility(1)
self._cubeOrientationActor.SetFaceTextVisibility(1)
self.orientationWidget = vtk.vtkOrientationMarkerWidget()
self.orientationWidget.SetInteractor(self._interactor)
self.orientationWidget.SetViewport(0.85, 0.85, 1, 1)
self.orientationWidget.SetOrientationMarker(self._cubeOrientationActor)
self.orientationWidget.SetEnabled(1)
self.orientationWidget.InteractiveOff()
self.orientationWidget.On();
def run(self):
if self.displayAxes:
axesActor = vtk.vtkAxesActor()
axesActor.SetShaftTypeToLine()
axes = vtk.vtkOrientationMarkerWidget()
axes.SetOrientationMarker(axesActor);
axes.SetInteractor(self.interactor);
axes.EnabledOn();
axes.InteractiveOn();
self.window.Render()
self.window.SetWindowName(self.windowTitle)
self.interactor.Start()
def addAxes(self):
self.widget = vtkOrientationMarkerWidget()
axes = vtkAxesActor()
axes.SetShaftTypeToLine()
axes.SetTotalLength(0.5, 0.5, 0.5)
self.widget.SetOutlineColor(0.9300,0.5700,0.1300)
self.widget.SetOrientationMarker(axes)
self.widget.SetInteractor(self._Iren)
self.widget.SetViewport(0.80, 0.0, 1.0,0.25)
self._widgetState = True
self.widget.SetEnabled(self._widgetState)
self.widget.InteractiveOff()
def renderthis(self):
# open a window and create a renderer
self.ren = vtk.vtkRenderer()
self.widget.GetRenderWindow().AddRenderer(self.ren)
# to generate polygonal data for a arrow.
Arrow = vtk.vtkArrowSource()
Arrow.SetShaftResolution(100)
Arrow.SetTipResolution(100)
#invert arrow so the point which is referenced is the top of the point
Arrow.InvertOn()
# take the polygonal data from the vtkArrowSource and assign to variable arrowmapper
ArrowMapper = vtk.vtkPolyDataMapper()
ArrowMapper.SetInputConnection(Arrow.GetOutputPort())
# create an actor for our scene (arrowactor)
self.ArrowActor = vtk.vtkActor()
self.ArrowActor.SetMapper(ArrowMapper)
self.ArrowActor.GetProperty().SetColor(1,1,0)
self.ArrowActor.GetProperty().SetOpacity(0.60)
self.ArrowActor.GetProperty().EdgeVisibilityOn()
self.ArrowActor.GetProperty().SetColor(0.1,0.1,0.1)
# set tip position to (0,0,0)
self.position=(0,0,0)
self.ArrowActor.SetPosition(self.position)
# get and print arrow position
self.ArrowPos = self.ArrowActor.GetPosition()
#print self.ArrowPos
# Add actor to renderer window
#self.ren.AddActor(self.ArrowActor)
# Background colour lightgrey
self.ren.SetBackground(0.9,0.9,0.9)
#create a X,Y,Z axes to show 3d position:
# create axes variable and load vtk axes actor
self.axes = vtk.vtkAxesActor()
self.marker = vtk.vtkOrientationMarkerWidget()
# set the interactor. self.widget._Iren is inbuilt python mechanism for current renderer window.
self.marker.SetInteractor(self.widget._Iren )
self.marker.SetOrientationMarker(self.axes )
# set size and position of window (Xmin,Ymin,Xmax,Ymax)
self.marker.SetViewport(0.75,0,1,0.25)
#Allow user input
self.marker.SetEnabled(1)
# #settings for renderer window
self.ren.ResetCamera()
self.ren.ResetCameraClippingRange()
self.isplotted = True
self.p=0
def __init__(self):
'''
Constructor
'''
vtkPythonViewImage.__init__(self)
# texture mapper in 3D: vtkVolumeMapper
self.__VolumeMapper = None
# texture mapper in 3D: vtkVolumeTextureMapper3D
self.__VolumeTextureMapper = vtk.vtkVolumeTextureMapper3D()
# volume ray cast mapper vtkFixedPointVolumeRayCastMapper
self.__VolumeRayCastMapper = vtk.vtkFixedPointVolumeRayCastMapper()
# volume property: vtkVolumeProperty
self.__VolumeProperty = vtk.vtkVolumeProperty()
# volume actor: vtkVolume
self.__VolumeActor = vtk.vtkVolume()
# opacity transfer function: vtkPiecewiseFunction
self.__OpacityFunction = vtk.vtkPiecewiseFunction()
# color transfer function: vtkColorTransferFunction
self.__ColorFunction = vtk.vtkColorTransferFunction()
# vtkProp3DCollection
self.__PhantomCollection = vtk.vtkProp3DCollection()
# blender: vtkImageBlend
self.__Blender = None
# image 3D cropping box callback: vtkImage3DCroppingBoxCallback
self.__Callback = vtkPythonImage3DCroppingBoxCallback()
# box widget: vtkOrientedBoxWidget
# self.__BoxWidget = vtkOrientedBoxWidget() # Now I could not wrap vtkOrientedBoxWidget
self.__BoxWidget = vtk.vtkBoxWidget()
# vtkPlane widget: vtkPlaneWidget
self.__PlaneWidget = vtk.vtkPlaneWidget()
# annotated cube actor: vtkAnnotatedCubeActor, vtkOrientationMarkerWidget
self.__Cube = vtk.vtkAnnotatedCubeActor()
self.__Marker = vtk.vtkOrientationMarkerWidget()
self.SetupVolumeRendering()
self.SetupWidgets()
self.ShowAnnotationsOn()
self.getTextProperty().SetColor(0, 0, 0)
self.SetBackground(0.9, 0.9, 0.9) # white
self.__FirstRender = 1
self.__RenderingMode = self.PLANAR_RENDERING
self.__VRQuality = 1
self.__InteractorStyleSwitcher = None
def __init__(self, iren):
# super(Marker, self).__init__()
self.axes_actor = Axes().axes
self.cube_actor = Cube().cube
self.assembly = vtk.vtkPropAssembly()
self.assembly.AddPart(self.axes_actor)
self.assembly.AddPart(self.cube_actor)
self.marker = vtk.vtkOrientationMarkerWidget()
self.marker.SetOutlineColor(0.93, 0.57, 0.13)
self.marker.SetOrientationMarker(self.assembly)
# self.marker.SetViewport(0.0, 0.0, 0.15, 0.3)
self.marker.SetInteractor(iren)
def renderthis(self):
# open a window and create a renderer
self.widget.GetRenderWindow().AddRenderer(self.renderer)
# open file
self.filename=""
openFileDialog = wx.FileDialog(self, "Open STL file", "", self.filename,
"*.stl", wx.FD_OPEN | wx.FD_FILE_MUST_EXIST)
if openFileDialog.ShowModal() == wx.ID_CANCEL:
return
self.filename = openFileDialog.GetPath()
# render the data
reader = vtk.vtkSTLReader()
reader.SetFileName(self.filename)
# To take the polygonal data from the vtkConeSource and
# create a rendering for the renderer.
coneMapper = vtk.vtkPolyDataMapper()
coneMapper.SetInput(reader.GetOutput())
# create an actor for our scene
if self.isploted:
coneActor=self.renderer.GetActors().GetLastActor()
self.renderer.RemoveActor(coneActor)
coneActor = vtk.vtkActor()
coneActor.SetMapper(coneMapper)
# Add actor
self.renderer.AddActor(coneActor)
# print self.ren.GetActors().GetNumberOfItems()
if not self.isploted:
axes = vtk.vtkAxesActor()
self.marker = vtk.vtkOrientationMarkerWidget()
self.marker.SetInteractor( self.widget._Iren )
self.marker.SetOrientationMarker( axes )
self.marker.SetViewport(0.75,0,1,0.25)
self.marker.SetEnabled(1)
self.renderer.ResetCamera()
self.renderer.ResetCameraClippingRange()
cam = self.renderer.GetActiveCamera()
cam.Elevation(10)
cam.Azimuth(70)
self.isploted = True
self.renderer.Render()
def RenderSTL(self, filename):
# not relod file
if (self.filename == filename):
return
self.filename = filename
# render the data
reader = vtk.vtkSTLReader()
reader.SetFileName(self.filename)
# To take the polygonal data from the vtkConeSource and
# create a rendering for the renderer.
coneMapper = vtk.vtkPolyDataMapper()
coneMapper.SetInput(reader.GetOutput())
# create an actor for our scene
if self.isploted:
coneActor=self.ren.GetActors().GetLastActor()
self.ren.RemoveActor(coneActor)
coneActor = vtk.vtkActor()
coneActor.SetMapper(coneMapper)
# Add actor
self.ren.AddActor(coneActor)
# print self.ren.GetActors().GetNumberOfItems()
if not self.isploted:
axes = vtk.vtkAxesActor()
self.marker = vtk.vtkOrientationMarkerWidget()
self.marker.SetInteractor( self.widget._Iren )
self.marker.SetOrientationMarker( axes )
self.marker.SetViewport(0.75,0,1,0.25)
self.marker.SetEnabled(1)
self.ren.ResetCamera()
self.ren.ResetCameraClippingRange()
cam = self.ren.GetActiveCamera()
cam.Elevation(10)
cam.Azimuth(70)
self.isploted = True
self.ren.Render()
# Refresh Panel
self.Layout()
def draw(self):
self._renderWindowInteractor.Initialize()
self._renderWindowInteractor.SetInteractorStyle(self._interactorStyle)
axes = vtk.vtkAxesActor()
widget = vtk.vtkOrientationMarkerWidget()
widget.SetOutlineColor(0.9300, 0.5700, 0.1300)
widget.SetOrientationMarker(axes)
widget.SetInteractor(self._renderWindowInteractor)
#widget.SetViewport(0.0, 0.0, 0.1, 0.1)
widget.SetViewport(0.0, 0.0, 0.2, 0.4)
widget.SetEnabled(True)
widget.InteractiveOn()
textWidget = vtk.vtkTextWidget()
textRepresentation = vtk.vtkTextRepresentation()
textRepresentation.GetPositionCoordinate().SetValue(.0,.0 )
textRepresentation.GetPosition2Coordinate().SetValue(.3,.04 )
textWidget.SetRepresentation(textRepresentation)
textWidget.SetInteractor(self._renderWindowInteractor)
textWidget.SetTextActor(self._textActor)
textWidget.SelectableOff()
textWidget.On()
self._rendererScene.ResetCamera()
camPos = self._rendererScene.GetActiveCamera().GetPosition()
self._rendererScene.GetActiveCamera().SetPosition((camPos[2],camPos[1],camPos[0]))
self._rendererScene.GetActiveCamera().SetViewUp((0.0,0.0,1.0))
self._rendererScene.GetActiveCamera().Zoom(1.4)
self._renderWindowScene.Render()
if self._addedBSpline:
self._contextViewPlotCurv.GetRenderWindow().SetMultiSamples(0)
self._contextViewPlotCurv.GetInteractor().Initialize()
self._contextViewPlotCurv.GetInteractor().SetInteractorStyle(self._contextInteractorStyleCurv)
#self._contextViewPlotCurv.GetInteractor().Start()
self._contextViewPlotTors.GetRenderWindow().SetMultiSamples(0)
self._contextViewPlotTors.GetInteractor().Initialize()
self._contextViewPlotTors.GetInteractor().SetInteractorStyle(self._contextInteractorStyleTors)
self._contextViewPlotTors.GetInteractor().Start()
else:
self._renderWindowInteractor.Start()
def __init__(self, parent, pointSize=3, zMin=-10.0, zMax=10.0, maxNumPoints=1e6):
wx.Panel.__init__(self, parent)
#to interact with the scene using the mouse use an instance of vtkRenderWindowInteractor.
self.widget = wxVTKRenderWindowInteractor(self, -1)
self.widget.Enable(1)
self.widget.AddObserver("ExitEvent", lambda o,e,f=self: f.Close())
self.sizer = wx.BoxSizer(wx.VERTICAL)
self.sizer.Add(self.widget, 1, wx.EXPAND)
self.SetSizer(self.sizer)
self.Layout()
wx.YieldIfNeeded()
self.maxNumPoints = maxNumPoints
self.vtkPolyData = vtk.vtkPolyData()
self.clearPoints()
mapper = vtk.vtkPolyDataMapper()
mapper.SetInput(self.vtkPolyData)
mapper.SetColorModeToDefault()
mapper.SetScalarRange(zMin, zMax)
mapper.SetScalarVisibility(1)
self.vtkActor = vtk.vtkActor()
self.vtkActor.GetProperty().SetPointSize(pointSize);
self.vtkActor.SetMapper(mapper)
# Renderer
renderer = vtk.vtkRenderer()
renderer.AddActor(self.vtkActor)
renderer.SetBackground(0.0, 0.0, 0.0)
renderer.ResetCamera()
self.widget.GetRenderWindow().AddRenderer(renderer)
axes = vtk.vtkAxesActor()
self.marker = vtk.vtkOrientationMarkerWidget()
self.marker.SetInteractor( self.widget._Iren )
self.marker.SetOrientationMarker( axes )
self.marker.SetViewport(0.75,0,1,0.25)
self.marker.SetEnabled(1)
renderer.ResetCamera()
renderer.ResetCameraClippingRange()
cam = renderer.GetActiveCamera()
cam.Azimuth(180)
def __init__(self, parent, visualizer, **kws):
"""
Initialization
"""
self.x, self.y, self.z = -1, -1, -1
self.renew = 1
self.mapper = vtk.vtkPolyDataMapper()
self.axes = None
VisualizationModule.__init__(self, parent, visualizer, **kws)
iactor = self.wxrenwin.GetRenderWindow().GetInteractor()
self.descs = {"X": "X axis", "Y": "Y axis", "Z": "Z axis"}
self.axes = axes = vtk.vtkAxesActor()
axes.SetShaftTypeToCylinder()
axes.SetXAxisLabelText("X")
axes.SetYAxisLabelText("Y")
axes.SetZAxisLabelText("Z")
axes.SetTotalLength(2.0, 2.0, 2.0)
self.length = math.sqrt(2.0**2 + 2.0**2 + 2.0**2)
tprop = vtk.vtkTextProperty()
tprop.ItalicOn()
tprop.ShadowOn()
tprop.SetFontFamilyToTimes()
axes.GetXAxisCaptionActor2D().SetCaptionTextProperty(tprop)
tprop2 = vtk.vtkTextProperty()
tprop2.ShallowCopy(tprop)
axes.GetYAxisCaptionActor2D().SetCaptionTextProperty(tprop2)
tprop3 = vtk.vtkTextProperty()
tprop3.ShallowCopy(tprop)
axes.GetZAxisCaptionActor2D().SetCaptionTextProperty(tprop3)
self.renderer = self.parent.getRenderer()
self.actor = self.axes
self.marker = vtk.vtkOrientationMarkerWidget()
self.marker.SetOutlineColor(0.93, 0.57, 0.13)
self.marker.SetOrientationMarker(axes)
self.marker.SetViewport(0.0, 0.0, 0.2, 0.2)
self.marker.SetInteractor(iactor)
self.marker.SetEnabled(1)
self.marker.InteractiveOff()
self.filterDesc = "Add axes in 3D view"
def __init__(self, data_container, parent_qt_frame, busyness_indicator = None):
modelview.Observer.__init__(self)
self.data_container = data_container
# Make sure that the data container has the right type
if not isinstance(self.data_container, dc.DataContainer):
raise TypeError("the data container has the wrong type")
# Register itself as an observer to the data_container
self.data_container.add_observer(self)
self.busyness_indicator = busyness_indicator
# Make sure 'busyness_indicator' has the right type
if self.busyness_indicator and not isinstance(self.busyness_indicator, gui.busy.BusynessIndicator):
print("Warning: input parameter 'busyness_indicator' has the wrong type")
self.busyness_indicator = None
# The render window interactor
self.__vtk_widget = QVTKWidget(parent_qt_frame)
self.__vtk_widget.Renderer.SetBackground(0.4, 0.41, 0.42)
# This guy is very important: it handles all the model selection in the 3D view
self.__model_picker = ModelPicker(self.data_container, self.interactor)
# We want to see xyz axes in the lower left corner of the window
lower_left_axes_actor = vtk.vtkAxesActor()
lower_left_axes_actor.SetXAxisLabelText("X")
lower_left_axes_actor.SetYAxisLabelText("Y")
lower_left_axes_actor.SetZAxisLabelText("Z")
lower_left_axes_actor.SetTotalLength(1.5, 1.5, 1.5)
self.lower_left_axes_widget = vtk.vtkOrientationMarkerWidget()
self.lower_left_axes_widget.SetOrientationMarker(lower_left_axes_actor)
self.lower_left_axes_widget.KeyPressActivationOff()
self.lower_left_axes_widget.SetInteractor(self.interactor)
self.lower_left_axes_widget.SetViewport(0.0, 0.0, 0.2, 0.2)
self.lower_left_axes_widget.SetEnabled(1)
self.lower_left_axes_widget.InteractiveOff()
# The slicer for the volume data
self.volume_widget = vtk.vtkImagePlaneWidget()
self.volume_widget.SetInteractor(self.interactor)
self.volume_widget.SetResliceInterpolateToCubic()
def __init__(self, renWinInteract):
# create axes
self._axes = vtk.vtkAxesActor()
self._axes.SetShaftTypeToCylinder()
self._axes.GetXAxisCaptionActor2D().GetCaptionTextProperty().SetColor(1, 0, 0)
self._axes.GetXAxisCaptionActor2D().GetCaptionTextProperty().SetFontFamilyToArial()
self._axes.GetXAxisCaptionActor2D().GetCaptionTextProperty().ShadowOff()
self._axes.GetYAxisCaptionActor2D().GetCaptionTextProperty().SetColor(0, 1, 0)
self._axes.GetYAxisCaptionActor2D().GetCaptionTextProperty().SetFontFamilyToArial()
self._axes.GetYAxisCaptionActor2D().GetCaptionTextProperty().ShadowOff()
self._axes.GetZAxisCaptionActor2D().GetCaptionTextProperty().SetColor(0, 0, 1)
self._axes.GetZAxisCaptionActor2D().GetCaptionTextProperty().SetFontFamilyToArial()
self._axes.GetZAxisCaptionActor2D().GetCaptionTextProperty().ShadowOff()
# create axes marker
self._marker = vtk.vtkOrientationMarkerWidget()
self._marker.SetInteractor(renWinInteract)
self._marker.SetOrientationMarker(self._axes)
self._marker.SetViewport(0, 0, 0.25, 0.25)
self._marker.SetEnabled(0)
self._enabled = False
def __init__(self, rwi):
self._orientation_widget = vtk.vtkOrientationMarkerWidget()
self._orientation_widget.SetInteractor(rwi)
# we'll use this if there is no orientation metadata
# just a thingy with x-y-z indicators
self._axes_actor = vtk.vtkAxesActor()
# we'll use this if there is orientation metadata
self._annotated_cube_actor = aca = vtk.vtkAnnotatedCubeActor()
# configure the thing with better colours and no stupid edges
#aca.TextEdgesOff()
aca.GetXMinusFaceProperty().SetColor(1,0,0)
aca.GetXPlusFaceProperty().SetColor(1,0,0)
aca.GetYMinusFaceProperty().SetColor(0,1,0)
aca.GetYPlusFaceProperty().SetColor(0,1,0)
aca.GetZMinusFaceProperty().SetColor(0,0,1)
aca.GetZPlusFaceProperty().SetColor(0,0,1)
def __init__(self, parent_qt_frame, progress_bar):
super().__init__(parent_qt_frame)
# This one indicates the progress of computationally heavy tasks
self.__progress_bar = progress_bar
# The observers of this guy
self.__observers = list()
# The render window
#self.renderer.SetBackground(0.4, 0.41, 0.42)
self.renderer.SetBackground(1.0, 1.0, 1.0)
self.enable_depthpeeling()
self.__interactor_style = vtk.vtkInteractorStyleTrackballCamera()
self.__interactor_style.AddObserver("KeyReleaseEvent", self.__on_key_released)
self.__interactor_style.AddObserver("LeftButtonPressEvent", self.__on_left_button_pressed)
self.__interactor_style.AddObserver("LeftButtonReleaseEvent", self.__on_left_button_released)
self.__interactor_style.AddObserver("RightButtonPressEvent", self.__on_right_button_pressed)
self.__interactor_style.AddObserver("RightButtonReleaseEvent", self.__on_right_button_released)
self.__interactor_style.AddObserver("MouseMoveEvent", self.__on_mouse_moved)
self.interactor.SetInteractorStyle(self.__interactor_style)
# This guy is very important: it handles all the model selection in the 3D view
self.__prop3d_picker = vtk.vtkPropPicker()
self.interactor.SetPicker(self.__prop3d_picker)
self.__perform_prop3d_picking = True
# We want to see xyz axes in the lower left corner of the window
lower_left_axes_actor = vtk.vtkAxesActor()
lower_left_axes_actor.SetXAxisLabelText("X")
lower_left_axes_actor.SetYAxisLabelText("Y")
lower_left_axes_actor.SetZAxisLabelText("Z")
lower_left_axes_actor.SetTotalLength(1.5, 1.5, 1.5)
self.__lower_left_axes_widget = vtk.vtkOrientationMarkerWidget()
self.__lower_left_axes_widget.SetOrientationMarker(lower_left_axes_actor)
self.__lower_left_axes_widget.KeyPressActivationOff()
self.__lower_left_axes_widget.SetInteractor(self.render_window_interactor)
self.__lower_left_axes_widget.SetViewport(0.0, 0.0, 0.2, 0.2)
self.__lower_left_axes_widget.SetEnabled(1)
self.__lower_left_axes_widget.InteractiveOff()
def __init__(self):
Thread.__init__(self)
self.ren = vtkRenderer()
self.win = vtkRenderWindow()
self.win.AddRenderer(self.ren)
self.iren = vtkRenderWindowInteractor()
self.iren.SetRenderWindow(self.win)
style = vtkInteractorStyleTrackballCamera()
self.iren.SetInteractorStyle(style)
self._ctrl = False
self.iren.AddObserver("KeyPressEvent", self._KeypressCtrl)
self.iren.AddObserver("KeyReleaseEvent", self._KeyreleaseCtrl)
self.iren.AddObserver("ExitEvent", self._stop)
axesActor = vtkAxesActor()
self.axes = vtkOrientationMarkerWidget()
self.axes.SetOrientationMarker(axesActor)
self.axes.SetInteractor(self.iren)
self.axes.EnabledOn()
self.axes.InteractiveOn()
self.axes.SetViewport(0, 0.8, 0.15, 1)
self.ren.ResetCamera()
# information
self.info = vtkTextActor()
self.info.SetDisplayPosition(10, 10)
self.ren.AddActor(self.info)
# window-definitions
self.SetSize(800, 600)
self.SetWindowName("odeViz")
self.SetBackground(0.6, 0.6, 0.8)
def renderthis(self):
# open a window and create a renderer
if (self.parent.icpd.transformed is not None):
self.parent.icpd.mappertf.SetInput(self.parent.icpd.transformed)
self.parent.icpd.actortf.SetMapper(self.parent.icpd.mappertf)
self.parent.icpd.actortf.GetProperty().SetColor(1,0,0) # (R,G,B) # Red
self.parent.icpd.actortf.GetProperty().SetPointSize(3)
self.renderer.AddActor(self.parent.icpd.actortf)
if (self.parent.icpd.source is not None):
self.parent.icpd.mappers.SetInput(self.parent.icpd.source)
self.parent.icpd.actors.SetMapper(self.parent.icpd.mappers)
self.parent.icpd.actors.GetProperty().SetColor(0,1,0) # (R,G,B) #source
self.parent.icpd.actors.GetProperty().SetPointSize(3)
self.renderer.AddActor(self.parent.icpd.actors)
if (self.parent.icpd.target is not None):
self.parent.icpd.mappert.SetInput(self.parent.icpd.target)
self.parent.icpd.actort.SetMapper(self.parent.icpd.mappert)
self.parent.icpd.actort.GetProperty().SetColor(0,0,1) # (R,G,B) #
self.parent.icpd.actort.GetProperty().SetPointSize(3)
self.renderer.AddActor(self.parent.icpd.actort)
if not self.isploted:
axes = vtk.vtkAxesActor()
self.marker = vtk.vtkOrientationMarkerWidget()
self.marker.SetInteractor( self.widget._Iren )
self.marker.SetOrientationMarker( axes )
self.marker.SetViewport(0.75,0,1,0.25)
self.marker.SetEnabled(1)
self.renderer.ResetCamera()
self.renderer.ResetCameraClippingRange()
#cam = self.renderer.GetActiveCamera()
#cam.Elevation(10)
#cam.Azimuth(70)
self.isploted = True
self.renderer.Render()
def Start(self):
## create VTK interactor (this is the most important object)
# this need a Tkinter GUI object (render_frame) and a VTK render window (renWindow) to work
self.renWinInteractor = vtkTkRenderWindowInteractor(self.render_frame, rw=self.renWindow, width=600, height=600)
self.renWinInteractor.SetInteractorStyle(vtk.vtkInteractorStyleTrackballCamera()) # set the trackball behaviour
# we can add additional configurations for this interactor here
axes = vtk.vtkAxesActor()
marker = vtk.vtkOrientationMarkerWidget()
marker.SetOutlineColor(0.93, 0.57, 0.13)
marker.SetOrientationMarker(axes)
marker.SetInteractor(self.renWinInteractor)
marker.SetViewport(0.0, 0.0, 0.4, 0.4)
marker.SetEnabled(1)
marker.InteractiveOff()
## initialize the interactor and align it to the frame
self.renWinInteractor.Initialize()
self.renWinInteractor.pack(side='top', fill='both', expand=1)
self.renWindow.Render()
self.renWinInteractor.Start()
## main loop
self.root.mainloop()
def addDirectionWidget(iren,ren,coneH,coneR):
''' Function to add a direction widget.
Inputs:
iren - interactive renderer
coneH - height of the cone
coneR - radius of the cone
'''
# Define the direction cone
nArr = vtk.vtkConeSource()
nArr.SetResolution(100)
nArr.SetHeight(coneH)
nArr.SetRadius(coneR)
nArr.SetDirection(.0,1.0,.0)
nArr.Update()
# Cone mapper and actor
nArrMap = vtk.vtkPolyDataMapper()
nArrMap.SetInputConnection(nArr.GetOutputPort())
nArrAct = vtk.vtkActor()
nArrAct.SetMapper(nArrMap)
# Orientation widget
oriWid = vtk.vtkOrientationMarkerWidget()
oriWid.SetOrientationMarker(nArrAct)
oriWid.SetInteractor(iren)
oriWid.SetViewport(.05,.05,.15,.15)
oriWid.EnabledOn()
oriWid.InteractiveOn()
# Add the text actor.
oriText = vtk.vtkTextActor()
oriText.GetPositionCoordinate().SetCoordinateSystemToNormalizedViewport()
oriText.GetTextProperty().SetFontSize(32)
oriText.GetTextProperty().SetColor(0.0,0.0,0.0)
oriText.SetPosition(0.025,0.025)
oriText.SetInput('North')
ren.AddActor(oriText)
return oriWid
def add_widgets(self):
# axes
axes = vtk.vtkAxesActor()
self.marker_widget = vtk.vtkOrientationMarkerWidget()
self.marker_widget.SetInteractor(self.iren)
self.marker_widget.SetOrientationMarker(axes)
self.marker_widget.SetViewport(0.0, 0.0, 0.25, 0.25)
# scalar bar
self.scalarbar_actor = vtk.vtkScalarBarActor()
self.scalarbar_actor.SetLookupTable(self.lut)
self.scalarbar_widget = vtk.vtkScalarBarWidget()
self.scalarbar_widget.SetInteractor(self.iren)
self.scalarbar_widget.SetScalarBarActor(self.scalarbar_actor)
# contour slider
self.slider_rep = vtk.vtkSliderRepresentation2D()
self.slider_rep.SetTitleText("contour")
self.slider_rep.GetPoint1Coordinate().SetCoordinateSystemToNormalizedViewport()
self.slider_rep.GetPoint1Coordinate().SetValue(0.65, 0.1)
self.slider_rep.GetPoint2Coordinate().SetCoordinateSystemToNormalizedViewport()
self.slider_rep.GetPoint2Coordinate().SetValue(0.95, 0.1)
self.slider_widget = vtk.vtkSliderWidget()
self.slider_widget.SetInteractor(self.iren)
self.slider_widget.SetRepresentation(self.slider_rep)
self.slider_widget.SetAnimationModeToAnimate()
self.slider_widget.AddObserver(vtk.vtkCommand.InteractionEvent,
self.update_contour);
