def planeModel(self, scene, normal, origin, name, color): """ Create a plane model node which can be viewed in the 3D View """ #A plane source plane = vtk.vtkPlane() plane.SetOrigin(origin) plane.SetNormal(normal) planeSample = vtk.vtkSampleFunction() planeSample.SetImplicitFunction(plane) planeSample.SetModelBounds(-100,100,-100,100,-100,100) planeSample.SetSampleDimensions(100,100,100) planeSample.ComputeNormalsOff() planeContour = vtk.vtkContourFilter() planeContour.SetInput(planeSample.GetOutput()) # Create plane model node planeNode = slicer.vtkMRMLModelNode() planeNode.SetScene(scene) planeNode.SetName(name) planeNode.SetAndObservePolyData(planeContour.GetOutput()) # Create plane display model node planeModelDisplay = slicer.vtkMRMLModelDisplayNode() planeModelDisplay.SetColor(color) planeModelDisplay.SetBackfaceCulling(0) planeModelDisplay.SetScene(scene) scene.AddNode(planeModelDisplay) planeNode.SetAndObserveDisplayNodeID(planeModelDisplay.GetID()) #Add to scene planeModelDisplay.SetInputPolyData(planeContour.GetOutput()) scene.AddNode(planeNode) return plane
def getIntersectionBetweenModelAnd1PlaneWithNormalAndOrigin( modelNode, normal, origin, intersectionModel): plane = vtk.vtkPlane() plane.SetOrigin(origin) plane.SetNormal(normal) clipper = vtk.vtkClipPolyData() clipper.SetInputData(modelNode.GetPolyData()) clipper.SetClipFunction(plane) clipper.Update() intersectionModel.SetAndObservePolyData(clipper.GetOutput())
def __init__(self): # Matrix that define each plane self.matrix = None # normal to the plane self.n = None # point in the plane self.P = None # Slice State self.boxState = False self.negState = False self.posState = False # Plane for cliping self.vtkPlane = vtk.vtkPlane()
def CreatePlane(self, startPoint, endPoint, direction): """ Takes two points and a direction vector returns an implicit function defining a plane """ a, b, c = startPoint # quick unpack d, e, f = endPoint # quick unpack q, r, s = a - d, b - e, c - f # quick direction vector catheterDirection = [q, r, s] normal = self.utility.CrossProduct(direction, catheterDirection) self.listOfNormals.append(normal) implicitPlane = vtk.vtkPlane() implicitPlane.SetNormal(normal) implicitPlane.SetOrigin(startPoint) self.listOfPlanes.append(implicitPlane) # Saving plane objects onto object
def CreatePlane(self, startPoint, endPoint, direction): """ Takes two points and a direction vector returns an implicit function defining a plane """ a, b, c = startPoint #quick unpack d, e, f = endPoint #quick unpack q, r, s = a - d, b - e, c - f #quick direction vector catheterDirection = [q, r, s] normal = self.utility.CrossProduct(direction, catheterDirection) self.listOfNormals.append(normal) implicitPlane = vtk.vtkPlane() implicitPlane.SetNormal(normal) implicitPlane.SetOrigin(startPoint) self.listOfPlanes.append( implicitPlane) # Saving plane objects onto object
def getIntersectionBetweenModelAnd1Plane(modelNode, planeNode, intersectionModel): plane = vtk.vtkPlane() origin = [0, 0, 0] normal = [0, 0, 0] planeNode.GetOrigin(origin) planeNode.GetNormal(normal) plane.SetOrigin(origin) plane.SetNormal(normal) cutter = vtk.vtkCutter() cutter.SetInputData(modelNode.GetPolyData()) cutter.SetCutFunction(plane) cutter.Update() intersectionModel.SetAndObservePolyData(cutter.GetOutput())
def CreateBackLine(self, ruler, ROI, implicitPlane): """ Creates the polydata for where the cutting plane hits the the back of the ROI. This backline will be used to close the catheter path allowing for the specification of Towards or Away from the face ASSERTION: that the ruler's second point will be closest to the front of our mask. """ roiPoints = self.utility.GetROIPoints(ROI) frontExtentIndex = self.utility.GetClosestExtent(ruler, ROI) backExtentIndex = self.utility.GetOppositeExtent(frontExtentIndex) #Creating an implict plane for the back of the ROI ROICenterPoint = [0, 0, 0] ROI.GetXYZ(ROICenterPoint) backNormal = self.utility.GetVector(ROICenterPoint, roiPoints[backExtentIndex]) backPlane = vtk.vtkPlane() backPlane.SetNormal(backNormal) backPlane.SetOrigin(roiPoints[backExtentIndex]) #Finding the Intercept of this and the CuttingPlane sampleFunction = vtk.vtkSampleFunction() sampleFunction.SetSampleDimensions(10, 10, 10) sampleFunction.SetImplicitFunction(backPlane) bounds = self.utility.ExpandExtents(self.utility.GetROIExtents(ROI), 1) sampleFunction.SetModelBounds(bounds) sampleFunction.Update() contourFilter = vtk.vtkContourFilter() contourFilter.SetInputConnection(sampleFunction.GetOutputPort()) contourFilter.GenerateValues(1, 1, 1) contourFilter.Update() cutter = vtk.vtkCutter() cutter.SetInputConnection(contourFilter.GetOutputPort()) cutter.SetCutFunction(implicitPlane) cutter.GenerateValues(1, 1, 1) cutter.Update() self.listOfBackLines.append(cutter.GetOutput()) PATH = self.ROOTPATH + "\\doc\\DebugPolyData\\" + "BackLine-" + str( len(self.listOfBackLines)) self.utility.PolyDataWriter(self.listOfBackLines[-1], PATH + ".vtk")
def getPointsOnPlane(self, planePosition, planeNormal): plane = vtk.vtkPlane() plane.SetOrigin(planePosition) plane.SetNormal(planeNormal) cutEdges = vtk.vtkCutter() cutEdges.SetInputData(self.curvePoly) cutEdges.SetCutFunction(plane) cutEdges.GenerateCutScalarsOff() cutEdges.SetValue(0, 0) cutEdges.Update() intersection = cutEdges.GetOutput() intersectionPoints = intersection.GetPoints() n = intersectionPoints.GetNumberOfPoints() points = np.zeros([3, n]) pos = [0.0, 0.0, 0.0] for i in range(n): intersectionPoints.GetPoint(i, pos) points[:, i] = pos return points
def CreateBackLine(self, ruler, ROI, implicitPlane): """ Creates the polydata for where the cutting plane hits the the back of the ROI. This backline will be used to close the catheter path allowing for the specification of Towards or Away from the face ASSERTION: that the ruler's second point will be closest to the front of our mask. """ roiPoints = self.utility.GetROIPoints(ROI) frontExtentIndex = self.utility.GetClosestExtent(ruler, ROI) backExtentIndex = self.utility.GetOppositeExtent(frontExtentIndex) # Creating an implict plane for the back of the ROI ROICenterPoint = [0, 0, 0] ROI.GetXYZ(ROICenterPoint) backNormal = self.utility.GetVector(ROICenterPoint, roiPoints[backExtentIndex]) backPlane = vtk.vtkPlane() backPlane.SetNormal(backNormal) backPlane.SetOrigin(roiPoints[backExtentIndex]) # Finding the Intercept of this and the CuttingPlane sampleFunction = vtk.vtkSampleFunction() sampleFunction.SetSampleDimensions(10, 10, 10) sampleFunction.SetImplicitFunction(backPlane) bounds = self.utility.ExpandExtents(self.utility.GetROIExtents(ROI), 1) sampleFunction.SetModelBounds(bounds) sampleFunction.Update() contourFilter = vtk.vtkContourFilter() contourFilter.SetInputConnection(sampleFunction.GetOutputPort()) contourFilter.GenerateValues(1, 1, 1) contourFilter.Update() cutter = vtk.vtkCutter() cutter.SetInputConnection(contourFilter.GetOutputPort()) cutter.SetCutFunction(implicitPlane) cutter.GenerateValues(1, 1, 1) cutter.Update() self.listOfBackLines.append(cutter.GetOutput()) PATH = self.ROOTPATH + "\\doc\\DebugPolyData\\" + "BackLine-" + str(len(self.listOfBackLines)) self.utility.PolyDataWriter(self.listOfBackLines[-1], PATH + ".vtk")
def getNearestIntersectionBetweenModelAnd1Plane(modelNode, planeNode, intersectionModel): plane = vtk.vtkPlane() origin = [0, 0, 0] normal = [0, 0, 0] planeNode.GetOrigin(origin) planeNode.GetNormal(normal) plane.SetOrigin(origin) plane.SetNormal(normal) cutter = vtk.vtkCutter() cutter.SetInputData(modelNode.GetPolyData()) cutter.SetCutFunction(plane) cutter.Update() connectivityFilter = vtk.vtkConnectivityFilter() connectivityFilter.SetInputData(cutter.GetOutput()) connectivityFilter.SetClosestPoint(origin) connectivityFilter.SetExtractionModeToClosestPointRegion() connectivityFilter.Update() intersectionModel.SetAndObservePolyData(connectivityFilter.GetOutput())
def clipping(self, red_plane_boxState, radio_red_NegState, radio_red_PosState, yellow_plane_boxState, radio_yellow_NegState, radio_yellow_PosState, green_plane_boxState, radio_green_NegState, radio_green_PosState): # Clipping in the direction of the normal vector self.plane_red = vtk.vtkPlane() self.plane_yellow = vtk.vtkPlane() self.plane_green = vtk.vtkPlane() self.planeCollection = vtk.vtkPlaneCollection() #Condition for the red plane print self.m_Red print self.n_NewRedPlan print self.A_NewRedPlan self.n_NewRedPlan1 = self.n_NewRedPlan self.n_NewGreenPlan1 = self.n_NewGreenPlan self.n_NewYellowPlan1 = self.n_NewYellowPlan self.n_NewRedPlan1[0] = self.n_NewRedPlan[0] - self.A_NewRedPlan[0] self.n_NewRedPlan1[1] = self.n_NewRedPlan[1] - self.A_NewRedPlan[1] self.n_NewRedPlan1[2] = self.n_NewRedPlan[2] - self.A_NewRedPlan[2] print self.n_NewRedPlan1 if red_plane_boxState: if radio_red_NegState: self.plane_red.SetOrigin(self.A_NewRedPlan[0], self.A_NewRedPlan[1], self.A_NewRedPlan[2]) if self.n_NewRedPlan1[2] >= 0: self.plane_red.SetNormal(-self.n_NewRedPlan1[0], -self.n_NewRedPlan1[1], -self.n_NewRedPlan1[2]) if self.n_NewRedPlan1[2] < 0: self.plane_red.SetNormal(self.n_NewRedPlan1[0], self.n_NewRedPlan1[1], self.n_NewRedPlan1[2]) self.planeCollection.AddItem(self.plane_red) print self.plane_red if radio_red_PosState: self.plane_red.SetOrigin(self.A_NewRedPlan[0], self.A_NewRedPlan[1], self.A_NewRedPlan[2]) if self.n_NewRedPlan1[2] >= 0: self.plane_red.SetNormal(self.n_NewRedPlan1[0], self.n_NewRedPlan1[1], self.n_NewRedPlan1[2]) if self.n_NewRedPlan1[2] < 0: self.plane_red.SetNormal(-self.n_NewRedPlan1[0], -self.n_NewRedPlan1[1], -self.n_NewRedPlan1[2]) self.planeCollection.AddItem(self.plane_red) print self.plane_red #Condition for the yellow plane print self.m_Yellow print self.n_NewYellowPlan print self.A_NewYellowPlan self.n_NewYellowPlan1[0] = self.n_NewYellowPlan[0] - self.A_NewYellowPlan[0] self.n_NewYellowPlan1[1] = self.n_NewYellowPlan[1] - self.A_NewYellowPlan[1] self.n_NewYellowPlan1[2] = self.n_NewYellowPlan[2] - self.A_NewYellowPlan[2] print self.n_NewYellowPlan1 if yellow_plane_boxState: if radio_yellow_NegState: self.plane_yellow.SetOrigin(self.A_NewYellowPlan[0], self.A_NewYellowPlan[1], self.A_NewYellowPlan[2]) if self.n_NewYellowPlan1[0] >= 0: self.plane_yellow.SetNormal(-self.n_NewYellowPlan1[0], -self.n_NewYellowPlan1[1], -self.n_NewYellowPlan1[2]) if self.n_NewYellowPlan1[0] < 0: self.plane_yellow.SetNormal(self.n_NewYellowPlan1[0], self.n_NewYellowPlan1[1], self.n_NewYellowPlan1[2]) self.planeCollection.AddItem(self.plane_yellow) print self.plane_yellow if radio_yellow_PosState: self.plane_yellow.SetOrigin(self.A_NewYellowPlan[0], self.A_NewYellowPlan[1], self.A_NewYellowPlan[2]) if self.n_NewYellowPlan1[0] >= 0: self.plane_yellow.SetNormal(self.n_NewYellowPlan1[0], self.n_NewYellowPlan1[1], self.n_NewYellowPlan1[2]) if self.n_NewYellowPlan1[0] < 0: self.plane_yellow.SetNormal(-self.n_NewYellowPlan1[0], -self.n_NewYellowPlan1[1], -self.n_NewYellowPlan1[2]) self.planeCollection.AddItem(self.plane_yellow) print self.plane_yellow #Condition for the green plane print self.m_Green print self.n_NewGreenPlan print self.A_NewGreenPlan self.n_NewGreenPlan1[0] = self.n_NewGreenPlan[0] - self.A_NewGreenPlan[0] self.n_NewGreenPlan1[1] = self.n_NewGreenPlan[1] - self.A_NewGreenPlan[1] self.n_NewGreenPlan1[2] = self.n_NewGreenPlan[2] - self.A_NewGreenPlan[2] print self.n_NewGreenPlan1 if green_plane_boxState: if radio_green_NegState: self.plane_green.SetOrigin(self.A_NewGreenPlan[0], self.A_NewGreenPlan[1], self.A_NewGreenPlan[2]) if self.n_NewGreenPlan1[1] >= 0: self.plane_green.SetNormal(-self.n_NewGreenPlan1[0], -self.n_NewGreenPlan1[1], -self.n_NewGreenPlan1[2]) if self.n_NewGreenPlan1[1] < 0: self.plane_green.SetNormal(self.n_NewGreenPlan1[0], self.n_NewGreenPlan1[1], self.n_NewGreenPlan1[2]) self.planeCollection.AddItem(self.plane_green) print self.plane_green if radio_green_PosState: self.plane_green.SetOrigin(self.A_NewGreenPlan[0], self.A_NewGreenPlan[1], self.A_NewGreenPlan[2]) if self.n_NewGreenPlan1[1] > 0: self.plane_green.SetNormal(self.n_NewGreenPlan1[0], self.n_NewGreenPlan1[1], self.n_NewGreenPlan1[2]) if self.n_NewGreenPlan1[1] < 0: self.plane_green.SetNormal(-self.n_NewGreenPlan1[0], -self.n_NewGreenPlan1[1], -self.n_NewGreenPlan1[2]) self.planeCollection.AddItem(self.plane_green) print self.plane_green numNodes = slicer.mrmlScene.GetNumberOfNodesByClass("vtkMRMLModelNode") self.dictionnaryModel = dict() self.dictionnaryModel.clear() for i in range(3, numNodes): mh = slicer.mrmlScene.GetNthNodeByClass(i, "vtkMRMLModelNode") self.model = slicer.util.getNode(mh.GetName()) print mh.GetName() self.dictionnaryModel[self.model.GetID()]=self.model.GetPolyData() self.polyData = self.model.GetPolyData() PolyAlgorithm = vtk.vtkClipClosedSurface() PolyAlgorithm.SetInputData(self.polyData) clipper = vtk.vtkClipClosedSurface() clipper.SetClippingPlanes(self.planeCollection) clipper.SetInputConnection(PolyAlgorithm.GetOutputPort()) clipper.SetGenerateFaces(1) clipper.SetScalarModeToLabels() clipper.Update() polyDataNew = clipper.GetOutput() self.model.SetAndObservePolyData(polyDataNew) return self.dictionnaryModel
def iceCream(self): # based on iceCream.py from VTK/Examples/Modelling # This example demonstrates how to use boolean combinations of implicit # functions to create a model of an ice cream cone. import vtk from vtk.util.colors import chocolate, mint # Create implicit function primitives. These have been carefully # placed to give the effect that we want. We are going to use various # combinations of these functions to create the shape we want; for # example, we use planes intersected with a cone (which is infinite in # extent) to get a finite cone. cone = vtk.vtkCone() cone.SetAngle(20) vertPlane = vtk.vtkPlane() vertPlane.SetOrigin(.1, 0, 0) vertPlane.SetNormal(-1, 0, 0) basePlane = vtk.vtkPlane() basePlane.SetOrigin(1.2, 0, 0) basePlane.SetNormal(1, 0, 0) iceCream = vtk.vtkSphere() iceCream.SetCenter(1.333, 0, 0) iceCream.SetRadius(0.5) bite = vtk.vtkSphere() bite.SetCenter(1.5, 0, 0.5) bite.SetRadius(0.25) # Combine primitives to build ice-cream cone. Clip the cone with planes. theCone = vtk.vtkImplicitBoolean() theCone.SetOperationTypeToIntersection() theCone.AddFunction(cone) theCone.AddFunction(vertPlane) theCone.AddFunction(basePlane) # Take a bite out of the ice cream. theCream = vtk.vtkImplicitBoolean() theCream.SetOperationTypeToDifference() theCream.AddFunction(iceCream) theCream.AddFunction(bite) # The sample function generates a distance function from the implicit # function (which in this case is the cone). This is then contoured to # get a polygonal surface. theConeSample = vtk.vtkSampleFunction() theConeSample.SetImplicitFunction(theCone) theConeSample.SetModelBounds(-1, 1.5, -1.25, 1.25, -1.25, 1.25) theConeSample.SetSampleDimensions(60, 60, 60) theConeSample.ComputeNormalsOff() theConeSurface = vtk.vtkContourFilter() theConeSurface.SetInputConnection(theConeSample.GetOutputPort()) theConeSurface.SetValue(0, 0.0) coneMapper = vtk.vtkPolyDataMapper() coneMapper.SetInputConnection(theConeSurface.GetOutputPort()) coneMapper.ScalarVisibilityOff() coneActor = vtk.vtkActor() coneActor.SetMapper(coneMapper) coneActor.GetProperty().SetColor(chocolate) # The same here for the ice cream. theCreamSample = vtk.vtkSampleFunction() theCreamSample.SetImplicitFunction(theCream) theCreamSample.SetModelBounds(0, 2.5, -1.25, 1.25, -1.25, 1.25) theCreamSample.SetSampleDimensions(60, 60, 60) theCreamSample.ComputeNormalsOff() theCreamSurface = vtk.vtkContourFilter() theCreamSurface.SetInputConnection(theCreamSample.GetOutputPort()) theCreamSurface.SetValue(0, 0.0) creamMapper = vtk.vtkPolyDataMapper() creamMapper.SetInputConnection(theCreamSurface.GetOutputPort()) creamMapper.ScalarVisibilityOff() creamActor = vtk.vtkActor() creamActor.SetMapper(creamMapper) creamActor.GetProperty().SetColor(mint) # Create the usual rendering stuff ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # Add the actors to the renderer, set the background and size ren.AddActor(coneActor) ren.AddActor(creamActor) ren.SetBackground(1, 1, 1) renWin.SetSize(500, 500) ren.ResetCamera() ren.GetActiveCamera().Roll(90) ren.GetActiveCamera().Dolly(1.5) ren.ResetCameraClippingRange() iren.Initialize() renWin.Render() iren.Start() return iren