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 __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
