def resetVariables(self):
self.models_path = slicer.modules.arhealth.path.replace("ARHealth.py", "") + "Resources/Models/"
self.models = dict()
# Mode
self.selected_mode = 1
# Center Model Transform
slicer.mrmlScene.RemoveNode(self.centerModelsTransform)
self.centerModelsTransform = slicer.vtkMRMLLinearTransformNode()
self.centerModelsTransform.SetName("centerModelsTransform")
slicer.mrmlScene.AddNode(self.centerModelsTransform)
# Base height
self.baseHeightMode_val = 10
# Scaling
slicer.mrmlScene.RemoveNode(self.scaleTransform)
self.scaleTransform = slicer.vtkMRMLLinearTransformNode()
self.scaleTransform.SetName("scaleTransform")
slicer.mrmlScene.AddNode(self.scaleTransform)
self.scaleVal = 100.0
# Translation
slicer.mrmlScene.RemoveNode(self.translationTransform)
self.translationTransform = slicer.vtkMRMLLinearTransformNode()
self.translationTransform.SetName("translationTransform")
slicer.mrmlScene.AddNode(self.translationTransform)
self.translation_PA = 0.0
self.translation_LR = 0.0
self.translation_IS = 0.0
# Rotation
slicer.mrmlScene.RemoveNode(self.rotationTransform)
self.rotationTransform = slicer.vtkMRMLLinearTransformNode()
self.rotationTransform.SetName("rotationTransform")
slicer.mrmlScene.AddNode(self.rotationTransform)
self.rotation_LR = 0.0
self.rotation_PA = 0.0
self.rotation_IS = 0.0
# Positioning Transform
slicer.mrmlScene.RemoveNode(self.positioningTransform)
self.positioningTransform = slicer.vtkMRMLLinearTransformNode()
self.positioningTransform.SetName("positioningTransform")
slicer.mrmlScene.AddNode(self.positioningTransform)
# Color code
self.color_code_i = 0
def onConnectButtonClicked(self):
# Creates a connector Node
if self.connectorNode is None:
if self.connectCheck == 1:
if self.imageNode or self.transformNode is None:
if self.imageNode is None:
print('Please select an US volume')
if self.trandformNode is None:
print('Please select the tip to probe transform')
if self.imageNode is not None and self.transformNode is not None:
if self.fiducialNode is not None:
self.fiducialNode.RemoveAllMarkups()
self.numFid = self.numFid+1
self.numFidLabel.setText(str(self.numFid))
self.manualOutputRegistrationTransformNode = slicer.vtkMRMLLinearTransformNode()
slicer.mrmlScene.AddNode(self.manualOutputRegistrationTransformNode)
self.manualOutputRegistrationTransformNode.SetName('ImageToProbeMan')
slicer.modules.markups.logic().StartPlaceMode(0)
slicer.app.layoutManager().sliceWidget('Red').setCursor(qt.QCursor(2))
else:
self.connectorNode = slicer.vtkMRMLIGTLConnectorNode()
# Adds this node to the scene, not there is no need for self here as it is its own node
slicer.mrmlScene.AddNode(self.connectorNode)
# Configures the connector
self.connectorNode.SetTypeClient(self.inputIPLineEdit.text, int(self.inputPortLineEdit.text))
self.connectorNode.Start()
else:
if self.connectorNode.GetState() == 2:
# Connected
self.connectorNode.Stop()
self.connectButton.text = "Connect"
self.freezeButton.text = "Unfreeze"
if self.imageSelector.currentNode() or self.TransformSelector.currentNode() is None:
if self.imageNode is None:
print('Please select an US volume')
if self.transformNode is None:
print('Please select the tip to probe transform')
if self.imageNode is not None and self.transformNode is not None:
self.numFid = self.numFid + 1
self.numFidLabel.setText(str(self.numFid))
self.manualOutputRegistrationTransformNode = slicer.vtkMRMLLinearTransformNode()
slicer.mrmlScene.AddNode(self.manualOutputRegistrationTransformNode)
self.manualOutputRegistrationTransformNode.SetName('ImageToProbeMan')
slicer.modules.markups.logic().StartPlaceMode(0)
slicer.app.layoutManager().sliceWidget('Red').setCursor(qt.QCursor(2))
else:
# This starts the connection
self.connectorNode.Start()
self.connectButton.text = "Disconnect"
self.freezeButton.text = "Freeze"
if self.fiducialNode is not None:
self.fiducialNode.RemoveAllMarkups()
def __init__(self):
# Variable Definition
self.m = vtk.vtkMatrix4x4() # 4x4 VTK matrix to save the transformation matrix sent through Plus.
self.transform=numpy.zeros((3,3), dtype=numpy.float64) # Numpy matrix used as input for the transformation decomposition.
self.observedNode = None
self.outputObserverTag = -1
self.record = False
self.timerActive=False
self.recordingTime_mode1=10 # 5 seconds to record initial position
self.recordingTime_mode2=10 # 5 seconds to record initial position
self.mode=0
self.myTimer=Timer()
self.recordedDataBuffer = []
self.processedRotation =[]
self.name = '' # To save data
self.prename = '' #To save data
self.alarmCounter = 0
self.rotationMatrix=list()
self.rotationMatrices=list()
# Variables to control the repetition number of each movement.
self.repIDflexoext=0
self.repIDflexlat=0
self.repIDrotation=0
# Arrays to save measured data.
self.timeStamp=numpy.array([])
# Defines Alarm file path and mode
self.sound = qt.QSound('G:/ModulesSlicer/src/AlgiaCervical/Resources/Alarm/alarm.wav')
self.sound.setLoops(1)
# Labels for Data Visualization
self.outputROMLabel = None
self.outputMaxVariabilityLabel = None
self.outputMinVariabilityLabel = None
import Viewpoint # Viewpoint Module must have been added to Slicer
self.viewpointLogic = Viewpoint.ViewpointLogic()
# Transform matrix of viewpoint in order to center head model in 3D view
self.headCameraToHead = slicer.util.getNode('headCameraToHead')
if not self.headCameraToHead:
self.headCameraToHead=slicer.vtkMRMLLinearTransformNode()
self.headCameraToHead.SetName("headCameraToHead")
matrixHeadCamera = vtk.vtkMatrix4x4()
matrixHeadCamera.SetElement( 0, 0, 1.0 ) # Row 1
matrixHeadCamera.SetElement( 0, 1, 0.05 )
matrixHeadCamera.SetElement( 0, 2, 0.01 )
matrixHeadCamera.SetElement( 0, 3, 9.42 )
matrixHeadCamera.SetElement( 1, 0, 0.0 ) # Row 2
matrixHeadCamera.SetElement( 1, 1, 0.28 )
matrixHeadCamera.SetElement( 1, 2, -0.96 )
matrixHeadCamera.SetElement( 1, 3, -252.69 )
matrixHeadCamera.SetElement( 2, 0, -0.05 ) # Row 3
matrixHeadCamera.SetElement( 2, 1, 0.96 )
matrixHeadCamera.SetElement( 2, 2, 0.28 )
matrixHeadCamera.SetElement( 2, 3, 122.39 )
self.headCameraToHead.SetMatrixTransformToParent(matrixHeadCamera)
slicer.mrmlScene.AddNode(self.headCameraToHead)
def alignSegments(self):
# Rotation
self.alignmentTransform = slicer.vtkMRMLLinearTransformNode()
self.alignmentTransform.SetName("alignmentTransform")
slicer.mrmlScene.AddNode(self.alignmentTransform)
# Create transformation matrix
rotMatrix = vtk.vtkTransform()
rotMatrix.RotateZ(-180.0)
self.alignmentTransform.SetMatrixTransformToParent(
rotMatrix.GetMatrix())
# Build transform tree
self.segment2.SetAndObserveTransformNodeID(
self.alignmentTransform.GetID())
# Harden transform
self.segment2.HardenTransform()
# Delete transform from scene
slicer.mrmlScene.RemoveNode(self.alignmentTransform)
# Center 3D view
layoutManager = slicer.app.layoutManager()
threeDWidget = layoutManager.threeDWidget(0)
threeDView = threeDWidget.threeDView()
threeDView.resetFocalPoint()
def onVisualizeButtonClicked(self):
if self.fiducialNode is not None:
self.fiducialNode.RemoveAllMarkups()
if self.isVisualizing:
slicer.app.layoutManager().setLayout(
slicer.vtkMRMLLayoutNode.SlicerLayoutOneUpRedSliceView)
self.isVisualizing = False
self.visualizeButton.text = 'Show 3D Scene'
self.manualOutputRegistrationTransformNode.SetMatrixTransformToParent(
None)
else:
self.isVisualizing = True
slicer.app.layoutManager().sliceWidget(
'Red').sliceLogic().GetSliceNode().SetSliceVisible(True)
slicer.app.layoutManager().setLayout(
slicer.vtkMRMLLayoutNode.SlicerLayoutOneUp3DView)
self.visualizeButton.text = 'Show ultrasound stream'
if self.transformNode is None:
print('Please select an US volume')
else:
if self.manualOutputRegistrationTransformNode is None:
self.manualOutputRegistrationTransformNode = slicer.vtkMRMLLinearTransformNode(
)
slicer.mrmlScene.AddNode(
self.manualOutputRegistrationTransformNode)
self.manualOutputRegistrationTransformNode.SetName(
'ImageToProbeMan')
self.imageNode.SetAndObserveTransformNodeID(
self.manualOutputRegistrationTransformNode.GetID())
self.manualOutputRegistrationTransformNode.SetMatrixTransformToParent(
self.ImageToProbeMan)
def rigidReg(fixedImg, movingImg, outTfm, outImg=None, initTfm=None):
'''Rigid registration using BRAINS Registration
fixedImg: full path to the fixed image;
movingImg: full path to the moving image;
outImg: full path to the output co-registered image;
outTfm: full path to the output transform file (.tfm).
'''
slicer.mrmlScene.Clear(0)
fixed = slicer.util.loadVolume(fixedImg)
moving = slicer.util.loadVolume(movingImg)
cliModule = slicer.modules.brainsfit
p = {}
p['fixedVolume'] = fixed.GetID()
p['movingVolume'] = moving.GetID()
outVolume = slicer.vtkMRMLScalarVolumeNode()
slicer.mrmlScene.AddNode(outVolume)
p['outputVolume'] = outVolume.GetID()
p['transformType'] = 'Rigid'
tfm = slicer.vtkMRMLLinearTransformNode()
slicer.mrmlScene.AddNode(tfm)
p['outputTransform'] = tfm.GetID()
if initTfm:
_tfm = slicer.util.loadTransform(initTfm)
p['initialTransform'] = _tfm.GetID()
slicer.cli.run(cliModule, None, p, wait_for_completion=True)
result = {}
if outImg:
state1 = slicer.util.saveNode(outVolume, outImg)
result.update({outImg: state1})
state2 = slicer.util.saveNode(tfm, outTfm)
result.update({outTfm: state2})
slicer.mrmlScene.Clear(0)
return result
def copyAndHardenModel(self,originalModel):
# copy model
outputModel = slicer.vtkMRMLModelNode()
fullPolyData = originalModel.GetPolyData()
outputModel.SetAndObservePolyData(fullPolyData)
md2 = slicer.vtkMRMLModelDisplayNode()
slicer.mrmlScene.AddNode(outputModel)
slicer.mrmlScene.AddNode(md2)
outputModel.SetAndObserveDisplayNodeID(md2.GetID())
md2.SetVisibility(0)
# apply transforms tree to copied model
parent_transform = originalModel.GetParentTransformNode()
try:
t = slicer.util.getNode('DefinedTransform')
identityTransform = vtk.vtkMatrix4x4()
t.SetMatrixTransformToParent(identityTransform)
except:
t=slicer.vtkMRMLLinearTransformNode()
t.SetName('DefinedTransform')
slicer.mrmlScene.AddNode(t)
t.SetAndObserveTransformNodeID(parent_transform.GetID())
t.HardenTransform()
outputModel.SetAndObserveTransformNodeID(t.GetID())
outputModel.HardenTransform()
return outputModel,t
def save_electrode_properties(self, electrode):
"""
Save electrode properties to model attributes.
Args:
electrode (vtkMRMLModelNode): Electrode to save properties of.
"""
if not self.switching_electrodes:
# Save its full transform
electrode_transform = slicer.vtkMRMLLinearTransformNode()
trans = vtk.vtkMatrix4x4()
# create an inverse
electrode_transform.GetMatrixTransformFromNode(
slicer.util.getNode("Arc"), trans)
electrode_transform = slicer.util.getNode("Transform_" +
electrode.GetName())
electrode_transform.SetMatrixTransformToParent(trans)
# save specific values
electrode.SetAttribute("X", str(self.x_origin_widget.value))
electrode.SetAttribute("Y", str(self.y_origin_widget.value))
electrode.SetAttribute("Z", str(self.z_origin_widget.value))
electrode.SetAttribute("Arc", str(self.arc_angle_widget.value))
electrode.SetAttribute("Collar",
str(self.collar_angle_widget.value))
entry_point = np.array([0.0, 0.0, 0.0])
self.targs.GetNthFiducialPosition(1, entry_point)
electrode.SetAttribute("Entry", str(list(entry_point)))
def initializeLinearTransformNode(self, name):
logging.debug('initializeLinearTransformNode')
transformNode = slicer.mrmlScene.GetFirstNodeByName(name)
if not transformNode:
transformNode = slicer.vtkMRMLLinearTransformNode()
transformNode.SetName(name)
slicer.mrmlScene.AddNode(transformNode)
return transformNode
def setHeadModelVisualization(self, RigidBodyToTrackerTransform, HeadModel):
# From matrix to transform node
headToRigidBodyTransform=slicer.vtkMRMLLinearTransformNode()
headToRigidBodyTransform.SetName("headToRigidBodyTransform")
headToRigidBodyTransform.SetMatrixTransformToParent(self.headToRigidBodyTransformMatrix)
slicer.mrmlScene.AddNode(headToRigidBodyTransform)
# Build transform tree
HeadModel.SetAndObserveTransformNodeID(headToRigidBodyTransform.GetID())
headToRigidBodyTransform.SetAndObserveTransformNodeID(RigidBodyToTrackerTransform.GetID())
def getLastApprovedRigidTransformation(self):
if sum([1 for result in self._registrationResults.values() if result.approved]) == 1:
lastRigidTfm = None
else:
lastRigidTfm = self.getMostRecentApprovedResult().rigidTransform
if not lastRigidTfm:
lastRigidTfm = slicer.vtkMRMLLinearTransformNode()
slicer.mrmlScene.AddNode(lastRigidTfm)
return lastRigidTfm
def getLastApprovedRigidTransformation(self):
if sum([1 for result in self.registrationResults.values() if result.approved]) == 1:
lastRigidTfm = None
else:
lastRigidTfm = self.getMostRecentApprovedResult().transforms.rigid
if not lastRigidTfm:
lastRigidTfm = slicer.vtkMRMLLinearTransformNode()
slicer.mrmlScene.AddNode(lastRigidTfm)
return lastRigidTfm
def onFiducialClicked(self):
if self.fiducialNode is not None:
self.fiducialNode.RemoveAllMarkups()
self.numFid = self.numFid + 1
self.numFidLabel.setText(str(self.numFid))
self.OutputRegistrationTransformNode = slicer.vtkMRMLLinearTransformNode()
slicer.mrmlScene.AddNode(self.OutputRegistrationTransformNode)
self.OutputRegistrationTransformNode.SetName('ImageToProbe')
slicer.modules.markups.logic().StartPlaceMode(0)
slicer.app.layoutManager().sliceWidget('Red').setCursor(qt.QCursor(2))
def _setTransform(self):
if self.inputVolume:
seriesNumber = self.inputVolume.GetName().split(":")[0]
name = seriesNumber + "-ZFrameTransform"
if self.outputTransform:
self.mrmlScene.RemoveNode(self.outputTransform)
self.outputTransform = None
self.outputTransform = slicer.vtkMRMLLinearTransformNode()
self.outputTransform.SetName(name)
self.mrmlScene.AddNode(self.outputTransform)
def __init__(self):
self.camera = slicer.util.getNode('Default Scene Camera')
self.transform = slicer.vtkMRMLLinearTransformNode()
slicer.mrmlScene.AddNode(self.transform)
self.camera.SetAndObserveTransformNodeID(self.transform.GetID())
self.vtkcam = self.camera.GetCamera()
self.matrix = vtk.vtkTransform()
self.degrees = 1
self.rotateX = True
self.rotateY = True
self.rotateZ = True
def __init__(self):
self.camera = slicer.util.getNode('Default Scene Camera')
self.transform = slicer.vtkMRMLLinearTransformNode()
slicer.mrmlScene.AddNode(self.transform)
self.camera.SetAndObserveTransformNodeID(self.transform.GetID())
self.vtkcam = self.camera.GetCamera()
self.matrix = vtk.vtkTransform()
self.degrees = 1
self.rotateX = True
self.rotateY = True
self.rotateZ = True
def onInputTransformSelect(self):
self.TipTransform = slicer.vtkMRMLLinearTransformNode()
newName = self.inputtransformSelector.currentNode().GetName().rstrip(
'ToReference')
self.TipTransform.SetName(newName + 'TipTo' + newName)
slicer.mrmlScene.AddNode(self.TipTransform)
self.outputtransformSelector.setCurrentNodeID(
self.TipTransform.GetID())
self.inputSelector.currentNode().SetAndObserveTransformNodeID(
self.TipTransform.GetID())
self.TipTransform.SetAndObserveTransformNodeID(
self.inputtransformSelector.currentNode().GetID())
def onVisualizeButtonClicked(self):
self.clippingModel.SetDisplayVisibility(False)
if self.imageNode or self.imageNode2 or self.transformNode is None:
if self.imageNode is None:
print('Please select the left image')
if self.imageNode2 is None:
print('Please select the right image')
if self.transformNode is None:
print('Please select a tip to probe transform')
if self.imageNode and self.imageNode2 and self.transformNode is not None:
self.OutputRegistrationTransformNode = slicer.vtkMRMLLinearTransformNode()
self.OutputRegistrationTransformNodeX = slicer.vtkMRMLLinearTransformNode()
slicer.mrmlScene.AddNode(self.OutputRegistrationTransformNode)
slicer.mrmlScene.AddNode(self.OutputRegistrationTransformNodeX)
self.OutputRegistrationTransformNode.SetName('ImageToProbe')
self.OutputRegistrationTransformNodeX.SetName('ImageToProbeX')
if self.fiducialNode is not None:
self.fiducialNode.RemoveAllMarkups()
if self.isVisualizing:
slicer.app.layoutManager().setLayout(slicer.vtkMRMLLayoutNode.SlicerLayoutSideBySideView)
self.isVisualizing = False
self.visualizeButton.text = 'Show 3D Scene'
self.OutputRegistrationTransformNode.SetMatrixTransformToParent(None)
self.OutputRegistrationTransformNodeX.SetMatrixTransformToParent(None)
else:
self.isVisualizing = True
slicer.app.layoutManager().sliceWidget('Red').sliceLogic().GetSliceNode().SetSliceVisible(True)
slicer.app.layoutManager().sliceWidget('Yellow').sliceLogic().GetSliceNode().SetSliceVisible(True)
slicer.app.layoutManager().setLayout(slicer.vtkMRMLLayoutNode.SlicerLayoutOneUp3DView)
self.visualizeButton.text = 'Show ultrasound stream'
if self.imageSelector.currentNode is None:
print('Please select an US volume')
else:
self.leftTransform.Concatenate(self.ImageToProbe)
self.rightTransform.Concatenate(self.ImageToProbe)
self.imageSelector.currentNode().SetAndObserveTransformNodeID(self.OutputRegistrationTransformNode.GetID())
self.imageSelector2.currentNode().SetAndObserveTransformNodeID(self.OutputRegistrationTransformNodeX.GetID())
self.OutputRegistrationTransformNode.SetMatrixTransformToParent(self.leftTransform.GetMatrix())
self.OutputRegistrationTransformNodeX.SetMatrixTransformToParent(self.rightTransform.GetMatrix())
def getTransformNode(self):
if len(slicer.util.getNodes('ras2lps*')) > 0:
transformNode = slicer.util.getNode('ras2lps*')
else:
transformNode = slicer.vtkMRMLLinearTransformNode()
transformNode.SetScene(slicer.mrmlScene)
transformNode.HideFromEditorsOn()
transformNode.SetName("ras2lps")
t = vtk.vtkTransform()
t.Identity()
t.Scale([-1, -1, 1])
transformNode.SetMatrixTransformToParent(t.GetMatrix())
slicer.mrmlScene.AddNode(transformNode)
return transformNode
def __init__(self, parent=None):
ScriptedLoadableModuleWidget.__init__(self, parent)
# Set member variables equal to None
self.tempNode = None
self.connectorNode = None
self.sceneObserverTag = None
self.logic = GuidedUSCalLogic()
self.resliceLogic = slicer.modules.volumereslicedriver.logic()
self.imageNode = None
self.probeNode = None
self.sequenceNode = None
self.sequenceNode2 = None
self.sequenceBrowserNode = None
self.transformNode = None
self.dataStack = None
self.numFid = 0
self.sequenceLogic = slicer.modules.sequencebrowser.logic()
self.counter = 0
self.centroid = [0,0,0]
self.isVisualizing = False
self.currentMatrix = np.matrix('1,0,0,0;0,1,0,0;0,0,1,0;0,0,0,1', dtype = np.float64)
slicer.mymod = self
self.connectCheck = 0
self.node = slicer.mrmlScene.AddNewNodeByClass('vtkMRMLScalarVolumeNode')
self.path = os.path.dirname(os.path.abspath(__file__))
self.model = load_model(os.path.join(self.path,'Resources\Models\cnn_model_best.keras.h5'))
self.fiducialNode = slicer.mrmlScene.AddNewNodeByClass('vtkMRMLMarkupsFiducialNode')
self.fiducialNode.CreateDefaultDisplayNodes()
self.displayNode = self.fiducialNode.GetDisplayNode()
self.displayNode.SetGlyphType(7)
self.displayNode.SetGlyphScale(2)
self.displayNode.SetTextScale(0)
self.displayNode.PointLabelsVisibilityOff()
self.displayNode.SetSelectedColor(0, 0, 1)
self.defaultDisplayNode = slicer.modules.markups.logic().GetDefaultMarkupsDisplayNode()
self.defaultDisplayNode.SetGlyphType(7)
self.defaultDisplayNode.SetGlyphScale(2)
self.defaultDisplayNode.SetTextScale(0)
self.defaultDisplayNode.SetSelectedColor(0, 0, 1)
self.defaultDisplayNode.PointLabelsVisibilityOff()
self.wResized = self.model.layers[0].output_shape[0][1]
self.hResized = self.model.layers[0].output_shape[0][2]
self.tipToProbeTransform = vtk.vtkMatrix4x4()
self.outputRegistrationTransformNode = slicer.vtkMRMLLinearTransformNode()
slicer.mrmlScene.AddNode(self.outputRegistrationTransformNode)
self.outputRegistrationTransformNode.SetName('ImageToProbe')
self.needleModel = slicer.modules.createmodels.logic().CreateNeedle(150, 0.4, 0, False)
self.imageToProbe = vtk.vtkMatrix4x4()
self.redoStack = None
def createSampleModels_NoCollisions(self):
# Create a cautery model
moduleDirectoryPath = slicer.modules.autotransparency.path.replace('AutoTransparency.py', '')
slicer.util.loadModel(qt.QDir.toNativeSeparators(moduleDirectoryPath + 'Resources/CAD/Cautery.stl'))
self.cauteryModelNode = slicer.util.getNode(pattern = "Cautery")
self.cauteryModelNode.GetDisplayNode().SetColor(1.0, 1.0, 0)
self.cauteryModelNode.SetName("CauteryModel")
self.cauteryModelNode.GetDisplayNode().SliceIntersectionVisibilityOn()
# Create transform node and set transform of transform node
self.cauteryModelToRAS = slicer.vtkMRMLLinearTransformNode()
self.cauteryModelToRAS.SetName('CauteryModelToRAS')
slicer.mrmlScene.AddNode(self.cauteryModelToRAS)
cauteryModelToRASTransform = vtk.vtkTransform()
cauteryModelToRASTransform.PreMultiply()
cauteryModelToRASTransform.Translate(0, 100, 0)
cauteryModelToRASTransform.RotateX(30)
cauteryModelToRASTransform.Update()
self.cauteryModelToRAS.SetAndObserveTransformToParent(cauteryModelToRASTransform)
# Transform the cautery model
self.cauteryModelNode.SetAndObserveTransformNodeID(self.cauteryModelToRAS.GetID())
# Create a sphere tumor model
self.tumorModelNode = slicer.modules.createmodels.logic().CreateSphere(10)
self.tumorModelNode.GetDisplayNode().SetColor(0,1,0) #Green
self.tumorModelNode.SetName('TumorModel')
# Create transform node and set transform of transform node
self.tumorModelToRAS = slicer.vtkMRMLLinearTransformNode()
self.tumorModelToRAS.SetName('tumorModelToRAS')
slicer.mrmlScene.AddNode(self.tumorModelToRAS)
tumorModelToRASTransform = vtk.vtkTransform()
self.tumorModelToRAS.SetAndObserveTransformToParent(tumorModelToRASTransform)
# Transform the tumor model
self.tumorModelNode.SetAndObserveTransformNodeID(self.tumorModelToRAS.GetID())
def onFiducialClicked(self):
if self.fiducialNode is not None:
self.fiducialNode.RemoveAllMarkups()
if self.imageNode or self.transformNode is None:
if self.imageNode is None:
print('Please select an US volume')
if self.transformNode is None:
print('Please select the tip to probe transform')
if self.imageNode is not None and self.transformNode is not None:
self.numFid = self.numFid+1
self.numFidLabel.setText(str(self.numFid))
self.manualOutputRegistrationTransformNode = slicer.vtkMRMLLinearTransformNode()
slicer.mrmlScene.AddNode(self.manualOutputRegistrationTransformNode)
self.manualOutputRegistrationTransformNode.SetName('ImageToProbeMan')
slicer.modules.markups.logic().StartPlaceMode(0)
slicer.app.layoutManager().sliceWidget('Red').setCursor(qt.QCursor(2))
def test_BRAINSFitRigidRegistrationCrashIssue4139(self):
""" Ideally you should have several levels of tests. At the lowest level
tests should exercise the functionality of the logic with different inputs
(both valid and invalid). At higher levels your tests should emulate the
way the user would interact with your code and confirm that it still works
the way you intended.
One of the most important features of the tests is that it should alert other
developers when their changes will have an impact on the behavior of your
module. For example, if a developer removes a feature that you depend on,
your test should break so they know that the feature is needed.
"""
self.delayDisplay("Starting the test")
logic = BRAINSFitRigidRegistrationCrashIssue4139Logic()
import SampleData
from SampleData import SampleDataLogic
sampleDatalogic = SampleDataLogic()
fixed = sampleDatalogic.downloadMRBrainTumor1()
self.assertIsNotNone(logic.hasImageData(fixed))
moving = sampleDatalogic.downloadMRBrainTumor2()
self.assertIsNotNone(logic.hasImageData(moving))
self.delayDisplay('Finished with download and loading')
outputTransform = slicer.vtkMRMLLinearTransformNode()
slicer.mrmlScene.AddNode(outputTransform)
outputVolume = slicer.vtkMRMLScalarVolumeNode()
slicer.mrmlScene.AddNode(outputVolume)
parameters = {
'fixedVolume' : fixed,
'movingVolume' : moving,
'linearTransform' : outputTransform,
'outputVolume' : outputVolume,
'useRigid' : True
}
cmdLineNode = slicer.cli.runSync(slicer.modules.brainsfit, parameters=parameters)
self.assertIsNotNone(cmdLineNode)
# If test reach this point without crashing it is a success
self.delayDisplay('Test passed!')
def run(self):
"""
Run the actual algorithm
"""
#generating Nodes for displaying a new model
modelNode = slicer.vtkMRMLModelNode()
dispNode = slicer.vtkMRMLModelDisplayNode()
transform = slicer.vtkMRMLLinearTransformNode()
#Display node characteristics
dispNode.SetVisibility(True)
dispNode.SetSliceIntersectionVisibility(True)
dispNode.SetOpacity(1)
dispNode.SetColor(1, 1, 0)
dispNode.SetScene(slicer.mrmlScene)
#generate sphere data
sphere = vtk.vtkSphereSource()
sphere.SetCenter(10,10,10)
sphere.SetRadius(40)
sphere.Update()
#adding necessary nodes to the Scene
slicer.mrmlScene.AddNode(dispNode)
slicer.mrmlScene.AddNode(transform)
slicer.mrmlScene.AddNode(modelNode)
#model node name and associations!
modelNode.SetName("SphereModelNode")
modelNode.SetScene(slicer.mrmlScene)
modelNode.SetAndObserveTransformNodeID(transform.GetID())
modelNode.SetAndObserveDisplayNodeID(dispNode.GetID())
apd = vtk.vtkAppendPolyData()
apd.AddInputData(sphere.GetOutput())
apd.Update()
#adding model node poly data! Here there are sphere's data!!!
modelNode.SetAndObservePolyData(apd.GetOutput())
#update the scene
slicer.mrmlScene.Modified()
return True
def TextureMappedPlane(self, obj, event):
# use dummy image data here
e = vtk.vtkImageEllipsoidSource()
scene = slicer.mrmlScene
# Create model node
model = slicer.vtkMRMLModelNode()
model.SetScene(scene)
model.SetName(scene.GenerateUniqueName("2DImageModel"))
planeSource = vtk.vtkPlaneSource()
model.SetAndObservePolyData(planeSource.GetOutput())
# Create display node
modelDisplay = slicer.vtkMRMLModelDisplayNode()
modelDisplay.SetColor(1, 1, 0) # yellow
# modelDisplay.SetBackfaceCulling(0)
modelDisplay.SetScene(scene)
scene.AddNode(modelDisplay)
model.SetAndObserveDisplayNodeID(modelDisplay.GetID())
modelDisplay.SetSliceIntersectionVisibility(True)
modelDisplay.SetVisibility(True)
# Add to scene
modelDisplay.SetTextureImageDataConnection(e.GetOutputPort())
# modelDisplay.SetInputPolyDataConnection(model.GetPolyDataConnection())
scene.AddNode(model)
transform = slicer.vtkMRMLLinearTransformNode()
scene.AddNode(transform)
model.SetAndObserveTransformNodeID(transform.GetID())
vTransform = vtk.vtkTransform()
vTransform.Scale(50, 50, 50)
vTransform.RotateX(30)
# transform.SetAndObserveMatrixTransformToParent(vTransform.GetMatrix())
transform.SetMatrixTransformToParent(vTransform.GetMatrix())
def run(self, initialModel, inputModel, fidList, LeftBreast, volume, modelFids, reverseNormal,
setInsideOut, noBreast, registrationFlag):
"""
Run the actual algorithm
"""
meanDis = 0
transformNode = slicer.vtkMRMLLinearTransformNode()
if initialModel != None:
#If the models need to registered
if registrationFlag == True:
transformNode = self.surfaceRegistration(initialModel, inputModel)
meanDis = self.distanceAfterRegistration(initialModel, inputModel, fidList, transformNode)
else:
meanDis = self.distanceAfterRegistration(initialModel, inputModel, fidList, transformNode)
# Creates the closed breast model
modelNode = self.cropWithCurve(inputModel, fidList, LeftBreast, reverseNormal, setInsideOut, noBreast)
self.AddVolumeNode()
# Computes the volume of the closed breast model
volumeVal = self.AddSegmentNode(modelNode, volume)
return [volumeVal, meanDis]
logging.info('Processing completed')
def surfaceRegistration(self, initialModel, inputModel):
# Registers the input scan to the initial scan where the breast boundaries were defined
# Uses ICP to create the transform
icpTransform = vtk.vtkIterativeClosestPointTransform()
icpTransform.SetSource(initialModel.GetPolyData())
icpTransform.SetTarget(inputModel.GetPolyData())
icpTransform.GetLandmarkTransform().SetModeToRigidBody()
icpTransform.SetMaximumNumberOfIterations(100)
icpTransform.Inverse()
icpTransform.Modified()
icpTransform.Update()
# Applies the transform
transformNode = slicer.vtkMRMLLinearTransformNode()
transformNode.SetAndObserveMatrixTransformToParent(icpTransform.GetMatrix())
slicer.mrmlScene.AddNode(transformNode)
inputModel.SetAndObserveTransformNodeID(transformNode.GetID())
inputModel.HardenTransform()
return transformNode
def setupMRMLTracking(self):
"""
For the tracking endpoint this creates a kind of 'cursor' in the scene.
Adds "trackingDevice" (model node) to self.
"""
if not hasattr(self, "trackingDevice"):
""" set up the mrml parts or use existing """
nodes = slicer.mrmlScene.GetNodesByName('trackingDevice')
if nodes.GetNumberOfItems() > 0:
self.trackingDevice = nodes.GetItemAsObject(0)
nodes = slicer.mrmlScene.GetNodesByName('tracker')
self.tracker = nodes.GetItemAsObject(0)
else:
# trackingDevice cursor
self.cube = vtk.vtkCubeSource()
self.cube.SetXLength(30)
self.cube.SetYLength(70)
self.cube.SetZLength(5)
self.cube.Update()
# display node
self.modelDisplay = slicer.vtkMRMLModelDisplayNode()
self.modelDisplay.SetColor(1, 1, 0) # yellow
slicer.mrmlScene.AddNode(self.modelDisplay)
# self.modelDisplay.SetPolyData(self.cube.GetOutputPort())
# Create model node
self.trackingDevice = slicer.vtkMRMLModelNode()
self.trackingDevice.SetScene(slicer.mrmlScene)
self.trackingDevice.SetName("trackingDevice")
self.trackingDevice.SetAndObservePolyData(
self.cube.GetOutputDataObject(0))
self.trackingDevice.SetAndObserveDisplayNodeID(
self.modelDisplay.GetID())
slicer.mrmlScene.AddNode(self.trackingDevice)
# tracker
self.tracker = slicer.vtkMRMLLinearTransformNode()
self.tracker.SetName('tracker')
slicer.mrmlScene.AddNode(self.tracker)
self.trackingDevice.SetAndObserveTransformNodeID(
self.tracker.GetID())
def rigidVolumeRegistration(self, fixedVolume, movingVolume, movingBinaryVolume = None, fixedBinaryVolume = None, Rigid = True, RigidScale = False):
parameters = {}
brainsFit = slicer.modules.brainsfit
parameters['fixedVolume'] = fixedVolume.GetID()
parameters ['movingVolume'] = movingVolume.GetID()
# parameters["initialTransform"] = initialTransform.GetID()
parameters["useRigid"] = Rigid
parameters["useRigid"] = RigidScale
parameters["useScaleVersor3D"] = True
outputTransform = slicer.vtkMRMLLinearTransformNode()
outputTransform.SetName('PreopToIntraopAutoRegTransform')
slicer.mrmlScene.AddNode(outputTransform)
parameters ["outputTransform"] = outputTransform.GetID()
parameters['fixedBinaryVolume'] = fixedBinaryVolume
parameters['movingBinaryVolume'] = movingBinaryVolume
cliBrainsFitNode = slicer.cli.run(brainsFit, None, parameters)
waitCount = 0
while cliBrainsFitNode.GetStatusString() != 'Completed':
print( "Performing Deformable Registration... %d" % waitCount )
#print cliBrainsFitNode.GetStatusString()
waitCount += 1
print("Automatic Rigid Registration Completed.")
def createTransformPoints(randErr, N):
Scale = 30.0
Sigma = randErr # radius of random error
fromNormCoordinates = numpy.random.rand(N, 3) # An array of random numbers
noise = numpy.random.normal(0.0, Sigma, N * 3)
# Homework for Jan 24:
referenceToRas = slicer.vtkMRMLLinearTransformNode()
slicer.mrmlScene.AddNode(referenceToRas)
referenceToRas.SetName('ReferenceToRas')
referenceFids = slicer.vtkMRMLMarkupsFiducialNode()
referenceFids.SetName('ReferenceFiducials')
slicer.mrmlScene.AddNode(referenceFids)
referenceFids.GetDisplayNode().SetSelectedColor(0, 0, 1)
RASFids = slicer.vtkMRMLMarkupsFiducialNode()
RASFids.SetName('RASFiducials')
slicer.mrmlScene.AddNode(RASFids)
RASFids.GetDisplayNode().SetSelectedColor(1, 1, 0)
alphaPoints = vtk.vtkPoints()
betaPoints = vtk.vtkPoints()
for i in range(N):
x = (fromNormCoordinates[i, 0] - 0.5) * Scale
y = (fromNormCoordinates[i, 1] - 0.5) * Scale
z = (fromNormCoordinates[i, 2] - 0.5) * Scale
numFids = referenceFids.AddFiducial(x, y, z)
numPoints = alphaPoints.InsertNextPoint(x, y, z)
xx = x + noise[i * 3]
yy = y + noise[i * 3 + 1]
zz = z + noise[i * 3 + 2]
numFids = RASFids.AddFiducial(xx, yy, zz)
numPoints = betaPoints.InsertNextPoint(xx, yy, zz)
return [alphaPoints, betaPoints, referenceToRas]
def __init__(self, path, fiducialListNode):
fids = fiducialListNode
scene = slicer.mrmlScene
points = vtk.vtkPoints()
polyData = vtk.vtkPolyData()
polyData.SetPoints(points)
lines = vtk.vtkCellArray()
polyData.SetLines(lines)
linesIDArray = lines.GetData()
linesIDArray.Reset()
linesIDArray.InsertNextTuple1(0)
polygons = vtk.vtkCellArray()
polyData.SetPolys( polygons )
idArray = polygons.GetData()
idArray.Reset()
idArray.InsertNextTuple1(0)
for point in path:
pointIndex = points.InsertNextPoint(*point)
linesIDArray.InsertNextTuple1(pointIndex)
linesIDArray.SetTuple1( 0, linesIDArray.GetNumberOfTuples() - 1 )
lines.SetNumberOfCells(1)
import vtk.util.numpy_support as VN
pointsArray = VN.vtk_to_numpy(points.GetData())
self.planePosition, self.planeNormal = self.planeFit(pointsArray.T)
# Create model node
model = slicer.vtkMRMLModelNode()
model.SetScene(scene)
model.SetName(scene.GenerateUniqueName("Path-%s" % fids.GetName()))
model.SetAndObservePolyData(polyData)
# Create display node
modelDisplay = slicer.vtkMRMLModelDisplayNode()
modelDisplay.SetColor(1,1,0) # yellow
modelDisplay.SetScene(scene)
scene.AddNode(modelDisplay)
model.SetAndObserveDisplayNodeID(modelDisplay.GetID())
# Add to scene
scene.AddNode(model)
# Camera cursor
sphere = vtk.vtkSphereSource()
sphere.Update()
# Create model node
cursor = slicer.vtkMRMLModelNode()
cursor.SetScene(scene)
cursor.SetName(scene.GenerateUniqueName("Cursor-%s" % fids.GetName()))
cursor.SetPolyDataConnection(sphere.GetOutputPort())
# Create display node
cursorModelDisplay = slicer.vtkMRMLModelDisplayNode()
cursorModelDisplay.SetColor(1,0,0) # red
cursorModelDisplay.SetScene(scene)
scene.AddNode(cursorModelDisplay)
cursor.SetAndObserveDisplayNodeID(cursorModelDisplay.GetID())
# Add to scene
scene.AddNode(cursor)
# Create transform node
transform = slicer.vtkMRMLLinearTransformNode()
transform.SetName(scene.GenerateUniqueName("Transform-%s" % fids.GetName()))
scene.AddNode(transform)
cursor.SetAndObserveTransformNodeID(transform.GetID())
self.transform = transform
def onApplyButton(self):
mvNode = self.outputSelector.currentNode()
inputVolume= self.inputSelector.currentNode()
"""
Run the actual algorithm
"""
#se obtiene la escena y se obtiene el volumen 4D a partir del Volumen 4D de
#entrada de la ventana desplegable
escena = slicer.mrmlScene
imagenvtk4D = inputVolume.GetImageData()
#Se obtiene el número de volúmenes que tiene el volumen 4D
numero_imagenes = inputVolume.GetNumberOfFrames()
print('imagenes: ' + str(numero_imagenes))
#filtro vtk para descomponer un volumen 4D
extract1 = vtk.vtkImageExtractComponents()
extract1.SetInputData(imagenvtk4D)
#matriz de transformación
ras2ijk = vtk.vtkMatrix4x4()
ijk2ras = vtk.vtkMatrix4x4()
#le solicitamos al volumen original que nos devuelva sus matrices
inputVolume.GetRASToIJKMatrix(ras2ijk)
inputVolume.GetIJKToRASMatrix(ijk2ras)
#creo un volumen nuevo
volumenFijo = slicer.vtkMRMLScalarVolumeNode()
volumenSalida = slicer.vtkMRMLMultiVolumeNode()
#le asigno las transformaciones
volumenFijo.SetRASToIJKMatrix(ras2ijk)
volumenFijo.SetIJKToRASMatrix(ijk2ras)
#le asigno el volumen 3D fijo
imagen_fija = extract1.SetComponents(0)
extract1.Update()
volumenFijo.SetName('fijo')
volumenFijo.SetAndObserveImageData(extract1.GetOutput())
#anado el nuevo volumen a la escena
escena.AddNode(volumenFijo)
#se crea un vector para guardar el número del volumen que tenga un
#desplazamiento de mas de 4mm en cualquier dirección
v=[]
#se hace un ciclo for para registrar todos los demás volúmenes del volumen 4D
#con el primer volumen que se definió como fijo
frameLabelsAttr=''
frames = []
volumeLabels = vtk.vtkDoubleArray()
volumeLabels.SetNumberOfTuples(numero_imagenes)
volumeLabels.SetNumberOfComponents(1)
volumeLabels.Allocate(numero_imagenes)
for i in range(numero_imagenes):
# extraigo la imagen móvil en la posición i+1 ya que el primero es el fijo
imagen_movil = extract1.SetComponents(i+1) #Seleccionar un volumen i+1
extract1.Update()
#Creo el volumen móvil, y realizo el mismo procedimiento que con el fijo
volumenMovil = slicer.vtkMRMLScalarVolumeNode();
volumenMovil.SetRASToIJKMatrix(ras2ijk)
volumenMovil.SetIJKToRASMatrix(ijk2ras)
volumenMovil.SetAndObserveImageData(extract1.GetOutput())
volumenMovil.SetName('movil '+str(i+1))
escena.AddNode(volumenMovil)
#creamos la transformada para alinear los volúmenes
transformadaSalida = slicer.vtkMRMLLinearTransformNode()
transformadaSalida.SetName('Transformadaderegistro'+str(i+1))
slicer.mrmlScene.AddNode(transformadaSalida)
#parámetros para la operación de registro
parameters = {}
#parameters['InitialTransform'] = transI.GetID()
parameters['fixedVolume'] = volumenFijo.GetID()
parameters['movingVolume'] = volumenMovil.GetID()
parameters['transformType'] = 'Rigid'
parameters['outputTransform'] = transformadaSalida.GetID()
frames.append(volumenMovil)
## parameters['outputVolume']=volumenSalida.GetID()
#Realizo el registro
cliNode = slicer.cli.run( slicer.modules.brainsfit,None,parameters,wait_for_completion=True)
#obtengo la transformada lineal que se usó en el registro
transformada=escena.GetFirstNodeByName('Transformadaderegistro'+str(i+1))
#Obtengo la matriz de la transformada, esta matriz es de dimensiones 4x4
#en la cual estan todos los desplazamientos y rotaciones que se hicieron
#en la transformada, a partir de ella se obtienen los volumenes que se
#desplazaron mas de 4mm en cualquier direccion
frameId = i;
volumeLabels.SetComponent(i, 0, frameId)
frameLabelsAttr += str(frameId)+','
Matriz=transformada.GetMatrixTransformToParent()
LR=Matriz.GetElement(0,3)#dirección izquierda o derecha en la fila 1, columna 4
PA=Matriz.GetElement(1,3)#dirección anterior o posterior en la fila 2, columna 4
IS=Matriz.GetElement(2,3)#dirección inferior o superior en la fila 3, columna 4
#Se mira si el volumen "i" en alguna dirección tuvo un desplazamiento
#mayor a 4mm, en caso de ser cierto se guarda en el vector "v"
if abs(LR)>4:
v.append(i+2)
elif abs(PA)>4:
v.append(i+2)
elif abs(IS)>4:
v.append(i+2)
print("MovilExtent: "+str(volumenMovil.GetImageData().GetExtent()))
## print("valor de f: "+ str(volumenMovil))
frameLabelsAttr = frameLabelsAttr[:-1]
mvImage = vtk.vtkImageData()
mvImage.SetExtent(volumenMovil.GetImageData().GetExtent())##Se le asigna la dimensión del miltuvolumen
mvImage.AllocateScalars(volumenMovil.GetImageData().GetScalarType(), numero_imagenes)##Se le asigna el tipo y número de cortes al multivolumen
mvImageArray = vtk.util.numpy_support.vtk_to_numpy(mvImage.GetPointData().GetScalars())## Se crea la matriz de datos donde va a ir la imagen
mat = vtk.vtkMatrix4x4()
##Se hace la conversión y se obtiene la matriz de transformación del nodo
volumenMovil.GetRASToIJKMatrix(mat)
mvNode.SetRASToIJKMatrix(mat)
volumenMovil.GetIJKToRASMatrix(mat)
mvNode.SetIJKToRASMatrix(mat)
print("frameId: "+str(frameId))
print("# imag: "+str(numero_imagenes))
## print("Long frame1: "+str(len(frame)))
print("Long frames: "+str(len(frames)))
##
for frameId in range(numero_imagenes):
# TODO: check consistent size and orientation!
frame = frames[frameId]
frameImage = frame.GetImageData()
frameImageArray = vtk.util.numpy_support.vtk_to_numpy(frameImage.GetPointData().GetScalars())
mvImageArray.T[frameId] = frameImageArray
##Se crea el nodo del multivolumen
mvDisplayNode = slicer.mrmlScene.CreateNodeByClass('vtkMRMLMultiVolumeDisplayNode')
mvDisplayNode.SetScene(slicer.mrmlScene)
slicer.mrmlScene.AddNode(mvDisplayNode)
mvDisplayNode.SetReferenceCount(mvDisplayNode.GetReferenceCount()-1)
mvDisplayNode.SetDefaultColorMap()
mvNode.SetAndObserveDisplayNodeID(mvDisplayNode.GetID())
mvNode.SetAndObserveImageData(mvImage)
mvNode.SetNumberOfFrames(numero_imagenes)
mvNode.SetLabelArray(volumeLabels)
mvNode.SetLabelName('na')
mvNode.SetAttribute('MultiVolume.FrameLabels',frameLabelsAttr)
mvNode.SetAttribute('MultiVolume.NumberOfFrames',str(numero_imagenes))
mvNode.SetAttribute('MultiVolume.FrameIdentifyingDICOMTagName','NA')
mvNode.SetAttribute('MultiVolume.FrameIdentifyingDICOMTagUnits','na')
mvNode.SetName('MultiVolume Registrado')
Helper.SetBgFgVolumes(mvNode.GetID(),None)
print('Registro completo')
#al terminar el ciclo for con todos los volúmenes registrados se genera una
#ventana emergente con un mensaje("Registro completo!") y mostrando los
#volúmenes que se desplazaron mas de 4mm
qt.QMessageBox.information(slicer.util.mainWindow(),'Slicer Python','Registro completo!\nVolumenes con movimiento mayor a 4mm:\n'+str(v))
return True
def refineLandmark(self, state):
"""Refine the specified landmark"""
# Refine landmark, or if none, do nothing
# Crop images around the fiducial
# Affine registration of the cropped images
# Transform the fiducial using the transformation
#
# No need to take into account the current transformation because landmarks are in World RAS
timing = False
if self.VerboseMode == "Verbose":
timing = True
if state.logic.cropLogic is None:
print(
"Cannot refine landmarks. CropVolume module is not available.")
if state.fixed == None or state.moving == None or state.fixedFiducials == None or state.movingFiducials == None or state.currentLandmarkName == None:
print "Cannot refine landmarks. Images or landmarks not selected."
return
print("Refining landmark " +
state.currentLandmarkName) + " using " + self.name
start = time.time()
volumes = (state.fixed, state.moving)
(fixedVolume, movingVolume) = volumes
slicer.mrmlScene.StartState(slicer.mrmlScene.BatchProcessState)
landmarks = state.logic.landmarksForVolumes(volumes)
cvpn = slicer.vtkMRMLCropVolumeParametersNode()
cvpn.SetInterpolationMode(1)
cvpn.SetVoxelBased(1)
fixedPoint = [
0,
] * 3
movingPoint = [
0,
] * 3
(fixedFiducial, movingFiducial) = landmarks[state.currentLandmarkName]
(fixedList, fixedIndex) = fixedFiducial
(movingList, movingIndex) = movingFiducial
# define an roi for the fixed
if timing: roiStart = time.time()
roiFixed = slicer.vtkMRMLAnnotationROINode()
slicer.mrmlScene.AddNode(roiFixed)
fixedList.GetNthFiducialPosition(fixedIndex, fixedPoint)
roiFixed.SetDisplayVisibility(0)
roiFixed.SelectableOff()
roiFixed.SetXYZ(fixedPoint)
roiFixed.SetRadiusXYZ(30, 30, 30)
# crop the fixed. note we hide the display node temporarily to avoid the automated
# window level calculation on temporary nodes created by cloning
cvpn.SetROINodeID(roiFixed.GetID())
cvpn.SetInputVolumeNodeID(fixedVolume.GetID())
fixedDisplayNode = fixedVolume.GetDisplayNode()
fixedVolume.SetAndObserveDisplayNodeID(
'This is not a valid DisplayNode ID')
if timing: roiEnd = time.time()
if timing: cropStart = time.time()
state.logic.cropLogic.Apply(cvpn)
if timing: cropEnd = time.time()
croppedFixedVolume = slicer.mrmlScene.GetNodeByID(
cvpn.GetOutputVolumeNodeID())
fixedVolume.SetAndObserveDisplayNodeID(fixedDisplayNode.GetID())
# define an roi for the moving
if timing: roi2Start = time.time()
roiMoving = slicer.vtkMRMLAnnotationROINode()
slicer.mrmlScene.AddNode(roiMoving)
movingList.GetNthFiducialPosition(movingIndex, movingPoint)
roiMoving.SetDisplayVisibility(0)
roiMoving.SelectableOff()
roiMoving.SetXYZ(movingPoint)
if self.LocalBRAINSFitMode == "Small":
roiMoving.SetRadiusXYZ(45, 45, 45)
else:
roiMoving.SetRadiusXYZ(60, 60, 60)
# crop the moving. note we hide the display node temporarily to avoid the automated
# window level calculation on temporary nodes created by cloning
cvpn.SetROINodeID(roiMoving.GetID())
cvpn.SetInputVolumeNodeID(movingVolume.GetID())
movingDisplayNode = movingVolume.GetDisplayNode()
movingVolume.SetAndObserveDisplayNodeID(
'This is not a valid DisplayNode ID')
if timing: roi2End = time.time()
if timing: crop2Start = time.time()
state.logic.cropLogic.Apply(cvpn)
if timing: crop2End = time.time()
croppedMovingVolume = slicer.mrmlScene.GetNodeByID(
cvpn.GetOutputVolumeNodeID())
movingVolume.SetAndObserveDisplayNodeID(movingDisplayNode.GetID())
if timing:
print 'Time to set up fixed ROI was ' + str(roiEnd -
roiStart) + ' seconds'
if timing:
print 'Time to set up moving ROI was ' + str(
roi2End - roi2Start) + ' seconds'
if timing:
print 'Time to crop fixed volume ' + str(cropEnd -
cropStart) + ' seconds'
if timing:
print 'Time to crop moving volume ' + str(crop2End -
crop2Start) + ' seconds'
#
transform = slicer.vtkMRMLLinearTransformNode()
slicer.mrmlScene.AddNode(transform)
matrix = vtk.vtkMatrix4x4()
# define the registration parameters
minPixelSpacing = min(croppedFixedVolume.GetSpacing())
parameters = {}
parameters['fixedVolume'] = croppedFixedVolume.GetID()
parameters['movingVolume'] = croppedMovingVolume.GetID()
parameters['linearTransform'] = transform.GetID()
parameters['useRigid'] = True
parameters['initializeTransformMode'] = 'useGeometryAlign'
parameters['samplingPercentage'] = 0.2
parameters['minimumStepLength'] = 0.1 * minPixelSpacing
parameters['maximumStepLength'] = minPixelSpacing
# run the registration
if timing: regStart = time.time()
slicer.cli.run(slicer.modules.brainsfit,
None,
parameters,
wait_for_completion=True)
if timing: regEnd = time.time()
if timing:
print 'Time for local registration ' + str(regEnd -
regStart) + ' seconds'
# apply the local transform to the landmark
#print transform
if timing: resultStart = time.time()
transform.GetMatrixTransformToWorld(matrix)
matrix.Invert()
tp = [
0,
] * 4
tp = matrix.MultiplyPoint(fixedPoint + [
1,
])
#print fixedPoint, movingPoint, tp[:3]
movingList.SetNthFiducialPosition(movingIndex, tp[0], tp[1], tp[2])
if timing: resultEnd = time.time()
if timing:
print 'Time for transforming landmark was ' + str(
resultEnd - resultStart) + ' seconds'
# clean up cropped volmes, need to reset the foreground/background display before we delete it
if timing: cleanUpStart = time.time()
slicer.mrmlScene.RemoveNode(croppedFixedVolume)
slicer.mrmlScene.RemoveNode(croppedMovingVolume)
slicer.mrmlScene.RemoveNode(roiFixed)
slicer.mrmlScene.RemoveNode(roiMoving)
slicer.mrmlScene.RemoveNode(transform)
roiFixed = None
roiMoving = None
transform = None
matrix = None
if timing: cleanUpEnd = time.time()
if timing:
print 'Cleanup took ' + str(cleanUpEnd - cleanUpStart) + ' seconds'
end = time.time()
print 'Refined landmark ' + state.currentLandmarkName + ' in ' + str(
end - start) + ' seconds'
slicer.mrmlScene.EndState(slicer.mrmlScene.BatchProcessState)
def TestSection_04_RegisterDay2CTToDay1CT(self):
try:
scene = slicer.mrmlScene
slicer.util.selectModule('BRAINSFit')
brainsFit = slicer.modules.brainsfit
# Hide isodose
shNode = slicer.vtkMRMLSubjectHierarchyNode.GetSubjectHierarchyNode(slicer.mrmlScene)
self.assertIsNotNone( shNode )
day2IsodoseShItemID = shNode.GetItemByDataNode(slicer.util.getNode(self.day2IsodosesName))
shNode.SetDisplayVisibilityForBranch(day2IsodoseShItemID, 0)
# Register Day 2 CT to Day 1 CT using rigid registration
self.delayDisplay("Register Day 2 CT to Day 1 CT using rigid registration.\n It may take a few minutes...",self.delayMs)
parametersRigid = {}
day1CT = slicer.util.getNode(self.day1CTName)
parametersRigid["fixedVolume"] = day1CT.GetID()
day2CT = slicer.util.getNode(self.day2CTName)
parametersRigid["movingVolume"] = day2CT.GetID()
linearTransform = slicer.vtkMRMLLinearTransformNode()
linearTransform.SetName(self.transformDay2ToDay1RigidName)
slicer.mrmlScene.AddNode( linearTransform )
parametersRigid["linearTransform"] = linearTransform.GetID()
parametersRigid["useRigid"] = True
parametersRigid["samplingPercentage"] = 0.0002
self.cliBrainsFitRigidNode = None
self.cliBrainsFitRigidNode = slicer.cli.run(brainsFit, None, parametersRigid)
waitCount = 0
while self.cliBrainsFitRigidNode.GetStatusString() != 'Completed' and waitCount < 200:
self.delayDisplay( "Register Day 2 CT to Day 1 CT using rigid registration... %d" % waitCount )
waitCount += 1
self.delayDisplay("Register Day 2 CT to Day 1 CT using rigid registration finished",self.delayMs)
self.assertEqual( self.cliBrainsFitRigidNode.GetStatusString(), 'Completed' )
# Register Day 2 CT to Day 1 CT using BSpline registration
# TODO: Move this to workflow 2
# if self.performDeformableRegistration:
# self.delayDisplay("Register Day 2 CT to Day 1 CT using BSpline registration.\n It may take a few minutes...",self.delayMs)
# parametersBSpline = {}
# parametersBSpline["fixedVolume"] = day1CT.GetID()
# parametersBSpline["movingVolume"] = day2CT.GetID()
# parametersBSpline["initialTransform"] = linearTransform.GetID()
# bsplineTransform = slicer.vtkMRMLBSplineTransformNode()
# bsplineTransform.SetName(self.transformDay2ToDay1BSplineName)
# slicer.mrmlScene.AddNode( bsplineTransform )
# parametersBSpline["bsplineTransform"] = bsplineTransform.GetID()
# parametersBSpline["useBSpline"] = True
# self.cliBrainsFitBSplineNode = None
# self.cliBrainsFitBSplineNode = slicer.cli.run(brainsFit, None, parametersBSpline)
# waitCount = 0
# while self.cliBrainsFitBSplineNode.GetStatusString() != 'Completed' and waitCount < 600:
# self.delayDisplay( "Register Day 2 CT to Day 1 CT using BSpline registration... %d" % waitCount )
# waitCount += 1
# self.delayDisplay("Register Day 2 CT to Day 1 CT using BSpline registration finished",self.delayMs)
# self.assertEqual( self.cliBrainsFitBSplineNode.GetStatusString(), 'Completed' )
except Exception, e:
import traceback
traceback.print_exc()
self.delayDisplay('Test caused exception!\n' + str(e),self.delayMs*2)
raise Exception("Exception occurred, handled, thrown further to workflow level")
def __init__(self):
self.toolTipToTool = slicer.util.getNode('toolTipToTool')
self.pointerTipToReference = None
self.targetCreatedTransformed = False
self.firstFiducial = True
if not self.toolTipToTool:
self.toolTipToTool=slicer.vtkMRMLLinearTransformNode()
self.toolTipToTool.SetName("toolTipToTool")
m = vtk.vtkMatrix4x4()
m.SetElement( 0, 0, 1 ) # Row 1
m.SetElement( 0, 1, 0 )
m.SetElement( 0, 2, 0 )
m.SetElement( 0, 3, 0 )
m.SetElement( 1, 0, 0 ) # Row 2
m.SetElement( 1, 1, 1 )
m.SetElement( 1, 2, 0 )
m.SetElement( 1, 3, 0 )
m.SetElement( 2, 0, 0 ) # Row 3
m.SetElement( 2, 1, 0 )
m.SetElement( 2, 2, 1 )
m.SetElement( 2, 3, 0 )
self.toolTipToTool.SetMatrixTransformToParent(m)
slicer.mrmlScene.AddNode(self.toolTipToTool)
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
self.observerTag=None
# Output Distance Label
self.outputDistanceLabel=None
import Viewpoint # Viewpoint Module must have been added to Slicer
self.viewpointLogic = Viewpoint.ViewpointLogic()
# Camera transformations
self.needleCameraToNeedle = slicer.util.getNode('needleCameraToNeedle')
if not self.needleCameraToNeedle:
self.needleCameraToNeedle=slicer.vtkMRMLLinearTransformNode()
self.needleCameraToNeedle.SetName("needleCameraToNeedle")
matrixNeedleCamera = vtk.vtkMatrix4x4()
matrixNeedleCamera.SetElement( 0, 0, -0.05 ) # Row 1
matrixNeedleCamera.SetElement( 0, 1, 0.09 )
matrixNeedleCamera.SetElement( 0, 2, -0.99 )
matrixNeedleCamera.SetElement( 0, 3, 60.72 )
matrixNeedleCamera.SetElement( 1, 0, -0.01 ) # Row 2
matrixNeedleCamera.SetElement( 1, 1, 1 )
matrixNeedleCamera.SetElement( 1, 2, 0.09 )
matrixNeedleCamera.SetElement( 1, 3, 12.17 )
matrixNeedleCamera.SetElement( 2, 0, 1 ) # Row 3
matrixNeedleCamera.SetElement( 2, 1, 0.01 )
matrixNeedleCamera.SetElement( 2, 2, -0.05 )
matrixNeedleCamera.SetElement( 2, 3, -7.26 )
self.needleCameraToNeedle.SetMatrixTransformToParent(matrixNeedleCamera)
slicer.mrmlScene.AddNode(self.needleCameraToNeedle)
self.pointerCameraToPointer = slicer.util.getNode('pointerCameraToPointer')
if not self.pointerCameraToPointer:
self.pointerCameraToPointer=slicer.vtkMRMLLinearTransformNode()
self.pointerCameraToPointer.SetName("pointerCameraToPointer")
matrixPointerCamera = vtk.vtkMatrix4x4()
matrixPointerCamera.SetElement( 0, 0, -0.05 ) # Row 1
matrixPointerCamera.SetElement( 0, 1, 0.09 )
matrixPointerCamera.SetElement( 0, 2, -0.99 )
matrixPointerCamera.SetElement( 0, 3, 121.72 )
matrixPointerCamera.SetElement( 1, 0, -0.01 ) # Row 2
matrixPointerCamera.SetElement( 1, 1, 1 )
matrixPointerCamera.SetElement( 1, 2, 0.09 )
matrixPointerCamera.SetElement( 1, 3, 17.17 )
matrixPointerCamera.SetElement( 2, 0, 1 ) # Row 3
matrixPointerCamera.SetElement( 2, 1, 0.01 )
matrixPointerCamera.SetElement( 2, 2, -0.05 )
matrixPointerCamera.SetElement( 2, 3, -7.26 )
self.pointerCameraToPointer.SetMatrixTransformToParent(matrixPointerCamera)
slicer.mrmlScene.AddNode(self.pointerCameraToPointer)
# Tranformations to fix models orientation
self.needleModelToNeedleTip = slicer.util.getNode('needleModelToNeedleTip')
if not self.needleModelToNeedleTip:
self.needleModelToNeedleTip=slicer.vtkMRMLLinearTransformNode()
self.needleModelToNeedleTip.SetName("needleModelToNeedleTip")
matrixNeedleModel = vtk.vtkMatrix4x4()
matrixNeedleModel.SetElement( 0, 0, -1 ) # Row 1
matrixNeedleModel.SetElement( 0, 1, 0 )
matrixNeedleModel.SetElement( 0, 2, 0 )
matrixNeedleModel.SetElement( 0, 3, 0 )
matrixNeedleModel.SetElement( 1, 0, 0 ) # Row 2
matrixNeedleModel.SetElement( 1, 1, 1 )
matrixNeedleModel.SetElement( 1, 2, 0 )
matrixNeedleModel.SetElement( 1, 3, 0 )
matrixNeedleModel.SetElement( 2, 0, 0 ) # Row 3
matrixNeedleModel.SetElement( 2, 1, 0 )
matrixNeedleModel.SetElement( 2, 2, -1 )
matrixNeedleModel.SetElement( 2, 3, 0 )
self.needleModelToNeedleTip.SetMatrixTransformToParent(matrixNeedleModel)
slicer.mrmlScene.AddNode(self.needleModelToNeedleTip)
self.pointerModelToPointerTip = slicer.util.getNode('pointerModelToPointerTip')
if not self.pointerModelToPointerTip:
self.pointerModelToPointerTip=slicer.vtkMRMLLinearTransformNode()
self.pointerModelToPointerTip.SetName("pointerModelToPointerTip")
matrixPointerModel = vtk.vtkMatrix4x4()
matrixPointerModel.SetElement( 0, 0, 0 ) # Row 1
matrixPointerModel.SetElement( 0, 1, 0 )
matrixPointerModel.SetElement( 0, 2, 1 )
matrixPointerModel.SetElement( 0, 3, 0 )
matrixPointerModel.SetElement( 1, 0, 0 ) # Row 2
matrixPointerModel.SetElement( 1, 1, 1 )
matrixPointerModel.SetElement( 1, 2, 0 )
matrixPointerModel.SetElement( 1, 3, 0 )
matrixPointerModel.SetElement( 2, 0, -1 ) # Row 3
matrixPointerModel.SetElement( 2, 1, 0 )
matrixPointerModel.SetElement( 2, 2, 0 )
matrixPointerModel.SetElement( 2, 3, 0 )
self.pointerModelToPointerTip.SetMatrixTransformToParent(matrixPointerModel)
slicer.mrmlScene.AddNode(self.pointerModelToPointerTip)
self.fRBLToSLPR = slicer.util.getNode('FRBLToSLPR')
if not self.fRBLToSLPR:
self.fRBLToSLPR = slicer.vtkMRMLLinearTransformNode()
self.fRBLToSLPR.SetName('FRBLToSLPR')
slicer.mrmlScene.AddNode(self.fRBLToSLPR)
# Create fiducials to orientate model
self.fiducialsFRBL = slicer.util.getNode('FiducialsFRBL')
if not self.fiducialsFRBL:
self.fiducialsFRBL = slicer.vtkMRMLMarkupsFiducialNode()
self.fiducialsFRBL.SetName('FiducialsFRBL')
slicer.mrmlScene.AddNode(self.fiducialsFRBL)
self.fiducialsFRBL.SetDisplayVisibility(False)
self.fiducialsSLPR = slicer.util.getNode('FiducialsSLPR')
if not self.fiducialsSLPR:
self.fiducialsSLPR = slicer.vtkMRMLMarkupsFiducialNode()
self.fiducialsSLPR.SetName('FiducialsSLPR')
self.fiducialsSLPR.AddFiducial(0, 100, 0)
self.fiducialsSLPR.SetNthFiducialLabel(0, 'S')
self.fiducialsSLPR.AddFiducial(-100, 0, 0)
self.fiducialsSLPR.SetNthFiducialLabel(1, 'L')
self.fiducialsSLPR.AddFiducial(0, -100, 0)
self.fiducialsSLPR.SetNthFiducialLabel(2, 'P')
self.fiducialsSLPR.AddFiducial(100, 0, 0)
self.fiducialsSLPR.SetNthFiducialLabel(3, 'R')
slicer.mrmlScene.AddNode(self.fiducialsSLPR)
self.fiducialsSLPR.SetDisplayVisibility(False)
def createDummyTransform(self): transformNode = slicer.vtkMRMLLinearTransformNode() slicer.mrmlScene.AddNode(transformNode) return transformNode
def __init__(self, path, fiducialListNode):
fids = fiducialListNode
scene = slicer.mrmlScene
points = vtk.vtkPoints()
polyData = vtk.vtkPolyData()
polyData.SetPoints(points)
lines = vtk.vtkCellArray()
polyData.SetLines(lines)
linesIDArray = lines.GetData()
linesIDArray.Reset()
linesIDArray.InsertNextTuple1(0)
polygons = vtk.vtkCellArray()
polyData.SetPolys( polygons )
idArray = polygons.GetData()
idArray.Reset()
idArray.InsertNextTuple1(0)
for point in path:
pointIndex = points.InsertNextPoint(*point)
linesIDArray.InsertNextTuple1(pointIndex)
linesIDArray.SetTuple1( 0, linesIDArray.GetNumberOfTuples() - 1 )
lines.SetNumberOfCells(1)
# Create model node
model = slicer.vtkMRMLModelNode()
model.SetScene(scene)
model.SetName(scene.GenerateUniqueName("Path-%s" % fids.GetName()))
model.SetAndObservePolyData(polyData)
# Create display node
modelDisplay = slicer.vtkMRMLModelDisplayNode()
modelDisplay.SetColor(1,1,0) # yellow
modelDisplay.SetScene(scene)
scene.AddNode(modelDisplay)
model.SetAndObserveDisplayNodeID(modelDisplay.GetID())
# Add to scene
if vtk.VTK_MAJOR_VERSION <= 5:
# shall not be needed.
modelDisplay.SetInputPolyData(model.GetPolyData())
scene.AddNode(model)
# Camera cursor
sphere = vtk.vtkSphereSource()
sphere.Update()
# Create model node
cursor = slicer.vtkMRMLModelNode()
cursor.SetScene(scene)
cursor.SetName(scene.GenerateUniqueName("Cursor-%s" % fids.GetName()))
if vtk.VTK_MAJOR_VERSION <= 5:
cursor.SetAndObservePolyData(sphere.GetOutput())
else:
cursor.SetPolyDataConnection(sphere.GetOutputPort())
# Create display node
cursorModelDisplay = slicer.vtkMRMLModelDisplayNode()
cursorModelDisplay.SetColor(1,0,0) # red
cursorModelDisplay.SetScene(scene)
scene.AddNode(cursorModelDisplay)
cursor.SetAndObserveDisplayNodeID(cursorModelDisplay.GetID())
# Add to scene
if vtk.VTK_MAJOR_VERSION <= 5:
# Shall not be needed.
cursorModelDisplay.SetInputPolyData(sphere.GetOutput())
scene.AddNode(cursor)
# Create transform node
transform = slicer.vtkMRMLLinearTransformNode()
transform.SetName(scene.GenerateUniqueName("Transform-%s" % fids.GetName()))
scene.AddNode(transform)
cursor.SetAndObserveTransformNodeID(transform.GetID())
self.transform = transform
def TestSection_03_qMRMLSegmentationGeometryWidget(self):
logging.info('Test section 2: qMRMLSegmentationGeometryWidget')
binaryLabelmapReprName = slicer.vtkSegmentationConverter.GetBinaryLabelmapRepresentationName(
)
closedSurfaceReprName = slicer.vtkSegmentationConverter.GetClosedSurfaceRepresentationName(
)
# Use MRHead and Tinypatient for testing
import SampleData
mrVolumeNode = SampleData.downloadSample("MRHead")
[tinyVolumeNode,
tinySegmentationNode] = SampleData.downloadSamples('TinyPatient')
# Convert MRHead to oriented image data
import vtkSlicerSegmentationsModuleLogicPython as vtkSlicerSegmentationsModuleLogic
mrOrientedImageData = vtkSlicerSegmentationsModuleLogic.vtkSlicerSegmentationsModuleLogic.CreateOrientedImageDataFromVolumeNode(
mrVolumeNode)
mrOrientedImageData.UnRegister(None)
# Create segmentation node with binary labelmap master and one segment with MRHead geometry
segmentationNode = slicer.mrmlScene.AddNewNodeByClass(
'vtkMRMLSegmentationNode')
segmentationNode.GetSegmentation().SetMasterRepresentationName(
binaryLabelmapReprName)
geometryStr = slicer.vtkSegmentationConverter.SerializeImageGeometry(
mrOrientedImageData)
segmentationNode.GetSegmentation().SetConversionParameter(
slicer.vtkSegmentationConverter.
GetReferenceImageGeometryParameterName(), geometryStr)
threshold = vtk.vtkImageThreshold()
threshold.SetInputData(mrOrientedImageData)
threshold.ThresholdByUpper(16.0)
threshold.SetInValue(1)
threshold.SetOutValue(0)
threshold.SetOutputScalarType(vtk.VTK_UNSIGNED_CHAR)
threshold.Update()
segmentOrientedImageData = slicer.vtkOrientedImageData()
segmentOrientedImageData.DeepCopy(threshold.GetOutput())
mrImageToWorldMatrix = vtk.vtkMatrix4x4()
mrOrientedImageData.GetImageToWorldMatrix(mrImageToWorldMatrix)
segmentOrientedImageData.SetImageToWorldMatrix(mrImageToWorldMatrix)
segment = slicer.vtkSegment()
segment.SetName('Brain')
segment.SetColor(0.0, 0.0, 1.0)
segment.AddRepresentation(binaryLabelmapReprName,
segmentOrientedImageData)
segmentationNode.GetSegmentation().AddSegment(segment)
# Create geometry widget
geometryWidget = slicer.qMRMLSegmentationGeometryWidget()
geometryWidget.setSegmentationNode(segmentationNode)
geometryWidget.editEnabled = True
geometryImageData = slicer.vtkOrientedImageData(
) # To contain the output later
# Volume source with no transforms
geometryWidget.setSourceNode(tinyVolumeNode)
geometryWidget.geometryImageData(geometryImageData)
self.assertTrue(
self.compareOutputGeometry(
geometryImageData, (49, 49, 23), (248.8439, 248.2890, -123.75),
[[-1.0, 0.0, 0.0], [0.0, -1.0, 0.0], [0.0, 0.0, 1.0]]))
slicer.vtkOrientedImageDataResample.ResampleOrientedImageToReferenceOrientedImage(
segmentOrientedImageData, geometryImageData, geometryImageData,
False, True)
self.assertEqual(self.getForegroundVoxelCount(geometryImageData), 92)
# Transformed volume source
translationTransformMatrix = vtk.vtkMatrix4x4()
translationTransformMatrix.SetElement(0, 3, 24.5)
translationTransformMatrix.SetElement(1, 3, 24.5)
translationTransformMatrix.SetElement(2, 3, 11.5)
translationTransformNode = slicer.vtkMRMLLinearTransformNode()
translationTransformNode.SetName('TestTranslation')
slicer.mrmlScene.AddNode(translationTransformNode)
translationTransformNode.SetMatrixTransformToParent(
translationTransformMatrix)
tinyVolumeNode.SetAndObserveTransformNodeID(
translationTransformNode.GetID())
geometryWidget.geometryImageData(geometryImageData)
self.assertTrue(
self.compareOutputGeometry(
geometryImageData, (49, 49, 23), (273.3439, 272.7890, -112.25),
[[-1.0, 0.0, 0.0], [0.0, -1.0, 0.0], [0.0, 0.0, 1.0]]))
slicer.vtkOrientedImageDataResample.ResampleOrientedImageToReferenceOrientedImage(
segmentOrientedImageData, geometryImageData, geometryImageData,
False, True)
self.assertEqual(self.getForegroundVoxelCount(geometryImageData), 94)
# Volume source with isotropic spacing
tinyVolumeNode.SetAndObserveTransformNodeID(None)
geometryWidget.setIsotropicSpacing(True)
geometryWidget.geometryImageData(geometryImageData)
self.assertTrue(
self.compareOutputGeometry(
geometryImageData, (23, 23, 23), (248.8439, 248.2890, -123.75),
[[-1.0, 0.0, 0.0], [0.0, -1.0, 0.0], [0.0, 0.0, 1.0]]))
slicer.vtkOrientedImageDataResample.ResampleOrientedImageToReferenceOrientedImage(
segmentOrientedImageData, geometryImageData, geometryImageData,
False, True)
self.assertEqual(self.getForegroundVoxelCount(geometryImageData), 414)
# Volume source with oversampling
geometryWidget.setIsotropicSpacing(False)
geometryWidget.setOversamplingFactor(2.0)
geometryWidget.geometryImageData(geometryImageData)
self.assertTrue(
self.compareOutputGeometry(
geometryImageData, (24.5, 24.5, 11.5),
(261.0939, 260.5390, -129.5),
[[-1.0, 0.0, 0.0], [0.0, -1.0, 0.0], [0.0, 0.0, 1.0]]))
slicer.vtkOrientedImageDataResample.ResampleOrientedImageToReferenceOrientedImage(
segmentOrientedImageData, geometryImageData, geometryImageData,
False, True)
self.assertEqual(self.getForegroundVoxelCount(geometryImageData), 751)
slicer.util.delayDisplay('Volume source cases - OK')
# Segmentation source with binary labelmap master
geometryWidget.setOversamplingFactor(1.0)
geometryWidget.setSourceNode(tinySegmentationNode)
geometryWidget.geometryImageData(geometryImageData)
self.assertTrue(
self.compareOutputGeometry(
geometryImageData, (49, 49, 23), (248.8439, 248.2890, -123.75),
[[-1.0, 0.0, 0.0], [0.0, -1.0, 0.0], [0.0, 0.0, 1.0]]))
slicer.vtkOrientedImageDataResample.ResampleOrientedImageToReferenceOrientedImage(
segmentOrientedImageData, geometryImageData, geometryImageData,
False, True)
self.assertEqual(self.getForegroundVoxelCount(geometryImageData), 92)
# Segmentation source with closed surface master
tinySegmentationNode.GetSegmentation().SetConversionParameter(
'Smoothing factor', '0.0')
self.assertTrue(
tinySegmentationNode.GetSegmentation().CreateRepresentation(
closedSurfaceReprName))
tinySegmentationNode.GetSegmentation().SetMasterRepresentationName(
closedSurfaceReprName)
tinySegmentationNode.Modified(
) # Trigger re-calculation of geometry (only generic Modified event is observed)
geometryWidget.geometryImageData(geometryImageData)
self.assertTrue(
self.compareOutputGeometry(
geometryImageData,
(1, 1, 1),
(-86.645, 133.929,
116.786), # current origin of the segmentation is kept
[[0.0, 0.0, 1.0], [-1.0, 0.0, 0.0], [0.0, -1.0, 0.0]]))
slicer.vtkOrientedImageDataResample.ResampleOrientedImageToReferenceOrientedImage(
segmentOrientedImageData, geometryImageData, geometryImageData,
False, True)
self.assertEqual(self.getForegroundVoxelCount(geometryImageData),
5223040)
slicer.util.delayDisplay('Segmentation source cases - OK')
# Model source with no transform
shNode = slicer.vtkMRMLSubjectHierarchyNode.GetSubjectHierarchyNode(
slicer.mrmlScene)
outputFolderId = shNode.CreateFolderItem(shNode.GetSceneItemID(),
'ModelsFolder')
success = vtkSlicerSegmentationsModuleLogic.vtkSlicerSegmentationsModuleLogic.ExportVisibleSegmentsToModels(
tinySegmentationNode, outputFolderId)
self.assertTrue(success)
modelNode = slicer.util.getNode('Body_Contour')
geometryWidget.setSourceNode(modelNode)
geometryWidget.geometryImageData(geometryImageData)
self.assertTrue(
self.compareOutputGeometry(
geometryImageData,
(1, 1, 1),
(-86.645, 133.929,
116.786), # current origin of the segmentation is kept
[[0.0, 0.0, 1.0], [-1.0, 0.0, 0.0], [0.0, -1.0, 0.0]]))
slicer.vtkOrientedImageDataResample.ResampleOrientedImageToReferenceOrientedImage(
segmentOrientedImageData, geometryImageData, geometryImageData,
False, True)
self.assertEqual(self.getForegroundVoxelCount(geometryImageData),
5223040)
# Transformed model source
rotationTransform = vtk.vtkTransform()
rotationTransform.RotateX(45)
rotationTransformMatrix = vtk.vtkMatrix4x4()
rotationTransform.GetMatrix(rotationTransformMatrix)
rotationTransformNode = slicer.vtkMRMLLinearTransformNode()
rotationTransformNode.SetName('TestRotation')
slicer.mrmlScene.AddNode(rotationTransformNode)
rotationTransformNode.SetMatrixTransformToParent(
rotationTransformMatrix)
modelNode.SetAndObserveTransformNodeID(rotationTransformNode.GetID())
modelNode.Modified()
geometryWidget.geometryImageData(geometryImageData)
self.assertTrue(
self.compareOutputGeometry(
geometryImageData, (1, 1, 1), (-86.645, 177.282, -12.122),
[[0.0, 0.0, 1.0], [-0.7071, -0.7071, 0.0],
[0.7071, -0.7071, 0.0]]))
slicer.vtkOrientedImageDataResample.ResampleOrientedImageToReferenceOrientedImage(
segmentOrientedImageData, geometryImageData, geometryImageData,
False, True)
self.assertEqual(self.getForegroundVoxelCount(geometryImageData),
5229164)
# ROI source
roiNode = slicer.mrmlScene.AddNewNodeByClass(
"vtkMRMLAnnotationROINode", 'SourceROI')
xyz = [0.0, 0.0, 0.0]
center = [0.0, 0.0, 0.0]
slicer.vtkMRMLSliceLogic.GetVolumeRASBox(tinyVolumeNode, xyz, center)
radius = [x / 2.0 for x in xyz]
roiNode.SetXYZ(center)
roiNode.SetRadiusXYZ(radius)
geometryWidget.setSourceNode(roiNode)
geometryWidget.geometryImageData(geometryImageData)
self.assertTrue(
self.compareOutputGeometry(
geometryImageData, (1, 1, 1), (0.0, 0.0, 0.0),
[[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]]))
slicer.vtkOrientedImageDataResample.ResampleOrientedImageToReferenceOrientedImage(
segmentOrientedImageData, geometryImageData, geometryImageData,
False, True)
self.assertEqual(self.getForegroundVoxelCount(geometryImageData),
5224232)
slicer.util.delayDisplay('Model and ROI source cases - OK')
slicer.util.delayDisplay('Segmentation geometry widget test passed')
def TestSection_2_qMRMLSegmentationGeometryWidget(self):
logging.info('Test section 2: qMRMLSegmentationGeometryWidget')
import vtkSegmentationCore
binaryLabelmapReprName = vtkSegmentationCore.vtkSegmentationConverter.GetBinaryLabelmapRepresentationName()
closedSurfaceReprName = vtkSegmentationCore.vtkSegmentationConverter.GetClosedSurfaceRepresentationName()
# Use MRHead and Tinypatient for testing
import SampleData
sampleDataLogic = SampleData.SampleDataLogic()
mrVolumeNode = sampleDataLogic.downloadMRHead()
[tinyVolumeNode, tinySegmentationNode] = sampleDataLogic.downloadSample('TinyPatient')
# Convert MRHead to oriented image data
import vtkSlicerSegmentationsModuleLogicPython as vtkSlicerSegmentationsModuleLogic
mrOrientedImageData = vtkSlicerSegmentationsModuleLogic.vtkSlicerSegmentationsModuleLogic.CreateOrientedImageDataFromVolumeNode(mrVolumeNode)
mrOrientedImageData.UnRegister(None)
# Create segmentation node with binary labelmap master and one segment with MRHead geometry
segmentationNode = slicer.vtkMRMLSegmentationNode()
segmentationNode.GetSegmentation().SetMasterRepresentationName(binaryLabelmapReprName)
geometryStr = vtkSegmentationCore.vtkSegmentationConverter.SerializeImageGeometry(mrOrientedImageData)
segmentationNode.GetSegmentation().SetConversionParameter(
vtkSegmentationCore.vtkSegmentationConverter.GetReferenceImageGeometryParameterName(), geometryStr)
slicer.mrmlScene.AddNode(segmentationNode)
threshold = vtk.vtkImageThreshold()
threshold.SetInputData(mrOrientedImageData)
threshold.ThresholdByUpper(16.0)
threshold.SetInValue(1)
threshold.SetOutValue(0)
threshold.SetOutputScalarType(vtk.VTK_UNSIGNED_CHAR)
threshold.Update()
segmentOrientedImageData = vtkSegmentationCore.vtkOrientedImageData()
segmentOrientedImageData.DeepCopy(threshold.GetOutput())
mrImageToWorldMatrix = vtk.vtkMatrix4x4()
mrOrientedImageData.GetImageToWorldMatrix(mrImageToWorldMatrix)
segmentOrientedImageData.SetImageToWorldMatrix(mrImageToWorldMatrix)
segment = vtkSegmentationCore.vtkSegment()
segment.SetName('Brain')
segment.SetColor(0.0,0.0,1.0)
segment.AddRepresentation(binaryLabelmapReprName, segmentOrientedImageData)
segmentationNode.GetSegmentation().AddSegment(segment)
# Create geometry widget
geometryWidget = slicer.qMRMLSegmentationGeometryWidget()
geometryWidget.setSegmentationNode(segmentationNode)
geometryWidget.editEnabled = True
geometryImageData = vtkSegmentationCore.vtkOrientedImageData() # To contain the output later
# Volume source with no transforms
geometryWidget.setSourceNode(tinyVolumeNode)
geometryWidget.geometryImageData(geometryImageData)
self.assertTrue(self.compareOutputGeometry(geometryImageData,
(49,49,23), (248.8439, 248.2890, -123.75),
[[-1.0, 0.0, 0.0], [0.0, -1.0, 0.0], [0.0, 0.0, 1.0]]))
vtkSegmentationCore.vtkOrientedImageDataResample.ResampleOrientedImageToReferenceOrientedImage(
segmentOrientedImageData, geometryImageData, geometryImageData, False, True)
self.assertEqual(self.getForegroundVoxelCount(geometryImageData), 92)
# Transformed volume source
translationTransformMatrix = vtk.vtkMatrix4x4()
translationTransformMatrix.SetElement(0,3,24.5)
translationTransformMatrix.SetElement(1,3,24.5)
translationTransformMatrix.SetElement(2,3,11.5)
translationTransformNode = slicer.vtkMRMLLinearTransformNode()
translationTransformNode.SetName('TestTranslation')
slicer.mrmlScene.AddNode(translationTransformNode)
translationTransformNode.SetMatrixTransformToParent(translationTransformMatrix)
tinyVolumeNode.SetAndObserveTransformNodeID(translationTransformNode.GetID())
geometryWidget.geometryImageData(geometryImageData)
self.assertTrue(self.compareOutputGeometry(geometryImageData,
(49,49,23), (224.3439, 223.7890, -135.25),
[[-1.0, 0.0, 0.0], [0.0, -1.0, 0.0], [0.0, 0.0, 1.0]]))
vtkSegmentationCore.vtkOrientedImageDataResample.ResampleOrientedImageToReferenceOrientedImage(
segmentOrientedImageData, geometryImageData, geometryImageData, False, True)
self.assertEqual(self.getForegroundVoxelCount(geometryImageData), 94)
# Volume source with isotropic spacing
tinyVolumeNode.SetAndObserveTransformNodeID(None)
geometryWidget.setIsotropicSpacing(True)
geometryWidget.geometryImageData(geometryImageData)
self.assertTrue(self.compareOutputGeometry(geometryImageData,
(23,23,23), (248.8439, 248.2890, -123.75),
[[-1.0, 0.0, 0.0], [0.0, -1.0, 0.0], [0.0, 0.0, 1.0]]))
vtkSegmentationCore.vtkOrientedImageDataResample.ResampleOrientedImageToReferenceOrientedImage(
segmentOrientedImageData, geometryImageData, geometryImageData, False, True)
self.assertEqual(self.getForegroundVoxelCount(geometryImageData), 414)
# Volume source with oversampling
geometryWidget.setIsotropicSpacing(False)
geometryWidget.setOversamplingFactor(2.0)
geometryWidget.geometryImageData(geometryImageData)
self.assertTrue(self.compareOutputGeometry(geometryImageData,
(24.5, 24.5, 11.5), (261.0939, 260.5390, -129.5),
[[-1.0, 0.0, 0.0], [0.0, -1.0, 0.0], [0.0, 0.0, 1.0]]))
vtkSegmentationCore.vtkOrientedImageDataResample.ResampleOrientedImageToReferenceOrientedImage(
segmentOrientedImageData, geometryImageData, geometryImageData, False, True)
self.assertEqual(self.getForegroundVoxelCount(geometryImageData), 751)
slicer.util.delayDisplay('Volume source cases - OK')
# Segmentation source with binary labelmap master
geometryWidget.setOversamplingFactor(1.0)
geometryWidget.setSourceNode(tinySegmentationNode)
geometryWidget.geometryImageData(geometryImageData)
self.assertTrue(self.compareOutputGeometry(geometryImageData,
(49,49,23), (248.8439, 248.2890, -123.75),
[[-1.0, 0.0, 0.0], [0.0, -1.0, 0.0], [0.0, 0.0, 1.0]]))
vtkSegmentationCore.vtkOrientedImageDataResample.ResampleOrientedImageToReferenceOrientedImage(
segmentOrientedImageData, geometryImageData, geometryImageData, False, True)
self.assertEqual(self.getForegroundVoxelCount(geometryImageData), 92)
# Segmentation source with closed surface master
tinySegmentationNode.GetSegmentation().SetConversionParameter('Smoothing factor', '0.0')
self.assertTrue(tinySegmentationNode.GetSegmentation().CreateRepresentation(closedSurfaceReprName))
tinySegmentationNode.GetSegmentation().SetMasterRepresentationName(closedSurfaceReprName)
tinySegmentationNode.Modified() # Trigger re-calculation of geometry (only generic Modified event is observed)
geometryWidget.geometryImageData(geometryImageData)
self.assertTrue(self.compareOutputGeometry(geometryImageData,
(1,1,1), (-167.156, -217.711, -135.75),
[[0.0, 0.0, 1.0], [-1.0, 0.0, 0.0], [0.0, -1.0, 0.0]]))
vtkSegmentationCore.vtkOrientedImageDataResample.ResampleOrientedImageToReferenceOrientedImage(
segmentOrientedImageData, geometryImageData, geometryImageData, False, True)
self.assertEqual(self.getForegroundVoxelCount(geometryImageData), 5223846)
slicer.util.delayDisplay('Segmentation source cases - OK')
# Model source with no transform
outputModelHierarchy = slicer.vtkMRMLModelHierarchyNode()
slicer.mrmlScene.AddNode(outputModelHierarchy)
success = vtkSlicerSegmentationsModuleLogic.vtkSlicerSegmentationsModuleLogic.ExportVisibleSegmentsToModelHierarchy(
tinySegmentationNode, outputModelHierarchy )
self.assertTrue(success)
modelNode = slicer.util.getNode('Body_Contour')
geometryWidget.setSourceNode(modelNode)
geometryWidget.geometryImageData(geometryImageData)
self.assertTrue(self.compareOutputGeometry(geometryImageData,
(1,1,1), (-167.156, -217.711, -135.75),
[[0.0, 0.0, 1.0], [-1.0, 0.0, 0.0], [0.0, -1.0, 0.0]]))
vtkSegmentationCore.vtkOrientedImageDataResample.ResampleOrientedImageToReferenceOrientedImage(
segmentOrientedImageData, geometryImageData, geometryImageData, False, True)
self.assertEqual(self.getForegroundVoxelCount(geometryImageData), 5223846)
# Transformed model source
rotationTransform = vtk.vtkTransform()
rotationTransform.RotateX(45)
rotationTransformMatrix = vtk.vtkMatrix4x4()
rotationTransform.GetMatrix(rotationTransformMatrix)
rotationTransformNode = slicer.vtkMRMLLinearTransformNode()
rotationTransformNode.SetName('TestRotation')
slicer.mrmlScene.AddNode(rotationTransformNode)
rotationTransformNode.SetMatrixTransformToParent(rotationTransformMatrix)
modelNode.SetAndObserveTransformNodeID(rotationTransformNode.GetID())
modelNode.Modified()
geometryWidget.geometryImageData(geometryImageData)
self.assertTrue(self.compareOutputGeometry(geometryImageData,
(1,1,1), (-167.156, -58.6623, -249.228),
[[0.0, 0.0, 1.0], [-0.7071, -0.7071, 0.0], [0.7071, -0.7071, 0.0]]))
vtkSegmentationCore.vtkOrientedImageDataResample.ResampleOrientedImageToReferenceOrientedImage(
segmentOrientedImageData, geometryImageData, geometryImageData, False, True)
self.assertEqual(self.getForegroundVoxelCount(geometryImageData), 5221241)
# ROI source
roiNode = slicer.vtkMRMLAnnotationROINode()
roiNode.SetName('SourceROI')
slicer.mrmlScene.AddNode(roiNode)
roiNode.UnRegister(None)
xyz = [0]*3
center = [0]*3
slicer.vtkMRMLSliceLogic.GetVolumeRASBox(tinyVolumeNode, xyz, center)
radius = map(lambda x: x/2.0, xyz)
roiNode.SetXYZ(center)
roiNode.SetRadiusXYZ(radius)
geometryWidget.setSourceNode(roiNode)
geometryWidget.geometryImageData(geometryImageData)
self.assertTrue(self.compareOutputGeometry(geometryImageData,
(1,1,1), (-216.156, -217.711, -135.75),
[[0.0, 0.0, 1.0], [-1.0, 0.0, 0.0], [0.0, -1.0, 0.0]]))
vtkSegmentationCore.vtkOrientedImageDataResample.ResampleOrientedImageToReferenceOrientedImage(
segmentOrientedImageData, geometryImageData, geometryImageData, False, True)
self.assertEqual(self.getForegroundVoxelCount(geometryImageData), 5223846)
slicer.util.delayDisplay('Model and ROI source cases - OK')
slicer.util.delayDisplay('Segmentation geometry widget test passed')
def transform(self,cmd):
if not hasattr(self,'p'):
self.p = numpy.zeros(3)
self.dpdt = numpy.zeros(3)
self.d2pdt2 = numpy.zeros(3)
self.o = numpy.zeros(3)
self.dodt = numpy.zeros(3)
self.d2odt2 = numpy.zeros(3)
p = urlparse.urlparse(cmd)
q = urlparse.parse_qs(p.query)
print (q)
dt = float(q['interval'][0])
self.d2pdt2 = 1000 * numpy.array([float(q['x'][0]), float(q['y'][0]), float(q['z'][0])])
if not hasattr(self,'g0'):
self.g0 = self.d2pdt2
self.d2pdt2 = self.d2pdt2 - self.g0
self.dpdt = self.dpdt + dt * self.d2pdt2
self.p = self.p + dt * self.dpdt
# TODO: integrate rotations
if not hasattr(self, "idevice"):
""" set up the mrml parts or use existing """
nodes = slicer.mrmlScene.GetNodesByName('idevice')
if nodes.GetNumberOfItems() > 0:
self.idevice = nodes.GetItemAsObject(0)
nodes = slicer.mrmlScene.GetNodesByName('tracker')
self.tracker = nodes.GetItemAsObject(0)
else:
# idevice cursor
self.cube = vtk.vtkCubeSource()
self.cube.SetXLength(30)
self.cube.SetYLength(70)
self.cube.SetZLength(5)
self.cube.Update()
# display node
self.modelDisplay = slicer.vtkMRMLModelDisplayNode()
self.modelDisplay.SetColor(1,1,0) # yellow
slicer.mrmlScene.AddNode(self.modelDisplay)
self.modelDisplay.SetPolyData(self.cube.GetOutput())
# Create model node
self.idevice = slicer.vtkMRMLModelNode()
self.idevice.SetScene(slicer.mrmlScene)
self.idevice.SetName("idevice")
self.idevice.SetAndObservePolyData(self.cube.GetOutput())
self.idevice.SetAndObserveDisplayNodeID(self.modelDisplay.GetID())
slicer.mrmlScene.AddNode(self.idevice)
# tracker
self.tracker = slicer.vtkMRMLLinearTransformNode()
self.tracker.SetName('tracker')
slicer.mrmlScene.AddNode(self.tracker)
self.idevice.SetAndObserveTransformNodeID(self.tracker.GetID())
m = self.tracker.GetMatrixTransformToParent()
m.Identity()
up = numpy.zeros(3)
up[2] = 1
d = self.d2pdt2
dd = d / numpy.sqrt(numpy.dot(d,d))
xx = numpy.cross(dd,up)
yy = numpy.cross(dd,xx)
for row in xrange(3):
m.SetElement(row,0, dd[row])
m.SetElement(row,1, xx[row])
m.SetElement(row,2, yy[row])
#m.SetElement(row,3, self.p[row])
return ( "got it" )
def __init__(self):
self.toolTipToTool = slicer.util.getNode('toolTipToTool')
if not self.toolTipToTool:
self.toolTipToTool=slicer.vtkMRMLLinearTransformNode()
self.toolTipToTool.SetName("toolTipToTool")
m = vtk.vtkMatrix4x4()
m.SetElement( 0, 0, 1 ) # Row 1
m.SetElement( 0, 1, 0 )
m.SetElement( 0, 2, 0 )
m.SetElement( 0, 3, 0 )
m.SetElement( 1, 0, 0 ) # Row 2
m.SetElement( 1, 1, 1 )
m.SetElement( 1, 2, 0 )
m.SetElement( 1, 3, 0 )
m.SetElement( 2, 0, 0 ) # Row 3
m.SetElement( 2, 1, 0 )
m.SetElement( 2, 2, 1 )
m.SetElement( 2, 3, 0 )
self.toolTipToTool.SetMatrixTransformToParent(m)
slicer.mrmlScene.AddNode(self.toolTipToTool)
self.toolToReference = slicer.util.getNode('toolToReference')
if not self.toolToReference:
self.toolToReference=slicer.vtkMRMLLinearTransformNode()
self.toolToReference.SetName("toolToReference")
matrixRef = vtk.vtkMatrix4x4()
matrixRef.SetElement( 0, 0, 1 ) # Row 1
matrixRef.SetElement( 0, 1, 0 )
matrixRef.SetElement( 0, 2, 0 )
matrixRef.SetElement( 0, 3, 0 )
matrixRef.SetElement( 1, 0, 0 ) # Row 2
matrixRef.SetElement( 1, 1, 1 )
matrixRef.SetElement( 1, 2, 0 )
matrixRef.SetElement( 1, 3, 0 )
matrixRef.SetElement( 2, 0, 0 ) # Row 3
matrixRef.SetElement( 2, 1, 0 )
matrixRef.SetElement( 2, 2, 1 )
matrixRef.SetElement( 2, 3, 0 )
self.toolToReference.SetMatrixTransformToParent(matrixRef)
slicer.mrmlScene.AddNode(self.toolToReference)
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.targetFiducial = slicer.util.getNode('Target')
if not self.targetFiducial:
self.targetFiducial = slicer.vtkMRMLMarkupsFiducialNode()
self.targetFiducial.SetName('Target')
self.targetFiducial.AddFiducial(0, 0, 0)
self.targetFiducial.SetNthFiducialLabel(0, '')
slicer.mrmlScene.AddNode(self.targetFiducial)
self.targetFiducial.SetDisplayVisibility(True)
self.targetFiducial.GetDisplayNode().SetGlyphType(1) # Vertex2D
self.targetFiducial.GetDisplayNode().SetTextScale(1.3)
self.targetFiducial.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
self.observerTag=None
# Output Distance Label
self.outputDistanceLabel=None
import Viewpoint # Viewpoint Module must have been added to Slicer
self.viewpointLogic = Viewpoint.ViewpointLogic()
# Camera transformations
self.needleCameraToNeedle = slicer.util.getNode('needleCameraToNeedle')
if not self.needleCameraToNeedle:
self.needleCameraToNeedle=slicer.vtkMRMLLinearTransformNode()
self.needleCameraToNeedle.SetName("needleCameraToNeedle")
matrixNeedleCamera = vtk.vtkMatrix4x4()
matrixNeedleCamera.SetElement( 0, 0, -0.05 ) # Row 1
matrixNeedleCamera.SetElement( 0, 1, 0.09 )
matrixNeedleCamera.SetElement( 0, 2, -0.99 )
matrixNeedleCamera.SetElement( 0, 3, 60.72 )
matrixNeedleCamera.SetElement( 1, 0, -0.01 ) # Row 2
matrixNeedleCamera.SetElement( 1, 1, 1 )
matrixNeedleCamera.SetElement( 1, 2, 0.09 )
matrixNeedleCamera.SetElement( 1, 3, 12.17 )
matrixNeedleCamera.SetElement( 2, 0, 1 ) # Row 3
matrixNeedleCamera.SetElement( 2, 1, 0.01 )
matrixNeedleCamera.SetElement( 2, 2, -0.05 )
matrixNeedleCamera.SetElement( 2, 3, -7.26 )
self.needleCameraToNeedle.SetMatrixTransformToParent(matrixNeedleCamera)
slicer.mrmlScene.AddNode(self.needleCameraToNeedle)
self.pointerCameraToPointer = slicer.util.getNode('pointerCameraToPointer')
if not self.pointerCameraToPointer:
self.pointerCameraToPointer=slicer.vtkMRMLLinearTransformNode()
self.pointerCameraToPointer.SetName("pointerCameraToPointer")
matrixPointerCamera = vtk.vtkMatrix4x4()
matrixPointerCamera.SetElement( 0, 0, -0.05 ) # Row 1
matrixPointerCamera.SetElement( 0, 1, 0.09 )
matrixPointerCamera.SetElement( 0, 2, -0.99 )
matrixPointerCamera.SetElement( 0, 3, 121.72 )
matrixPointerCamera.SetElement( 1, 0, -0.01 ) # Row 2
matrixPointerCamera.SetElement( 1, 1, 1 )
matrixPointerCamera.SetElement( 1, 2, 0.09 )
matrixPointerCamera.SetElement( 1, 3, 17.17 )
matrixPointerCamera.SetElement( 2, 0, 1 ) # Row 3
matrixPointerCamera.SetElement( 2, 1, 0.01 )
matrixPointerCamera.SetElement( 2, 2, -0.05 )
matrixPointerCamera.SetElement( 2, 3, -7.26 )
self.pointerCameraToPointer.SetMatrixTransformToParent(matrixPointerCamera)
slicer.mrmlScene.AddNode(self.pointerCameraToPointer)
def findAxisOfMotion(self, origins):
#Following guide from: http://sebastianraschka.com/Articles/2014_pca_step_by_step.html
#scale factor for better display:
scale = 100
#Calculate mean position
meanVector = [0, 0 ,0]
for i in range(3):
meanVector[i] = np.mean(origins[i, :])
#Computing covariance matrix
convMatrix = np.cov([origins[0, :], origins[1, :], origins[2, :]])
#Get eigenvectors
eig_val, eig_vec = np.linalg.eig(convMatrix)
# Make a list of (eigenvalue, eigenvector) tuples
eig_pairs = [(np.abs(eig_val[i]), eig_vec[:,i]) for i in range(len(eig_val))]
# Sort the (eigenvalue, eigenvector) tuples from high to low
eig_pairs.sort()
# eig_pairs.reverse()
matrix_w = np.hstack((eig_pairs[0][1].reshape(3, 1),
eig_pairs[1][1].reshape(3, 1),
eig_pairs[2][1].reshape(3, 1)))
print('Matrix W:\n', matrix_w)
#Create linear transform for contour propagation
vtkMatrix = vtk.vtkMatrix4x4()
transform = slicer.vtkMRMLLinearTransformNode()
slicer.mrmlScene.AddNode(transform)
for i in range(3):
for j in range(3):
vtkMatrix.SetElement(j, i, matrix_w[i, j])
transform.SetAndObserveMatrixTransformFromParent(vtkMatrix)
#Plot eigenvectors from mean position
fiducials = slicer.vtkMRMLMarkupsFiducialNode()
displayNode = slicer.vtkMRMLMarkupsDisplayNode()
# vtkNew<vtkMRMLMarkupsFiducialStorageNode> wFStorageNode;
slicer.mrmlScene.AddNode(displayNode)
slicer.mrmlScene.AddNode(fiducials)
fiducials.SetAndObserveDisplayNodeID(displayNode.GetID())
fiducials.AddFiducialFromArray(meanVector, "Mean Position")
for i in range(len(eig_vec)):
# fiducials.AddFiducialFromArray(meanVector + scale * eig_vec[i], " P " + str(i+1))
#Plot ruler
ruler = slicer.vtkMRMLAnnotationRulerNode()
displayRuler = slicer.vtkMRMLAnnotationLineDisplayNode()
displayRuler.SetLabelVisibility(0)
displayRuler.SetMaxTicks(0)
displayRuler.SetLineWidth(5)
slicer.mrmlScene.AddNode(displayRuler)
slicer.mrmlScene.AddNode(ruler)
ruler.SetAndObserveDisplayNodeID(displayRuler.GetID())
ruler.SetPosition1(meanVector)
ruler.SetPosition2(meanVector + scale * eig_vec[i])
return matrix_w
def run(self, inputT1Volume, inputFLAIRVolume, outputVolume, isBET, absError, gamma, WMMath, minLesionSize, GMlabel, WMLabel):
"""
Run the actual algorithm
"""
if not self.isValidInputOutputData(inputT1Volume, outputVolume):
slicer.util.errorDisplay('Input T1 volume is the same as output volume. Choose a different output volume.')
return False
if not self.isValidInputOutputData(inputFLAIRVolume, outputVolume):
slicer.util.errorDisplay('Input FLAIR volume is the same as output volume. Choose a different output volume.')
return False
logging.info('Processing started')
# Creating FLAIR image copy for processing pipeline
inputFLAIRVolume_tmp = slicer.vtkMRMLScalarVolumeNode()
slicer.mrmlScene.AddNode(inputFLAIRVolume_tmp)
inputT1Volume_tmp = slicer.vtkMRMLScalarVolumeNode()
slicer.mrmlScene.AddNode(inputT1Volume_tmp)
slicer.util.showStatusMessage("Step 1: Bias field correction...")
#################################################################################################################
# Image Processing #
#################################################################################################################
#################################################################################################################
# T2-FLAIR Bias Field Correction #
#################################################################################################################
regParams = {}
regParams["inputImageName"] = inputFLAIRVolume.GetID()
regParams["outputImageName"] = inputFLAIRVolume_tmp.GetID()
slicer.cli.run(slicer.modules.n4itkbiasfieldcorrection, None, regParams, wait_for_completion=True)
#################################################################################################################
# T1 Bias Field Correction #
#################################################################################################################
regParams = {}
regParams["inputImageName"] = inputT1Volume.GetID()
regParams["outputImageName"] = inputT1Volume_tmp.GetID()
slicer.cli.run(slicer.modules.n4itkbiasfieldcorrection, None, regParams, wait_for_completion=True)
# Get the path to LSSegmenter-Data files
path2files = os.path.dirname(slicer.modules.lssegmenter.path)
#################################################################################################################
# Registration - MNI to Native space #
#################################################################################################################
if platform.system() is "Windows":
if isBET:
(read, MNITemplateNode) = slicer.util.loadVolume(
path2files + '\\Resources\\LSSegmenter-Data\\MNI152_T1_1mm_brain.nii.gz',
{}, True)
else:
(read, MNITemplateNode) = slicer.util.loadVolume(
path2files + '\\Resources\\LSSegmenter-Data\\MNI152_T1_1mm.nii.gz', {},
True)
else:
if isBET:
(read, MNITemplateNode) = slicer.util.loadVolume(
path2files + '/Resources/LSSegmenter-Data/MNI152_T1_1mm_brain.nii.gz', {},
True)
else:
(read, MNITemplateNode) = slicer.util.loadVolume(
path2files + '/Resources/LSSegmenter-Data/MNI152_T1_1mm.nii.gz', {}, True)
#
# Registering the FLAIR to T1 space.
#
slicer.util.showStatusMessage("Step 2: FLAIR to T1 space registration...")
regParams = {}
regParams["fixedVolume"] = inputT1Volume.GetID()
regParams["movingVolume"] = inputFLAIRVolume_tmp.GetID()
regParams["outputVolume"] = inputFLAIRVolume_tmp.GetID()
regParams["samplingPercentage"] = 0.02
regParams["splineGridSize"] = '8,8,8'
regParams["initializeTransformMode"] = "useMomentsAlign"
regParams["useRigid"] = True
# regParams["useAffine"] = True
# regParams["useBSpline"] = True
regParams["interpolationMode"] = "Linear"
slicer.cli.run(slicer.modules.brainsfit, None, regParams, wait_for_completion=True)
#
# Registering the MNI template to native space.
#
registrationMNI2NativeTransform = slicer.vtkMRMLLinearTransformNode()
registrationMNI2NativeTransform.SetName("regMNI2Native_linear")
slicer.mrmlScene.AddNode(registrationMNI2NativeTransform)
slicer.util.showStatusMessage("Step 3: MNI152 to native space registration...")
regParams = {}
regParams["fixedVolume"] = inputT1Volume_tmp.GetID()
regParams["movingVolume"] = MNITemplateNode.GetID()
regParams["outputVolume"] = MNITemplateNode.GetID()
regParams["samplingPercentage"] = 0.02
regParams["splineGridSize"] = '8,8,8'
regParams["linearTransform"] = registrationMNI2NativeTransform.GetID()
regParams["initializeTransformMode"] = "useMomentsAlign"
regParams["useRigid"] = True
regParams["useAffine"] = True
regParams["useBSpline"] = True
regParams["interpolationMode"] = "Linear"
slicer.cli.run(slicer.modules.brainsfit, None, regParams, wait_for_completion=True)
if platform.system() is "Windows":
(read, MNIBrainTissues) = slicer.util.loadLabelVolume(
path2files + '\\Resources\\LSSegmenter-Data\\MNI152_T1_1mm_brain_tissues.nii.gz', {}, True)
else:
(read, MNIBrainTissues) = slicer.util.loadLabelVolume(
path2files + '/Resources/LSSegmenter-Data/MNI152_T1_1mm_brain_tissues.nii.gz', {}, True)
slicer.util.showStatusMessage("Step 4: MNI brain template conforming...")
params = {}
params["inputVolume"] = MNIBrainTissues.GetID()
params["referenceVolume"] = inputT1Volume_tmp.GetID()
params["outputVolume"] = MNIBrainTissues.GetID()
params["transformationFile"] = registrationMNI2NativeTransform.GetID()
params["inverseITKTransformation"] = False
params["interpolationType"] = "nn"
slicer.cli.run(slicer.modules.resamplescalarvectordwivolume, None, params, wait_for_completion=True)
slicer.util.showStatusMessage("Step 5: MS lesion segmentation...")
cliParams={}
cliParams["inputT1Volume"] = inputT1Volume_tmp.GetID()
cliParams["inputT2FLAIRVolume"] = inputFLAIRVolume_tmp.GetID()
cliParams["inputMNIVolume"] = MNITemplateNode.GetID()
cliParams["brainLabels"] = MNIBrainTissues.GetID()
cliParams["outputLesionMap"] = outputVolume.GetID()
cliParams["absErrorThreshold"] = absError
cliParams["gamma"] = gamma
cliParams["wmMatch"] = WMMath
cliParams["minimumSize"] = minLesionSize
cliParams["gmMaskValue"] = GMlabel
cliParams["wmMaskValue"] = WMLabel
slicer.cli.run(slicer.modules.automaticflairthreshold, None, cliParams, wait_for_completion=True)
logging.info('Processing completed')
# Removing unnecessary nodes
slicer.mrmlScene.RemoveNode(MNIBrainTissues)
slicer.mrmlScene.RemoveNode(MNITemplateNode)
slicer.mrmlScene.RemoveNode(registrationMNI2NativeTransform)
slicer.mrmlScene.RemoveNode(inputFLAIRVolume_tmp)
slicer.mrmlScene.RemoveNode(inputT1Volume_tmp)
return True
def TestSection_ImportExportSegment(self):
# Import/export, both one label and all labels
logging.info('Test section: Import/export segment')
# Export single segment to model node
bodyModelNode = slicer.vtkMRMLModelNode()
bodyModelNode.SetName('BodyModel')
slicer.mrmlScene.AddNode(bodyModelNode)
bodySegment = self.inputSegmentationNode.GetSegmentation().GetSegment(self.bodySegmentName)
result = slicer.vtkSlicerSegmentationsModuleLogic.ExportSegmentToRepresentationNode(bodySegment, bodyModelNode)
self.assertTrue(result)
self.assertIsNotNone(bodyModelNode.GetPolyData())
#TODO: Number of points increased to 1677 due to end-capping, need to investigate!
#self.assertEqual(bodyModelNode.GetPolyData().GetNumberOfPoints(), 302)
#TODO: On Linux and Windows it is 588, on Mac it is 580. Need to investigate
# self.assertEqual(bodyModelNode.GetPolyData().GetNumberOfCells(), 588)
#self.assertTrue(bodyModelNode.GetPolyData().GetNumberOfCells() == 588 or bodyModelNode.GetPolyData().GetNumberOfCells() == 580)
# Export single segment to volume node
bodyLabelmapNode = slicer.vtkMRMLLabelMapVolumeNode()
bodyLabelmapNode.SetName('BodyLabelmap')
slicer.mrmlScene.AddNode(bodyLabelmapNode)
result = slicer.vtkSlicerSegmentationsModuleLogic.ExportSegmentToRepresentationNode(bodySegment, bodyLabelmapNode)
self.assertTrue(result)
bodyImageData = bodyLabelmapNode.GetImageData()
self.assertIsNotNone(bodyImageData)
imageStat = vtk.vtkImageAccumulate()
imageStat.SetInputData(bodyImageData)
imageStat.Update()
self.assertEqual(imageStat.GetVoxelCount(), 792)
self.assertEqual(imageStat.GetMin()[0], 0)
self.assertEqual(imageStat.GetMax()[0], 1)
# Export multiple segments to volume node
allSegmentsLabelmapNode = slicer.vtkMRMLLabelMapVolumeNode()
allSegmentsLabelmapNode.SetName('AllSegmentsLabelmap')
slicer.mrmlScene.AddNode(allSegmentsLabelmapNode)
result = slicer.vtkSlicerSegmentationsModuleLogic.ExportAllSegmentsToLabelmapNode(self.inputSegmentationNode, allSegmentsLabelmapNode)
self.assertTrue(result)
allSegmentsImageData = allSegmentsLabelmapNode.GetImageData()
self.assertIsNotNone(allSegmentsImageData)
imageStat = vtk.vtkImageAccumulate()
imageStat.SetInputData(allSegmentsImageData)
imageStat.SetComponentExtent(0,5,0,0,0,0)
imageStat.SetComponentOrigin(0,0,0)
imageStat.SetComponentSpacing(1,1,1)
imageStat.Update()
imageStatResult = imageStat.GetOutput()
for i in range(4):
logging.info("Volume {0}: {1}".format(i, imageStatResult.GetScalarComponentAsDouble(i,0,0,0)))
self.assertEqual(imageStat.GetVoxelCount(), 127109360)
self.assertEqual(imageStatResult.GetScalarComponentAsDouble(0,0,0,0), 78967249)
self.assertEqual(imageStatResult.GetScalarComponentAsDouble(1,0,0,0), 39705288)
self.assertEqual(imageStatResult.GetScalarComponentAsDouble(2,0,0,0), 890883)
self.assertEqual(imageStatResult.GetScalarComponentAsDouble(3,0,0,0), 7545940)
# Import model to segment
modelImportSegmentationNode = slicer.mrmlScene.AddNewNodeByClass('vtkMRMLSegmentationNode', 'ModelImport')
modelImportSegmentationNode.GetSegmentation().SetMasterRepresentationName(self.closedSurfaceReprName)
modelSegment = slicer.vtkSlicerSegmentationsModuleLogic.CreateSegmentFromModelNode(bodyModelNode)
modelSegment.UnRegister(None) # Need to release ownership
self.assertIsNotNone(modelSegment)
self.assertIsNotNone(modelSegment.GetRepresentation(self.closedSurfaceReprName))
# Import multi-label labelmap to segmentation
multiLabelImportSegmentationNode = slicer.mrmlScene.AddNewNodeByClass('vtkMRMLSegmentationNode', 'MultiLabelImport')
multiLabelImportSegmentationNode.GetSegmentation().SetMasterRepresentationName(self.binaryLabelmapReprName)
result = slicer.vtkSlicerSegmentationsModuleLogic.ImportLabelmapToSegmentationNode(allSegmentsLabelmapNode, multiLabelImportSegmentationNode)
self.assertTrue(result)
self.assertEqual(multiLabelImportSegmentationNode.GetSegmentation().GetNumberOfSegments(), 3)
# Import labelmap into single segment
singleLabelImportSegmentationNode = slicer.mrmlScene.AddNewNodeByClass('vtkMRMLSegmentationNode', 'SingleLabelImport')
singleLabelImportSegmentationNode.GetSegmentation().SetMasterRepresentationName(self.binaryLabelmapReprName)
# Should not import multi-label labelmap to segment
nullSegment = slicer.vtkSlicerSegmentationsModuleLogic.CreateSegmentFromLabelmapVolumeNode(allSegmentsLabelmapNode)
self.assertIsNone(nullSegment)
logging.info('(This error message is a result of testing an impossible scenario, it is supposed to appear)')
# Make labelmap single-label and import again
threshold = vtk.vtkImageThreshold()
threshold.SetInValue(0)
threshold.SetOutValue(1)
threshold.ReplaceInOn()
threshold.ThresholdByLower(0)
threshold.SetOutputScalarType(vtk.VTK_UNSIGNED_CHAR)
if vtk.VTK_MAJOR_VERSION <= 5:
threshold.SetInput(allSegmentsLabelmapNode.GetImageData())
else:
threshold.SetInputData(allSegmentsLabelmapNode.GetImageData())
threshold.Update()
allSegmentsLabelmapNode.GetImageData().ShallowCopy(threshold.GetOutput())
labelSegment = slicer.vtkSlicerSegmentationsModuleLogic.CreateSegmentFromLabelmapVolumeNode(allSegmentsLabelmapNode)
labelSegment.UnRegister(None) # Need to release ownership
self.assertIsNotNone(labelSegment)
self.assertIsNotNone(labelSegment.GetRepresentation(self.binaryLabelmapReprName))
# Import/export with transforms
logging.info('Test subsection: Import/export with transforms')
# Create transform node that will be used to transform the tested nodes
bodyModelTransformNode = slicer.vtkMRMLLinearTransformNode()
slicer.mrmlScene.AddNode(bodyModelTransformNode)
bodyModelTransform = vtk.vtkTransform()
bodyModelTransform.Translate(1000.0, 0.0, 0.0)
bodyModelTransformNode.ApplyTransformMatrix(bodyModelTransform.GetMatrix())
# Set transform as parent to input segmentation node
self.inputSegmentationNode.SetAndObserveTransformNodeID(bodyModelTransformNode.GetID())
# Export single segment to model node from transformed segmentation
bodyModelNodeTransformed = slicer.vtkMRMLModelNode()
bodyModelNodeTransformed.SetName('BodyModelTransformed')
slicer.mrmlScene.AddNode(bodyModelNodeTransformed)
bodySegment = self.inputSegmentationNode.GetSegmentation().GetSegment(self.bodySegmentName)
result = slicer.vtkSlicerSegmentationsModuleLogic.ExportSegmentToRepresentationNode(bodySegment, bodyModelNodeTransformed)
self.assertTrue(result)
self.assertIsNotNone(bodyModelNodeTransformed.GetParentTransformNode())
# Export single segment to volume node from transformed segmentation
bodyLabelmapNodeTransformed = slicer.vtkMRMLLabelMapVolumeNode()
bodyLabelmapNodeTransformed.SetName('BodyLabelmapTransformed')
slicer.mrmlScene.AddNode(bodyLabelmapNodeTransformed)
result = slicer.vtkSlicerSegmentationsModuleLogic.ExportSegmentToRepresentationNode(bodySegment, bodyLabelmapNodeTransformed)
self.assertTrue(result)
self.assertIsNotNone(bodyLabelmapNodeTransformed.GetParentTransformNode())
# Create transform node that will be used to transform the tested nodes
modelTransformedImportSegmentationTransformNode = slicer.vtkMRMLLinearTransformNode()
slicer.mrmlScene.AddNode(modelTransformedImportSegmentationTransformNode)
modelTransformedImportSegmentationTransform = vtk.vtkTransform()
modelTransformedImportSegmentationTransform.Translate(-500.0, 0.0, 0.0)
modelTransformedImportSegmentationTransformNode.ApplyTransformMatrix(modelTransformedImportSegmentationTransform.GetMatrix())
# Import transformed model to segment in transformed segmentation
modelTransformedImportSegmentationNode = slicer.mrmlScene.AddNewNodeByClass('vtkMRMLSegmentationNode', 'ModelImportTransformed')
modelTransformedImportSegmentationNode.GetSegmentation().SetMasterRepresentationName(self.closedSurfaceReprName)
modelTransformedImportSegmentationNode.SetAndObserveTransformNodeID(modelTransformedImportSegmentationTransformNode.GetID())
modelSegmentTranformed = slicer.vtkSlicerSegmentationsModuleLogic.CreateSegmentFromModelNode(bodyModelNodeTransformed, modelTransformedImportSegmentationNode)
modelSegmentTranformed.UnRegister(None) # Need to release ownership
self.assertIsNotNone(modelSegmentTranformed)
modelSegmentTransformedPolyData = modelSegmentTranformed.GetRepresentation(self.closedSurfaceReprName)
self.assertIsNotNone(modelSegmentTransformedPolyData)
self.assertEqual(int(modelSegmentTransformedPolyData.GetBounds()[0]), 1332)
self.assertEqual(int(modelSegmentTransformedPolyData.GetBounds()[1]), 1675)
# Clean up temporary nodes
slicer.mrmlScene.RemoveNode(bodyModelNode)
slicer.mrmlScene.RemoveNode(bodyLabelmapNode)
slicer.mrmlScene.RemoveNode(allSegmentsLabelmapNode)
slicer.mrmlScene.RemoveNode(modelImportSegmentationNode)
slicer.mrmlScene.RemoveNode(multiLabelImportSegmentationNode)
slicer.mrmlScene.RemoveNode(singleLabelImportSegmentationNode)
slicer.mrmlScene.RemoveNode(bodyModelTransformNode)
slicer.mrmlScene.RemoveNode(bodyModelNodeTransformed)
slicer.mrmlScene.RemoveNode(bodyLabelmapNodeTransformed)
slicer.mrmlScene.RemoveNode(modelTransformedImportSegmentationNode)
def TestSection_3_ImportExportSegment(self):
# Import/export, both one label and all labels
logging.info('Test section 3: Import/export segment')
# Export single segment to model node
bodyModelNode = slicer.vtkMRMLModelNode()
bodyModelNode.SetName('BodyModel')
slicer.mrmlScene.AddNode(bodyModelNode)
bodySegment = self.inputSegmentationNode.GetSegmentation().GetSegment('Body_Contour')
result = vtkSlicerSegmentationsModuleLogic.ExportSegmentToRepresentationNode(bodySegment, bodyModelNode)
self.assertTrue(result)
self.assertIsNotNone(bodyModelNode.GetPolyData())
self.assertEqual(bodyModelNode.GetPolyData().GetNumberOfPoints(), 302)
#TODO: On Linux and Windows it is 588, on Mac it is 580. Need to investigate
# self.assertEqual(bodyModelNode.GetPolyData().GetNumberOfCells(), 588)
self.assertTrue(bodyModelNode.GetPolyData().GetNumberOfCells() == 588 or bodyModelNode.GetPolyData().GetNumberOfCells() == 580)
# Export single segment to volume node
bodyLabelmapNode = slicer.vtkMRMLLabelMapVolumeNode()
bodyLabelmapNode.SetName('BodyLabelmap')
slicer.mrmlScene.AddNode(bodyLabelmapNode)
result = vtkSlicerSegmentationsModuleLogic.ExportSegmentToRepresentationNode(bodySegment, bodyLabelmapNode)
self.assertTrue(result)
bodyImageData = bodyLabelmapNode.GetImageData()
self.assertIsNotNone(bodyImageData)
imageStat = vtk.vtkImageAccumulate()
imageStat.SetInputData(bodyImageData)
imageStat.Update()
self.assertEqual(imageStat.GetVoxelCount(), 648)
self.assertEqual(imageStat.GetMin()[0], 0)
self.assertEqual(imageStat.GetMax()[0], 1)
# Export multiple segments to volume node
allSegmentsLabelmapNode = slicer.vtkMRMLLabelMapVolumeNode()
allSegmentsLabelmapNode.SetName('AllSegmentsLabelmap')
slicer.mrmlScene.AddNode(allSegmentsLabelmapNode)
result = vtkSlicerSegmentationsModuleLogic.ExportAllSegmentsToLabelmapNode(self.inputSegmentationNode, allSegmentsLabelmapNode)
self.assertTrue(result)
allSegmentsImageData = allSegmentsLabelmapNode.GetImageData()
self.assertIsNotNone(allSegmentsImageData)
imageStat = vtk.vtkImageAccumulate()
imageStat.SetInputData(allSegmentsImageData)
imageStat.SetComponentExtent(0,5,0,0,0,0)
imageStat.SetComponentOrigin(0,0,0)
imageStat.SetComponentSpacing(1,1,1)
imageStat.Update()
self.assertEqual(imageStat.GetVoxelCount(), 54872000)
imageStatResult = imageStat.GetOutput()
self.assertEqual(imageStatResult.GetScalarComponentAsDouble(0,0,0,0), 46678738)
self.assertEqual(imageStatResult.GetScalarComponentAsDouble(1,0,0,0), 0)
self.assertEqual(imageStatResult.GetScalarComponentAsDouble(2,0,0,0), 7618805)
self.assertEqual(imageStatResult.GetScalarComponentAsDouble(3,0,0,0), 128968)
self.assertEqual(imageStatResult.GetScalarComponentAsDouble(4,0,0,0), 0) # Built from color table and color four is removed in previous test section
self.assertEqual(imageStatResult.GetScalarComponentAsDouble(5,0,0,0), 445489)
# Import model to segment
modelImportSegmentationNode = vtkMRMLSegmentationNode()
modelImportSegmentationNode.SetName('ModelImport')
modelImportSegmentationNode.GetSegmentation().SetMasterRepresentationName(self.closedSurfaceReprName)
slicer.mrmlScene.AddNode(modelImportSegmentationNode)
modelSegment = vtkSlicerSegmentationsModuleLogic.CreateSegmentFromModelNode(bodyModelNode)
modelSegment.UnRegister(None) # Need to release ownership
self.assertIsNotNone(modelSegment)
self.assertIsNotNone(modelSegment.GetRepresentation(self.closedSurfaceReprName))
# Import multi-label labelmap to segmentation
multiLabelImportSegmentationNode = vtkMRMLSegmentationNode()
multiLabelImportSegmentationNode.SetName('MultiLabelImport')
multiLabelImportSegmentationNode.GetSegmentation().SetMasterRepresentationName(self.binaryLabelmapReprName)
slicer.mrmlScene.AddNode(multiLabelImportSegmentationNode)
result = vtkSlicerSegmentationsModuleLogic.ImportLabelmapToSegmentationNode(allSegmentsLabelmapNode, multiLabelImportSegmentationNode)
self.assertTrue(result)
self.assertEqual(multiLabelImportSegmentationNode.GetSegmentation().GetNumberOfSegments(), 3)
# Import labelmap into single segment
singleLabelImportSegmentationNode = vtkMRMLSegmentationNode()
singleLabelImportSegmentationNode.SetName('SingleLabelImport')
singleLabelImportSegmentationNode.GetSegmentation().SetMasterRepresentationName(self.binaryLabelmapReprName)
slicer.mrmlScene.AddNode(singleLabelImportSegmentationNode)
# Should not import multi-label labelmap to segment
nullSegment = vtkSlicerSegmentationsModuleLogic.CreateSegmentFromLabelmapVolumeNode(allSegmentsLabelmapNode)
self.assertIsNone(nullSegment)
logging.info('(This error message tests an impossible scenario, it is supposed to appear)')
# Make labelmap single-label and import again
threshold = vtk.vtkImageThreshold()
threshold.ThresholdByUpper(0.5)
threshold.SetInValue(1)
threshold.SetOutValue(0)
threshold.SetOutputScalarType(vtk.VTK_UNSIGNED_CHAR)
if vtk.VTK_MAJOR_VERSION <= 5:
threshold.SetInput(allSegmentsLabelmapNode.GetImageData())
else:
threshold.SetInputData(allSegmentsLabelmapNode.GetImageData())
threshold.SetOutput(allSegmentsLabelmapNode.GetImageData())
threshold.Update()
labelSegment = vtkSlicerSegmentationsModuleLogic.CreateSegmentFromLabelmapVolumeNode(allSegmentsLabelmapNode)
labelSegment.UnRegister(None) # Need to release ownership
self.assertIsNotNone(labelSegment)
self.assertIsNotNone(labelSegment.GetRepresentation(self.binaryLabelmapReprName))
# Import/export with transforms
logging.info('Test section 4/2: Import/export with transforms')
# Create transform node that will be used to transform the tested nodes
bodyModelTransformNode = slicer.vtkMRMLLinearTransformNode()
slicer.mrmlScene.AddNode(bodyModelTransformNode)
bodyModelTransform = vtk.vtkTransform()
bodyModelTransform.Translate(1000.0, 0.0, 0.0)
bodyModelTransformNode.ApplyTransformMatrix(bodyModelTransform.GetMatrix())
# Set transform as parent to input segmentation node
self.inputSegmentationNode.SetAndObserveTransformNodeID(bodyModelTransformNode.GetID())
# Export single segment to model node from transformed segmentation
bodyModelNodeTransformed = slicer.vtkMRMLModelNode()
bodyModelNodeTransformed.SetName('BodyModelTransformed')
slicer.mrmlScene.AddNode(bodyModelNodeTransformed)
bodySegment = self.inputSegmentationNode.GetSegmentation().GetSegment('Body_Contour')
result = vtkSlicerSegmentationsModuleLogic.ExportSegmentToRepresentationNode(bodySegment, bodyModelNodeTransformed)
self.assertTrue(result)
self.assertIsNotNone(bodyModelNodeTransformed.GetParentTransformNode())
# Export single segment to volume node from transformed segmentation
bodyLabelmapNodeTransformed = slicer.vtkMRMLLabelMapVolumeNode()
bodyLabelmapNodeTransformed.SetName('BodyLabelmapTransformed')
slicer.mrmlScene.AddNode(bodyLabelmapNodeTransformed)
result = vtkSlicerSegmentationsModuleLogic.ExportSegmentToRepresentationNode(bodySegment, bodyLabelmapNodeTransformed)
self.assertTrue(result)
self.assertIsNotNone(bodyLabelmapNodeTransformed.GetParentTransformNode())
# Create transform node that will be used to transform the tested nodes
modelTransformedImportSegmentationTransformNode = slicer.vtkMRMLLinearTransformNode()
slicer.mrmlScene.AddNode(modelTransformedImportSegmentationTransformNode)
modelTransformedImportSegmentationTransform = vtk.vtkTransform()
modelTransformedImportSegmentationTransform.Translate(-500.0, 0.0, 0.0)
modelTransformedImportSegmentationTransformNode.ApplyTransformMatrix(modelTransformedImportSegmentationTransform.GetMatrix())
# Import transformed model to segment in transformed segmentation
modelTransformedImportSegmentationNode = vtkMRMLSegmentationNode()
modelTransformedImportSegmentationNode.SetName('ModelImportTransformed')
modelTransformedImportSegmentationNode.GetSegmentation().SetMasterRepresentationName(self.closedSurfaceReprName)
slicer.mrmlScene.AddNode(modelTransformedImportSegmentationNode)
modelTransformedImportSegmentationNode.SetAndObserveTransformNodeID(modelTransformedImportSegmentationTransformNode.GetID())
modelSegmentTranformed = vtkSlicerSegmentationsModuleLogic.CreateSegmentFromModelNode(bodyModelNodeTransformed, modelTransformedImportSegmentationNode)
modelSegmentTranformed.UnRegister(None) # Need to release ownership
self.assertIsNotNone(modelSegmentTranformed)
modelSegmentTransformedPolyData = modelSegmentTranformed.GetRepresentation(self.closedSurfaceReprName)
self.assertIsNotNone(modelSegmentTransformedPolyData)
self.assertEqual(int(modelSegmentTransformedPolyData.GetBounds()[0]), 1332)
self.assertEqual(int(modelSegmentTransformedPolyData.GetBounds()[1]), 1675)
# Clean up temporary nodes
slicer.mrmlScene.RemoveNode(bodyModelNode)
slicer.mrmlScene.RemoveNode(bodyLabelmapNode)
slicer.mrmlScene.RemoveNode(allSegmentsLabelmapNode)
slicer.mrmlScene.RemoveNode(modelImportSegmentationNode)
slicer.mrmlScene.RemoveNode(multiLabelImportSegmentationNode)
slicer.mrmlScene.RemoveNode(singleLabelImportSegmentationNode)
slicer.mrmlScene.RemoveNode(bodyModelTransformNode)
slicer.mrmlScene.RemoveNode(bodyModelNodeTransformed)
slicer.mrmlScene.RemoveNode(bodyLabelmapNodeTransformed)
slicer.mrmlScene.RemoveNode(modelTransformedImportSegmentationNode)
def refineLandmark(self, state):
"""Refine the specified landmark"""
# Refine landmark, or if none, do nothing
# Crop images around the fiducial
# Affine registration of the cropped images
# Transform the fiducial using the transformation
#
# No need to take into account the current transformation because landmarks are in World RAS
timing = False
if self.VerboseMode == "Verbose":
timing = True
if state.logic.cropLogic is None:
print("Cannot refine landmarks. CropVolume module is not available.")
if state.fixed == None or state.moving == None or state.fixedFiducials == None or state.movingFiducials == None or state.currentLandmarkName == None:
print "Cannot refine landmarks. Images or landmarks not selected."
return
print ("Refining landmark " + state.currentLandmarkName) + " using " + self.name
start = time.time()
volumes = (state.fixed, state.moving)
(fixedVolume, movingVolume) = volumes
slicer.mrmlScene.StartState(slicer.mrmlScene.BatchProcessState)
landmarks = state.logic.landmarksForVolumes(volumes)
cvpn = slicer.vtkMRMLCropVolumeParametersNode()
cvpn.SetInterpolationMode(1)
cvpn.SetVoxelBased(1)
fixedPoint = [0,]*3
movingPoint = [0,]*3
(fixedFiducial, movingFiducial) = landmarks[state.currentLandmarkName]
(fixedList,fixedIndex) = fixedFiducial
(movingList, movingIndex) = movingFiducial
# define an roi for the fixed
if timing: roiStart = time.time()
roiFixed = slicer.vtkMRMLAnnotationROINode()
slicer.mrmlScene.AddNode(roiFixed)
fixedList.GetNthFiducialPosition(fixedIndex,fixedPoint)
roiFixed.SetDisplayVisibility(0)
roiFixed.SelectableOff()
roiFixed.SetXYZ(fixedPoint)
roiFixed.SetRadiusXYZ(30, 30, 30)
# crop the fixed. note we hide the display node temporarily to avoid the automated
# window level calculation on temporary nodes created by cloning
cvpn.SetROINodeID( roiFixed.GetID() )
cvpn.SetInputVolumeNodeID( fixedVolume.GetID() )
fixedDisplayNode = fixedVolume.GetDisplayNode()
fixedVolume.SetAndObserveDisplayNodeID('This is not a valid DisplayNode ID')
if timing: roiEnd = time.time()
if timing: cropStart = time.time()
state.logic.cropLogic.Apply( cvpn )
if timing: cropEnd = time.time()
croppedFixedVolume = slicer.mrmlScene.GetNodeByID( cvpn.GetOutputVolumeNodeID() )
fixedVolume.SetAndObserveDisplayNodeID(fixedDisplayNode.GetID())
# define an roi for the moving
if timing: roi2Start = time.time()
roiMoving = slicer.vtkMRMLAnnotationROINode()
slicer.mrmlScene.AddNode(roiMoving)
movingList.GetNthFiducialPosition(movingIndex,movingPoint)
roiMoving.SetDisplayVisibility(0)
roiMoving.SelectableOff()
roiMoving.SetXYZ(movingPoint)
if self.LocalBRAINSFitMode == "Small":
roiMoving.SetRadiusXYZ(45, 45, 45)
else:
roiMoving.SetRadiusXYZ(60, 60, 60)
# crop the moving. note we hide the display node temporarily to avoid the automated
# window level calculation on temporary nodes created by cloning
cvpn.SetROINodeID( roiMoving.GetID() )
cvpn.SetInputVolumeNodeID( movingVolume.GetID() )
movingDisplayNode = movingVolume.GetDisplayNode()
movingVolume.SetAndObserveDisplayNodeID('This is not a valid DisplayNode ID')
if timing: roi2End = time.time()
if timing: crop2Start = time.time()
state.logic.cropLogic.Apply( cvpn )
if timing: crop2End = time.time()
croppedMovingVolume = slicer.mrmlScene.GetNodeByID( cvpn.GetOutputVolumeNodeID() )
movingVolume.SetAndObserveDisplayNodeID(movingDisplayNode.GetID())
if timing: print 'Time to set up fixed ROI was ' + str(roiEnd - roiStart) + ' seconds'
if timing: print 'Time to set up moving ROI was ' + str(roi2End - roi2Start) + ' seconds'
if timing: print 'Time to crop fixed volume ' + str(cropEnd - cropStart) + ' seconds'
if timing: print 'Time to crop moving volume ' + str(crop2End - crop2Start) + ' seconds'
#
transform = slicer.vtkMRMLLinearTransformNode()
slicer.mrmlScene.AddNode(transform)
matrix = vtk.vtkMatrix4x4()
# define the registration parameters
minPixelSpacing = min(croppedFixedVolume.GetSpacing())
parameters = {}
parameters['fixedVolume'] = croppedFixedVolume.GetID()
parameters['movingVolume'] = croppedMovingVolume.GetID()
parameters['linearTransform'] = transform.GetID()
parameters['useRigid'] = True
parameters['initializeTransformMode'] = 'useGeometryAlign';
parameters['samplingPercentage'] = 0.2
parameters['minimumStepLength'] = 0.1 * minPixelSpacing
parameters['maximumStepLength'] = minPixelSpacing
# run the registration
if timing: regStart = time.time()
slicer.cli.run(slicer.modules.brainsfit, None, parameters, wait_for_completion=True)
if timing: regEnd = time.time()
if timing: print 'Time for local registration ' + str(regEnd - regStart) + ' seconds'
# apply the local transform to the landmark
#print transform
if timing: resultStart = time.time()
transform.GetMatrixTransformToWorld(matrix)
matrix.Invert()
tp = [0,]*4
tp = matrix.MultiplyPoint(fixedPoint + [1,])
#print fixedPoint, movingPoint, tp[:3]
movingList.SetNthFiducialPosition(movingIndex, tp[0], tp[1], tp[2])
if timing: resultEnd = time.time()
if timing: print 'Time for transforming landmark was ' + str(resultEnd - resultStart) + ' seconds'
# clean up cropped volmes, need to reset the foreground/background display before we delete it
if timing: cleanUpStart = time.time()
slicer.mrmlScene.RemoveNode(croppedFixedVolume)
slicer.mrmlScene.RemoveNode(croppedMovingVolume)
slicer.mrmlScene.RemoveNode(roiFixed)
slicer.mrmlScene.RemoveNode(roiMoving)
slicer.mrmlScene.RemoveNode(transform)
roiFixed = None
roiMoving = None
transform = None
matrix = None
if timing: cleanUpEnd = time.time()
if timing: print 'Cleanup took ' + str(cleanUpEnd - cleanUpStart) + ' seconds'
end = time.time()
print 'Refined landmark ' + state.currentLandmarkName + ' in ' + str(end - start) + ' seconds'
slicer.mrmlScene.EndState(slicer.mrmlScene.BatchProcessState)
def setup(self):
ScriptedLoadableModuleWidget.setup(self)
self.logic = SoundGuidanceLogic()
# Instantiate and connect widgets ...
self.defaultStyleSheet = "QLabel { color : #000000; \
font: bold 14px}"
# Load models first
self.SoundGuidanceModuleModelsPath = slicer.modules.soundguidance.path.replace("SoundGuidance.py","") + 'Resources/Models/'
self.boxModel = slicer.util.getNode('boxModel')
if not self.boxModel:
slicer.util.loadModel(self.SoundGuidanceModuleModelsPath + 'box.stl')
self.boxModel = slicer.util.getNode(pattern="box")
self.boxModelDisplay=self.boxModel.GetModelDisplayNode()
self.boxModelDisplay.SetColor([0.098,0.5,0.42])
self.boxModelDisplay.SetOpacity(0.3)
self.aroModel = slicer.util.getNode('aroModel')
if not self.aroModel:
slicer.util.loadModel(self.SoundGuidanceModuleModelsPath + 'aro.stl')
self.aroModel = slicer.util.getNode(pattern="aro")
self.aroModelDisplay=self.aroModel.GetModelDisplayNode()
self.aroModelDisplay.SetColor([0.063,0.14,0.5])
#We create models
self.needleModel = slicer.util.getNode('NeedleModel')
if not self.needleModel:
slicer.util.loadModel(self.SoundGuidanceModuleModelsPath + 'NeedleModel.stl')
self.needleModel = slicer.util.getNode(pattern="NeedleModel")
self.needleModelDisplay=self.needleModel.GetModelDisplayNode()
self.needleModelDisplay.SetColor([0,1,1])
self.pointerModel = slicer.util.getNode('PointerModel')
if not self.pointerModel:
slicer.util.loadModel(self.SoundGuidanceModuleModelsPath + 'PointerModel.stl')
self.pointerModel = slicer.util.getNode(pattern="PointerModel")
self.pointerModelDisplay=self.pointerModel.GetModelDisplayNode()
self.pointerModelDisplay.SetColor([0,0,0])
self.targetFiducial = slicer.util.getNode('targetFiducial')
if not self.targetFiducial:
slicer.util.loadMarkupsFiducialList(self.SoundGuidanceModuleModelsPath + 'Target.fcsv')
self.targetFiducial = slicer.util.getNode(pattern="Target")
self.surfaceFiducial = slicer.util.getNode('surfaceFiducial')
if not self.surfaceFiducial:
slicer.util.loadMarkupsFiducialList(self.SoundGuidanceModuleModelsPath + 'surfacePoint.fcsv')
self.surfaceFiducial = slicer.util.getNode(pattern="surfacePoint")
self.xAxisFiducial = slicer.util.getNode('xAxisFiducial')
if not self.xAxisFiducial:
slicer.util.loadMarkupsFiducialList(self.SoundGuidanceModuleModelsPath + 'xAxisFiducial.fcsv')
self.xAxisFiducial= slicer.util.getNode(pattern="xAxisFiducial")
# Parameters Area
# Parameters Area
#
parametersCollapsibleButton = ctk.ctkCollapsibleButton()
parametersCollapsibleButton.text = "Parameters"
self.layout.addWidget(parametersCollapsibleButton)
# Layout within the dummy collapsible button
parametersFormLayout = qt.QFormLayout(parametersCollapsibleButton)
#
# Apply Button
#
self.applyButton = qt.QPushButton("Calculate Distance")
self.applyButton.toolTip = "Run the algorithm."
self.applyButton.enabled = True
self.applyButton.checkable = True
parametersFormLayout.addRow(self.applyButton)
# Calculate Distance Label
self.calculateDistanceLabel = qt.QLabel('-')
self.calculateDistanceLabel.setStyleSheet(self.defaultStyleSheet)
self.QFormLayoutLabel = qt.QLabel('Distance to target (mm): ')
self.QFormLayoutLabel.setStyleSheet(self.defaultStyleSheet)
parametersFormLayout.addRow(self.QFormLayoutLabel, self.calculateDistanceLabel)
#
# Sound Button
#
self.playSoundButton = qt.QPushButton("Play Sound")
self.playSoundButton.enabled = True
self.playSoundButton.checkable = True
parametersFormLayout.addRow(self.playSoundButton)
#Load transformations
self.pointerToTracker = slicer.util.getNode('PointerToTracker')
if not self.pointerToTracker:
print('ERROR: pointerToTracker transform node was not found')
self.needleToTracker = slicer.util.getNode('NeedleToTracker')
if not self.needleToTracker:
print('ERROR: needleToTracker transform node was not found')
self.referenceToTracker = slicer.util.getNode('ReferenceToTracker')
if not self.referenceToTracker:
print('ERROR: referenceToTracker transform node was not found')
self.trackerToReference = slicer.util.getNode('TrackerToReference')
if not self.trackerToReference:
print('ERROR: TrackerToReference transform node was not found')
# Load models first
self.SoundGuidanceModuleDataPath = slicer.modules.soundguidance.path.replace("SoundGuidance.py","") + 'Resources/Data/'
self.needleTipToNeedle = slicer.util.getNode('NeedleTipToNeedle')
if not self.needleTipToNeedle:
slicer.util.loadTransform(self.SoundGuidanceModuleDataPath + 'NeedleTipToNeedle.h5')
self.needleTipToNeedle = slicer.util.getNode(pattern="NeedleTipToNeedle")
self.pointerTipToPointer = slicer.util.getNode('PointerTipToPointer')
if not self.pointerTipToPointer:
slicer.util.loadTransform(self.SoundGuidanceModuleDataPath + 'PointerTipToPointer.h5')
self.pointerTipToPointer = slicer.util.getNode(pattern="PointerTipToPointer")
self.boxToReference = slicer.util.getNode('BoxToReference')
if not self.boxToReference:
slicer.util.loadTransform(self.SoundGuidanceModuleDataPath + 'BoxToReference.h5')
self.boxToReference = slicer.util.getNode(pattern="BoxToReference")
# Tranformations to fix models orientation
self.needleModelToNeedleTip = slicer.util.getNode('needleModelToNeedleTip')
if not self.needleModelToNeedleTip:
self.needleModelToNeedleTip=slicer.vtkMRMLLinearTransformNode()
self.needleModelToNeedleTip.SetName("needleModelToNeedleTip")
matrixNeedleModel = vtk.vtkMatrix4x4()
matrixNeedleModel.SetElement( 0, 0, -1 ) # Row 1
matrixNeedleModel.SetElement( 0, 1, 0 )
matrixNeedleModel.SetElement( 0, 2, 0 )
matrixNeedleModel.SetElement( 0, 3, 0 )
matrixNeedleModel.SetElement( 1, 0, 0 ) # Row 2
matrixNeedleModel.SetElement( 1, 1, 1 )
matrixNeedleModel.SetElement( 1, 2, 0 )
matrixNeedleModel.SetElement( 1, 3, 0 )
matrixNeedleModel.SetElement( 2, 0, 0 ) # Row 3
matrixNeedleModel.SetElement( 2, 1, 0 )
matrixNeedleModel.SetElement( 2, 2, -1 )
matrixNeedleModel.SetElement( 2, 3, 0 )
self.needleModelToNeedleTip.SetMatrixTransformToParent(matrixNeedleModel)
slicer.mrmlScene.AddNode(self.needleModelToNeedleTip)
self.pointerModelToPointerTip = slicer.util.getNode('pointerModelToPointerTip')
if not self.pointerModelToPointerTip:
self.pointerModelToPointerTip=slicer.vtkMRMLLinearTransformNode()
self.pointerModelToPointerTip.SetName("pointerModelToPointerTip")
matrixPointerModel = vtk.vtkMatrix4x4()
matrixPointerModel.SetElement( 0, 0, 0 ) # Row 1
matrixPointerModel.SetElement( 0, 1, 0 )
matrixPointerModel.SetElement( 0, 2, 1 )
matrixPointerModel.SetElement( 0, 3, 0 )
matrixPointerModel.SetElement( 1, 0, 0 ) # Row 2
matrixPointerModel.SetElement( 1, 1, 1 )
matrixPointerModel.SetElement( 1, 2, 0 )
matrixPointerModel.SetElement( 1, 3, 0 )
matrixPointerModel.SetElement( 2, 0, -1 ) # Row 3
matrixPointerModel.SetElement( 2, 1, 0 )
matrixPointerModel.SetElement( 2, 2, 0 )
matrixPointerModel.SetElement( 2, 3, 0 )
self.pointerModelToPointerTip.SetMatrixTransformToParent(matrixPointerModel)
slicer.mrmlScene.AddNode(self.pointerModelToPointerTip)
# connections
self.applyButton.connect('clicked(bool)', self.onCalculateDistanceButton)
self.playSoundButton.connect('clicked(bool)', self.onplaySoundButtonClicked)
#Build Transforms tree
# Pointer
self.pointerModel.SetAndObserveTransformNodeID(self.pointerModelToPointerTip.GetID())
self.pointerModelToPointerTip.SetAndObserveTransformNodeID(self.pointerTipToPointer.GetID())
self.pointerTipToPointer.SetAndObserveTransformNodeID(self.pointerToTracker.GetID())
# Needle
self.needleModel.SetAndObserveTransformNodeID(self.needleModelToNeedleTip.GetID())
self.needleModelToNeedleTip.SetAndObserveTransformNodeID(self.needleTipToNeedle.GetID())
self.needleTipToNeedle.SetAndObserveTransformNodeID(self.needleToTracker.GetID())
#Box and aro
self.boxModel.SetAndObserveTransformNodeID(self.boxToReference.GetID())
self.aroModel.SetAndObserveTransformNodeID(self.boxToReference.GetID())
self.targetFiducial.SetAndObserveTransformNodeID(self.boxToReference.GetID())
self.surfaceFiducial.SetAndObserveTransformNodeID(self.boxToReference.GetID())
self.xAxisFiducial.SetAndObserveTransformNodeID(self.boxToReference.GetID())
self.boxToReference.SetAndObserveTransformNodeID(self.referenceToTracker.GetID())
# Add vertical spacer
self.layout.addStretch(1)
import slicer
# test that brainsfit is available and can run
# if this fails, changetracker cannot be used
tfm = slicer.vtkMRMLLinearTransformNode()
slicer.mrmlScene.AddNode(tfm)
vl = slicer.modules.volumes.logic()
if len(sys.argv) > 1:
path1 = sys.argv[1]
path2 = sys.argv[2]
else:
path1 = slicer.app.slicerHome + "/../../Slicer/Libs/MRML/Core/Testing/TestData/fixed.nrrd"
path2 = slicer.app.slicerHome + "/../../Slicer/Libs/MRML/Core/Testing/TestData/moving.nrrd"
vol1 = vl.AddArchetypeVolume(path1, 'fixed', 0)
vol2 = vl.AddArchetypeVolume(path2, 'moving', 1)
parameters = {}
parameters['fixedVolume'] = vol1.GetID()
parameters['movingVolume'] = vol2.GetID()
parameters['useRigid'] = True
#parameters['outputVolume'] = '/tmp/test.nrrd'
parameters['linearTransform'] = tfm.GetID()
print 'ChangeTrackerTest1 brainsfit parameters: ', parameters
cliNode = None
cliNode = slicer.cli.run(slicer.modules.brainsfit, cliNode, parameters, wait_for_completion = True)
def onAddprobe2Button(self):
[success_2, probmodel_2] = slicer.util.loadModel(
'C:\Users\Deniz\Documents\RFNavigation\Probe_removed_casing_Binary_noWire.ply',
returnNode=True)
Probe_2_Transformation = slicer.vtkMRMLLinearTransformNode()
Probe_2_Transformation.ApplyTransform(probmodel_2)
def createTransformNode(name, isBSpline): node = slicer.vtkMRMLBSplineTransformNode() if isBSpline else slicer.vtkMRMLLinearTransformNode() node.SetName(name) slicer.mrmlScene.AddNode(node) return node
