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);