def addPlaneCutter(self, i): #take record of the plane weight planeWeightTextValue = self.planeWeightText[i].text() self.planeWtInt[i] = planeWeightTextValue.toFloat() self.ren.RemoveActor(self.planeActor) plane=vtk.vtkPlane() plane.SetOrigin(float(self.firstPlanePtValueRecord[i][0]),float(self.firstPlanePtValueRecord[i][1]), float(self.firstPlanePtValueRecord[i][2]) ) a = np.array([self.secondPlanePtValueRecord[i][0]-self.firstPlanePtValueRecord[i][0], self.secondPlanePtValueRecord[i][1]-self.firstPlanePtValueRecord[i][1], self.secondPlanePtValueRecord[i][2]-self.firstPlanePtValueRecord[i][2]]) b = np.array([self.thirdPlanePtValueRecord[i][0]-self.firstPlanePtValueRecord[i][0], self.thirdPlanePtValueRecord[i][1]-self.firstPlanePtValueRecord[i][1],self.thirdPlanePtValueRecord[i][2]-self.firstPlanePtValueRecord[i][2]]) self.planeOrigin[i] = self.firstPlanePtValueRecord[i] self.planeNormal[i] = np.cross(a, b) self.planeNormal[i] = self.planeNormal[i] / np.linalg.norm(self.planeNormal[i]) plane.SetNormal(self.planeNormal[i]) #create cutter cutter=vtk.vtkCutter() cutter.SetCutFunction(plane) cutter.SetInputConnection(self.append.GetOutputPort()) cutter.Update() cutterMapper=vtk.vtkPolyDataMapper() cutterMapper.SetInputConnection(cutter.GetOutputPort()) self.planeActor.GetProperty().SetColor(1.0,1,0) self.planeActor.GetProperty().SetLineWidth(2) self.planeActor.SetMapper(cutterMapper) self.ren.AddActor(self.planeActor)
def get(self): resultado = {} imageData = reader.get("IMAGE", self.subj, format="VTK", name=self.get_argument("type", None), space="world") plane=vtk.vtkPlane() if (self.get_argument("plane", None) == "x"): plane.SetNormal(1,0,0) plane.SetOrigin(float(self.get_argument("pos", None)),0,0) if (self.get_argument("plane", None) == "y"): plane.SetNormal(0,1,0) plane.SetOrigin(0,float(self.get_argument("pos", None)),0) if (self.get_argument("plane", None) == "z"): plane.SetNormal(0,0,1) plane.SetOrigin(0,0,float(self.get_argument("pos", None))) planeCut = vtk.vtkCutter() planeCut.SetInputData(imageData) planeCut.SetCutFunction(plane) planeCut.Update() resultado['subject'] = self.subj resultado['type'] = 'image' resultado['plane'] = self.get_argument("plane", None) resultado['pos'] = self.get_argument("pos", None) resultado['bounds'] = planeCut.GetOutput().GetBounds() resultado['dimensions'] = imageData.GetDimensions() resultado['scalars'] = numpy_support.vtk_to_numpy(planeCut.GetOutput().GetPointData().GetScalars()).tolist() self.set_header("Content-Type","application/json") self.write(json.dumps(resultado, separators=(',',':')))
def InitVTKMethods(self): """Initializes the VTK methods to be used.""" self.colortable=ColorTableSource() self._plane=vtkPlane() self._cutter=vtkCutter() self._mapper=vtkDataSetMapper() self.actor=vtkLODActor()
def __init__(self): """Setup the pipeline. """ self.reader = vtkSTLReader() self.cutter = vtkCutter() self.cutter.SetInputConnection(self.reader.GetOutputPort()) self.regionPicker = vtkPolyDataConnectivityFilter() self.regionPicker.SetInputConnection(self.cutter.GetOutputPort()) self.regionPicker.SetExtractionModeToClosestPointRegion() self.scaler = vtkTransformPolyDataFilter() self.scaler.SetInputConnection(self.regionPicker.GetOutputPort()) self.GetFileName = self.reader.GetFileName self.SetFileName = self.reader.SetFileName self.GetOutputPort = self.scaler.GetOutputPort self.GetOutput = self.scaler.GetOutput self.Update = self.scaler.Update self.iolet = None self.fileUnitLength = None return
def create_cut_acto_plane(self,xpos,ypos,zpos,plane_id): #vtk plane plane=vtk.vtkPlane() plane.SetOrigin(xpos,ypos,zpos) if plane_id==0: plane.SetNormal(1,0,0) if plane_id==1: plane.SetNormal(0,1,0) if plane_id==2: plane.SetNormal(0.0,0.0,1) #create cutter cutter=vtk.vtkCutter() cutter.SetCutFunction(plane) cutter.SetInputConnection(self.dti_reader.GetOutputPort()) cutter.Update() #probe filter for the cutting plane probe_filter=vtk.vtkProbeFilter() probe_filter.SetInputConnection(cutter.GetOutputPort()) probe_filter.SetSourceConnection(self.dti_reader.GetOutputPort()) self.plane1=plane return probe_filter
def __init__ (self, mod_m): debug ("In VectorCutPlane::__init__ ()") Common.state.busy () Base.Objects.CutPlaneModule.__init__ (self, mod_m) self.cut = vtk.vtkCutter () self.glyph2d_src = vtk.vtkGlyphSource2D () self.cone = vtk.vtkConeSource () self.arrow = vtk.vtkArrowSource () self.glyph_src = self.cone self.glyph3d = vtk.vtkGlyph3D () self.mapper = self.map = vtk.vtkPolyDataMapper () self.actor = self.act = vtk.vtkActor () # used to orient the cone properly self.glph_trfm = vtk.vtkTransformFilter () self.glph_trfm.SetTransform (vtk.vtkTransform ()) self.data_out = self.mod_m.GetOutput () # Point of glyph that is attached -- -1 is tail, 0 is center, # 1 is head. self.glyph_pos = -1 self.scale = 1.0 self.color_mode = 2 #2 is vector, 1 is scalar, -1 none self._initialize () self._gui_init () self.renwin.Render () Common.state.idle ()
def initialize (self): debug ("In CutPlane::initialize ()") self.plane = vtk.vtkPlane () self.fil = vtk.vtkCutter () out = self.prev_fil.GetOutput() self.fil.SetInput (out) self.fil.SetCutFunction (self.plane) self.center = out.GetCenter () self.plane.SetOrigin (self.center) self.plane.SetNormal (0.0, 0.0, 1.0) self.step_var = Tkinter.DoubleVar () self.n_step_var = Tkinter.IntVar () self.resoln_var = Tkinter.DoubleVar () self.resoln_var.set (1.0) self.slider = [] self.set_def_step_size () self.step_var.set (self.step_size) self.n_step_var.set (10) self.slider_pos = 0 self._auto_sweep_init () self.sweep_step.set (1) self.fil.Update ()
def addContourObject(self, contourObject, prop3D): """Activate contouring for the contourObject. The contourObject is usually a tdObject and specifically a vtkPolyData. We also need the prop3D that represents this polydata in the 3d scene. """ if self._contourObjectsDict.has_key(contourObject): # we already have this, thanks return try: contourable = contourObject.IsA('vtkPolyData') except: contourable = False if contourable: # we need a cutter to calculate the contours and then a stripper # to string them all together cutter = vtk.vtkCutter() plane = vtk.vtkPlane() cutter.SetCutFunction(plane) trfm = vtk.vtkTransform() trfm.SetMatrix(prop3D.GetMatrix()) trfmFilter = vtk.vtkTransformPolyDataFilter() trfmFilter.SetTransform(trfm) trfmFilter.SetInput(contourObject) cutter.SetInput(trfmFilter.GetOutput()) stripper = vtk.vtkStripper() stripper.SetInput(cutter.GetOutput()) # #tubef = vtk.vtkTubeFilter() #tubef.SetNumberOfSides(12) #tubef.SetRadius(0.5) #tubef.SetInput(stripper.GetOutput()) # and create the overlay at least for the 3d renderer mapper = vtk.vtkPolyDataMapper() mapper.SetInput(stripper.GetOutput()) mapper.ScalarVisibilityOff() actor = vtk.vtkActor() actor.SetMapper(mapper) c = self.sliceDirections.slice3dVWR._tdObjects.getObjectColour( contourObject) actor.GetProperty().SetColor(c) actor.GetProperty().SetInterpolationToFlat() # add it to the renderer self.sliceDirections.slice3dVWR._threedRenderer.AddActor(actor) # add all necessary metadata to our dict contourDict = {'contourObject' : contourObject, 'contourObjectProp' : prop3D, 'trfmFilter' : trfmFilter, 'cutter' : cutter, 'tdActor' : actor} self._contourObjectsDict[contourObject] = contourDict # now sync the bugger self.syncContourToObject(contourObject)
def __init__(self, embryo, parent=None): #super(vtkSimVisualizerCutter, self).__init__(embryo,parent) vtkSimVisualizer.__init__(self,embryo,parent=parent) # Check if 3D embryo if self.embryo.geometry.dim==2: printWarning("vtkSimVisualizerCutter does only work and make sense for 3D geometries. Will not initialize cutter and fall back tostandad vtkSimVisualizer.") return self.vtkWidgetCut,self.renCut,self.irenCut=self.initVTKWidget(self.frame) # Plane used for cutting self.plane = vtk.vtkPlane() # Cutter self.cutter = vtk.vtkCutter() # Plane widget self.initPlaneWidget() # Add Layout self.layout.addWidget(self.vtkWidgetCut,1,2) # Run cut mesh once self.CutMesh() self.irenCut.Initialize()
def __init__(self, embryo, parent=None): super(vtkSimVisualizerCutter, self).__init__(parent) # Load embryo self.embryo=embryo # Check if simulation is saved if len(self.embryo.simulation.vals)==0: printWarning("Embryo does not have saved simulation. Rerun simulation with saveSim=True.") # Check if 3D embryo if self.embryo.geometry.dim==2: printError("vtkSimVisualizerCutter does only work and make sense for 3D geometries. Use vtkSimVisualizer instead.") # To numpy array self.embryo.simulation.vals=np.array(self.embryo.simulation.vals) # Frame self.frame = QtGui.QFrame() # Vtk widgets self.vtkWidget,self.ren,self.iren=self.initVTKWidget(self.frame) self.vtkWidgetCut,self.renCut,self.irenCut=self.initVTKWidget(self.frame) # Add slider for 3D self.slider,self.label=self.initSlider(0, len(self.embryo.simulation.tvecSim)-1,self.sliderCallback) # Setup 3D simulation plot self.init3D() # Plane used for cutting self.plane = vtk.vtkPlane() # Cutter self.cutter = vtk.vtkCutter() # Plane widget self.initPlaneWidget() # Add Layout self.layout=QtGui.QGridLayout() self.layout.addWidget(self.vtkWidget,1,1) self.layout.addWidget(self.vtkWidgetCut,1,2) self.layout.addWidget(self.slider,2,1) self.layout.addWidget(self.label,3,1) # Set central widget self.frame.setLayout(self.layout) self.setCentralWidget(self.frame) self.setWindowTitle('vtkSimVisualizerCutter of embryo ' + self.embryo.name) # Run cut mesh once self.CutMesh() # Show everything self.show() self.iren.Initialize() self.irenCut.Initialize()
def cut(cube, normal): plane=vtk.vtkPlane() plane.SetOrigin(cube.GetCenter()) plane.SetNormal(*normal) #create cutter cutter=vtk.vtkCutter() cutter.SetCutFunction(plane) cutter.SetInputConnection(cube.GetOutputPort()) cutter.Update() cutterMapper=vtk.vtkPolyDataMapper() cutterMapper.SetInputConnection( cutter.GetOutputPort()) #create plane actor planeActor=vtk.vtkActor() planeActor.GetProperty().SetColor(1.0,1,0) planeActor.GetProperty().SetLineWidth(2) planeActor.SetMapper(cutterMapper) #create renderers and add actors of plane and cube ren.AddActor(planeActor) ret = [] points = cutter.GetOutput().GetPoints() for i in range(points.GetNumberOfPoints()): point = points.GetPoint(i) ret.append( point ) return ret
def ImplicitFunctionVtuCut(inputVtu, implicitFunction): """ Perform a cut of a vtu. Cutting as in ClipCow.py vtkCutter example of vtk documentation 5.0.4, and Fluidity test case lock_exchange_tet.xml results variable. """ # The cutter cutter = vtk.vtkCutter() cutter.SetCutFunction(implicitFunction) if vtk.vtkVersion.GetVTKMajorVersion() <= 5: cutter.SetInput(inputVtu.ugrid) else: cutter.SetInputData(inputVtu.ugrid) # Cut cutter.Update() cutUPoly = cutter.GetOutput() # Construct output result = vtu() result.ugrid = PolyDataToUnstructuredGrid(cutUPoly) if result.ugrid.GetNumberOfPoints() == 0: debug.deprint("Warning: Cut vtu contains no nodes") return result
def AddDataSet(self, dataset, property): doit = True if not dataset: doit = False if self.HasDataSet(dataset): doit = False imagedata = vtk.vtkImageData.SafeDownCast(dataset) if imagedata: self.SetImage(imagedata) else: if not self.Image: doit=False if doit: matrix = vtk.vtkMatrix4x4() for i in range(3): for j in range(3): matrix.SetElement(i,j,self.ImageReslice.GetResliceAxes().GetElement(j,i)) matrix.SetElement(i, 3, 0) matrix.SetElement(3, 3, 1) cutter = vtk.vtkCutter() cutter.SetCutFunction(self.DataSetCutPlane) # Very strangely in some cases (ex : landmarks) # the cutter increments the RefCount of the input dataset by 2 # making some memory leek... # I could not manage to know what is wrong here cutter.SetInput(dataset) cutter.Update() if not cutter.GetOutput(): print "Unable to cut this dataset..." del matrix del cutter return None mapper = vtk.vtkPolyDataMapper() mapper.SetInput(cutter.GetOutput()) actor = vtk.vtkActor() actor.SetUseMatrix(matrix) actor.SetMapper(mapper) if property: actor.SetProperty(property) actor.PickableOff() self.AddActor(actor) self.DataSetList.append(dataset) self.DataSetActorList.append(actor) self.ResetAndRestablishZoomAndCamera() del actor del mapper del matrix del cutter return self.GetDataSetActor(dataset)
def cutdataset(dataset, point, normal): cutplane = vtk.vtkPlane() cutplane.SetOrigin(point) cutplane.SetNormal(normal) cutter = vtk.vtkCutter() cutter.SetInputData(dataset) cutter.SetCutFunction(cutplane) cutter.Update() return cutter.GetOutput()
def slicedataset(dataset, point, normal): """Slice through a vtkDataSet object with a plane defined by point and normal.""" cutplane = vtk.vtkPlane() cutplane.SetOrigin(point) cutplane.SetNormal(normal) cutter = vtk.vtkCutter() cutter.SetInput(dataset) cutter.SetCutFunction(cutplane) cutter.Update() return cutter.GetOutput()
def _UpdateIntersections(self): if self._Planes is None: return if self._Cube is None: return self._Cutters = [] for plane in self._Planes: cutter = vtk.vtkCutter() cutter.SetCutFunction(plane.GetPlaneEquation()) cutter.SetInput(self._Cube.GetOutput()) self._Cutters.append(cutter)
def __init__(self, module_manager): SimpleVTKClassModuleBase.__init__( self, module_manager, vtk.vtkCutter(), "Processing.", ("vtkDataSet",), ("vtkPolyData",), replaceDoc=True, inputFunctions=None, outputFunctions=None, )
def extract_sphere(data, origin, radius): """Extracts a spherical slice of data from VTK data object """ sphere = vtk.vtkSphere() sphere.SetRadius(radius) cutter = vtk.vtkCutter() cutter.SetInputDataObject(data.reader.GetOutput()) cutter.SetCutFunction(sphere) cutter.Update() return cutter.GetOutputDataObject(0)
def _slice(pdi, pdo, plane): """Slice an input on a plane and produce the output """ # create slice cutter = vtk.vtkCutter() # Construct the cutter object cutter.SetInputData(pdi) # Use the grid as the data we desire to cut cutter.SetCutFunction(plane) # the the cutter to use the plane we made cutter.Update() # Perfrom the Cut slc = cutter.GetOutput() # grab the output pdo.ShallowCopy(slc) return pdo
def __init__(self, map_actor, text_actor): self.AddObserver("MouseMoveEvent", self.mouse_move_event) self.map_actor = map_actor self.text_actor = text_actor self.elevation_actor = vtk.vtkActor() self.sphere = vtk.vtkSphere() self.cutter = vtk.vtkCutter() self.stripper = vtk.vtkStripper() self.tube_filter = vtk.vtkTubeFilter() self.mapper = vtk.vtkDataSetMapper() self.picker = vtk.vtkPointPicker()
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 InitializeContours(self, data, color=yellow): self.data = data # Disable interactor self.viewer.GetRenderWindow().GetInteractor().Disable() if self.contourActor is not None: self.viewer.GetRenderer().RemoveActor(self.contourActor) self.contourActor = None # Update contours self.plane = vtk.vtkPlane() RCW = self.viewer.GetResliceCursorWidget() ps = RCW.GetResliceCursorRepresentation().GetPlaneSource() self.plane.SetOrigin(ps.GetOrigin()) normal = ps.GetNormal() self.plane.SetNormal(normal) # Generate line segments self.cutEdges = vtk.vtkCutter() self.cutEdges.SetInputConnection(self.data.GetOutputPort()) self.cutEdges.SetCutFunction(self.plane) self.cutEdges.GenerateCutScalarsOff() self.cutEdges.SetValue(0, 0.5) # Put together into polylines cutStrips = vtk.vtkStripper() cutStrips.SetInputConnection(self.cutEdges.GetOutputPort()) cutStrips.Update() edgeMapper = vtk.vtkPolyDataMapper() edgeMapper.SetInputConnection(cutStrips.GetOutputPort()) # Attach observer to mapper edgeMapper.AddObserver(vtk.vtkCommand.UpdateEvent, myCallback) self.contourActor = vtk.vtkActor() self.contourActor.SetMapper(edgeMapper) prop = self.contourActor.GetProperty() renderLinesAsTubes(prop) prop.SetColor(color) # If Scalars are extracted - they turn green # Move in front of image (is this necessary?) transform = vtk.vtkTransform() transform.Translate(normal) self.contourActor.SetUserTransform(transform) # Add actor to renderer self.viewer.GetRenderer().AddViewProp(self.contourActor) # Enable interactor again self.viewer.GetRenderWindow().GetInteractor().Enable()
def __init__(self, parent = None): super(VTKFrame, self).__init__(parent) self.vtkWidget = QVTKRenderWindowInteractor(self) vl = QtGui.QVBoxLayout(self) vl.addWidget(self.vtkWidget) vl.setContentsMargins(0, 0, 0, 0) self.ren = vtk.vtkRenderer() self.vtkWidget.GetRenderWindow().AddRenderer(self.ren) self.iren = self.vtkWidget.GetRenderWindow().GetInteractor() #Create a sphere sphere = vtk.vtkSphereSource() sphere.SetRadius(50) sphere.SetThetaResolution(100) sphere.SetPhiResolution(100) plane = vtk.vtkPlane() plane.SetOrigin(20, 0, 0) plane.SetNormal(1, 0, 0) #create cutter cutter = vtk.vtkCutter() cutter.SetCutFunction(plane) cutter.SetInputConnection(sphere.GetOutputPort()) cutter.Update() cutStrips = vtk.vtkStripper() cutStrips.SetInputConnection(cutter.GetOutputPort()) cutStrips.Update() cutPoly = vtk.vtkPolyData() cutPoly.SetPoints((cutStrips.GetOutput()).GetPoints()) cutPoly.SetPolys((cutStrips.GetOutput()).GetLines()) cutMapper = vtk.vtkPolyDataMapper() cutMapper.SetInput(cutPoly) #cutMapper.SetInputConnection(cutter.GetOutputPort()) cutActor = vtk.vtkActor() cutActor.GetProperty().SetColor(1, 1, 0) cutActor.GetProperty().SetEdgeColor(0, 1, 0) cutActor.GetProperty().SetLineWidth(2) cutActor.GetProperty().EdgeVisibilityOn() cutActor.SetMapper(cutMapper) #create renderers and add actors of plane and cube self.ren.AddActor(cutActor) self.ren.ResetCamera() self._initialized = False
def InitializeContours(self, contourData, color=yellow): # Disable interactor self.viewer.GetRenderWindow().GetInteractor().Disable() if self.contourActor is not None: self.viewer.GetRenderer().RemoveActor(self.contourActor) self.contourActor = None # Update contours self.plane = vtk.vtkPlane() RCW = self.viewer.GetResliceCursorWidget() ps = RCW.GetResliceCursorRepresentation().GetPlaneSource() self.plane.SetOrigin(ps.GetOrigin()) normal = ps.GetNormal() self.plane.SetNormal(normal) # We ignore empty ouput (in C++) # Transform polydata according to misplacement self.transformPolyDataFilter = vtk.vtkTransformPolyDataFilter() self.transformPolyDataFilter.SetInputConnection( contourData.GetOutputPort()) self.transformPolyDataFilter.SetTransform(self.transform) # Generate line segments self.cutEdges = vtk.vtkCutter() self.cutEdges.SetInputConnection( self.transformPolyDataFilter.GetOutputPort()) self.cutEdges.SetCutFunction(self.plane) self.cutEdges.GenerateCutScalarsOff() self.cutEdges.SetValue(0, 0.5) self.cutEdges.Update() # Put together into polylines self.cutStrips = vtk.vtkStripper() self.cutStrips.SetInputConnection(self.cutEdges.GetOutputPort()) self.cutStrips.Update() edgeMapper = vtk.vtkPolyDataMapper() edgeMapper.SetInputConnection(self.cutStrips.GetOutputPort()) self.contourActor = vtk.vtkActor() self.contourActor.SetMapper(edgeMapper) prop = self.contourActor.GetProperty() renderLinesAsTubes(prop) prop.SetColor(color) # Add actor to renderer self.viewer.GetRenderer().AddViewProp(self.contourActor) # Enable interactor again self.viewer.GetRenderWindow().GetInteractor().Enable()
def __init__(self, parent=None): super(VTKFrame, self).__init__(parent) self.vtkWidget = QVTKRenderWindowInteractor(self) vl = QtGui.QVBoxLayout(self) vl.addWidget(self.vtkWidget) vl.setContentsMargins(0, 0, 0, 0) self.ren = vtk.vtkRenderer() self.vtkWidget.GetRenderWindow().AddRenderer(self.ren) self.iren = self.vtkWidget.GetRenderWindow().GetInteractor() #Create a sphere sphere = vtk.vtkSphereSource() sphere.SetRadius(50) sphere.SetThetaResolution(100) sphere.SetPhiResolution(100) plane = vtk.vtkPlane() plane.SetOrigin(20, 0, 0) plane.SetNormal(1, 0, 0) #create cutter cutter = vtk.vtkCutter() cutter.SetCutFunction(plane) cutter.SetInputConnection(sphere.GetOutputPort()) cutter.Update() cutStrips = vtk.vtkStripper() cutStrips.SetInputConnection(cutter.GetOutputPort()) cutStrips.Update() cutPoly = vtk.vtkPolyData() cutPoly.SetPoints((cutStrips.GetOutput()).GetPoints()) cutPoly.SetPolys((cutStrips.GetOutput()).GetLines()) cutMapper = vtk.vtkPolyDataMapper() cutMapper.SetInput(cutPoly) #cutMapper.SetInputConnection(cutter.GetOutputPort()) cutActor = vtk.vtkActor() cutActor.GetProperty().SetColor(1, 1, 0) cutActor.GetProperty().SetEdgeColor(0, 1, 0) cutActor.GetProperty().SetLineWidth(2) cutActor.GetProperty().EdgeVisibilityOn() cutActor.SetMapper(cutMapper) #create renderers and add actors of plane and cube self.ren.AddActor(cutActor) self.ren.ResetCamera() self._initialized = False
def _createCutter(self): logging.debug("In MultiSliceContour::createCutter()") self._cutters = [] self._planeCutters = [] for slice in self._scene.slice: cutter = vtk.vtkCutter() plane = vtk.vtkPlane() plane.SetOrigin(slice.plane.GetOrigin()) plane.SetNormal(slice.plane.GetNormal()) cutter.SetCutFunction(plane) cutter.GenerateCutScalarsOn() self._planeCutters.append(plane) self._cutters.append(cutter)
def extract_plane(data, origin, normal): """Extracts a planar slice of data from VTK data object """ plane = vtk.vtkPlane() plane.SetOrigin(*origin) plane.SetNormal(*normal) cutter = vtk.vtkCutter() cutter.SetInputDataObject(data.reader.GetOutput()) cutter.SetCutFunction(plane) cutter.Update() return cutter.GetOutputDataObject(0)
def CreateSkinCutting(cf): plane = vtk.vtkPlane() plane.SetOrigin(0, 0, 0) plane.SetNormal(0, 0, 1) cutter = vtk.vtkCutter() cutter.SetCutFunction(plane) cutter.SetInputConnection(cf.GetOutputPort()) for i in range(100): cutter.SetValue(i, 10 * i) cutter.Update() return cutter
def slice_extraction(self, origin, normal): # create a plane to cut (xz normal=(1,0,0);XY =(0,0,1),YZ =(0,1,0) plane = vtk.vtkPlane() plane.SetOrigin(*origin) plane.SetNormal(*normal) # create cutter cutter = vtk.vtkCutter() cutter.SetCutFunction(plane) cutter.SetInputConnection(self.mesh.GetOutputPort()) cutter.Update() self.mesh = cutter
def __init__(self, parent = None): super(VTKFrame, self).__init__(parent) self.vtkWidget = QVTKRenderWindowInteractor(self) vl = QtGui.QVBoxLayout(self) vl.addWidget(self.vtkWidget) vl.setContentsMargins(0, 0, 0, 0) self.ren = vtk.vtkRenderer() self.vtkWidget.GetRenderWindow().AddRenderer(self.ren) self.iren = self.vtkWidget.GetRenderWindow().GetInteractor() #Create a cube cube=vtk.vtkCubeSource() cube.SetXLength(40) cube.SetYLength(30) cube.SetZLength(20) cubeMapper=vtk.vtkPolyDataMapper() cubeMapper.SetInputConnection(cube.GetOutputPort()) #create a plane to cut,here it cuts in the XZ direction (xz normal=(1,0,0);XY =(0,0,1),YZ =(0,1,0) plane=vtk.vtkPlane() plane.SetOrigin(10,0,0) plane.SetNormal(1,0,0) #create cutter cutter=vtk.vtkCutter() cutter.SetCutFunction(plane) cutter.SetInputConnection(cube.GetOutputPort()) cutter.Update() cutterMapper=vtk.vtkPolyDataMapper() cutterMapper.SetInputConnection( cutter.GetOutputPort()) #create plane actor planeActor=vtk.vtkActor() planeActor.GetProperty().SetColor(1.0,1,0) planeActor.GetProperty().SetLineWidth(2) planeActor.SetMapper(cutterMapper) #create cube actor cubeActor=vtk.vtkActor() cubeActor.GetProperty().SetColor(0.5,1,0.5) cubeActor.GetProperty().SetOpacity(0.5) cubeActor.SetMapper(cubeMapper) #create renderers and add actors of plane and cube self.ren.AddActor(planeActor) self.ren.AddActor(cubeActor) self.ren.ResetCamera() self._initialized = False
def main(): colors = vtk.vtkNamedColors() # Create a cube cube = vtk.vtkCubeSource() cube.SetXLength(40) cube.SetYLength(30) cube.SetZLength(20) cubeMapper = vtk.vtkPolyDataMapper() cubeMapper.SetInputConnection(cube.GetOutputPort()) # create a plane to cut,here it cuts in the XZ direction (xz normal=(1,0,0);XY =(0,0,1),YZ =(0,1,0) plane = vtk.vtkPlane() plane.SetOrigin(10, 0, 0) plane.SetNormal(1, 0, 0) # create cutter cutter = vtk.vtkCutter() cutter.SetCutFunction(plane) cutter.SetInputConnection(cube.GetOutputPort()) cutter.Update() cutterMapper = vtk.vtkPolyDataMapper() cutterMapper.SetInputConnection(cutter.GetOutputPort()) # create plane actor planeActor = vtk.vtkActor() planeActor.GetProperty().SetColor(colors.GetColor3d("Yellow")) planeActor.GetProperty().SetLineWidth(2) planeActor.SetMapper(cutterMapper) # create cube actor cubeActor = vtk.vtkActor() cubeActor.GetProperty().SetColor(colors.GetColor3d("Aquamarine")) cubeActor.GetProperty().SetOpacity(0.3) cubeActor.SetMapper(cubeMapper) # create renderers and add actors of plane and cube ren = vtk.vtkRenderer() ren.AddActor(planeActor) ren.AddActor(cubeActor) # Add renderer to renderwindow and render renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) renWin.SetSize(600, 600) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) ren.SetBackground(colors.GetColor3d("Silver")) renWin.Render() iren.Start()
def __init__(self, parent=None): super(VTKFrame, self).__init__(parent) self.vtkWidget = QVTKRenderWindowInteractor(self) vl = QtGui.QVBoxLayout(self) vl.addWidget(self.vtkWidget) vl.setContentsMargins(0, 0, 0, 0) self.ren = vtk.vtkRenderer() self.vtkWidget.GetRenderWindow().AddRenderer(self.ren) self.iren = self.vtkWidget.GetRenderWindow().GetInteractor() #Create a cube cube = vtk.vtkCubeSource() cube.SetXLength(40) cube.SetYLength(30) cube.SetZLength(20) cubeMapper = vtk.vtkPolyDataMapper() cubeMapper.SetInputConnection(cube.GetOutputPort()) #create a plane to cut,here it cuts in the XZ direction (xz normal=(1,0,0);XY =(0,0,1),YZ =(0,1,0) plane = vtk.vtkPlane() plane.SetOrigin(10, 0, 0) plane.SetNormal(1, 0, 0) #create cutter cutter = vtk.vtkCutter() cutter.SetCutFunction(plane) cutter.SetInputConnection(cube.GetOutputPort()) cutter.Update() cutterMapper = vtk.vtkPolyDataMapper() cutterMapper.SetInputConnection(cutter.GetOutputPort()) #create plane actor planeActor = vtk.vtkActor() planeActor.GetProperty().SetColor(1.0, 1, 0) planeActor.GetProperty().SetLineWidth(2) planeActor.SetMapper(cutterMapper) #create cube actor cubeActor = vtk.vtkActor() cubeActor.GetProperty().SetColor(0.5, 1, 0.5) cubeActor.GetProperty().SetOpacity(0.5) cubeActor.SetMapper(cubeMapper) #create renderers and add actors of plane and cube self.ren.AddActor(planeActor) self.ren.AddActor(cubeActor) self.ren.ResetCamera() self._initialized = False
def SetPlanes(self, planes): self._Planes = planes for i in range(3): for j in range(i + 1, 3): cutter = vtk.vtkCutter() # VTK-6 if vtk.vtkVersion().GetVTKMajorVersion() > 5: cutter.SetInputData(planes[i].GetPolyData()) else: cutter.SetInput(planes[i].GetPolyData()) cutter.SetCutFunction(planes[j].GetPlaneEquation()) self._Cutters.append(cutter)
def cutplanes(data, origin, normal): # create cutting plane plane = createplane(origin,normal) # create cutter cutter = vtk.vtkCutter() cutter.SetCutFunction(plane) cutter.SetInputData(data) cutter.Update() #print cutter cutslice = cutter.GetOutput() npoints = cutslice.GetNumberOfPoints() ncells = cutslice.GetNumberOfCells() #print cutslice return cutslice, npoints, ncells
def __init__(self, mesh): self.cutter = vtkCutter() self.cutter.SetCutFunction(vtkPlane()) self.tubes = vtkTubeFilter() self.tubes.SetInputConnection(self.cutter.GetOutputPort()) self.tubes.SetRadius(1) self.tubes.SetNumberOfSides(8) self.tubes.CappingOn() self.mapper = vtkPolyDataMapper() self.mapper.SetInputConnection(self.tubes.GetOutputPort()) self.actor = vtkActor() self.actor.SetMapper(self.mapper) self.cutter.SetInput(mesh) self.AddPart(self.actor)
def vtkCutDataSet(dataset, func, values): """ uses vtkCutter, always creates a mesh consisting only of triangles (in3d) """ f = vtk.vtkCutter() f.SetCutFunction(func) if not hasattr(values, '__iter__'): values = [values] for i, v in enumerate(values): f.SetValue(i, v) f.SetInput(dataset) f.Update() return f.GetOutput()
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 __init__ (self, mod_m): debug ("In WarpVectorCutPlane::__init__ ()") Common.state.busy () Base.Objects.CutPlaneModule.__init__ (self, mod_m) self.cut = vtk.vtkCutter () self.warp = vtk.vtkWarpVector () self.norm = vtk.vtkPolyDataNormals () self.mapper = self.map = vtk.vtkPolyDataMapper () self.map.SetLookupTable (self.mod_m.get_scalar_lut ()) self.actor = self.act = vtk.vtkActor () self.data_out = self.mod_m.GetOutput () self._initialize () self._gui_init () self.renwin.Render () Common.state.idle ()
def plot_mesh_cuts(pd, p_name, nz=7): """ """ # Create a cube cube = vtk.vtkCubeSource() cube.SetXLength(40) cube.SetYLength(30) cube.SetZLength(20) # cubeMapper = vtk.vtkPolyDataMapper() # cubeMapper.SetInputConnection(cube.GetOutputPort()) pd.GetPointData().SetActiveScalars("radius") # for the the filter tubeFilter = vtk.vtkTubeFilter() tubeFilter.SetInputData(pd) tubeFilter.SetNumberOfSides(9) tubeFilter.SetVaryRadiusToVaryRadiusByAbsoluteScalar() tubeFilter.Update() bounds = pd.GetBounds() planes = [] for i in range(0, nz): # z-slices (implicit functions) p = vtk.vtkPlane() z = ((bounds[5] - bounds[4]) / (nz + 1)) * (i + 1) p.SetOrigin(0., 0., bounds[4] + z) p.SetNormal(0., 0., 1) planes.append(p) lut = get_lookup_table(24) # 24= Brewer Diverging Brown-Blue-Green (11) # lut.SetTableRange(pd.GetPointData().GetScalars(p_name).GetRange()) # create cutter, mappers, and actors actors = [] for i in range(0, nz): cutter = vtk.vtkCutter() # cutter.SetInputData(pd) cutter.SetCutFunction(planes[i]) cutter.SetInputConnection(tubeFilter.GetOutputPort()) cutter.Update() m = vtk.vtkPolyDataMapper() m.SetInputConnection(cutter.GetOutputPort()) m.Update() m.SetLookupTable(lut) a = vtk.vtkActor() # create plane actor a.GetProperty().SetColor(1.0, 1, 0) a.GetProperty().SetLineWidth(2) a.SetMapper(m) actors.append(a) return actors
def check_if_filt_tri_inside_PD(tripts, mesh): points1 =vtk.vtkPoints() points1.InsertNextPoint (triangle_points[0]) points1.InsertNextPoint (triangle_points[1]) points1.InsertNextPoint (triangle_points[2]) triangle =vtk.vtkTriangle() triangle.GetPointIds().SetId ( 0, 0 ) triangle.GetPointIds().SetId ( 1, 1 ) triangle.GetPointIds().SetId ( 2, 2 ) triangles = vtk.vtkCellArray() triangles.InsertNextCell(triangle) trianglePolyData =vtk.vtkPolyData() trianglePolyData.SetPoints( points1 ) trianglePolyData.SetPolys( triangles ) A=triangle_points[0] B=triangle_points[1] C=triangle_points[2] a_minus_b=A-B a_minus_C=A-C normtoplane=np.cross(a_minus_b,a_minus_C) centerOfMassFilter =vtk.vtkCenterOfMass() centerOfMassFilter.SetInputData(trianglePolyData) centerOfMassFilter.Update() center=centerOfMassFilter.GetCenter() plane = vtk.vtkPlane() plane.SetOrigin(center) plane.SetNormal(normtoplane) planeCut = vtk.vtkCutter() planeCut.SetInputData(mesh) planeCut.SetCutFunction(plane) planeCut.Update() num_inter= planeCut.GetOutput().GetNumberOfPoints() return num_inter
def InitializeContour(self, data): # Update contours self.plane = vtk.vtkPlane() RCW = self.viewer.GetResliceCursorWidget() ps = RCW.GetResliceCursorRepresentation().GetPlaneSource() normal = ps.GetNormal() origin = ps.GetOrigin() self.plane.SetOrigin(origin) self.plane.SetNormal(normal) if not oldWay: self.plane.SetOrigin(0, 0, 0) self.plane.SetNormal(0, 0, 1) self.tmp = vtk.vtkTransform() self.tmp.SetMatrix( main_window.planeWidget[self.iDim].GetResliceAxes()) self.plane.SetTransform(self.tmp) # Generate line segments cutEdges = vtk.vtkCutter() cutEdges.SetInputConnection(main_window.vesselNormals.GetOutputPort()) cutEdges.SetCutFunction(self.plane) cutEdges.GenerateCutScalarsOff() cutEdges.SetValue(0, 0.5) # Put together into polylines cutStrips = vtk.vtkStripper() cutStrips.SetInputConnection(cutEdges.GetOutputPort()) cutStrips.Update() edgeMapper = vtk.vtkPolyDataMapper() edgeMapper.SetInputConnection(cutStrips.GetOutputPort()) self.edgeActor = vtk.vtkActor() self.edgeActor.SetMapper(edgeMapper) prop = self.edgeActor.GetProperty() renderLinesAsTubes(prop) prop.SetColor(yellow) # If Scalars are extracted - they turn green # Move in front of image transform = vtk.vtkTransform() transform.Translate(normal) self.edgeActor.SetUserTransform(transform) # Add actor to renderer self.viewer.GetRenderer().AddViewProp(self.edgeActor)
def addSlices(self, slices): r""" Adds slices into the AmpActor which can then be rendered Parameters ---------- slices: array_like The values in the z-axis of which to make the slices """ self.planes = [] self.cutters = [] self.pMapper = [] self.pActors = [] self.lActors = [] self.labels = [] self.hier = [] self.lMapper = [] for s in slices: p = vtk.vtkPlane() p.SetOrigin(0, 0, s) p.SetNormal(0, 0, 1) c = vtk.vtkCutter() c.SetCutFunction(p) c.SetInputData(self.mesh) c.Update() cM=vtk.vtkPolyDataMapper() cM.SetInputConnection(c.GetOutputPort()) pA=vtk.vtkActor() pA.GetProperty().SetColor(31.0/255.0, 73.0/255.0, 125.0/255.0) pA.GetProperty().SetLineWidth(5) pA.GetProperty().SetInterpolationToFlat() pA.GetProperty().EdgeVisibilityOn() pA.GetProperty().SetRenderLinesAsTubes(True) pA.SetMapper(cM) text = vtk.vtkBillboardTextActor3D() text.SetInput('test') text.SetPosition(0,0,s) text.GetTextProperty().SetColor(0, 0, 0) self.planes.append(p) self.cutters.append(c) self.pMapper.append(cM) self.pActors.append(pA) self.lActors.append(text) self.setOpacity(0.1)
def createClipActor(grid, plane, showScalar=False, range=None, showEdges=False, colorMap='GrayScale'): clipMapper = vtk.vtkDataSetMapper() clipMapper.SetInput(grid) cutMapper = vtk.vtkDataSetMapper() clipActor = vtk.vtkActor() cutActor = vtk.vtkActor() if showScalar: scalars = grid.GetPointData().GetScalars() if scalars==None: scalars = grid.GetCellData().GetScalars() if scalars==None: scalars = grid.GetPointData().GetArray(0) grid.GetPointData().SetScalars(scalars) if scalars==None: scalars = grid.GetCellData().GetArray(0) grid.GetCellData().SetScalars(scalars) if range==None: range = [scalars.GetRange()[0],.8*scalars.GetRange()[1]] cutMapper.SetScalarRange(*range) clipMapper.SetScalarRange(*range) if colorMap=='GrayScale':wl = vtk.vtkWindowLevelLookupTable() else: wl = vtk.vtkLookupTable() wl.SetScaleToLinear() wl.SetRange(*range) wl.SetHueRange(0.6667,0.0)#blue to red wl.Build() clipMapper.SetLookupTable(wl) cutMapper.SetLookupTable(wl) else: clipMapper.ScalarVisibilityOff() cutMapper.ScalarVisibilityOff() clipActor.GetProperty().SetColor(.6, .6, .6) cutActor.GetProperty().SetColor(.6, .6, .6) clipMapper.AddClippingPlane(plane) clipActor.SetMapper(clipMapper) cutter = vtk.vtkCutter() cutter.SetCutFunction(plane) cutter.SetInput(grid) cutter.Update() cutMapper.SetInputConnection(cutter.GetOutputPort()) cutActor.SetMapper(cutMapper) if showEdges: cutActor.GetProperty().EdgeVisibilityOn() clipActor.GetProperty().EdgeVisibilityOn() return [cutActor,clipActor]
def __init__(self, actCut, Map, text): self.AddObserver("MouseMoveEvent", self.mouseMoveEvent) # l'acteur dois déjà être ajouté au renderer self.PickedActorCutter = actCut self.Map = Map self.textActor = text self.plane = vtk.vtkPlane() self.plane.SetNormal(0, 0, 1) self.cutter = vtk.vtkCutter() self.cutter.SetCutFunction(self.plane) self.cutter.SetValue(0, 10) self.cutter.SetInputData(self.Map) self.cutterMapper = vtk.vtkPolyDataMapper()
def sliceheart(domain, C, N, verbose=True): if (verbose): print '*** Slice Heart ***' plane = vtk.vtkPlane() plane.SetOrigin(C) plane.SetNormal(N) cutter = vtk.vtkCutter() cutter.SetCutFunction(plane) if (vtk.vtkVersion().GetVTKMajorVersion() < 6): cutter.SetInput(domain) else: cutter.SetInputData(domain) cutter.Update() return cutter.GetOutput()
def getSlice(data_outVTK, orig, nor): """ Defines the plane normal to the vector *nor* that contains the point *orig* and then extract the data from the reader *reader*. The dimension of the data returned is reduced by one (a 2D data field gives a 1D data filed). Parameters ---------- data_outVTK : VTK output object from a VTK reader VTK output object associated to the file we want to extract a slice of data. orig : tuple(3) A point element of the plane used to slice the data. normal : tuple(3) A vector normal to the plane used to slice the data. Returns ------- slice_outVTK : VTK output object from a VTK reader Returned data are still not in an array form, but a VTK output object is returned where the data are stored. """ #function display print '---- DAEPy::getSlice ----' # Plane of the Slice plane = vtk.vtkPlane() plane.SetOrigin(orig) plane.SetNormal(nor) print '--> normal used to slice: ', nor # Cutter plane planeCut = vtk.vtkCutter() # planeCut.SetInputData(data_outVTK) # VTK6 SetInput() repl. with SetInputData() vtk.org/Wiki/VTK/VTK_6_Migration/Replacement_of_SetInput planeCut.SetInput(data_outVTK) # sometimes to switch one another planeCut.SetCutFunction(plane) # Make the slice planeCut.Update() slice_outVTK = planeCut.GetOutput() print '' return slice_outVTK
def testCutterNoTriangles(self): cutter = vtk.vtkCutter() cutter.GenerateTrianglesOff() # triangle generation is disabled! cutter_function = vtk.vtkPlane() cutter_function.SetOrigin(0.0, 0.0, 0.5) cutter_function.SetNormal(0.0, 0.0, 1.0) cutter.SetCutFunction(cutter_function) cutter.SetInputData(self.vtk_grid) cutter.Update() surface = cutter.GetOutput() writer = vtk.vtkXMLPolyDataWriter() writer.SetInputData(surface) writer.SetFileName('surface_poly.vtp') writer.Write() self.assertEqual(surface.GetNumberOfCells(), 1)
def get_section(asmesh: vtk.vtkPolyData, normal, origin, return_untransformed=False): normal = normal / np.linalg.norm(normal) cutter = vtk.vtkCutter() plane = vtk.vtkPlane() plane.SetOrigin(origin) plane.SetNormal(normal) cutter.SetCutFunction(plane) cutter.SetInputData(asmesh) cutter.Update() cut = pyvista.PolyData(cutter.GetOutput()) lines = extract_lines(cut) if return_untransformed: return [np.array(cut.points[l]) for l in lines] # we need to apply a transform to put the data in the local section reference frame # we start setting the new axis for building the transform z = -normal u = np.array([ 1, 0, 0.0 ]) # as x we will use the vector coming from projecting u onto the plane u = u / np.linalg.norm(u) x = u - u.dot( normal) * normal # note: we know they already are unit vectors y = np.cross(z, x) # third axis T = np.column_stack([x, y, z]) # note we know transform is orthonormal newpts = cut.points.dot(T) o = [] for sline in lines: aa = newpts[:, :2][sline] o.append(np.array(aa)) return o
def write_unstructured_grid(filename,mesh,cdata,nEle,EFs,time,verbose, outline=False,cut=[]): writer = vtk.vtkXMLUnstructuredGridWriter() writer.SetDataModeToBinary() ## writer.SetDataModeToAscii() writer.SetFileName(filename+'.vtu') extract = vtk.vtkExtractCells() extract.SetInputData(mesh) eleList = vtk.vtkIdList() EF = cdata.GetArray('EF') for k in range(nEle): if (EFs[EF.GetValue(k)][0]<time and EFs[EF.GetValue(k)][1]>=time) or (EFs[EF.GetValue(k)][0]==0 and time==0): a=eleList.InsertNextId(k) extract.SetCellList(eleList) grid = extract.GetOutputPort() if outline: gf = vtk.vtkGeometryFilter() gf.SetInputConnection(grid) cpd = vtk.vtkCleanPolyData() cpd.SetInputConnection(gf.GetOutputPort()) cpd.Update() af = vtk.vtkAppendFilter() af.AddInputData(cpd.GetOutput()) grid = af.GetOutputPort() elif len(cut): plane = vtk.vtkPlane() plane.SetOrigin(cut[0]) plane.SetNormal(cut[1]) cutter = vtk.vtkCutter() cutter.SetInputConnection(grid) cutter.SetCutFunction(plane) cutter.Update() cpd = vtk.vtkCleanPolyData() cpd.SetInputConnection(cutter.GetOutputPort()) cpd.Update() af = vtk.vtkAppendFilter() af.AddInputData(cpd.GetOutput()) grid = af.GetOutputPort() writer.SetFileName(filename+'_cut.vtu') writer.SetInputConnection(grid) writer.Write() if not verbose: print('%i elements written to %s'%(eleList.GetNumberOfIds(),filename))
def __init__(self, marker, planeWidget, transform=None, lineWidth=1): self.lineWidth=lineWidth self.marker = marker self.markerSource = marker.get_source() self.planeWidget = planeWidget self.transform = transform self.implicitPlane = vtk.vtkPlane() self.ringEdges = vtk.vtkCutter() self.ringStrips = vtk.vtkStripper() self.ringPoly = vtk.vtkPolyData() self.ringMapper = vtk.vtkPolyDataMapper() self.ringEdges.SetInput(self.markerSource.GetOutput()) self.implicitPlane.SetNormal(self.planeWidget.GetNormal()) self.implicitPlane.SetOrigin(self.planeWidget.GetOrigin()) #print 'implicit plane', self.implicitPlane self.ringEdges.SetCutFunction(self.implicitPlane) self.ringEdges.GenerateCutScalarsOff() self.ringEdges.SetValue(0, 0.0) self.ringStrips.SetInput(self.ringEdges.GetOutput()) self.ringStrips.Update() self.ringPoly.SetPoints(self.ringStrips.GetOutput().GetPoints()) self.ringPoly.SetPolys(self.ringStrips.GetOutput().GetLines()) self.ringMapper.SetInput(self.ringPoly) self.SetMapper(self.ringMapper) self.lineProperty = self.GetProperty() self.lineProperty.SetRepresentationToWireframe() self.lineProperty.SetAmbient(1.0) self.lineProperty.SetColor(self.marker.get_color()) self.lineProperty.SetLineWidth(lineWidth) self.SetProperty(self.lineProperty) self.VisibilityOff() if transform is not None: self.filter = vtk.vtkTransformPolyDataFilter() self.filter.SetTransform(transform) else: self.filter = None self.update()
def Slice_VTK_data_to_numpyArray(inputFileName, point, normal, resolution): reader = vtk.vtkXMLUnstructuredGridReader() reader.SetFileName(inputFileName) reader.Update() plane = vtk.vtkPlane() plane.SetOrigin(point) plane.SetNormal(normal) cutter = vtk.vtkCutter() cutter.SetCutFunction(plane) cutter.SetInputConnection(reader.GetOutputPort()) cutter.Update() vtkarray = cutter.GetOutput().GetPointData().GetArray(0) numpy_array = npvtk.vtk_to_numpy(vtkarray) return numpy_array
def slice(dataset, normal='x', origin=None, generate_triangles=False, contour=False): """Slice a dataset by a plane at the specified origin and normal vector orientation. If no origin is specified, the center of the input dataset will be used. Parameters ---------- normal : tuple(float) or str Length 3 tuple for the normal vector direction. Can also be specified as a string conventional direction such as ``'x'`` for ``(1,0,0)`` or ``'-x'`` for ``(-1,0,0)```, etc. origin : tuple(float) The center (x,y,z) coordinate of the plane on which the slice occurs generate_triangles: bool, optional If this is enabled (``False`` by default), the output will be triangles otherwise, the output will be the intersection polygons. contour : bool, optional If True, apply a ``contour`` filter after slicing """ if isinstance(normal, str): normal = NORMALS[normal.lower()] # find center of data if origin not specified if origin is None: origin = dataset.center if not is_inside_bounds(origin, dataset.bounds): raise AssertionError('Slice is outside data bounds.') # create the plane for clipping plane = _generate_plane(normal, origin) # create slice alg = vtk.vtkCutter() # Construct the cutter object alg.SetInputDataObject(dataset) # Use the grid as the data we desire to cut alg.SetCutFunction(plane) # the the cutter to use the plane we made if not generate_triangles: alg.GenerateTrianglesOff() alg.Update() # Perfrom the Cut output = _get_output(alg) if contour: return output.contour() return output
def Execute(self): plane = vtk.vtkPlane() plane.SetOrigin(self.Center) plane.SetNormal(-math.sin(self.RotationAngle),math.cos(self.RotationAngle),0.0) cutter = vtk.vtkCutter() cutter.SetInput(self.Contour) cutter.SetCutFunction(plane) cutter.SetValue(0,0.0) cutter.Update() cutPoints = cutter.GetOutput().GetPoints() if not cutPoints or cutPoints.GetNumberOfPoints()==0: self.Locations = [0.0, 0.0] self.Thickness = 0.0 self.Thickness3D = 0.0 return self.Locations = self.FindLocations(cutPoints) self.Thickness = self.Locations[1] - self.Locations[0] self.Thickness3D = self.Thickness * math.cos(self.TiltingAngle)
def makeZCutter(self, bounds, scaleFactor, value): """ create z cutter plane """ npos = self._calculateZCutterPos(value) self.zplane = vtk.vtkPlane() self.zplane.SetOrigin(0, 0, npos) self.zplane.SetNormal(0, 0, 1) self.ZCutter = vtk.vtkCutter() self.ZCutter.SetInputConnection(self.warp.GetOutputPort()) self.ZCutter.SetCutFunction(self.zplane) self.ZCutter.GenerateCutScalarsOff() self.ZCutterMapper = vtk.vtkPolyDataMapper() self.ZCutterMapper.SetInputConnection(self.ZCutter.GetOutputPort()) # visual plane to move plane = vtk.vtkPlaneSource() plane.SetResolution(50, 50) plane.SetCenter(0, 0, 0) plane.SetNormal(0, 0, 1) tran = vtk.vtkTransform() tran.Translate((bounds[1] - bounds[0]) / 2. - (0 - bounds[0]), (bounds[3] - bounds[2]) / 2. - (0 - bounds[2]), npos) tran.Scale((bounds[1] - bounds[0]), (bounds[3] - bounds[2]), 1) tran.PostMultiply() self.ZCutterTransform = tran tranf = vtk.vtkTransformPolyDataFilter() tranf.SetInputConnection(plane.GetOutputPort()) tranf.SetTransform(tran) mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(tranf.GetOutputPort()) actor = vtk.vtkActor() actor.SetMapper(mapper) actor.GetProperty().SetColor(0.9, 0.9, 0.9) actor.GetProperty().SetOpacity(self.opacitySlice) return actor
def __init__(self, item_actor, plane, lut): self.cutter = vtkCutter() self.cutter.SetCutFunction(plane) self.cutter.SetInputConnection(item_actor.reader.GetOutputPort()) self.cutter.Update() self.mapper = vtkDataSetMapper() self.mapper.ScalarVisibilityOn() self.mapper.SetLookupTable(lut) self.mapper.SetInputConnection(self.cutter.GetOutputPort()) back = vtkProperty() back.SetColor(100, 100, 100) self.GetProperty().SetColor(1, 0, 0) self.GetProperty().EdgeVisibilityOff() self.GetProperty().SetLineWidth(3) self.SetMapper(self.mapper) self.SetBackfaceProperty(back)
def add_contour(renderer, plane, polydata, transform=None, line_width=3, color=(1, 0, 0)): """Add contour of mesh cut by given image plane to render scene.""" if transform: transformer = vtk.vtkTransformPolyDataFilter() transformer.SetInputData(polydata) transformer.SetTransform(transform) transformer.Update() polydata = deep_copy(transformer.GetOutput()) transformer = None cutter = vtk.vtkCutter() cutter.SetInputData(polydata) cutter.SetCutFunction(plane) cutter.Update() contour = deep_copy(cutter.GetOutput()) cutter = None mapper = vtk.vtkPolyDataMapper() mapper.SetInputData(contour) actor = vtk.vtkActor() actor.SetMapper(mapper) prop = actor.GetProperty() prop.LightingOff() prop.SetRepresentationToWireframe() prop.SetLineWidth(line_width) if color: prop.SetColor(color) mapper.ScalarVisibilityOff() elif polydata.GetPointData().GetScalars(): mapper.SetScalarModeToUsePointData() mapper.ScalarVisibilityOn() elif polydata.GetCellData().GetScalars(): mapper.SetScalarModeToUseCellData() mapper.ScalarVisibilityOn() renderer.AddActor(actor) return actor
def slicevtkcontour(vtkmesh, h, init=0, end=0): # Get limits xmin, xmax, ymin, ymax, zmin, zmax = vtkmesh.GetBounds() zmin += init zmax -= end # Plane to cut plane = vtk.vtkPlane() plane.SetOrigin(0, 0, zmin + h / 2.0) plane.SetNormal(0, 0, 1) # Cut function cutter = vtk.vtkCutter() cutter.SetInput(vtkmesh) cutter.SetCutFunction(plane) cutter.GenerateCutScalarsOn() cutter.SetValue(0, 0) # Catch the points cutStrips = vtk.vtkStripper() cutStrips.SetInputConnection(cutter.GetOutputPort()) cutStrips.Update() # Slice and create polygons layers = list() # zreal = h/2.0 z = zmin + h / 2.0 # because set an reliable zero can broke the tip zs = list() polygons = list() # one for layer while z < zmax: zs.append(z) plane.SetOrigin(0, 0, z) cutStrips.Update() coords = tuple() for j in range( cutStrips.GetOutput().GetCell(0).GetPoints().GetNumberOfPoints() ): # retrieve all points from the line vec = Vec(cutStrips.GetOutput().GetCell(0).GetPoints().GetPoint(j)) coords += ((vec.x, vec.y),) polygon = Polygon(coords) polygons.append(polygon) z += h return polygons, zs
def SliceSurface(self, m_pt, m_normalVector): """ Use vtkCutter to obtain a slice along the centerline direction :param m_pt: [float, float, float] A coordinate on the desired cutting plane :param m_normalVector: [float, float, float] The normal vector of the cutting plane :return: """ m_plane = vtk.vtkPlane() m_plane.SetOrigin(m_pt) m_plane.SetNormal(m_normalVector) # create cutter m_cutter = vtk.vtkCutter() m_cutter.SetCutFunction(m_plane) m_cutter.SetInputConnection(self._reader.GetOutputPort()) m_cutter.Update() m_vtkpoints = m_cutter.GetOutput().GetPoints() return m_vtkpoints