def computeFA(self, inputVolume):
# Create intermediate output volumes
dtiVolume = slicer.mrmlScene.AddNode(slicer.vtkMRMLDiffusionTensorVolumeNode())
outputBaseline = slicer.mrmlScene.AddNode(slicer.vtkMRMLScalarVolumeNode())
# Compute the DTI output volume using the "DWI to DTI estimation" CLI module
module = slicer.modules.dwitodtiestimation
self.delayDisplay(module.title)
logging.info('"%s" started' % module.title)
cliParams = {
'inputVolume': inputVolume.GetID(),
'outputTensor': dtiVolume.GetID(),
'outputBaseline' : outputBaseline.GetID()
}
cliNode = slicer.cli.run(module, None, cliParams, wait_for_completion=True)
logging.info('"%s" completed' % module.title)
# Create output volume
outputScalar = slicer.mrmlScene.AddNode(slicer.vtkMRMLScalarVolumeNode())
# Compute FA output volume using "Diffusion Tensor Scalar Measurements" CLI module
module = slicer.modules.diffusiontensorscalarmeasurements
self.delayDisplay(module.title)
logging.info('"%s" started' % module.title)
cliParams = {
'inputVolume': dtiVolume.GetID(),
'outputScalar': outputScalar.GetID()
}
cliNode = slicer.cli.run(module, None, cliParams, wait_for_completion=True)
logging.info('"%s" completed' % module.title)
return (outputBaseline, outputScalar)
def run(self,inputVolume,outputVolume,pixelSizeX,pixelSizeY,pixelSizeZ):
"""
Run the actual algorithm
"""
#Run Label Map Smoothing Module: Smooth the moving label with Max RMs Err = 1 and Sigma =2.
tmpImageLMS = slicer.vtkMRMLScalarVolumeNode()
tmpImageLMS.SetName('tmp_LMS')
slicer.mrmlScene.AddNode(tmpImageLMS)
self.delayDisplay('Label Map Smoothing')
lms = slicer.modules.labelmapsmoothing
parameters = {}
parameters['labelToSmooth'] = -1
parameters['numberOfIterations'] = 50
parameters['maxRMSError'] = 1.0
parameters['gaussianSigma'] = 2.0
parameters['inputVolume'] = inputVolume.GetID()
parameters['outputVolume'] = tmpImageLMS.GetID()
slicer.cli.run(lms, None, parameters, True)
#Run Resample Scalar Volume Module:Increase the resolution of the output of previous step by dividing the third entity by 2.
tmpImageRSV = slicer.vtkMRMLScalarVolumeNode()
tmpImageLMS.SetName('tmp_RSV')
slicer.mrmlScene.AddNode(tmpImageRSV)
self.delayDisplay('Resample Scalar Volume')
rsv = slicer.modules.resamplescalarvolume
parameters = {}
parameters['outputPixelSpacing'] = "%f,%f,%f" % (pixelSizeX, pixelSizeY, pixelSizeZ)
parameters['interpolationType'] = 'linear'
parameters['InputVolume'] = tmpImageLMS.GetID()
parameters['OutputVolume'] = tmpImageRSV.GetID()
slicer.cli.run(rsv, None, parameters, True)
#Run Label Smoothing Module: Smooth the output of previous step with Max RMs Err = 0.5 and Sigma =1.
self.delayDisplay('Label Map Smoothing')
parameters = {}
parameters['labelToSmooth'] = -1
parameters['numberOfIterations'] = 50
parameters['maxRMSError'] = 0.5
parameters['gaussianSigma'] = 1
parameters['inputVolume'] = tmpImageRSV.GetID()
parameters['outputVolume'] = outputVolume.GetID()
slicer.cli.run(lms, None, parameters, True)
#Remove temporary nodes.
slicer.mrmlScene.RemoveNode(tmpImageLMS)
slicer.mrmlScene.RemoveNode(tmpImageRSV)
#Run Image Resample module: Use your Transformation and apply it on the output of the previous step.
#Registration Metric: Calculate HD and DSC.
return True
def onApply(self):
fixedVolumeNode = self.fixedImageSelector.currentNode()
movingVolumeSequenceNode = self.movingImageSequenceSelector.currentNode()
maskROINode = self.InputROISelector.currentNode()
initialTransformNode = self.linearTransformSelector.currentNode()
initializeTransformModeOption = self.initializeTransformModeOption
outputTransformSequenceNode = self.outputTransformSequenceSelector.currentNode()
outputVolumeSequenceNode = self.outputImageSequenceSelector.currentNode()
logic = SequenceRegistrationLogic()
if maskROINode:
print("create the mask from ROI")
if self.maskVolumeNode == None:
self.maskVolumeNode = slicer.vtkMRMLScalarVolumeNode()
slicer.mrmlScene.AddNode(self.maskVolumeNode)
logic.makeMaskVolumeFromROI(fixedVolumeNode, self.maskVolumeNode, maskROINode)
else:
slicer.mrmlScene.RemoveNode(self.maskVolumeNode)
self.maskVolumeNode = None
print("Start the registration")
logic.RegisterImageSequence(fixedVolumeNode, movingVolumeSequenceNode, outputTransformSequenceNode, outputVolumeSequenceNode, initializeTransformModeOption, initialTransformNode, self.maskVolumeNode)
print("finish the registration")
def registerVolumes(self, fixedVolumeName, fixedTransformName, movingVolumeName, movingTransformName, registrationTransformName):
# self.Registered = False
# get the nodes
fixedTransformNode = slicer.util.getNode(fixedTransformName)
movingTransformNode = slicer.util.getNode(movingTransformName)
fixedVolumeNode = slicer.util.getNode(fixedVolumeName)
movingVolumeNode = slicer.util.getNode(movingVolumeName)
# check volumes
if not fixedVolumeNode or not movingVolumeNode:
print('Registration failed: the volume nodes are not set correctly')
return False
# setup the brainsfit CLI module
parameters = {}
parameters["fixedVolume"] = fixedVolumeNode.GetID()
parameters["movingVolume"] = movingVolumeNode.GetID()
parameters["useRigid"] = True
transformNode = slicer.util.getNode(registrationTransformName);
if not transformNode == None:
slicer.mrmlScene.RemoveNode(transformNode)
registrationTransformNode = slicer.vtkMRMLLinearTransformNode()
registrationTransformNode.SetName(registrationTransformName)
slicer.mrmlScene.AddNode(registrationTransformNode)
parameters["linearTransform"] = registrationTransformNode.GetID()
parameters["initializeTransformMode"] = "useCenterOfHeadAlign"
outputVolumeName = movingVolumeNode.GetName() + "_" + fixedVolumeNode.GetName();
outputVolumeNode = slicer.util.getNode(outputVolumeName)
if outputVolumeNode is None:
outputVolumeNode = slicer.vtkMRMLScalarVolumeNode()
slicer.mrmlScene.AddNode(outputVolumeNode)
outputVolumeNode.SetName(outputVolumeName)
parameters["outputVolume"] = outputVolumeNode.GetID()
brainsfit = slicer.modules.brainsfit
# run the registration
cliBrainsFitRigidNode = slicer.cli.run(brainsfit, None, parameters)
# cliBrainsFitRigidNode = slicer.cli.run(brainsfit, None, parameters, True) # El ultimo true es para que espere hasta la finalizacion
waitCount = 0
while cliBrainsFitRigidNode.GetStatusString() != 'Completed' and waitCount < self.REGISTRATION_TIMEOUT:
self.delayDisplay("Register " + movingVolumeNode.GetName() + " to " + fixedVolumeNode.GetName() + "... %d" % waitCount)
waitCount += 1
self.delayDisplay("Register " + movingVolumeNode.GetName() + "to " + fixedVolumeNode.GetName() + " finished")
qt.QApplication.restoreOverrideCursor()
if not cliBrainsFitRigidNode:
slicer.mrmlScene.RemoveNode(registrationTransformNode.GetID())
print('Registration failed: Brainsfit module failed')
else:
# attach the transform to the moving volume
movingVolumeNode.SetAndObserveTransformNodeID(registrationTransformNode.GetID())
pass
return cliBrainsFitRigidNode
def onSubtractionRequest(self):
""" This method subtracts two images pixel-for-pixel using Slicer's
subtractscalarvolumes module. It apparently can deal with differently
sized images. A new volume is created and displayed, subtractVolume.
"""
pNode = self.parameterNode()
baselineVolumeID = pNode.GetParameter('baselineVolumeID')
followupVolumeID = pNode.GetParameter('followupVolumeID')
followupVolume = Helper.getNodeByID(followupVolumeID)
baselineVolume = Helper.getNodeByID(baselineVolumeID)
subtractVolume = slicer.vtkMRMLScalarVolumeNode()
subtractVolume.SetScene(slicer.mrmlScene)
subtractVolume.SetName(Helper.getNodeByID(baselineVolumeID).GetName() + '_subtraction')
slicer.mrmlScene.AddNode(subtractVolume)
pNode.SetParameter('subtractVolumeID', subtractVolume.GetID())
# TO-D0: Understand the math behind interpolation order in image subtraction
parameters = {}
parameters["inputVolume1"] = followupVolume
parameters["inputVolume2"] = baselineVolume
parameters['outputVolume'] = subtractVolume
parameters['order'] = '1'
self.__cliNode = None
self.__cliNode = slicer.cli.run(slicer.modules.subtractscalarvolumes, self.__cliNode, parameters)
# An event listener for the CLI. To-Do: Add a progress bar.
self.__cliObserverTag = self.__cliNode.AddObserver('ModifiedEvent', self.processSubtractionCompletion)
self.__subtractionButton.setText('Subtraction running...')
self.__subtractionButton.setEnabled(0)
def extractFrame(scalarVolumeNode, multiVolumeNode, frameId):
# Extract frame from multiVolumeNode and put it into scalarVolumeNode
# if no scalar volume given, create one
if scalarVolumeNode is None:
scalarVolumeNode = slicer.vtkMRMLScalarVolumeNode()
scalarVolumeNode.SetScene(slicer.mrmlScene)
slicer.mrmlScene.AddNode(scalarVolumeNode)
# Extract the image data
mvImage = multiVolumeNode.GetImageData()
extract = vtk.vtkImageExtractComponents()
extract.SetInputData(mvImage)
extract.SetComponents(frameId)
extract.Update()
ras2ijk = vtk.vtkMatrix4x4()
ijk2ras = vtk.vtkMatrix4x4()
multiVolumeNode.GetRASToIJKMatrix(ras2ijk)
multiVolumeNode.GetIJKToRASMatrix(ijk2ras)
scalarVolumeNode.SetRASToIJKMatrix(ras2ijk)
scalarVolumeNode.SetIJKToRASMatrix(ijk2ras)
scalarVolumeNode.SetAndObserveImageData(extract.GetOutput())
displayNode = scalarVolumeNode.GetDisplayNode()
if displayNode is None:
displayNode = slicer.mrmlScene.CreateNodeByClass(
'vtkMRMLScalarVolumeDisplayNode')
displayNode.SetReferenceCount(1)
displayNode.SetScene(slicer.mrmlScene)
slicer.mrmlScene.AddNode(displayNode)
displayNode.SetDefaultColorMap()
scalarVolumeNode.SetAndObserveDisplayNodeID(displayNode.GetID())
return scalarVolumeNode
def onSubtractionRequest(self):
""" This method subtracts two images pixel-for-pixel using Slicer's
subtractscalarvolumes module. It apparently can deal with differently
sized images. A new volume is created and displayed, subtractVolume.
"""
pNode = self.parameterNode()
baselineVolumeID = pNode.GetParameter('baselineVolumeID')
followupVolumeID = pNode.GetParameter('followupVolumeID')
followupVolume = Helper.getNodeByID(followupVolumeID)
baselineVolume = Helper.getNodeByID(baselineVolumeID)
subtractVolume = slicer.vtkMRMLScalarVolumeNode()
subtractVolume.SetScene(slicer.mrmlScene)
subtractVolume.SetName(
Helper.getNodeByID(baselineVolumeID).GetName() + '_subtraction')
slicer.mrmlScene.AddNode(subtractVolume)
pNode.SetParameter('subtractVolumeID', subtractVolume.GetID())
# TO-D0: Understand the math behind interpolation order in image subtraction
parameters = {}
parameters["inputVolume1"] = followupVolume
parameters["inputVolume2"] = baselineVolume
parameters['outputVolume'] = subtractVolume
parameters['order'] = '1'
self.__cliNode = None
self.__cliNode = slicer.cli.run(slicer.modules.subtractscalarvolumes,
self.__cliNode, parameters)
# An event listener for the CLI. To-Do: Add a progress bar.
self.__cliObserverTag = self.__cliNode.AddObserver(
'ModifiedEvent', self.processSubtractionCompletion)
self.__subtractionButton.setText('Subtraction running...')
self.__subtractionButton.setEnabled(0)
def onSubtractButtonClicked(self):
scene = slicer.mrmlScene
subtractmodule = slicer.modules.subtractscalarvolumes
vols = self.loadVolumesForTesting()
fixedVolume = vols["fixedVolume"]
movingVolume = vols["movingVolume"]
parameters = {}
parameters["inputVolume1"] = fixedVolume
parameters["inputVolume2"] = movingVolume
outputVolume = slicer.vtkMRMLScalarVolumeNode()
outputVolume.SetModifiedSinceRead(1)
outputVolume.SetName('subtracted_volume')
scene.AddNode(outputVolume) # Important before GetID()!
parameters["outputVolume"] = outputVolume.GetID()
print "Calling subtract volumes CLI..."
self.__cliNode = None
self.__cliNode = slicer.cli.run(subtractmodule, self.__cliNode, parameters)
# Each time the event is modified, the function processSubtractCompletion will be called.
self.__cliObserverTag = self.__cliNode.AddObserver('ModifiedEvent', self.processSubtractCompletion)
self.__subtractStatus.setText('Wait ...')
self.__subtractButton.setEnabled(0)
def loadTCGAData(self):
slicer.util.openAddVolumeDialog()
red_logic = slicer.app.layoutManager().sliceWidget("Red").sliceLogic()
red_cn = red_logic.GetSliceCompositeNode()
fgrdVolID = red_cn.GetBackgroundVolumeID()
fgrdNode = slicer.util.getNode(fgrdVolID)
fMat=vtk.vtkMatrix4x4()
fgrdNode.GetIJKToRASDirectionMatrix(fMat)
bgrdName = fgrdNode.GetName() + '_gray'
self.tilename = fgrdNode.GetName() + '_gray'
self.parameterNode.SetParameter("SlicerPathology,tilename", self.tilename)
# Get dummy grayscale image
magnitude = vtk.vtkImageMagnitude()
magnitude.SetInputData(fgrdNode.GetImageData())
magnitude.Update()
bgrdNode = slicer.vtkMRMLScalarVolumeNode()
bgrdNode.SetImageDataConnection(magnitude.GetOutputPort())
bgrdNode.SetName(bgrdName)
bgrdNode.SetIJKToRASDirectionMatrix(fMat)
slicer.mrmlScene.AddNode(bgrdNode)
bgrdVolID = bgrdNode.GetID()
# Reset slice configuration
red_cn.SetForegroundVolumeID(fgrdVolID)
red_cn.SetBackgroundVolumeID(bgrdVolID)
red_cn.SetForegroundOpacity(1)
self.checkAndSetLUT()
print bgrdName
cv = slicer.util.getNode(bgrdName)
self.volumesLogic = slicer.modules.volumes.logic()
labelName = bgrdName+'-label'
refLabel = self.volumesLogic.CreateAndAddLabelVolume(slicer.mrmlScene,cv,labelName)
refLabel.GetDisplayNode().SetAndObserveColorNodeID(self.SlicerPathologyColorNode.GetID())
self.editorWidget.helper.setMasterVolume(cv)
def testElastixLogic(self):
print("Starting the test")
#
# first, get some data
#
slicer.mrmlScene.Clear(0)
import SampleData
sampleDataLogic = SampleData.SampleDataLogic()
tumor1 = sampleDataLogic.downloadMRBrainTumor1()
tumor2 = sampleDataLogic.downloadMRBrainTumor2()
outputVolume = slicer.vtkMRMLScalarVolumeNode()
slicer.mrmlScene.AddNode(outputVolume)
outputVolume.CreateDefaultDisplayNodes()
#self.useLocalRegisterVolumes = False
self.setLogic()
parameterFilenames = ["QuickCenteringRigid.txt"]
self.registrationLogic.registerVolumes(
tumor1,
tumor2,
parameterFilenames=parameterFilenames,
outputVolumeNode=outputVolume)
selectionNode = slicer.app.applicationLogic().GetSelectionNode()
selectionNode.SetReferenceActiveVolumeID(outputVolume.GetID())
slicer.app.applicationLogic().PropagateVolumeSelection(0)
def setupScene(self):
logging.info("UltraSound.setupScene")
# live ultrasound
liveUltrasoundNodeName = self.guideletParent.parameterNode.GetParameter("LiveUltrasoundNodeName")
self.liveUltrasoundNode_Reference = slicer.util.getNode(liveUltrasoundNodeName)
if not self.liveUltrasoundNode_Reference:
imageSpacing = [0.2, 0.2, 0.2]
# Create an empty image volume
imageData = vtk.vtkImageData()
imageData.SetDimensions(self.DEFAULT_IMAGE_SIZE)
imageData.AllocateScalars(vtk.VTK_UNSIGNED_CHAR, 1)
thresholder = vtk.vtkImageThreshold()
thresholder.SetInputData(imageData)
thresholder.SetInValue(0)
thresholder.SetOutValue(0)
# Create volume node
self.liveUltrasoundNode_Reference = slicer.vtkMRMLScalarVolumeNode()
self.liveUltrasoundNode_Reference.SetName(liveUltrasoundNodeName)
self.liveUltrasoundNode_Reference.SetSpacing(imageSpacing)
self.liveUltrasoundNode_Reference.SetImageDataConnection(thresholder.GetOutputPort())
# Add volume to scene
slicer.mrmlScene.AddNode(self.liveUltrasoundNode_Reference)
displayNode = slicer.vtkMRMLScalarVolumeDisplayNode()
slicer.mrmlScene.AddNode(displayNode)
colorNode = slicer.util.getNode("Grey")
displayNode.SetAndObserveColorNodeID(colorNode.GetID())
self.liveUltrasoundNode_Reference.SetAndObserveDisplayNodeID(displayNode.GetID())
# self.liveUltrasoundNode_Reference.CreateDefaultStorageNode()
self.setupResliceDriver()
def CreateNewNode(self, colorName, color, dim, origin):
# we add a pseudo-random number to the name of our empty volume to avoid the risk of having a volume called
# exactly the same by the user which could be confusing. We could also have used slicer.app.sessionId()
if colorName not in self.colorSliceVolumes.keys():
VolumeName = "EasyClip_EmptyVolume_" + str(slicer.app.applicationPid()) + "_" + colorName
# Do NOT set the spacing and the origin of imageData (vtkImageData)
# The spacing and the origin should only be set in the vtkMRMLScalarVolumeNode!!!!!!
# We only create an image of 1 voxel (as we only use it to color the planes
imageData = vtk.vtkImageData()
imageData.SetDimensions(1, 1, 1)
imageData.AllocateScalars(vtk.VTK_UNSIGNED_CHAR, 1)
imageData.SetScalarComponentFromDouble(0, 0, 0, 0, color)
if hasattr(slicer, 'vtkMRMLLabelMapVolumeNode'):
sampleVolumeNode = slicer.vtkMRMLLabelMapVolumeNode()
else:
sampleVolumeNode = slicer.vtkMRMLScalarVolumeNode()
sampleVolumeNode = slicer.mrmlScene.AddNode(sampleVolumeNode)
sampleVolumeNode.SetName(VolumeName)
labelmapVolumeDisplayNode = slicer.vtkMRMLLabelMapVolumeDisplayNode()
slicer.mrmlScene.AddNode(labelmapVolumeDisplayNode)
colorNode = slicer.util.getNode('GenericAnatomyColors')
labelmapVolumeDisplayNode.SetAndObserveColorNodeID(colorNode.GetID())
sampleVolumeNode.SetAndObserveImageData(imageData)
sampleVolumeNode.SetAndObserveDisplayNodeID(labelmapVolumeDisplayNode.GetID())
labelmapVolumeDisplayNode.VisibilityOff()
self.colorSliceVolumes[colorName] = sampleVolumeNode.GetID()
sampleVolumeNode = slicer.mrmlScene.GetNodeByID(self.colorSliceVolumes[colorName])
sampleVolumeNode.HideFromEditorsOn()
sampleVolumeNode.SetOrigin(origin[0], origin[1], origin[2])
sampleVolumeNode.SetSpacing(dim[0], dim[1], dim[2])
if not hasattr(slicer, 'vtkMRMLLabelMapVolumeNode'):
sampleVolumeNode.SetLabelMap(1)
sampleVolumeNode.SetHideFromEditors(True)
sampleVolumeNode.SetSaveWithScene(False)
return sampleVolumeNode
def onSubtractButtonClicked(self):
scene = slicer.mrmlScene
subtractmodule = slicer.modules.subtractscalarvolumes
vols = self.loadVolumesForTesting()
fixedVolume = vols["fixedVolume"]
movingVolume = vols["movingVolume"]
parameters = {}
parameters["inputVolume1"] = fixedVolume
parameters["inputVolume2"] = movingVolume
outputVolume = slicer.vtkMRMLScalarVolumeNode()
outputVolume.SetModifiedSinceRead(1)
outputVolume.SetName('subtracted_volume')
scene.AddNode(outputVolume) # Important before GetID()!
parameters["outputVolume"] = outputVolume.GetID()
print "Calling subtract volumes CLI..."
self.__cliNode = None
self.__cliNode = slicer.cli.run(subtractmodule, self.__cliNode,
parameters)
# Each time the event is modified, the function processSubtractCompletion will be called.
self.__cliObserverTag = self.__cliNode.AddObserver(
'ModifiedEvent', self.processSubtractCompletion)
self.__subtractStatus.setText('Wait ...')
self.__subtractButton.setEnabled(0)
def interpolateScalarVolumeNode3D(selNode, outputPixelSpacing=(3, 3, 3)):
from __main__ import vtk, qt, ctk, slicer, os
resampledNode = slicer.vtkMRMLScalarVolumeNode()
resampledImageNode.SetName(selNode.GetName() + "_resampled")
slicer.mrmlScene.AddNode(resampledNode)
resampleScalarVolume(selNode, resampledNode, outputPixelSpacing)
return resampledNode
def setWarpVolume(self):
warpVolume = slicer.vtkMRMLScalarVolumeNode()
slicer.mrmlScene.AddNode(warpVolume)
storageNode = warpVolume.CreateDefaultStorageNode()
slicer.mrmlScene.AddNode(storageNode)
warpVolume.SetAndObserveStorageNodeID(storageNode.GetID())
self.warpVolume = warpVolume
def downsampleCT(self, input_image):
"""Downsample input image by factor 2
:params input_image: image to downsample
"""
oldSpacing = input_image.GetSpacing()
newSpacing = []
newSpacing.append(oldSpacing[0] * 2)
newSpacing.append(oldSpacing[1] * 2)
newSpacing.append(oldSpacing[2])
resamplescalarvolume = slicer.modules.resamplescalarvolume
upsampledNode = slicer.mrmlScene.AddNode(
slicer.vtkMRMLScalarVolumeNode())
parameters = {
"outputPixelSpacing": newSpacing,
"InputVolume": input_image.GetID(),
"OutputVolume": upsampledNode.GetID(),
}
slicer.cli.run(resamplescalarvolume,
None,
parameters,
wait_for_completion=True)
return upsampledNode
def test_VolumeClipWithRoi1(self):
# Download MRHead from sample data
import SampleData
sampleDataLogic = SampleData.SampleDataLogic()
self.delayDisplay("Getting MR Head Volume")
mrHeadVolume = sampleDataLogic.downloadMRHead()
# Create output volume
outputVolume = slicer.vtkMRMLScalarVolumeNode()
slicer.mrmlScene.AddNode(outputVolume)
# Create clipping ROI
roiNode = slicer.vtkMRMLAnnotationROINode()
roiNode.SetXYZ(36, 17, -10)
roiNode.SetRadiusXYZ(25, 40, 65)
roiNode.Initialize(slicer.mrmlScene)
fillValue = 17
clipOutsideSurface = True
logic = VolumeClipWithRoiLogic()
logic.clipVolumeWithRoi(roiNode, mrHeadVolume, fillValue,
clipOutsideSurface, outputVolume)
self.delayDisplay("Test passed!")
def createSampleLabelmapVolumeNode(self, volumeNode, name, label, colorNode=None):
self.assertTrue( volumeNode != None )
self.assertTrue( volumeNode.IsA('vtkMRMLScalarVolumeNode') )
self.assertTrue( label > 0 )
sampleLabelmapNode = slicer.vtkMRMLScalarVolumeNode()
sampleLabelmapNode.SetName(name)
sampleLabelmapNode.SetLabelMap(1)
sampleLabelmapNode = slicer.mrmlScene.AddNode(sampleLabelmapNode)
sampleLabelmapNode.Copy(volumeNode)
imageData = vtk.vtkImageData()
imageData.DeepCopy(volumeNode.GetImageData())
sampleLabelmapNode.SetAndObserveImageData(imageData)
extent = imageData.GetExtent()
for x in xrange(extent[0], extent[1]+1):
for y in xrange(extent[2], extent[3]+1):
for z in xrange(extent[4], extent[5]+1):
if (x >= (extent[1]/4) and x <= (extent[1]/4) * 3) and (y >= (extent[3]/4) and y <= (extent[3]/4) * 3) and (z >= (extent[5]/4) and z <= (extent[5]/4) * 3):
imageData.SetScalarComponentFromDouble(x,y,z,0,label)
else:
imageData.SetScalarComponentFromDouble(x,y,z,0,0)
# Display labelmap
labelmapVolumeDisplayNode = slicer.vtkMRMLLabelMapVolumeDisplayNode()
slicer.mrmlScene.AddNode(labelmapVolumeDisplayNode)
if colorNode == None:
colorNode = slicer.util.getNode('GenericAnatomyColors')
self.assertTrue( colorNode != None )
labelmapVolumeDisplayNode.SetAndObserveColorNodeID(colorNode.GetID())
labelmapVolumeDisplayNode.VisibilityOn()
sampleLabelmapNode.SetAndObserveDisplayNodeID(labelmapVolumeDisplayNode.GetID())
return sampleLabelmapNode
def cropVolumeFromLandmarks(self, name, clipOutside):
# Input Volume
inputVolume = slicer.mrmlScene.GetNodeByID('vtkMRMLScalarVolumeNode1')
# Create empty model node
clippingModel = slicer.vtkMRMLModelNode()
clippingModel.SetName('clipModel')
slicer.mrmlScene.AddNode(clippingModel)
# Create output volume
outputVolume = slicer.vtkMRMLScalarVolumeNode()
outputVolume.SetName(name)
slicer.mrmlScene.AddNode(outputVolume)
# Get crop landmarks
landmarks = slicer.mrmlScene.GetNodesByName('Crop Landmarks')
cropLandmarks = landmarks.GetItemAsObject(0)
# Clip volume
#logic = VolumeClipWithModelLogic()
logic = VolumeClipWithModel.VolumeClipWithModelLogic()
clipOutsideSurface = clipOutside
fillValue = -1000
logic.updateModelFromMarkup(cropLandmarks, clippingModel)
logic.clipVolumeWithModel(inputVolume, clippingModel, clipOutsideSurface, fillValue, outputVolume)
logic.showInSliceViewers(outputVolume, ["Red", "Yellow", "Green"])
clippingModel.SetDisplayVisibility(0)
def CreateNewVolume(self, trial_num, numSamp, labelType):
imageSize=[64, 64, 64]
imageSpacing=[1.0, 1.0, 1.0]
voxelType=vtk.VTK_UNSIGNED_CHAR
# Create an empty image volume
imageData=vtk.vtkImageData()
imageData.SetDimensions(imageSize)
imageData.AllocateScalars(voxelType, 1)
thresholder=vtk.vtkImageThreshold()
thresholder.SetInputData(imageData)
thresholder.SetInValue(0)
thresholder.SetOutValue(0)
# Create volume node
volumeNode=slicer.vtkMRMLScalarVolumeNode()
volumeNode.SetSpacing(imageSpacing)
volumeNode.SetImageDataConnection(thresholder.GetOutputPort())
# Add volume to scene
slicer.mrmlScene.AddNode(volumeNode)
displayNode=slicer.vtkMRMLScalarVolumeDisplayNode()
slicer.mrmlScene.AddNode(displayNode)
colorNode = slicer.util.getNode('Grey')
displayNode.SetAndObserveColorNodeID(colorNode.GetID())
volumeNode.SetAndObserveDisplayNodeID(displayNode.GetID())
volumeNode.CreateDefaultStorageNode()
# name volume
volume_name = str(labelType)+'_trial_'+str(trial_num)+'_nsamp_'+str(numSamp)
volumeNode.SetName(volume_name)
return volumeNode
def setupScene(self):
logging.info("UltraSound.setupScene")
'''
ReferenceToRas transform is used in almost all IGT applications. Reference is the coordinate system
of a tool fixed to the patient. Tools are tracked relative to Reference, to compensate for patient
motion. ReferenceToRas makes sure that everything is displayed in an anatomical coordinate system, i.e.
R, A, and S (Right, Anterior, and Superior) directions in Slicer are correct relative to any
images or tracked tools displayed.
ReferenceToRas is needed for initialization, so we need to set it up before calling Guidelet.setupScene().
'''
if self.referenceToRas is None or (self.referenceToRas and slicer.mrmlScene.GetNodeByID(self.referenceToRas.GetID()) is None):
self.referenceToRas = slicer.mrmlScene.GetFirstNodeByName('ReferenceToRas')
if self.referenceToRas is None:
self.referenceToRas = slicer.vtkMRMLLinearTransformNode()
self.referenceToRas.SetName("ReferenceToRas")
m = self.guideletParent.logic.readTransformFromSettings('ReferenceToRas', self.guideletParent.configurationName)
if m is None:
m = self.guideletParent.logic.createMatrixFromString('1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1')
self.referenceToRas.SetMatrixTransformToParent(m)
slicer.mrmlScene.AddNode(self.referenceToRas)
# live ultrasound
liveUltrasoundNodeName = self.guideletParent.parameterNode.GetParameter('LiveUltrasoundNodeName')
self.liveUltrasoundNode_Reference = slicer.mrmlScene.GetFirstNodeByName(liveUltrasoundNodeName)
if not self.liveUltrasoundNode_Reference:
imageSpacing=[0.2, 0.2, 0.2]
# Create an empty image volume
imageData=vtk.vtkImageData()
imageData.SetDimensions(self.DEFAULT_IMAGE_SIZE)
imageData.AllocateScalars(vtk.VTK_UNSIGNED_CHAR, 1)
thresholder=vtk.vtkImageThreshold()
thresholder.SetInputData(imageData)
thresholder.SetInValue(0)
thresholder.SetOutValue(0)
# Create volume node
self.liveUltrasoundNode_Reference=slicer.vtkMRMLScalarVolumeNode()
self.liveUltrasoundNode_Reference.SetName(liveUltrasoundNodeName)
self.liveUltrasoundNode_Reference.SetSpacing(imageSpacing)
self.liveUltrasoundNode_Reference.SetImageDataConnection(thresholder.GetOutputPort())
# Add volume to scene
slicer.mrmlScene.AddNode(self.liveUltrasoundNode_Reference)
displayNode=slicer.vtkMRMLScalarVolumeDisplayNode()
slicer.mrmlScene.AddNode(displayNode)
colorNode = slicer.mrmlScene.GetFirstNodeByName('Grey')
displayNode.SetAndObserveColorNodeID(colorNode.GetID())
self.liveUltrasoundNode_Reference.SetAndObserveDisplayNodeID(displayNode.GetID())
self.plusRemoteNode = slicer.mrmlScene.GetFirstNodeByClass('vtkMRMLPlusRemoteNode')
if self.plusRemoteNode is None:
self.plusRemoteNode = slicer.vtkMRMLPlusRemoteNode()
self.plusRemoteNode.SetName("PlusRemoteNode")
slicer.mrmlScene.AddNode(self.plusRemoteNode)
self.plusRemoteNode.AddObserver(slicer.vtkMRMLPlusRemoteNode.RecordingStartedEvent, self.recordingCommandCompleted)
self.plusRemoteNode.AddObserver(slicer.vtkMRMLPlusRemoteNode.RecordingCompletedEvent, self.recordingCommandCompleted)
self.plusRemoteNode.SetAndObserveOpenIGTLinkConnectorNode(self.guideletParent.connectorNode)
self.setupResliceDriver()
def setupScene(self):
logging.info("UltraSound.setupScene")
'''
ReferenceToRas transform is used in almost all IGT applications. Reference is the coordinate system
of a tool fixed to the patient. Tools are tracked relative to Reference, to compensate for patient
motion. ReferenceToRas makes sure that everything is displayed in an anatomical coordinate system, i.e.
R, A, and S (Right, Anterior, and Superior) directions in Slicer are correct relative to any
images or tracked tools displayed.
ReferenceToRas is needed for initialization, so we need to set it up before calling Guidelet.setupScene().
'''
if self.referenceToRas is None or (
self.referenceToRas and slicer.mrmlScene.GetNodeByID(
self.referenceToRas.GetID()) is None):
self.referenceToRas = slicer.mrmlScene.GetFirstNodeByName(
'ReferenceToRas')
if self.referenceToRas is None:
self.referenceToRas = slicer.vtkMRMLLinearTransformNode()
self.referenceToRas.SetName("ReferenceToRas")
m = self.guideletParent.logic.readTransformFromSettings(
'ReferenceToRas', self.guideletParent.configurationName)
if m is None:
m = self.guideletParent.logic.createMatrixFromString(
'1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1')
self.referenceToRas.SetMatrixTransformToParent(m)
slicer.mrmlScene.AddNode(self.referenceToRas)
# live ultrasound
liveUltrasoundNodeName = self.guideletParent.parameterNode.GetParameter(
'LiveUltrasoundNodeName')
self.liveUltrasoundNode_Reference = slicer.mrmlScene.GetFirstNodeByName(
liveUltrasoundNodeName)
if not self.liveUltrasoundNode_Reference:
imageSpacing = [0.2, 0.2, 0.2]
# Create an empty image volume
imageData = vtk.vtkImageData()
imageData.SetDimensions(self.DEFAULT_IMAGE_SIZE)
imageData.AllocateScalars(vtk.VTK_UNSIGNED_CHAR, 1)
thresholder = vtk.vtkImageThreshold()
thresholder.SetInputData(imageData)
thresholder.SetInValue(0)
thresholder.SetOutValue(0)
# Create volume node
self.liveUltrasoundNode_Reference = slicer.vtkMRMLScalarVolumeNode(
)
self.liveUltrasoundNode_Reference.SetName(liveUltrasoundNodeName)
self.liveUltrasoundNode_Reference.SetSpacing(imageSpacing)
self.liveUltrasoundNode_Reference.SetImageDataConnection(
thresholder.GetOutputPort())
# Add volume to scene
slicer.mrmlScene.AddNode(self.liveUltrasoundNode_Reference)
displayNode = slicer.vtkMRMLScalarVolumeDisplayNode()
slicer.mrmlScene.AddNode(displayNode)
colorNode = slicer.mrmlScene.GetFirstNodeByName('Grey')
displayNode.SetAndObserveColorNodeID(colorNode.GetID())
self.liveUltrasoundNode_Reference.SetAndObserveDisplayNodeID(
displayNode.GetID())
self.setupResliceDriver()
def readFrame(self, file):
sNode = slicer.vtkMRMLVolumeArchetypeStorageNode()
sNode.ResetFileNameList()
sNode.SetFileName(file)
sNode.SetSingleFile(0)
frame = slicer.vtkMRMLScalarVolumeNode()
success = sNode.ReadData(frame)
return (success, frame)
def readFrame(self, file):
sNode = slicer.vtkMRMLVolumeArchetypeStorageNode()
sNode.ResetFileNameList()
sNode.SetFileName(file)
sNode.SetSingleFile(1)
frame = slicer.vtkMRMLScalarVolumeNode()
sNode.ReadData(frame)
return frame
def CrearIzquierda(self):
### imagenes a trabajar
inputVolume = self.inputSelector.currentNode()
outputVolume = self.outputSelector.currentNode()
petVolume = self.petSelector.currentNode()
mascaraIzquierdaVolume = self.mascaraIzquierdaSelector.currentNode()
salida = slicer.vtkMRMLScalarVolumeNode()
slicer.mrmlScene.AddNode(salida)
salida.SetName('salida')
parameters = {}
parameters['InputVolume'] = inputVolume
parameters['OutputVolume'] = salida
parameters['ThresholdType'] = 'Above'
parameters['Lower'] = 0
parameters['Upper'] = 0
parameters['Outsite'] = 0
parameters['ThresholdValue'] = 3
cliNode = slicer.cli.run(slicer.modules.thresholdscalarvolume,
None,
parameters,
wait_for_completion=True)
parameters = {}
parameters['InputVolume'] = salida
parameters['OutputVolume'] = outputVolume
parameters['ThresholdType'] = 'Below'
parameters['Lower'] = 0
parameters['Upper'] = 0
parameters['Outsite'] = 0
parameters['ThresholdValue'] = 3
cliNode = slicer.cli.run(slicer.modules.thresholdscalarvolume,
None,
parameters,
wait_for_completion=True)
parameters = {}
parameters['InputVolume'] = petVolume
parameters['MaskVolume'] = outputVolume
parameters['OutputVolume'] = mascaraIzquierdaVolume
parameters['Label'] = 3
parameters['Replace'] = 0
cliNode = slicer.cli.run(slicer.modules.maskscalarvolume,
None,
parameters,
wait_for_completion=True)
imagenIzquierda = slicer.util.getNode('Volume_2')
imagenDataIzquierda = imagenIzquierda.GetImageData()
intensidadTotalIzquierda = 0
for i in range(127):
for j in range(127, 0, -1):
intensidadTotalIzquierda = intensidadTotalIzquierda + (
imagenDataIzquierda.GetScalarComponentAsDouble(
int(i), int(j), int(45), 0))
print(intensidadTotalIzquierda)
def fit(self, atlasName='DevelopmentalAtlas', range=[0, 5]):
"""
Create a volume of the slope across the range of years.
least squares notation from:
http://docs.scipy.org/doc/numpy/reference/generated/numpy.linalg.lstsq.html
"""
ijkToRAS = vtk.vtkMatrix4x4()
atlasVolume = slicer.util.getNode(atlasName)
atlasVolume.GetIJKToRASMatrix(ijkToRAS)
fitVolume = slicer.vtkMRMLScalarVolumeNode()
fitVolume.SetIJKToRASMatrix(ijkToRAS)
ageRange = str(range).replace('[', '(').replace(']', ')')
fitName = 'Slope_' + ageRange + '_' + atlasName
fitVolume.SetName(fitName)
colorNode = slicer.vtkMRMLColorTableNode()
colorNode.SetTypeToGrey()
slicer.mrmlScene.AddNode(colorNode)
fitDisplayNode = slicer.vtkMRMLScalarVolumeDisplayNode()
fitDisplayNode.SetAutoWindowLevel(False)
fitDisplayNode.SetWindow(10)
fitDisplayNode.SetLevel(45)
slicer.mrmlScene.AddNode(fitDisplayNode)
fitDisplayNode.SetAndObserveColorNodeID(colorNode.GetID())
fitImage = vtk.vtkImageData()
fitImage.ShallowCopy(atlasVolume.GetImageData())
fitImage.AllocateScalars(vtk.VTK_FLOAT, 1)
fitVolume.SetAndObserveImageData(fitImage)
slicer.mrmlScene.AddNode(fitVolume)
fitVolume.SetAndObserveDisplayNodeID(fitDisplayNode.GetID())
fitArray = slicer.util.array(fitName)
atlasArray = slicer.util.array(atlasName)
# make a regression against a scale more or less like the multivolume plot
timePoints = self.agesInYears[range[0]:range[1]]
timePoints = map(lambda x: x * 1000., timePoints)
A = numpy.vstack([timePoints, numpy.ones(len(timePoints))]).T
slices, rows, columns, frames = atlasArray.shape
for slice in xrange(slices):
for row in xrange(rows):
for column in xrange(columns):
if atlasArray[slice, row, column, 0] == 0:
fit = 0
else:
series = atlasArray[slice, row,
column][range[0]:range[1]]
slope, intercept = numpy.linalg.lstsq(A, series)[0]
fit = -1. * numpy.degrees(numpy.arctan(slope))
fitArray[slice, row, column] = fit
return fitVolume
def __init__(self, slicerVersion):
self.volume = slicer.vtkMRMLScalarVolumeNode()
self.display = slicer.vtkMRMLScalarVolumeDisplayNode()
if slicerVersion == 4:
self.fiducialList = slicer.vtkMRMLAnnotationHierarchyNode()
self.newFiducial = slicer.vtkMRMLAnnotationFiducialNode()
else:
self.fiducialList = slicer.vtkMRMLFiducialListNode()
self.newFiducial = slicer.vtkMRMLFiducial()
def __init__(self, slicerVersion):
self.volume = slicer.vtkMRMLScalarVolumeNode()
self.display = slicer.vtkMRMLScalarVolumeDisplayNode()
if slicerVersion == 4:
self.fiducialList = slicer.vtkMRMLAnnotationHierarchyNode()
self.newFiducial = slicer.vtkMRMLAnnotationFiducialNode()
else:
self.fiducialList = slicer.vtkMRMLFiducialListNode()
self.newFiducial = slicer.vtkMRMLFiducial()
def onApply(self):
fixedImage = self.fixedSelector.currentNode()
movingImage = self.movingSelector.currentNode()
#outputImage = self.outputSelector.currentNode()
fixedExtract = vtk.vtkImageExtractComponents()
fixedExtract.SetComponents(0,1,2)
fixedLuminance = vtk.vtkImageLuminance()
fixedExtract.SetInputConnection(fixedImage.GetImageDataConnection())
fixedLuminance.SetInputConnection(fixedExtract.GetOutputPort())
fixedLuminance.Update()
fixedIJKToRAS = vtk.vtkMatrix4x4()
fixedImage.GetIJKToRASMatrix(fixedIJKToRAS)
fixedScalarVolume = slicer.vtkMRMLScalarVolumeNode()
fixedScalarVolume.SetName('fixedScalarImage')
fixedScalarVolume.SetIJKToRASMatrix(fixedIJKToRAS)
fixedScalarVolume.SetImageDataConnection(fixedLuminance.GetOutputPort())
slicer.mrmlScene.AddNode(fixedScalarVolume)
movingExtract = vtk.vtkImageExtractComponents()
movingExtract.SetComponents(0,1,2)
movingLuminance = vtk.vtkImageLuminance()
movingExtract.SetInputConnection(movingImage.GetImageDataConnection())
movingLuminance.SetInputConnection(movingExtract.GetOutputPort())
movingLuminance.Update()
movingIJKToRAS = vtk.vtkMatrix4x4()
movingImage.GetIJKToRASMatrix(movingIJKToRAS)
movingScalarVolume = slicer.vtkMRMLScalarVolumeNode()
movingScalarVolume.SetName('movingScalarImage')
movingScalarVolume.SetIJKToRASMatrix(movingIJKToRAS)
movingScalarVolume.SetImageDataConnection(movingLuminance.GetOutputPort())
slicer.mrmlScene.AddNode(movingScalarVolume)
anglesNumber = self.numberOfAnglesBox.value
print anglesNumber
imageRegistration = slicer.modules.imageregistrationcli
parameters = {
"fixedImage": fixedScalarVolume,
"movingImage": movingScalarVolume,
"anglesNumber": anglesNumber,
}
slicer.cli.run( imageRegistration,None,parameters,wait_for_completion=True )
def createVectorVolumeFromRoi(self,
exportRoi,
spacingMm,
numberOfComponents=3):
roiCenter = [0, 0, 0]
exportRoi.GetXYZ(roiCenter)
roiRadius = [0, 0, 0]
exportRoi.GetRadiusXYZ(roiRadius)
roiOrigin_Roi = [
roiCenter[0] - roiRadius[0], roiCenter[1] - roiRadius[1],
roiCenter[2] - roiRadius[2], 1
]
roiToRas = vtk.vtkMatrix4x4()
if exportRoi.GetTransformNodeID() != None:
roiBoxTransformNode = slicer.mrmlScene.GetNodeByID(
exportRoi.GetTransformNodeID())
roiBoxTransformNode.GetMatrixTransformToWorld(roiToRas)
exportVolumeSize = [
roiRadius[0] * 2 / spacingMm, roiRadius[1] * 2 / spacingMm,
roiRadius[2] * 2 / spacingMm
]
exportVolumeSize = [int(math.ceil(x)) for x in exportVolumeSize]
exportImageData = vtk.vtkImageData()
exportImageData.SetExtent(0, exportVolumeSize[0] - 1, 0,
exportVolumeSize[1] - 1, 0,
exportVolumeSize[2] - 1)
if vtk.VTK_MAJOR_VERSION <= 5:
exportImageData.SetScalarType(vtk.VTK_DOUBLE)
exportImageData.SetNumberOfScalarComponents(numberOfComponents)
exportImageData.AllocateScalars()
else:
exportImageData.AllocateScalars(vtk.VTK_DOUBLE, numberOfComponents)
exportVolume = None
if numberOfComponents == 1:
exportVolume = slicer.vtkMRMLScalarVolumeNode()
else:
exportVolume = slicer.vtkMRMLVectorVolumeNode()
exportVolume.SetAndObserveImageData(exportImageData)
exportVolume.SetIJKToRASDirections(roiToRas.GetElement(0, 0),
roiToRas.GetElement(0, 1),
roiToRas.GetElement(0, 2),
roiToRas.GetElement(1, 0),
roiToRas.GetElement(1, 1),
roiToRas.GetElement(1, 2),
roiToRas.GetElement(2, 0),
roiToRas.GetElement(2, 1),
roiToRas.GetElement(2, 2))
exportVolume.SetSpacing(spacingMm, spacingMm, spacingMm)
roiOrigin_Ras = roiToRas.MultiplyPoint(roiOrigin_Roi)
exportVolume.SetOrigin(roiOrigin_Ras[0:3])
return exportVolume
def fit(self,atlasName='DevelopmentalAtlas', range=[0,5]):
"""
Create a volume of the slope across the range of years.
least squares notation from:
http://docs.scipy.org/doc/numpy/reference/generated/numpy.linalg.lstsq.html
"""
ijkToRAS = vtk.vtkMatrix4x4()
atlasVolume = slicer.util.getNode(atlasName)
atlasVolume.GetIJKToRASMatrix(ijkToRAS)
fitVolume = slicer.vtkMRMLScalarVolumeNode()
fitVolume.SetIJKToRASMatrix(ijkToRAS)
ageRange = str(range).replace('[','(').replace(']',')')
fitName = 'Slope_'+ageRange+'_'+atlasName
fitVolume.SetName(fitName)
colorNode = slicer.vtkMRMLColorTableNode()
colorNode.SetTypeToGrey()
slicer.mrmlScene.AddNode(colorNode)
fitDisplayNode = slicer.vtkMRMLScalarVolumeDisplayNode()
fitDisplayNode.SetAutoWindowLevel(False)
fitDisplayNode.SetWindow(10)
fitDisplayNode.SetLevel(45)
slicer.mrmlScene.AddNode(fitDisplayNode)
fitDisplayNode.SetAndObserveColorNodeID(colorNode.GetID())
fitImage = vtk.vtkImageData()
fitImage.ShallowCopy(atlasVolume.GetImageData())
fitImage.AllocateScalars(vtk.VTK_FLOAT, 1)
fitVolume.SetAndObserveImageData(fitImage)
slicer.mrmlScene.AddNode(fitVolume)
fitVolume.SetAndObserveDisplayNodeID(fitDisplayNode.GetID())
fitArray = slicer.util.array(fitName)
atlasArray = slicer.util.array(atlasName)
# make a regression against a scale more or less like the multivolume plot
timePoints = self.agesInYears[range[0]:range[1]]
timePoints = map(lambda x : x * 1000., timePoints)
A = numpy.vstack([timePoints, numpy.ones(len(timePoints))]).T
slices, rows, columns, frames = atlasArray.shape
for slice in xrange(slices):
for row in xrange(rows):
for column in xrange(columns):
if atlasArray[slice, row, column, 0] == 0:
fit = 0
else:
series = atlasArray[slice, row, column][range[0]:range[1]]
slope, intercept = numpy.linalg.lstsq(A, series)[0]
fit = -1. * numpy.degrees(numpy.arctan(slope))
fitArray[slice, row, column] = fit
return fitVolume
def onHelloWorldButtonClicked(self):
print "Hello World !"
#frame volume sera el scalar volume de referencia#
self.__mvNode = self.mvSelector.currentNode()
#NODO REFERENCIA
frameVolume = slicer.vtkMRMLScalarVolumeNode()
frameVolume.SetScene(slicer.mrmlScene)
slicer.mrmlScene.AddNode(frameVolume)
nComponents = self.__mvNode.GetNumberOfFrames()
f=int(self.__veInitial.value)
frameId = min(f,nComponents-1)
ras2ijk = vtk.vtkMatrix4x4()
ijk2ras = vtk.vtkMatrix4x4()
self.__mvNode.GetRASToIJKMatrix(ras2ijk)
self.__mvNode.GetIJKToRASMatrix(ijk2ras)
frameImage = frameVolume.GetImageData()
if frameImage == None:
frameVolume.SetRASToIJKMatrix(ras2ijk)
frameVolume.SetIJKToRASMatrix(ijk2ras)
mvImage = self.__mvNode.GetImageData()
for i in range(nComponents-1):
extract = vtk.vtkImageExtractComponents()
extract.SetInput(mvImage)
extract.SetComponents(i)
extract.Update()
if i == 0:
frameVolume.SetAndObserveImageData(extract.GetOutput())
elif i < frameId+1 :
s=vtk.vtkImageMathematics()
s.SetOperationToAdd()
s.SetInput1(frameVolume.GetImageData())
s.SetInput2(extract.GetOutput())
s.Update()
frameVolume.SetAndObserveImageData(s.GetOutput())
frameName = 'Holaaa'
frameVolume.SetName(frameName)
selectionNode = slicer.app.applicationLogic().GetSelectionNode()
selectionNode.SetReferenceActiveVolumeID(frameVolume.GetID())
slicer.app.applicationLogic().PropagateVolumeSelection(0)
def TestNeedleDetection(self):
parameters = {}
scene = slicer.mrmlScene
collection = scene.GetNodesByClass('vtkMRMLScalarVolumeNode');
nimages = collection.GetNumberOfItems()
collection.InitTraversal()
n = 0
cliList = []
while n < nimages:
inImage = collection.GetNextItemAsObject()
if inImage == None:
break
id = inImage.GetID()
print('Processing image node = %s...' % id)
# Create a new image node
outImage = slicer.vtkMRMLScalarVolumeNode()
name = inImage.GetName() + '_Needle'
outImage.SetName(name)
scene.AddNode(outImage)
outImage.SetLabelMap(1)
# Create a new linear transform node (for needle position/orientation)
needleTransform = slicer.vtkMRMLLinearTransformNode()
name = inImage.GetName() + '_Transform'
needleTransform.SetName(name)
scene.AddNode(needleTransform)
parameters = {}
parameters['inputVolume'] = inImage.GetID()
parameters['outputVolume'] = outImage.GetID()
parameters['needleTransform'] = needleTransform.GetID()
parameters['sigma1'] = 0.5
parameters['minsigma'] = 0.5
parameters['maxsigma'] = 1.3
parameters['stepsigma'] = 5
parameters['minlinemeasure'] = 40
parameters['alpha1'] = 0.5
parameters['alpha2'] = 2
parameters['anglethreshold'] = 25
parameters['normal'] = [0.0, 0.0, 1.0]
parameters['numberOfBins'] = 128
parameters['minimumObjectSize'] = 50
parameters['minPrincipalAxisLength'] = 50
parameters['closestPoint'] = [0.0, 0.0, 0.0]
nd = slicer.modules.needledetection
c = slicer.cli.run(nd, None, parameters)
c.AddObserver('ModifiedEvent', self.printStatus)
self.cliList.append(c)
n = n + 1
def CreateVolumeFromRoi(self, roiNode, spacingMm):
"""Creates a volume node with image data of proper spacing inside of it
PARAM : roi and spacing we wish to have
RETURN : vtkMRMLScalarVolumeNode()
"""
roiCenter = [0, 0, 0]
roiNode.GetXYZ(roiCenter)
roiRadius = [0, 0, 0]
roiNode.GetRadiusXYZ(roiRadius)
roiOrigin_Roi = [
roiCenter[0] - roiRadius[0], roiCenter[1] - roiRadius[1],
roiCenter[2] - roiRadius[2], 1
]
roiToRas = vtk.vtkMatrix4x4()
if roiNode.GetTransformNodeID() != None:
roiBoxTransformNode = slicer.mrmlScene.GetNodeByID(
roiNode.GetTransformNodeID())
roiBoxTransformNode.GetMatrixTransformToWorld(roiToRas)
outputVolumeSize = [
roiRadius[0] * 2 / spacingMm, roiRadius[1] * 2 / spacingMm,
roiRadius[2] * 2 / spacingMm
]
outputVolumeSize = [int(math.ceil(x)) for x in outputVolumeSize]
outputImageData = vtk.vtkImageData()
outputImageData.SetExtent(0, outputVolumeSize[0] - 1, 0,
outputVolumeSize[1] - 1, 0,
outputVolumeSize[2] - 1)
if vtk.VTK_MAJOR_VERSION <= 5:
outputImageData.SetScalarType(vtk.VTK_UNSIGNED_CHAR)
outputImageData.SetNumberOfScalarComponents(3)
outputImageData.AllocateScalars()
else:
outputImageData.AllocateScalars(vtk.VTK_UNSIGNED_CHAR, 1)
outputVolumeNode = slicer.vtkMRMLScalarVolumeNode()
outputVolumeNode.SetAndObserveImageData(outputImageData)
outputVolumeNode.SetIJKToRASDirections(roiToRas.GetElement(0, 0),
roiToRas.GetElement(0, 1),
roiToRas.GetElement(0, 2),
roiToRas.GetElement(1, 0),
roiToRas.GetElement(1, 1),
roiToRas.GetElement(1, 2),
roiToRas.GetElement(2, 0),
roiToRas.GetElement(2, 1),
roiToRas.GetElement(2, 2))
outputVolumeNode.SetSpacing(spacingMm, spacingMm, spacingMm)
roiOrigin_Ras = roiToRas.MultiplyPoint(roiOrigin_Roi)
outputVolumeNode.SetOrigin(roiOrigin_Ras[0:3])
return outputVolumeNode
def setupScene(self):
layoutManager = slicer.app.layoutManager()
# live ultrasound
liveUltrasoundNodeName = self.guideletParent.parameterNode.GetParameter('LiveUltrasoundNodeName')
self.liveUltrasoundNode_Reference = slicer.util.getNode(liveUltrasoundNodeName)
if not self.liveUltrasoundNode_Reference:
imageSize=[800, 600, 1]
imageSpacing=[0.2, 0.2, 0.2]
# Create an empty image volume
imageData=vtk.vtkImageData()
imageData.SetDimensions(imageSize)
imageData.AllocateScalars(vtk.VTK_UNSIGNED_CHAR, 1)
thresholder=vtk.vtkImageThreshold()
thresholder.SetInputData(imageData)
thresholder.SetInValue(0)
thresholder.SetOutValue(0)
# Create volume node
self.liveUltrasoundNode_Reference=slicer.vtkMRMLScalarVolumeNode()
self.liveUltrasoundNode_Reference.SetName(liveUltrasoundNodeName)
self.liveUltrasoundNode_Reference.SetSpacing(imageSpacing)
self.liveUltrasoundNode_Reference.SetImageDataConnection(thresholder.GetOutputPort())
# Add volume to scene
slicer.mrmlScene.AddNode(self.liveUltrasoundNode_Reference)
displayNode=slicer.vtkMRMLScalarVolumeDisplayNode()
slicer.mrmlScene.AddNode(displayNode)
colorNode = slicer.util.getNode('Grey')
displayNode.SetAndObserveColorNodeID(colorNode.GetID())
self.liveUltrasoundNode_Reference.SetAndObserveDisplayNodeID(displayNode.GetID())
#self.liveUltrasoundNode_Reference.CreateDefaultStorageNode()
# Show ultrasound in red view.
redSlice = layoutManager.sliceWidget('Red')
redSliceLogic = redSlice.sliceLogic()
redSliceLogic.GetSliceCompositeNode().SetBackgroundVolumeID(self.liveUltrasoundNode_Reference.GetID())
# Set up volume reslice driver.
resliceLogic = slicer.modules.volumereslicedriver.logic()
if resliceLogic:
redNode = slicer.util.getNode('vtkMRMLSliceNodeRed')
# Typically the image is zoomed in, therefore it is faster if the original resolution is used
# on the 3D slice (and also we can show the full image and not the shape and size of the 2D view)
redNode.SetSliceResolutionMode(slicer.vtkMRMLSliceNode.SliceResolutionMatchVolumes)
resliceLogic.SetDriverForSlice(self.liveUltrasoundNode_Reference.GetID(), redNode)
resliceLogic.SetModeForSlice(6, redNode) # Transverse mode, default for PLUS ultrasound.
resliceLogic.SetFlipForSlice(False, redNode)
resliceLogic.SetRotationForSlice(180, redNode)
redSliceLogic.FitSliceToAll()
else:
logging.warning('Logic not found for Volume Reslice Driver')
self.liveUltrasoundNode_Reference.SetAndObserveTransformNodeID(self.guideletParent.ReferenceToRas.GetID())
def onSliderChanged(self, newValue):
value = self.__mdSlider.value
if self.__mvNode != None:
mvDisplayNode = self.__mvNode.GetDisplayNode()
mvDisplayNode.SetFrameComponent(newValue)
else:
return
if self.extractFrame == True:
frameVolume = self.__vfSelector.currentNode()
if frameVolume == None:
mvNodeFrameCopy = slicer.vtkMRMLScalarVolumeNode()
mvNodeFrameCopy.SetName(self.__mvNode.GetName() + ' frame')
mvNodeFrameCopy.SetScene(slicer.mrmlScene)
slicer.mrmlScene.AddNode(mvNodeFrameCopy)
self.__vfSelector.setCurrentNode(mvNodeFrameCopy)
frameVolume = self.__vfSelector.currentNode()
mvImage = self.__mvNode.GetImageData()
frameId = newValue
extract = vtk.vtkImageExtractComponents()
extract.SetInput(mvImage)
extract.SetComponents(frameId)
extract.Update()
ras2ijk = vtk.vtkMatrix4x4()
ijk2ras = vtk.vtkMatrix4x4()
self.__mvNode.GetRASToIJKMatrix(ras2ijk)
self.__mvNode.GetIJKToRASMatrix(ijk2ras)
frameImage = frameVolume.GetImageData()
if frameImage == None:
frameVolume.SetRASToIJKMatrix(ras2ijk)
frameVolume.SetIJKToRASMatrix(ijk2ras)
frameVolume.SetAndObserveImageData(extract.GetOutput())
displayNode = frameVolume.GetDisplayNode()
if displayNode == None:
displayNode = slicer.mrmlScene.CreateNodeByClass(
'vtkMRMLScalarVolumeDisplayNode')
displayNode.SetReferenceCount(1)
displayNode.SetScene(slicer.mrmlScene)
slicer.mrmlScene.AddNode(displayNode)
displayNode.SetDefaultColorMap()
frameVolume.SetAndObserveDisplayNodeID(displayNode.GetID())
frameName = '%s frame %d' % (self.__mvNode.GetName(), frameId)
frameVolume.SetName(frameName)
def onSliderChanged(self, newValue):
value = self.__mdSlider.value
if self.__mvNode != None:
mvDisplayNode = self.__mvNode.GetDisplayNode()
mvDisplayNode.SetFrameComponent(newValue)
else:
return
if self.extractFrame == True:
frameVolume = self.__vfSelector.currentNode()
if frameVolume == None:
mvNodeFrameCopy = slicer.vtkMRMLScalarVolumeNode()
mvNodeFrameCopy.SetName(self.__mvNode.GetName()+' frame')
mvNodeFrameCopy.SetScene(slicer.mrmlScene)
slicer.mrmlScene.AddNode(mvNodeFrameCopy)
self.__vfSelector.setCurrentNode(mvNodeFrameCopy)
frameVolume = self.__vfSelector.currentNode()
mvImage = self.__mvNode.GetImageData()
frameId = newValue
extract = vtk.vtkImageExtractComponents()
extract.SetInput(mvImage)
extract.SetComponents(frameId)
extract.Update()
ras2ijk = vtk.vtkMatrix4x4()
ijk2ras = vtk.vtkMatrix4x4()
self.__mvNode.GetRASToIJKMatrix(ras2ijk)
self.__mvNode.GetIJKToRASMatrix(ijk2ras)
frameImage = frameVolume.GetImageData()
if frameImage == None:
frameVolume.SetRASToIJKMatrix(ras2ijk)
frameVolume.SetIJKToRASMatrix(ijk2ras)
frameVolume.SetAndObserveImageData(extract.GetOutput())
displayNode = frameVolume.GetDisplayNode()
if displayNode == None:
displayNode = slicer.mrmlScene.CreateNodeByClass('vtkMRMLScalarVolumeDisplayNode')
displayNode.SetReferenceCount(1)
displayNode.SetScene(slicer.mrmlScene)
slicer.mrmlScene.AddNode(displayNode)
displayNode.SetDefaultColorMap()
frameVolume.SetAndObserveDisplayNodeID(displayNode.GetID())
frameName = '%s frame %d' % (self.__mvNode.GetName(), frameId)
frameVolume.SetName(frameName)
def saveIntermediateImage(self,name,image):
node=slicer.mrmlScene.GetNodesByClassByName('vtkMRMLScalarVolumeNode',name).GetItemAsObject(0)
if not node:
node=slicer.vtkMRMLScalarVolumeNode()
IJK=vtk.vtkMatrix4x4()
self.input.GetIJKToRASMatrix(IJK)
node.SetName(name)
node.SetIJKToRASMatrix(IJK)
#node.SetLabelMap(1)
slicer.mrmlScene.AddNode(node)
node.SetAndObserveImageData(image)
def generateDistanceMap(self):
print("Generating distance map.")
## Create an scalar volume node for distance map
self.distanceMapNode = slicer.vtkMRMLScalarVolumeNode()
slicer.mrmlScene.AddNode(self.distanceMapNode)
## Call CLI
parameters = {}
parameters["inputVolume"] = self.tumorLabelSelector.currentNode().GetID()
parameters["outputVolume"] = self.distanceMapNode.GetID()
parameters["physicalDistance"] = True
distanceMap = slicer.modules.distancemap
cliNode = slicer.cli.run(distanceMap, None, parameters)
cliNode.AddObserver('ModifiedEvent', self.probeDistanceMap)
def detectEdgeInROI(self,edge,alternateEdge=None):
qu=QCLib.QCUtil()
VOIROI=qu.getVOIfromRectROI(self.ROI)
eV=vtk.vtkExtractVOI()
eV.SetInputData(self.input.GetImageData())
eV.SetVOI(VOIROI)
eV.Update()
imROI=eV.GetOutput()
thr=[0,0]
if self.algorithm==0:
#find threshold for edge detection
mL=makeROIGhostLogic()
ghost=vtk.vtkImageData()
ghnode=slicer.vtkMRMLScalarVolumeNode()
ghnode.SetAndObserveImageData(ghost)
mL.run(self.input,ghnode)
rL=ROIStatisticsLogic()
rL.run(self.input,ghnode)
zROI=VOIROI[4]
ghVals=[]
stats=rL.stats.values()
for n in range(rL.stats.__len__()):
ghVals.append(stats[n][zROI]['mean']+stats[n][zROI]['sd'])
thr=[max(ghVals),2*max(ghVals)]
else:
alternateEdge=None
cast=vtk.vtkImageCast()
cast.SetOutputScalarTypeToDouble()
cast.SetInputData(imROI)
cast.Update()
em=slicer.vtkITKEdgeDetection()
em.SetInputData(cast.GetOutput())
em.SetAlgorithmInt(self.algorithm)
em.Setthreshold(thr)
em.Setvariance(5)
em.Update()
edge.DeepCopy(em.GetOutput())
if alternateEdge:
self.signedDistance(edge,alternateEdge)
def CreateSkinModel(self, parameters, wait_for_completion=False):
self.CLINode.SetStatus(self.CLINode.Running)
erodeSkin = len(parameters['SkinLabel']) > 0
# 0 - Add intermediate volume to the scene
self.NewVolume = None
if erodeSkin:
self.NewVolume = slicer.vtkMRMLScalarVolumeNode()
self.NewVolume.SetName('SkinModelMakerTemp')
slicer.mrmlScene.AddNode(self.NewVolume)
# 1 - Setup change label parameters
self.ChangeLabelParameters["RunChangeLabel"] = erodeSkin
self.ChangeLabelParameters["InputVolume"] = parameters["InputVolume"]
self.ChangeLabelParameters["OutputVolume"] = self.NewVolume
self.ChangeLabelParameters["InputLabelNumber"] = str(
len(parameters['SkinLabel'].split(',')))
self.ChangeLabelParameters["InputLabel"] = parameters['SkinLabel']
self.ChangeLabelParameters["OutputLabel"] = parameters[
'BackgroundLabel']
# 2 Setup generate model parameters
if erodeSkin:
self.GenerateModelParameters["InputVolume"] = self.NewVolume
else:
self.GenerateModelParameters["InputVolume"] = parameters[
"InputVolume"]
self.GenerateModelParameters["OutputGeometry"] = parameters[
"OutputGeometry"]
self.GenerateModelParameters[
"Threshold"] = parameters['BackgroundLabel'] + 0.1
if parameters['Decimate']:
self.GenerateModelParameters["Decimate"] = 0.0
self.GenerateModelParameters["Smooth"] = 0
# 3 Setup decimator parameters
self.DecimateParameters["RunDecimator"] = parameters['Decimate']
self.DecimateParameters["InputModel"] = parameters["OutputGeometry"]
self.DecimateParameters["DecimatedModel"] = parameters[
"OutputGeometry"]
self.DecimateParameters["Spacing"] = parameters['Spacing']
self.DecimateParameters['UseInputPoints'] = True
self.DecimateParameters['UseFeatureEdges'] = True
self.DecimateParameters['UseFeaturePoints'] = True
# Start CLI chain
self.WaitForCompletion = wait_for_completion
self.runChangeLabel()
def DisplayImageData(self, imageData_Ijk, referenceVolumeNode_Ras, name="ImageNode"):
volumeNode_Ras=slicer.util.getNode(name)
if (not volumeNode_Ras):
displayNode=slicer.vtkMRMLScalarVolumeDisplayNode()
displayNode.SetAndObserveColorNodeID("vtkMRMLColorTableNodeGrey")
volumeNode_Ras=slicer.vtkMRMLScalarVolumeNode()
volumeNode_Ras.SetName(name)
slicer.mrmlScene.AddNode(volumeNode_Ras)
slicer.mrmlScene.AddNode(displayNode)
volumeNode_Ras.SetAndObserveDisplayNodeID(displayNode.GetID())
volumeNode_Ras.SetAndObserveImageData(imageData_Ijk)
rasToIjkMatrix=vtk.vtkMatrix4x4()
referenceVolumeNode_Ras.GetRASToIJKMatrix(rasToIjkMatrix)
volumeNode_Ras.SetRASToIJKMatrix(rasToIjkMatrix)
return volumeNode_Ras
def generateDistanceMap(self):
print("Generating distance map.")
## Create an scalar volume node for distance map
self.distanceMapNode = slicer.vtkMRMLScalarVolumeNode()
slicer.mrmlScene.AddNode(self.distanceMapNode)
## Call CLI
parameters = {}
parameters["inputVolume"] = self.tumorLabelSelector.currentNode(
).GetID()
parameters["outputVolume"] = self.distanceMapNode.GetID()
parameters["physicalDistance"] = True
distanceMap = slicer.modules.distancemap
cliNode = slicer.cli.run(distanceMap, None, parameters)
cliNode.AddObserver('ModifiedEvent', self.probeDistanceMap)
def RegisterImageSequence(self, fixedVolumeNode, movingVolumeSequenceNode, linearTransformSequenceNode, outputVolumeSequenceNode, initializeTransformMode='useGeometryAlign', initialTransformNode=None, maskVolumeNode=None):
if linearTransformSequenceNode:
linearTransformSequenceNode.RemoveAllDataNodes()
if outputVolumeSequenceNode:
outputVolumeSequenceNode.RemoveAllDataNodes()
numOfImageNodes = movingVolumeSequenceNode.GetNumberOfDataNodes()
lastTransformNode = None
for i in range(numOfImageNodes):
movingVolumeNode = movingVolumeSequenceNode.GetNthDataNode(i)
movingVolumeIndexValue = movingVolumeSequenceNode.GetNthIndexValue(i)
slicer.mrmlScene.AddNode(movingVolumeNode)
outputTransformNode = slicer.vtkMRMLLinearTransformNode()
#outputTransformNode = slicer.vtkMRMLBSplineTransformNode()
slicer.mrmlScene.AddNode(outputTransformNode)
outputVolumeNode = None
if outputVolumeSequenceNode:
outputVolumeNode = slicer.vtkMRMLScalarVolumeNode()
slicer.mrmlScene.AddNode(outputVolumeNode)
initialTransformNode = linearTransformSequenceNode.GetNthDataNode(i-1)
if initialTransformNode:
slicer.mrmlScene.AddNode(initialTransformNode)
else:
initialTransformNode = None
self.RegisterImage(fixedVolumeNode, movingVolumeNode, outputTransformNode, outputVolumeNode, initializeTransformMode, initialTransformNode, maskVolumeNode)
if linearTransformSequenceNode:
linearTransformSequenceNode.SetDataNodeAtValue(outputTransformNode, movingVolumeIndexValue)
if outputVolumeSequenceNode:
outputVolumeSequenceNode.SetDataNodeAtValue(outputVolumeNode, movingVolumeIndexValue)
if initialTransformNode:
slicer.mrmlScene.RemoveNode(initialTransformNode)
slicer.mrmlScene.RemoveNode(movingVolumeNode)
if outputVolumeNode:
slicer.mrmlScene.RemoveNode(outputVolumeNode)
# Initialize the lastTransform so the next registration can start with this transform
lastTransform = outputTransformNode
slicer.mrmlScene.RemoveNode(outputTransformNode)
# This is required as a temp workaround to use the transform sequence to map baseline ROI to sequence ROI
if linearTransformSequenceNode:
for i in range(numOfImageNodes):
transformNode = linearTransformSequenceNode.GetNthDataNode(i)
transformNode.Inverse()
def onHelloWorldButtonClicked(self):
print "Hello World !"
#frame volume sera el scalar volume de referencia#
self.__mvNode = self.mvSelector.currentNode()
#NODO REFERENCIA
frameVolume = slicer.vtkMRMLScalarVolumeNode()
frameVolume.SetScene(slicer.mrmlScene)
slicer.mrmlScene.AddNode(frameVolume)
nComponents = self.__mvNode.GetNumberOfFrames()
f = int(self.__veInitial.value)
frameId = min(f, nComponents - 1)
ras2ijk = vtk.vtkMatrix4x4()
ijk2ras = vtk.vtkMatrix4x4()
self.__mvNode.GetRASToIJKMatrix(ras2ijk)
self.__mvNode.GetIJKToRASMatrix(ijk2ras)
frameImage = frameVolume.GetImageData()
if frameImage == None:
frameVolume.SetRASToIJKMatrix(ras2ijk)
frameVolume.SetIJKToRASMatrix(ijk2ras)
mvImage = self.__mvNode.GetImageData()
for i in range(nComponents - 1):
extract = vtk.vtkImageExtractComponents()
extract.SetInput(mvImage)
extract.SetComponents(i)
extract.Update()
if i == 0:
frameVolume.SetAndObserveImageData(extract.GetOutput())
elif i < frameId + 1:
s = vtk.vtkImageMathematics()
s.SetOperationToAdd()
s.SetInput1(frameVolume.GetImageData())
s.SetInput2(extract.GetOutput())
s.Update()
frameVolume.SetAndObserveImageData(s.GetOutput())
frameName = 'Holaaa'
frameVolume.SetName(frameName)
selectionNode = slicer.app.applicationLogic().GetSelectionNode()
selectionNode.SetReferenceActiveVolumeID(frameVolume.GetID())
slicer.app.applicationLogic().PropagateVolumeSelection(0)
def run(self, referenceSequenceNode, inputNode, transformSequenceNode,
outputSequenceNode):
"""
Run the actual algorithm
"""
if outputSequenceNode:
outputSequenceNode.RemoveAllDataNodes()
numOfImageNodes = referenceSequenceNode.GetNumberOfDataNodes()
for i in xrange(numOfImageNodes):
referenceNode = referenceSequenceNode.GetNthDataNode(i)
referenceNodeIndexValue = referenceSequenceNode.GetNthIndexValue(i)
dimensions = [1, 1, 1]
referenceNode.GetImageData().GetDimensions(dimensions)
transformNode = transformSequenceNode.GetNthDataNode(i)
inputIJK2RASMatrix = vtk.vtkMatrix4x4()
inputNode.GetIJKToRASMatrix(inputIJK2RASMatrix)
referenceRAS2IJKMatrix = vtk.vtkMatrix4x4()
referenceNode.GetRASToIJKMatrix(referenceRAS2IJKMatrix)
inputRAS2RASMatrix = transformNode.GetTransformToParent()
resampleTransform = vtk.vtkGeneralTransform()
resampleTransform.Identity()
resampleTransform.PostMultiply()
resampleTransform.Concatenate(inputIJK2RASMatrix)
resampleTransform.Concatenate(inputRAS2RASMatrix)
resampleTransform.Concatenate(referenceRAS2IJKMatrix)
resampleTransform.Inverse()
resampler = vtk.vtkImageReslice()
resampler.SetInput(inputNode.GetImageData())
resampler.SetOutputOrigin(0, 0, 0)
resampler.SetOutputSpacing(1, 1, 1)
resampler.SetOutputExtent(0, dimensions[0], 0, dimensions[1], 0,
dimensions[2])
resampler.SetResliceTransform(resampleTransform)
resampler.Update()
outputNode = slicer.vtkMRMLScalarVolumeNode()
outputNode.CopyOrientation(referenceNode)
outputNode.SetAndObserveImageData(resampler.GetOutput())
outputSequenceNode.SetDataNodeAtValue(outputNode,
referenceNodeIndexValue)
return True
def onRegisterButtonClicked(self):
scene = slicer.mrmlScene
fixedVolume = self.__fixedVolumeSelector.currentNode()
movingVolume = self.__movingVolumeSelector.currentNode()
brainsWarp = slicer.modules.brainsdemonwarp # takes forever!
brainsFit = slicer.modules.brainsfit # Tested during Image Analysis II. Takes about 20mins
bsplinedeformable = slicer.modules.bsplinedeformableregistration # Tested during Image Analysis II
parameters = {}
# TODO remove the automatic loading and leave this one
#parameters["movingVolume"] = movingVolume.GetID()
#parameters["fixedVolume"] = fixedVolume.GetID()
# Only for testing. Load volumes automatically
# TODO Remove when out of testing
vols = self.loadVolumesForTesting()
fixedVolume = vols["fixedVolume"]
movingVolume = vols["movingVolume"]
parameters["movingVolume"] = movingVolume
parameters["fixedVolume"] = fixedVolume
# ONLY for brainsfit
parameters['initializeTransformMode'] = 'useCenterOfHeadAlign'
parameters['useRigid'] = True
# Create an output volume
outputVolume = slicer.vtkMRMLScalarVolumeNode()
outputVolume.SetModifiedSinceRead(1)
outputVolume.SetName('registered_volume')
scene.AddNode(outputVolume) # Important before GetID()!
parameters["outputVolume"] = outputVolume.GetID()
print "Calling register volumes CLI..."
self.__cliNode = None
self.__cliNode = slicer.cli.run(brainsFit, self.__cliNode, parameters)
# Each time the event is modified, the function processSubtractCompletion will be called.
self.__cliObserverTag = self.__cliNode.AddObserver(
'ModifiedEvent', self.processRegistrationCompletion)
self.__registerStatus.setText('Wait ...')
self.__registerButton.setEnabled(0)
def DisplayImageData(self,
imageData_Ijk,
referenceVolumeNode_Ras,
name="ImageNode"):
volumeNode_Ras = slicer.util.getNode(name)
if (not volumeNode_Ras):
displayNode = slicer.vtkMRMLScalarVolumeDisplayNode()
displayNode.SetAndObserveColorNodeID("vtkMRMLColorTableNodeGrey")
volumeNode_Ras = slicer.vtkMRMLScalarVolumeNode()
volumeNode_Ras.SetName(name)
slicer.mrmlScene.AddNode(volumeNode_Ras)
slicer.mrmlScene.AddNode(displayNode)
volumeNode_Ras.SetAndObserveDisplayNodeID(displayNode.GetID())
volumeNode_Ras.SetAndObserveImageData(imageData_Ijk)
rasToIjkMatrix = vtk.vtkMatrix4x4()
referenceVolumeNode_Ras.GetRASToIJKMatrix(rasToIjkMatrix)
volumeNode_Ras.SetRASToIJKMatrix(rasToIjkMatrix)
return volumeNode_Ras
def onRegisterButtonClicked(self):
scene = slicer.mrmlScene
fixedVolume = self.__fixedVolumeSelector.currentNode()
movingVolume = self.__movingVolumeSelector.currentNode()
brainsWarp = slicer.modules.brainsdemonwarp # takes forever!
brainsFit = slicer.modules.brainsfit # Tested during Image Analysis II. Takes about 20mins
bsplinedeformable = slicer.modules.bsplinedeformableregistration # Tested during Image Analysis II
parameters = {}
# TODO remove the automatic loading and leave this one
#parameters["movingVolume"] = movingVolume.GetID()
#parameters["fixedVolume"] = fixedVolume.GetID()
# Only for testing. Load volumes automatically
# TODO Remove when out of testing
vols = self.loadVolumesForTesting()
fixedVolume = vols["fixedVolume"]
movingVolume = vols["movingVolume"]
parameters["movingVolume"] = movingVolume
parameters["fixedVolume"] = fixedVolume
# ONLY for brainsfit
parameters['initializeTransformMode'] = 'useCenterOfHeadAlign'
parameters['useRigid'] = True
# Create an output volume
outputVolume = slicer.vtkMRMLScalarVolumeNode()
outputVolume.SetModifiedSinceRead(1)
outputVolume.SetName('registered_volume')
scene.AddNode(outputVolume) # Important before GetID()!
parameters["outputVolume"] = outputVolume.GetID()
print "Calling register volumes CLI..."
self.__cliNode = None
self.__cliNode = slicer.cli.run(brainsFit, self.__cliNode, parameters)
# Each time the event is modified, the function processSubtractCompletion will be called.
self.__cliObserverTag = self.__cliNode.AddObserver('ModifiedEvent', self.processRegistrationCompletion)
self.__registerStatus.setText('Wait ...')
self.__registerButton.setEnabled(0)
def test_VolumeClipWithModel1(self):
# Download MRHead from sample data
import SampleData
sampleDataLogic = SampleData.SampleDataLogic()
self.delayDisplay("Getting MR Head Volume")
inputVolume = sampleDataLogic.downloadMRHead()
# Create empty model node
clippingModel = slicer.vtkMRMLModelNode()
slicer.mrmlScene.AddNode(clippingModel)
# Create markup fiducials
displayNode = slicer.vtkMRMLMarkupsDisplayNode()
slicer.mrmlScene.AddNode(displayNode)
inputMarkup = slicer.vtkMRMLMarkupsFiducialNode()
inputMarkup.SetName('C')
slicer.mrmlScene.AddNode(inputMarkup)
inputMarkup.SetAndObserveDisplayNodeID(displayNode.GetID())
inputMarkup.AddFiducial(35, -10, -10)
inputMarkup.AddFiducial(-15, 20, -10)
inputMarkup.AddFiducial(-25, -25, -10)
inputMarkup.AddFiducial(-5, -60, -15)
inputMarkup.AddFiducial(-5, 5, 60)
inputMarkup.AddFiducial(-5, -35, -30)
# Create output volume
outputVolume = slicer.vtkMRMLScalarVolumeNode()
slicer.mrmlScene.AddNode(outputVolume)
# Clip volume
logic = VolumeClipWithModelLogic()
clipOutsideSurface = True
fillOutsideValue = 0
clipInsideSurface = True
fillInsideValue = 255
logic.updateModelFromMarkup(inputMarkup, clippingModel)
logic.clipVolumeWithModel(inputVolume, clippingModel,
clipOutsideSurface, fillOutsideValue,
outputVolume)
logic.showInSliceViewers(outputVolume, ["Red", "Yellow", "Green"])
self.delayDisplay("Test passed!")
def run(self,referenceSequenceNode, inputNode, transformSequenceNode, outputSequenceNode):
"""
Run the actual algorithm
"""
if outputSequenceNode:
outputSequenceNode.RemoveAllDataNodes()
numOfImageNodes = referenceSequenceNode.GetNumberOfDataNodes()
for i in xrange(numOfImageNodes):
referenceNode = referenceSequenceNode.GetNthDataNode(i)
referenceNodeIndexValue = referenceSequenceNode.GetNthIndexValue(i)
dimensions = [1,1,1]
referenceNode.GetImageData().GetDimensions(dimensions)
transformNode = transformSequenceNode.GetNthDataNode(i)
inputIJK2RASMatrix = vtk.vtkMatrix4x4()
inputNode.GetIJKToRASMatrix(inputIJK2RASMatrix)
referenceRAS2IJKMatrix = vtk.vtkMatrix4x4()
referenceNode.GetRASToIJKMatrix(referenceRAS2IJKMatrix)
inputRAS2RASMatrix = transformNode.GetTransformToParent()
resampleTransform = vtk.vtkGeneralTransform()
resampleTransform.Identity()
resampleTransform.PostMultiply()
resampleTransform.Concatenate(inputIJK2RASMatrix)
resampleTransform.Concatenate(inputRAS2RASMatrix)
resampleTransform.Concatenate(referenceRAS2IJKMatrix)
resampleTransform.Inverse()
resampler = vtk.vtkImageReslice()
resampler.SetInput(inputNode.GetImageData())
resampler.SetOutputOrigin(0,0,0)
resampler.SetOutputSpacing(1,1,1)
resampler.SetOutputExtent(0,dimensions[0],0,dimensions[1],0,dimensions[2])
resampler.SetResliceTransform(resampleTransform)
resampler.Update()
outputNode = slicer.vtkMRMLScalarVolumeNode()
outputNode.CopyOrientation(referenceNode)
outputNode.SetAndObserveImageData(resampler.GetOutput())
outputSequenceNode.SetDataNodeAtValue(outputNode, referenceNodeIndexValue)
return True
def CreateSkinModel(self, parameters, wait_for_completion = False):
self.CLINode.SetStatus(self.CLINode.Running)
erodeSkin = len(parameters['SkinLabel']) > 0
# 0 - Add intermediate volume to the scene
self.NewVolume = None
if erodeSkin:
self.NewVolume = slicer.vtkMRMLScalarVolumeNode()
self.NewVolume.SetName('SkinModelMakerTemp')
slicer.mrmlScene.AddNode(self.NewVolume)
# 1 - Setup change label parameters
self.ChangeLabelParameters["RunChangeLabel"] = erodeSkin
self.ChangeLabelParameters["InputVolume"] = parameters["InputVolume"]
self.ChangeLabelParameters["OutputVolume"] = self.NewVolume
self.ChangeLabelParameters["InputLabelNumber"] = str(len(parameters['SkinLabel'].split(',')))
self.ChangeLabelParameters["InputLabel"] = parameters['SkinLabel']
self.ChangeLabelParameters["OutputLabel"] = parameters['BackgroundLabel']
# 2 Setup generate model parameters
if erodeSkin:
self.GenerateModelParameters["InputVolume"] = self.NewVolume
else:
self.GenerateModelParameters["InputVolume"] = parameters["InputVolume"]
self.GenerateModelParameters["OutputGeometry"] = parameters["OutputGeometry"]
self.GenerateModelParameters["Threshold"] = parameters['BackgroundLabel'] + 0.1
if parameters['Decimate']:
self.GenerateModelParameters["Decimate"] = 0.0
self.GenerateModelParameters["Smooth"] = 0
# 3 Setup decimator parameters
self.DecimateParameters["RunDecimator"] = parameters['Decimate']
self.DecimateParameters["InputModel"] = parameters["OutputGeometry"]
self.DecimateParameters["DecimatedModel"] = parameters["OutputGeometry"]
self.DecimateParameters["Spacing"] = parameters['Spacing']
self.DecimateParameters['UseInputPoints'] = True
self.DecimateParameters['UseFeatureEdges'] = True
self.DecimateParameters['UseFeaturePoints'] = True
# Start CLI chain
self.WaitForCompletion = wait_for_completion
self.runChangeLabel()
def onApplyButton2(self):
logic = VolumeClipIntegrationLogic()
print("onApplyButton2")
# initialize Label Map
outputLabelMap=slicer.vtkMRMLScalarVolumeNode()
outputLabelMap.SetLabelMap(1)
slicer.mrmlScene.AddNode(outputLabelMap)
# get clippingModel Node
clipModelNode=slicer.mrmlScene.GetNodesByName('clipModelNode')
clippingModel=clipModelNode.GetItemAsObject(0)
# run CLI-Module
logic.modelToLabelmap(self.inputSelector.currentNode(),clippingModel,outputLabelMap)
# set Label Outline
slicer.mrmlScene.GetNodeByID("vtkMRMLSliceNodeRed").SetUseLabelOutline(True)
slicer.mrmlScene.GetNodeByID("vtkMRMLSliceNodeYellow").SetUseLabelOutline(True)
slicer.mrmlScene.GetNodeByID("vtkMRMLSliceNodeGreen").SetUseLabelOutline(True)
def makeSlicerObject(self, sitk_img, name, label,end=False):
""" Make simpleITK object into slicer object
:param obj sitk_img: SimpleITK image object
:param str name: What the slicer object should be called
:param bool label: True if label map. False if normal volume
"""
# Get a slicer volume node ready
slicer.modules.WaspWidget.updateStatusLabel("Converting sitk image into slicer object")
slice_vol = slicer.vtkMRMLScalarVolumeNode()
slice_vol.SetScene(slicer.mrmlScene)
if name == "ws_level":
# Name is taken from the ws_level array. Reduces the array as it goes along. Not very elegant but for
# reason putting the full name into the function was not working.
level = self.ws_list_4_slicer_obj[0]
name = name+str(level)
self.ws_list_4_slicer_obj = np.delete(self.ws_list_4_slicer_obj, [0])
print self.ws_list_4_slicer_obj
slice_vol.SetName(name)
# check if it is to be a label map
if label == True:
slice_vol.LabelMapOn()
# Add to scene
slicer.mrmlScene.AddNode(slice_vol)
# # get the node address
outputNodeName = slice_vol.GetName()
nodeWriteAddress = sitkUtils.GetSlicerITKReadWriteAddress(outputNodeName)
#
# # simpleitk can now write to that node address
sitk.WriteImage(sitk_img, nodeWriteAddress)
slice_vol.UnRegister(slicer.mrmlScene)
sitk_img = None
slicer.modules.WaspWidget.updateStatusLabel("")
