def clipping_plane(v, interactor, event): if interactor.GetKeyCode() == "c": planew = vtk.vtkImplicitPlaneWidget() planew.SetInteractor(v.getInteractor()) plane = vtk.vtkPlane() planew.GetPlane(plane) planew.PlaceWidget() v.volume_mapper.AddClippingPlane(plane) v.plane = plane v.planew = planew
def BuildView(self): if not self.vmtkRenderer: self.vmtkRenderer = vmtkrenderer.vmtkRenderer() self.vmtkRenderer.Initialize() self.OwnRenderer = 1 self.vmtkRenderer.RegisterScript(self) self.PlaneWidget = vtk.vtkImplicitPlaneWidget() if self.Actor != None: self.vmtkRenderer.Renderer.RemoveActor(self.Actor) if self.Mesh != None: self.MeshCutFilter = vtk.vtkCutter() self.MeshCutFilter.SetInputData(self.Mesh) cutPlane = vtk.vtkPlane() self.PlaneWidget.GetPlane(cutPlane) self.MeshCutFilter.SetCutFunction(cutPlane) self.MeshCutFilter.Update() self.Surface = self.MeshCutFilter.GetOutput() self.PlaneWidget.AddObserver("StartInteractionEvent", self.StartPlaneCallback) self.PlaneWidget.AddObserver("EndInteractionEvent", self.EndPlaneCallback) mapper = vtk.vtkDataSetMapper() mapper.SetInputData(self.Mesh) self.Actor = vtk.vtkActor() self.Actor.SetMapper(mapper) self.vmtkRenderer.Renderer.AddActor(self.Actor) self.Actor.GetProperty().SetOpacity(self.Opacity) self.PlaneWidget.SetInteractor( self.vmtkRenderer.RenderWindowInteractor) self.PlaneWidget.SetPlaceFactor(1.25) self.PlaneWidget.DrawPlaneOn() self.PlaneWidget.GetPlaneProperty().SetOpacity(0.1) self.PlaneWidget.SetProp3D(self.Actor) self.PlaneWidget.PlaceWidget() self.PlaneWidget.SetOrigin(self.Actor.GetCenter()) self.PlaneWidget.On() if (self.Display == 1): self.vmtkRenderer.Render() if self.OwnRenderer: self.vmtkRenderer.Deallocate()
def BuildView(self): if not self.vmtkRenderer: self.vmtkRenderer = vmtkrenderer.vmtkRenderer() self.vmtkRenderer.Initialize() self.OwnRenderer = 1 self.vmtkRenderer.RegisterScript(self) self.PlaneWidget = vtk.vtkImplicitPlaneWidget() if self.Actor != None: self.vmtkRenderer.Renderer.RemoveActor(self.Actor) if self.Mesh != None: self.MeshCutFilter = vtk.vtkCutter() self.MeshCutFilter.SetInputData(self.Mesh) cutPlane = vtk.vtkPlane() self.PlaneWidget.GetPlane(cutPlane) self.MeshCutFilter.SetCutFunction(cutPlane) self.MeshCutFilter.Update() self.Surface = self.MeshCutFilter.GetOutput() self.PlaneWidget.AddObserver("StartInteractionEvent",self.StartPlaneCallback) self.PlaneWidget.AddObserver("EndInteractionEvent",self.EndPlaneCallback) mapper = vtk.vtkDataSetMapper() mapper.SetInputData(self.Mesh) self.Actor = vtk.vtkActor() self.Actor.SetMapper(mapper) self.vmtkRenderer.Renderer.AddActor(self.Actor) self.Actor.GetProperty().SetOpacity(self.Opacity) self.PlaneWidget.SetInteractor(self.vmtkRenderer.RenderWindowInteractor) self.PlaneWidget.SetPlaceFactor(1.25) self.PlaneWidget.DrawPlaneOn() self.PlaneWidget.GetPlaneProperty().SetOpacity(0.1) self.PlaneWidget.SetProp3D(self.Actor) self.PlaneWidget.PlaceWidget() self.PlaneWidget.SetOrigin(self.Actor.GetCenter()) self.PlaneWidget.On() if (self.Display == 1): self.vmtkRenderer.Render() if self.OwnRenderer: self.vmtkRenderer.Deallocate()
def createPlaneWidget(ugrid): planeWidget = vtk.vtkImplicitPlaneWidget() planeWidget.SetPlaceFactor(1.25) planeWidget.SetInput(ugrid) planeWidget.PlaceWidget(ugrid.GetBounds()) planeWidget.NormalToXAxisOn() planeWidget.DrawPlaneOff() planeWidget.TubingOn() planeWidget.OutlineTranslationOff() planeWidget.ScaleEnabledOff() planeWidget.GetNormalProperty().SetColor(.6, .1, 1) planeWidget.GetSelectedNormalProperty().SetColor(.4, .4, 4) planeWidget.GetEdgesProperty().SetLineWidth(.6) planeWidget.SetHandleSize(.01) return planeWidget
def update_pipeline(self): if self.isoActor is not None: self.renderer.RemoveActor(self.isoActor) pipe = self.marchingCubes if self.useConnect: self.connect.SetInput( pipe.GetOutput()) pipe = self.connect if self.useDecimate: self.deci.SetInput( pipe.GetOutput()) pipe = self.deci if 0: plane = vtk.vtkPlane() clipper = vtk.vtkClipPolyData() polyData = pipe.GetOutput() clipper.SetInput(polyData) clipper.SetClipFunction(plane) clipper.InsideOutOff() pipe = clipper def callback(pw, event): pw.GetPlane(plane) self.interactor.Render() self.planeWidget = vtk.vtkImplicitPlaneWidget() self.planeWidget.SetInteractor(self.interactor) self.planeWidget.On() self.planeWidget.SetPlaceFactor(1.0) self.planeWidget.SetInput(polyData) self.planeWidget.PlaceWidget() self.planeWidget.AddObserver("InteractionEvent", callback) self.isoMapper = vtk.vtkPolyDataMapper() self.isoMapper.SetInput(pipe.GetOutput()) self.isoMapper.ScalarVisibilityOff() self.isoActor = vtk.vtkActor() self.isoActor.SetMapper(self.isoMapper) self.renderer.AddActor(self.isoActor) self.update_properties()
def makePlaneWidget(vtkObj,iren): """Make an interactive planeWidget""" # Associate the line widget with the interactor planeWidget = vtk.vtkImplicitPlaneWidget() planeWidget.SetInteractor(iren) planeWidget.SetInput(vtkObj ) planeWidget.SetPlaceFactor(1.05) # Increases the size of the widget bounds planeWidget.PlaceWidget(vtkObj.GetBounds()) b1,b2,b3 = vtkObj.GetBounds()[::2] planeWidget.SetOrigin(b1,b2,b3) #planeWidget.AddObserver("InteractionEvent", movePlane) planeWidget.SetOutsideBounds(0) # Not allow the widget to move outside the input bounds planeWidget.SetScaleEnabled(0) # Ability to scale with the mouse planeWidget.SetEnabled(1) # Starts the widget planeWidget.SetOutlineTranslation(0) # Abiltiy to move the widget with the mouse planeWidget.GetPlaneProperty().SetOpacity(0.1) return planeWidget
def makePlaneWidget(vtkObj,iren,plane,actor): """Make an interactive planeWidget""" # Callback function def movePlane(obj, events): obj.GetPlane(intPlane) intActor.VisibilityOn() # Associate the line widget with the interactor planeWidget = vtk.vtkImplicitPlaneWidget() planeWidget.SetInteractor(iren) planeWidget.SetPlaceFactor(1.25) planeWidget.SetInput(vtkObj) planeWidget.PlaceWidget() #planeWidget.AddObserver("InteractionEvent", movePlane) planeWidget.SetScaleEnabled(0) planeWidget.SetEnabled(1) planeWidget.SetOutlineTranslation(0) planeWidget.GetPlaneProperty().SetOpacity(0.1) return planeWidget
def initPlaneWidget(self): """Sets up vtkImplicitPlaneWidget for plane selection. Sets also up necessary actor and mapper. Returns: vtk.vtkImplicitPlaneWidget: Widget. """ # Initialize a plane widget self.planeWidget = vtk.vtkImplicitPlaneWidget() self.planeWidget.SetInteractor(self.iren) self.planeWidget.SetPlaceFactor(1.25) self.planeWidget.SetInput(self.grid) self.planeWidget.PlaceWidget() # Callback connection of interaction event self.planeWidget.AddObserver("InteractionEvent", self.StartPlaneCallback) self.planeWidget.AddObserver("EndInteractionEvent",self.EndPlaneCallback) # Mapper self.selectMapper = vtk.vtkDataSetMapper() self.selectMapper.SetInput(self.grid) # Actor self.selectActor = vtk.vtkLODActor() self.selectActor.SetMapper(self.selectMapper) self.selectActor.GetProperty().SetColor(0, 1, 0) self.selectActor.VisibilityOff() self.selectActor.SetScale(1.01, 1.01, 1.01) self.ren.AddActor(self.selectActor) # Place widget at right position self.planeWidget.SetNormal(0,0,1) self.planeWidget.SetOrigin(self.grid.GetCenter()) return self.planeWidget
def initPlaneWidget(self): """Sets up vtkImplicitPlaneWidget for plane selection. Sets also up necessary actor and mapper. Returns: vtk.vtkImplicitPlaneWidget: Widget. """ # Initialize a plane widget self.planeWidget = vtk.vtkImplicitPlaneWidget() self.planeWidget.SetInteractor(self.iren) self.planeWidget.SetPlaceFactor(1.25) self.planeWidget.SetInput(self.grid) self.planeWidget.PlaceWidget() # Callback connection of interaction event self.planeWidget.AddObserver("InteractionEvent", self.StartPlaneCallback) self.planeWidget.AddObserver("EndInteractionEvent", self.EndPlaneCallback) # Mapper self.selectMapper = vtk.vtkDataSetMapper() self.selectMapper.SetInput(self.grid) # Actor self.selectActor = vtk.vtkLODActor() self.selectActor.SetMapper(self.selectMapper) self.selectActor.GetProperty().SetColor(0, 1, 0) self.selectActor.VisibilityOff() self.selectActor.SetScale(1.01, 1.01, 1.01) self.ren.AddActor(self.selectActor) # Place widget at right position self.planeWidget.SetNormal(0, 0, 1) self.planeWidget.SetOrigin(self.grid.GetCenter()) return self.planeWidget
def Plane(self): if(self.planew != None): self.info_text.appendPlainText (_fromUtf8("Nelze použít více rovin najednou. Nejdříve proveďte řez")) else: planeWidget = vtk.vtkImplicitPlaneWidget() # předaní interaktoru objektu roviny planeWidget.SetInteractor(self.iren) # nastavení velikosti prostoru ve kterém se může rovina pohybovat planeWidget.SetPlaceFactor(1.5) # nastavení vstupních dat planeWidget.SetInput(surface.GetOutput()) planeWidget.PlaceWidget() planeWidget.TubingOff() planeWidget.OutsideBoundsOff() planeWidget.ScaleEnabledOff() planeWidget.OutlineTranslationOff() planeWidget.AddObserver("InteractionEvent", self.Cutter) planeWidget.On() self.planew = planeWidget self.planew.SetNormal(2.0,0.0,0.0)
def plot(self, struct): # creates self. data1, legend, filename, fieldname, dim, has_field, tracker, revision if not self.call_config(struct): return # creates self.src if not self.call_src(): return # postponed widget processing if self.has_field: self.add_scalarbar_1() self.add_abs_rel_1() self.add_outline_1() self.add_plane_1() self.add_sw_1() self.add_opacity_1(selection=0) # Opacity: 100%/75%/50%/25%/0% # vector self.plane = vtk.vtkPlane() self.origin = self.src.GetOutput().GetCenter() print 'center', self.origin # self.plane.SetOrigin(self.origin) #xml # self.plane.SetNormal(1, 1, 1) #xml self.clipper = vtk.vtkExtractGeometry() self.clipper.SetInputConnection(self.src.GetOutputPort()) self.clipper.SetImplicitFunction(self.plane) self.clipper.ExtractInsideOn() # +/- # self.clipper.ExtractBoundaryCellsOn() # inclue as que estan parcialmente dentro # self.clipper.ExtractOnlyBoundaryCellsOn() self.pdM = vtk.vtkDataSetMapper() self.pdM.SetInputConnection(self.clipper.GetOutputPort()) if self.has_field: self.pdM.ScalarVisibilityOn() else: self.pdM.ScalarVisibilityOff() self.scalarrange.local_set(self.src.GetOutput().GetScalarRange()) # reverse rainbow [red->blue] -> [blue->red] look = self.pdM.GetLookupTable() # self.add_scalarbar_2(look) self.add_outline_2(self.src) self.cutA = vtk.vtkActor() self.cutA.SetMapper(self.pdM) self.cutA.GetProperty().SetRepresentationToSurface() self.cutA.GetProperty().SetColor(Plot.mesh_color) self.rens[0].AddActor(self.cutA) # poñendo a scalarbar aquí e non antes, queda ben dibuxada desde o primeiro (non negra) if self.has_field: self.add_scalarbar_2(look) self.add_abs_rel_2(self.src, self.clipper) self.add_sw_2(self.cutA) self.add_opacity_2([self.cutA]) # Opacity: 100%/75%/50%/25%/0% # mover plano interactivamente #self.planeI = vtk.vtkPlaneWidget() self.planeI = vtk.vtkImplicitPlaneWidget() seeds = vtk.vtkPolyData() if vtk.vtkVersion.GetVTKMajorVersion() < 6: self.planeI.SetInput(self.src.GetOutput()) else: self.planeI.SetInputConnection(self.src.GetOutputPort()) self.add_plane_2(self.planeI) self.planeI.SetOrigin(self.origin[0], self.origin[1], self.origin[2]) #self.planeI.SetResolution(20) #planeWidget.NormalToXAxisOn() #planeWidget.SetRepresentationToOutline() #self.planeI.PlaceWidget() self.planeI.GetPolyData(seeds) self.planeI.SetPlaceFactor(1.0) # factor * bounds self.planeI.OutsideBoundsOn() # not on PlaneWidget self.planeI.OutlineTranslationOff() self.planeI.DrawPlaneOff() self.planeI.ScaleEnabledOff() self.planeI.PlaceWidget() #self.planeI.PlaceWidget(self.src.GetOutput().GetBounds()) self.planeI.AddObserver("EndInteractionEvent", self.event_end) self.set_iren() self.planeI.SetInteractor(self.iren) self.planeI.On() # self.lineI.AddObserver("StartInteractionEvent", self.event_start) # self.lineI.AddObserver("InteractionEvent", self.event) # self.lineI.AddObserver("EndInteractionEvent", self.event_end) # /mover plano interactivamente if interactive2 and self.has_field: #self.set_iren() #necesario ^ self.clicker = ClickLabel.ClickLabel() self.clicker.set_point_cell(self.data1.get('fielddomain')) self.clicker.set_objects(self.clipper, self.rens[0], self.iren, self.widget) self.clicker.set_props([self.cutA]) self.clicker.setup() o = self.planeI.GetOrigin() n = self.planeI.GetNormal() print 'initial: o,n', o, n self.set_params(struct, o, n) # not force first time self.copy_params(struct) self.done = True
renderer.RemoveViewProp(actoriso) # Clip the data cf = vtk.vtkClipDataSet() # Set the clipping plane plane = vtk.vtkPlane() cf.SetClipFunction(plane) print plane # Set the plane origin plane.SetOrigin(560000, 5120000, 2000) # Connect the pipeline cf.SetInputConnection(warp.GetOutputPort()) mapper.SetInputConnection(cf.GetOutputPort()) # Step 8 - Clipping Widget interaction # Creates an implicit plane widget widget = vtk.vtkImplicitPlaneWidget() widget.PlaceWidget(warp.GetOutput().GetBounds()) widget.SetOrigin([plane.GetOrigin()[x] for x in 0, 1, 2]) widget.SetNormal([plane.GetNormal()[x] for x in 0, 1, 2]) widget.SetInteractor(iren) # Connects the interaction event to the plane def cb(obj, event): global plane obj.GetPlane(plane) widget.AddObserver("InteractionEvent", cb) widget.SetEnabled(1) widget.DrawPlaneOn()
import misc ''' Používané globální proměnné ''' plane = vtk.vtkPlane() normal = None coordinates = None iren = vtk.vtkRenderWindowInteractor() surface = vtk.vtkDataSetSurfaceFilter() app = QApplication(sys.argv) label = QtGui.QLabel() myLayout = QGridLayout() widget = vtk.vtkSphereSource() planeWidget = vtk.vtkImplicitPlaneWidget() ''' Kód grafického editoru resekční linie. Tento kód byl automaticky vygenerován pomocí programu Qt Designer ''' ##------------------------------------------------------------------------------------------ try: _fromUtf8 = QtCore.QString.fromUtf8 except AttributeError: def _fromUtf8(s): return s try: _encoding = QtGui.QApplication.UnicodeUTF8 def _translate(context, text, disambig):
def BuildView(self): if not self.vmtkRenderer: self.vmtkRenderer = vmtkrenderer.vmtkRenderer() self.vmtkRenderer.Initialize() self.OwnRenderer = 1 if self.Actor != None: self.vmtkRenderer.Renderer.RemoveActor(self.Actor) if self.ScalarBarActor != None: self.vmtkRenderer.Renderer.RemoveActor(self.ScalarBarActor) if self.Mesh != None: self.InitialMesh = self.Mesh self.DisplayMesh = self.Mesh mapper = vtk.vtkDataSetMapper() mapper.SetInputData(self.DisplayMesh) array = None if (self.ArrayName != ''): if self.DisplayCellData == 0: self.Mesh.GetPointData().SetActiveScalars(self.ArrayName) array = self.Mesh.GetPointData().GetScalars() else: self.Mesh.GetCellData().SetActiveScalars(self.ArrayName) array = self.Mesh.GetCellData().GetScalars() mapper.SetScalarModeToUseCellData() if (array != None): if (self.ScalarRange[1] > self.ScalarRange[0]): mapper.SetScalarRange(self.ScalarRange) else: mapper.SetScalarRange(array.GetRange(0)) if (self.Grayscale == 1): lut = vtk.vtkLookupTable() lut.SetValueRange(0.0, 1.0) lut.SetSaturationRange(0.0, 0.0) mapper.SetLookupTable(lut) self.Actor = vtk.vtkActor() self.Actor.SetMapper(mapper) if (self.Color[0] >= 0.0): self.Actor.GetProperty().SetColor(self.Color) if (self.FlatInterpolation == 1): self.Actor.GetProperty().SetInterpolationToFlat() self.Actor.GetProperty().SetOpacity(self.Opacity) self.vmtkRenderer.Renderer.AddActor(self.Actor) if (self.Legend == 1) & (self.Actor != None): self.ScalarBarActor = vtk.vtkScalarBarActor() self.ScalarBarActor.SetLookupTable( self.Actor.GetMapper().GetLookupTable()) self.ScalarBarActor.GetLabelTextProperty().ItalicOff() self.ScalarBarActor.GetLabelTextProperty().BoldOff() self.ScalarBarActor.GetLabelTextProperty().ShadowOff() ## self.ScalarBarActor.GetLabelTextProperty().SetColor(0.0,0.0,0.0) self.ScalarBarActor.SetLabelFormat('%.2f') self.vmtkRenderer.Renderer.AddActor(self.ScalarBarActor) #self.vmtkRenderer.RenderWindowInteractor.AddObserver("KeyPressEvent", self.KeyPressed) self.vmtkRenderer.AddKeyBinding('i', 'Interact.', self.InteractCallback) self.vmtkRenderer.AddKeyBinding('c', 'Clip.', self.ClipCallback) self.vmtkRenderer.AddKeyBinding('e', 'Extract.', self.ExtractCallback) self.vmtkRenderer.AddKeyBinding('n', 'Show clipped area.', self.NCallback) self.vmtkRenderer.AddKeyBinding('d', 'Switch clipped/unclipped area.', self.DCallback) self.vmtkRenderer.AddKeyBinding('t', 'Redo.', self.TCallback) self.vmtkRenderer.AddKeyBinding('u', 'Undo.', self.UndoCallback) self.PlaneWidget = vtk.vtkImplicitPlaneWidget() self.PlaneWidget.SetInteractor( self.vmtkRenderer.RenderWindowInteractor) self.PlaneWidget.SetPlaceFactor(1.25) self.PlaneWidget.DrawPlaneOff() self.PlaneWidget.SetProp3D(self.Actor) self.PlaneWidget.PlaceWidget() #Work around bug/strange behaviour in vtk self.PlaneWidget.SetOrigin(self.Actor.GetCenter()) if (self.Display == 1): self.vmtkRenderer.Render() self.Mesh = self.InitialMesh if self.OwnRenderer: self.vmtkRenderer.Deallocate()
def add_plane_widget(self, callback, normal='x', origin=None, bounds=None, factor=1.25, color=None, assign_to_axis=None, tubing=False, outline_translation=False, origin_translation=True, implicit=True, pass_widget=False, test_callback=True): """Add a plane widget to the scene. This is useless without a callback function. You can pass a callable function that takes two arguments, the normal and origin of the plane in that order output from this widget, and performs a task with that plane. Parameters ---------- callback : callable The method called every time the plane is updated. Takes two arguments, the normal and origin of the plane in that order. normal : str or tuple(float) The starting normal vector of the plane origin : tuple(float) The starting coordinate of the center of the place bounds : tuple(float) Length 6 tuple of the bounding box where the widget is placed. factor : float, optional An inflation factor to expand on the bounds when placing color : string or 3 item list, optional, defaults to white Either a string, rgb list, or hex color string. assign_to_axis : str or int Assign the normal of the plane to be parallel with a given axis: options are (0, 'x'), (1, 'y'), or (2, 'z'). tubing : bool When using an implicit plane wiget, this controls whether or not tubing is shown around the plane's boundaries. outline_translation : bool If ``False``, the plane widget cannot be translated and is strictly placed at the given bounds. Only valid when using an implicit plane. origin_translation : bool If ``False``, the plane widget cannot be translated by its origin and is strictly placed at the given origin. Only valid when using an implicit plane. implicit : bool When ``True``, a ``vtkImplicitPlaneWidget`` is ued and when ``False``, a ``vtkPlaneWidget`` is used. pass_widget : bool If true, the widget will be passed as the last argument of the callback test_callback: bool if true, run the callback function after the widget is created. """ if hasattr(self, 'notebook') and self.notebook: raise AssertionError( 'Plane widget not available in notebook plotting') if not hasattr(self, 'iren'): raise AttributeError( 'Widgets must be used with an intereactive renderer. No off screen plotting.' ) if not hasattr(self, "plane_widgets"): self.plane_widgets = [] if origin is None: origin = self.center if bounds is None: bounds = self.bounds if isinstance(normal, str): normal = NORMALS[normal.lower()] if color is None: color = rcParams['font']['color'] def _the_callback(widget, event_id): the_plane = vtk.vtkPlane() widget.GetPlane(the_plane) normal = the_plane.GetNormal() origin = the_plane.GetOrigin() if hasattr(callback, '__call__'): if pass_widget: try_callback(callback, normal, origin, widget) else: try_callback(callback, normal, origin) return if implicit: plane_widget = vtk.vtkImplicitPlaneWidget() plane_widget.GetNormalProperty().SetColor(parse_color(color)) plane_widget.GetOutlineProperty().SetColor(parse_color(color)) plane_widget.GetOutlineProperty().SetColor(parse_color(color)) plane_widget.SetTubing(tubing) plane_widget.SetOutlineTranslation(outline_translation) plane_widget.SetOriginTranslation(origin_translation) _start_interact = lambda plane_widget, event: plane_widget.SetDrawPlane( True) _stop_interact = lambda plane_widget, event: plane_widget.SetDrawPlane( False) plane_widget.SetDrawPlane(False) plane_widget.AddObserver(vtk.vtkCommand.StartInteractionEvent, _start_interact) plane_widget.AddObserver(vtk.vtkCommand.EndInteractionEvent, _stop_interact) plane_widget.SetPlaceFactor(factor) plane_widget.PlaceWidget(bounds) plane_widget.SetOrigin(origin) else: # Position of the small plane source = vtk.vtkPlaneSource() source.SetNormal(normal) source.SetCenter(origin) source.SetPoint1(origin[0] + (bounds[1] - bounds[0]) * 0.01, origin[1] - (bounds[3] - bounds[2]) * 0.01, origin[2]) source.SetPoint2(origin[0] - (bounds[1] - bounds[0]) * 0.01, origin[1] + (bounds[3] - bounds[2]) * 0.01, origin[2]) source.Update() plane_widget = vtk.vtkPlaneWidget() plane_widget.SetHandleSize(.01) # Position of the widget plane_widget.SetInputData(source.GetOutput()) plane_widget.SetRepresentationToOutline() plane_widget.SetPlaceFactor(factor) plane_widget.PlaceWidget(bounds) plane_widget.SetCenter(origin) # Necessary plane_widget.GetPlaneProperty().SetColor( parse_color(color)) # self.C_LOT[fn]) plane_widget.GetHandleProperty().SetColor(parse_color(color)) plane_widget.GetPlaneProperty().SetOpacity(0.5) plane_widget.SetInteractor(self.iren) plane_widget.SetCurrentRenderer(self.renderer) if assign_to_axis: # TODO: how do we now disable/hide the arrow? if assign_to_axis in [0, "x", "X"]: plane_widget.NormalToXAxisOn() plane_widget.SetNormal(NORMALS["x"]) elif assign_to_axis in [1, "y", "Y"]: plane_widget.NormalToYAxisOn() plane_widget.SetNormal(NORMALS["y"]) elif assign_to_axis in [2, "z", "Z"]: plane_widget.NormalToZAxisOn() plane_widget.SetNormal(NORMALS["z"]) else: raise RuntimeError("assign_to_axis not understood") else: plane_widget.SetNormal(normal) plane_widget.Modified() plane_widget.UpdatePlacement() plane_widget.On() plane_widget.AddObserver(vtk.vtkCommand.EndInteractionEvent, _the_callback) if test_callback: _the_callback(plane_widget, None) # Trigger immediate update self.plane_widgets.append(plane_widget) return plane_widget
def BuildView(self): if not self.vmtkRenderer: self.vmtkRenderer = vmtkrenderer.vmtkRenderer() self.vmtkRenderer.Initialize() self.OwnRenderer = 1 if self.Actor != None: self.vmtkRenderer.Renderer.RemoveActor(self.Actor) if self.ScalarBarActor != None: self.vmtkRenderer.Renderer.RemoveActor(self.ScalarBarActor) if self.Mesh != None: self.InitialMesh = self.Mesh self.DisplayMesh = self.Mesh mapper = vtk.vtkDataSetMapper() mapper.SetInputData(self.DisplayMesh) array = None if (self.ArrayName != ''): if self.DisplayCellData == 0: self.Mesh.GetPointData().SetActiveScalars(self.ArrayName) array = self.Mesh.GetPointData().GetScalars() else: self.Mesh.GetCellData().SetActiveScalars(self.ArrayName) array = self.Mesh.GetCellData().GetScalars() mapper.SetScalarModeToUseCellData() if (array != None): if (self.ScalarRange[1] > self.ScalarRange[0]): mapper.SetScalarRange(self.ScalarRange) else: mapper.SetScalarRange(array.GetRange(0)) if (self.Grayscale == 1): lut = vtk.vtkLookupTable() lut.SetValueRange(0.0,1.0) lut.SetSaturationRange(0.0,0.0) mapper.SetLookupTable(lut) self.Actor = vtk.vtkActor() self.Actor.SetMapper(mapper) if (self.Color[0] >= 0.0): self.Actor.GetProperty().SetColor(self.Color) if (self.FlatInterpolation == 1): self.Actor.GetProperty().SetInterpolationToFlat() self.Actor.GetProperty().SetOpacity(self.Opacity) self.vmtkRenderer.Renderer.AddActor(self.Actor) if (self.Legend == 1) & (self.Actor != None): self.ScalarBarActor = vtk.vtkScalarBarActor() self.ScalarBarActor.SetLookupTable(self.Actor.GetMapper().GetLookupTable()) self.ScalarBarActor.GetLabelTextProperty().ItalicOff() self.ScalarBarActor.GetLabelTextProperty().BoldOff() self.ScalarBarActor.GetLabelTextProperty().ShadowOff() ## self.ScalarBarActor.GetLabelTextProperty().SetColor(0.0,0.0,0.0) self.ScalarBarActor.SetLabelFormat('%.2f') self.vmtkRenderer.Renderer.AddActor(self.ScalarBarActor) #self.vmtkRenderer.RenderWindowInteractor.AddObserver("KeyPressEvent", self.KeyPressed) self.vmtkRenderer.AddKeyBinding('i','Interact.',self.InteractCallback) self.vmtkRenderer.AddKeyBinding('c','Clip.',self.ClipCallback) self.vmtkRenderer.AddKeyBinding('e','Extract.',self.ExtractCallback) self.vmtkRenderer.AddKeyBinding('n','Show clipped area.',self.NCallback) self.vmtkRenderer.AddKeyBinding('d','Switch clipped/unclipped area.',self.DCallback) self.vmtkRenderer.AddKeyBinding('t','Redo.',self.TCallback) self.vmtkRenderer.AddKeyBinding('u','Undo.',self.UndoCallback) self.PlaneWidget = vtk.vtkImplicitPlaneWidget() self.PlaneWidget.SetInteractor(self.vmtkRenderer.RenderWindowInteractor) self.PlaneWidget.SetPlaceFactor(1.25) self.PlaneWidget.DrawPlaneOff() self.PlaneWidget.SetProp3D(self.Actor) self.PlaneWidget.PlaceWidget() #Work around bug/strange behaviour in vtk self.PlaneWidget.SetOrigin(self.Actor.GetCenter()) if (self.Display == 1): self.vmtkRenderer.Render() self.Mesh = self.InitialMesh if self.OwnRenderer: self.vmtkRenderer.Deallocate()
def _createImplicit(self, implicitType, implicitName, bounds, primaryInput): if implicitType in self._implicitTypes and \ implicitName not in self._implicitsDict: pi = primaryInput rwi = self.slice3dVWR.threedFrame.threedRWI implicitInfoBounds = None if implicitType == "Plane": implicitWidget = vtk.vtkImplicitPlaneWidget() implicitWidget.SetPlaceFactor(1.25) if pi != None: implicitWidget.SetInput(pi) implicitWidget.PlaceWidget() b = pi.GetBounds() implicitWidget.SetOrigin(b[0], b[2], b[4]) implicitInfoBounds = b elif bounds != None: implicitWidget.PlaceWidget(bounds) implicitWidget.SetOrigin(bounds[0], bounds[2], bounds[4]) implicitInfoBounds = bounds else: # this can never happen pass implicitWidget.SetInteractor(rwi) implicitWidget.On() # create the implicit function implicitFunction = vtk.vtkPlane() # sync it to the initial widget self._syncPlaneFunctionToWidget(implicitWidget) # add it to the output self.outputImplicitFunction.AddFunction(implicitFunction) # now add an observer to the widget def observerImplicitPlaneWidget(widget, eventName): # sync it to the initial widget ret = self._syncPlaneFunctionToWidget(widget) # also select the correct grid row if ret != None: name, ii = ret row = self.findGridRowByName(name) if row >= 0: self._grid.SelectRow(row) oId = implicitWidget.AddObserver('EndInteractionEvent', observerImplicitPlaneWidget) elif implicitType == "Sphere": implicitWidget = vtk.vtkSphereWidget() implicitWidget.SetPlaceFactor(1.25) implicitWidget.TranslationOn() implicitWidget.ScaleOn() #implicitWidget.HandleVisibilityOn() if pi != None: implicitWidget.SetInput(pi) implicitWidget.PlaceWidget() b = pi.GetBounds() implicitInfoBounds = b #implicitWidget.SetOrigin(b[0], b[2], b[4]) elif bounds != None: implicitWidget.PlaceWidget(bounds) implicitInfoBounds = bounds #implicitWidget.SetOrigin(bounds[0], bounds[2], bounds[4]) else: # this can never happen pass implicitWidget.SetInteractor(rwi) implicitWidget.On() # create the implicit function implicitFunction = vtk.vtkSphere() # sync it to the initial widget self._syncSphereFunctionToWidget(implicitWidget) # add it to the output self.outputImplicitFunction.AddFunction(implicitFunction) # now add an observer to the widget def observerImplicitSphereWidget(widget, eventName): # sync it to the initial widget ret = self._syncSphereFunctionToWidget(widget) # also select the correct grid row if ret != None: name, ii = ret row = self.findGridRowByName(name) if row >= 0: self._grid.SelectRow(row) oId = implicitWidget.AddObserver('EndInteractionEvent', observerImplicitSphereWidget) if implicitWidget: # set the priority so it gets interaction before the # ImagePlaneWidget. 3D widgets have default priority 0.5, # so we assign our widgets just a tad higher. (voiwidget # has 0.6 for example) # NB: in a completely weird twist of events, only slices # added AFTER this widget will act like they have lower # priority. The initial slice still takes events from us! implicitWidget.SetPriority(0.7) # add to our internal thingy ii = implicitInfo() ii.name = implicitName ii.type = implicitType ii.widget = implicitWidget ii.bounds = implicitInfoBounds ii.oId = oId ii.function = implicitFunction self._implicitsDict[implicitName] = ii # now add to the grid nrGridRows = self._grid.GetNumberRows() self._grid.AppendRows() self._grid.SetCellValue(nrGridRows, self._gridNameCol, implicitName) self._grid.SetCellValue(nrGridRows, self._gridTypeCol, implicitType) # set the relevant cells up for Boolean for col in [self._gridEnabledCol]: self._grid.SetCellRenderer(nrGridRows, col, wx.grid.GridCellBoolRenderer()) self._grid.SetCellAlignment(nrGridRows, col, wx.ALIGN_CENTRE, wx.ALIGN_CENTRE) self._setImplicitEnabled(ii.name, True)
def testSlice(self): global plane, filter, args writefiles = "SaveData" in args renderer = vtk.vtkRenderer() renwin = vtk.vtkRenderWindow() renwin.AddRenderer(renderer) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renwin) renwin.Render() if "GPURender" in args: vtk.vtkPistonMapper.InitCUDAGL(renwin) src = vtk.vtkImageMandelbrotSource() src.SetWholeExtent(0, 20, 0, 20, 0, 20) #scale and bias until piston understands origin and spacing src.Update() inputdata = src.GetOutput() if "Normalize" in args: testdata1 = inputdata.NewInstance() testdata1.ShallowCopy(inputdata) testdata1.SetSpacing(1, 1, 1) testdata1.SetOrigin(0, 0, 0) inputdata = testdata1 bounds = inputdata.GetBounds() center = [(bounds[1] - bounds[0]) / 2 + bounds[0], (bounds[3] - bounds[2]) / 2 + bounds[2], (bounds[5] - bounds[4]) / 2 + bounds[4]] d2p = vtk.vtkDataSetToPiston() d2p.SetInputData(inputdata) #d2p.SetInputConnection(src.GetOutputPort()) plane = vtk.vtkPlane() plane.SetOrigin(center) plane.SetNormal(0, 0, 1) filter = vtk.vtkPistonSlice() filter.SetInputConnection(d2p.GetOutputPort()) filter.SetClippingPlane(plane) filter.SetOffset(0.0) p2d = vtk.vtkPistonToDataSet() p2d.SetOutputDataSetType(vtk.VTK_POLY_DATA) p2d.SetInputConnection(filter.GetOutputPort()) if writefiles: writeFile(p2d, "piston_slice.vtk") mapper = vtk.vtkPistonMapper() mapper.SetInputConnection(filter.GetOutputPort()) mapper.Update() #TODO why is this necessary actor = vtk.vtkActor() actor.SetMapper(mapper) renderer.AddActor(actor) widget = vtk.vtkImplicitPlaneWidget() widget.PlaceWidget(bounds) widget.SetOrigin([plane.GetOrigin()[x] for x in 0, 1, 2]) widget.SetNormal([plane.GetNormal()[x] for x in 0, 1, 2]) widget.SetInteractor(iren) widget.AddObserver("InteractionEvent", widgetCallBack) widget.SetEnabled(1) widget.DrawPlaneOff() renderer.ResetCamera() renwin.Render() img_file = "TestSlice.png" Testing.compareImage(renwin, Testing.getAbsImagePath(img_file)) if Testing.isInteractive(): widget.DrawPlaneOn() iren.Start()
def add_plane_widget(self, callback, normal='x', origin=None, bounds=None, factor=1.25, color=None, assign_to_axis=None, tubing=False, outline_translation=False, origin_translation=True, **kwargs): """Add a plane widget to the scene. This is useless without a callback function. You can pass a callable function that takes two arguments, the normal and origin of the plane in that order output from this widget, and performs a task with that plane. Parameters ---------- callback : callable The method called everytime the plane is updated. Takes two arguments, the normal and origin of the plane in that order. noraml : str or tuple(flaot) The starting normal vector of the plane origin : tuple(float) The starting coordinate of the center of the place bounds : tuple(float) Length 6 tuple of the bounding box where the widget is placed. factor : float, optional An inflation factor to expand on the bounds when placing color : string or 3 item list, optional, defaults to white Either a string, rgb list, or hex color string. translation_enabled : bool If ``False``, the box widget cannot be translated and is strictly placed at the given bounds. """ if hasattr(self, 'notebook') and self.notebook: raise AssertionError( 'Plane widget not available in notebook plotting') if not hasattr(self, 'iren'): raise AttributeError( 'Widgets must be used with an intereactive renderer. No off screen plotting.' ) if not hasattr(self, "plane_widgets"): self.plane_widgets = [] if origin is None: origin = self.center if bounds is None: bounds = self.bounds if isinstance(normal, str): normal = NORMALS[normal.lower()] if color is None: color = rcParams['font']['color'] def _the_callback(plane_widget, event_id): the_plane = vtk.vtkPlane() plane_widget.GetPlane(the_plane) normal = the_plane.GetNormal() origin = the_plane.GetOrigin() if hasattr(callback, '__call__'): try_callback(callback, normal, origin) return plane_widget = vtk.vtkImplicitPlaneWidget() plane_widget.GetNormalProperty().SetColor(parse_color(color)) plane_widget.GetOutlineProperty().SetColor(parse_color(color)) plane_widget.GetOutlineProperty().SetColor(parse_color(color)) plane_widget.GetPlaneProperty().SetOpacity(0.5) plane_widget.SetTubing(tubing) plane_widget.SetInteractor(self.iren) plane_widget.SetCurrentRenderer(self.renderer) plane_widget.SetPlaceFactor(factor) plane_widget.PlaceWidget(bounds) plane_widget.SetOrigin(origin) plane_widget.SetOutlineTranslation(outline_translation) plane_widget.SetOriginTranslation(origin_translation) if assign_to_axis: # TODO: how do we now disable/hide the arrow? if assign_to_axis in [0, "x", "X"]: plane_widget.NormalToXAxisOn() plane_widget.SetNormal(NORMALS["x"]) elif assign_to_axis in [1, "y", "Y"]: plane_widget.NormalToYAxisOn() plane_widget.SetNormal(NORMALS["y"]) elif assign_to_axis in [2, "z", "Z"]: plane_widget.NormalToZAxisOn() plane_widget.SetNormal(NORMALS["z"]) else: raise RuntimeError("assign_to_axis not understood") else: plane_widget.SetNormal(normal) plane_widget.Modified() plane_widget.UpdatePlacement() plane_widget.On() plane_widget.AddObserver(vtk.vtkCommand.EndInteractionEvent, _the_callback) _the_callback(plane_widget, None) # Trigger immediate update _start_interact = lambda plane_widget, event: plane_widget.SetDrawPlane( True) _stop_interact = lambda plane_widget, event: plane_widget.SetDrawPlane( False) plane_widget.SetDrawPlane(False) plane_widget.AddObserver(vtk.vtkCommand.StartInteractionEvent, _start_interact) plane_widget.AddObserver(vtk.vtkCommand.EndInteractionEvent, _stop_interact) self.plane_widgets.append(plane_widget) return plane_widget
def __init__(self, slider_x, slider_y, slider_z, parent=None): super(VTK_Widget1, self).__init__(parent) self.source_is_connected = False self.slider_x = slider_x self.slider_y = slider_y self.slider_z = slider_z # vtk to point data self.c2p = vtk.vtkCellDataToPointData() self.opacityTransferFunction = vtk.vtkPiecewiseFunction() self.colorTransferFunction = vtk.vtkColorTransferFunction() # clip plane self.clip_plane = vtk.vtkPlane() self.clip_plane.SetNormal(0, 0, 1) self.clipper = vtk.vtkClipDataSet() self.clipper.SetClipFunction(self.clip_plane) self.clipper.SetInputConnection(self.c2p.GetOutputPort()) # create a volume property for describing how the data will look self.volumeProperty = vtk.vtkVolumeProperty() self.volumeProperty.SetColor(self.colorTransferFunction) self.volumeProperty.SetScalarOpacity(self.opacityTransferFunction) self.volumeProperty.ShadeOn() self.volumeProperty.SetInterpolationTypeToLinear() # convert to unstructured grid volume self.triangleFilter = vtk.vtkDataSetTriangleFilter() self.triangleFilter.TetrahedraOnlyOn() self.triangleFilter.SetInputConnection(self.clipper.GetOutputPort()) # create a ray cast mapper self.compositeFunction = vtk.vtkUnstructuredGridBunykRayCastFunction() self.volumeMapper = vtk.vtkUnstructuredGridVolumeRayCastMapper() self.volumeMapper.SetRayCastFunction(self.compositeFunction) self.volumeMapper.SetInputConnection(self.triangleFilter.GetOutputPort()) # create a volume self.volume = vtk.vtkVolume() self.volume.SetMapper(self.volumeMapper) self.volume.SetProperty(self.volumeProperty) self.volume.VisibilityOff() # create the VTK widget for rendering self.vtkw = QVTKRenderWindowInteractor(self) self.ren = vtk.vtkRenderer() self.vtkw.GetRenderWindow().AddRenderer(self.ren) self.ren.AddVolume(self.volume) self.alphaSlider = QSlider(Qt.Horizontal) self.alphaSlider.setValue(33) self.alphaSlider.setRange(0, 100) self.alphaSlider.setTickPosition(QSlider.NoTicks) self.connect(self.alphaSlider, SIGNAL("valueChanged(int)"), self.AdjustAlpha) self.alphaLabel = QLabel("alpha: ") # layout manager self.layout = QVBoxLayout() self.layout2 = QHBoxLayout() self.layout2.addWidget(self.alphaLabel) self.layout2.addWidget(self.alphaSlider) self.layout.addWidget(self.vtkw) self.layout.addSpacing(34) self.layout.addLayout(self.layout2) self.setLayout(self.layout) # initialize the interactor self.vtkw.Initialize() self.vtkw.Start() # Associate the line widget with the interactor self.planeWidget = vtk.vtkImplicitPlaneWidget() self.planeWidget.SetInteractor(self.vtkw) self.planeWidget.AddObserver("InteractionEvent", self.PlaneWidgetCallback) self.planeWidget.DrawPlaneOff() self.planeWidget.TubingOn()
def testSlice(self): global plane, filter, args writefiles = "SaveData" in args renderer = vtk.vtkRenderer() renwin = vtk.vtkRenderWindow() renwin.AddRenderer(renderer) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renwin) renwin.Render() if "GPURender" in args: vtk.vtkPistonMapper.InitCUDAGL(renwin) src = vtk.vtkImageMandelbrotSource() src.SetWholeExtent(0,20,0,20,0,20) #scale and bias until piston understands origin and spacing src.Update() inputdata = src.GetOutput() if "Normalize" in args: testdata1 = inputdata.NewInstance() testdata1.ShallowCopy(inputdata) testdata1.SetSpacing(1,1,1) testdata1.SetOrigin(0,0,0) inputdata = testdata1 bounds = inputdata.GetBounds() center = [(bounds[1]-bounds[0])/2+bounds[0], (bounds[3]-bounds[2])/2+bounds[2], (bounds[5]-bounds[4])/2+bounds[4]] d2p = vtk.vtkDataSetToPiston() d2p.SetInputData(inputdata) #d2p.SetInputConnection(src.GetOutputPort()) plane = vtk.vtkPlane() plane.SetOrigin(center) plane.SetNormal(0,0,1) filter = vtk.vtkPistonSlice() filter.SetInputConnection(d2p.GetOutputPort()) filter.SetClippingPlane(plane) filter.SetOffset(0.0) p2d = vtk.vtkPistonToDataSet() p2d.SetOutputDataSetType(vtk.VTK_POLY_DATA) p2d.SetInputConnection(filter.GetOutputPort()) if writefiles: writeFile(p2d, "piston_slice.vtk") mapper = vtk.vtkPistonMapper() mapper.SetInputConnection(filter.GetOutputPort()) mapper.Update() #TODO why is this necessary actor = vtk.vtkActor() actor.SetMapper(mapper) renderer.AddActor(actor) widget = vtk.vtkImplicitPlaneWidget() widget.PlaceWidget(bounds) widget.SetOrigin([plane.GetOrigin()[x] for x in 0,1,2])