def createNeedleModelNode(self, name):
locatorModel = self.scene.CreateNodeByClass('vtkMRMLModelNode')
# Cylinder represents the locator stick
cylinder = vtk.vtkCylinderSource()
cylinder.SetRadius(1.5)
cylinder.SetHeight(100)
cylinder.SetCenter(0, 0, 0)
cylinder.Update()
# Rotate cylinder
tfilter = vtk.vtkTransformPolyDataFilter()
trans = vtk.vtkTransform()
trans.RotateX(90.0)
trans.Translate(0.0, -50.0, 0.0)
trans.Update()
if vtk.VTK_MAJOR_VERSION <= 5:
tfilter.SetInput(cylinder.GetOutput())
else:
tfilter.SetInputConnection(cylinder.GetOutputPort())
tfilter.SetTransform(trans)
tfilter.Update()
# Sphere represents the locator tip
sphere = vtk.vtkSphereSource()
sphere.SetRadius(3.0)
sphere.SetCenter(0, 0, 0)
sphere.Update()
apd = vtk.vtkAppendPolyData()
if vtk.VTK_MAJOR_VERSION <= 5:
apd.AddInput(sphere.GetOutput())
apd.AddInput(tfilter.GetOutput())
else:
apd.AddInputConnection(sphere.GetOutputPort())
apd.AddInputConnection(tfilter.GetOutputPort())
apd.Update()
locatorModel.SetAndObservePolyData(apd.GetOutput());
self.scene.AddNode(locatorModel)
locatorModel.SetScene(self.scene);
locatorModel.SetName(name)
locatorDisp = locatorModel.GetDisplayNodeID()
if locatorDisp == None:
locatorDisp = self.scene.CreateNodeByClass('vtkMRMLModelDisplayNode')
self.scene.AddNode(locatorDisp)
locatorDisp.SetScene(self.scene)
locatorModel.SetAndObserveDisplayNodeID(locatorDisp.GetID());
color = [0, 0, 0]
color[0] = 0.5
color[1] = 0.5
color[2] = 1.0
locatorDisp.SetColor(color)
return locatorModel.GetID()
def test_FiducialsToModelRegistration1(self):
"""
Test FiducialsToModelRegistrationLogic.
This test scenario:
- Creates and adds a cylinder model to the scene
- Creates 3 markup fiducials (points)
- Runs module processing logic to register points against the cylinder
"""
# Create and add cylinder to the scene.
s = vtk.vtkCylinderSource()
s.SetHeight(100)
s.SetRadius(50)
s.SetResolution(50)
s.Update()
inputModel = slicer.modules.models.logic().AddModel(s.GetOutput())
# Create and add markup fiducials to the scene.
slicer.modules.markups.logic().AddFiducial(40, -20, 33)
slicer.modules.markups.logic().AddFiducial(40, -25, 37)
slicer.modules.markups.logic().AddFiducial(52, -28, 42)
# Create output transform node
transformNode = slicer.mrmlScene.AddNewNodeByClass("vtkMRMLTransformNode")
# Run module logic with default settings
logic = slicer.modules.fiducialstomodelregistration.widgetRepresentation().self().logic
inputFiducials = slicer.util.getNode("F")
success = logic.run(inputFiducials, inputModel, transformNode)
self.assertEqual(success, True)
slicer.util.delayDisplay('Test passed')
def updateModel(self):
if self.AutomaticUpdate == False:
return
if not self.ModelNode:
return
if self.ModelNode.GetDisplayNodeID() == None:
modelDisplayNode = slicer.vtkMRMLModelDisplayNode()
modelDisplayNode.SetColor(self.ModelColor)
slicer.mrmlScene.AddNode(modelDisplayNode)
self.ModelNode.SetAndObserveDisplayNodeID(modelDisplayNode.GetID())
displayNodeID = self.ModelNode.GetDisplayNodeID()
modelDisplayNode = slicer.mrmlScene.GetNodeByID(displayNodeID)
if modelDisplayNode:
if self.SliceIntersection == True:
modelDisplayNode.SliceIntersectionVisibilityOn()
else:
modelDisplayNode.SliceIntersectionVisibilityOff()
modelDisplayNode.SetOpacity(0.5)
if self.CylinderSource == None:
self.CylinderSource = vtk.vtkCylinderSource()
self.CylinderSource.SetResolution(60)
self.CylinderSource.SetRadius(self.Diameter/2.0)
self.CylinderSource.SetHeight(self.Length)
self.CylinderSource.SetCenter(self.Offset)
self.CylinderSource.Update()
## Scale sphere to make ellipsoid
#scale = vtk.vtkTransform()
#scale.Scale(self.MinorAxis, self.MinorAxis, self.MajorAxis)
#scaleFilter = vtk.vtkTransformPolyDataFilter()
#scaleFilter.SetInputConnection(self.CylinderSource.GetOutputPort())
#scaleFilter.SetTransform(scale)
#scaleFilter.Update();
# Transform
#transform = vtk.vtkTransform()
#self.computeTransform(pTip, pTail, self.TipOffset, transform)
#transformFilter = vtk.vtkTransformPolyDataFilter()
#transformFilter.SetInputConnection(scaleFilter.GetOutputPort())
#transformFilter.SetInputConnection(self.CylinderSource.GetOutputPort())
#transformFilter.SetTransform(transform)
#transformFilter.Update();
#self.ModelNode.SetAndObservePolyData(transformFilter.GetOutput())
self.ModelNode.SetAndObservePolyData(self.CylinderSource.GetOutput())
self.ModelNode.Modified()
if self.ModelNode.GetScene() == None:
slicer.mrmlScene.AddNode(self.ModelNode)
def generateCylinderPolyData(self, x, y):
cylinderHeightMm = 80
cylinderRadiusMm = 1
cylinderSource = vtk.vtkCylinderSource()
cylinderSource.SetHeight(cylinderHeightMm)
cylinderSource.SetRadius(cylinderRadiusMm)
renderDepthMm = -cylinderHeightMm # negative because in graphics, negative is depth, positive goes toward the user
transform = vtk.vtkTransform()
transform.Translate(x, y, renderDepthMm)
transform.RotateX(90) # rotate so that the cylinder follows the z axis
transformFilter = vtk.vtkTransformFilter()
transformFilter.SetTransform(transform)
transformFilter.SetInputConnection(cylinderSource.GetOutputPort(0))
transformFilter.Update()
polyData = transformFilter.GetOutput()
return polyData
def generateCylinderPolyData(self,x,y): cylinderHeightMm = 80 cylinderRadiusMm = 1 cylinderSource = vtk.vtkCylinderSource() cylinderSource.SetHeight(cylinderHeightMm) cylinderSource.SetRadius(cylinderRadiusMm) renderDepthMm = -cylinderHeightMm # negative because in graphics, negative is depth, positive goes toward the user transform = vtk.vtkTransform() transform.Translate(x,y,renderDepthMm) transform.RotateX(90) # rotate so that the cylinder follows the z axis transformFilter = vtk.vtkTransformFilter() transformFilter.SetTransform(transform) transformFilter.SetInputConnection(cylinderSource.GetOutputPort(0)) transformFilter.Update() polyData = transformFilter.GetOutput() return polyData
def __init__(self, markupID, radius, length, position):
# We use the markupID to check whether this tool's markup has
# been removed in the onMarkupRemoved event
self.markupID = markupID
# Create a vtkCylinderSource for rendering the tool
self.toolSrc = vtk.vtkCylinderSource()
self.toolSrc.SetRadius(radius)
self.toolSrc.SetHeight(length)
# Create tool model using cylinder source
self.modelNode = slicer.vtkMRMLModelNode()
self.modelNode.HideFromEditorsOn()
self.modelNode.SetName(slicer.mrmlScene.GenerateUniqueName("Tool"))
polyData = self.toolSrc.GetOutput()
self.modelNode.SetAndObservePolyData(polyData)
slicer.mrmlScene.AddNode(self.modelNode)
# Create a DisplayNode for this node (so that it can control its
# own visibility) and have modelNode observe it
self.modelDisplay = slicer.vtkMRMLModelDisplayNode()
self.modelDisplay.SetColor(0, 1, 1) # cyan
slicer.mrmlScene.AddNode(self.modelDisplay)
self.modelNode.SetAndObserveDisplayNodeID(
self.modelDisplay.GetID())
# Create a transform for our tool model that will scale it to
# the proper radius, length, and position. Leave the orientation
# at the default.
self.transformNode = slicer.vtkMRMLLinearTransformNode()
self.transformNode.HideFromEditorsOn()
self.transformNode.SetName(
slicer.mrmlScene.GenerateUniqueName("Transform"))
self.updatePosition(position)
slicer.mrmlScene.AddNode(self.transformNode)
# apply the new transform to our tool
self.modelNode.SetAndObserveTransformNodeID(
self.transformNode.GetID())
# Set tool to be visible
self.visible = True
def GenerateCylinderLabelMap(self,needleTransform, image, outputMask, radius, length, offset, refineRate = 3):
# Get needle matrix
needleMatrix = needleTransform.GetMatrixTransformToParent()
# Create cylinder
cylinderSource = vtk.vtkCylinderSource()
cylinderSource.SetCenter(0.0, 0.0, 0.0)
cylinderSource.SetRadius(radius)
cylinderSource.SetHeight(length)
cylinderSource.SetResolution(240)
cylinderSource.Update()
# Move cylinder to needleTransform
transformCylinder = vtk.vtkTransform()
transformCylinder.RotateX(90)
transformCylinder.Translate(0.0, -length/2, 0.0)
transformCylinder.PostMultiply()
transformCylinder.Concatenate(needleMatrix)
transformCylinder.Update()
transformPolyData = vtk.vtkTransformPolyDataFilter()
transformPolyData.SetInputConnection(cylinderSource.GetOutputPort())
transformPolyData.SetTransform(transformCylinder)
transformPolyData.Update()
# Add nodes to the scene
modelDisplayNode = slicer.mrmlScene.CreateNodeByClass("vtkMRMLModelDisplayNode")
modelDisplayNode.SetColor(1.0,0.0,0.0)
slicer.mrmlScene.AddNode(modelDisplayNode)
modelNode = slicer.mrmlScene.CreateNodeByClass("vtkMRMLModelNode")
modelNode.SetName("CylinderModel")
modelNode.SetAndObservePolyData(transformPolyData.GetOutput())
modelNode.SetAndObserveDisplayNodeID(modelDisplayNode.GetID())
modelNode.Modified()
slicer.mrmlScene.AddNode(modelNode)
# Call ModelToLabelMap module
cliNode = self.runModelToLabelMap(image, modelNode, outputMask, refineRate)
def __init__(self, markupID, radius, length, position):
# We use the markupID to check whether this tool's markup has
# been removed in the onMarkupRemoved event
self.markupID = markupID
# Create a vtkCylinderSource for rendering the tool
self.toolSrc = vtk.vtkCylinderSource()
self.toolSrc.SetRadius(radius)
self.toolSrc.SetHeight(length)
# Create tool model using cylinder source
self.modelNode = slicer.vtkMRMLModelNode()
self.modelNode.HideFromEditorsOn()
self.modelNode.SetName(slicer.mrmlScene.GenerateUniqueName("Tool"))
polyData = self.toolSrc.GetOutput()
self.modelNode.SetAndObservePolyData(polyData)
slicer.mrmlScene.AddNode(self.modelNode)
# Create a DisplayNode for this node (so that it can control its
# own visibility) and have modelNode observe it
self.modelDisplay = slicer.vtkMRMLModelDisplayNode()
self.modelDisplay.SetColor(0,1,1) # cyan
slicer.mrmlScene.AddNode(self.modelDisplay)
self.modelNode.SetAndObserveDisplayNodeID(self.modelDisplay.GetID())
# Create a transform for our tool model that will scale it to
# the proper radius, length, and position. Leave the orientation
# at the default.
self.transformNode = slicer.vtkMRMLLinearTransformNode()
self.transformNode.HideFromEditorsOn()
self.transformNode.SetName(slicer.mrmlScene.GenerateUniqueName("Transform"))
self.updatePosition(position)
slicer.mrmlScene.AddNode(self.transformNode)
# apply the new transform to our tool
self.modelNode.SetAndObserveTransformNodeID(self.transformNode.GetID())
# Set tool to be visible
self.visible = True
def AddApplicatorTrajectoryModel(self,scene,LineLandmarkTransform ):
# check if already implemented
if ( self.ApplicatorTrajectoryModel != None ):
print "removing", self.ApplicatorTrajectoryModel.GetName()
scene.RemoveNode(self.ApplicatorTrajectoryModel)
# Define applicator tip
vtkCylinder = vtk.vtkCylinderSource()
vtkCylinder.SetHeight(10.*self.DiffusingTipLength);
vtkCylinder.SetRadius(0.1*self.DiffusingTipRadius);
vtkCylinder.SetCenter(0.0, 10.*self.DiffusingTipLength/2.0, 0.0);
vtkCylinder.SetResolution(16);
# transform
slicertransformFilter = vtk.vtkTransformFilter()
slicertransformFilter.SetInput(vtkCylinder.GetOutput() )
slicertransformFilter.SetTransform( LineLandmarkTransform )
slicertransformFilter.Update()
apppolyData=slicertransformFilter.GetOutput();
# add to scene
self.ApplicatorTrajectoryModel = slicer.vtkMRMLModelNode()
self.ApplicatorTrajectoryModel.SetScene(scene)
#self.ApplicatorTrajectoryModel.SetName(scene.GenerateUniqueName("Applicator-%s" % fiducialsNode.GetName()))
self.ApplicatorTrajectoryModel.SetName("ApplicatorTrajectory" )
self.ApplicatorTrajectoryModel.SetAndObservePolyData(apppolyData)
# Create display node
modelDisplay = slicer.vtkMRMLModelDisplayNode()
modelDisplay.SetColor(1,0.5,0) # red
modelDisplay.SetScene(scene)
scene.AddNode(modelDisplay)
self.ApplicatorTrajectoryModel.SetAndObserveDisplayNodeID(modelDisplay.GetID())
# Add to scene
modelDisplay.SetInputPolyData(self.ApplicatorTrajectoryModel.GetPolyData())
scene.AddNode(self.ApplicatorTrajectoryModel)
def createNeedleModelNode(self, name):
locatorModel = self.scene.CreateNodeByClass('vtkMRMLModelNode')
# Cylinder represents the locator stick
cylinder = vtk.vtkCylinderSource()
cylinder.SetRadius(1.5)
cylinder.SetHeight(100)
cylinder.SetCenter(0, 0, 0)
cylinder.Update()
# Rotate cylinder
tfilter = vtk.vtkTransformPolyDataFilter()
trans = vtk.vtkTransform()
trans.RotateX(90.0)
trans.Translate(0.0, -50.0, 0.0)
trans.Update()
if vtk.VTK_MAJOR_VERSION <= 5:
tfilter.SetInput(cylinder.GetOutput())
else:
tfilter.SetInputConnection(cylinder.GetOutputPort())
tfilter.SetTransform(trans)
tfilter.Update()
# Sphere represents the locator tip
sphere = vtk.vtkSphereSource()
sphere.SetRadius(3.0)
sphere.SetCenter(0, 0, 0)
sphere.Update()
apd = vtk.vtkAppendPolyData()
if vtk.VTK_MAJOR_VERSION <= 5:
apd.AddInput(sphere.GetOutput())
apd.AddInput(tfilter.GetOutput())
else:
apd.AddInputConnection(sphere.GetOutputPort())
apd.AddInputConnection(tfilter.GetOutputPort())
apd.Update()
locatorModel.SetAndObservePolyData(apd.GetOutput())
self.scene.AddNode(locatorModel)
locatorModel.SetScene(self.scene)
locatorModel.SetName(name)
locatorDisp = locatorModel.GetDisplayNodeID()
if locatorDisp == None:
locatorDisp = self.scene.CreateNodeByClass(
'vtkMRMLModelDisplayNode')
self.scene.AddNode(locatorDisp)
locatorDisp.SetScene(self.scene)
locatorModel.SetAndObserveDisplayNodeID(locatorDisp.GetID())
color = [0, 0, 0]
color[0] = 0.5
color[1] = 0.5
color[2] = 1.0
locatorDisp.SetColor(color)
return locatorModel.GetID()
def createNeedleModelNode(self, name,index):
locatorModel = self.scene.CreateNodeByClass('vtkMRMLModelNode')
# Cylinder represents the locator stick
cylinder = vtk.vtkCylinderSource()
cylinder.SetRadius(1.5)
cylinder.SetHeight(100)
cylinder.SetCenter(0, 0, 0)
cylinder.Update()
# Rotate cylinder
tfilter = vtk.vtkTransformPolyDataFilter()
trans = vtk.vtkTransform()
trans.RotateX(90.0)
trans.Translate(0.0, -50.0, 0.0)
trans.Update()
if vtk.VTK_MAJOR_VERSION <= 5:
tfilter.SetInput(cylinder.GetOutput())
else:
tfilter.SetInputConnection(cylinder.GetOutputPort())
tfilter.SetTransform(trans)
tfilter.Update()
# Sphere represents the locator tip
sphere = vtk.vtkSphereSource()
sphere.SetRadius(3.0)
sphere.SetCenter(0, 0, 0)
sphere.Update()
apd = vtk.vtkAppendPolyData()
if vtk.VTK_MAJOR_VERSION <= 5:
apd.AddInput(sphere.GetOutput())
apd.AddInput(tfilter.GetOutput())
else:
apd.AddInputConnection(sphere.GetOutputPort())
apd.AddInputConnection(tfilter.GetOutputPort())
apd.Update()
locatorModel.SetAndObservePolyData(apd.GetOutput());
self.scene.AddNode(locatorModel)
locatorModel.SetScene(self.scene);
needleName = "Needle_%s" % name
locatorModel.SetName(needleName)
locatorDisp = locatorModel.GetDisplayNodeID()
if locatorDisp == None:
locatorDisp = self.scene.CreateNodeByClass('vtkMRMLModelDisplayNode')
self.scene.AddNode(locatorDisp)
locatorDisp.SetScene(self.scene)
locatorModel.SetAndObserveDisplayNodeID(locatorDisp.GetID());
color = [0, 0, 0]
color[0] = 0.5
color[1] = 0.5
color[2] = 1.0
locatorDisp.SetColor(color)
print name
if self.colorMap.get(name):
locatorDisp.SetColor(self.colorMap.get(name))
color = self.colorMap.get(name)
colorName = "background:rgb({},{},{})".format(255*color[0], 255*color[1], 255*color[2])
print colorName
self.widget.colorSelectors[index].setStyleSheet(colorName)
#qss = qt.QString("background-color: %1").arg(col.name());
return locatorModel.GetID()
def p2pCyl(startPoint, endPoint, radius=10, modName="Cyl", plus=0, Seg=3, color="red", Opacity=1, RotY=0, Tx=0): """12 prisms of point-to-point""" cylinderSource = vtk.vtkCylinderSource() cylinderSource.SetRadius(radius) cylinderSource.SetResolution(Seg) rng = vtk.vtkMinimalStandardRandomSequence() rng.SetSeed(8775070) # For testing 8775070 # Compute a basis normalizedX = [0] * 3 normalizedY = [0] * 3 normalizedZ = [0] * 3 # The X axis is a vector from start to end vtk.vtkMath.Subtract(endPoint, startPoint, normalizedX) length = vtk.vtkMath.Norm(normalizedX) + plus # length = 20 vtk.vtkMath.Normalize(normalizedX) # The Xn axis is an arbitrary vector cross X arbitrary = [0] * 3 for i in range(0, 3): rng.Next() arbitrary[i] = rng.GetRangeValue(-10, 10) vtk.vtkMath.Cross(normalizedX, arbitrary, normalizedZ) vtk.vtkMath.Normalize(normalizedZ) # The Zn axis is Xn cross X vtk.vtkMath.Cross(normalizedZ, normalizedX, normalizedY) matrix = vtk.vtkMatrix4x4() # Create the direction cosine matrix matrix.Identity() for i in range(0, 3): matrix.SetElement(i, 0, normalizedX[i]) matrix.SetElement(i, 1, normalizedY[i]) matrix.SetElement(i, 2, normalizedZ[i]) # Apply the transforms transform = vtk.vtkTransform() transform.Translate(startPoint) # translate to starting point transform.Concatenate(matrix) # apply direction cosines transform.RotateZ(-90.0) # align cylinder to x axis transform.Scale(1.0, length, 1.0) # scale along the height vector transform.Translate(0, .5, 0) # translate to start of cylinder transform.RotateY(RotY) transform.Translate(Tx, 0, 0) # Transform the polydata transformPD = vtk.vtkTransformPolyDataFilter() transformPD.SetTransform(transform) transformPD.SetInputConnection(cylinderSource.GetOutputPort()) stlMapper = vtk.vtkPolyDataMapper() stlMapper.SetInputConnection(transformPD.GetOutputPort()) vtkNode = slicer.modules.models.logic().AddModel(transformPD.GetOutputPort()) vtkNode.SetName(modName) modelDisplay = vtkNode.GetDisplayNode() modelDisplay.SetColor(Helper.myColor(color)) modelDisplay.SetOpacity(Opacity) modelDisplay.SetBackfaceCulling(0) # modelDisplay.SetVisibility(1) modelDisplay.SetVisibility2D(True) # modelDisplay.SetSliceDisplayModeToProjection() # dn.SetVisibility2D(True) return
def __init__(self, entryPointFiducialListNode, targetFiducialListNode, length, diameter, probeText, probeColor):
entryPointFid = entryPointFiducialListNode
targetFid = targetFiducialListNode
scene = slicer.mrmlScene
#Create an probe.
probe = vtk.vtkCylinderSource()
probe.SetHeight(length)
probe.SetRadius(diameter / 2)
pos = [0 for i in range(3)]
# get coordinates from current entry point fiducial
currentEntryPointFiducialCoordinatesRAS = [0, 0, 0]
entryPointFid.GetFiducialCoordinates(currentEntryPointFiducialCoordinatesRAS)
currentTargetFiducialCoordinatesRAS = [0, 0, 0]
targetFid.GetFiducialCoordinates(currentTargetFiducialCoordinatesRAS)
# pos is the vector that describes the distance between the target and the entry point
for i in range(3):
pos[i] = currentTargetFiducialCoordinatesRAS[i] - currentEntryPointFiducialCoordinatesRAS[i]
pointsDistance = sqrt(pow(pos[0], 2) + pow(pos[1], 2) + pow(pos[2], 2))
# len is the vector that describes the length of the probe
len = [0 for i in range(3)]
for i in range(3):
len[i] = length / pointsDistance * pos[i]
translationTarget = [currentTargetFiducialCoordinatesRAS[0] - len[0] / 2, currentTargetFiducialCoordinatesRAS[1] - len[1] / 2, currentTargetFiducialCoordinatesRAS[2] - len[2] / 2]
# Generate a random start and end point
random.seed(8775070)
startPoint = [0 for i in range(3)]
startPoint[0] = currentEntryPointFiducialCoordinatesRAS[0]
startPoint[1] = currentEntryPointFiducialCoordinatesRAS[1]
startPoint[2] = currentEntryPointFiducialCoordinatesRAS[2]
endPoint = [0 for i in range(3)]
endPoint[0] = currentTargetFiducialCoordinatesRAS[0]
endPoint[1] = currentTargetFiducialCoordinatesRAS[1]
endPoint[2] = currentTargetFiducialCoordinatesRAS[2]
# Compute a basis
normalizedX = [0 for i in range(3)]
normalizedY = [0 for i in range(3)]
normalizedZ = [0 for i in range(3)]
# The X axis is a vector from start to end
math = vtk.vtkMath()
math.Subtract(endPoint, startPoint, normalizedX)
# length = math.Norm(normalizedX)
math.Normalize(normalizedX)
# The Z axis is an arbitrary vector cross X
arbitrary = [0 for i in range(3)]
arbitrary[0] = random.uniform(-10,10)
arbitrary[1] = random.uniform(-10,10)
arbitrary[2] = random.uniform(-10,10)
math.Cross(normalizedX, arbitrary, normalizedZ)
math.Normalize(normalizedZ)
# The Y axis is Z cross X
math.Cross(normalizedZ, normalizedX, normalizedY)
matrix = vtk.vtkMatrix4x4()
# Create the direction cosine matrix
matrix.Identity()
for i in range(3):
matrix.SetElement(i, 0, normalizedX[i])
matrix.SetElement(i, 1, normalizedY[i])
matrix.SetElement(i, 2, normalizedZ[i])
# Apply the transforms
transform = vtk.vtkTransform()
transform.Translate(translationTarget)
transform.Concatenate(matrix)
transform.RotateZ(90)
# Create model node
probeModel = slicer.vtkMRMLModelNode()
probeModel.SetScene(scene)
probeModel.SetName(probeText + "-%s" % targetFid.GetName())
probeModel.SetAndObservePolyData(probe.GetOutput())
# Create display node
probeModelDisplay = slicer.vtkMRMLModelDisplayNode()
probeModelDisplay.SetColor(probeColor)
probeModelDisplay.SetOpacity(1)
probeModelDisplay.SliceIntersectionVisibilityOn()
probeModelDisplay.SetScene(scene)
scene.AddNode(probeModelDisplay)
probeModel.SetAndObserveDisplayNodeID(probeModelDisplay.GetID())
# Add to scene
probeModelDisplay.SetPolyData(probe.GetOutput())
scene.AddNode(probeModel)
# Create probeTransform node
probeTransform = slicer.vtkMRMLLinearTransformNode()
probeTransform.SetName(probeText + 'Transform-%s' % entryPointFid.GetName())
scene.AddNode(probeTransform)
probeTransform.ApplyTransformMatrix(transform.GetMatrix())
probeModel.SetAndObserveTransformNodeID(probeTransform.GetID())
def __init__(self, entryPointFiducialListNode, targetFiducialListNode, shape, shapeRadius, shapeHeight, shapeVolume, ablationZoneColor):
entryPointFid = entryPointFiducialListNode
targetFid = targetFiducialListNode
scene = slicer.mrmlScene
if (shape == 'sphere'):
source = vtk.vtkSphereSource()
source.SetRadius(shapeRadius)
source.Update()
elif (shape == 'cylinder'):
source = vtk.vtkCylinderSource()
source.SetRadius(shapeRadius)
source.SetHeight(shapeHeight)
source.Update()
elif (shape == 'ellipsoid'):
source = vtk.vtkSphereSource()
source.SetRadius(shapeRadius)
source.Update()
else:
source = vtk.vtkSphereSource()
source.SetRadius(shapeRadius)
source.Update()
# get coordinates from current entry point fiducial
currentEntryPointFiducialCoordinatesRAS = [0, 0, 0]
entryPointFid.GetFiducialCoordinates(currentEntryPointFiducialCoordinatesRAS)
currentTargetFiducialCoordinatesRAS = [0, 0, 0]
targetFid.GetFiducialCoordinates(currentTargetFiducialCoordinatesRAS)
translationTarget = [currentTargetFiducialCoordinatesRAS[0], currentTargetFiducialCoordinatesRAS[1], currentTargetFiducialCoordinatesRAS[2]]
# Generate a random start and end point
random.seed(8775070)
startPoint = [0 for i in range(3)]
startPoint[0] = currentEntryPointFiducialCoordinatesRAS[0]
startPoint[1] = currentEntryPointFiducialCoordinatesRAS[1]
startPoint[2] = currentEntryPointFiducialCoordinatesRAS[2]
endPoint = [0 for i in range(3)]
endPoint[0] = currentTargetFiducialCoordinatesRAS[0]
endPoint[1] = currentTargetFiducialCoordinatesRAS[1]
endPoint[2] = currentTargetFiducialCoordinatesRAS[2]
# Compute a basis
normalizedX = [0 for i in range(3)]
normalizedY = [0 for i in range(3)]
normalizedZ = [0 for i in range(3)]
# The X axis is a vector from start to end
math = vtk.vtkMath()
math.Subtract(endPoint, startPoint, normalizedX)
# length = math.Norm(normalizedX)
math.Normalize(normalizedX)
# The Z axis is an arbitrary vector cross X
arbitrary = [0 for i in range(3)]
arbitrary[0] = random.uniform(-10,10)
arbitrary[1] = random.uniform(-10,10)
arbitrary[2] = random.uniform(-10,10)
math.Cross(normalizedX, arbitrary, normalizedZ)
math.Normalize(normalizedZ)
# The Y axis is Z cross X
math.Cross(normalizedZ, normalizedX, normalizedY)
matrix = vtk.vtkMatrix4x4()
# Create the direction cosine matrix
matrix.Identity()
for i in range(3):
matrix.SetElement(i, 0, normalizedX[i])
matrix.SetElement(i, 1, normalizedY[i])
matrix.SetElement(i, 2, normalizedZ[i])
matrix.SetElement(i, 3, currentTargetFiducialCoordinatesRAS[i])
# Apply the transforms
transform = vtk.vtkTransform()
transform.Concatenate(matrix)
transform.RotateZ(90)
'''
ps = vtk.vtkProgrammableSource()
import math
numPts = 80
polyLinePoints = vtk.vtkPoints()
polyLinePoints.SetNumberOfPoints(numPts)
R=1.0
for i in range(0,numPts):
x = R*math.cos(i*2*math.pi/numPts)
y = R*math.sin(i*2*math.pi/numPts)
polyLinePoints.InsertPoint(i, x, y, 0)
aPolyLine1 = vtk.vtkPolyLine()
aPolyLine1.GetPointIds().SetNumberOfIds(numPts+1)
for i in range(0,numPts):
aPolyLine1.GetPointIds().SetId(i,i)
# add one more cell at the end to close the circle on itself
aPolyLine1.GetPointIds().SetId(numPts, 0)
aPolyLineGrid = ps.GetOutput()
aPolyLineGrid.Allocate(1,1)
aPolyLineGrid.InsertNextCell(aPolyLine1.GetCellType(), aPolyLine1.GetPointIds())
aPolyLineGrid.SetPoints(polyLinePoints)
'''
'''
#This script generates a helix double.
#This is intended as the script of a 'Programmable Source'
import math
ps = vtk.vtkSphereSource()
numPts = 80 # Points along each Helix
length = 8 # Length of each Helix
rounds = 3 # Number of times around
phase_shift = math.pi/1.5 # Phase shift between Helixes
#Get a vtk.PolyData object for the output
pdo = ps.GetOutput()
print "before"
print pdo
#This will store the points for the Helix
newPts = vtk.vtkPoints()
for i in range(0, numPts):
#Generate Points for first Helix
x = i*length/numPts
y = math.sin(i*rounds*2*math.pi/numPts)
z = math.cos(i*rounds*2*math.pi/numPts)
newPts.InsertPoint(i, x,y,z)
#Generate Points for second Helix. Add a phase offset to y and z.
y = math.sin(i*rounds*2*math.pi/numPts+phase_shift)
z = math.cos(i*rounds*2*math.pi/numPts+phase_shift)
#Offset Helix 2 pts by 'numPts' to keep separate from Helix 1 Pts
newPts.InsertPoint(i+numPts, x,y,z)
#Add the points to the vtkPolyData object
pdo.SetPoints(newPts)
#Make two vtkPolyLine objects to hold curve construction data
aPolyLine1 = vtk.vtkPolyLine()
aPolyLine2 = vtk.vtkPolyLine()
#Indicate the number of points along the line
aPolyLine1.GetPointIds().SetNumberOfIds(numPts)
aPolyLine2.GetPointIds().SetNumberOfIds(numPts)
for i in range(0,numPts):
#First Helix - use the first set of points
aPolyLine1.GetPointIds().SetId(i, i)
#Second Helix - use the second set of points
#(Offset the point reference by 'numPts').
aPolyLine2.GetPointIds().SetId(i,i+numPts)
#Allocate the number of 'cells' that will be added.
#Two 'cells' for the Helix curves, and one 'cell'
#for every 3rd point along the Helixes.
links = range(0,numPts,3)
pdo.Allocate(2+len(links), 1)
#Add the poly line 'cell' to the vtkPolyData object.
pdo.InsertNextCell(aPolyLine1.GetCellType(), aPolyLine1.GetPointIds())
pdo.InsertNextCell(aPolyLine2.GetCellType(), aPolyLine2.GetPointIds())
for i in links:
#Add a line connecting the two Helixes.
aLine = vtk.vtkLine()
aLine.GetPointIds().SetId(0, i)
aLine.GetPointIds().SetId(1, i+numPts)
pdo.InsertNextCell(aLine.GetCellType(), aLine.GetPointIds())
print "after"
print pdo
'''
# Create model node
lesionModel = slicer.vtkMRMLModelNode()
lesionModel.SetScene(scene)
lesionModel.SetName("Ablationzone-%s" % targetFid.GetName())
lesionModel.SetAndObservePolyData(source.GetOutput())
self.lesionModel = lesionModel
# Create display node
lesionModelDisplay = slicer.vtkMRMLModelDisplayNode()
lesionModelDisplay.SetColor(ablationZoneColor)
lesionModelDisplay.SetOpacity(0.4)
lesionModelDisplay.SliceIntersectionVisibilityOn()
lesionModelDisplay.SetScene(scene)
scene.AddNode(lesionModelDisplay)
lesionModel.SetAndObserveDisplayNodeID(lesionModelDisplay.GetID())
# Add to scene
lesionModelDisplay.SetPolyData(source.GetOutput())
self.lesionModelDisplay = lesionModelDisplay
self.lesionModel= lesionModel
scene.AddNode(lesionModel)
# Create ablationZoneTransform node
ablationZoneTransform = slicer.vtkMRMLLinearTransformNode()
ablationZoneTransform.SetName('AblationZoneTransform-%s' % targetFid.GetName())
scene.AddNode(ablationZoneTransform)
ablationZoneTransform.ApplyTransformMatrix(transform.GetMatrix())
lesionModel.SetAndObserveTransformNodeID(ablationZoneTransform.GetID())
self.ablationZoneTransform = ablationZoneTransform
