def showVolumeFromHierarchyNode(self, hierarchyNode):
volume = self.loadVolumeFromHierarchyNode(hierarchyNode)
if not volume:
print "No volume"
return
if volume.IsA('vtkMRMLVolumeNode'):
if not volume.GetDisplayNodeID():
displayNode = None
if volume.IsA('vtkMRMLScalarVolumeNode'):
displayNode = slicer.vtkMRMLScalarVolumeDisplayNode()
displayNode.SetAndObserveColorNodeID("vtkMRMLColorTableNodeGrey")
if volume.IsA('vtkMRMLVectorVolumeNode'):
displayNode = slicer.vtkMRMLVectorVolumeDisplayNode()
displayNode.SetAndObserveColorNodeID("vtkMRMLColorTableNodeGrey")
if displayNode:
slicer.mrmlScene.AddNode(displayNode)
volume.SetAndObserveDisplayNodeID(displayNode.GetID())
else:
volume.GetDisplayNode().SetAndObserveColorNodeID("vtkMRMLColorTableNodeGrey")
selectionNode = slicer.app.applicationLogic().GetSelectionNode()
selectionNode.SetReferenceActiveVolumeID(volume.GetID())
slicer.app.applicationLogic().PropagateVolumeSelection(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")
# 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 onSelectOutput(self):
merge=self.outputSelector.currentNode()
master=self.masterSelector.currentNode()
if master and merge:
if not merge.GetImageData():
print("create Output Volume")
imd=vtk.vtkImageData()
mim=master.GetImageData()
imd.SetDimensions(mim.GetDimensions())
imd.SetSpacing(mim.GetSpacing())
imd.SetOrigin(mim.GetOrigin())
# if mim.GetScalarTypeMin()>=0: #unsigned
# mim.SetScalarType(mim.GetScalarType()-1)
# imd.SetScalarType(mim.GetScalarType())
IJK=vtk.vtkMatrix4x4()
master.GetIJKToRASMatrix(IJK)
merge.SetIJKToRASMatrix(IJK)
nd=slicer.vtkMRMLScalarVolumeDisplayNode()
slicer.mrmlScene.AddNode(nd)
merge.AddAndObserveDisplayNodeID(nd.GetID())
merge.SetAndObserveImageData(imd)
warnings = self.checkForVolumeWarnings(master,merge)
if warnings != "":
self.errorDialog( "Warning: %s" % warnings )
self.outputSelector.setCurrentNode(None)
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 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 __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 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 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 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 DisplayVolumeNode(self, volumeNode, name="Volume"):
existingVolumeNode = slicer.util.getNode(name)
if not existingVolumeNode:
displayNode = slicer.vtkMRMLScalarVolumeDisplayNode()
displayNode.SetAndObserveColorNodeID("vtkMRMLColorTableNodeGrey")
volumeNode.SetName(name)
slicer.mrmlScene.AddNode(volumeNode)
slicer.mrmlScene.AddNode(displayNode)
volumeNode.SetAndObserveDisplayNodeID(displayNode.GetID())
else:
existingVolumeNode.SetImageData(volumeNode.GetImageData())
existingVolumeNode.SetIJKToRAS(volumeNode.GetIJKToRAS())
return
def DisplayVolumeNode(self, volumeNode, name="Volume"):
existingVolumeNode=slicer.util.getNode(name)
if not existingVolumeNode:
displayNode=slicer.vtkMRMLScalarVolumeDisplayNode()
displayNode.SetAndObserveColorNodeID("vtkMRMLColorTableNodeGrey")
volumeNode.SetName(name)
slicer.mrmlScene.AddNode(volumeNode)
slicer.mrmlScene.AddNode(displayNode)
volumeNode.SetAndObserveDisplayNodeID(displayNode.GetID())
else:
existingVolumeNode.SetImageData(volumeNode.GetImageData())
existingVolumeNode.SetIJKToRAS(volumeNode.GetIJKToRAS())
return
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 CreateNewLabelVolume(self,name):
""" Creates a new labelmap volume with the inputted name
"""
# Create labelmap node
labelNode=slicer.vtkMRMLLabelMapVolumeNode()
labelNode.SetName(name)
# Add volume to scene
slicer.mrmlScene.AddNode(labelNode)
displayNode=slicer.vtkMRMLScalarVolumeDisplayNode()
slicer.mrmlScene.AddNode(displayNode)
colorNode = slicer.util.getNode('Grey')
displayNode.SetAndObserveColorNodeID(colorNode.GetID())
labelNode.SetAndObserveDisplayNodeID(displayNode.GetID())
labelNode.CreateDefaultStorageNode()
return labelNode
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 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 takeUSSnapshot2(self,name):
snapshotDisp = slicer.vtkMRMLModelDisplayNode()
slicer.mrmlScene.AddNode(snapshotDisp)
snapshotDisp.SetScene(slicer.mrmlScene)
snapshotDisp.SetDisableModifiedEvent(1)
snapshotDisp.SetOpacity(1.0)
snapshotDisp.SetColor(1.0, 1.0, 1.0)
snapshotDisp.SetAmbient(1.0)
snapshotDisp.SetBackfaceCulling(0)
snapshotDisp.SetDiffuse(0)
snapshotDisp.SetSaveWithScene(0)
snapshotDisp.SetDisableModifiedEvent(0)
snapshotModel = slicer.vtkMRMLModelNode()
snapshotModel.SetName(name)
snapshotModel.SetDescription("Live Ultrasound Snapshot")
snapshotModel.SetScene(slicer.mrmlScene)
snapshotModel.SetAndObserveDisplayNodeID(snapshotDisp.GetID())
snapshotModel.SetHideFromEditors(0)
snapshotModel.SetSaveWithScene(0)
slicer.mrmlScene.AddNode(snapshotModel)
image_RAS = slicer.util.getNode("Image_Image")
dim = [0, 0, 0]
imageData = image_RAS.GetImageData()
imageData.GetDimensions(dim)
plane = vtk.vtkPlaneSource()
plane.Update()
snapshotModel.SetAndObservePolyData(plane.GetOutput())
slicePolyData = snapshotModel.GetPolyData()
slicePoints = slicePolyData.GetPoints()
# In parent transform is saved the ReferenceToRAS transform
parentTransform = vtk.vtkTransform()
parentTransform.Identity()
if not image_RAS.GetParentTransformNode() == None:
parentMatrix = vtk.vtkMatrix4x4()
parentTransformNode = image_RAS.GetParentTransformNode()
parentTransformNode.GetMatrixTransformToWorld(parentMatrix)
# aux=parentTransform.GetMatrix()
# aux.DeepCopy(parentMatrix)
# parentTransform.Update()
parentTransform.SetMatrix(parentMatrix)
inImageTransform = vtk.vtkTransform()
inImageTransform.Identity()
image_RAS.GetIJKToRASMatrix(inImageTransform.GetMatrix())
tImageToRAS = vtk.vtkTransform()
tImageToRAS.Identity()
tImageToRAS.PostMultiply()
tImageToRAS.Concatenate(inImageTransform)
tImageToRAS.Concatenate(parentTransform)
tImageToRAS.Update()
point1Image = [0.0, 0.0, 0.0, 1.0]
point2Image = [dim[0], 0.0, 0.0, 1.0]
point3Image = [0.0, dim[1], 0.0, 1.0]
point4Image = [dim[0], dim[1], 0.0, 1.0]
point1RAS = [0.0, 0.0, 0.0, 0.0]
point2RAS = [0.0, 0.0, 0.0, 0.0]
point3RAS = [0.0, 0.0, 0.0, 0.0]
point4RAS = [0.0, 0.0, 0.0, 0.0]
tImageToRAS.MultiplyPoint(point1Image, point1RAS)
tImageToRAS.MultiplyPoint(point2Image, point2RAS)
tImageToRAS.MultiplyPoint(point3Image, point3RAS)
tImageToRAS.MultiplyPoint(point4Image, point4RAS)
p1RAS = [point1RAS[0], point1RAS[1], point1RAS[2]]
p2RAS = [point2RAS[0], point2RAS[1], point2RAS[2]]
p3RAS = [point3RAS[0], point3RAS[1], point3RAS[2]]
p4RAS = [point4RAS[0], point4RAS[1], point4RAS[2]]
slicePoints.SetPoint(0, p1RAS)
slicePoints.SetPoint(1, p2RAS)
slicePoints.SetPoint(2, p3RAS)
slicePoints.SetPoint(3, p4RAS)
# # Add image texture.
image = vtk.vtkImageData()
image.DeepCopy(imageData)
modelDisplayNode = snapshotModel.GetModelDisplayNode()
modelDisplayNode.SetAndObserveTextureImageData(image)
snapshotTexture = slicer.vtkMRMLScalarVolumeNode()
snapshotTexture.SetAndObserveImageData(image)
snapshotTexture.SetName(name + "_Texture")
slicer.mrmlScene.AddNode(snapshotTexture)
snapshotTexture.CopyOrientation( image_RAS )
snapshotTextureDisplayNode = slicer.vtkMRMLScalarVolumeDisplayNode()
snapshotTextureDisplayNode.SetName(name + "_TextureDisplay")
snapshotTextureDisplayNode.SetAutoWindowLevel(0);
snapshotTextureDisplayNode.SetWindow(256);
snapshotTextureDisplayNode.SetLevel(128);
snapshotTextureDisplayNode.SetDefaultColorMap();
slicer.mrmlScene.AddNode(snapshotTextureDisplayNode)
snapshotTexture.AddAndObserveDisplayNodeID( snapshotTextureDisplayNode.GetID() )
snapshotModel.SetAttribute( "TextureNodeID", snapshotTexture.GetID() )
snapshotModelDisplayNode= snapshotModel.GetModelDisplayNode()
snapshotModelDisplayNode.SetAndObserveTextureImageData( snapshotTexture.GetImageData() )
def clipVolumeWithModel(self, inputVolume, clippingModel,
clipOutsideSurface, fillOutsideValue,
clipInsideSurface, fillInsideValue, outputVolume):
"""
Fill voxels of the input volume inside/outside the clipping model with the provided fill value
"""
# Determine the transform between the box and the image IJK coordinate systems
rasToModel = vtk.vtkMatrix4x4()
if clippingModel.GetTransformNodeID() != None:
modelTransformNode = slicer.mrmlScene.GetNodeByID(
clippingModel.GetTransformNodeID())
boxToRas = vtk.vtkMatrix4x4()
modelTransformNode.GetMatrixTransformToWorld(boxToRas)
rasToModel.DeepCopy(boxToRas)
rasToModel.Invert()
ijkToRas = vtk.vtkMatrix4x4()
inputVolume.GetIJKToRASMatrix(ijkToRas)
ijkToModel = vtk.vtkMatrix4x4()
vtk.vtkMatrix4x4.Multiply4x4(rasToModel, ijkToRas, ijkToModel)
modelToIjkTransform = vtk.vtkTransform()
modelToIjkTransform.SetMatrix(ijkToModel)
modelToIjkTransform.Inverse()
transformModelToIjk = vtk.vtkTransformPolyDataFilter()
transformModelToIjk.SetTransform(modelToIjkTransform)
transformModelToIjk.SetInputConnection(
clippingModel.GetPolyDataConnection())
# Use the stencil to fill the volume
# Convert model to stencil
polyToStencil = vtk.vtkPolyDataToImageStencil()
polyToStencil.SetInputConnection(transformModelToIjk.GetOutputPort())
polyToStencil.SetOutputSpacing(inputVolume.GetImageData().GetSpacing())
polyToStencil.SetOutputOrigin(inputVolume.GetImageData().GetOrigin())
polyToStencil.SetOutputWholeExtent(
inputVolume.GetImageData().GetExtent())
# Apply the stencil to the volume
stencilToImage = vtk.vtkImageStencil()
stencilToImage.SetInputConnection(inputVolume.GetImageDataConnection())
stencilToImage.SetStencilConnection(polyToStencil.GetOutputPort())
# Create a copy of the input volume to work on
outputImageData = vtk.vtkImageData()
outputImageData.DeepCopy(inputVolume.GetImageData())
outputVolume.SetAndObserveImageData(outputImageData)
outputVolume.SetIJKToRASMatrix(ijkToRas)
# Update volume with the stencil operation result depending on user choices
if clipOutsideSurface:
stencilToImage.ReverseStencilOff()
stencilToImage.SetBackgroundValue(fillOutsideValue)
stencilToImage.Update()
outputImageData.DeepCopy(stencilToImage.GetOutput())
outputVolume.SetAndObserveImageData(outputImageData)
outputVolume.SetIJKToRASMatrix(ijkToRas)
if clipInsideSurface:
stencilToImage.SetInputConnection(
outputVolume.GetImageDataConnection())
stencilToImage.ReverseStencilOn()
stencilToImage.SetBackgroundValue(fillInsideValue)
stencilToImage.Update()
outputImageData.DeepCopy(stencilToImage.GetOutput())
outputVolume.SetAndObserveImageData(outputImageData)
outputVolume.SetIJKToRASMatrix(ijkToRas)
# Add a default display node to output volume node if it does not exist yet
if not outputVolume.GetDisplayNode:
displayNode = slicer.vtkMRMLScalarVolumeDisplayNode()
displayNode.SetAndObserveColorNodeID("vtkMRMLColorTableNodeGrey")
slicer.mrmlScene.AddNode(displayNode)
outputVolume.SetAndObserveDisplayNodeID(displayNode.GetID())
return True
def createLabelMap(self, dataNode, labelNode, outputDir, IDcurrPatient):
"""
self.sliceXarray = numpy.rollaxis(self.sliceXarray,1)[:,:,None] #512,36,1
#self.sliceXarray = self.sliceXarray[:,:,None]
self.sliceYarray = numpy.rollaxis(self.sliceYarray,1)[:,:,None] #512,36,1
#self.sliceYarray = self.sliceYarray[:,:,None]
#self.slizeZarray = numpy.rot90(self.sliceZarray)
self.sliceZarray = self.sliceZarray[:,:,None] #512,512,1
self.sliceXnode = slicer.vtkMRMLScalarVolumeNode()
self.sliceYnode = slicer.vtkMRMLScalarVolumeNode()
self.sliceZnode = slicer.vtkMRMLScalarVolumeNode()
self.sliceXnode.SetName('SliceX')
self.sliceYnode.SetName('SliceY')
self.sliceZnode.SetName('SliceZ')
self.sliceXNodeDisplayNode = slicer.vtkMRMLVectorVolumeDisplayNode()
slicer.mrmlScene.AddNode(self.sliceXNodeDisplayNode)
self.sliceXnode.SetAndObserveDisplayNodeID(self.sliceXNodeDisplayNode.GetID())
self.sliceYNodeDisplayNode = slicer.vtkMRMLVectorVolumeDisplayNode()
slicer.mrmlScene.AddNode(self.sliceYNodeDisplayNode)
self.sliceYnode.SetAndObserveDisplayNodeID(self.sliceYNodeDisplayNode.GetID())
self.sliceZNodeDisplayNode = slicer.vtkMRMLVectorVolumeDisplayNode()
slicer.mrmlScene.AddNode(self.sliceZNodeDisplayNode)
self.sliceZnode.SetAndObserveDisplayNodeID(self.sliceZNodeDisplayNode.GetID())
"""
imageFilePath = dataNode.GetStorageNode().GetFileName()
imageName = os.path.basename(imageFilePath).replace('.nrrd','')
reconDir = os.path.dirname(imageFilePath)
studyDir = os.path.dirname(reconDir)
segDir = [dirpath for dirpath in glob.glob(os.path.join(studyDir,'*')) if 'Segmentations' in dirpath][0]
resourcesDir = [dirpath for dirpath in glob.glob(os.path.join(studyDir,'*')) if 'Resources' in dirpath][0]
spacing = dataNode.GetSpacing()
origin = dataNode.GetOrigin()
#pdb.set_trace()
arrays = []
for r,d,f in os.walk(studyDir):
[arrays.append(os.path.join(r,file)) for file in fnmatch.filter(f, '*.npy')]
try:
name = os.path.basename(arrays[0]).replace('.npy', '')
except IndexError:
print(IDcurrPatient, ': FAILED TO PROCESS NPY FILE')
return
arr = numpy.load(arrays[0])
#arr = numpy.ascontiguousarray(arr)
#nump_arr = reversedim(arr,0)
nump_arr = numpy.swapaxes(arr, 0, 2)
#nump_arr = nump_arr[...,::-1]
#nump_arr = numpy.rollaxis(numpy.rollaxis(nump_arr,2),2,1)
self.labelMapnode = slicer.vtkMRMLScalarVolumeNode()
self.labelMapnode.SetName('labelMap')
self.labelMapnode.LabelMapOn()
self.labelMapnodeDisplayNode = slicer.vtkMRMLScalarVolumeDisplayNode()
slicer.mrmlScene.AddNode(self.labelMapnodeDisplayNode)
self.labelMapnode.SetAndObserveDisplayNodeID(self.labelMapnodeDisplayNode.GetID())
self.labelMapnodeDisplayNode.SetAndObserveColorNodeID('vtkMRMLColorTableNodeFileGenericColors.txt')
try:
self.labelMapnode = renderArray(self, nump_arr, self.labelMapnode, dataNode, shape=nump_arr.shape, spacing=spacing, origin=origin)
except ValueError:
print(IDcurrPatient, ': FAILED TO CONVERT TO LABEL MAP')
return
#self.sliceXnode = self.renderSlice(self.sliceXarray, self.sliceXnode, self.dataNode, shape=self.sliceXarray.shape, spacing=(x,z,1))
#self.sliceYnode = self.renderSlice(self.sliceYarray, self.sliceYnode, self.dataNode, shape=self.sliceYarray.shape, spacing=(y,z,1))
#self.sliceZnode = self.renderSlice(self.sliceZarray, self.sliceZnode, self.dataNode, shape=self.sliceZarray.shape, spacing=(x,y,1))
self.labelMapnode = binarizeLabelMapToValue(self.labelMapnode)
self.labelMapnodeDisplayNode.SetInputImageDataConnection(self.labelMapnode.GetImageDataConnection())
self.labelMapnodeDisplayNode.UpdateImageDataPipeline()
volumesLogic = slicer.vtkSlicerVolumesLogic()
volumesLogic.CenterVolume(dataNode)
volumesLogic.CenterVolume(self.labelMapnode)
labelMapNodeFileName = os.path.join(segDir, imageName + '_labelMap.nrrd')
saveLabelMap = slicer.util.saveNode(self.labelMapnode, labelMapNodeFileName, properties={"filetype": ".nrrd"})
#saveNode = slicer.util.saveNode(dataNode, imageFilePath, properties={"filetype": ".nrrd"})
arraysName = os.path.basename(arrays[0])
shutil.move(arrays[0],os.path.join(resourcesDir,arraysName))
labelMapNodeSITK = sitk.ReadImage(str(labelMapNodeFileName))
FlipZAxis = sitk.FlipImageFilter()
FlipZAxis.SetDebug(False)
FlipZAxis.SetFlipAxes([False, False, True])
FlipZAxis.SetFlipAboutOrigin(True)
FlipZAxis.SetNumberOfThreads(4)
labelMapNodeSITK = FlipZAxis.Execute(labelMapNodeSITK)
FlipZAxis.Execute(labelMapNodeSITK)
sitk.WriteImage(labelMapNodeSITK, str(labelMapNodeFileName) )
"""
def computeAverage(self, inputFieldNodes, roi, outputAverageVolume, outputVarianceVolume):
referenceVolume = self.createVectorVolumeFromRoi(roi, self.ReferenceVolumeSpacingMm)
referenceVolume.SetName('ReferenceVolume')
slicer.mrmlScene.AddNode( referenceVolume )
fieldNodes=[]
fieldImageData=[]
for fieldNode in inputFieldNodes:
resampledFieldNode = self.resampleVolume(fieldNode, referenceVolume)
fieldNodes.append(resampledFieldNode)
fieldImageData.append(resampledFieldNode.GetImageData())
ijkToRasMatrix = vtk.vtkMatrix4x4()
# Average volume
averageImageData = vtk.vtkImageData()
averageImageData.DeepCopy(referenceVolume.GetImageData())
outputAverageVolume.SetAndObserveImageData(averageImageData)
referenceVolume.GetIJKToRASMatrix(ijkToRasMatrix)
outputAverageVolume.SetIJKToRASMatrix(ijkToRasMatrix)
# Variance volume
varianceImageData = vtk.vtkImageData()
varianceImageData.SetExtent(averageImageData.GetExtent())
if vtk.VTK_MAJOR_VERSION <= 5:
varianceImageData.SetScalarType(vtk.VTK_DOUBLE)
varianceImageData.SetNumberOfScalarComponents(1)
varianceImageData.AllocateScalars()
else:
varianceImageData.AllocateScalars(vtk.VTK_DOUBLE, 1)
outputVarianceVolume.SetIJKToRASMatrix(ijkToRasMatrix)
outputVarianceVolume.SetAndObserveImageData(varianceImageData)
# Compute
dims = averageImageData.GetDimensions()
# [field, component]
voxelValues = numpy.zeros([len(fieldImageData), 3])
for z in xrange(dims[2]):
for y in xrange(dims[1]):
for x in xrange(dims[0]):
fieldIndex = 0
for imageData in fieldImageData:
voxelValues[fieldIndex,0] = imageData.GetScalarComponentAsDouble(x, y, z, 0)
voxelValues[fieldIndex,1] = imageData.GetScalarComponentAsDouble(x, y, z, 1)
voxelValues[fieldIndex,2] = imageData.GetScalarComponentAsDouble(x, y, z, 2)
fieldIndex = fieldIndex+1
meanVoxelValues = numpy.mean(voxelValues, axis = 0)
averageImageData.SetScalarComponentFromDouble(x, y, z, 0, meanVoxelValues[0])
averageImageData.SetScalarComponentFromDouble(x, y, z, 1, meanVoxelValues[1])
averageImageData.SetScalarComponentFromDouble(x, y, z, 2, meanVoxelValues[2])
# Compute the mean of the magnitude of the error vectors
errorValues = voxelValues-meanVoxelValues
errorVectorMagnitudes = numpy.sqrt(numpy.sum(errorValues*errorValues, axis=1))
varianceImageData.SetScalarComponentFromDouble(x, y, z, 0, numpy.mean(errorVectorMagnitudes))
averageImageData.Modified()
varianceImageData.Modified()
# Create display node if they have not created yet
if not outputAverageVolume.GetNthDisplayNode(0):
outputAverageVolumeDisplayNode = slicer.vtkMRMLVectorVolumeDisplayNode()
slicer.mrmlScene.AddNode( outputAverageVolumeDisplayNode )
outputAverageVolumeDisplayNode.SetAndObserveColorNodeID("vtkMRMLColorTableNodeRainbow");
outputAverageVolume.SetAndObserveNthDisplayNodeID(0, outputAverageVolumeDisplayNode.GetID());
if not outputVarianceVolume.GetNthDisplayNode(0):
outputVarianceVolumeDisplayNode = slicer.vtkMRMLScalarVolumeDisplayNode()
slicer.mrmlScene.AddNode( outputVarianceVolumeDisplayNode )
outputVarianceVolumeDisplayNode.SetAndObserveColorNodeID("vtkMRMLColorTableNodeRainbow");
outputVarianceVolume.SetAndObserveNthDisplayNodeID(0, outputVarianceVolumeDisplayNode.GetID());
# Clean up temporary nodes
for fieldNode in fieldNodes:
slicer.mrmlScene.RemoveNode( fieldNode )
slicer.mrmlScene.RemoveNode( referenceVolume )
def computeAverage(self, inputFieldNodes, roi, outputAverageVolume,
outputVarianceVolume):
referenceVolume = self.createVectorVolumeFromRoi(
roi, self.ReferenceVolumeSpacingMm)
referenceVolume.SetName('ReferenceVolume')
slicer.mrmlScene.AddNode(referenceVolume)
fieldNodes = []
fieldImageData = []
for fieldNode in inputFieldNodes:
resampledFieldNode = self.resampleVolume(fieldNode,
referenceVolume)
fieldNodes.append(resampledFieldNode)
fieldImageData.append(resampledFieldNode.GetImageData())
ijkToRasMatrix = vtk.vtkMatrix4x4()
# Average volume
averageImageData = vtk.vtkImageData()
averageImageData.DeepCopy(referenceVolume.GetImageData())
outputAverageVolume.SetAndObserveImageData(averageImageData)
referenceVolume.GetIJKToRASMatrix(ijkToRasMatrix)
outputAverageVolume.SetIJKToRASMatrix(ijkToRasMatrix)
# Variance volume
varianceImageData = vtk.vtkImageData()
varianceImageData.SetExtent(averageImageData.GetExtent())
if vtk.VTK_MAJOR_VERSION <= 5:
varianceImageData.SetScalarType(vtk.VTK_DOUBLE)
varianceImageData.SetNumberOfScalarComponents(1)
varianceImageData.AllocateScalars()
else:
varianceImageData.AllocateScalars(vtk.VTK_DOUBLE, 1)
outputVarianceVolume.SetIJKToRASMatrix(ijkToRasMatrix)
outputVarianceVolume.SetAndObserveImageData(varianceImageData)
# Compute
dims = averageImageData.GetDimensions()
# [field, component]
voxelValues = numpy.zeros([len(fieldImageData), 3])
for z in xrange(dims[2]):
for y in xrange(dims[1]):
for x in xrange(dims[0]):
fieldIndex = 0
for imageData in fieldImageData:
voxelValues[fieldIndex,
0] = imageData.GetScalarComponentAsDouble(
x, y, z, 0)
voxelValues[fieldIndex,
1] = imageData.GetScalarComponentAsDouble(
x, y, z, 1)
voxelValues[fieldIndex,
2] = imageData.GetScalarComponentAsDouble(
x, y, z, 2)
fieldIndex = fieldIndex + 1
meanVoxelValues = numpy.mean(voxelValues, axis=0)
averageImageData.SetScalarComponentFromDouble(
x, y, z, 0, meanVoxelValues[0])
averageImageData.SetScalarComponentFromDouble(
x, y, z, 1, meanVoxelValues[1])
averageImageData.SetScalarComponentFromDouble(
x, y, z, 2, meanVoxelValues[2])
# Compute the mean of the magnitude of the error vectors
errorValues = voxelValues - meanVoxelValues
errorVectorMagnitudes = numpy.sqrt(
numpy.sum(errorValues * errorValues, axis=1))
varianceImageData.SetScalarComponentFromDouble(
x, y, z, 0, numpy.mean(errorVectorMagnitudes))
averageImageData.Modified()
varianceImageData.Modified()
# Create display node if they have not created yet
if not outputAverageVolume.GetNthDisplayNode(0):
outputAverageVolumeDisplayNode = slicer.vtkMRMLVectorVolumeDisplayNode(
)
slicer.mrmlScene.AddNode(outputAverageVolumeDisplayNode)
outputAverageVolumeDisplayNode.SetAndObserveColorNodeID(
"vtkMRMLColorTableNodeRainbow")
outputAverageVolume.SetAndObserveNthDisplayNodeID(
0, outputAverageVolumeDisplayNode.GetID())
if not outputVarianceVolume.GetNthDisplayNode(0):
outputVarianceVolumeDisplayNode = slicer.vtkMRMLScalarVolumeDisplayNode(
)
slicer.mrmlScene.AddNode(outputVarianceVolumeDisplayNode)
outputVarianceVolumeDisplayNode.SetAndObserveColorNodeID(
"vtkMRMLColorTableNodeRainbow")
outputVarianceVolume.SetAndObserveNthDisplayNodeID(
0, outputVarianceVolumeDisplayNode.GetID())
# Clean up temporary nodes
for fieldNode in fieldNodes:
slicer.mrmlScene.RemoveNode(fieldNode)
slicer.mrmlScene.RemoveNode(referenceVolume)
def onHelloWorldButtonClicked(self):
scene = slicer.mrmlScene
inputModel = self.inputSelector.currentNode()
bounds = [0, 0, 0, 0, 0, 0]
inputModel.GetBounds(bounds)
print('Model Name is:')
print(inputModel.GetName())
X = bounds[1] - bounds[0]
Y = bounds[3] - bounds[2]
Z = bounds[5] - bounds[4]
mid = (bounds[0] + X / 2, bounds[2] + Y / 2, bounds[4] + Z / 2)
X_thick = .1 #TODO resolution input
Y_thick = .1 #TODO resolution input
Z_thick = .1 #TODO resolution input
z_slices = int(math.ceil(Z / Z_thick))
y_slices = int(math.ceil(Y / Y_thick))
x_slices = int(math.ceil(X / X_thick))
x_thick = X / x_slices
y_thick = Y / y_slices
z_thick = Z / z_slices
print('number of slices')
print((x_slices, y_slices, z_slices))
print('midpoint')
print(mid)
#TODO Bounding box calculation
imageSize = [x_slices, y_slices, z_slices]
imageSpacing = [x_thick, y_thick, z_thick]
voxelType = vtk.VTK_UNSIGNED_CHAR
imageData = vtk.vtkImageData()
imageData.SetDimensions(imageSize)
imageData.AllocateScalars(voxelType, 1)
thresholder = vtk.vtkImageThreshold()
thresholder.SetInputData(imageData)
thresholder.SetInValue(1)
thresholder.SetOutValue(1)
# 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()
#Transform the Volume to Fit Around the Model
transform = slicer.vtkMRMLLinearTransformNode()
scene.AddNode(transform)
volumeNode.SetAndObserveTransformNodeID(transform.GetID())
vTransform = vtk.vtkTransform()
vTransform.Translate(
(-X / 2 + mid[0], -Y / 2 + mid[1], -Z / 2 + mid[2]))
transform.SetAndObserveMatrixTransformToParent(vTransform.GetMatrix())
#Create a segmentation Node
segmentationNode = slicer.vtkMRMLSegmentationNode()
slicer.mrmlScene.AddNode(segmentationNode)
segmentationNode.CreateDefaultDisplayNodes()
segmentationNode.SetReferenceImageGeometryParameterFromVolumeNode(
volumeNode)
#Add the model as a segmentation
#sphereSource = vtk.vtkSphereSource()
#sphereSource.SetRadius(10)
#sphereSource.SetCenter(6,30,28)
#sphereSource.Update()
#segmentationNode.AddSegmentFromClosedSurfaceRepresentation(sphereSource.GetOutput(), "Test")
segmentID = segmentationNode.GetSegmentation().GenerateUniqueSegmentID(
"Test")
segmentationNode.AddSegmentFromClosedSurfaceRepresentation(
inputModel.GetPolyData(), segmentID)
#TODO, Unique ID
segmentationNode.SetMasterRepresentationToBinaryLabelmap()
modelLabelMap = segmentationNode.GetBinaryLabelmapRepresentation(
segmentID) #TODO Unique ID
segmentationNode.SetMasterRepresentationToBinaryLabelmap()
shape = list(modelLabelMap.GetDimensions())
shape.reverse() #why reverse?
labelArray = vtk.util.numpy_support.vtk_to_numpy(
modelLabelMap.GetPointData().GetScalars()).reshape(shape)
for n in range(1, shape[0] - 1):
labelArray[n, :, :] = numpy.maximum(labelArray[n, :, :],
labelArray[n - 1, :, :])
outputPolyData = vtk.vtkPolyData()
slicer.vtkSlicerSegmentationsModuleLogic.GetSegmentClosedSurfaceRepresentation(
segmentationNode, segmentID, outputPolyData)
# Create model node
model = slicer.vtkMRMLModelNode()
model.SetScene(scene)
model.SetName(scene.GenerateUniqueName("Model_Undercuts_Removed"))
model.SetAndObservePolyData(outputPolyData)
# 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())
# Add to scene
scene.AddNode(model)
def loadFilesWithPyDICOM(self):
"""
Experimental method - not ready to be used yet.
* Goal is to perform timing comparisons between
ITK dicom loading vs something that bypasses ITK
"""
import dicom
import numpy
import vtk.util.numpy_support
dataset0 = dicom.read_file(self.files[0])
dims = (dataset0.Columns, dataset0.Rows, len(self.files))
originLPS = dataset0.ImagePositionPatient
rowToLPS = dataset0.ImageOrientationPatient[:3]
colToLPS = dataset0.ImageOrientationPatient[3:]
originRAS = [-1 * originLPS[0], -1 * originLPS[1], originLPS[2]]
rowToRAS = [-1 * rowToLPS[0], -1 * rowToLPS[1], rowToLPS[2]]
colToRAS = [-1 * colToLPS[0], -1 * colToLPS[1], rowToLPS[2]]
sliceToRAS = numpy.cross(rowToRAS, colToRAS)
spacing = dataset0.PixelSpacing
if len(self.files) > 1:
dataset1 = dicom.read_file(self.files[1])
o0 = numpy.array(originLPS)
o1 = numpy.array(dataset1.ImagePositionPatient)
sliceSpacing = numpy.sqrt(abs(numpy.sum(o1-o0)))
else:
sliceSpacing = 1.
spacing.append(sliceSpacing)
typeMap = {'int16': 4, 'uint16' : 5}
imageData = vtk.vtkImageData()
imageData.SetDimensions(dims)
imageData.SetScalarType(typeMap[str(dataset0.pixel_array.dtype)])
imageData.AllocateScalars()
imageArray = vtk.util.numpy_support.vtk_to_numpy(imageData.GetPointData().GetScalars())
imageArray = imageArray.reshape(dims[::-1])
slice = 0
for f in self.files:
dataset = dicom.read_file(f)
imageArray[slice] = dataset.pixel_array
slice += 1
#TODO:
# figure out datatype...
# set window/level
# any error checking?
# multi-frame data?
# check number of components
# detect DWI
# add progress
self.volumeNode = slicer.vtkMRMLScalarVolumeNode()
self.volumeNode.SetName(self.name)
self.volumeNode.SetOrigin(originRAS)
self.volumeNode.SetIToRASDirection(rowToRAS[0], rowToRAS[1], rowToRAS[2])
self.volumeNode.SetJToRASDirection(colToRAS[0], colToRAS[1], colToRAS[2])
self.volumeNode.SetKToRASDirection(sliceToRAS[0], sliceToRAS[1], sliceToRAS[2])
self.volumeNode.SetSpacing(spacing)
self.volumeNode.SetAndObserveImageData(imageData)
displayNode = slicer.vtkMRMLScalarVolumeDisplayNode()
colorLogic = slicer.modules.colors.logic()
displayNode.SetAndObserveColorNodeID(colorLogic.GetDefaultVolumeColorNodeID())
slicer.mrmlScene.AddNode(displayNode)
slicer.mrmlScene.AddNode(self.volumeNode)
self.volumeNode.SetAndObserveDisplayNodeID(displayNode.GetID())
def clipVolumeWithModel(self, inputVolume, clippingModel, clipOutsideSurface, fillValue, outputVolume):
"""
Fill voxels of the input volume inside/outside the clipping model with the provided fill value
"""
# Determine the transform between the box and the image IJK coordinate systems
rasToModel = vtk.vtkMatrix4x4()
if clippingModel.GetTransformNodeID() != None:
modelTransformNode = slicer.mrmlScene.GetNodeByID(clippingModel.GetTransformNodeID())
boxToRas = vtk.vtkMatrix4x4()
modelTransformNode.GetMatrixTransformToWorld(boxToRas)
rasToModel.DeepCopy(boxToRas)
rasToModel.Invert()
ijkToRas = vtk.vtkMatrix4x4()
inputVolume.GetIJKToRASMatrix( ijkToRas )
ijkToModel = vtk.vtkMatrix4x4()
vtk.vtkMatrix4x4.Multiply4x4(rasToModel,ijkToRas,ijkToModel)
modelToIjkTransform = vtk.vtkTransform()
modelToIjkTransform.SetMatrix(ijkToModel)
modelToIjkTransform.Inverse()
transformModelToIjk=vtk.vtkTransformPolyDataFilter()
transformModelToIjk.SetTransform(modelToIjkTransform)
transformModelToIjk.SetInputConnection(clippingModel.GetPolyDataConnection())
# Use the stencil to fill the volume
# Convert model to stencil
polyToStencil = vtk.vtkPolyDataToImageStencil()
polyToStencil.SetInputConnection(transformModelToIjk.GetOutputPort())
polyToStencil.SetOutputSpacing(inputVolume.GetImageData().GetSpacing())
polyToStencil.SetOutputOrigin(inputVolume.GetImageData().GetOrigin())
polyToStencil.SetOutputWholeExtent(inputVolume.GetImageData().GetExtent())
# Apply the stencil to the volume
stencilToImage=vtk.vtkImageStencil()
stencilToImage.SetInputConnection(inputVolume.GetImageDataConnection())
stencilToImage.SetStencilConnection(polyToStencil.GetOutputPort())
if clipOutsideSurface:
stencilToImage.ReverseStencilOff()
else:
stencilToImage.ReverseStencilOn()
stencilToImage.SetBackgroundValue(fillValue)
stencilToImage.Update()
# Update the volume with the stencil operation result
outputImageData = vtk.vtkImageData()
outputImageData.DeepCopy(stencilToImage.GetOutput())
outputVolume.SetAndObserveImageData(outputImageData);
outputVolume.SetIJKToRASMatrix(ijkToRas)
# Add a default display node to output volume node if it does not exist yet
if not outputVolume.GetDisplayNode:
displayNode=slicer.vtkMRMLScalarVolumeDisplayNode()
displayNode.SetAndObserveColorNodeID("vtkMRMLColorTableNodeGrey")
slicer.mrmlScene.AddNode(displayNode)
outputVolume.SetAndObserveDisplayNodeID(displayNode.GetID())
return True
def setupScene(self):
logging.debug('setupScene')
logging.debug('Create transforms')
self.ReferenceToRas = slicer.util.getNode('ReferenceToRas')
if not self.ReferenceToRas:
self.ReferenceToRas=slicer.vtkMRMLLinearTransformNode()
self.ReferenceToRas.SetName("ReferenceToRas")
m = vtk.vtkMatrix4x4()
m.SetElement( 0, 0, 0 )
m.SetElement( 0, 2, -1 )
m.SetElement( 1, 1, 0 )
m.SetElement( 1, 1, -1 )
m.SetElement( 2, 2, 0 )
m.SetElement( 2, 0, -1 )
self.ReferenceToRas.SetMatrixTransformToParent(m)
slicer.mrmlScene.AddNode(self.ReferenceToRas)
self.needleTipToNeedle = slicer.util.getNode('NeedleTipToNeedle')
if not self.needleTipToNeedle:
self.needleTipToNeedle=slicer.vtkMRMLLinearTransformNode()
self.needleTipToNeedle.SetName("NeedleTipToNeedle")
m = self.readTransformFromSettings('NeedleTipToNeedle')
if m:
self.needleTipToNeedle.SetMatrixTransformToParent(m)
slicer.mrmlScene.AddNode(self.needleTipToNeedle)
self.needleModelToNeedleTip = slicer.util.getNode('NeedleModelToNeedleTip')
if not self.needleModelToNeedleTip:
self.needleModelToNeedleTip=slicer.vtkMRMLLinearTransformNode()
self.needleModelToNeedleTip.SetName("NeedleModelToNeedleTip")
m = vtk.vtkMatrix4x4()
m.SetElement( 0, 0, 0 )
m.SetElement( 1, 1, 0 )
m.SetElement( 2, 2, 0 )
m.SetElement( 0, 1, 1 )
m.SetElement( 1, 2, 1 )
m.SetElement( 2, 0, 1 )
self.needleModelToNeedleTip.SetMatrixTransformToParent(m)
slicer.mrmlScene.AddNode(self.needleModelToNeedleTip)
# Create transforms that will be updated through OpenIGTLink
self.needleToReference = slicer.util.getNode('NeedleToReference')
if not self.needleToReference:
self.needleToReference=slicer.vtkMRMLLinearTransformNode()
self.needleToReference.SetName("NeedleToReference")
slicer.mrmlScene.AddNode(self.needleToReference)
# Models
logging.debug('Create models')
self.needleModel_NeedleTip = slicer.util.getNode('NeedleModel')
if not self.needleModel_NeedleTip:
slicer.modules.createmodels.logic().CreateNeedle(80,1.0,2.5,0)
self.needleModel_NeedleTip=slicer.util.getNode(pattern="NeedleModel")
self.needleModel_NeedleTip.GetDisplayNode().SetColor(0.333333, 1.0, 1.0)
self.needleModel_NeedleTip.SetName("NeedleModel")
self.needleModel_NeedleTip.GetDisplayNode().SliceIntersectionVisibilityOn()
liveUltrasoundNodeName = self.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.
layoutManager = self.layoutManager
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')
# Build transform tree
logging.debug('Set up transform tree')
self.needleModel_NeedleTip.SetAndObserveTransformNodeID(self.needleModelToNeedleTip.GetID())
self.needleModelToNeedleTip.SetAndObserveTransformNodeID(self.needleTipToNeedle.GetID())
self.needleTipToNeedle.SetAndObserveTransformNodeID(self.needleToReference.GetID())
self.liveUltrasoundNode_Reference.SetAndObserveTransformNodeID(self.ReferenceToRas.GetID())
# Hide slice view annotations (patient name, scale, color bar, etc.) as they
# decrease reslicing performance by 20%-100%
logging.debug('Hide slice view annotations')
import DataProbe
dataProbeUtil=DataProbe.DataProbeLib.DataProbeUtil()
dataProbeParameterNode=dataProbeUtil.getParameterNode()
dataProbeParameterNode.SetParameter('showSliceViewAnnotations', '0')
def clipVolumeWithRoi(self, roiNode, volumeNode, fillValue,
clipOutsideSurface, outputVolume):
# Create a box implicit function that will be used as a stencil to fill the volume
roiBox = vtk.vtkBox()
roiCenter = [0, 0, 0]
roiNode.GetXYZ(roiCenter)
roiRadius = [0, 0, 0]
roiNode.GetRadiusXYZ(roiRadius)
roiBox.SetBounds(roiCenter[0] - roiRadius[0],
roiCenter[0] + roiRadius[0],
roiCenter[1] - roiRadius[1],
roiCenter[1] + roiRadius[1],
roiCenter[2] - roiRadius[2],
roiCenter[2] + roiRadius[2])
# Determine the transform between the box and the image IJK coordinate systems
rasToBox = vtk.vtkMatrix4x4()
if roiNode.GetTransformNodeID() != None:
roiBoxTransformNode = slicer.mrmlScene.GetNodeByID(
roiNode.GetTransformNodeID())
boxToRas = vtk.vtkMatrix4x4()
roiBoxTransformNode.GetMatrixTransformToWorld(boxToRas)
rasToBox.DeepCopy(boxToRas)
rasToBox.Invert()
ijkToRas = vtk.vtkMatrix4x4()
volumeNode.GetIJKToRASMatrix(ijkToRas)
ijkToBox = vtk.vtkMatrix4x4()
vtk.vtkMatrix4x4.Multiply4x4(rasToBox, ijkToRas, ijkToBox)
ijkToBoxTransform = vtk.vtkTransform()
ijkToBoxTransform.SetMatrix(ijkToBox)
roiBox.SetTransform(ijkToBoxTransform)
# Use the stencil to fill the volume
imageData = volumeNode.GetImageData()
# Convert the implicit function to a stencil
functionToStencil = vtk.vtkImplicitFunctionToImageStencil()
functionToStencil.SetInput(roiBox)
functionToStencil.SetOutputOrigin(imageData.GetOrigin())
functionToStencil.SetOutputSpacing(imageData.GetSpacing())
functionToStencil.SetOutputWholeExtent(imageData.GetExtent())
functionToStencil.Update()
# Apply the stencil to the volume
stencilToImage = vtk.vtkImageStencil()
stencilToImage.SetInputData(imageData)
stencilToImage.SetStencilData(functionToStencil.GetOutput())
if clipOutsideSurface:
stencilToImage.ReverseStencilOff()
else:
stencilToImage.ReverseStencilOn()
stencilToImage.SetBackgroundValue(fillValue)
stencilToImage.Update()
# Update the volume with the stencil operation result
outputImageData = vtk.vtkImageData()
outputImageData.DeepCopy(stencilToImage.GetOutput())
outputVolume.SetAndObserveImageData(outputImageData)
outputVolume.SetIJKToRASMatrix(ijkToRas)
# Add a default display node to output volume node if it does not exist yet
if not outputVolume.GetDisplayNode:
displayNode = slicer.vtkMRMLScalarVolumeDisplayNode()
displayNode.SetAndObserveColorNodeID("vtkMRMLColorTableNodeGrey")
slicer.mrmlScene.AddNode(displayNode)
outputVolume.SetAndObserveDisplayNodeID(displayNode.GetID())
def onApplyButton(self):
inputVolume = self.inputSelector.currentNode()
outputVolume = self.outputSelector.currentNode()
if not (inputVolume and outputVolume):
qt.QMessageBox.critical(
slicer.util.mainWindow(),
'T1 Mapping', 'Input and output volumes are required for T1 Mapping')
return
# run T1Mapping
# Create numpy array from images
s=slicer.util.array(inputVolume.GetID())
# Create zero numpy arrays wich has the same dimension as the input images
d=s.shape
ssin=numpy.zeros(d,dtype=numpy.float)
stan=numpy.zeros(d,dtype=numpy.float)
# Read info from VTK node (FA and TR)
v=slicer.util.getNode(inputVolume.GetID())
FA=string.split(v.GetAttribute('MultiVolume.FrameLabels'),',')
nFrames=len(FA)
for l in range(nFrames):
FA[l]=float(FA[l])
TR=str(v.GetAttribute('MultiVolume.DICOM.RepetitionTime'))
TR=float(TR)
# convert degrees to radians
FArdg=numpy.radians(FA)
# create output array
o=numpy.zeros((d[0],d[1],d[2]))
# calculate the slope of the linear regression
for i in range(nFrames):
ssin[:,:,:,i]=s[:,:,:,i]/numpy.sin(FArdg[i])
stan[:,:,:,i]=s[:,:,:,i]/numpy.tan(FArdg[i])
for i in range(d[0]):
for j in range(d[1]):
for k in range(d[2]):
[coef,res]=numpy.polyfit(stan[i,j,k,:],ssin[i,j,k,:],1)
o[i,j,k]=coef
# compute the real T1
T1=TR/numpy.log(o)*(-1)
T1=numpy.uint16(T1)
importer = vtk.vtkImageImport()
data_string = T1.tostring()
importer.CopyImportVoidPointer(data_string, len(data_string))
setDataType = 'importer.SetDataScalarTypeTo' + 'UnsignedShort' + '()'
eval(setDataType)
importer.SetNumberOfScalarComponents(1)
importer.SetWholeExtent(0,T1.shape[2]-1,0,T1.shape[1]-1,0,T1.shape[0]-1)
importer.SetDataExtentToWholeExtent()
print importer.GetDataExtent()
importer.Update()
ijkToRAS = vtk.vtkMatrix4x4()
inputVolume.GetIJKToRASMatrix(ijkToRAS)
outputVolume.SetIJKToRASMatrix(ijkToRAS)
outputVolume.SetAndObserveImageData(importer.GetOutput())
slicer.mrmlScene.AddNode(Volume)
volumeDisplayNode = slicer.vtkMRMLScalarVolumeDisplayNode()
slicer.mrmlScene.AddNode(volumeDisplayNode)
greyColorTable = slicer.util.getNode('Grey')
volumeDisplayNode.SetAndObserveColorNodeID(greyColorTable.GetID())
