def main(): colors = vtk.vtkNamedColors() # create a rendering window and renderer ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) # create a renderwindowinteractor iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) style = vtk.vtkInteractorStyleTrackballActor() iren.SetInteractorStyle(style) # create source sphereSource = vtk.vtkSphereSource() # mapper mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(sphereSource.GetOutputPort()) # actor actor = vtk.vtkActor() actor.SetMapper(mapper) actor.GetProperty().SetColor(colors.GetColor3d('Chartreuse')) # assign actor to the renderer ren.AddActor(actor) ren.SetBackground(colors.GetColor3d('PaleGoldenrod')) # enable user interface interactor iren.Initialize() renWin.Render() iren.Start()
def __init__(self): """Init.""" # Interactor responsible for moving the camera. self.trackball_camera = vtk.vtkInteractorStyleTrackballCamera() # Interactor responsible for moving/rotating a selected actor. self.trackball_actor = vtk.vtkInteractorStyleTrackballActor() # Interactor responsible for panning/zooming the camera. self.image = vtk.vtkInteractorStyleImage() # The picker allows us to know which object/actor is under the mouse. self.picker = vtk.vtkPropPicker() self.chosen_element = None self.event = Event() self.event2id = {} # To map an event's name to an ID. # Define some interaction states self.left_button_down = False self.right_button_down = False self.middle_button_down = False self.active_props = set() self.history = deque(maxlen=10) # Events history. self.selected_props = {"left_button": set(), "right_button": set(), "middle_button": set()}
def __init__(self, background_file, model_file, camera_file): super(ManualRegistrationMainWidget, self).__init__() if not background_file: raise ValueError("Background image must be specified") if not model_file: raise ValueError("VTK model must be specified") if not camera_file: raise ValueError("Camera matrix must be specified") self.setContentsMargins(0, 0, 0, 0) self.viewer = ow.VTKOverlayWindow() self.viewer_size_policy = \ QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) self.viewer.setSizePolicy(self.viewer_size_policy) self.interactor_style = vtk.vtkInteractorStyleTrackballActor() self.viewer.SetInteractorStyle(self.interactor_style) self.vertical_layout = QtWidgets.QVBoxLayout(self) self.vertical_layout.setContentsMargins(0, 0, 0, 0) self.vertical_layout.addWidget(self.viewer) background = cv2.imread(background_file) model = sm.VTKSurfaceModel(model_file, [1.0, 1.0, 1.0], opacity=0.5) camera_matrix = np.loadtxt(camera_file) self.viewer.set_video_image(background) self.viewer.set_camera_matrix(camera_matrix) self.viewer.add_vtk_models([model])
def __init__(self, camera, tfBuffer, markerTopic, robotFrame, tipFrame, cameraFrame, masterWidget=None, parent=None): super(GpOverlayWidget, self).__init__(parent=parent) # Load in variables self.tfBuffer = tfBuffer self.robotFrame = robotFrame self.tipFrame = tipFrame self.markerTopic = markerTopic self.cameraFrame = cameraFrame self.masterWidget = masterWidget uiPath = cleanResourcePath( "package://dvrk_vision/src/dvrk_vision/overlay_widget.ui") # Get CV image from path uic.loadUi(uiPath, self) self.vtkWidget = QVTKStereoViewer(camera, parent=self) self.vtkWidget.renderSetup = self.renderSetup # Add vtk widget self.vl = QVBoxLayout() self.vl.addWidget(self.vtkWidget) self.vtkFrame.setLayout(self.vl) self.otherWindows = [] if self.masterWidget is not None: self.masterWidget.otherWindows.append(self) self.otherWindows.append(self.masterWidget) # Set up QT slider for opacity self.opacitySlider.valueChanged.connect(self.sliderChanged) self.textureCheckBox.stateChanged.connect(self.checkBoxChanged) self.iren = self.vtkWidget.GetRenderWindow().GetInteractor() self.iren.SetInteractorStyle(vtk.vtkInteractorStyleTrackballActor()) self.organFrame = None self.textureCheckBox.setText("Show GP mesh") self.POICheckBox = QCheckBox("Show markers", self) self.POICheckBox.setChecked(True) self.POICheckBox.stateChanged.connect(self.checkBoxChanged) self.horizontalLayout.addWidget(self.POICheckBox) self.clearButton = QPushButton("Clear markers", self) self.clearButton.pressed.connect(self.clearPOI) self.horizontalLayout.addWidget(self.clearButton) self.vtkWidget.Initialize() self.vtkWidget.start()
def __init__(self): self.scene = Scene() self.frame = MainWindow(self.scene) self.camera_style = vtk.vtkInteractorStyleTrackballCamera() self.camera_style.AddObserver('LeftButtonPressEvent', self.bimodal_mouse_handler) self.camera_style.AddObserver('LeftButtonReleaseEvent', self.bimodal_mouse_handler) self.camera_style.AddObserver('MiddleButtonPressEvent', self.bimodal_mouse_handler) self.camera_style.AddObserver('MiddleButtonReleaseEvent', self.bimodal_mouse_handler) self.camera_style.AddObserver('RightButtonPressEvent', self.bimodal_mouse_handler) self.camera_style.AddObserver('RightButtonReleaseEvent', self.bimodal_mouse_handler) self.camera_style.AddObserver('MouseWheelForwardEvent', self.bimodal_mouse_handler) self.camera_style.AddObserver('MouseWheelBackwardEvent', self.bimodal_mouse_handler) self.camera_style.AddObserver('KeyPressEvent', lambda a, b: None) self.actor_style = vtk.vtkInteractorStyleTrackballActor() self.actor_style.AddObserver('LeftButtonPressEvent', self.bimodal_mouse_handler) self.actor_style.AddObserver('LeftButtonReleaseEvent', self.bimodal_mouse_handler) self.actor_style.AddObserver('MiddleButtonPressEvent', self.bimodal_mouse_handler) self.actor_style.AddObserver('MiddleButtonReleaseEvent', self.bimodal_mouse_handler) self.actor_style.AddObserver('RightButtonPressEvent', self.bimodal_mouse_handler) self.actor_style.AddObserver('RightButtonReleaseEvent', self.bimodal_mouse_handler) self.actor_style.AddObserver('MouseWheelForwardEvent', self.bimodal_mouse_handler) self.actor_style.AddObserver('MouseWheelBackwardEvent', self.bimodal_mouse_handler) self.actor_style.AddObserver('KeyPressEvent', lambda a, b: None) self.frame.iren.SetInteractorStyle(self.camera_style) self.frame.iren.AddObserver('KeyPressEvent', self.keypress_handler) self.frame.ren.SetBackground(name_to_rgb_float(MAIN_WIN_BG_COLOR)) self.scene.frame = self.frame axes = vtk.vtkAxes() mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(axes.GetOutputPort()) self.frame.axes_actor = vtk.vtkActor() self.frame.axes_actor.SetMapper(mapper) self.frame.axes_actor.GetProperty().SetLineWidth(1) self.frame.axes_actor.SetVisibility(START_WITH_AXES) self.frame.ren.AddActor(self.frame.axes_actor)
def __init__(self, width=1400, height=1000, title='VTK Viewer'): self.renderer = vtk.vtkRenderer() self.renderer.SetBackground(1.0, 1.0, 1.0) self.render_window = vtk.vtkRenderWindow() self.render_window.AddRenderer(self.renderer) self.render_window.SetSize(width, height) self.root = Tkinter.Tk() self.root.title(title) self.render_window_interactor = vtkTkRenderWindowInteractorNoCharEvent( self.root, rw=self.render_window, width=width, height=height) self.render_window_interactor.Initialize() self.render_window_interactor.pack(fill='both', expand=1) self.cam_trackball = vtk.vtkInteractorStyleTrackballCamera() self.cam_trackball.SetCurrentRenderer(self.renderer) self.render_window_interactor.SetInteractorStyle(self.cam_trackball) self.cam_trackball.AddObserver('KeyPressEvent', self.on_key_press) self.key_callbacks = {} self.act_trackball = vtk.vtkInteractorStyleTrackballActor() self.act_trackball.SetCurrentRenderer(self.renderer) self.act_trackball.AddObserver('KeyPressEvent', self.on_key_press) self.act_trackball.AddObserver('InteractionEvent', self.on_actor_move) self.actor_move_callbacks = [] self.mouse_pick_interactor = vtk.vtkInteractorStyleUser() self.mouse_pick_interactor.SetCurrentRenderer(self.renderer) self.mouse_pick_interactor.AddObserver('KeyPressEvent', self.on_key_press) self.mouse_pick_interactor.AddObserver('LeftButtonPressEvent', lambda x, y: self.pick(True)) self.rubber_band_interactor = vtk.vtkInteractorStyleRubberBand3D() self.rubber_band_interactor.SetCurrentRenderer(self.renderer) self.rubber_band_interactor.AddObserver('KeyPressEvent', self.on_key_press) self.rubber_band_interactor.AddObserver('SelectionChangedEvent', self.on_box_select) self.box_select_callbacks = [] # Create pickers self.cell_picker = vtk.vtkCellPicker() self.cell_picker.AddObserver("EndPickEvent", self.on_pick) self.point_picker = vtk.vtkPointPicker() self.point_picker.AddObserver("EndPickEvent", self.on_pick) self.pick_callbacks = []
def renderSetup(self): super(ManualRegistrationWidget, self).renderSetup() self.actor_moving.VisibilityOn() self.actor_moving.SetPosition(0, 0, .1) self.vtkWidget.ren.ResetCameraClippingRange() self.iren = self.vtkWidget.GetRenderWindow().GetInteractor() self.iren.SetInteractorStyle(vtk.vtkInteractorStyleTrackballActor()) self.iren.AddObserver("StartInteractionEvent", self.interactionChange) self.iren.AddObserver("EndInteractionEvent", self.interactionChange) self.iren.RemoveObservers( "RightButtonPressEvent") #, self.buttonEvent) self.iren.RemoveObservers( "RightButtonReleaseEvent") #, self.buttonEvent) self.iren.AddObserver("RightButtonPressEvent", self.interactionChange) self.iren.AddObserver("RightButtonReleaseEvent", self.interactionChange) self.iren.AddObserver("InteractionEvent", self.interactionEvent) self.iren.AddObserver("MouseMoveEvent", self.interactionEvent)
def __init__(self, width=1400, height=1000, title='VTK Viewer'): self.renderer = vtk.vtkRenderer() self.renderer.SetBackground(1.0, 1.0, 1.0) self.render_window = vtk.vtkRenderWindow() self.render_window.AddRenderer(self.renderer) self.render_window.SetSize(width, height) self.root = Tkinter.Tk() self.root.title(title) self.render_window_interactor = vtkTkRenderWindowInteractorNoCharEvent(self.root, rw=self.render_window, width=width, height=height) self.render_window_interactor.Initialize() self.render_window_interactor.pack(fill='both', expand=1) self.cam_trackball = vtk.vtkInteractorStyleTrackballCamera() self.cam_trackball.SetCurrentRenderer(self.renderer) self.render_window_interactor.SetInteractorStyle(self.cam_trackball) self.cam_trackball.AddObserver('KeyPressEvent', self.on_key_press) self.key_callbacks = {} self.act_trackball = vtk.vtkInteractorStyleTrackballActor() self.act_trackball.SetCurrentRenderer(self.renderer) self.act_trackball.AddObserver('KeyPressEvent', self.on_key_press) self.act_trackball.AddObserver('InteractionEvent', self.on_actor_move) self.actor_move_callbacks = [] self.mouse_pick_interactor = vtk.vtkInteractorStyleUser() self.mouse_pick_interactor.SetCurrentRenderer(self.renderer) self.mouse_pick_interactor.AddObserver('KeyPressEvent', self.on_key_press) self.mouse_pick_interactor.AddObserver('LeftButtonPressEvent', lambda x, y: self.pick(True)) self.rubber_band_interactor = vtk.vtkInteractorStyleRubberBand3D() self.rubber_band_interactor.SetCurrentRenderer(self.renderer) self.rubber_band_interactor.AddObserver('KeyPressEvent', self.on_key_press) self.rubber_band_interactor.AddObserver('SelectionChangedEvent', self.on_box_select) self.box_select_callbacks = [] # Create pickers self.cell_picker = vtk.vtkCellPicker() self.cell_picker.AddObserver("EndPickEvent", self.on_pick) self.point_picker = vtk.vtkPointPicker() self.point_picker.AddObserver("EndPickEvent", self.on_pick) self.pick_callbacks = []
mapper2 = vtk.vtkPolyDataMapper() mapper2.SetInputConnection(sphereSource2.GetOutputPort()) # Create an actor actor2 = vtk.vtkActor() actor2.SetMapper(mapper2) # 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(actor1) renderer.AddActor(actor2) renderer.SetBackground(1, 1, 1) # Background color white # Render an image (lights and cameras are created automatically) renderWindow.Render() style = vtk.vtkInteractorStyleTrackballActor() renderWindowInteractor.SetInteractorStyle(style) # Begin mouse interaction renderWindowInteractor.Start()
light.SetLightTypeToSceneLight() light.SetAmbientColor(1, 1, 1) light.SetDiffuseColor(1, 1, 1) light.SetSpecularColor(1, 1, 1) light.SetPosition(-100, 100, 25) light.SetFocalPoint(0, 0, 0) light.SetIntensity(0.8) # Add the light to the renderer ren1.AddLight(light) ren2.AddLight(light) ren3.AddLight(light) ren4.AddLight(light) renWin = vtk.vtkRenderWindow() renWin.SetSize(800, 800) renWin.AddRenderer(ren1) renWin.AddRenderer(ren2) renWin.AddRenderer(ren3) renWin.AddRenderer(ren4) iren = vtk.vtkRenderWindowInteractor() iren.SetInteractorStyle(vtk.vtkInteractorStyleTrackballActor()) iren.SetRenderWindow(renWin) renWin.Render() iren.Initialize() iren.Start()
def __init__(self,parent): wx.Panel.__init__(self, parent) # Default object to display self.stlObject = vtk.vtkSTLReader() # Use \\ for the path name instead of \ for vtk to recognise the default file self.stlObject.SetFileName("C:\\Users\\user\\workspace\\arrow.stl") # Create a mapper and an actor self.mainMapper = vtk.vtkPolyDataMapper() self.mainMapper.SetInputConnection(self.stlObject.GetOutputPort()) self.mainActor = vtk.vtkActor() self.mainActor.SetMapper(self.mainMapper) self.mainActor.GetProperty().BackfaceCullingOff() self.widget = wxVTKRenderWindowInteractor(self, -1) self.widget.Enable(1) self.widget.AddObserver("ExitEvent", lambda o,e,f=self: f.Close()) self.style = vtk.vtkInteractorStyleTrackballActor() self.widget.SetInteractorStyle(self.style) # Binds events to the functions created self.widget.Bind(wx.EVT_LEFT_DOWN, self.onLeftDown) self.widget.Bind(wx.EVT_MIDDLE_DOWN, self.onMiddleDown) self.widget.Bind(wx.EVT_MOTION, self.onMotion) self.widget.Bind(wx.EVT_LEFT_UP, self.onLeftUp) self.widget.Bind(wx.EVT_MIDDLE_UP, self.onMiddleUp) self.widget.Bind(wx.EVT_KEY_DOWN, self.kDown) self.widget.Bind(wx.EVT_RIGHT_UP, self.onRightUp) self.widget.Bind(wx.EVT_RIGHT_DOWN, self.onRightDown) self.trackMotion = False self.trackpos = False self.sizer = wx.BoxSizer(wx.VERTICAL) self.sizer.Add(self.widget, 1, wx.EXPAND) self.SetSizer(self.sizer) self.Layout() self.isploted = False # Open window and create a renderer # to interact with the scene using the mouse use an instance of vtkRenderWindowInteractor. self.renderer = vtk.vtkRenderer() self.renderer.SetBackground(.1, .2, .3) # Background colour dark blue self.widget.GetRenderWindow().AddRenderer(self.renderer) # Add actor to render window #self.renderer.GetActors().AddActor(self.mainActor) self.renderer.AddActor(self.mainActor) # Setup orientation markers self.axes = vtk.vtkAxesActor() self.marker = vtk.vtkOrientationMarkerWidget() self.marker.SetInteractor(self.widget._Iren) self.marker.SetOrientationMarker(self.axes) self.marker.SetViewport(0.75,0,1,0.25) self.marker.SetEnabled(1) self.renderer.ResetCamera() self.renderer.ResetCameraClippingRange() self.isploted = True # Getting points when the actor is moved with the mouse self.pointcatcher = self.linedrawer() self.linesPolyData = vtk.vtkPolyData()
def show( self, *actors, **options # at=None, # axes=None, # c=None, # alpha=None, # wire=False, # bc=None, # resetcam=True, # zoom=False, # interactive=None, # rate=None, # viewup="", # azimuth=0, # elevation=0, # roll=0, # interactorStyle=0, # q=False, ): """ Render a list of actors. Allowed input objects are: ``filename``, ``vtkPolyData``, ``vtkActor``, ``vtkActor2D``, ``vtkImageActor``, ``vtkAssembly`` or ``vtkVolume``. If filename is given, its type is guessed based on its extension. Supported formats are: `vtu, vts, vtp, ply, obj, stl, 3ds, xml, neutral, gmsh, pcd, xyz, txt, byu, tif, slc, vti, mhd, png, jpg`. :param int at: number of the renderer to plot to, if more than one exists :param int axes: set the type of axes to be shown - 0, no axes, - 1, draw three gray grid walls - 2, show cartesian axes from (0,0,0) - 3, show positive range of cartesian axes from (0,0,0) - 4, show a triad at bottom left - 5, show a cube at bottom left - 6, mark the corners of the bounding box - 7, draw a simple ruler at the bottom of the window - 8, show the ``vtkCubeAxesActor`` object, - 9, show the bounding box outLine, - 10, show three circles representing the maximum bounding box :param c: surface color, in rgb, hex or name formats :param bc: set a color for the internal surface face :param bool wire: show actor in wireframe representation :param float azimuth/elevation/roll: move camera accordingly :param str viewup: either ['x', 'y', 'z'] or a vector to set vertical direction :param bool resetcam: re-adjust camera position to fit objects :param bool interactive: pause and interact with window (True) or continue execution (False) :param float rate: maximum rate of `show()` in Hertz :param int interactorStyle: set the type of interaction - 0, TrackballCamera - 1, TrackballActor - 2, JoystickCamera - 3, Unicam - 4, Flight - 5, RubberBand3D - 6, RubberBandZoom :param bool q: force program to quit after `show()` command returns. """ if not hasattr(self, 'window'): return at = options.pop("at", None) axes = options.pop("axes", None) c = options.pop("c", None) alpha = options.pop("alpha", None) wire = options.pop("wire", False) bc = options.pop("bc", None) resetcam = options.pop("resetcam", True) zoom = options.pop("zoom", False) interactive = options.pop("interactive", None) rate = options.pop("rate", None) viewup = options.pop("viewup", "") azimuth = options.pop("azimuth", 0) elevation = options.pop("elevation", 0) roll = options.pop("roll", 0) interactorStyle = options.pop("interactorStyle", 0) q = options.pop("q", False) if self.offscreen: interactive = False self.interactive = False def scan(wannabeacts): scannedacts = [] if not utils.isSequence(wannabeacts): wannabeacts = [wannabeacts] for a in wannabeacts: # scan content of list if isinstance(a, vtk.vtkActor): scannedacts.append(a) if hasattr(a, 'trail' ) and a.trail and not a.trail in self.actors: scannedacts.append(a.trail) elif isinstance(a, vtk.vtkAssembly): scannedacts.append(a) if a.trail and not a.trail in self.actors: scannedacts.append(a.trail) elif isinstance(a, vtk.vtkActor2D): if isinstance(a, vtk.vtkCornerAnnotation): for a2 in settings.collectable_actors: if isinstance(a2, vtk.vtkCornerAnnotation): if at in a2.renderedAt: # remove old message self.removeActor(a2) scannedacts.append(a) elif isinstance(a, vtk.vtkImageActor): scannedacts.append(a) elif isinstance(a, vtk.vtkVolume): scannedacts.append(a) elif isinstance(a, vtk.vtkImageData): scannedacts.append(Volume(a)) elif isinstance(a, vtk.vtkPolyData): scannedacts.append(Actor(a, c, alpha, wire, bc)) elif isinstance(a, str): # assume a filepath was given out = vtkio.load(a, c, alpha, wire, bc) if isinstance(out, str): colors.printc("~times File not found:", out, c=1) scannedacts.append(None) else: scannedacts.append(out) elif "dolfin" in str(type(a)): # assume a dolfin.Mesh object from vtkplotter.dolfin import MeshActor out = MeshActor(a, c=c, alpha=alpha, wire=True, bc=bc) scannedacts.append(out) elif a is None: pass elif isinstance(a, vtk.vtkUnstructuredGrid): gf = vtk.vtkGeometryFilter() gf.SetInputData(a) gf.Update() scannedacts.append( Actor(gf.GetOutput(), c, alpha, wire, bc)) elif isinstance(a, vtk.vtkStructuredGrid): gf = vtk.vtkGeometryFilter() gf.SetInputData(a) gf.Update() scannedacts.append( Actor(gf.GetOutput(), c, alpha, wire, bc)) elif isinstance(a, vtk.vtkRectilinearGrid): gf = vtk.vtkRectilinearGridGeometryFilter() gf.SetInputData(a) gf.Update() scannedacts.append( Actor(gf.GetOutput(), c, alpha, wire, bc)) elif isinstance(a, vtk.vtkMultiBlockDataSet): for i in range(a.GetNumberOfBlocks()): b = a.GetBlock(i) if isinstance(b, vtk.vtkPolyData): scannedacts.append(Actor(b, c, alpha, wire, bc)) elif isinstance(b, vtk.vtkImageData): scannedacts.append(Volume(b)) else: colors.printc("~!? Cannot understand input in show():", type(a), c=1) scannedacts.append(None) return scannedacts if len(actors) == 0: actors = None elif len(actors) == 1: actors = actors[0] else: actors = utils.flatten(actors) if actors is not None: self.actors = [] actors2show = scan(actors) for a in actors2show: if a not in self.actors: self.actors.append(a) else: actors2show = scan(self.actors) self.actors = list(actors2show) if axes is not None: self.axes = axes if interactive is not None: self.interactive = interactive if at is None and len(self.renderers) > 1: # in case of multiple renderers a call to show w/o specifing # at which renderer will just render the whole thing and return if self.interactor: if zoom: self.camera.Zoom(zoom) self.interactor.Render() if self.interactive: self.interactor.Start() return if at is None: at = 0 if at < len(self.renderers): self.renderer = self.renderers[at] else: colors.printc("~times Error in show(): wrong renderer index", at, c=1) return if not self.camera: self.camera = self.renderer.GetActiveCamera() self.camera.SetParallelProjection(self.infinity) if self.camThickness: self.camera.SetThickness(self.camThickness) if self.sharecam: for r in self.renderers: r.SetActiveCamera(self.camera) if len(self.renderers) == 1: self.renderer.SetActiveCamera(self.camera) # rendering for ia in actors2show: # add the actors that are not already in scene if ia: if isinstance(ia, vtk.vtkVolume): self.renderer.AddVolume(ia) else: self.renderer.AddActor(ia) if hasattr(ia, 'renderedAt'): ia.renderedAt.add(at) else: colors.printc( "~lightning Warning: Invalid actor in actors list, skip.", c=5) # remove the ones that are not in actors2show for ia in self.getActors(at): if ia not in actors2show: self.renderer.RemoveActor(ia) if hasattr(ia, 'renderedAt'): ia.renderedAt.discard(at) for c in self.scalarbars: self.renderer.RemoveActor(c) if hasattr(c, 'renderedAt'): c.renderedAt.discard(at) if self.axes is not None: addons.addAxes() addons.addLegend() if self.showFrame and len(self.renderers) > 1: addons.addFrame() if resetcam or self.initializedIren == False: self.renderer.ResetCamera() if not self.initializedIren and self.interactor: self.initializedIren = True self.interactor.Initialize() self.interactor.RemoveObservers("CharEvent") if self.verbose and self.interactive: docs.onelinetip() self.initializedPlotter = True if zoom: self.camera.Zoom(zoom) if azimuth: self.camera.Azimuth(azimuth) if elevation: self.camera.Elevation(elevation) if roll: self.camera.Roll(roll) if len(viewup): if viewup == "x": viewup = [1, 0, 0] elif viewup == "y": viewup = [0, 1, 0] elif viewup == "z": viewup = [0, 0, 1] self.camera.Azimuth(60) self.camera.Elevation(30) self.camera.Azimuth(0.01) # otherwise camera gets locked self.camera.SetViewUp(viewup) self.renderer.ResetCameraClippingRange() self.window.Render() scbflag = False for a in self.actors: if (hasattr(a, "scalarbar") and a.scalarbar is not None and utils.isSequence(a.scalarbar)): if len(a.scalarbar) == 5: # addScalarBar s1, s2, s3, s4, s5 = a.scalarbar sb = addons.addScalarBar(a, s1, s2, s3, s4, s5) scbflag = True a.scalarbar = sb # save scalarbar actor elif len(a.scalarbar) == 10: # addScalarBar3D s0, s1, s2, s3, s4, s5, s6, s7, s8 = a.scalarbar sb = addons.addScalarBar3D(a, at, s0, s1, s2, s3, s4, s5, s6, s7, s8) scbflag = True a.scalarbar = sb # save scalarbar actor if scbflag: self.window.Render() if settings.allowInteraction and not self.offscreen: self.allowInteraction() if settings.interactorStyle is not None: interactorStyle = settings.interactorStyle if interactorStyle == 0 or interactorStyle == "TrackballCamera": pass # do nothing elif interactorStyle == 1 or interactorStyle == "TrackballActor": self.interactor.SetInteractorStyle( vtk.vtkInteractorStyleTrackballActor()) elif interactorStyle == 2 or interactorStyle == "JoystickCamera": self.interactor.SetInteractorStyle( vtk.vtkInteractorStyleJoystickCamera()) elif interactorStyle == 3 or interactorStyle == "Unicam": self.interactor.SetInteractorStyle(vtk.vtkInteractorStyleUnicam()) elif interactorStyle == 4 or interactorStyle == "Flight": self.interactor.SetInteractorStyle(vtk.vtkInteractorStyleFlight()) elif interactorStyle == 5 or interactorStyle == "RubberBand3D": self.interactor.SetInteractorStyle( vtk.vtkInteractorStyleRubberBand3D()) elif interactorStyle == 6 or interactorStyle == "RubberBandZoom": self.interactor.SetInteractorStyle( vtk.vtkInteractorStyleRubberBandZoom()) if self.interactor and self.interactive: self.interactor.Start() if rate: if self.clock is None: # set clock and limit rate self._clockt0 = time.time() self.clock = 0.0 else: t = time.time() - self._clockt0 elapsed = t - self.clock mint = 1.0 / rate if elapsed < mint: time.sleep(mint - elapsed) self.clock = time.time() - self._clockt0 if q: # gracefully exit if self.verbose: print("q flag set to True. Exit.") sys.exit(0)
def __init__(self): """ Constructor, puts OverlayMainWidget in window. """ super().__init__() self.mode = "circle" self.model = None self.layout = QtWidgets.QVBoxLayout() self.frame = QtWidgets.QFrame() self.frame.setLayout(self.layout) self.setCentralWidget(self.frame) self.h_box = QtWidgets.QHBoxLayout() self.vtk_overlay_window = ow.VTKOverlayWindow() self.controls_box = QtWidgets.QHBoxLayout() self.h_box.addWidget(self.vtk_overlay_window) self.layout.addLayout(self.h_box) self.layout.addLayout(self.controls_box) self.add_group_box() self.add_opacity_slider() # Reset button self.button = QtWidgets.QPushButton('Move Target', self) self.button.clicked.connect(self.reset_models) self.layout.addWidget(self.button) self.target_actor = None self.window_width = 800 self.window_height = 600 self.setFixedSize(self.window_width, self.window_height) style = vtk.vtkInteractorStyleTrackballActor() self.vtk_overlay_window.SetInteractorStyle(style) # Setup text labels self.txtPosition = vtk.vtkTextActor() self.txtPosition.SetDisplayPosition(30, 60) self.txtPosition.GetTextProperty().SetFontSize(25) self.txtScale = vtk.vtkTextActor() self.txtScale.SetDisplayPosition(30, 30) self.txtScale.GetTextProperty().SetFontSize(25) self.reset_text_labels() self.vtk_overlay_window.foreground_renderer.AddActor(self.txtScale) self.vtk_overlay_window.foreground_renderer.AddActor(self.txtPosition) self.setup_target() self.setup_overlay() self.update() self.setContentsMargins(0, 0, 0, 0) def interactionChange(_, event): """ Mouse callbacks """ if event == "EndInteractionEvent": # position pos_error = self.check_position() self.txtPosition.SetInput(f"Alignment Error: {pos_error:.2f}") # scale scale_error = self.check_scale() self.txtScale.SetInput(f"Size Error: {scale_error:.2f}") # pylint:disable=protected-access self.vtk_overlay_window._Iren.AddObserver("EndInteractionEvent", interactionChange)
def _keypress(iren, event): # qt creates and passes a vtkGenericRenderWindowInteractor vp = settings.plotter_instance key = iren.GetKeySym() #print('Pressed key:', key, [vp]) if key in ["q", "Q", "space", "Return"]: iren.ExitCallback() return elif key == "Escape": sys.stdout.flush() settings.plotter_instance.closeWindow() elif key in ["F1", "Pause"]: sys.stdout.flush() colors.printc('\n[F1] Execution aborted. Exiting python now.') settings.plotter_instance.closeWindow() sys.exit(0) elif key == "m": if vp.clickedActor in vp.getActors(): vp.clickedActor.GetProperty().SetOpacity(0.02) bfp = vp.clickedActor.GetBackfaceProperty() if bfp and hasattr(vp.clickedActor, "_bfprop"): vp.clickedActor._bfprop = bfp # save it vp.clickedActor.SetBackfaceProperty(None) else: for a in vp.getActors(): if a.GetPickable(): a.GetProperty().SetOpacity(0.02) bfp = a.GetBackfaceProperty() if bfp and hasattr(a, "_bfprop"): a._bfprop = bfp a.SetBackfaceProperty(None) elif key == "comma": if vp.clickedActor in vp.getActors(): ap = vp.clickedActor.GetProperty() aal = max([ap.GetOpacity() * 0.75, 0.01]) ap.SetOpacity(aal) bfp = vp.clickedActor.GetBackfaceProperty() if bfp and hasattr(vp.clickedActor, "_bfprop"): vp.clickedActor._bfprop = bfp vp.clickedActor.SetBackfaceProperty(None) else: for a in vp.getActors(): if a.GetPickable(): ap = a.GetProperty() aal = max([ap.GetOpacity() * 0.75, 0.01]) ap.SetOpacity(aal) bfp = a.GetBackfaceProperty() if bfp and hasattr(a, "_bfprop"): a._bfprop = bfp a.SetBackfaceProperty(None) elif key == "period": if vp.clickedActor in vp.getActors(): ap = vp.clickedActor.GetProperty() aal = min([ap.GetOpacity() * 1.25, 1.0]) ap.SetOpacity(aal) if aal == 1 and hasattr(vp.clickedActor, "_bfprop") and vp.clickedActor._bfprop: # put back vp.clickedActor.SetBackfaceProperty(vp.clickedActor._bfprop) else: for a in vp.getActors(): if a.GetPickable(): ap = a.GetProperty() aal = min([ap.GetOpacity() * 1.25, 1.0]) ap.SetOpacity(aal) if aal == 1 and hasattr(a, "_bfprop") and a._bfprop: a.SetBackfaceProperty(a._bfprop) elif key == "slash": if vp.clickedActor in vp.getActors(): vp.clickedActor.GetProperty().SetOpacity(1) if hasattr(vp.clickedActor, "_bfprop") and vp.clickedActor._bfprop: vp.clickedActor.SetBackfaceProperty(vp.clickedActor._bfprop) else: for a in vp.getActors(): if a.GetPickable(): a.GetProperty().SetOpacity(1) if hasattr(a, "_bfprop") and a._bfprop: a.clickedActor.SetBackfaceProperty(a._bfprop) elif key == "P": if vp.clickedActor in vp.getActors(): acts = [vp.clickedActor] else: acts = vp.getActors() for ia in acts: if ia.GetPickable(): try: ps = ia.GetProperty().GetPointSize() if ps > 1: ia.GetProperty().SetPointSize(ps - 1) ia.GetProperty().SetRepresentationToPoints() except AttributeError: pass elif key == "p": if vp.clickedActor in vp.getActors(): acts = [vp.clickedActor] else: acts = vp.getActors() for ia in acts: if ia.GetPickable(): try: ps = ia.GetProperty().GetPointSize() ia.GetProperty().SetPointSize(ps + 2) ia.GetProperty().SetRepresentationToPoints() except AttributeError: pass elif key == "w": if vp.clickedActor and vp.clickedActor in vp.getActors(): vp.clickedActor.GetProperty().SetRepresentationToWireframe() else: for a in vp.getActors(): if a and a.GetPickable(): if a.GetProperty().GetRepresentation() == 1: # toggle a.GetProperty().SetRepresentationToSurface() else: a.GetProperty().SetRepresentationToWireframe() elif key == "r": vp.renderer.ResetCamera() ############################################################# ### now intercept custom observer ########################### ############################################################# if vp.keyPressFunction: if key not in ["Shift_L", "Control_L", "Super_L", "Alt_L"]: if key not in ["Shift_R", "Control_R", "Super_R", "Alt_R"]: vp.verbose = False vp.keyPressFunction(key) return if key == "h": from vtkplotter.docs import tips tips() return if key == "a": iren.ExitCallback() cur = iren.GetInteractorStyle() if isinstance(cur, vtk.vtkInteractorStyleTrackballCamera): print("\nInteractor style changed to TrackballActor") print(" you can now move and rotate individual meshes:") print(" press X twice to save the repositioned mesh,") print(" press 'a' to go back to normal style.") iren.SetInteractorStyle(vtk.vtkInteractorStyleTrackballActor()) else: iren.SetInteractorStyle(vtk.vtkInteractorStyleTrackballCamera()) iren.Start() return if key == "j": iren.ExitCallback() cur = iren.GetInteractorStyle() if isinstance(cur, vtk.vtkInteractorStyleJoystickCamera): iren.SetInteractorStyle(vtk.vtkInteractorStyleTrackballCamera()) else: print("\nInteractor style changed to Joystick,", end="") print(" press j to go back to normal.") iren.SetInteractorStyle(vtk.vtkInteractorStyleJoystickCamera()) iren.Start() return if key == "S": screenshot("screenshot.png") colors.printc("~camera Saved rendering window as screenshot.png", c="blue") return if key == "C": cam = vp.renderer.GetActiveCamera() print('\n### Example code to position this vtkCamera:') print('vp = vtkplotter.Plotter()\n...') print('vp.camera.SetPosition(', [round(e, 3) for e in cam.GetPosition()], ')') print('vp.camera.SetFocalPoint(', [round(e, 3) for e in cam.GetFocalPoint()], ')') print('vp.camera.SetViewUp(', [round(e, 3) for e in cam.GetViewUp()], ')') print('vp.camera.SetDistance(', round(cam.GetDistance(), 3), ')') print('vp.camera.SetClippingRange(', [round(e, 3) for e in cam.GetClippingRange()], ')') return if key == "s": if vp.clickedActor and vp.clickedActor in vp.getActors(): vp.clickedActor.GetProperty().SetRepresentationToSurface() else: for a in vp.getActors(): if a and a.GetPickable(): a.GetProperty().SetRepresentationToSurface() elif key == "V": if not (vp.verbose): vp._tips() vp.verbose = not (vp.verbose) print("Verbose: ", vp.verbose) elif key == "1": vp.icol += 1 if vp.clickedActor and hasattr(vp.clickedActor, "GetProperty"): vp.clickedActor.GetMapper().ScalarVisibilityOff() vp.clickedActor.GetProperty().SetColor(colors.colors1[(vp.icol) % 10]) else: for i, ia in enumerate(vp.getActors()): if not ia.GetPickable(): continue ia.GetProperty().SetColor(colors.colors1[(i + vp.icol) % 10]) ia.GetMapper().ScalarVisibilityOff() addons.addLegend() elif key == "2": vp.icol += 1 if vp.clickedActor and hasattr(vp.clickedActor, "GetProperty"): vp.clickedActor.GetMapper().ScalarVisibilityOff() vp.clickedActor.GetProperty().SetColor(colors.colors2[(vp.icol) % 10]) else: for i, ia in enumerate(vp.getActors()): if not ia.GetPickable(): continue ia.GetProperty().SetColor(colors.colors2[(i + vp.icol) % 10]) ia.GetMapper().ScalarVisibilityOff() addons.addLegend() elif key == "3": c = colors.getColor("gold") acs = vp.getActors() if len(acs) == 0: return alpha = 1.0 / len(acs) for ia in acs: if not ia.GetPickable(): continue ia.GetProperty().SetColor(c) ia.GetProperty().SetOpacity(alpha) ia.GetMapper().ScalarVisibilityOff() addons.addLegend() elif key == "4": for ia in vp.getActors(): if not ia.GetPickable(): continue if isinstance(ia, Actor): iascals = ia.scalars() if len(iascals): stype, sname = iascals[ia._scals_idx] if "ormal" not in sname: # exclude normals ia.scalars(ia._scals_idx) ia.GetMapper().ScalarVisibilityOn() colors.printc("..active scalars set to:", sname, "\ttype:", stype, c='g', bold=0) ia._scals_idx += 1 if ia._scals_idx >= len(iascals): ia._scals_idx = 0 addons.addLegend() elif key == "5": bgc = numpy.array(vp.renderer.GetBackground()).sum() / 3 if bgc <= 0: bgc = 0.223 elif 0 < bgc < 1: bgc = 1 else: bgc = 0 vp.renderer.SetBackground(bgc, bgc, bgc) elif "KP_" in key: # change axes style asso = { "KP_Insert": 0, "KP_0": 0, "KP_End": 1, "KP_1": 1, "KP_Down": 2, "KP_2": 2, "KP_Next": 3, "KP_3": 3, "KP_Left": 4, "KP_4": 4, "KP_Begin": 5, "KP_5": 5, "KP_Right": 6, "KP_6": 6, "KP_Home": 7, "KP_7": 7, "KP_Up": 8, "KP_8": 8, "KP_Prior": 9, "KP_9": 9, } clickedr = vp.renderers.index(vp.renderer) if key in asso.keys(): if vp.axes_instances[clickedr]: if hasattr(vp.axes_instances[clickedr], "EnabledOff"): # widget vp.axes_instances[clickedr].EnabledOff() else: vp.renderer.RemoveActor(vp.axes_instances[clickedr]) vp.axes_instances[clickedr] = None addons.addAxes(axtype=asso[key], c=None) vp.interactor.Render() elif key in ["k", "K"]: for a in vp.getActors(): ptdata = a.GetMapper().GetInput().GetPointData() cldata = a.GetMapper().GetInput().GetCellData() arrtypes = dict() arrtypes[vtk.VTK_UNSIGNED_CHAR] = "UNSIGNED_CHAR" arrtypes[vtk.VTK_UNSIGNED_INT] = "UNSIGNED_INT" arrtypes[vtk.VTK_FLOAT] = "FLOAT" arrtypes[vtk.VTK_DOUBLE] = "DOUBLE" foundarr = 0 if key == "k": for i in range(ptdata.GetNumberOfArrays()): name = ptdata.GetArrayName(i) if name == "Normals": continue ptdata.SetActiveScalars(name) foundarr = 1 if not foundarr: print("No vtkArray is associated to points", end="") if hasattr(a, "_legend"): print(" for actor:", a._legend) else: print() if key == "K": for i in range(cldata.GetNumberOfArrays()): name = cldata.GetArrayName(i) if name == "Normals": continue cldata.SetActiveScalars(name) foundarr = 1 if not foundarr: print("No vtkArray is associated to cells", end="") if hasattr(a, "_legend"): print(" for actor:", a._legend) else: print() a.GetMapper().ScalarVisibilityOn() elif key == "l": if vp.clickedActor in vp.getActors(): acts = [vp.clickedActor] else: acts = vp.getActors() for ia in acts: if not ia.GetPickable(): continue try: ev = ia.GetProperty().GetEdgeVisibility() ia.GetProperty().SetEdgeVisibility(not ev) ia.GetProperty().SetRepresentationToSurface() ia.GetProperty().SetLineWidth(0.1) except AttributeError: pass elif key == "n": # show normals to an actor from vtkplotter.analysis import normalLines if vp.clickedActor in vp.getActors(): if vp.clickedActor.GetPickable(): vp.renderer.AddActor(normalLines(vp.clickedActor)) iren.Render() else: print("Click an actor and press n to add normals.") elif key == "x": if vp.justremoved is None: if vp.clickedActor in vp.getActors() or isinstance( vp.clickedActor, vtk.vtkAssembly): vp.justremoved = vp.clickedActor vp.renderer.RemoveActor(vp.clickedActor) if hasattr(vp.clickedActor, '_legend') and vp.clickedActor._legend: print('...removing actor: ' + str(vp.clickedActor._legend) + ', press x to put it back') else: print("Click an actor and press x to toggle it.") else: vp.renderer.AddActor(vp.justremoved) vp.renderer.Render() vp.justremoved = None addons.addLegend() elif key == "X": if vp.clickedActor: if not vp.cutterWidget: addons.addCutterTool(vp.clickedActor) else: fname = "clipped.vtk" confilter = vtk.vtkPolyDataConnectivityFilter() if isinstance(vp.clickedActor, vtk.vtkActor): confilter.SetInputData( vp.clickedActor.GetMapper().GetInput()) elif isinstance(vp.clickedActor, vtk.vtkAssembly): act = vp.clickedActor.getActors()[0] confilter.SetInputData(act.GetMapper().GetInput()) else: confilter.SetInputData(vp.clickedActor.polydata(True)) confilter.SetExtractionModeToLargestRegion() confilter.Update() cpd = vtk.vtkCleanPolyData() cpd.SetInputData(confilter.GetOutput()) cpd.Update() w = vtk.vtkPolyDataWriter() w.SetInputData(cpd.GetOutput()) w.SetFileName(fname) w.Write() colors.printc("~save Saved file:", fname, c="m") vp.cutterWidget.Off() vp.cutterWidget = None else: for a in vp.actors: if isinstance(a, vtk.vtkVolume): addons.addCutterTool(a) return colors.printc( "Click an actor and press X to open the cutter box widget.", c=4) elif key == "i": # print info if vp.clickedActor: utils.printInfo(vp.clickedActor) else: utils.printInfo(vp) if iren: iren.Render()
""" VTK render model """ import logging from atom.api import Atom, Dict, Str, observe, Value, Int, Tuple, List from functools import partial import vtk logging.basicConfig(format="%(asctime)s: %(levelname)s: %(message)s", level=logging.DEBUG) INTERACTION_STYLES = { "TrackBallActor": vtk.vtkInteractorStyleTrackballActor(), "TrackBallCamera": vtk.vtkInteractorStyleTrackballCamera(), # default style "JoystickCamera": vtk.vtkInteractorStyleJoystickCamera(), "JoystickActor": vtk.vtkInteractorStyleJoystickActor(), "Terrain": vtk.vtkInteractorStyleTerrain(), } class VTKRenderController(Atom): """ vtk render controller - supply renderers to VTKCanvas """ zoomFactor = Value() numOfRenderers = Int() callbacks = Dict() customPorts = Dict() customBackgrounds = Dict()
import vtk # create a rendering window and renderer ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) # create a renderwindowinteractor iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) style = vtk.vtkInteractorStyleTrackballActor() iren.SetInteractorStyle(style) # create source sphereSource = vtk.vtkSphereSource() sphereSource.Update() # mapper mapper = vtk.vtkPolyDataMapper() mapper.SetInput(sphereSource.GetOutput()) # actor actor = vtk.vtkActor() actor.SetMapper(mapper) # assign actor to the renderer ren.AddActor(actor) # enable user interface interactor iren.Initialize()
""" VTK render model """ import logging from atom.api import Atom, Dict, Str, observe, Value, Int, Tuple, List from functools import partial import vtk logging.basicConfig(format='%(asctime)s: %(levelname)s: %(message)s', level=logging.DEBUG) INTERACTION_STYLES = { 'TrackBallActor': vtk.vtkInteractorStyleTrackballActor(), 'TrackBallCamera': vtk.vtkInteractorStyleTrackballCamera(), # default style 'JoystickCamera': vtk.vtkInteractorStyleJoystickCamera(), 'JoystickActor': vtk.vtkInteractorStyleJoystickActor(), 'Terrain': vtk.vtkInteractorStyleTerrain(), } class VTKRenderController(Atom): """ vtk render controller - supply renderers to VTKCanvas """ zoomFactor = Value() numOfRenderers = Int() callbacks = Dict() customPorts = Dict() customBackgrounds = Dict()
transformFilter.Update() #print("applying transform",transformFilter.GetScale()) mapper2 = vtk.vtkPolyDataMapper() mapper2.SetInputData(transformFilter.GetOutput()) actor2 = vtk.vtkActor() actor2.SetMapper(mapper2) renderer = vtk.vtkRenderer() renderWin = vtk.vtkRenderWindow() interactor = vtk.vtkRenderWindowInteractor() renderWin.AddRenderer(renderer) interactor.SetRenderWindow(renderWin) interactor.SetInteractorStyle(vtk.vtkInteractorStyleTrackballActor()) # renderer.AddActor(actor1) renderer.AddActor(actor2) renderer.SetBackground(1,1,1) renderWin.Render() interactor.Start()