def __init__(self, renderers):
'''
Initialize the axes - not the parent version, we're going to assign a vtkAxesActor to it and add it ourselves.
'''
# Skip the parent constructor
#super(Axes,self).__init__(renderer)
# Ref: http://vtk.org/gitweb?p=VTK.git;a=blob;f=Examples/GUI/Tcl/ProbeWithSplineWidget.tcl
self.vtkActor = vtk.vtkAxesActor()
self.vtkActor.SetShaftTypeToCylinder()
self.vtkActor.SetCylinderRadius(0.05)
self.vtkActor.SetTotalLength(2.5, 2.5, 2.5)
# Change the font size to something reasonable
# Ref: http://vtk.1045678.n5.nabble.com/VtkAxesActor-Problem-td4311250.html
self.vtkActor.GetXAxisCaptionActor2D().GetTextActor().SetTextScaleMode(vtk.vtkTextActor.TEXT_SCALE_MODE_NONE)
self.vtkActor.GetXAxisCaptionActor2D().GetTextActor().GetTextProperty().SetFontSize(25);
self.vtkActor.GetYAxisCaptionActor2D().GetTextActor().SetTextScaleMode(vtk.vtkTextActor.TEXT_SCALE_MODE_NONE)
self.vtkActor.GetYAxisCaptionActor2D().GetTextActor().GetTextProperty().SetFontSize(25);
self.vtkActor.GetZAxisCaptionActor2D().GetTextActor().SetTextScaleMode(vtk.vtkTextActor.TEXT_SCALE_MODE_NONE)
self.vtkActor.GetZAxisCaptionActor2D().GetTextActor().GetTextProperty().SetFontSize(25);
# Add the actor.
for item in renderers:
item.AddActor(self.vtkActor)
#renderer.AddActor(self.vtkActor)
def dataShape(self, shape):
if shape == self._dataShape:
return
self._dataShape = shape
if self.planes:
self.planes.RemoveObserver(self.coordEventObserver)
self.qvtk.renderer.RemoveViewProp(self.planes)
del self.planes
self.planes = SlicingPlanesWidget(shape, self.qvtk.GetInteractor())
#self.planes.SetInteractor(self.qvtk.GetInteractor())
self.coordEventObserver = self.planes.AddObserver("CoordinatesEvent", self.slicingCallback)
self.planes.SetCoordinate([0,0,0])
self.planes.SetPickable(False)
## Add RGB arrow axes
if self.axes:
self.qvtk.renderer.RemoveActor(self.axes)
del self.axes
self.axes = vtkAxesActor();
self.axes.AxisLabelsOff()
self.axes.SetTotalLength(0.5*shape[0], 0.5*shape[1], 0.5*shape[2])
self.axes.SetShaftTypeToCylinder()
self.qvtk.renderer.AddActor(self.axes)
self.qvtk.renderer.AddActor(self.planes)
self.qvtk.renderer.ResetCamera()
#for some reason, we have to do this afterwards!
self.planes.togglePlanesOn()
def __init__(self, threadLock, actorWrapper, axis=True,):
super(VTKVisualisation, self).__init__()
self.threadLock = threadLock
self.ren = vtk.vtkRenderer()
self.ren.AddActor(actorWrapper.actor)
self.axesActor = vtk.vtkAxesActor()
self.axesActor.AxisLabelsOff()
self.axesActor.SetTotalLength(1, 1, 1)
self.ren.AddActor(self.axesActor)
self.renWin = vtk.vtkRenderWindow()
self.renWin.AddRenderer(self.ren)
## IREN
self.iren = vtk.vtkRenderWindowInteractor()
self.iren.SetRenderWindow(self.renWin)
self.iren.Initialize()
self.style = vtk.vtkInteractorStyleTrackballCamera()
self.iren.SetInteractorStyle(self.style)
self.iren.AddObserver("TimerEvent", self.update_visualisation)
dt = 30 # ms
timer_id = self.iren.CreateRepeatingTimer(dt)
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 __init__(self):
# Skip the parent constructor
# super(Axes, self).__init__(renderer)
text_property_x = vtk.vtkTextProperty()
text_property_x.ItalicOn()
text_property_x.ShadowOn()
text_property_x.BoldOn()
text_property_x.SetFontFamilyToTimes()
text_property_x.SetColor(1, 0, 0)
text_property_y = vtk.vtkTextProperty()
text_property_y.ShallowCopy(text_property_x)
text_property_y.SetColor(0, 1, 0)
text_property_z = vtk.vtkTextProperty()
text_property_z.ShallowCopy(text_property_x)
text_property_z.SetColor(0, 0, 1)
self.axes = vtk.vtkAxesActor()
self.axes.SetShaftTypeToCylinder()
self.axes.SetCylinderRadius(0.05)
self.axes.SetTotalLength(3 * [1.5])
self.axes.GetXAxisCaptionActor2D().SetCaptionTextProperty(
text_property_x)
self.axes.GetYAxisCaptionActor2D().SetCaptionTextProperty(
text_property_y)
self.axes.GetZAxisCaptionActor2D().SetCaptionTextProperty(
text_property_z)
def visualize(self):
# a renderer and render window
renderer = vtk.vtkRenderer()
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer)
# an interactor
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
renderWindowInteractor.SetRenderWindow(renderWindow)
#add the actors to the scene
renderer.AddActor(self.vtkActor)
renderer.SetBackground(255, 255, 255) # Background white
# renderer.SetBackground(0, 0, 0)
transform = vtk.vtkTransform()
transform.Translate(0, 0, 0)
axes = vtk.vtkAxesActor()
axes.SetTotalLength(50, 50, 50)
axes.GetXAxisCaptionActor2D().GetCaptionTextProperty().SetFontSize(1)
axes.GetYAxisCaptionActor2D().GetCaptionTextProperty().SetFontSize(1)
axes.GetZAxisCaptionActor2D().GetCaptionTextProperty().SetFontSize(1)
# The axes are positioned with a user transform
axes.SetUserTransform(transform)
# renderer.AddActor(axes)
renderer.ResetCamera()
# Begin Interaction
renderWindow.SetSize(400, 400)
renderWindow.Render()
renderWindowInteractor.Start()
def createAnnotations(self):
# Add axes.
self.axesActor = vtk.vtkAxesActor()
self.axesActor.SetTotalLength(30,30,30)
self.axesActor.SetShaftTypeToCylinder()
self.axesActor.SetCylinderRadius(.05)
self.axesActor.GetXAxisCaptionActor2D().GetTextActor().SetTextScaleModeToNone()
self.axesActor.GetXAxisCaptionActor2D().GetCaptionTextProperty().SetFontSize(12)
self.axesActor.GetXAxisCaptionActor2D().GetCaptionTextProperty().ItalicOff()
self.axesActor.GetXAxisCaptionActor2D().GetCaptionTextProperty().BoldOff()
self.axesActor.GetXAxisCaptionActor2D().GetCaptionTextProperty().ShadowOff()
self.axesActor.GetYAxisCaptionActor2D().GetTextActor().SetTextScaleModeToNone()
self.axesActor.GetYAxisCaptionActor2D().GetCaptionTextProperty().SetFontSize(12)
self.axesActor.GetYAxisCaptionActor2D().GetCaptionTextProperty().ItalicOff()
self.axesActor.GetYAxisCaptionActor2D().GetCaptionTextProperty().BoldOff()
self.axesActor.GetYAxisCaptionActor2D().GetCaptionTextProperty().ShadowOff()
self.axesActor.GetZAxisCaptionActor2D().GetTextActor().SetTextScaleModeToNone()
self.axesActor.GetZAxisCaptionActor2D().GetCaptionTextProperty().SetFontSize(12)
self.axesActor.GetZAxisCaptionActor2D().GetCaptionTextProperty().ItalicOff()
self.axesActor.GetZAxisCaptionActor2D().GetCaptionTextProperty().BoldOff()
self.axesActor.GetZAxisCaptionActor2D().GetCaptionTextProperty().ShadowOff()
self.addActor(self.axesActor)
# Add handling info.
self.infoText = vtk.vtkTextActor()
self.infoText.SetInput("Rotate: Left mouse button\nPan: Middle mouse button\nZoom: Right mouse button")
self.infoText.GetTextProperty()
self.infoText.GetTextProperty().SetFontFamilyToArial()
self.infoText.GetTextProperty().SetFontSize(11)
self.infoText.GetTextProperty().SetColor(.6,.6,.6)
self.infoText.SetDisplayPosition(20,30)
self.addActor(self.infoText)
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 SetObjective(self, ApplicatorObjetiveInOpticalCoordinates):
if self.calibrated:
# Save the Transformation Goal
self.ApplicatorObjetiveAxis = ApplicatorObjetiveInOpticalCoordinates.copy()
self.ApplicatorObjetiveAxis = numpy.dot(self.TWorldToOptical,self.ApplicatorObjetiveAxis)
self.ApplicatorObjetive = vtk.vtkTransform()
self.ApplicatorObjetive.SetMatrix([self.ApplicatorObjetiveAxis[0,0],self.ApplicatorObjetiveAxis[0,1],self.ApplicatorObjetiveAxis[0,2],self.ApplicatorObjetiveAxis[0,3],
self.ApplicatorObjetiveAxis[1,0],self.ApplicatorObjetiveAxis[1,1],self.ApplicatorObjetiveAxis[1,2],self.ApplicatorObjetiveAxis[1,3],
self.ApplicatorObjetiveAxis[2,0],self.ApplicatorObjetiveAxis[2,1],self.ApplicatorObjetiveAxis[2,2],self.ApplicatorObjetiveAxis[2,3],
self.ApplicatorObjetiveAxis[3,0],self.ApplicatorObjetiveAxis[3,1],self.ApplicatorObjetiveAxis[3,2],self.ApplicatorObjetiveAxis[3,3]])
self.ApplicatorObjetiveaxes = vtk.vtkAxesActor()
self.ApplicatorObjetiveaxes.SetUserTransform(self.ApplicatorObjetive)
self.ApplicatorObjetiveaxes.SetXAxisLabelText('X App')
self.ApplicatorObjetiveaxes.SetYAxisLabelText('Y App')
self.ApplicatorObjetiveaxes.SetZAxisLabelText('Z App')
self.ApplicatorObjetiveaxes.SetTotalLength(0.2,0.2,0.2)
self.STLReaderApplicator = vtk.vtkSTLReader()
self.STLReaderApplicator.SetFileName(self.pathToModelApplicator)
self.STLReaderApplicator.Update()
self.mapperApplicator = vtk.vtkPolyDataMapper()
self.mapperApplicator.SetInputConnection(self.STLReaderApplicator.GetOutputPort())
self.modelActorApplicator = vtk.vtkActor()
self.modelActorApplicator.SetMapper(self.mapperApplicator)
self.modelActorApplicator.SetUserTransform(self.ApplicatorObjetive)
self.modelActorApplicator.GetProperty().SetColor(0,1,0)
self.modelActorApplicator.GetProperty().SetOpacity(0.5)
self.objetiveFixed = True
def setupAxes(self):
'''Add an vtkAxesActor to the renderer.'''
bnd= self.gridRecord.getBND()
offsetVector= bnd.diagonal*0.1
offset= offsetVector.getModulo()
axesPosition= bnd.pMin-offsetVector
transform = vtk.vtkTransform()
transform.Translate(axesPosition.x, axesPosition.y, axesPosition.z)
axes= vtk.vtkAxesActor()
# The axes are positioned with a user transform
axes.SetUserTransform(transform)
length= offset
axes.SetTotalLength(length,length,length)
textSize= int(3*offset)
axes.GetXAxisCaptionActor2D().GetTextActor().SetTextScaleMode(False)
axes.GetXAxisCaptionActor2D().GetTextActor().GetTextProperty().SetFontSize(textSize)
axes.GetYAxisCaptionActor2D().GetTextActor().SetTextScaleMode(False)
axes.GetYAxisCaptionActor2D().GetTextActor().GetTextProperty().SetFontSize(textSize)
axes.GetZAxisCaptionActor2D().GetTextActor().SetTextScaleMode(False)
axes.GetZAxisCaptionActor2D().GetTextActor().GetTextProperty().SetFontSize(textSize)
# properties of the axes labels can be set as follows
# this sets the x axis label to red
# axes.GetXAxisCaptionActor2D().GetCaptionTextProperty().SetColor(1,0,0)
# the actual text of the axis label can be changed:
# axes.SetXAxisLabelText("test")
self.renderer.AddActor(axes)
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 __init__(self,ext_actors=None): #ext_actors is a list of any external vtkActors.
#initializations:
self.renderer = vtk.vtkRenderer()
self.window = vtk.vtkRenderWindow()
self.window.SetSize(1000,1000)
self.mapper = vtk.vtkPolyDataMapper()
self.points = vtk.vtkPoints()
self.poly_data = vtk.vtkPolyData()
self.glyph3d = vtk.vtkGlyph3D()
self.actor = vtk.vtkActor()
self.point_s = vtk.vtkPointSource()
self.sphere = vtk.vtkSphereSource()
self.interactor= vtk.vtkRenderWindowInteractor()
self.inter_sty = PdbInteractorStyle()
self.axes_actor= vtk.vtkAxesActor()
#configurations:
self.point_s.SetNumberOfPoints(1)
self.sphere.SetRadius(1.0)
self.interactor.SetInteractorStyle(self.inter_sty)
self.interactor.SetRenderWindow(self.window)
self.axes_actor.SetTotalLength(100,100,100)
if ext_actors:
self.ex_actors = ext_actors
else:
self.ex_actors=[]
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 initialize():
# Create a rendering window and renderer
transform = vtk.vtkTransform()
transform.Scale(10.0, 10.0, 10.0)
axes = vtk.vtkAxesActor()
axes.SetUserTransform(transform)
transform.Translate(3.0, -2.0, 0.0)
axes.SetUserTransform(transform)
ren = vtk.vtkRenderer()
ren.AddActor(axes)
ren.ResetCamera()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
# Create a RenderWindowInteractor to permit manipulating the camera
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
style = vtk.vtkInteractorStyleTrackballCamera()
iren.SetInteractorStyle(style)
# enable user interface interactor
iren.Initialize()
renWin.Render()
iren.Start()
return ren, iren, renWin
def __init__(self, cell):
assert isinstance(cell, vtkUnitCellModule)
self.cell = cell
l0 = self.cell.get_characteristic_length()
# Create VTK axes actor (not really a VTK actor though)
self.vtk_ax = vtkAxesActor()
self.vtk_ax.SetTipTypeToCone()
self.vtk_ax.SetConeRadius(5e-2*l0)
self.vtk_ax.SetShaftTypeToCylinder()
self.vtk_ax.SetCylinderRadius(5e-3*l0)
# Create VTK two-dimensional property
p2d = vtkProperty2D()
p2d.SetDisplayLocationToBackground()
vtkModule.__init__(self, self.vtk_ax, p2d)
# Create VTK text property and apply to axes
vtk_textproperty = vtkTextProperty()
vtk_textproperty.SetFontSize(14)
vtk_textproperty.SetBold(True)
vtk_textproperty.SetItalic(True)
vtk_textproperty.SetShadow(True)
vtk_textproperty.SetJustificationToRight()
vtk_textproperty.SetVerticalJustificationToCentered()
self.set_text_property(vtk_textproperty)
def Visualize_Orientation(model, out_file):
# create coordinate actor
axes_actor = vtk.vtkAxesActor()
axes_actor.SetTotalLength(500.0, 500.0, 500.0)
# create model actor
model_mapper = vtk.vtkPolyDataMapper()
model_mapper.SetInputData(model)
model_actor = vtk.vtkActor()
model_actor.SetMapper(model_mapper)
global renderer
global interactor
renderer = vtk.vtkRenderer()
renderer.AddActor(model_actor)
renderer.AddActor(axes_actor)
win = vtk.vtkRenderWindow()
win.AddRenderer(renderer)
interactor = vtk.vtkRenderWindowInteractor()
interactor_style = QIN_Style()
interactor_style.SetRenderer(renderer)
interactor_style.SetActor(model_actor)
interactor_style.SetPolyData(model)
interactor_style.SetOutName(out_file)
interactor.SetInteractorStyle(interactor_style)
win.SetInteractor(interactor)
win.Render()
interactor.Start()
pass
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 _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 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 __init__(self):
# ODE initialization
self.world = ode.World()
self.world.setGravity(GRAVITY)
self.world.setERP(ERP)
self.world.setCFM(CFM)
self.space = ode.Space()
self.floor = ode.GeomPlane(self.space, (0.0,1.0,0.0), 0.0)
self.jointGroup = ode.JointGroup()
self.time = 0.0
# VTK initialization
self.renderer = vtk.vtkRenderer()
self.renderer.SetBackground(102.0/255.0,204/255.0,1.0)
self.window = vtk.vtkRenderWindow()
self.window.SetSize(WINDOW_WIDTH,WINDOW_HEIGHT)
self.window.AddRenderer(self.renderer)
self.interactor = vtk.vtkRenderWindowInteractor()
self.interactor.SetRenderWindow(self.window)
self.axes = vtk.vtkAxesActor()
self.axes.SetAxisLabels(0)
transform = vtk.vtkTransform()
transform.Scale(0.1,0.1,0.1)
self.axes.SetUserTransform(transform)
self.renderer.AddActor(self.axes)
# Create ground plane visualization
self.floorVisual = vtk.vtkPlaneSource()
self.floorVisual.SetNormal((0.0,1.0,0.0))
self.floorVisual.SetResolution(10,10)
self.floorReader = vtk.vtkJPEGReader()
self.floorReader.SetFileName(FLOOR_IMAGE)
self.floorTexture = vtk.vtkTexture()
transform = vtk.vtkTransform()
transform.Scale(50.0,50.0,50.0)
self.floorTexture.SetTransform(transform)
self.floorTexture.SetInput(self.floorReader.GetOutput())
self.floorMap = vtk.vtkTextureMapToPlane()
self.floorMap.SetInput(self.floorVisual.GetOutput())
self.floorMapper = vtk.vtkPolyDataMapper()
self.floorMapper.SetInput(self.floorMap.GetOutput())
self.floorActor = vtk.vtkActor()
transform = vtk.vtkTransform()
transform.Scale(100.0,100.0,100.0)
self.floorActor.SetUserTransform(transform)
self.floorActor.SetMapper(self.floorMapper)
self.floorActor.SetTexture(self.floorTexture)
self.renderer.AddActor(self.floorActor)
# VTK camera setup
self.camera = vtk.vtkCamera()
self.renderer.SetActiveCamera(self.camera)
self.cameraFocus = [0.0, 0.0, 0.0]
self.cameraPos = [4.0, 2.5, 1.5]
self.cameraOffset = [0.0,1.0,3.0]
self.cameraRoll = 0.0
# Keep track of the simulated bodies and robots
self.bodies = []
self.robots = []
self.controllers = []
def build_axes(self, noZaxis = False):
if self.axes is None:
self.axes = vtk.vtkAxesActor()
# self.axes.SetShaftTypeToCylinder()
if not noZaxis:
self.axes.SetTotalLength( self.data.shape[0] - 1, self.data.shape[1] - 1, self.data.shape[2] - 1)
else:
self.axes.SetTotalLength( self.data.shape[0] - 1, self.data.shape[1] - 1, 0 )
self.axes.SetNormalizedShaftLength( 1, 1, 1 )
self.axes.SetNormalizedTipLength( 0, 0, 0 )
# self.axes.SetNormalizedShaftLength( 0.85, 0.85, 0.85 )
# self.axes.SetNormalizedTipLength( 0.15, 0.15, 0.15 )
self.axes.AxisLabelsOn()
self.axes.GetXAxisTipProperty().SetColor( 0, 0, 1)
self.axes.GetXAxisShaftProperty().SetColor( 0, 0, 1)
self.axes.GetXAxisShaftProperty().SetLineWidth (2)
self.axes.SetXAxisLabelText('x')
txtprop = vtk.vtkTextProperty()
txtprop.SetColor(0, 0, 0)
txtprop.SetFontFamilyToArial()
txtprop.SetFontSize(12)
txtprop.SetOpacity(0.5)
self.axes.GetXAxisCaptionActor2D().SetCaptionTextProperty(txtprop)
self.axes.GetYAxisTipProperty().SetColor( 0, 1, 0)
self.axes.GetYAxisShaftProperty().SetColor( 0, 1, 0)
self.axes.GetYAxisShaftProperty().SetLineWidth (2)
self.axes.SetYAxisLabelText('y')
txtprop = vtk.vtkTextProperty()
txtprop.SetColor(0, 0, 0)
txtprop.SetFontFamilyToArial()
txtprop.SetFontSize(12)
txtprop.SetOpacity(0.5)
self.axes.GetYAxisCaptionActor2D().SetCaptionTextProperty(txtprop)
self.axes.GetZAxisTipProperty().SetColor( 1, 0, 0 )
self.axes.GetZAxisShaftProperty().SetColor( 1, 0, 0)
self.axes.GetZAxisShaftProperty().SetLineWidth (2)
self.axes.SetZAxisLabelText('z')
txtprop = vtk.vtkTextProperty()
txtprop.SetColor(0, 0, 0)
txtprop.SetFontFamilyToArial()
txtprop.SetFontSize(12)
txtprop.SetOpacity(0.5)
self.axes.GetZAxisCaptionActor2D().SetCaptionTextProperty(txtprop)
self.renderer.AddActor(self.axes)
self.iren.Render()
else :
if self.axes.GetVisibility():
self.axes.VisibilityOff()
else:
self.axes.VisibilityOn()
self.iren.Render()
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 visualize(meshFname = None, dumpFname = None, nFrames = 100):
# Create a rendering window and renderer
transform = vtk.vtkTransform()
transform.Scale(10.0, 10.0, 10.0)
axes = vtk.vtkAxesActor()
axes.SetUserTransform(transform)
transform.Translate(2.0, -1.0, 0.0)
axes.SetUserTransform(transform)
renderer = vtk.vtkRenderer()
renderer.AddActor(axes)
camera = vtk.vtkCamera()
camera.SetFocalPoint(0, 0, 0);
renderer.SetActiveCamera(camera);
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(renderer)
# Create a RenderWindowInteractor to permit manipulating the camera
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
style = vtk.vtkInteractorStyleTrackballCamera()
iren.SetInteractorStyle(style)
scale = 0.1
if dumpFname is not None:
with open(dumFname) as fp:
lines = (line for line in fp if not line.strip()[:3].isalpha())
sphereData = np.array(lines)
Natoms = len(sphereData) - nFrames
for i in range(nFrames):
for data in sphereData[Natoms * nFrames: Natoms * (nFrames+1)]:
plotSpheres(ren, data[1] * scale, data[2] * scale, data[3] * scale, 0.001)
if meshFname is not None:
polydata = loadStl(meshFname)
renderer.AddActor(polyDataToActor(polydata))
renderer.SetBackground(0.1, 0.1, 0.1)
style = vtk.vtkInteractorStyleTrackballCamera()
iren.SetInteractorStyle(style)
renderer.ResetCamera()
iren.Initialize()
renWin.Render()
iren.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 build_axes():
axes = vtk.vtkAxesActor() # create axes actor
axes.SetTotalLength( 10, 10 , 10 )
axes.SetNormalizedShaftLength( 1, 1, 1 )
axes.SetNormalizedTipLength( 0, 0, 0 )
axes.AxisLabelsOff()
axes.GetXAxisTipProperty().SetColor( 0, 0, 1 )
axes.GetXAxisShaftProperty().SetColor( 0, 0, 1 )
axes.GetYAxisTipProperty().SetColor( 1, 1, 1 )
axes.GetYAxisShaftProperty().SetColor( 1, 1, 1 )
axes.GetZAxisTipProperty().SetColor( 1, 0, 0 )
axes.GetZAxisShaftProperty().SetColor( 1, 0, 0 )
return axes
def draw(self, graphics):
transform = vtk.vtkTransform()
transform.Translate(self.points[0], self.points[1], self.points[2])
axes = vtk.vtkAxesActor()
if self.size:
#transform.Scale(self.size, self.size, self.size)
axes.SetTotalLength(self.size, self.size, self.size)
# The axes are positioned with a user transform
#axes.SetShaftTypeToCylinder()
axes.SetUserTransform(transform)
if not self.label:
axes.AxisLabelsOff()
graphics.renderer.AddActor(axes)
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, interactor):
colors = vtk.vtkNamedColors()
axes = vtk.vtkAxesActor()
widget = vtk.vtkOrientationMarkerWidget()
rgba = [0] * 4
colors.GetColor("Carrot", rgba)
widget.SetOutlineColor(rgba[0], rgba[1], rgba[2])
widget.SetOrientationMarker(axes)
widget.SetInteractor(interactor)
widget.SetViewport(0.0, 0.0, 0.4, 0.4)
widget.SetEnabled(1)
widget.InteractiveOn()
def visualise_scenegraph(camera, focal_distance=1, zoom=1):
if not isinstance(camera, Observer):
raise TypeError("The vtk visualisation function takes a Raysect Observer object as its argument.")
world = camera.root
if not isinstance(world, World):
raise TypeError("The vtk visualisation function requires the Raysect Observer object to be connected to a valid scene-graph.")
# Add the actors to the renderer
renderer = vtk.vtkRenderer()
renderer.SetBackground(0, 0, 0)
for child in world.children:
vtk_element = map_raysect_element_to_vtk(child)
if isinstance(vtk_element, VTKAssembly):
renderer.AddActor(vtk_element.assembly)
else:
renderer.AddActor(vtk_element.actor)
axes = vtk.vtkAxesActor()
renderer.AddActor(axes)
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(renderer)
renWin.SetSize(512, 512)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
iren.SetInteractorStyle(vtk.vtkInteractorStyleTrackballCamera())
iren.Initialize()
camera_origin = Point3D(0, 0, 0).transform(camera.transform)
camera_direction = Vector3D(0, 0, 1).transform(camera.transform)
up_direction = Vector3D(0, 1, 0).transform(camera.transform)
focal_point = camera_origin + camera_direction * focal_distance
vtk_camera = vtk.vtkCamera()
vtk_camera.SetPosition(camera_origin.x, camera_origin.y, camera_origin.z)
vtk_camera.SetFocalPoint(focal_point.x, focal_point.y, focal_point.z)
vtk_camera.SetViewUp(up_direction.x, up_direction.y, up_direction.z)
vtk_camera.ComputeViewPlaneNormal()
vtk_camera.SetDistance(focal_distance)
vtk_camera.Zoom(zoom)
renderer.SetActiveCamera(vtk_camera)
renderer.SetBackground(1.0, 0.9688, 0.8594)
renderer.SetBackground(vtk_colors.GetColor3d("SlateGray"))
# Start the event loop.
iren.Start()
def plot(self):
pose_se3 = self
if type(self) is SO3:
pose_se3 = self.to_se3()
pipeline = VtkPipeline()
axes = [vtk.vtkAxesActor() for i in range(self.length)]
vtk_mat = [transforms.np2vtk(each) for each in pose_se3]
for i in range(len(axes)):
axes[i].SetUserMatrix(vtk_mat[i])
axes[i].SetAxisLabels(0)
pipeline.add_actor(axes[i])
pipeline.add_actor(graphics.axesCube(pipeline.ren))
pipeline.render()
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 render(args):
# file_list = os.listdir(os.path.join(args.dataset_path, 'prediction'))
# file_name = choice(file_list)[:-4]
# oripoints = read_pickle(os.path.join(args.dataset_path, 'lidar', file_name+'.pkl'))
# boxes_corner = read_label(os.path.join(args.dataset_path, 'prediction', file_name+'.txt'))
# for KITTI
# oripoints = read_bin(args.bin_path)
# for Hobot
# oripoints = read_pickle(args.bin_path)
# boxes_corner = read_label(args.txt_path)
oripoints = np.fromfile("./data_labels/10_points.bin",
dtype=np.float32).reshape([-1, 5])[:, 1:]
bboxes = np.fromfile("./data_labels/10_boxes_f64.bin",
dtype=np.float64).reshape([-1, 7])
boxes_corner = rbbox3d_to_corners(bboxes)
ren = vtk.vtkRenderer()
for box in boxes_corner:
cubeActor = draw_box(box)
ren.AddActor(cubeActor)
gridActor = draw_grid()
ren.AddActor(gridActor)
colors1 = generator_color(oripoints.shape[0], [128, 128, 128])
obj = pointobject.VTKObject()
obj.CreateFromArray(np.array(oripoints))
obj.AddColors(colors1)
ren.AddActor(obj.GetActor())
axes = vtk.vtkAxesActor()
grid = vtk.vtkImageGridSource()
axes.SetTotalLength(80, 10, 80)
ren.AddActor(axes)
ren.SetBackground(0.1, 0.2, 0.3)
renWin = vtk.vtkRenderWindow()
renWin.SetSize(1600, 1600)
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
iren.Initialize()
iren.Start()
def createAnnotations(self):
# Add axes.
self.axesActor = vtk.vtkAxesActor()
self.axesActor.SetTotalLength(30, 30, 30)
self.axesActor.SetShaftTypeToCylinder()
self.axesActor.SetCylinderRadius(.05)
self.axesActor.GetXAxisCaptionActor2D().GetTextActor(
).SetTextScaleModeToNone()
self.axesActor.GetXAxisCaptionActor2D().GetCaptionTextProperty(
).SetFontSize(12)
self.axesActor.GetXAxisCaptionActor2D().GetCaptionTextProperty(
).ItalicOff()
self.axesActor.GetXAxisCaptionActor2D().GetCaptionTextProperty(
).BoldOff()
self.axesActor.GetXAxisCaptionActor2D().GetCaptionTextProperty(
).ShadowOff()
self.axesActor.GetYAxisCaptionActor2D().GetTextActor(
).SetTextScaleModeToNone()
self.axesActor.GetYAxisCaptionActor2D().GetCaptionTextProperty(
).SetFontSize(12)
self.axesActor.GetYAxisCaptionActor2D().GetCaptionTextProperty(
).ItalicOff()
self.axesActor.GetYAxisCaptionActor2D().GetCaptionTextProperty(
).BoldOff()
self.axesActor.GetYAxisCaptionActor2D().GetCaptionTextProperty(
).ShadowOff()
self.axesActor.GetZAxisCaptionActor2D().GetTextActor(
).SetTextScaleModeToNone()
self.axesActor.GetZAxisCaptionActor2D().GetCaptionTextProperty(
).SetFontSize(12)
self.axesActor.GetZAxisCaptionActor2D().GetCaptionTextProperty(
).ItalicOff()
self.axesActor.GetZAxisCaptionActor2D().GetCaptionTextProperty(
).BoldOff()
self.axesActor.GetZAxisCaptionActor2D().GetCaptionTextProperty(
).ShadowOff()
self.addActor(self.axesActor)
# Add handling info.
self.infoText = vtk.vtkTextActor()
self.infoText.SetInput(
"Rotate: Left mouse button\nPan: Middle mouse button\nZoom: Right mouse button"
)
self.infoText.GetTextProperty()
self.infoText.GetTextProperty().SetFontFamilyToArial()
self.infoText.GetTextProperty().SetFontSize(11)
self.infoText.GetTextProperty().SetColor(.6, .6, .6)
self.infoText.SetDisplayPosition(20, 30)
self.addActor(self.infoText)
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()
self.axes = vtk.vtkAxesActor()
self.add_actor(self.axes)
self._axes_visible = True
self.axes.SetConeRadius(0)
self.show()
self.iren.Initialize()
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()
self.axes = vtk.vtkAxesActor()
self.add_actor(self.axes)
self._axes_visible = True
self.axes.SetConeRadius(0)
self.show()
self.iren.Initialize()
def add_axes_at_origin(self):
"""
Add axes actor at origin
Returns
--------
marker_actor : vtk.vtkAxesActor
vtkAxesActor actor
"""
self.marker_actor = vtk.vtkAxesActor()
# renderer = self.renderers[self.loc_to_index(loc)]
self.AddActor(self.marker_actor)
self.parent._actors[str(hex(id(
self.marker_actor)))] = self.marker_actor
return self.marker_actor
def main():
parser = argparse.ArgumentParser()
parser.add_argument('-m', '--model', type=str,
required=True, help='Model filename')
parser.add_argument('-s', '--shape', type=int, nargs=2, default=None,
help='Input image shape')
parser.add_argument('-c', '--camera', type=str, default=None,
help='Camera configuraiton.')
args = parser.parse_args()
# Load statistical model
model = np.load(args.model)[()]
# Load camera parameters
camera = None
if args.camera is not None:
geometry = render.GeometryContext.load_from_file(args.camera)
else:
geometry = render.GeometryContext()
geometry.SOD = 1200
geometry.SDD = 1100
if args.shape is not None:
geometry.image_size = args.shape
renderer = render.SurfaceRenderer(False)
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(renderer.render_window)
faces = model['faces']
means = model['mean'].reshape(model['n_point'], model['n_dim'])
model_center = np.mean(means, axis=0)
means -= np.repeat(model_center[np.newaxis, :], means.shape[0], axis=0)
interactor.Initialize()
renderer.setup_render()
renderer.render((means, faces))
axes = vtk.vtkAxesActor()
axes.SetTotalLength(100, 100, 100)
renderer.renderer.AddActor(axes)
renderer.renderer.ResetCamera()
renderer.set_camera_parameter(geometry)
renderer.flush()
interactor.Start()
def load_vtk_frame(self):
# vtk
vtk_frame = QtGui.QFrame()
self.vtk_frame = vtk_frame
vtk_boxlayout = QtGui.QVBoxLayout()
self.vtk_boxlayout = vtk_boxlayout
vtk_widget = QVTKRenderWindowInteractor(vtk_frame)
self.vtk_widget = vtk_widget
vtk_boxlayout.addWidget(vtk_widget)
vtk_ren = vtk.vtkRenderer()
self.vtk_ren = vtk_ren
vtk_widget.GetRenderWindow().AddRenderer(vtk_ren)
vtk_iren = vtk_widget.GetRenderWindow().GetInteractor()
self.vtk_iren = vtk_iren
interactor_style = vtk.vtkInteractorStyleTrackballCamera()
self.vtk_iren.SetInteractorStyle(interactor_style)
# Orientation Marker
axesActor = vtk.vtkAxesActor()
self.orientation_marker = vtk.vtkOrientationMarkerWidget()
self.orientation_marker.SetOrientationMarker(axesActor)
self.orientation_marker.SetInteractor(self.vtk_iren)
self.orientation_marker.EnabledOn()
self.orientation_marker.InteractiveOn()
# test work
# Create source
source = vtk.vtkSphereSource()
source.SetCenter(0, 0, 0)
source.SetRadius(5.0)
# Create a mapper
mapper = vtk.vtkDataSetMapper()
mapper.SetInputConnection(source.GetOutputPort())
# Create an actor
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.GetProperty().SetRepresentationToWireframe()
vtk_ren.AddActor(actor)
vtk_frame.setLayout(vtk_boxlayout)
self.part_info['Sample Sphere'] = {'center': source.GetCenter()}
self.ug_mapper_actor['Sample Sphere'] = (source, mapper, actor)
uti.signal_center.report_part_list_signal.emit({'Volume Parts':['Sample Sphere'], 'Boundary Parts':list()})
# add to properties
# delete-able
vtk_ren.ResetCamera()
return vtk_frame
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 __init__(self,
vtk_renderer=None,
vtk_axes_actor=None,
vtk_orientation_marker_widget=None,
vtk_render_window_interactor=None):
self.init_instance_variable("vtk_renderer", vtk_renderer,
vtk.vtkRenderer())
self.init_instance_variable("vtk_axes_actor", vtk_axes_actor,
vtk.vtkAxesActor())
self.init_instance_variable("vtk_orientation_marker_widget",
vtk_orientation_marker_widget,
vtk.vtkOrientationMarkerWidget())
self.init_instance_variable("vtk_render_window_interactor",
vtk_render_window_interactor,
vtk.vtkRenderWindowInteractor())
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 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 create_actor(self):
self.part_num = len(self.engine.model)
for i in range(self.part_num):
# Set up point_list and color_list
self.point_list.append(vtk.vtkPoints())
self.color_list.append(vtk.vtkUnsignedCharArray())
self.color_list[i].SetName("colors")
self.color_list[i].SetNumberOfComponents(4)
# Create polydata by setting up points information and color information
polydata = vtk.vtkPolyData()
polydata.SetPoints(self.point_list[i])
polydata.GetPointData().SetScalars(self.color_list[i])
# create cell
voxel = self.create_voxel()
# Set up Glyph3D data representation: color, data representation form, input data and et.
self.glyph3D_list.append(vtk.vtkGlyph3D())
self.glyph3D_list[i].SetColorModeToColorByScalar()
self.glyph3D_list[i].SetSource(
voxel.GetOutput()) # Set up data representation form
self.glyph3D_list[i].SetInput(polydata) # Set input data
self.glyph3D_list[i].ScalingOff()
self.glyph3D_list[i].Update()
# mapper
mapper = vtk.vtkPolyDataMapper()
mapper.SetInput(self.glyph3D_list[i].GetOutput())
# actor
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.GetProperty()
self.renderer.AddActor(actor)
self.part_list.append(actor)
transform = vtk.vtkTransform()
transform.Translate(0.0, 0.0, 0.0)
axes = vtk.vtkAxesActor()
# The axes are positioned with a user transform
axes.SetUserTransform(transform)
# the actual text of the axis label can be changed:
axes.SetXAxisLabelText("")
axes.SetYAxisLabelText("")
axes.SetZAxisLabelText("")
def dispaly_axes(transformationMat):
#%%
originArray = np.zeros(3)
for i in range(3):
originArray[i] = transformationMat.GetElement(i, 3)
#create a Sphere
sphereSource = vtk.vtkSphereSource()
sphereSource.SetCenter(originArray)
sphereSource.SetRadius(0.1)
#create a mapper
sphereMapper = vtk.vtkPolyDataMapper()
sphereMapper.SetInputConnection(sphereSource.GetOutputPort())
#create an actor
sphereActor = vtk.vtkActor()
sphereActor.SetMapper(sphereMapper)
#a renderer and render window
renderer = vtk.vtkRenderer()
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer)
#an interactor
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
renderWindowInteractor.SetRenderWindow(renderWindow)
#add the actors to the scene
renderer.AddActor(sphereActor)
# renderer.SetBackground(.1,.2,.3) # Background dark blue
#Set the transformation to transform the axes+ origin to the desired location
transform = vtk.vtkTransform()
transform.SetMatrix(transformationMat)
axes = vtk.vtkAxesActor()
# The axes are positioned with a user transform
axes.SetUserTransform(transform)
renderer.AddActor(axes)
renderer.ResetCamera()
renderWindow.Render()
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, widget=None):
self.ren = vtk.vtkRenderer()
if widget is not None:
# Qt Widget Mode
self.qtwidget_mode = True
#### Init
# self.vtkWidget = QVTKRenderWindowInteractor(self.centralwidget)
# self.vtkWidget.setGeometry(0,0,200,200)
# self.vtkRenderer = calipy.vtkRenderer(self.vtkWidget)
# Qt Widget
self.vtkWidget = widget
self.vtkWidget.GetRenderWindow().AddRenderer(self.ren)
self.iren = self.vtkWidget.GetRenderWindow().GetInteractor()
self.iren.SetInteractorStyle(
vtk.vtkInteractorStyleTrackballCamera())
self.iren.Initialize()
self.iren.Start()
else:
# Window Mode
self.qtwidget_mode = False
# Make empty window
self.renWin = vtk.vtkRenderWindow()
self.renWin.AddRenderer(self.ren)
self.renWin.SetSize(960, 540)
self.iren = vtk.vtkRenderWindowInteractor()
self.iren.SetInteractorStyle(
vtk.vtkInteractorStyleTrackballCamera())
self.iren.SetRenderWindow(self.renWin)
self.iren.Initialize()
self.ren.SetBackground(0, 0.1, 0)
self.actor_list = {}
axes = vtk.vtkAxesActor()
self.ren.AddActor(axes)
self.actor_list["axes"] = axes
self.ren.ResetCamera()
self.iren.AddObserver('LeftButtonPressEvent',
self.pushLeftButtonPressEventOnVTK, 1.0)
def add_axes(iren):
axes = vtk.vtkAxesActor()
# put axes at origin
transform = vtk.vtkTransform()
transform.Translate(0.0, 0.0, 0.0)
axes.SetUserTransform(transform)
widget = vtk.vtkOrientationMarkerWidget()
widget.SetOutlineColor(0.9300, 0.5700, 0.1300)
widget.SetOrientationMarker(axes)
widget.SetInteractor(iren)
widget.SetViewport(0.0, 0.0, 0.2, 0.2)
widget.SetEnabled(1)
widget.InteractiveOn()
return widget
def add_axes_widget(self):
self.vtk_axes = vtk.vtkAxesActor()
self.vtk_axes.SetXAxisLabelText("Z")
self.vtk_axes.SetZAxisLabelText("X")
self.vtk_axes.GetZAxisShaftProperty().SetColor(0.129, 0.467, 0.694)
self.vtk_axes.GetZAxisTipProperty().SetColor(0.129, 0.467, 0.694)
self.vtk_axes.GetXAxisShaftProperty().SetColor(0.835, 0.165, 0.176)
self.vtk_axes.GetXAxisTipProperty().SetColor(0.835, 0.165, 0.176)
self.vtk_axes.GetYAxisShaftProperty().SetColor(0.188, 0.627, 0.224)
self.vtk_axes.GetYAxisTipProperty().SetColor(0.188, 0.627, 0.224)
self.vtk_orientation_marker = vtk.vtkOrientationMarkerWidget()
self.vtk_orientation_marker.SetOutlineColor(1, 1, 1)
self.vtk_orientation_marker.SetOrientationMarker(self.vtk_axes)
self.vtk_orientation_marker.SetInteractor(self.interactor)
self.vtk_orientation_marker.SetViewport(0, 0, 0.2, 0.2)
self.set_axes_widget_visibility(self.display_axes)
self.set_axes_widget_interactive(self.axes_interactive)
def addTriad(self, actors, viewport=0, color=[1.0, 1.0, 1.0], font=None):
r"""
Add 3D axes to the vtk window
Parameters
----------
actors: list
List of ampActors, this is used to determine the necessary limits
of the axes
viewport: int, default 0
The index of the viewport add the axes into
color: array_like
The RGB values as floats of the axes line and text colour
between [0, 1]
"""
lim = []
for actor in actors:
lim.append(actor.GetBounds())
if lim:
lim = np.array(lim) * 1.1
lim = lim.max(axis=0)
else:
lim = [0, 1, 0, 1, 0, 1]
transform = vtk.vtkTransform()
transform.Translate(lim[0], lim[2], lim[4])
scale = (lim[5] - lim[4]) * 0.1
transform.Scale(scale, scale, scale)
if self.triad:
self.rens[viewport].RemoveActor(self.triad)
self.triad = vtk.vtkAxesActor()
# The axes are positioned with a user transform
self.triad.SetUserTransform(transform)
for ax in [
self.triad.GetXAxisCaptionActor2D(),
self.triad.GetYAxisCaptionActor2D(),
self.triad.GetZAxisCaptionActor2D()
]:
ax.GetTextActor().GetTextProperty().SetFontFamilyToCourier()
ax.GetTextActor().GetTextProperty().SetColor(0, 0, 0)
ax.GetTextActor().GetTextProperty().ShadowOff()
ax.GetTextActor().GetTextProperty().BoldOff()
ax.GetTextActor().GetTextProperty().ItalicOff()
ax.GetTextActor().GetTextProperty().SetFontSize(8)
self.rens[viewport].AddActor(self.triad)
self.Render()
def vis_with_renderer(renderer):
# Renderer
# renderer.SetBackground(.2, .3, .4)
renderer.SetBackground(1, 1, 1)
renderer.ResetCamera()
transform = vtk.vtkTransform()
transform.Translate(1.0, 0.0, 0.0)
axes = vtk.vtkAxesActor()
renderer.AddActor(axes)
# Render Window
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer)
# Interactor
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
renderWindowInteractor.SetRenderWindow(renderWindow)
def get_camera_info(obj, ev):
if renderWindowInteractor.GetKeyCode() == "s":
w2if = vtk.vtkWindowToImageFilter()
w2if.SetInput(renderWindow)
w2if.Update()
writer = vtk.vtkPNGWriter()
writer.SetFileName("screenshot.png")
if vtk.VTK_MAJOR_VERSION == 5:
writer.SetInput(w2if.GetOutput())
else:
writer.SetInputData(w2if.GetOutput())
writer.Write()
print("screenshot saved")
style = vtk.vtkInteractorStyleSwitch()
renderWindowInteractor.SetInteractorStyle(style)
# style.SetCurrentStyleToTrackballActor()
style.SetCurrentStyleToTrackballCamera()
# Begin Interaction
renderWindowInteractor.AddObserver(vtk.vtkCommand.KeyPressEvent,
get_camera_info, 1)
renderWindow.Render()
renderWindowInteractor.Start()
def initialize_vtk(self):
'''
Run-once setup/definition of interactor specifics
'''
axes_actor = vtk.vtkAxesActor()
self.axes = vtk.vtkOrientationMarkerWidget()
self.axes.SetOrientationMarker(axes_actor)
self.iren.AddObserver("KeyPressEvent", self.keypress)
self.axes.SetInteractor(self.iren)
self.axes.EnabledOn()
self.axes.InteractiveOn()
self.ren.GetActiveCamera().ParallelProjectionOn()
colors = vtk.vtkNamedColors()
self.ren.SetBackground(colors.GetColor3d('Azure'))
self.ren.ResetCamera()
self.iren.Initialize()
def __init__(self, renderables):
self.iren = vtk.vtkRenderWindowInteractor()
self.iren.SetInteractorStyle(Camera(self.iren))
self.renderer = vtk.vtkRenderer()
axes = vtk.vtkAxesActor()
# The axes are positioned with a user transform
transform = vtk.vtkTransform()
transform.Translate(0.0, 0.0, 0.0)
axes.SetUserTransform(transform)
self.renderer.AddActor(axes)
for renderable in renderables:
for actor in renderable.get_actors():
self.renderer.AddActor(actor)
self.renderer.SetBackground(.0, .0, .0)
self.renderer.ResetCamera()
self.renderWindow = vtk.vtkRenderWindow()
self.renderWindow.AddRenderer(self.renderer)
self.iren.SetRenderWindow(self.renderWindow)
def createNewActor(self):
axes = vtk.vtkAxesActor()
axes_length = 50.0
axes_label_font_size = np.int16(20)
axes.SetTotalLength(axes_length, axes_length, axes_length)
axes.SetCylinderRadius(0.01)
axes.SetShaftTypeToCylinder()
axes.GetXAxisCaptionActor2D().GetTextActor().SetTextScaleModeToNone()
axes.GetYAxisCaptionActor2D().GetTextActor().SetTextScaleModeToNone()
axes.GetZAxisCaptionActor2D().GetTextActor().SetTextScaleModeToNone()
axes.GetXAxisCaptionActor2D().GetCaptionTextProperty().SetFontSize(
axes_label_font_size)
axes.GetYAxisCaptionActor2D().GetCaptionTextProperty().SetFontSize(
axes_label_font_size)
axes.GetZAxisCaptionActor2D().GetCaptionTextProperty().SetFontSize(
axes_label_font_size)
axes.PickableOn()
return axes
def _createAxes(self):
axesActor = vtk.vtkAxesActor()
axesActor.SetShaftTypeToCylinder()
axesActor.SetCylinderRadius(0.03)
axesActor.SetConeRadius(0.5)
axesActor.SetNormalizedTipLength(0.25, 0.25, 0.25)
axesActor.SetNormalizedLabelPosition(1.3, 1.3, 1.3)
axesActor.SetXAxisLabelText("X")
axesActor.SetYAxisLabelText("Y")
axesActor.SetZAxisLabelText("Z")
self.axes = vtk.vtkOrientationMarkerWidget()
self.axes.SetOrientationMarker(axesActor)
self.axes.SetInteractor(self)
self.axes.EnabledOn()
self.axes.InteractiveOff()
def MakeAxesActor(scale, xyzLabels):
axes = vtk.vtkAxesActor()
axes.SetScale(scale[0], scale[1], scale[2])
axes.SetShaftTypeToCylinder()
axes.SetXAxisLabelText(xyzLabels[0])
axes.SetYAxisLabelText(xyzLabels[1])
axes.SetZAxisLabelText(xyzLabels[2])
axes.SetCylinderRadius(0.5 * axes.GetCylinderRadius())
axes.SetConeRadius(1.025 * axes.GetConeRadius())
axes.SetSphereRadius(1.5 * axes.GetSphereRadius())
tprop = axes.GetXAxisCaptionActor2D().GetCaptionTextProperty()
tprop.ItalicOn()
tprop.ShadowOn()
tprop.SetFontFamilyToTimes()
# Use the same text properties on the other two axes.
axes.GetYAxisCaptionActor2D().GetCaptionTextProperty().ShallowCopy(tprop)
axes.GetZAxisCaptionActor2D().GetCaptionTextProperty().ShallowCopy(tprop)
return axes
def __init__(self, parent):
super(NeuroGLWidget, self).__init__(parent)
self.iren = self.GetRenderWindow().GetInteractor()
self.volume = vtk.vtkVolume()
self.GetRenderWindow().SetNumberOfLayers(2)
self.ren = []
for i in range(2):
self.ren.append(vtk.vtkRenderer())
self.ren[i].SetLayer(i)
self.GetRenderWindow().AddRenderer(self.ren[i])
#self.ren[i].GetActiveCamera().ParallelProjectionOn()
self.ren[1].SetActiveCamera(self.ren[0].GetActiveCamera())
self.ren[0].GetActiveCamera().ParallelProjectionOn()
self.style = InteractorStyle.MyInteractorStyle()
self.style.SetInteractor(self.iren)
self.style.SetRenderers(self.ren)
#self.style.SetRendererCollection(self.GetRenderWindow().GetRenderers())
self.style.AutoAdjustCameraClippingRangeOff()
self.iren.SetInteractorStyle(self.style)
self.style.SetGLWidgetHandle(self)
self.transform = vtk.vtkTransform()
self.transform.Identity()
self.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
self.customContextMenuRequested.connect(self.onContextMenu)
self.volumeSize = [0, 0, 0] #d,h,w
self.volumeRes = [1, 1, 1] #d,h,w
self.outLine = vtk.vtkActor()
self.axes = vtk.vtkAxesActor()
self.marker = vtk.vtkOrientationMarkerWidget()
self.marker.SetOutlineColor(1, 1, 1)
self.marker.SetOrientationMarker(self.axes)
self.marker.SetInteractor(self.GetRenderWindow().GetInteractor())
self.marker.SetViewport(0, 0, 0.1, 0.1)
self.marker.SetEnabled(True)
self.marker.InteractiveOn()
self.picker = vtk.vtkCellPicker()
self.picker.SetTolerance(0.005)
self.importData = vtk.vtkImageData()
self.colorFunc = vtk.vtkColorTransferFunction()
self.planeWidgetZ = vtkImagePlaneWidget()
self.planeWidgetZ.SetSliceIndex(0)
self.planeMode = False
self.CreateSliderWidget()
def animate(self, other=None, duration=5, gif=None):
from .quaternion import UnitQuaternion
assert duration > 0
q1 = []
q2 = []
if other is not None:
assert type(other) is SO3
assert self.length == other.length
for i in range(self.length):
q1.append(UnitQuaternion.rot(self.data[i]))
q2.append(UnitQuaternion.rot(other.data[i]))
else:
for i in range(self.length):
q1.append(UnitQuaternion())
q2.append(UnitQuaternion.rot(self.data[i]))
self.pipeline = VtkPipeline(total_time_steps=duration * 60,
gif_file=gif)
axis_list = []
for i in range(self.length):
axis_list.append(vtk.vtkAxesActor())
axis_list[i].SetAxisLabels(0)
axis_list[i].SetUserMatrix(transforms.np2vtk(q1[i].q2tr()))
self.pipeline.add_actor(axis_list[i])
cube_axes = graphics.axesCube(self.pipeline.ren)
self.pipeline.add_actor(cube_axes)
def execute(obj, event):
nonlocal axis_list
self.pipeline.timer_tick()
print(self.pipeline.timer_count)
for i in range(len(axis_list)):
axis_list[i].SetUserMatrix(
transforms.np2vtk(
q1[i].interp(q2[i],
r=1 / self.pipeline.total_time_steps *
self.pipeline.timer_count).q2tr()))
self.pipeline.iren.GetRenderWindow().Render()
self.pipeline.iren.AddObserver('TimerEvent', execute)
self.pipeline.animate()
def _show(self, actors):
axes = vtk.vtkAxesActor()
axes.SetAxisLabels(0)
transform = vtk.vtkTransform()
transform.Scale(10.0, 10.0, 10.0)
transform.Translate(1.0, 0.0, 0.0)
axes.SetUserTransform(transform)
# properties of the axes labels can be set as follows
# this sets the x axis label to red
# axes->GetXAxisCaptionActor2D()->GetCaptionTextProperty()->SetColor(1,0,0);
# the actual text of the axis label can be changed:
# axes->SetXAxisLabelText("test");
renderer = vtk.vtkRenderer()
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer)
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
renderWindowInteractor.SetRenderWindow(renderWindow)
renderWindowInteractor.Initialize()
style = vtk.vtkInteractorStyleTrackballCamera()
renderWindowInteractor.SetInteractorStyle(style)
for actor in actors:
renderer.AddActor(actor)
renderer.AddActor(axes)
# renderer.SetBackground(0.4, 0.5, 0.6)
renderer.SetBackground(0.0, 0.0, 0.0)
# renderWindow.SetSize(800, 800)
renderWindow.SetSize(renderWindow.GetScreenSize())
renderWindow.SetWindowName("Point Cloud Visualization")
renderer.ResetCamera()
renderer.GetActiveCamera().Zoom(1)
renderWindow.Render()
renderWindowInteractor.Start()
def open(self):
# window
ren = vtk.vtkRenderer()
ren.SetBackground(0.1, 0.2, 0.4)
win = vtk.vtkRenderWindow()
win.SetSize(640, 480)
win.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
sw = vtk.vtkInteractorStyleSwitch()
sw.SetCurrentStyleToTrackballCamera()
iren.SetInteractorStyle(sw)
iren.SetRenderWindow(win)
for a in self.actors:
ren.AddActor(a)
ax_actor = vtk.vtkAxesActor()
ax_actor.SetShaftTypeToCylinder()
ax_actor.SetXAxisLabelText("x")
ax_actor.SetYAxisLabelText("y")
ax_actor.SetZAxisLabelText("z")
ax_actor.AxisLabelsOn()
ax_actor.SetTotalLength(1.5, 1.5, 1.5)
ax_widget = vtk.vtkOrientationMarkerWidget()
ax_widget.SetOrientationMarker(ax_actor)
ax_widget.SetViewport(0.0, 0.0, 0.15, 0.3)
ax_widget.SetInteractor(iren)
ax_widget.SetEnabled(1)
ax_widget.InteractiveOff()
ren.ResetCamera()
cam1 = ren.GetActiveCamera()
cam1.Elevation(-90)
cam1.SetViewUp(0, 0, 1)
cam1.Azimuth(45)
ren.ResetCameraClippingRange()
iren.Initialize()
win.Render()
iren.Start()
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);
