def updateAblationVolume(self):
if self.AutomaticUpdate == False:
return
if self.SourceNode and self.DestinationNode:
pTip = [0.0, 0.0, 0.0]
pTail = [0.0, 0.0, 0.0]
#self.SourceNode.GetNthFiducialPosition(0,pTip)
self.SourceNode.GetPosition1(pTip)
#self.SourceNode.GetNthFiducialPosition(1,pTail)
self.SourceNode.GetPosition2(pTail)
if self.DestinationNode.GetDisplayNodeID() == None:
modelDisplayNode = slicer.vtkMRMLModelDisplayNode()
modelDisplayNode.SetColor(self.ModelColor)
slicer.mrmlScene.AddNode(modelDisplayNode)
self.DestinationNode.SetAndObserveDisplayNodeID(modelDisplayNode.GetID())
displayNodeID = self.DestinationNode.GetDisplayNodeID()
modelDisplayNode = slicer.mrmlScene.GetNodeByID(displayNodeID)
if modelDisplayNode != None and self.SliceIntersection == True:
modelDisplayNode.SliceIntersectionVisibilityOn()
else:
modelDisplayNode.SliceIntersectionVisibilityOff()
if self.SphereSource == None:
self.SphereSource = vtk.vtkSphereSource()
self.SphereSource.SetThetaResolution(20)
self.SphereSource.SetPhiResolution(20)
self.SphereSource.Update()
# Scale sphere to make ellipsoid
scale = vtk.vtkTransform()
scale.Scale(self.MinorAxis, self.MinorAxis, self.MajorAxis)
scaleFilter = vtk.vtkTransformPolyDataFilter()
scaleFilter.SetInputConnection(self.SphereSource.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.SetTransform(transform)
transformFilter.Update();
self.DestinationNode.SetAndObservePolyData(transformFilter.GetOutput())
self.DestinationNode.Modified()
if self.DestinationNode.GetScene() == None:
slicer.mrmlScene.AddNode(self.DestinationNode)
def recolorLabelMap(self, modelNode, labelMap, initialValue, outputValue):
import vtkSlicerRtCommonPython
if (modelNode != None and labelMap != None):
self.labelMapImgData = labelMap.GetImageData()
self.resectionPolyData = modelNode.GetPolyData()
# IJK -> RAS
ijkToRasMatrix = vtk.vtkMatrix4x4()
labelMap.GetIJKToRASMatrix(ijkToRasMatrix)
# RAS -> IJK
rasToIjkMatrix = vtk.vtkMatrix4x4()
labelMap.GetRASToIJKMatrix(rasToIjkMatrix)
rasToIjkTransform = vtk.vtkTransform()
rasToIjkTransform.SetMatrix(rasToIjkMatrix)
rasToIjkTransform.Update()
# Transform Resection model from RAS -> IJK
polyDataTransformFilter = vtk.vtkTransformPolyDataFilter()
if (vtk.VTK_MAJOR_VERSION <= 5):
polyDataTransformFilter.SetInput(self.resectionPolyData)
else:
polyDataTransformFilter.SetInputData(self.resectionPolyData)
polyDataTransformFilter.SetTransform(rasToIjkTransform)
polyDataTransformFilter.Update()
# Convert Resection model to label map
polyDataToLabelmapFilter = vtkSlicerRtCommonPython.vtkPolyDataToLabelmapFilter()
polyDataToLabelmapFilter.SetInputPolyData(polyDataTransformFilter.GetOutput())
polyDataToLabelmapFilter.SetReferenceImage(self.labelMapImgData)
polyDataToLabelmapFilter.UseReferenceValuesOn()
polyDataToLabelmapFilter.SetBackgroundValue(0)
polyDataToLabelmapFilter.SetLabelValue(outputValue)
polyDataToLabelmapFilter.Update()
# Cast resection label map to unsigned char for use with mask filter
castFilter = vtk.vtkImageCast()
if (vtk.VTK_MAJOR_VERSION <= 5):
castFilter.SetInput(polyDataToLabelmapFilter.GetOutput())
else:
castFilter.SetInputData(polyDataToLabelmapFilter.GetOutput())
castFilter.SetOutputScalarTypeToUnsignedChar()
castFilter.Update()
# Create mask for recoloring the original label map
maskFilter = vtk.vtkImageMask()
if (vtk.VTK_MAJOR_VERSION <= 5):
maskFilter.SetImageInput(self.labelMapImgData)
maskFilter.SetMaskInput(castFilter.GetOutput())
else:
maskFilter.SetImageInputData(self.labelMapImgData)
maskFilter.SetMaskInputData(castFilter.GetOutput())
maskFilter.SetMaskedOutputValue(outputValue)
maskFilter.NotMaskOn()
maskFilter.Update()
self.labelMapImgData = maskFilter.GetOutput()
self.labelMapImgData.Modified()
labelMap.SetAndObserveImageData(self.labelMapImgData)
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 onApplyButton(self):
""" Aply the Surface ICP Registration """
print("Run the algorithm")
fixed = self.modelSelectors['Fixed Surface Volume'].currentNode()
moving = self.modelSelectors['Moving Surface Volume'].currentNode()
outputSurf = self.modelOutputSurfaceSelectors['Output Surface Volume'].currentNode()
initialTrans = self.volumeInitialTransformSelectors["Initial Transform"].currentNode()
outputTrans = self.volumeOutputTransformSelectors["Output Transform"].currentNode()
inputPolyData = moving.GetPolyData()
if initialTrans:
print "Applying initial transform"
initialMatrix = initialTrans.GetMatrixTransformToParent()
transform = vtk.vtkTransform()
transform.SetMatrix(initialMatrix)
transformFilter = vtk.vtkTransformPolyDataFilter()
transformFilter.SetInput(inputPolyData)
transformFilter.SetTransform(transform)
transformFilter.Update()
inputPolyData = transformFilter.GetOutput()
self.icp.SetSource(inputPolyData)
self.icp.SetTarget(fixed.GetPolyData())
print self.icpLandmarkTransformType
if self.icpLandmarkTransformType == "RigidBody":
print self.icpLandmarkTransformType
self.icp.GetLandmarkTransform().SetModeToRigidBody()
elif self.icpLandmarkTransformType == "Similarity":
print self.icpLandmarkTransformType
self.icp.GetLandmarkTransform().SetModeToSimilarity()
print self.icpLandmarkTransformType
elif self.icpLandmarkTransformType == "Affine":
self.icp.GetLandmarkTransform().SetModeToAffine()
self.icp.SetMaximumNumberOfIterations(self.numberOfIterationsValueChanged)
self.icp.SetMaximumMeanDistance(self.maxDistanceValueChanged)
self.icp.SetMaximumNumberOfLandmarks(self.numberOfLandmarksValueChanged)
self.icp.SetCheckMeanDistance(int(self.checkMeanDistanceActive))
self.icp.SetStartByMatchingCentroids(int(self.matchCentroidsLinearActive))
#self.icp.Update
print self.icp.GetLandmarkTransform()
outputMatrix = vtk.vtkMatrix4x4()
self.icp.GetMatrix(outputMatrix)
outputTrans.SetAndObserveMatrixTransformToParent(outputMatrix)
outputPolyData = vtk.vtkPolyData()
outputPolyData.DeepCopy(inputPolyData)
outputSurf.SetAndObservePolyData(outputPolyData)
print self.icp.GetLandmarkTransform()
print self.icp.GetLandmarkTransform().GetSourceLandmarks()
print self.icp.GetLandmarkTransform().GetTargetLandmarks()
print self.icp.GetMaximumMeanDistance()
print self.icp.GetMeanDistanceModeAsString()
print self.icp.GetMaximumNumberOfIterations()
print self.icp.GetMaximumNumberOfLandmarks()
def ConvertTextureToPointAttribute(modelNode, textureImageNode):
polyData=modelNode.GetPolyData()
textureImageFlipVert=vtk.vtkImageFlip()
textureImageFlipVert.SetFilteredAxis(1)
textureImageFlipVert.SetInputConnection(textureImageNode.GetImageDataConnection())
textureImageFlipVert.Update()
textureImageData=textureImageFlipVert.GetOutput()
pointData=polyData.GetPointData()
tcoords=pointData.GetTCoords()
numOfPoints=pointData.GetNumberOfTuples()
assert numOfPoints==tcoords.GetNumberOfTuples(), "Number of texture coordinates does not equal number of points"
textureSamplingPointsUv=vtk.vtkPoints()
textureSamplingPointsUv.SetNumberOfPoints(numOfPoints)
for pointIndex in xrange(numOfPoints):
uv=tcoords.GetTuple2(pointIndex)
textureSamplingPointsUv.SetPoint(pointIndex, uv[0], uv[1], 0)
textureSamplingPointDataUv=vtk.vtkPolyData()
uvToXyz=vtk.vtkTransform()
textureImageDataSpacingSpacing=textureImageData.GetSpacing()
textureImageDataSpacingOrigin=textureImageData.GetOrigin()
textureImageDataSpacingDimensions=textureImageData.GetDimensions()
uvToXyz.Scale(textureImageDataSpacingDimensions[0]/textureImageDataSpacingSpacing[0], textureImageDataSpacingDimensions[1]/textureImageDataSpacingSpacing[1], 1)
uvToXyz.Translate(textureImageDataSpacingOrigin)
textureSamplingPointDataUv.SetPoints(textureSamplingPointsUv)
transformPolyDataToXyz=vtk.vtkTransformPolyDataFilter()
transformPolyDataToXyz.SetInputData(textureSamplingPointDataUv)
transformPolyDataToXyz.SetTransform(uvToXyz)
probeFilter=vtk.vtkProbeFilter()
probeFilter.SetInputConnection(transformPolyDataToXyz.GetOutputPort())
probeFilter.SetSourceData(textureImageData)
probeFilter.Update()
rgbPoints=probeFilter.GetOutput().GetPointData().GetArray('ImageScalars')
colorArrayRed=vtk.vtkDoubleArray()
colorArrayRed.SetName('ColorRed')
colorArrayRed.SetNumberOfTuples(numOfPoints)
colorArrayGreen=vtk.vtkDoubleArray()
colorArrayGreen.SetName('ColorGreen')
colorArrayGreen.SetNumberOfTuples(numOfPoints)
colorArrayBlue=vtk.vtkDoubleArray()
colorArrayBlue.SetName('ColorBlue')
colorArrayBlue.SetNumberOfTuples(numOfPoints)
for pointIndex in xrange(numOfPoints):
rgb=rgbPoints.GetTuple3(pointIndex)
colorArrayRed.SetValue(pointIndex,rgb[0])
colorArrayGreen.SetValue(pointIndex,rgb[1])
colorArrayBlue.SetValue(pointIndex,rgb[2])
colorArrayRed.Modified()
colorArrayGreen.Modified()
colorArrayBlue.Modified()
pointData.AddArray(colorArrayRed)
pointData.AddArray(colorArrayGreen)
pointData.AddArray(colorArrayBlue)
pointData.Modified()
polyData.Modified()
def IntersectBaseModel(self):
transform = vtk.vtkTransform()
matrix = vtk.vtkMatrix4x4()
self.transformSelector.currentNode().GetMatrixTransformToParent(matrix)
transform.SetMatrix(matrix)
#transform.RotateX(-90.0)
# cylinder = vtk.vtkCylinderSource()
# cylinder.SetCenter(np.array([0.0, 0.0, 0.0]))
# cylinder.SetRadius(25)
# cylinder.SetHeight(60)
# cylinder.SetResolution(100)
# cylinder.Update()
originalCylinder_path = os.path.dirname(
os.path.realpath(__file__)) + "\\Models\\OriginalCylinder.stl"
originalCylinderModelNode = slicer.util.loadModel(
originalCylinder_path)
transformFilter = vtk.vtkTransformPolyDataFilter()
transformFilter.SetInputData(originalCylinderModelNode.GetPolyData())
transformFilter.SetTransform(transform)
transformFilter.ReleaseDataFlagOn()
transformFilter.Update()
modelNode = self.booleanModelSelector.currentNode()
modelNode.SetAndObservePolyData(transformFilter.GetOutput())
modelDisplayNode = modelNode.GetModelDisplayNode()
if modelDisplayNode is None:
modelDisplayNode = slicer.vtkMRMLModelDisplayNode()
modelDisplayNode.SetScene(slicer.mrmlScene)
slicer.mrmlScene.AddNode(modelDisplayNode)
modelNode.SetAndObserveDisplayNodeID(modelDisplayNode.GetID())
modelDisplayNode.SetOpacity(0.2)
modelDisplayNode.SetColor(0, 1, 0)
modelNode2 = self.transientModelSelector.currentNode()
modelDisplayNode2 = self.transientModelSelector.currentNode(
).GetModelDisplayNode()
if modelDisplayNode2 is None:
modelDisplayNode2 = slicer.vtkMRMLModelDisplayNode()
modelDisplayNode2.SetScene(slicer.mrmlScene)
slicer.mrmlScene.AddNode(modelDisplayNode2)
modelNode2.SetAndObserveDisplayNodeID(modelDisplayNode2.GetID())
modelDisplayNode2.SetOpacity(1.0)
modelDisplayNode2.SetColor(0, 1, 0)
cylinder_path = os.path.dirname(
os.path.realpath(__file__)) + "\\Models\\cylinder.stl"
slicer.util.saveNode(modelNode, cylinder_path)
slicer.mrmlScene.RemoveNode(originalCylinderModelNode)
self.blenderBoolean()
def marchingCubes( self, image, ijkToRasMatrix, threshold ):
transformIJKtoRAS = vtk.vtkTransform()
transformIJKtoRAS.SetMatrix( ijkToRasMatrix )
marchingCubes = vtk.vtkMarchingCubes()
marchingCubes.SetInput( image )
marchingCubes.SetValue( 0, threshold )
marchingCubes.ComputeScalarsOn()
marchingCubes.ComputeGradientsOn()
marchingCubes.ComputeNormalsOn()
marchingCubes.GetOutput().ReleaseDataFlagOn()
marchingCubes.Update()
if transformIJKtoRAS.GetMatrix().Determinant() < 0:
reverser = vtk.vtkReverseSense()
reverser.SetInput( marchingCubes.GetOutput() )
reverser.ReverseNormalsOn()
reverser.GetOutput().ReleaseDataFlagOn()
reverser.Update()
correctedOutput = reverser.GetOutput()
else:
correctedOutput = marchingCubes.GetOutput()
transformer = vtk.vtkTransformPolyDataFilter()
transformer.SetInput( correctedOutput )
transformer.SetTransform( transformIJKtoRAS )
transformer.GetOutput().ReleaseDataFlagOn()
transformer.Update()
normals = vtk.vtkPolyDataNormals()
normals.ComputePointNormalsOn()
normals.SetInput( transformer.GetOutput() )
normals.SetFeatureAngle( 60 )
normals.SetSplitting( 1 )
normals.GetOutput().ReleaseDataFlagOn()
normals.Update()
stripper = vtk.vtkStripper()
stripper.SetInput( normals.GetOutput() )
stripper.GetOutput().ReleaseDataFlagOff()
stripper.Update()
stripper.GetOutput().Update()
result = vtk.vtkPolyData()
result.DeepCopy( stripper.GetOutput() )
result.Update()
return result
def marchingCubes(self,image,ijkToRasMatrix,threshold):
transformIJKtoRAS = vtk.vtkTransform()
transformIJKtoRAS.SetMatrix(ijkToRasMatrix)
marchingCubes = vtk.vtkMarchingCubes()
marchingCubes.SetInput(image)
marchingCubes.SetValue(0,threshold)
marchingCubes.ComputeScalarsOn()
marchingCubes.ComputeGradientsOn()
marchingCubes.ComputeNormalsOn()
marchingCubes.GetOutput().ReleaseDataFlagOn()
marchingCubes.Update()
if transformIJKtoRAS.GetMatrix().Determinant() < 0:
reverser = vtk.vtkReverseSense()
reverser.SetInput(marchingCubes.GetOutput())
reverser.ReverseNormalsOn()
reverser.GetOutput().ReleaseDataFlagOn()
reverser.Update()
correctedOutput = reverser.GetOutput()
else:
correctedOutput = marchingCubes.GetOutput()
transformer = vtk.vtkTransformPolyDataFilter()
transformer.SetInput(correctedOutput)
transformer.SetTransform(transformIJKtoRAS)
transformer.GetOutput().ReleaseDataFlagOn()
transformer.Update()
normals = vtk.vtkPolyDataNormals()
normals.ComputePointNormalsOn()
normals.SetInput(transformer.GetOutput())
normals.SetFeatureAngle(60)
normals.SetSplitting(1)
normals.GetOutput().ReleaseDataFlagOn()
normals.Update()
stripper = vtk.vtkStripper()
stripper.SetInput(normals.GetOutput())
stripper.GetOutput().ReleaseDataFlagOff()
stripper.Update()
stripper.GetOutput().Update()
result = vtk.vtkPolyData()
result.DeepCopy(stripper.GetOutput())
result.Update()
return result
def PointsToSurfacePolyData( self, inPoints, reverse ):
# Create a polydata object from the points
pointsPolyData = vtk.vtkPolyData()
pointsPolyData.SetPoints( inPoints )
# Create the surface filter from the polydata
surfaceFilter = vtk.vtkSurfaceReconstructionFilter()
surfaceFilter.SetInputData( pointsPolyData )
surfaceFilter.Update()
# Do the contouring filter, and reverse to ensure it works properly
contourFilter = vtk.vtkContourFilter()
contourFilter.SetValue( 0, 0.0 )
contourFilter.SetInputData( surfaceFilter.GetOutput() )
contourFilter.Update()
# Reverse the normals if necessary
reverseFilter = vtk.vtkReverseSense()
reverseFilter.SetInputData( contourFilter.GetOutput() )
reverseFilter.SetReverseCells( reverse )
reverseFilter.SetReverseNormals( reverse )
reverseFilter.Update()
# Reset the scaling to let the surface match the points
fiducialBounds = [ 0, 0, 0, 0, 0, 0 ]
pointsPolyData.GetBounds( fiducialBounds )
tissueBounds = [ 0, 0, 0, 0, 0, 0 ]
reverseFilter.GetOutput().GetBounds( tissueBounds )
scaleX = ( fiducialBounds[1] - fiducialBounds[0] ) / ( tissueBounds[1] - tissueBounds[0] )
scaleY = ( fiducialBounds[3] - fiducialBounds[2] ) / ( tissueBounds[3] - tissueBounds[2] )
scaleZ = ( fiducialBounds[5] - fiducialBounds[4] ) / ( tissueBounds[5] - tissueBounds[4] )
transform = vtk.vtkTransform()
transform.Translate( fiducialBounds[0], fiducialBounds[2], fiducialBounds[4] )
transform.Scale( scaleX, scaleY, scaleZ )
transform.Translate( - tissueBounds[0], - tissueBounds[2], - tissueBounds[4] )
transformFilter = vtk.vtkTransformPolyDataFilter()
transformFilter.SetInputData( reverseFilter.GetOutput() )
transformFilter.SetTransform( transform )
transformFilter.Update()
return transformFilter.GetOutput()
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 transformPolyData(self, modelNode, transformNode):
transformedModel = slicer.util.getNode('Transformed Model')
if not transformedModel:
transformedModel = slicer.vtkMRMLModelNode()
transformedModel.SetName('Transformed Model')
transformedModel.SetAndObservePolyData(modelNode.GetPolyData())
modelDisplay = slicer.vtkMRMLModelDisplayNode()
modelDisplay.SetSliceIntersectionVisibility(True)
modelDisplay.SetColor(0,1,0)
slicer.mrmlScene.AddNode(modelDisplay)
transformedModel.SetAndObserveDisplayNodeID(modelDisplay.GetID())
slicer.mrmlScene.AddNode(transformedModel)
transformedModel.SetDisplayVisibility(False)
t = vtk.vtkGeneralTransform()
transformNode.GetTransformToWorld(t)
transformPolyDataFilter = vtk.vtkTransformPolyDataFilter()
transformPolyDataFilter.SetTransform(t)
transformPolyDataFilter.SetInputData(modelNode.GetPolyData())
transformPolyDataFilter.Update()
transformedModel.SetAndObservePolyData(transformPolyDataFilter.GetOutput())
def clipImageWithPolyData(self,
inputImageData,
outputImageData,
clippingPolyData,
rasToModel,
inputIjkToRas,
outputIjkToRas,
clipOutsideSurface=True,
fillValue=0,
reduceExtent=False):
"""
Fill voxels of the input volume inside/outside the clipping model with the provided fill value
If reduceExtent is True then the extent of the volume will be reduced to the smallest possible box that still contains all the non-zero voxels.
"""
# Determine the transform between the box and the image IJK coordinate systems
ijkToModel = vtk.vtkMatrix4x4()
vtk.vtkMatrix4x4.Multiply4x4(rasToModel, inputIjkToRas, ijkToModel)
modelToIjkTransform = vtk.vtkTransform()
modelToIjkTransform.SetMatrix(ijkToModel)
modelToIjkTransform.Inverse()
transformModelToIjk = vtk.vtkTransformPolyDataFilter()
transformModelToIjk.SetTransform(modelToIjkTransform)
transformModelToIjk.SetInputData(clippingPolyData)
# Use the stencil to fill the volume
# Convert model to stencil
polyToStencil = vtk.vtkPolyDataToImageStencil()
polyToStencil.SetInputConnection(transformModelToIjk.GetOutputPort())
polyToStencil.SetOutputSpacing(inputImageData.GetSpacing())
polyToStencil.SetOutputOrigin(inputImageData.GetOrigin())
polyToStencil.SetOutputWholeExtent(inputImageData.GetExtent())
# Apply the stencil to the volume
stencilToImage = vtk.vtkImageStencil()
stencilToImage.SetInputData(inputImageData)
stencilToImage.SetStencilConnection(polyToStencil.GetOutputPort())
if clipOutsideSurface:
stencilToImage.ReverseStencilOff()
else:
stencilToImage.ReverseStencilOn()
stencilToImage.SetBackgroundValue(fillValue)
stencilToImage.Update()
# Update the volume with the stencil operation result
if reduceExtent:
clippingPolyDataBounds_Ijk = [0, 0, 0, 0, 0, 0]
transformModelToIjk.GetOutput().GetBounds(
clippingPolyDataBounds_Ijk)
inputVolumeExtent_Ijk = inputImageData.GetExtent()
outputVolumeExtent_Ijk = list(inputVolumeExtent_Ijk) # make a copy
for i in range(3):
a = int(math.floor(clippingPolyDataBounds_Ijk[i * 2]))
if a > outputVolumeExtent_Ijk[i * 2]:
outputVolumeExtent_Ijk[i * 2] = a
b = int(math.ceil(clippingPolyDataBounds_Ijk[i * 2 + 1]))
if b < outputVolumeExtent_Ijk[i * 2 + 1]:
outputVolumeExtent_Ijk[i * 2 + 1] = b
clipper = vtk.vtkImageClip()
clipper.SetOutputWholeExtent(outputVolumeExtent_Ijk)
clipper.ClipDataOn()
clipper.SetInputConnection(stencilToImage.GetOutputPort())
clipper.Update()
outputImageData.DeepCopy(clipper.GetOutput())
# Offset the extent to start at [0,0,0]
# (maybe this is not needed, but we do it because some code may assume the image extent starts from zero)
outputVolumeExtent_Ijk = list(outputImageData.GetExtent())
outputIjkToInputIjk = vtk.vtkMatrix4x4()
for i in range(3):
outputVolumeExtentOffset = outputVolumeExtent_Ijk[i * 2]
outputVolumeExtent_Ijk[i * 2] = outputVolumeExtent_Ijk[
i * 2] - outputVolumeExtentOffset
outputVolumeExtent_Ijk[i * 2 + 1] = outputVolumeExtent_Ijk[
i * 2 + 1] - outputVolumeExtentOffset
outputIjkToInputIjk.SetElement(i, 3, outputVolumeExtentOffset)
outputImageData.SetExtent(outputVolumeExtent_Ijk)
vtk.vtkMatrix4x4.Multiply4x4(inputIjkToRas, outputIjkToInputIjk,
outputIjkToRas)
else:
outputImageData.DeepCopy(stencilToImage.GetOutput())
outputIjkToRas.DeepCopy(inputIjkToRas)
# This module was tested on 3D Slicer version 4.3.1
def convertTextureToPointAttribute(self, modelNode, textureImageNode,
colorAsVector):
polyData = modelNode.GetPolyData()
textureImageFlipVert = vtk.vtkImageFlip()
textureImageFlipVert.SetFilteredAxis(1)
textureImageFlipVert.SetInputConnection(
textureImageNode.GetImageDataConnection())
textureImageFlipVert.Update()
textureImageData = textureImageFlipVert.GetOutput()
pointData = polyData.GetPointData()
tcoords = pointData.GetTCoords()
numOfPoints = pointData.GetNumberOfTuples()
assert numOfPoints == tcoords.GetNumberOfTuples(
), "Number of texture coordinates does not equal number of points"
textureSamplingPointsUv = vtk.vtkPoints()
textureSamplingPointsUv.SetNumberOfPoints(numOfPoints)
for pointIndex in range(numOfPoints):
uv = tcoords.GetTuple2(pointIndex)
textureSamplingPointsUv.SetPoint(pointIndex, uv[0], uv[1], 0)
textureSamplingPointDataUv = vtk.vtkPolyData()
uvToXyz = vtk.vtkTransform()
textureImageDataSpacingSpacing = textureImageData.GetSpacing()
textureImageDataSpacingOrigin = textureImageData.GetOrigin()
textureImageDataSpacingDimensions = textureImageData.GetDimensions()
uvToXyz.Scale(
textureImageDataSpacingDimensions[0] /
textureImageDataSpacingSpacing[0],
textureImageDataSpacingDimensions[1] /
textureImageDataSpacingSpacing[1], 1)
uvToXyz.Translate(textureImageDataSpacingOrigin)
textureSamplingPointDataUv.SetPoints(textureSamplingPointsUv)
transformPolyDataToXyz = vtk.vtkTransformPolyDataFilter()
transformPolyDataToXyz.SetInputData(textureSamplingPointDataUv)
transformPolyDataToXyz.SetTransform(uvToXyz)
probeFilter = vtk.vtkProbeFilter()
probeFilter.SetInputConnection(transformPolyDataToXyz.GetOutputPort())
probeFilter.SetSourceData(textureImageData)
probeFilter.Update()
rgbPoints = probeFilter.GetOutput().GetPointData().GetArray(
'ImageScalars')
if colorAsVector:
colorArray = vtk.vtkDoubleArray()
colorArray.SetName('Color')
colorArray.SetNumberOfComponents(3)
colorArray.SetNumberOfTuples(numOfPoints)
for pointIndex in range(numOfPoints):
rgb = rgbPoints.GetTuple3(pointIndex)
colorArray.SetTuple3(pointIndex, rgb[0] / 255., rgb[1] / 255.,
rgb[2] / 255.)
colorArray.Modified()
pointData.AddArray(colorArray)
else:
colorArrayRed = vtk.vtkDoubleArray()
colorArrayRed.SetName('ColorRed')
colorArrayRed.SetNumberOfTuples(numOfPoints)
colorArrayGreen = vtk.vtkDoubleArray()
colorArrayGreen.SetName('ColorGreen')
colorArrayGreen.SetNumberOfTuples(numOfPoints)
colorArrayBlue = vtk.vtkDoubleArray()
colorArrayBlue.SetName('ColorBlue')
colorArrayBlue.SetNumberOfTuples(numOfPoints)
for pointIndex in range(numOfPoints):
rgb = rgbPoints.GetTuple3(pointIndex)
colorArrayRed.SetValue(pointIndex, rgb[0])
colorArrayGreen.SetValue(pointIndex, rgb[1])
colorArrayBlue.SetValue(pointIndex, rgb[2])
colorArrayRed.Modified()
colorArrayGreen.Modified()
colorArrayBlue.Modified()
pointData.AddArray(colorArrayRed)
pointData.AddArray(colorArrayGreen)
pointData.AddArray(colorArrayBlue)
pointData.Modified()
polyData.Modified()
def clipVolumeWithModel(self, inputVolume, clippingModel,
clipOutsideSurface, fillOutsideValue,
clipInsideSurface, fillInsideValue, outputVolume):
"""
Fill voxels of the input volume inside/outside the clipping model with the provided fill value
"""
# Determine the transform between the box and the image IJK coordinate systems
rasToModel = vtk.vtkMatrix4x4()
if clippingModel.GetTransformNodeID() != None:
modelTransformNode = slicer.mrmlScene.GetNodeByID(
clippingModel.GetTransformNodeID())
boxToRas = vtk.vtkMatrix4x4()
modelTransformNode.GetMatrixTransformToWorld(boxToRas)
rasToModel.DeepCopy(boxToRas)
rasToModel.Invert()
ijkToRas = vtk.vtkMatrix4x4()
inputVolume.GetIJKToRASMatrix(ijkToRas)
ijkToModel = vtk.vtkMatrix4x4()
vtk.vtkMatrix4x4.Multiply4x4(rasToModel, ijkToRas, ijkToModel)
modelToIjkTransform = vtk.vtkTransform()
modelToIjkTransform.SetMatrix(ijkToModel)
modelToIjkTransform.Inverse()
transformModelToIjk = vtk.vtkTransformPolyDataFilter()
transformModelToIjk.SetTransform(modelToIjkTransform)
transformModelToIjk.SetInputConnection(
clippingModel.GetPolyDataConnection())
# Use the stencil to fill the volume
# Convert model to stencil
polyToStencil = vtk.vtkPolyDataToImageStencil()
polyToStencil.SetInputConnection(transformModelToIjk.GetOutputPort())
polyToStencil.SetOutputSpacing(inputVolume.GetImageData().GetSpacing())
polyToStencil.SetOutputOrigin(inputVolume.GetImageData().GetOrigin())
polyToStencil.SetOutputWholeExtent(
inputVolume.GetImageData().GetExtent())
# Apply the stencil to the volume
stencilToImage = vtk.vtkImageStencil()
stencilToImage.SetInputConnection(inputVolume.GetImageDataConnection())
stencilToImage.SetStencilConnection(polyToStencil.GetOutputPort())
# Create a copy of the input volume to work on
outputImageData = vtk.vtkImageData()
outputImageData.DeepCopy(inputVolume.GetImageData())
outputVolume.SetAndObserveImageData(outputImageData)
outputVolume.SetIJKToRASMatrix(ijkToRas)
# Update volume with the stencil operation result depending on user choices
if clipOutsideSurface:
stencilToImage.ReverseStencilOff()
stencilToImage.SetBackgroundValue(fillOutsideValue)
stencilToImage.Update()
outputImageData.DeepCopy(stencilToImage.GetOutput())
outputVolume.SetAndObserveImageData(outputImageData)
outputVolume.SetIJKToRASMatrix(ijkToRas)
if clipInsideSurface:
stencilToImage.SetInputConnection(
outputVolume.GetImageDataConnection())
stencilToImage.ReverseStencilOn()
stencilToImage.SetBackgroundValue(fillInsideValue)
stencilToImage.Update()
outputImageData.DeepCopy(stencilToImage.GetOutput())
outputVolume.SetAndObserveImageData(outputImageData)
outputVolume.SetIJKToRASMatrix(ijkToRas)
# Add a default display node to output volume node if it does not exist yet
if not outputVolume.GetDisplayNode:
displayNode = slicer.vtkMRMLScalarVolumeDisplayNode()
displayNode.SetAndObserveColorNodeID("vtkMRMLColorTableNodeGrey")
slicer.mrmlScene.AddNode(displayNode)
outputVolume.SetAndObserveDisplayNodeID(displayNode.GetID())
return True
def PolyDataToImageData(self, inputPolydata_Ras, referenceVolumeNode_Ras, inVal=100, outVal=0):
""" We take in an polydata and convert it to an new image data , withing the Reference Voulume node
the reference volume node is cleared with a threshold because originally the volume may contain
alot of noisy pixels
PARAM: inputPolydata_Ras: Polydata we are looking to conver vtkPolydata()
PARAM: refernceVolumeNode_Ras vtkMRMLScalarVolumeNode()
RETURN : vtkImageData
"""
""" Transform the polydata from ras to ijk using the referenceVolumeNode """
#inputPolydataTriangulated_Ijk=polyToImage.GetOutput()
transformPolydataFilter=vtk.vtkTransformPolyDataFilter()
rasToIjkMatrix=vtk.vtkMatrix4x4()
referenceVolumeNode_Ras.GetRASToIJKMatrix(rasToIjkMatrix)
rasToIjkTransform = vtk.vtkTransform()
rasToIjkTransform.SetMatrix(rasToIjkMatrix)
transformPolydataFilter.SetTransform(rasToIjkTransform)
transformPolydataFilter.SetInputData(inputPolydata_Ras)
transformPolydataFilter.Update()
inputPolydata_Ijk=transformPolydataFilter.GetOutput()
normalsFunction=vtk.vtkPolyDataNormals()
normalsFunction.SetInputData(inputPolydata_Ijk)
normalsFunction.ConsistencyOn()
trigFilter=vtk.vtkTriangleFilter()
trigFilter.SetInputConnection(normalsFunction.GetOutputPort())
stripper=vtk.vtkStripper()
stripper.SetInputConnection(trigFilter.GetOutputPort())
stripper.Update()
inputPolydataTriangulated_Ijk=stripper.GetOutput()
# Clone reference image and clear it
referenceImage_Ijk = referenceVolumeNode_Ras.GetImageData()
# Fill image with outVal (there is no volume Fill filter in VTK, therefore we need to use threshold filter)
thresh = vtk.vtkImageThreshold()
thresh.ReplaceInOn()
thresh.ReplaceOutOn()
thresh.SetInValue(outVal)
thresh.SetOutValue(outVal)
#thresh.SetOutputScalarType (vtk.VTK_UNSIGNED_CHAR)
thresh.SetInputData(referenceImage_Ijk)
thresh.Update()
whiteImage_Ijk = thresh.GetOutput()
# Convert polydata to stencil
polyToImage = vtk.vtkPolyDataToImageStencil()
polyToImage.SetInputData(inputPolydataTriangulated_Ijk)
polyToImage.SetOutputSpacing(whiteImage_Ijk.GetSpacing())
polyToImage.SetOutputOrigin(whiteImage_Ijk.GetOrigin())
polyToImage.SetOutputWholeExtent(whiteImage_Ijk.GetExtent())
polyToImage.Update()
imageStencil_Ijk=polyToImage.GetOutput()
# Convert stencil to image
imgstenc = vtk.vtkImageStencil()
imgstenc.SetInputData(whiteImage_Ijk)
imgstenc.SetStencilData(imageStencil_Ijk)
imgstenc.ReverseStencilOn()
imgstenc.SetBackgroundValue(inVal)
imgstenc.Update()
return imgstenc.GetOutput()
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 setupScene(self): # applet specific
logging.debug('setupScene')
# Add a Qt timer, that fires every X ms (16.7ms = 60 FPS, 33ms = 30FPS)
# Connect the timeout() signal of the qt timer to a function in this class that you will write
self.timer.connect('timeout()', self.onTimerTimeout)
self.timer.start(16.7)
# ReferenceToRas is needed for ultrasound initialization, so we need to
# set it up before calling Guidelet.setupScene().
self.referenceToRasTransform = slicer.util.getNode('ReferenceToRas')
if not self.referenceToRasTransform:
self.referenceToRasTransform = slicer.vtkMRMLLinearTransformNode()
self.referenceToRasTransform.SetName("ReferenceToRas")
m = self.logic.readTransformFromSettings('ReferenceToRas',
self.configurationName)
if m is None:
# Create identity matrix
m = self.logic.createMatrixFromString(
'1.0 0.0 0.0 0.0 0.0 1.0 0.0 0.0 0.0 0.0 1.0 0.0 0 0 0 1')
self.referenceToRasTransform.SetMatrixTransformToParent(m)
slicer.mrmlScene.AddNode(self.referenceToRasTransform)
Guidelet.setupScene(self)
logging.debug('Create transforms')
# Coordinate system definitions: https://app.assembla.com/spaces/slicerigt/wiki/Coordinate_Systems
self.needleTipToNeedleTransform = slicer.util.getNode(
'NeedleTipToNeedle')
if not self.needleTipToNeedleTransform:
self.needleTipToNeedleTransform = slicer.vtkMRMLLinearTransformNode(
)
self.needleTipToNeedleTransform.SetName("NeedleTipToNeedle")
m = self.logic.readTransformFromSettings('NeedleTipToNeedle',
self.configurationName)
if m:
self.needleTipToNeedleTransform.SetMatrixTransformToParent(m)
slicer.mrmlScene.AddNode(self.needleTipToNeedleTransform)
self.needleModelToNeedleTipTransform = slicer.util.getNode(
'NeedleModelToNeedleTip')
if not self.needleModelToNeedleTipTransform:
self.needleModelToNeedleTipTransform = slicer.vtkMRMLLinearTransformNode(
)
self.needleModelToNeedleTipTransform.SetName(
"NeedleModelToNeedleTip")
m = self.logic.readTransformFromSettings('NeedleModelToNeedleTip',
self.configurationName)
if m:
self.needleModelToNeedleTipTransform.SetMatrixTransformToParent(
m)
slicer.mrmlScene.AddNode(self.needleModelToNeedleTipTransform)
self.trajModelToNeedleTipTransform = slicer.util.getNode(
'TrajModelToNeedleTip')
if not self.trajModelToNeedleTipTransform:
self.trajModelToNeedleTipTransform = slicer.vtkMRMLLinearTransformNode(
)
self.trajModelToNeedleTipTransform.SetName("TrajModelToNeedleTip")
m = self.logic.readTransformFromSettings('TrajModelToNeedleTip',
self.configurationName)
if m:
self.trajModelToNeedleTipTransform.SetMatrixTransformToParent(
m)
slicer.mrmlScene.AddNode(self.trajModelToNeedleTipTransform)
# Create transforms that will be updated through OpenIGTLink
self.needleToReferenceTransform = slicer.util.getNode(
'NeedleToReference')
if not self.needleToReferenceTransform:
self.needleToReferenceTransform = slicer.vtkMRMLLinearTransformNode(
)
self.needleToReferenceTransform.SetName("NeedleToReference")
slicer.mrmlScene.AddNode(self.needleToReferenceTransform)
# Models
logging.debug('Create models')
self.needleWithTipModel = slicer.util.getNode('NeedleModel')
if not self.needleWithTipModel:
# length, radius, tipradius, bool markers, vtkMRMLModelNode(1 or 0: creates a ring close to tip)
# length, radius, tipradius, bool markers, vtkMRMLModelNode(1 or 0: creates a ring close to tip)
slicer.modules.createmodels.logic().CreateNeedle(
65, 1.0, self.needleModelTipRadius, 0)
self.needleWithTipModel = slicer.util.getNode(
pattern="NeedleModel")
self.needleWithTipModel.GetDisplayNode().SetColor(0.08, 0.84,
0.1) # (1,0,1)#
self.needleWithTipModel.SetName("NeedleModel")
self.needleWithTipModel.GetDisplayNode(
).SliceIntersectionVisibilityOn()
self.trajectoryModel_needleModel = slicer.util.getNode(
'TrajectoryModel')
cylinderLength = 100
if not self.trajectoryModel_needleModel:
self.trajectoryModel_needleModel = slicer.modules.createmodels.logic(
).CreateCylinder(cylinderLength, 0.1) # 0.5mm tall, 4mm radius
self.trajectoryModel_needleModel.SetName('TrajectoryModel')
self.trajectoryModel_needleModel.GetDisplayNode().SetColor(
0.69, 0.93, 0.93) # (1, 1, 0.5)
# here, we want to bake in a transform to move the origin of the cylinder to one of the ends (instead
# of being in the middle)
transformFilter = vtk.vtkTransformPolyDataFilter()
transformFilter.SetInputConnection(
self.trajectoryModel_needleModel.GetPolyDataConnection())
trans = vtk.vtkTransform()
trans.Translate(0, 0, cylinderLength / 2)
transformFilter.SetTransform(trans)
transformFilter.Update()
self.trajectoryModel_needleModel.SetPolyDataConnection(
transformFilter.GetOutputPort())
# number of balls = cylinderLength / distance between markers (may be -1, depending on ball at tip (giggggity))
number_spheres = cylinderLength / 10
for i in range(0, number_spheres):
# create sphere model if non-existent
model = slicer.util.getNode('DistanceMarkerModel_' + str(i))
if model is None:
model = slicer.modules.createmodels.logic().CreateSphere(0.7)
model.SetName('DistanceMarkerModel_' + str(i))
R = 1.0
G = 1.0
B = 0.1 + i * (0.7 / (number_spheres - 1.0)
) # yellow spectrum ranging from 0.1-0.7
model.GetDisplayNode().SetColor(R, G, B)
# create transform node, apply z translation i*distanceBetweenMarkers
node = slicer.util.getNode('DistanceMarkerTransform_' + str(i))
if node is None:
node = slicer.vtkMRMLLinearTransformNode()
node.SetName('DistanceMarkerTransform_' + str(i))
slicer.mrmlScene.AddNode(node)
m = self.logic.createMatrixFromString('1.0 0.0 0.0 0.0 '
'0.0 1.0 0.0 0.0 '
'0.0 0.0 1.0 ' +
str((i + 1) * 10.0) + ' '
'0.0 0.0 0.0 1.0')
node.SetMatrixTransformToParent(m)
model.SetAndObserveTransformNodeID(node.GetID())
node.SetAndObserveTransformNodeID(
self.needleTipToNeedleTransform.GetID())
# Setup the needle tip hierarchy
self.needleToReferenceTransform.SetAndObserveTransformNodeID(
self.referenceToRasTransform.GetID())
self.needleTipToNeedleTransform.SetAndObserveTransformNodeID(
self.needleToReferenceTransform.GetID())
self.needleWithTipModel.SetAndObserveTransformNodeID(
self.needleTipToNeedleTransform.GetID())
# Build transform tree
logging.debug('Set up transform tree')
self.needleModelToNeedleTipTransform.SetAndObserveTransformNodeID(
self.needleTipToNeedleTransform.GetID())
self.needleWithTipModel.SetAndObserveTransformNodeID(
self.needleModelToNeedleTipTransform.GetID())
# self.liveUltrasoundNode_Reference.SetAndObserveTransformNodeID(self.referenceToRasTransform.GetID()) # always commented out
# self.needleToReferenceTransform.SetAndObserveTransformNodeID(self.referenceToRasTransform.GetID())
# self.needleTipToNeedleTransform.SetAndObserveTransformNodeID(self.needleToReferenceTransform.GetID())
# self.needleModelToNeedleTipTransform.SetAndObserveTransformNodeID(self.needleTipToNeedleTransform.GetID())
self.trajModelToNeedleTipTransform.SetAndObserveTransformNodeID(
self.needleTipToNeedleTransform.GetID())
self.trajectoryModel_needleModel.SetAndObserveTransformNodeID(
self.trajModelToNeedleTipTransform.GetID())
def recolorLabelMap(self, modelNode, labelMap, initialValue, outputValue):
import vtkSlicerRtCommonPython
if (modelNode != None and labelMap != None):
self.labelMapImgData = labelMap.GetImageData()
self.resectionPolyData = modelNode.GetPolyData()
# IJK -> RAS
ijkToRasMatrix = vtk.vtkMatrix4x4()
labelMap.GetIJKToRASMatrix(ijkToRasMatrix)
# RAS -> IJK
rasToIjkMatrix = vtk.vtkMatrix4x4()
labelMap.GetRASToIJKMatrix(rasToIjkMatrix)
rasToIjkTransform = vtk.vtkTransform()
rasToIjkTransform.SetMatrix(rasToIjkMatrix)
rasToIjkTransform.Update()
# Transform Resection model from RAS -> IJK
polyDataTransformFilter = vtk.vtkTransformPolyDataFilter()
if (vtk.VTK_MAJOR_VERSION <= 5):
polyDataTransformFilter.SetInput(self.resectionPolyData)
else:
polyDataTransformFilter.SetInputData(self.resectionPolyData)
polyDataTransformFilter.SetTransform(rasToIjkTransform)
polyDataTransformFilter.Update()
# Convert Resection model to label map
polyDataToLabelmapFilter = vtkSlicerRtCommonPython.vtkPolyDataToLabelmapFilter(
)
polyDataToLabelmapFilter.SetInputPolyData(
polyDataTransformFilter.GetOutput())
polyDataToLabelmapFilter.SetReferenceImage(self.labelMapImgData)
polyDataToLabelmapFilter.UseReferenceValuesOn()
polyDataToLabelmapFilter.SetBackgroundValue(0)
polyDataToLabelmapFilter.SetLabelValue(outputValue)
polyDataToLabelmapFilter.Update()
# Cast resection label map to unsigned char for use with mask filter
castFilter = vtk.vtkImageCast()
if (vtk.VTK_MAJOR_VERSION <= 5):
castFilter.SetInput(polyDataToLabelmapFilter.GetOutput())
else:
castFilter.SetInputData(polyDataToLabelmapFilter.GetOutput())
castFilter.SetOutputScalarTypeToUnsignedChar()
castFilter.Update()
# Create mask for recoloring the original label map
maskFilter = vtk.vtkImageMask()
if (vtk.VTK_MAJOR_VERSION <= 5):
maskFilter.SetImageInput(self.labelMapImgData)
maskFilter.SetMaskInput(castFilter.GetOutput())
else:
maskFilter.SetImageInputData(self.labelMapImgData)
maskFilter.SetMaskInputData(castFilter.GetOutput())
maskFilter.SetMaskedOutputValue(outputValue)
maskFilter.NotMaskOn()
maskFilter.Update()
self.labelMapImgData = maskFilter.GetOutput()
self.labelMapImgData.Modified()
labelMap.SetAndObserveImageData(self.labelMapImgData)
def updateRoi(self):
if not self.roiModelNode:
return
numberOfContourPoints = 0
annulusPoints = None
planePosition = None
planeNormal = None
if self.annulusContourCurve:
contourPoints = self.annulusContourCurve.curvePoints # vtk.vtkPoints()
numberOfContourPoints = contourPoints.GetNumberOfPoints()
if numberOfContourPoints > 0:
annulusPoints = self.annulusContourCurve.getInterpolatedPointsAsArray(
) # formerly contourPointsArray_Ras
[planePosition,
planeNormal] = HeartValveLib.planeFit(annulusPoints)
elif self.valveModel is not None and self.leafletSegmentId is not None:
annulusPoints = self.getLeafletBoundary()
if annulusPoints is not None:
numberOfContourPoints = annulusPoints.shape[1]
[planePosition,
planeNormal] = self.valveModel.getAnnulusContourPlane()
if numberOfContourPoints <= 0:
clippingPolyData = vtk.vtkPolyData()
self.roiModelNode.SetAndObservePolyData(clippingPolyData)
self.roiModelNode.Modified()
return
scale = float(self.roiModelNode.GetAttribute(self.PARAM_SCALE)) * 0.01
topDistance = float(
self.roiModelNode.GetAttribute(self.PARAM_TOP_DISTANCE))
topScale = float(self.roiModelNode.GetAttribute(
self.PARAM_TOP_SCALE)) * 0.01
bottomDistance = float(
self.roiModelNode.GetAttribute(self.PARAM_BOTTOM_DISTANCE))
bottomScale = float(
self.roiModelNode.GetAttribute(self.PARAM_BOTTOM_SCALE)) * 0.01
transformPlaneToWorld = vtk.vtkTransform()
transformWorldToPlaneMatrix = HeartValveLib.getTransformToPlane(
planePosition, planeNormal)
numberOfPoints = annulusPoints.shape[1]
# Concatenate a 4th line containing 1s so that we can transform the positions using
# a single matrix multiplication.
annulusPoints_World = np.row_stack(
(annulusPoints, np.ones(numberOfPoints)))
# Point positions in the plane coordinate system:
annulusPoints_Plane = np.dot(transformWorldToPlaneMatrix,
annulusPoints_World)
# remove the last row (all ones)
annulusPoints_Plane = annulusPoints_Plane[0:3, :]
# Add points for middle, top, and bottom planes
clippingSurfacePoints = vtk.vtkPoints()
clippingSurfacePoints.Allocate(
3 * numberOfContourPoints
) # annulus contour + 2x shifted annulus contour
# Middle plane
annulusPoints_Plane[0, :] = (
annulusPoints_Plane[0, :] - annulusPoints_Plane[0, :].mean()
) * scale + annulusPoints_Plane[0, :].mean()
annulusPoints_Plane[1, :] = (
annulusPoints_Plane[1, :] - annulusPoints_Plane[1, :].mean()
) * scale + annulusPoints_Plane[1, :].mean()
for contourPoint in annulusPoints_Plane.T:
clippingSurfacePoints.InsertNextPoint(contourPoint)
meanPosZ = annulusPoints_Plane[:, 2].mean()
# Top plane
contourPointsArrayTop_Ras = np.copy(annulusPoints_Plane)
contourPointsArrayTop_Ras[0, :] = (
contourPointsArrayTop_Ras[0, :] - annulusPoints_Plane[0, :].mean()
) * topScale + annulusPoints_Plane[0, :].mean()
contourPointsArrayTop_Ras[1, :] = (
contourPointsArrayTop_Ras[1, :] - annulusPoints_Plane[1, :].mean()
) * topScale + annulusPoints_Plane[1, :].mean()
contourPointsArrayTop_Ras[2, :] = topDistance # make the plane planar
for contourPoint in contourPointsArrayTop_Ras.T:
clippingSurfacePoints.InsertNextPoint(contourPoint)
# Bottom plane
contourPointsArrayBottom_Ras = np.copy(annulusPoints_Plane)
contourPointsArrayBottom_Ras[
0, :] = (contourPointsArrayBottom_Ras[0, :] - annulusPoints_Plane[
0, :].mean()) * bottomScale + annulusPoints_Plane[0, :].mean()
contourPointsArrayBottom_Ras[
1, :] = (contourPointsArrayBottom_Ras[1, :] - annulusPoints_Plane[
1, :].mean()) * bottomScale + annulusPoints_Plane[1, :].mean()
contourPointsArrayBottom_Ras[
2, :] = -bottomDistance # make the plane planar
for contourPoint in contourPointsArrayBottom_Ras.T:
clippingSurfacePoints.InsertNextPoint(contourPoint)
# Add frustum surfaces
strips = vtk.vtkCellArray()
# Between middle and top
strips.InsertNextCell(numberOfContourPoints * 2 + 2)
firstTopPointIndex = numberOfContourPoints
for i in range(numberOfContourPoints):
strips.InsertCellPoint(i)
strips.InsertCellPoint(i + firstTopPointIndex)
strips.InsertCellPoint(0)
strips.InsertCellPoint(firstTopPointIndex)
# Between middle and bottom
strips.InsertNextCell(numberOfContourPoints * 2 + 2)
firstBottomPointIndex = numberOfContourPoints * 2
for i in range(numberOfContourPoints):
strips.InsertCellPoint(i)
strips.InsertCellPoint(i + firstBottomPointIndex)
strips.InsertCellPoint(0)
strips.InsertCellPoint(firstBottomPointIndex)
# Top and bottom caps
polys = vtk.vtkCellArray()
polys.InsertNextCell(numberOfContourPoints)
for i in range(numberOfContourPoints, numberOfContourPoints * 2):
polys.InsertCellPoint(i)
polys.InsertNextCell(numberOfContourPoints)
for i in range(numberOfContourPoints * 2, numberOfContourPoints * 3):
polys.InsertCellPoint(i)
clippingSurfacePolyData = vtk.vtkPolyData()
clippingSurfacePolyData.SetPoints(clippingSurfacePoints)
clippingSurfacePolyData.SetStrips(strips)
clippingSurfacePolyData.SetPolys(polys)
triangulator = vtk.vtkTriangleFilter()
triangulator.SetInputData(clippingSurfacePolyData)
transformPlaneToWorldMatrix = np.linalg.inv(
transformWorldToPlaneMatrix)
transformPlaneToWorldMatrixVtk = vtk.vtkMatrix4x4()
for colIndex in range(4):
for rowIndex in range(3):
transformPlaneToWorldMatrixVtk.SetElement(
rowIndex, colIndex, transformPlaneToWorldMatrix[rowIndex,
colIndex])
transformPlaneToWorld.SetMatrix(transformPlaneToWorldMatrixVtk)
polyTransformToWorld = vtk.vtkTransformPolyDataFilter()
polyTransformToWorld.SetTransform(transformPlaneToWorld)
polyTransformToWorld.SetInputConnection(triangulator.GetOutputPort())
polyTransformToWorld.Update()
clippingPolyData = polyTransformToWorld.GetOutput()
self.roiModelNode.SetAndObservePolyData(clippingPolyData)
self.roiModelNode.Modified()
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 run( self, markupNode, depth, fitPlane, flip ):
"""
Run the actual algorithm
"""
# Get all of the fiducial nodes and convert to vtkPoints
points = vtk.vtkPoints()
for i in range( 0, markupNode.GetNumberOfFiducials() ):
currentCoordinates = [ 0, 0, 0 ]
markupNode.GetNthFiducialPosition( i, currentCoordinates )
points.InsertNextPoint( currentCoordinates )
# Check that there is non-zero range in all coordinate directions
pointsBounds = [ 0, 0, 0, 0, 0, 0 ]
points.GetBounds( pointsBounds )
if ( pointsBounds[0] == pointsBounds [1] or pointsBounds[2] == pointsBounds [3] or pointsBounds[4] == pointsBounds [5] ):
print "Tissue Model Creator: Points have no extent in one or more coordinate directions."
return False
# Create a polydata object from the points
# The reversiness doesn't matter - we will fix it later if it os wrong
if ( fitPlane ):
surfacePolyData = self.PointsToPlanePolyData( points, True )
else:
surfacePolyData = self.PointsToSurfacePolyData( points, True )
surfaceCleaner = vtk.vtkCleanPolyData()
surfaceCleaner.SetInputData( surfacePolyData )
surfaceCleaner.Update()
surfacePolyData = surfaceCleaner.GetOutput()
mean = self.CalculateMean( points )
surfaceBase = [ 0, 0, 0 ]
surfaceDir1 = [ 0, 0, 0 ]
surfaceDir2 = [ 0, 0, 0 ]
surfaceNormal = [ 0, 0, 0 ]
self.CalculatePlane( surfacePolyData.GetPoints(), surfaceBase, surfaceDir1, surfaceDir2, surfaceNormal )
if ( flip == True ):
surfaceNormal[ 0 ] = - surfaceNormal[ 0 ]
surfaceNormal[ 1 ] = - surfaceNormal[ 1 ]
surfaceNormal[ 2 ] = - surfaceNormal[ 2 ]
extremePointIndex = self.FindExtremePoint( surfacePolyData.GetPoints(), surfaceBase, surfaceNormal )
reverse = self.ReverseNormals( extremePointIndex, surfacePolyData, surfaceNormal )
# Reverse the normals if necessary
reverseFilter = vtk.vtkReverseSense()
reverseFilter.SetInputData( surfacePolyData )
reverseFilter.SetReverseCells( reverse )
reverseFilter.SetReverseNormals( reverse )
reverseFilter.Update()
surfacePolyData = reverseFilter.GetOutput()
untransDeepPolyData = vtk.vtkPolyData()
untransDeepPolyData.DeepCopy( surfacePolyData )
# Make the normals opposite the surface's normals
reverseFilter = vtk.vtkReverseSense()
reverseFilter.SetInputData( untransDeepPolyData )
reverseFilter.SetReverseCells( True )
reverseFilter.SetReverseNormals( True )
reverseFilter.Update()
untransDeepPolyData = reverseFilter.GetOutput()
deepTransform = vtk.vtkTransform()
deepTransform.Translate( depth * surfaceNormal[0], depth * surfaceNormal[1], depth * surfaceNormal[2] )
deepTransformFilter = vtk.vtkTransformPolyDataFilter()
deepTransformFilter.SetInputData( untransDeepPolyData )
deepTransformFilter.SetTransform( deepTransform )
deepTransformFilter.Update()
deepPolyData = deepTransformFilter.GetOutput()
surfaceHullPoints = self.GetBoundaryPoints( surfacePolyData )
deepHullPoints = self.GetBoundaryPoints( deepPolyData )
# Apparently, the joining needs an offset for the plane, but not for the surface reconstruction
if ( fitPlane ):
jointHullPolyData = self.JoinBoundaryPoints( surfaceHullPoints, deepHullPoints, 1 )
else:
jointHullPolyData = self.JoinBoundaryPoints( surfaceHullPoints, deepHullPoints, 0 )
# Append all of the polydata together
tissuePolyDataAppend = vtk.vtkAppendPolyData()
tissuePolyDataAppend.AddInputData( surfacePolyData )
tissuePolyDataAppend.AddInputData( deepPolyData )
tissuePolyDataAppend.AddInputData( jointHullPolyData )
tissuePolyDataAppend.Update()
# Clean up so the surface is closed
tissueCleaner = vtk.vtkCleanPolyData()
tissueCleaner.SetInputData( tissuePolyDataAppend.GetOutput() )
tissueCleaner.Update()
tissueModelPolyData = tissueCleaner.GetOutput()
# Add the data to a model
tissueModel = slicer.mrmlScene.CreateNodeByClass( "vtkMRMLModelNode" )
slicer.mrmlScene.AddNode( tissueModel )
tissueModel.SetName( "TissueModel" )
tissueModel.SetAndObservePolyData( tissueModelPolyData )
tissueModel.SetScene( slicer.mrmlScene )
# Finally display the model
tissueModelDisplay = slicer.mrmlScene.CreateNodeByClass( "vtkMRMLModelDisplayNode" )
slicer.mrmlScene.AddNode( tissueModelDisplay )
tissueModel.SetAndObserveDisplayNodeID( tissueModelDisplay.GetID() )
tissueModelDisplay.SetScene( slicer.mrmlScene )
tissueModelDisplay.SetInputPolyDataConnection( tissueModel.GetPolyDataConnection() )
# Check to make sure the model is a closed surface
edgesFilter = vtk.vtkFeatureEdges()
edgesFilter.FeatureEdgesOff()
edgesFilter.BoundaryEdgesOn()
edgesFilter.NonManifoldEdgesOn()
edgesFilter.SetInputData( tissueModel.GetPolyData() )
edgesFilter.Update()
if ( edgesFilter.GetOutput().GetNumberOfCells() != 0 ):
print "Tissue Model Creator: Surface is not closed."
return False
return True
def onApplyButton(self):
""" Aply the Surface ICP Registration """
print("Run the algorithm")
fixed = self.modelSelectors['Fixed Surface Volume'].currentNode()
moving = self.modelSelectors['Moving Surface Volume'].currentNode()
outputSurf = self.modelOutputSurfaceSelectors[
'Output Surface Volume'].currentNode()
initialTrans = self.volumeInitialTransformSelectors[
"Initial Transform"].currentNode()
outputTrans = self.volumeOutputTransformSelectors[
"Output Transform"].currentNode()
inputPolyData = moving.GetPolyData()
if initialTrans:
print "Applying initial transform"
initialMatrix = initialTrans.GetMatrixTransformToParent()
transform = vtk.vtkTransform()
transform.SetMatrix(initialMatrix)
transformFilter = vtk.vtkTransformPolyDataFilter()
transformFilter.SetInput(inputPolyData)
transformFilter.SetTransform(transform)
transformFilter.Update()
inputPolyData = transformFilter.GetOutput()
self.icp.SetSource(inputPolyData)
self.icp.SetTarget(fixed.GetPolyData())
print self.icpLandmarkTransformType
if self.icpLandmarkTransformType == "RigidBody":
print self.icpLandmarkTransformType
self.icp.GetLandmarkTransform().SetModeToRigidBody()
elif self.icpLandmarkTransformType == "Similarity":
print self.icpLandmarkTransformType
self.icp.GetLandmarkTransform().SetModeToSimilarity()
print self.icpLandmarkTransformType
elif self.icpLandmarkTransformType == "Affine":
self.icp.GetLandmarkTransform().SetModeToAffine()
self.icp.SetMaximumNumberOfIterations(
self.numberOfIterationsValueChanged)
self.icp.SetMaximumMeanDistance(self.maxDistanceValueChanged)
self.icp.SetMaximumNumberOfLandmarks(
self.numberOfLandmarksValueChanged)
self.icp.SetCheckMeanDistance(int(self.checkMeanDistanceActive))
self.icp.SetStartByMatchingCentroids(
int(self.matchCentroidsLinearActive))
#self.icp.Update
print self.icp.GetLandmarkTransform()
outputMatrix = vtk.vtkMatrix4x4()
self.icp.GetMatrix(outputMatrix)
outputTrans.SetAndObserveMatrixTransformToParent(outputMatrix)
outputPolyData = vtk.vtkPolyData()
outputPolyData.DeepCopy(inputPolyData)
outputSurf.SetAndObservePolyData(outputPolyData)
print self.icp.GetLandmarkTransform()
print self.icp.GetLandmarkTransform().GetSourceLandmarks()
print self.icp.GetLandmarkTransform().GetTargetLandmarks()
print self.icp.GetMaximumMeanDistance()
print self.icp.GetMeanDistanceModeAsString()
print self.icp.GetMaximumNumberOfIterations()
print self.icp.GetMaximumNumberOfLandmarks()
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 __init__(self, modelNode):
self.modelNode = modelNode
self.toolTipToTool = None
self.toolToReference = None
self.modelTransform = None
self.transformedModel = slicer.util.getNode('Transformed Model')
if not self.transformedModel:
self.transformedModel = slicer.vtkMRMLModelNode()
self.transformedModel.SetName('Transformed Model')
self.transformedModel.SetAndObservePolyData(self.modelNode.GetPolyData())
modelDisplay = slicer.vtkMRMLModelDisplayNode()
modelDisplay.SetSliceIntersectionVisibility(True)
modelDisplay.SetColor(0,1,0)
slicer.mrmlScene.AddNode(modelDisplay)
self.transformedModel.SetAndObserveDisplayNodeID(modelDisplay.GetID())
slicer.mrmlScene.AddNode(self.transformedModel)
self.transformedModel.SetDisplayVisibility(False)
self.closestFiducial = slicer.util.getNode('CP')
if not self.closestFiducial:
self.closestFiducial = slicer.vtkMRMLMarkupsFiducialNode()
self.closestFiducial.SetName('CP')
self.closestFiducial.AddFiducial(0, 0, 0)
self.closestFiducial.SetNthFiducialLabel(0, '')
slicer.mrmlScene.AddNode(self.closestFiducial)
self.closestFiducial.SetDisplayVisibility(False)
self.closestFiducial.GetDisplayNode().SetGlyphScale(3.0)
self.closestFiducial.GetDisplayNode().SetGlyphType(4) # ThickCross2D
self.closestFiducial.GetDisplayNode().SetSelectedColor(0,0,1)
self.tipFiducial = slicer.util.getNode('Tip')
if not self.tipFiducial:
self.tipFiducial = slicer.vtkMRMLMarkupsFiducialNode()
self.tipFiducial.SetName('Tip')
self.tipFiducial.AddFiducial(0, 0, 0)
self.tipFiducial.SetNthFiducialLabel(0, '')
slicer.mrmlScene.AddNode(self.tipFiducial)
self.tipFiducial.SetDisplayVisibility(True)
self.tipFiducial.GetDisplayNode().SetGlyphType(1) # Vertex2D
self.tipFiducial.GetDisplayNode().SetTextScale(1.3)
self.tipFiducial.GetDisplayNode().SetSelectedColor(1,1,1)
self.line = slicer.util.getNode('Line')
if not self.line:
self.line = slicer.vtkMRMLModelNode()
self.line.SetName('Line')
linePolyData = vtk.vtkPolyData()
self.line.SetAndObservePolyData(linePolyData)
modelDisplay = slicer.vtkMRMLModelDisplayNode()
modelDisplay.SetSliceIntersectionVisibility(True)
modelDisplay.SetColor(0,1,0)
slicer.mrmlScene.AddNode(modelDisplay)
self.line.SetAndObserveDisplayNodeID(modelDisplay.GetID())
slicer.mrmlScene.AddNode(self.line)
# VTK objects
self.transformPolyDataFilter = vtk.vtkTransformPolyDataFilter()
self.cellLocator = vtk.vtkCellLocator()
# 3D View
threeDWidget = slicer.app.layoutManager().threeDWidget(0)
self.threeDView = threeDWidget.threeDView()
self.callbackObserverTag = -1
def IterativeClosestPoint(self, source, target, reference=[]):
# Iterative closest point surface registration
icp = vtk.vtkIterativeClosestPointTransform()
try:
icp.SetSource(source.GetPolyData())
icp.SetTarget(target.GetPolyData())
except:
icp.SetSource(source)
icp.SetTarget(target)
if self.icp_mode == 'Rigid':
icp.GetLandmarkTransform().SetModeToRigidBody()
elif self.icp_mode == 'Similarity':
icp.GetLandmarkTransform().SetModeToSimilarity()
elif self.icp_mode == 'Affine':
icp.GetLandmarkTransform().SetModeToAffine()
# icp.DebugOn()
icp.SetMaximumNumberOfIterations(int(self.IterationNumber))
icp.SetMaximumNumberOfLandmarks(int(self.LandmarkNumber))
icp.SetMaximumMeanDistance(
self.RMS_Number
) # A small number would use the maximum number of iterations
icp.StartByMatchingCentroidsOn()
# RMS mode is the square root of the average of the sum of squares of the closest point distances
icp.SetMeanDistanceModeToRMS()
icp.Modified()
icp.Update()
# Apply the resulting transform to the vtk poly data
icpTransformFilter = vtk.vtkTransformPolyDataFilter()
try:
icpTransformFilter.SetInputData(source.GetPolyData())
except:
icpTransformFilter.SetInputData(source)
icpTransformFilter.SetTransform(icp)
icpTransformFilter.Update()
# Update the source object with the transformed object
transformedSource = icpTransformFilter.GetOutput()
# If there is a reference surface apply the ICP transform to it
if reference != []:
# Apply the resulting transform also to the reference surface vtk poly data
icpTransformFilter = vtk.vtkTransformPolyDataFilter()
try:
icpTransformFilter.SetInputData(reference.GetPolyData())
except:
icpTransformFilter.SetInputData(reference)
icpTransformFilter.SetTransform(icp)
icpTransformFilter.Update()
# Update the source object with the transformed object
transformedReference = icpTransformFilter.GetOutput()
# Is there is a referece surface return that instead
return transformedReference
else:
# If there in NOT a reference surface, return the registered source
return transformedSource
def PolyDataToImageData(self,
inputPolydata_Ras,
referenceVolumeNode_Ras,
inVal=100,
outVal=0):
""" We take in an polydata and convert it to an new image data , withing the Reference Voulume node
the reference volume node is cleared with a threshold because originally the volume may contain
alot of noisy pixels
PARAM: inputPolydata_Ras: Polydata we are looking to conver vtkPolydata()
PARAM: refernceVolumeNode_Ras vtkMRMLScalarVolumeNode()
RETURN : vtkImageData
"""
""" Transform the polydata from ras to ijk using the referenceVolumeNode """
#inputPolydataTriangulated_Ijk=polyToImage.GetOutput()
transformPolydataFilter = vtk.vtkTransformPolyDataFilter()
rasToIjkMatrix = vtk.vtkMatrix4x4()
referenceVolumeNode_Ras.GetRASToIJKMatrix(rasToIjkMatrix)
rasToIjkTransform = vtk.vtkTransform()
rasToIjkTransform.SetMatrix(rasToIjkMatrix)
transformPolydataFilter.SetTransform(rasToIjkTransform)
transformPolydataFilter.SetInputData(inputPolydata_Ras)
transformPolydataFilter.Update()
inputPolydata_Ijk = transformPolydataFilter.GetOutput()
normalsFunction = vtk.vtkPolyDataNormals()
normalsFunction.SetInputData(inputPolydata_Ijk)
normalsFunction.ConsistencyOn()
trigFilter = vtk.vtkTriangleFilter()
trigFilter.SetInputConnection(normalsFunction.GetOutputPort())
stripper = vtk.vtkStripper()
stripper.SetInputConnection(trigFilter.GetOutputPort())
stripper.Update()
inputPolydataTriangulated_Ijk = stripper.GetOutput()
# Clone reference image and clear it
referenceImage_Ijk = referenceVolumeNode_Ras.GetImageData()
# Fill image with outVal (there is no volume Fill filter in VTK, therefore we need to use threshold filter)
thresh = vtk.vtkImageThreshold()
thresh.ReplaceInOn()
thresh.ReplaceOutOn()
thresh.SetInValue(outVal)
thresh.SetOutValue(outVal)
#thresh.SetOutputScalarType (vtk.VTK_UNSIGNED_CHAR)
thresh.SetInputData(referenceImage_Ijk)
thresh.Update()
whiteImage_Ijk = thresh.GetOutput()
# Convert polydata to stencil
polyToImage = vtk.vtkPolyDataToImageStencil()
polyToImage.SetInputData(inputPolydataTriangulated_Ijk)
polyToImage.SetOutputSpacing(whiteImage_Ijk.GetSpacing())
polyToImage.SetOutputOrigin(whiteImage_Ijk.GetOrigin())
polyToImage.SetOutputWholeExtent(whiteImage_Ijk.GetExtent())
polyToImage.Update()
imageStencil_Ijk = polyToImage.GetOutput()
# Convert stencil to image
imgstenc = vtk.vtkImageStencil()
imgstenc.SetInputData(whiteImage_Ijk)
imgstenc.SetStencilData(imageStencil_Ijk)
imgstenc.ReverseStencilOn()
imgstenc.SetBackgroundValue(inVal)
imgstenc.Update()
return imgstenc.GetOutput()
