#!/usr/bin/env python ## Program: VMTK ## Module: $RCSfile: vmtkmeshclipcenterlines.py,v $ ## Language: Python ## Date: $$ ## Version: $$ ## Copyright (c) Luca Antiga, David Steinman. All rights reserved. ## See LICENCE file for details. ## This software is distributed WITHOUT ANY WARRANTY; without even ## the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR ## PURPOSE. See the above copyright notices for more information. ## Note: this class was contributed by ## Tangui Morvan ## Kalkulo AS ## Simula Research Laboratory ## Interactively clip a mesh using the distance to centerlines import vtk import sys import vtkvmtk import vtkvmtkcontrib import vmtkrenderer import vmtkscripts import pypes vmtkmeshclipcenterlines = 'vmtkMeshClipCenterlines' class vmtkMeshClipCenterlines(pypes.pypeScript): def __init__(self): pypes.pypeScript.__init__(self) #The orignal mesh self.Mesh = None #Preview of the resulting mesh self.PreviewMesh = None #Clipped part of the mesh self.ClippedMesh = None #Which mesh is displayed : 0 intial mesh, 1 preview mesh, 2 clipped mesh self.DisplayedMesh = 0 self.vmtkRenderer = None self.OwnRenderer = 0 self.Clipper = None #self.LineClipper = None self.InsideOut = 1 #Type of polyball : 0 global, 1 local self.PolyBallType = 0 self.CellEntityIdsArrayName = 'CellEntityIds' #Id of the first wall (mesh surface) self.WallCellEntityId = 1 #Should we include the new surface cells self.IncludeSurfaceCells = 1 #Tolerance used for reporjecting the cellentityid array self.Tolerance = -1. self.Centerlines = None self.RadiusArrayName = '' self.RadiusArray = None self.MeshActor = None self.CenterlinesActor = None #Spheres used to drive the radius array interpolation self.SpheresActor = None self.Spheres = vtk.vtkPolyData() self.SpheresIndices = vtk.vtkIdList() self.SpheresRadii = None self.CurrentSphereId = -1 self.SphereWidget = None #Used to display the interpolated spheres self.InterpolatedGlyphs = None self.InterpolatedSpheresActor = None self.PolyBall = None #used to display the polyball function used for clipping self.PolyBallActor = None self.PolyBallResolution = [32, 32, 32] self.SetScriptName('vmtkmeshclipcenterlines') self.SetScriptDoc('interactively clip a mesh using the distance to centerlines') self.SetInputMembers([ ['Mesh','i','vtkUnstructuredGrid',1,'','the input mesh','vmtkmeshreader'], ['Centerlines','centerlines','vtkPolyData',1,'','','vmtksurfacereader'], ['RadiusArrayName','radiusarray','str',1], ['PolyBallType','polyballtype','int',1,'','type of polyball used (0: global, 1: local)'], ['PolyBallResolution','polyballres','int',3,'','grid resolution for displaying the polyball'], ['InsideOut','insideout','bool',1,'','choose whether to clip the inside or outside of the polyball'], ['CellEntityIdsArrayName','entityidsarray','str',1,''], ['WallCellEntityId','wallid','int',1,'','id of the first surface cells in the entityids list'], ['Tolerance','tol','float',1,'','tolerance used to reproject the entity ids on the new surface'] #['IncludeSurfaceCells','includesurfacecells','bool',0,'','include new surface cells in output mesh'], #['vmtkRenderer','renderer','vmtkRenderer',1,'','external renderer'] ]) self.SetOutputMembers([ ['Mesh','o','vtkUnstructuredGrid',1,'','the output mesh','vmtkmeshwriter'], ['ClippedMesh','clippedmesh','vtkUnstructuredGrid',1,'','the clipped mesh','vmtkmeshwriter'] ]) def InitializeSpheres(self): #Reset the sphere array self.Spheres.Initialize() spherePoints = vtk.vtkPoints() self.Spheres.SetPoints(spherePoints) self.Spheres.GetPointData().Initialize() self.SpheresIndices.Initialize() self.SpheresRadii = vtk.vtkDoubleArray() self.SpheresRadii.SetName("SpheresRadii") self.Spheres.GetPointData().SetScalars(self.SpheresRadii) self.CurrentSphereId = -1 #Hide the widget self.SphereWidget.Off() #Disable scaling self.InterpolatedGlyphs.SetScaleModeToDataScalingOff() self.InterpolatedGlyphs.SetScaleFactor(0.) #reset the polyball self.PolyBall = None def PlaceSphere(self): if self.CurrentSphereId == -1: return self.SphereWidget.SetCenter(self.Spheres.GetPoint(self.CurrentSphereId)) self.SphereWidget.SetRadius(self.Spheres.GetPointData().GetScalars().GetValue(self.CurrentSphereId)) self.SphereWidget.On() def SphereCallback(self,widget,event_string): if self.CurrentSphereId == -1: return minRadius = self.Centerlines.GetLength()*0.001 if self.SphereWidget.GetRadius() < minRadius: self.SphereWidget.SetRadius(minRadius) self.Spheres.GetPointData().GetScalars().SetValue(self.CurrentSphereId,self.SphereWidget.GetRadius()) self.Spheres.Modified() def InterpolateRadius(self): #if we have no values return if self.SpheresRadii.GetNumberOfTuples() == 0: return; interpolator = vtkvmtkcontrib.vtkvmtkCenterlineInterpolateArray() interpolator.SetInput(self.Centerlines) interpolator.SetValues(self.SpheresRadii) interpolator.SetValuesIds(self.SpheresIndices) interpolator.SetInterpolatedArrayName("InterpolatedRadius") interpolator.Update() self.Centerlines = interpolator.GetOutput() self.Centerlines.GetPointData().SetActiveScalars("InterpolatedRadius") self.InterpolatedGlyphs.SetInput(self.Centerlines) #enable scaling self.InterpolatedGlyphs.SetScaleModeToScaleByScalar() self.InterpolatedGlyphs.SetScaleFactor(1) def BuildPolyBall(self): #if we have no values return if self.SpheresRadii.GetNumberOfTuples() == 0: return #interpolate the radius array self.InterpolateRadius() if self.PolyBallType==1: self.PolyBall = vtkvmtkcontrib.vtkvmtkPolyBallLine2() else: self.PolyBall = vtkvmtk.vtkvmtkPolyBallLine() self.PolyBall.SetInput(self.Centerlines) self.PolyBall.SetUseRadiusInformation(1) self.PolyBall.SetPolyBallRadiusArrayName("InterpolatedRadius") def BuildPolyBallSurface(self): #Build a surface for displaying the polyball if self.PolyBall == None: return #Sample the polyball sampler = vtk.vtkSampleFunction() sampler.SetImplicitFunction(self.PolyBall) #Set the bounds to be slightly larger than those of the mesh meshBounds = self.Mesh.GetBounds() meshCenter = self.Mesh.GetCenter() polyBallBounds = [0, 0, 0, 0, 0, 0] for i in range(0,3): length = 1.2*(meshBounds[2*i+1] - meshCenter[i]) polyBallBounds[2*i] = meshCenter[i] - length polyBallBounds[2*i+1] = meshCenter[i] + length sampler.SetModelBounds(polyBallBounds) sampler.SetSampleDimensions(self.PolyBallResolution) sampler.ComputeNormalsOff() sampler.Update() #Extract the isosurface at 0 contour = vtk.vtkContourFilter() contour.SetInput(sampler.GetOutput()) contour.SetValue(0,0.) contour.Update() #Set the new model as the mapper input self.PolyBallActor.GetMapper().SetInput(contour.GetOutput()) #self.PolyBallActor.VisibilityOn() def ClipMesh(self): #if we have no values simply return the original mesh if self.SpheresRadii.GetNumberOfTuples() == 0: self.PreviewMesh = self.Mesh self.ClippedMesh = None return self.BuildPolyBall() #Update the polyball model if necessary if self.PolyBallActor.GetVisibility(): self.BuildPolyBallSurface() self.Clipper.SetClipFunction(self.PolyBall) self.Clipper.Update() self.PreviewMesh = self.Clipper.GetOutput() self.ClippedMesh = self.Clipper.GetClippedOutput() #Clip the mesh using vtkvmtkClipDataSetLine #def ClipMeshLine(self): ##if we have no values simply return the original mesh #if self.SpheresRadii.GetNumberOfTuples() == 0: #self.PreviewMesh = self.Mesh #self.ClippedMesh = None #return #self.BuildPolyBall() ##Update the polyball model if necessary #if self.PolyBallActor.GetVisibility(): #self.BuildPolyBallSurface() #lineIntersector = vtkvmtkcontrib.vtkvmtkPolyBallLineIntersector() #lineIntersector.SetImplicitFunction(self.PolyBall) #self.LineClipper.SetLineIntersector(lineIntersector) #self.LineClipper.Update() #self.PreviewMesh = self.LineClipper.GetOutput() #self.ClippedMesh = self.LineClipper.GetClippedOutput() #Recreate the surface cells on the clipped and project the cell entity ids def CreateSurfaceCells(self,inMesh): #Remove the surface cells from the mesh cellDimFilter = vtkvmtkcontrib.vtkvmtkCellDimensionFilter() cellDimFilter.SetInput(inMesh) cellDimFilter.ThresholdByUpper(3) cellDimFilter.Update() volumetricMesh = cellDimFilter.GetOutput() #Get new surface cells geomFilter = vtk.vtkGeometryFilter() geomFilter.SetInput(cellDimFilter.GetOutput()) geomFilter.Update() newSurfaceCells = geomFilter.GetOutput() #If the celEntityIdArray exist, project the original entity ids cellEntityIdsArray = newSurfaceCells.GetCellData().GetArray(self.CellEntityIdsArrayName) if (cellEntityIdsArray != None): #Convert the surface cells to poly data surfaceCellsToSurface = vmtkscripts.vmtkMeshToSurface() surfaceCellsToSurface.Mesh = newSurfaceCells surfaceCellsToSurface.Execute() #Get the original surface cells meshThreshold = vtk.vtkThreshold() meshThreshold.SetInput(self.Mesh) meshThreshold.ThresholdByUpper(self.WallCellEntityId+0.5) meshThreshold.SetInputArrayToProcess(0,0,0,1,self.CellEntityIdsArrayName) meshThreshold.Update() meshToSurface = vmtkscripts.vmtkMeshToSurface() meshToSurface.Mesh = meshThreshold.GetOutput() meshToSurface.Execute() #Project the entity ids form the old surface cells to the new surface cells #TODO: This is hackish(need for a tolerance), find a beeter way projector = vtkvmtkcontrib.vtkvmtkSurfaceProjectCellArray() projector.SetInput(surfaceCellsToSurface.Surface) projector.SetReferenceSurface(meshToSurface.Surface) projector.SetProjectedArrayName(self.CellEntityIdsArrayName) projector.SetDefaultValue(self.WallCellEntityId) projector.SetDistanceTolerance(self.Tolerance) projector.Update() #Convert the surface cells back to unstructured grid surfaceToMesh = vmtkscripts.vmtkSurfaceToMesh() surfaceToMesh.Surface = projector.GetOutput() surfaceToMesh.Execute() newSurfaceCells = surfaceToMesh.Mesh #append the new surface cells to the volumetric elements appendFilter = vtkvmtk.vtkvmtkAppendFilter() appendFilter.AddInput(volumetricMesh) appendFilter.AddInput(newSurfaceCells) appendFilter.Update() return appendFilter.GetOutput() def LCallback(self,obj): self.DisplayedMesh = (self.DisplayedMesh+1)%3 if self.DisplayedMesh == 0: self.MeshActor.GetMapper().SetInput(self.Mesh) elif self.DisplayedMesh == 1: self.MeshActor.GetMapper().SetInput(self.PreviewMesh) elif self.DisplayedMesh == 2: self.MeshActor.GetMapper().SetInput(self.ClippedMesh) self.vmtkRenderer.RenderWindow.Render() def ClipCallback(self, obj): self.ClipMesh() if self.DisplayedMesh == 1: self.MeshActor.GetMapper().SetInput(self.PreviewMesh) elif self.DisplayedMesh == 2: self.MeshActor.GetMapper().SetInput(self.ClippedMesh) self.vmtkRenderer.RenderWindow.Render() #def MCallback(self, obj) #self.ClipMeshLine() #if self.DisplayedMesh == 1: #self.MeshActor.GetMapper().SetInput(self.PreviewMesh) #elif self.DisplayedMesh == 2: #self.MeshActor.GetMapper().SetInput(self.ClippedMesh) #self.vmtkRenderer.RenderWindow.Render() def SpaceCallback(self, obj): #Disable the sphere Widget so as not to pick it self.SphereWidget.Off() #add a new sphere picker = vtk.vtkPointPicker() picker.SetTolerance(1E-3 * self.Centerlines.GetLength()) eventPosition = self.vmtkRenderer.RenderWindowInteractor.GetEventPosition() #eventPosition = obj.GetEventPosition() result = picker.Pick(float(eventPosition[0]),float(eventPosition[1]),0.0,self.vmtkRenderer.Renderer) if result == 0: #Reenable the sphere widget self.SphereWidget.On() return pickId = picker.GetPointId() #Only insert a new sphere if this id is not already in the list if self.SpheresIndices.IsId(pickId) == -1: self.CurrentSphereId = self.Spheres.GetPoints().InsertNextPoint(self.Centerlines.GetPoint(pickId)) self.SpheresIndices.InsertNextId(pickId) interpolatedArray = self.Centerlines.GetPointData().GetArray("InterpolatedRadius") if interpolatedArray and (interpolatedArray.GetValue(pickId) != 0.): self.SpheresRadii.InsertNextValue(interpolatedArray.GetValue(pickId)) elif self.RadiusArray: self.SpheresRadii.InsertNextValue(self.RadiusArray.GetValue(pickId)) else: self.SpheresRadii.InsertNextValue(self.Centerlines.GetLength()*0.01) self.Spheres.Modified() self.PlaceSphere() #Reenable the sphere widget self.SphereWidget.On() self.vmtkRenderer.RenderWindow.Render() def KeyPressed(self,obj,event): key = obj.GetKeySym() if key == 'space': #Disable the sphere Widget so as not to pick it self.SphereWidget.Off() #add a new sphere picker = vtk.vtkPointPicker() picker.SetTolerance(1E-3 * self.Centerlines.GetLength()) eventPosition = obj.GetEventPosition() result = picker.Pick(float(eventPosition[0]),float(eventPosition[1]),0.0,self.vmtkRenderer.Renderer) if result == 0: #Reenable the sphere widget self.SphereWidget.On() return pickId = picker.GetPointId() #Only insert a new sphere if this id is not already in the list if self.SpheresIndices.IsId(pickId) == -1: self.CurrentSphereId = self.Spheres.GetPoints().InsertNextPoint(self.Centerlines.GetPoint(pickId)) self.SpheresIndices.InsertNextId(pickId) interpolatedArray = self.Centerlines.GetPointData().GetArray("InterpolatedRadius") if interpolatedArray and (interpolatedArray.GetValue(pickId) != 0.): self.SpheresRadii.InsertNextValue(interpolatedArray.GetValue(pickId)) elif self.RadiusArray: self.SpheresRadii.InsertNextValue(self.RadiusArray.GetValue(pickId)) else: self.SpheresRadii.InsertNextValue(self.Centerlines.GetLength()*0.01) self.Spheres.Modified() self.PlaceSphere() #Reenable the sphere widget self.SphereWidget.On() self.vmtkRenderer.RenderWindow.Render() def PlusCallback(self, obj): if self.CurrentSphereId != -1: #increase sphere radius newval = self.Spheres.GetPointData().GetScalars().GetValue(self.CurrentSphereId) + self.Centerlines.GetLength()*0.01 self.Spheres.GetPointData().GetScalars().SetValue(self.CurrentSphereId,newval) self.Spheres.Modified() self.PlaceSphere() self.vmtkRenderer.RenderWindow.Render() def MinusCallback(self, obj): if self.CurrentSphereId != -1: #decrease sphere radius newval = self.Spheres.GetPointData().GetScalars().GetValue(self.CurrentSphereId) - self.Centerlines.GetLength()*0.01 if newval> 0: self.Spheres.GetPointData().GetScalars().SetValue(self.CurrentSphereId,newval) self.Spheres.Modified() self.PlaceSphere() self.vmtkRenderer.RenderWindow.Render() def NextSphereCallback(self, obj): if self.CurrentSphereId != -1: #skip to next sphere self.CurrentSphereId = (self.CurrentSphereId + 1) % self.Spheres.GetNumberOfPoints(); self.PlaceSphere() self.vmtkRenderer.RenderWindow.Render() def ProviousSphereCallback(self, obj): if self.CurrentSphereId != -1: #skip to previous sphere self.CurrentSphereId = (self.CurrentSphereId - 1) % self.Spheres.GetNumberOfPoints(); self.PlaceSphere() self.vmtkRenderer.RenderWindow.Render() def UndoCallback(self, obj): #undo self.InitializeSpheres() self.Spheres.Modified() self.vmtkRenderer.RenderWindow.Render() def DeleteSphereCallback(self, obj): if self.CurrentSphereId != -1: #delete the current sphere #if no spheres would be left initialize if self.Spheres.GetNumberOfPoints() == 1: self.InitializeSpheres() else: #Copy the spheres into a new structure oldPoints = vtk.vtkPoints() oldPoints.DeepCopy(self.Spheres.GetPoints()) self.Spheres.Initialize() spherePoints = vtk.vtkPoints() for i in range(0,oldPoints.GetNumberOfPoints()): if i != self.CurrentSphereId: spherePoints.InsertNextPoint(oldPoints.GetPoint(i)) self.Spheres.SetPoints(spherePoints) self.SpheresRadii.RemoveTuple(self.CurrentSphereId) self.Spheres.GetPointData().SetScalars(self.SpheresRadii) self.SpheresIndices.DeleteId(self.SpheresIndices.GetId(i)) self.CurrentSphereId = (self.CurrentSphereId + 1) % self.Spheres.GetNumberOfPoints() self.PlaceSphere() self.vmtkRenderer.RenderWindow.Render() def InterpolatedSphereCallback(self, obj): #Display the interpolated spheres self.InterpolatedSpheresActor.SetVisibility(not self.InterpolatedSpheresActor.GetVisibility()) self.vmtkRenderer.RenderWindow.Render() def PolyballSurfaceCallback(self, obj): #Display/hide the polyball surface if self.PolyBallActor.GetVisibility(): self.PolyBallActor.VisibilityOff() elif self.PolyBall != None: self.BuildPolyBallSurface() self.PolyBallActor.VisibilityOn() self.vmtkRenderer.RenderWindow.Render() def MeshVisalizationCallback(self, obj): #Switch between transparent/opaque mesh for better visualisation if self.MeshActor.GetProperty().GetOpacity() == 0.25: self.MeshActor.GetProperty().SetOpacity(1.) else: self.MeshActor.GetProperty().SetOpacity(0.25) self.vmtkRenderer.RenderWindow.Render() def PolyballVisualizationCallback(self, obj): #Switch between transparent/opaque polyball for better visualisation if self.PolyBallActor.GetProperty().GetOpacity() == 0.25: self.PolyBallActor.GetProperty().SetOpacity(1.) self.MeshActor.VisibilityOff() else: self.PolyBallActor.GetProperty().SetOpacity(0.25) self.MeshActor.VisibilityOn() self.vmtkRenderer.RenderWindow.Render() def PolyballTypeCallback(self, obj): self.PolyBallType = (self.PolyBallType + 1)%2 def Display(self): self.vmtkRenderer.RenderWindowInteractor.Initialize() #self.vmtkRenderer.RenderWindowInteractor.AddObserver("KeyPressEvent", self.KeyPressed) self.vmtkRenderer.AddKeyBinding('f','Change Polyball type',self.PolyballTypeCallback) self.vmtkRenderer.AddKeyBinding('y','Switch between transparent/opaque polyball',self.PolyballVisualizationCallback) self.vmtkRenderer.AddKeyBinding('w','Switch between transparent/opaque mesh',self.MeshVisalizationCallback) self.vmtkRenderer.AddKeyBinding('b','Display/hide the polyball surface',self.PolyballSurfaceCallback) self.vmtkRenderer.AddKeyBinding('o','Display the interpolated spheres',self.InterpolatedSphereCallback) self.vmtkRenderer.AddKeyBinding('d','Delete the current sphere',self.DeleteSphereCallback) self.vmtkRenderer.AddKeyBinding('u','Undo',self.UndoCallback) self.vmtkRenderer.AddKeyBinding('v','Skip to previous sphere',self.ProviousSphereCallback) self.vmtkRenderer.AddKeyBinding('n','skip to next sphere',self.NextSphereCallback) self.vmtkRenderer.AddKeyBinding('minus','Decrease sphere radius',self.MinusCallback) self.vmtkRenderer.AddKeyBinding('plus','Increase sphere radius',self.PlusCallback) self.vmtkRenderer.AddKeyBinding('space','Disable the sphere Widget',self.SpaceCallback) self.vmtkRenderer.AddKeyBinding('c','Clip Mesh',self.ClipCallback) self.vmtkRenderer.AddKeyBinding('l','Change Displayed Mesh',self.LCallback) self.vmtkRenderer.Render() #self.vmtkRenderer.RenderWindowInteractor.Start() def Execute(self): if (self.Mesh == None): self.PrintError('Error: no Mesh.') if (self.Centerlines == None): self.PrintError('Error: no Centerlines') #Save the centerlines previousCenterlines = self.Centerlines cleaner = vtk.vtkCleanPolyData() cleaner.SetInput(self.Centerlines) cleaner.Update() self.Centerlines = cleaner.GetOutput() if self.Tolerance == -1: self.Tolerance = 0.000001*self.Mesh.GetLength() if self.RadiusArrayName != '': self.RadiusArray = self.Centerlines.GetPointData().GetArray(self.RadiusArrayName) if self.RadiusArray == None: self.PrintError('Error : could not find radius array') if not self.vmtkRenderer: self.vmtkRenderer = vmtkrenderer.vmtkRenderer() self.vmtkRenderer.Initialize() self.OwnRenderer = 1 meshMapper = vtk.vtkDataSetMapper() meshMapper.SetInput(self.Mesh) meshMapper.ScalarVisibilityOff() self.MeshActor = vtk.vtkActor() self.MeshActor.SetMapper(meshMapper) self.MeshActor.GetProperty().SetOpacity(0.25) self.MeshActor.PickableOff() self.vmtkRenderer.Renderer.AddActor(self.MeshActor) centerlinesMapper = vtk.vtkDataSetMapper() centerlinesMapper.SetInput(self.Centerlines) centerlinesMapper.ScalarVisibilityOff() self.CenterlinesActor = vtk.vtkActor() self.CenterlinesActor.SetMapper(centerlinesMapper) self.vmtkRenderer.Renderer.AddActor(self.CenterlinesActor) glyphs = vtk.vtkGlyph3D() glyphSource = vtk.vtkSphereSource() glyphSource.SetRadius(1) glyphs.SetInput(self.Spheres) glyphs.SetSource(glyphSource.GetOutput()) glyphs.SetScaleModeToScaleByScalar() glyphs.SetScaleFactor(1.) glyphMapper = vtk.vtkPolyDataMapper() glyphMapper.SetInput(glyphs.GetOutput()) glyphMapper.ScalarVisibilityOff() self.SpheresActor = vtk.vtkActor() self.SpheresActor.SetMapper(glyphMapper) self.SpheresActor.GetProperty().SetColor(1.0,0.0,0.0) self.SpheresActor.GetProperty().SetOpacity(0.25) self.SpheresActor.PickableOff() self.vmtkRenderer.Renderer.AddActor(self.SpheresActor) self.InterpolatedGlyphs = vtk.vtkGlyph3D() interpolatedGlyphSource = vtk.vtkSphereSource() interpolatedGlyphSource.SetRadius(1) self.InterpolatedGlyphs.SetInput(self.Centerlines) self.InterpolatedGlyphs.SetSource(interpolatedGlyphSource.GetOutput()) #scaling is off for now self.InterpolatedGlyphs.SetScaleModeToDataScalingOff() self.InterpolatedGlyphs.SetScaleFactor(0.) interpolatedGlyphMapper = vtk.vtkPolyDataMapper() interpolatedGlyphMapper.SetInput(self.InterpolatedGlyphs.GetOutput()) interpolatedGlyphMapper.ScalarVisibilityOff() self.InterpolatedSpheresActor = vtk.vtkActor() self.InterpolatedSpheresActor.SetMapper(interpolatedGlyphMapper) self.InterpolatedSpheresActor.GetProperty().SetColor(0.0,1.0,0.0) self.InterpolatedSpheresActor.GetProperty().SetOpacity(0.25) self.InterpolatedSpheresActor.PickableOff() self.InterpolatedSpheresActor.VisibilityOff() self.vmtkRenderer.Renderer.AddActor(self.InterpolatedSpheresActor) polyBallMapper = vtk.vtkPolyDataMapper() polyBallMapper.ScalarVisibilityOff() self.PolyBallActor = vtk.vtkActor() self.PolyBallActor.SetMapper(polyBallMapper) self.PolyBallActor.GetProperty().SetColor(0.0,1.0,0.0) self.PolyBallActor.GetProperty().SetOpacity(0.25) self.PolyBallActor.PickableOff() self.PolyBallActor.VisibilityOff() self.vmtkRenderer.Renderer.AddActor(self.PolyBallActor) self.SphereWidget = vtk.vtkSphereWidget() self.SphereWidget.TranslationOff() self.SphereWidget.SetInteractor(self.vmtkRenderer.RenderWindowInteractor) self.SphereWidget.AddObserver("InteractionEvent", self.SphereCallback) self.Clipper = vtk.vtkClipDataSet() self.Clipper.SetInput(self.Mesh) self.Clipper.SetInsideOut(self.InsideOut) self.Clipper.GenerateClippedOutputOn() #self.LineClipper = vtkvmtk.vtkvmtkClipDataSetLine() #self.LineClipper.SetInput(self.Mesh) #self.LineClipper.SetInsideOut(self.InsideOut) #self.LineClipper.GenerateClippedOutputOn() self.InitializeSpheres() self.PreviewMesh = self.Mesh self.Display() self.PolyBallActor.VisibilityOff() self.ClipMesh() if self.ClippedMesh == None: #return an empty mesh self.ClippedMesh = vtk.vtkUnstructuredGrid() elif self.IncludeSurfaceCells: #Create the surface cells self.PreviewMesh = self.CreateSurfaceCells(self.PreviewMesh) self.ClippedMesh = self.CreateSurfaceCells(self.ClippedMesh) self.Mesh = self.PreviewMesh if self.OwnRenderer: self.vmtkRenderer.Deallocate() if self.Mesh.GetSource(): self.Mesh.GetSource().UnRegisterAllOutputs() #Restore the centerlines self.Centerlines = previousCenterlines if __name__=='__main__': main = pypes.pypeMain() main.Arguments = sys.argv main.Execute()