def __init__(self, parent=None):
ScriptedLoadableModuleWidget.__init__(self, parent)
settings = qt.QSettings()
self.developerMode = SlicerUtil.IsDevelopment
if not parent:
self.parent = slicer.qMRMLWidget()
self.parent.setLayout(qt.QVBoxLayout())
self.parent.setMRMLScene(slicer.mrmlScene)
else:
self.parent = parent
self.layout = self.parent.layout()
if not parent:
self.setup()
self.parent.show()
self.priority = 2
self.calcificationType = 0
self.ThresholdMin = 130.0
self.ThresholdMax = 1000.0
self.MinimumLesionSize = 1
self.MaximumLesionSize = 500
self.croppedVolumeNode = slicer.vtkMRMLScalarVolumeNode()
self.threshImage = vtk.vtkImageData()
self.marchingCubes = vtk.vtkDiscreteMarchingCubes()
self.transformPolyData = vtk.vtkTransformPolyDataFilter()
self.selectedLabelList = []
self.labelScores = []
self.selectedLabels = {}
self.modelNodes = []
self.voxelVolume = 1.
self.sx = 1.
self.sy = 1.
self.sz = 1.
self.selectedRGB = [1,0,0]
self.observerTags = []
self.xy = []
self.summary_reports=["Agatston Score","Mass Score","Volume"]
self.labelScores = dict()
self.totalScores=dict()
for sr in self.summary_reports:
self.labelScores[sr]=[]
self.totalScores[sr]=0
self.columnsDict = OrderedDict()
self.columnsDict["CaseID"] = "CaseID"
for sr in self.summary_reports:
self.columnsDict[sr.replace(" ","")]=sr
def run(input_fpath, output_fpath, input_node_name=None):
assert _recent_opr_nodes == []
input_node = None
if input_node_name is not None:
input_node = getNode(input_node_name)
if input_node is None:
input_node = _load_volume(input_fpath, input_node_name)
atlas_volume, atlas_mask = _get_atlas_nodes()
output_volume_node = slicer.vtkMRMLScalarVolumeNode()
output_mask_node = slicer.vtkMRMLScalarVolumeNode()
output_volume_node.SetName('{}-output'.format(input_node.GetName()))
output_mask_node.SetName('{}-mask'.format(input_node.GetName()))
slicer.mrmlScene.AddNode(output_volume_node)
slicer.mrmlScene.AddNode(output_mask_node)
output_mask_node.LabelMapOn()
params = {
'atlasMRIVolume': atlas_volume.GetID(),
'atlasMaskVolume': atlas_mask.GetID(),
'patientVolume': input_node.GetID(),
'patientOutputVolume': output_volume_node.GetID(),
'patientMaskLabel': output_mask_node.GetID()
}
cli_node = slicer.cli.run(slicer.modules.swissskullstripper,
None,
params,
wait_for_completion=True)
# cli_node.AddObserver('ModifiedEvent', _on_status_modified)
_recent_opr_nodes[:] = [
input_node, output_volume_node, output_mask_node, output_fpath
]
_on_finished()
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(input_fpath, output_fpath, input_node_name=None):
assert _recent_opr_nodes == []
input_node = None
if input_node_name is not None:
input_node = getNode(input_node_name)
if input_node is None:
input_node = _load_volume(input_fpath, input_node_name)
atlas_volume, atlas_mask = _get_atlas_nodes()
output_volume_node = slicer.vtkMRMLScalarVolumeNode()
output_mask_node = slicer.vtkMRMLScalarVolumeNode()
output_volume_node.SetName('{}-output'.format(input_node.GetName()))
output_mask_node.SetName('{}-mask'.format(input_node.GetName()))
slicer.mrmlScene.AddNode(output_volume_node)
slicer.mrmlScene.AddNode(output_mask_node)
output_mask_node.LabelMapOn()
params = {
'atlasMRIVolume': atlas_volume.GetID(),
'atlasMaskVolume': atlas_mask.GetID(),
'patientVolume': input_node.GetID(),
'patientOutputVolume': output_volume_node.GetID(),
'patientMaskLabel': output_mask_node.GetID()
}
cli_node = slicer.cli.run(slicer.modules.swissskullstripper, None, params,
wait_for_completion=True)
# cli_node.AddObserver('ModifiedEvent', _on_status_modified)
_recent_opr_nodes[:] = [
input_node, output_volume_node, output_mask_node, output_fpath]
_on_finished()
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 TestSection_07_AccumulateDose(self):
try:
slicer.util.selectModule('DoseAccumulation')
doseAccumulationWidget = slicer.modules.doseaccumulation.widgetRepresentation()
doseAccumulationLogic = slicer.modules.doseaccumulation.logic()
self.doseAccumulationParamNode = slicer.util.getNode('DoseAccumulation')
self.assertIsNotNone( self.doseAccumulationParamNode )
day1Dose = slicer.util.getNode(self.day1DoseName)
inputFrame = slicer.util.findChildren(widget=doseAccumulationWidget, className='ctkCollapsibleButton', text='Input')[0]
referenceVolumeCombobox = slicer.util.findChildren(widget=inputFrame, className='qMRMLNodeComboBox')[0]
referenceVolumeCombobox.setCurrentNode(day1Dose)
outputFrame = slicer.util.findChildren(widget=doseAccumulationWidget, className='ctkCollapsibleButton', text='Output')[0]
outputMrmlNodeCombobox = slicer.util.findChildren(widget=outputFrame, className='qMRMLNodeComboBox')[0]
self.assertIsNotNone( referenceVolumeCombobox )
self.assertIsNotNone( outputMrmlNodeCombobox )
# Create output volumes
accumulatedDoseUnregistered = slicer.vtkMRMLScalarVolumeNode()
accumulatedDoseUnregistered.SetName(self.accumulatedDoseUnregisteredName)
slicer.mrmlScene.AddNode( accumulatedDoseUnregistered )
accumulatedDoseRigid = slicer.vtkMRMLScalarVolumeNode()
accumulatedDoseRigid.SetName(self.accumulatedDoseRigidName)
slicer.mrmlScene.AddNode( accumulatedDoseRigid )
doseAccumulationWidget.updateWidgetFromMRML()
self.DoseAccumulationUtility_SelectDoseVolume(self.day1DoseName, True)
# Accumulate Day 1 dose and untransformed Day 2 dose
self.delayDisplay("Accumulate Day 1 dose with unregistered Day 2 dose",self.delayMs)
self.DoseAccumulationUtility_SelectDoseVolume(self.day2DoseName, True)
outputMrmlNodeCombobox.setCurrentNode(accumulatedDoseUnregistered)
doseAccumulationLogic.AccumulateDoseVolumes(self.doseAccumulationParamNode)
self.assertIsNotNone( accumulatedDoseUnregistered.GetImageData() )
self.delayDisplay("Accumulate Day 1 dose with unregistered Day 2 dose finished",self.delayMs)
self.delayDisplay("Accumulate Day 1 dose with Day 2 dose registered with rigid registration",self.delayMs)
self.DoseAccumulationUtility_SelectDoseVolume(self.day2DoseName, False)
self.DoseAccumulationUtility_SelectDoseVolume(self.day2DoseRigidName, True)
outputMrmlNodeCombobox.setCurrentNode(accumulatedDoseRigid)
doseAccumulationLogic.AccumulateDoseVolumes(self.doseAccumulationParamNode)
self.assertIsNotNone( accumulatedDoseRigid.GetImageData() )
self.delayDisplay("Accumulate Day 1 dose with Day 2 dose registered with rigid registration finished",self.delayMs)
self.DoseAccumulationUtility_SelectDoseVolume(self.day2DoseRigidName, False)
except Exception, e:
import traceback
traceback.print_exc()
self.delayDisplay('Test caused exception!\n' + str(e),self.delayMs*2)
raise Exception("Exception occurred, handled, thrown further to workflow level")
def section_CLI(self):
self.delayDisplay("Test command-line interface", self.delayMs)
shNode = slicer.mrmlScene.GetSubjectHierarchyNode()
self.assertIsNotNone(shNode)
# Get CT volume
ctVolumeNode = shNode.GetItemDataNode(self.ctVolumeShItemID)
self.assertIsNotNone(ctVolumeNode)
# Create output volume
resampledVolumeNode = slicer.vtkMRMLScalarVolumeNode()
resampledVolumeNode.SetName(ctVolumeNode.GetName() +
'_Resampled_10x10x10mm')
slicer.mrmlScene.AddNode(resampledVolumeNode)
# Resample
resampleParameters = {
'outputPixelSpacing': '24.5,24.5,11.5',
'interpolationType': 'lanczos',
'InputVolume': ctVolumeNode.GetID(),
'OutputVolume': resampledVolumeNode.GetID()
}
slicer.cli.run(slicer.modules.resamplescalarvolume,
None,
resampleParameters,
wait_for_completion=True)
self.delayDisplay("Wait for CLI logic to add result to same branch",
self.delayMs)
# Check if output is also under the same study node
resampledVolumeItemID = shNode.GetItemByDataNode(resampledVolumeNode)
self.assertIsNotNone(resampledVolumeItemID)
self.assertEqual(shNode.GetItemParent(resampledVolumeItemID),
self.studyItemID)
def createListFromVectorImage(self, inputVectorNode, list):
print("Creating list from vectorNode")
inputImage = inputVectorNode.GetImageData()
listFeatureName = [
"energy", "entropy", "correlation", "inv_diff_moment", "inertia",
"cluster_shade", "cluster_prom", "har_correlation"
]
for i in range(inputImage.GetNumberOfScalarComponents()):
print("Processing return from vector to list: " + str(i) + "...")
outputNode = slicer.vtkMRMLScalarVolumeNode()
slicer.mrmlScene.AddNode(outputNode)
ijkToRAS = vtk.vtkMatrix4x4()
inputVectorNode.GetIJKToRASMatrix(ijkToRAS)
outputNode.SetIJKToRASMatrix(ijkToRAS)
extract = vtk.vtkImageExtractComponents()
extract.SetInputConnection(
inputVectorNode.GetImageDataConnection())
extract.SetComponents(i)
extract.Update()
outputNode.SetImageDataConnection(extract.GetOutputPort())
list.append((listFeatureName[i], outputNode))
def createMaskedVolume(self, inputVolume, labelVolume):
maskedVolume = slicer.vtkMRMLScalarVolumeNode()
maskedVolume.SetName("maskedTemplateVolume")
slicer.mrmlScene.AddNode(maskedVolume)
params = {'InputVolume': inputVolume, 'MaskVolume': labelVolume, 'OutputVolume': maskedVolume}
slicer.cli.run(slicer.modules.maskscalarvolume, None, params, wait_for_completion=True)
return maskedVolume
def warpImg(inImg, refImg, outImg, pixelT, tfmFile, intplMode, labelMap=False):
'''Resample an image using an exisiting transform.
inImg: full path to the input image (to be resampled);
refImg: full path to the reference image;
outImg: full path to the output image (resampled image);
pixelT: pixel type, options include
float, short, ushort, int, uint, uchar, binary
tfmFile: full path to the transform image;
intplMode: interpolation mode, options include
Linear, NearestNeighbor, BSpline, WindowedSinc.
labelMap: whether the output is a label map (Boolean).
'''
slicer.mrmlScene.Clear(0)
if labelMap:
inimg = slicer.util.loadLabelVolume(inImg)
outVolume = slicer.vtkMRMLLabelMapVolumeNode()
else:
inimg = slicer.util.loadVolume(inImg)
outVolume = slicer.vtkMRMLScalarVolumeNode()
refimg = slicer.util.loadVolume(refImg)
tfm = slicer.util.loadTransform(tfmFile)
slicer.mrmlScene.AddNode(outVolume)
cliModule = slicer.modules.brainsresample
p = {}
p['inputVolume'] = inimg.GetID()
p['referenceVolume'] = refimg.GetID()
p['outputVolume'] = outVolume.GetID()
p['pixelType'] = pixelT
p['warpTransform'] = tfm.GetID()
p['interpolationMode'] = intplMode
slicer.cli.run(cliModule, None, p, wait_for_completion=True)
state = slicer.util.saveNode(outVolume, outImg)
slicer.mrmlScene.Clear(0)
return {outImg: state}
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)
# Create 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()
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 test_Elastix1(self):
""" Ideally you should have several levels of tests. At the lowest level
tests should exercise the functionality of the logic with different inputs
(both valid and invalid). At higher levels your tests should emulate the
way the user would interact with your code and confirm that it still works
the way you intended.
One of the most important features of the tests is that it should alert other
developers when their changes will have an impact on the behavior of your
module. For example, if a developer removes a feature that you depend on,
your test should break so they know that the feature is needed.
"""
self.delayDisplay("Starting the test")
#
# first, get some data
#
import SampleData
sampleDataLogic = SampleData.SampleDataLogic()
tumor1 = sampleDataLogic.downloadMRBrainTumor1()
tumor2 = sampleDataLogic.downloadMRBrainTumor2()
outputVolume = slicer.vtkMRMLScalarVolumeNode()
slicer.mrmlScene.AddNode(outputVolume)
outputVolume.CreateDefaultDisplayNodes()
logic = ElastixLogic()
parameterFilenames = logic.getRegistrationPresets()[0][RegistrationPresets_ParameterFilenames]
logic.registerVolumes(tumor1, tumor2, parameterFilenames = parameterFilenames, outputVolumeNode = outputVolume)
self.delayDisplay('Test passed!')
def rigidReg(fixedImg, movingImg, outTfm, outImg=None, initTfm=None):
'''Rigid registration using BRAINS Registration
fixedImg: full path to the fixed image;
movingImg: full path to the moving image;
outImg: full path to the output co-registered image;
outTfm: full path to the output transform file (.tfm).
'''
slicer.mrmlScene.Clear(0)
fixed = slicer.util.loadVolume(fixedImg)
moving = slicer.util.loadVolume(movingImg)
cliModule = slicer.modules.brainsfit
p = {}
p['fixedVolume'] = fixed.GetID()
p['movingVolume'] = moving.GetID()
outVolume = slicer.vtkMRMLScalarVolumeNode()
slicer.mrmlScene.AddNode(outVolume)
p['outputVolume'] = outVolume.GetID()
p['transformType'] = 'Rigid'
tfm = slicer.vtkMRMLLinearTransformNode()
slicer.mrmlScene.AddNode(tfm)
p['outputTransform'] = tfm.GetID()
if initTfm:
_tfm = slicer.util.loadTransform(initTfm)
p['initialTransform'] = _tfm.GetID()
slicer.cli.run(cliModule, None, p, wait_for_completion=True)
result = {}
if outImg:
state1 = slicer.util.saveNode(outVolume, outImg)
result.update({outImg: state1})
state2 = slicer.util.saveNode(tfm, outTfm)
result.update({outTfm: state2})
slicer.mrmlScene.Clear(0)
return result
def runWatershed(self, masterImageData, seedLabelmap, outputLabelmap):
masterVolumeNode = slicer.vtkMRMLScalarVolumeNode()
slicer.mrmlScene.AddNode(masterVolumeNode)
slicer.vtkSlicerSegmentationsModuleLogic.CopyOrientedImageDataToVolumeNode(masterImageData, masterVolumeNode)
seedLabelmapNode = slicer.vtkMRMLLabelMapVolumeNode()
slicer.mrmlScene.AddNode(seedLabelmapNode)
slicer.vtkSlicerSegmentationsModuleLogic.CopyOrientedImageDataToVolumeNode(seedLabelmap, seedLabelmapNode)
# Read input data from Slicer into SimpleITK
labelImage = sitk.ReadImage(sitkUtils.GetSlicerITKReadWriteAddress(seedLabelmapNode.GetName()))
backgroundImage = sitk.ReadImage(sitkUtils.GetSlicerITKReadWriteAddress(masterVolumeNode.GetName()))
# Run watershed filter
featureImage = sitk.GradientMagnitudeRecursiveGaussian(backgroundImage, float(self.scriptedEffect.doubleParameter(FEATURE_SIZE_MM_PARAMETER_NAME)))
del backgroundImage
f = sitk.MorphologicalWatershedFromMarkersImageFilter()
f.SetMarkWatershedLine(False)
f.SetFullyConnected(False)
labelImage = f.Execute(featureImage, labelImage)
del featureImage
# Pixel type of watershed output is the same as the input. Convert it to int16 now.
if labelImage.GetPixelID() != sitk.sitkInt16:
labelImage = sitk.Cast(labelImage, sitk.sitkInt16)
# Write result from SimpleITK to Slicer. This currently performs a deep copy of the bulk data.
sitk.WriteImage(labelImage, sitkUtils.GetSlicerITKReadWriteAddress(seedLabelmapNode.GetName()))
# Update segmentation from labelmap node and remove temporary nodes
outputLabelmap.ShallowCopy(seedLabelmapNode.GetImageData())
outputLabelmap.SetExtent(masterImageData.GetExtent())
slicer.mrmlScene.RemoveNode(masterVolumeNode)
slicer.mrmlScene.RemoveNode(seedLabelmapNode)
def createVolume(name,n_row,n_col,n_slice):
imageSize = [n_row, n_col, n_slice]
imageSpacing = [1.0, 1.0, 1.0]
voxelType = vtk.VTK_FLOAT
# 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()
volumeNode.SetName(name)
return volumeNode
def section_CLI(self):
self.delayDisplay("Test command-line interface",self.delayMs)
shNode = slicer.vtkMRMLSubjectHierarchyNode.GetSubjectHierarchyNode(slicer.mrmlScene)
self.assertIsNotNone( shNode )
# Get CT volume
ctVolumeNode = shNode.GetItemDataNode(self.ctVolumeShItemID)
self.assertIsNotNone( ctVolumeNode )
# Create output volume
resampledVolumeNode = slicer.vtkMRMLScalarVolumeNode()
resampledVolumeNode.SetName(ctVolumeNode.GetName() + '_Resampled_10x10x10mm')
slicer.mrmlScene.AddNode(resampledVolumeNode)
# Resample
resampleParameters = { 'outputPixelSpacing':'24.5,24.5,11.5', 'interpolationType':'lanczos',
'InputVolume':ctVolumeNode.GetID(), 'OutputVolume':resampledVolumeNode.GetID() }
slicer.cli.run(slicer.modules.resamplescalarvolume, None, resampleParameters, wait_for_completion=True)
self.delayDisplay("Wait for CLI logic to add result to same branch",self.delayMs)
# Check if output is also under the same study node
resampledVolumeItemID = shNode.GetItemByDataNode(resampledVolumeNode)
self.assertIsNotNone( resampledVolumeItemID )
self.assertEqual( shNode.GetItemParent(resampledVolumeItemID), self.studyItemID )
def loadByPaths(self, paths, outputNode, properties={}):
volumeArray = None
sliceIndex = 0
for path in paths:
reader = sitk.ImageFileReader()
reader.SetFileName(path)
image = reader.Execute()
sliceArray = sitk.GetArrayFromImage(image)
if len(sliceArray.shape) == 3:
sliceArray = sitk.GetArrayFromImage(image)[:,:,0]
if volumeArray is None:
shape = (len(paths), *sliceArray.shape)
volumeArray = numpy.zeros(shape, dtype=sliceArray.dtype)
volumeArray[sliceIndex] = sliceArray
sliceIndex += 1
if not outputNode:
outputNode = slicer.vtkMRMLScalarVolumeNode()
slicer.mrmlScene.AddNode(outputNode)
if 'spacing' in properties:
outputNode.SetSpacing(*properties['spacing'])
slicer.util.updateVolumeFromArray(outputNode, volumeArray)
slicer.util.setSliceViewerLayers(background=outputNode, fit=True)
def create_new_volume_from_array(array,size,spacing,name=None):
"""
Creates a new slicer volume from a 3D numpy array
:param array: Values in the new volume
:param size: Physical size of the new image volume
:param spacing: Spacing between the voxels in the image
:param name: Name to be given to the created volume
:return: vtkMRMLScalarVolumeNode created
"""
nx, ny, nz = size
dx, dy, dz = spacing
imageOrigin = (-0.5 * (nx - 1) * dx, -0.5 * (ny - 1) * dy, -0.5 * (nz - 1) * dz)
voxelType = vtk.VTK_DOUBLE
# Create an empty image volume
imageData = vtk.vtkImageData()
imageData.SetDimensions(size)
imageData.AllocateScalars(voxelType, 1)
# Create volume node
volumeNode = slicer.vtkMRMLScalarVolumeNode()
volumeNode.SetSpacing(spacing)
volumeNode.SetOrigin(imageOrigin)
# Add volume to scene
slicer.mrmlScene.AddNode(volumeNode)
update_visualisation_settings(volumeNode,array)
volumeNode.CreateDefaultStorageNode()
if name is not None:
volumeNode.SetName(name)
slicer.util.updateVolumeFromArray(volumeNode, array)
return volumeNode
def loadByPaths(self, paths, outputNode, properties={}):
"""
Load the files in paths to outputNode with optional properties.
TODO: currently downsample is done with nearest neighbor filtering
(i.e. skip slices and take every other row/column).
It would be better to do a high order spline or other
method, but there is no convenient streaming option for these.
One option will be do to a box filter by averaging adjacent
slices/row/columns which should be easy in numpy
and give good results for a pixel aligned 50% scale operation.
"""
spacing = (1, 1, 1)
if 'spacing' in properties:
spacing = properties['spacing']
downsample = 'downsample' in properties and properties['downsample']
if downsample:
paths = paths[::2]
spacing = [element * 2. for element in spacing]
volumeArray = None
sliceIndex = 0
for path in paths:
reader = sitk.ImageFileReader()
reader.SetFileName(path)
image = reader.Execute()
sliceArray = sitk.GetArrayFromImage(image)
if len(sliceArray.shape) == 3:
sliceArray = sitk.GetArrayFromImage(image)[:, :, 0]
if volumeArray is None:
sliceShape = sliceArray.shape
if downsample:
sliceShape = [
math.floor(element / 2) for element in sliceShape
]
shape = (len(paths), *sliceShape)
volumeArray = numpy.zeros(shape, dtype=sliceArray.dtype)
if downsample:
sliceArray = sliceArray[::2, ::2]
volumeArray[sliceIndex] = sliceArray
sliceIndex += 1
if not outputNode:
outputNode = slicer.vtkMRMLScalarVolumeNode()
slicer.mrmlScene.AddNode(outputNode)
ijkToRAS = vtk.vtkMatrix4x4()
ijkToRAS.Identity()
for index in range(3):
if (spacing[index] < 0):
spacing[index] = -1. * spacing[index]
ijkToRAS.SetElement(index, index, -1.)
outputNode.SetSpacing(*spacing)
outputNode.SetIJKToRASMatrix(ijkToRAS)
slicer.util.updateVolumeFromArray(outputNode, volumeArray)
slicer.util.setSliceViewerLayers(background=outputNode, fit=True)
def mutate(self):
red_logic = slicer.app.layoutManager().sliceWidget("Red").sliceLogic()
red_cn = red_logic.GetSliceCompositeNode()
fgrdVolID = red_cn.GetBackgroundVolumeID()
fgrdNode = slicer.util.getNode("WEB")
fgrdVolID = fgrdNode.GetID()
fMat=vtk.vtkMatrix4x4()
fgrdNode.GetIJKToRASDirectionMatrix(fMat)
bgrdName = fgrdNode.GetName() + '_gray'
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()
red_cn.SetForegroundVolumeID(fgrdVolID)
red_cn.SetBackgroundVolumeID(bgrdVolID)
red_cn.SetForegroundOpacity(1)
resourcesPath = os.path.join(slicer.modules.slicerpathology.path.replace("SlicerPathology.py",""), 'Resources')
colorFile = os.path.join(resourcesPath, "Colors/SlicerPathology.csv")
try:
slicer.modules.EditorWidget.helper.structureListWidget.merge = None
except AttributeError:
pass
allColorTableNodes = slicer.util.getNodes('vtkMRMLColorTableNode*').values()
for ctn in allColorTableNodes:
if ctn.GetName() == 'SlicerPathologyColor':
slicer.mrmlScene.RemoveNode(ctn)
break
SlicerPathologyColorNode = slicer.vtkMRMLColorTableNode()
colorNode = SlicerPathologyColorNode
colorNode.SetName('SlicerPathologyColor')
slicer.mrmlScene.AddNode(colorNode)
colorNode.SetTypeToUser()
with open(colorFile) as f:
n = sum(1 for line in f)
colorNode.SetNumberOfColors(n-1)
colorNode.NamesInitialisedOn()
import csv
structureNames = []
with open(colorFile, 'rb') as csvfile:
reader = csv.DictReader(csvfile, delimiter=',')
for index,row in enumerate(reader):
success = colorNode.SetColor(index ,row['Label'],float(row['R'])/255,float(row['G'])/255,float(row['B'])/255,float(row['A']))
if not success:
print "color %s could not be set" % row['Label']
structureNames.append(row['Label'])
volumesLogic = slicer.modules.volumes.logic()
labelName = bgrdName+'-label'
refLabel = volumesLogic.CreateAndAddLabelVolume(slicer.mrmlScene,bgrdNode,labelName)
refLabel.GetDisplayNode().SetAndObserveColorNodeID(SlicerPathologyColorNode.GetID())
self.editorWidget.helper.setMasterVolume(bgrdNode)
def __init__(self, inputVolumes, outputVolume):
"""Configure outputVolume and an iterationVolume to match
the first inputVolume."""
self.inputVolumes = inputVolumes
self.outputVolume = outputVolume
if len(inputVolumes) < 1:
raise "Must have at least one input volume"
self.volume0 = inputVolumes[0]
if not self.volume0.GetImageData():
raise "Must have a valid input volume with image data"
# TODO: caller should be required to specify all scratch volumes
iterationName = '%s-iteration' % self.outputVolume.GetName()
try:
self.iterationVolume = slicer.util.getNode(iterationName)
except slicer.util.MRMLNodeNotFoundException:
self.iterationVolume = None
if not self.iterationVolume:
self.iterationVolume = slicer.vtkMRMLScalarVolumeNode()
self.iterationVolume.SetName(iterationName)
slicer.mrmlScene.AddNode(self.iterationVolume)
rasToIJK = vtk.vtkMatrix4x4()
self.volume0.GetRASToIJKMatrix(rasToIJK)
for volume in [self.iterationVolume, self.outputVolume]:
volume.SetRASToIJKMatrix(rasToIJK)
volume.SetAndObserveTransformNodeID(self.volume0.GetTransformNodeID())
image = vtk.vtkImageData()
image.SetDimensions(self.volume0.GetImageData().GetDimensions())
image.AllocateScalars(vtk.VTK_UNSIGNED_CHAR, 4) # TODO: needs to be RGBA for rendering
volume.SetAndObserveImageData(image)
self.header = """
#version 150
vec3 transformPoint(const in vec3 samplePoint)
{
return samplePoint; // identity
}
"""
self.vertexShaderTemplate = """
#version 150
in vec3 vertexCoordinate;
in vec2 textureCoordinate;
out vec3 interpolatedTextureCoordinate;
void main()
{
interpolatedTextureCoordinate = vec3(textureCoordinate, .5);
gl_Position = vec4(vertexCoordinate, 1.);
}
"""
self.readBackToVolumeNode = False
self.dummyImage = vtk.vtkImageData()
self.dummyImage.SetDimensions(5,5,5)
self.dummyImage.AllocateScalars(vtk.VTK_SHORT, 1)
def computePreviewLabelmap(self, mergedImage, outputLabelmap):
import vtkSegmentationCorePython as vtkSegmentationCore
import vtkSlicerSegmentationsModuleLogicPython as vtkSlicerSegmentationsModuleLogic
# This can be a long operation - indicate it to the user
qt.QApplication.setOverrideCursor(qt.Qt.WaitCursor)
masterVolumeNode = slicer.vtkMRMLScalarVolumeNode()
slicer.mrmlScene.AddNode(masterVolumeNode)
slicer.vtkSlicerSegmentationsModuleLogic.CopyOrientedImageDataToVolumeNode(
self.clippedMasterImageData, masterVolumeNode)
mergedLabelmapNode = slicer.vtkMRMLLabelMapVolumeNode()
slicer.mrmlScene.AddNode(mergedLabelmapNode)
slicer.vtkSlicerSegmentationsModuleLogic.CopyOrientedImageDataToVolumeNode(
mergedImage, mergedLabelmapNode)
outputRasToIjk = vtk.vtkMatrix4x4()
mergedImage.GetImageToWorldMatrix(outputRasToIjk)
outputExtent = mergedImage.GetExtent()
# Run segmentation algorithm
import SimpleITK as sitk
import sitkUtils
# Read input data from Slicer into SimpleITK
labelImage = sitk.ReadImage(
sitkUtils.GetSlicerITKReadWriteAddress(
mergedLabelmapNode.GetName()))
backgroundImage = sitk.ReadImage(
sitkUtils.GetSlicerITKReadWriteAddress(masterVolumeNode.GetName()))
# Run watershed filter
featureImage = sitk.GradientMagnitudeRecursiveGaussian(
backgroundImage,
float(self.scriptedEffect.doubleParameter("ObjectScaleMm")))
del backgroundImage
f = sitk.MorphologicalWatershedFromMarkersImageFilter()
f.SetMarkWatershedLine(False)
f.SetFullyConnected(False)
labelImage = f.Execute(featureImage, labelImage)
del featureImage
# Pixel type of watershed output is the same as the input. Convert it to int16 now.
if labelImage.GetPixelID() != sitk.sitkInt16:
labelImage = sitk.Cast(labelImage, sitk.sitkInt16)
# Write result from SimpleITK to Slicer. This currently performs a deep copy of the bulk data.
sitk.WriteImage(
labelImage,
sitkUtils.GetSlicerITKReadWriteAddress(
mergedLabelmapNode.GetName()))
# Update segmentation from labelmap node and remove temporary nodes
outputLabelmap.ShallowCopy(mergedLabelmapNode.GetImageData())
outputLabelmap.SetImageToWorldMatrix(outputRasToIjk)
outputLabelmap.SetExtent(outputExtent)
slicer.mrmlScene.RemoveNode(masterVolumeNode)
slicer.mrmlScene.RemoveNode(mergedLabelmapNode)
qt.QApplication.restoreOverrideCursor()
def _configure_scene(scene):
nodes = [slicer.vtkMRMLScalarVolumeNode() for idx in range(4)]
scene.AddNode(nodes[0]).SetName("Volume1")
scene.AddNode(nodes[1]).SetName("Volume2")
scene.AddNode(nodes[2]).SetName("Volume")
scene.AddNode(nodes[3]).SetName("Volume")
nodes[0].SetHideFromEditors(1)
return nodes
def _configure_scene(scene):
nodes = [slicer.vtkMRMLScalarVolumeNode() for idx in range(4)]
scene.AddNode(nodes[0]).SetName("Volume1")
scene.AddNode(nodes[1]).SetName("Volume2")
scene.AddNode(nodes[2]).SetName("Volume")
scene.AddNode(nodes[3]).SetName("Volume")
nodes[0].SetHideFromEditors(1)
return nodes
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 onApply(self):
# Get list of visible segment IDs, as the effect ignores hidden segments.
segmentationNode = self.scriptedEffect.parameterSetNode().GetSegmentationNode()
visibleSegmentIds = vtk.vtkStringArray()
segmentationNode.GetDisplayNode().GetVisibleSegmentIDs(visibleSegmentIds)
if visibleSegmentIds.GetNumberOfValues() == 0:
logging.info("Smoothing operation skipped: there are no visible segments")
return
# This can be a long operation - indicate it to the user
qt.QApplication.setOverrideCursor(qt.Qt.WaitCursor)
# Allow users revert to this state by clicking Undo
self.scriptedEffect.saveStateForUndo()
# Export master image data to temporary new volume node.
# Note: Although the original master volume node is already in the scene, we do not use it here,
# because the master volume may have been resampled to match segmentation geometry.
import vtkSegmentationCorePython as vtkSegmentationCore
masterVolumeNode = slicer.vtkMRMLScalarVolumeNode()
slicer.mrmlScene.AddNode(masterVolumeNode)
masterVolumeNode.SetAndObserveTransformNodeID(segmentationNode.GetTransformNodeID())
slicer.vtkSlicerSegmentationsModuleLogic.CopyOrientedImageDataToVolumeNode(self.scriptedEffect.masterVolumeImageData(), masterVolumeNode)
# Generate merged labelmap of all visible segments, as the filter expects a single labelmap with all the labels.
mergedLabelmapNode = slicer.vtkMRMLLabelMapVolumeNode()
slicer.mrmlScene.AddNode(mergedLabelmapNode)
slicer.vtkSlicerSegmentationsModuleLogic.ExportSegmentsToLabelmapNode(segmentationNode, visibleSegmentIds, mergedLabelmapNode, masterVolumeNode)
# Run segmentation algorithm
import SimpleITK as sitk
import sitkUtils
# Read input data from Slicer into SimpleITK
labelImage = sitk.ReadImage(sitkUtils.GetSlicerITKReadWriteAddress(mergedLabelmapNode.GetName()))
backgroundImage = sitk.ReadImage(sitkUtils.GetSlicerITKReadWriteAddress(masterVolumeNode.GetName()))
# Run watershed filter
featureImage = sitk.GradientMagnitudeRecursiveGaussian(backgroundImage, float(self.scriptedEffect.doubleParameter("ObjectScaleMm")))
del backgroundImage
f = sitk.MorphologicalWatershedFromMarkersImageFilter()
f.SetMarkWatershedLine(False)
f.SetFullyConnected(False)
labelImage = f.Execute(featureImage, labelImage)
del featureImage
# Pixel type of watershed output is the same as the input. Convert it to int16 now.
if labelImage.GetPixelID() != sitk.sitkInt16:
labelImage = sitk.Cast(labelImage, sitk.sitkInt16)
# Write result from SimpleITK to Slicer. This currently performs a deep copy of the bulk data.
sitk.WriteImage(labelImage, sitkUtils.GetSlicerITKReadWriteAddress(mergedLabelmapNode.GetName()))
mergedLabelmapNode.GetImageData().Modified()
mergedLabelmapNode.Modified()
# Update segmentation from labelmap node and remove temporary nodes
slicer.vtkSlicerSegmentationsModuleLogic.ImportLabelmapToSegmentationNode(mergedLabelmapNode, segmentationNode, visibleSegmentIds)
slicer.mrmlScene.RemoveNode(masterVolumeNode)
slicer.mrmlScene.RemoveNode(mergedLabelmapNode)
qt.QApplication.restoreOverrideCursor()
def onApply(self):
# Get list of visible segment IDs, as the effect ignores hidden segments.
segmentationNode = self.scriptedEffect.parameterSetNode().GetSegmentationNode()
visibleSegmentIds = vtk.vtkStringArray()
segmentationNode.GetDisplayNode().GetVisibleSegmentIDs(visibleSegmentIds)
if visibleSegmentIds.GetNumberOfValues() == 0:
logging.info("Smoothing operation skipped: there are no visible segments")
return
# This can be a long operation - indicate it to the user
qt.QApplication.setOverrideCursor(qt.Qt.WaitCursor)
# Allow users revert to this state by clicking Undo
self.scriptedEffect.saveStateForUndo()
# Export master image data to temporary new volume node.
# Note: Although the original master volume node is already in the scene, we do not use it here,
# because the master volume may have been resampled to match segmentation geometry.
import vtkSegmentationCorePython as vtkSegmentationCore
masterVolumeNode = slicer.vtkMRMLScalarVolumeNode()
slicer.mrmlScene.AddNode(masterVolumeNode)
masterVolumeNode.SetAndObserveTransformNodeID(segmentationNode.GetTransformNodeID())
slicer.vtkSlicerSegmentationsModuleLogic.CopyOrientedImageDataToVolumeNode(self.scriptedEffect.masterVolumeImageData(), masterVolumeNode)
# Generate merged labelmap of all visible segments, as the filter expects a single labelmap with all the labels.
mergedLabelmapNode = slicer.vtkMRMLLabelMapVolumeNode()
slicer.mrmlScene.AddNode(mergedLabelmapNode)
slicer.vtkSlicerSegmentationsModuleLogic.ExportSegmentsToLabelmapNode(segmentationNode, visibleSegmentIds, mergedLabelmapNode, masterVolumeNode)
# Run segmentation algorithm
import SimpleITK as sitk
import sitkUtils
# Read input data from Slicer into SimpleITK
labelImage = sitk.ReadImage(sitkUtils.GetSlicerITKReadWriteAddress(mergedLabelmapNode.GetName()))
backgroundImage = sitk.ReadImage(sitkUtils.GetSlicerITKReadWriteAddress(masterVolumeNode.GetName()))
# Run watershed filter
featureImage = sitk.GradientMagnitudeRecursiveGaussian(backgroundImage, float(self.scriptedEffect.doubleParameter("ObjectScaleMm")))
del backgroundImage
f = sitk.MorphologicalWatershedFromMarkersImageFilter()
f.SetMarkWatershedLine(False)
f.SetFullyConnected(False)
labelImage = f.Execute(featureImage, labelImage)
del featureImage
# Pixel type of watershed output is the same as the input. Convert it to int16 now.
if labelImage.GetPixelID() != sitk.sitkInt16:
labelImage = sitk.Cast(labelImage, sitk.sitkInt16)
# Write result from SimpleITK to Slicer. This currently performs a deep copy of the bulk data.
sitk.WriteImage(labelImage, sitkUtils.GetSlicerITKReadWriteAddress(mergedLabelmapNode.GetName()))
mergedLabelmapNode.GetImageData().Modified()
mergedLabelmapNode.Modified()
# Update segmentation from labelmap node and remove temporary nodes
slicer.vtkSlicerSegmentationsModuleLogic.ImportLabelmapToSegmentationNode(mergedLabelmapNode, segmentationNode, visibleSegmentIds)
slicer.mrmlScene.RemoveNode(masterVolumeNode)
slicer.mrmlScene.RemoveNode(mergedLabelmapNode)
qt.QApplication.restoreOverrideCursor()
def __init__(self, inputVolumes, outputVolume):
"""Configure outputVolume and an iterationVolume to match
the first inputVolume."""
self.inputVolumes = inputVolumes
self.outputVolume = outputVolume
if len(inputVolumes) < 1:
raise "Must have at least one input volume"
self.volume0 = inputVolumes[0]
if not self.volume0.GetImageData():
raise "Must have a valid input volume with image data"
# TODO: caller should be required to specify all scratch volumes
iterationName = '%s-iteration' % self.outputVolume.GetName()
self.iterationVolume = slicer.util.getNode(iterationName)
if not self.iterationVolume:
self.iterationVolume = slicer.vtkMRMLScalarVolumeNode()
self.iterationVolume.SetName(iterationName)
slicer.mrmlScene.AddNode(self.iterationVolume)
rasToIJK = vtk.vtkMatrix4x4()
self.volume0.GetRASToIJKMatrix(rasToIJK)
for volume in [self.iterationVolume, self.outputVolume]:
volume.SetRASToIJKMatrix(rasToIJK)
volume.SetAndObserveTransformNodeID(self.volume0.GetTransformNodeID())
image = vtk.vtkImageData()
image.SetDimensions(self.volume0.GetImageData().GetDimensions())
image.AllocateScalars(vtk.VTK_UNSIGNED_CHAR, 4) # TODO: needs to be RGBA for rendering
volume.SetAndObserveImageData(image)
self.header = """
#version 120
vec3 transformPoint(const in vec3 samplePoint)
{
return samplePoint; // identity
}
"""
self.vertexShaderTemplate = """
#version 120
attribute vec3 vertexAttribute;
attribute vec2 textureCoordinateAttribute;
varying vec3 interpolatedTextureCoordinate;
void main()
{
interpolatedTextureCoordinate = vec3(textureCoordinateAttribute, .5);
gl_Position = vec4(vertexAttribute, 1.);
}
"""
self.readBackToVolumeNode = False
self.dummyImage = vtk.vtkImageData()
self.dummyImage.SetDimensions(5,5,5)
self.dummyImage.AllocateScalars(vtk.VTK_SHORT, 1)
def onApplyButton(self):
print("Transducer parameters >> /n")
print("ROC:" + str(self.ROC.value))
print("Width:" + str(self.width.value))
print("ROC:" + str(self.freq.value))
skull, skull_actor = hlp.read_skull_vtk(
"/Users/home/Desktop/Simulation/Simulation/SMA_matlab_skull_transform0.vtk",
0.5, [0.8, 0.8, 0.8])
model = slicer.vtkMRMLModelNode()
model.SetAndObservePolyData(skull)
## set model node properties
modelDisplay = slicer.vtkMRMLModelDisplayNode()
modelDisplay.SetColor(0.8, 0.8, 0.8)
modelDisplay.BackfaceCullingOff()
modelDisplay.SetOpacity(0.5)
modelDisplay.SetPointSize(3)
## mode node display
modelDisplay.SetSliceIntersectionVisibility(True)
modelDisplay.SetVisibility(True)
slicer.mrmlScene.AddNode(modelDisplay)
model.SetAndObserveDisplayNodeID(modelDisplay.GetID())
modelDisplay.SetInputPolyDataConnection(model.GetPolyDataConnection())
## model node set name
slicer.mrmlScene.AddNode(model).SetName("Skull")
## read vtk object convert to vtkimage
result_image = hlp.vtk_grid2image(
"/Users/home/Desktop/Simulation/Simulation/SMA_full_0.vtk")
result_volume = slicer.vtkMRMLScalarVolumeNode()
result_volume.SetAndObserveImageData(result_image)
## image to 2D scene
defaultVolumeDisplayNode = slicer.mrmlScene.CreateNodeByClass(
"vtkMRMLScalarVolumeDisplayNode")
defaultVolumeDisplayNode.AutoWindowLevelOn()
defaultVolumeDisplayNode.SetVisibility(True)
defaultVolumeDisplayNode.AddWindowLevelPresetFromString(
"ColdToHotRainbow")
slicer.mrmlScene.AddDefaultNode(defaultVolumeDisplayNode)
result_volume.SetAndObserveDisplayNodeID(
defaultVolumeDisplayNode.GetID())
defaultVolumeDisplayNode.SetInputImageDataConnection(
result_volume.GetImageDataConnection())
## volume node set name
slicer.mrmlScene.AddNode(result_volume).SetName("simulation_result")
## volume rendering
hlp.showVolumeRendering(result_volume)
slicer.mrmlScene.AddObserver(slicer.vtkMRMLScene.NodeAddedEvent,
hlp.onNodeAdded)
def applyOtsuFilter(volume):
outputVolume = slicer.vtkMRMLScalarVolumeNode()
outputVolume.SetName('ZFrame_Otsu_Output')
slicer.mrmlScene.AddNode(outputVolume)
params = {'inputVolume': volume.GetID(),
'outputVolume': outputVolume.GetID(),
'insideValue': 0, 'outsideValue': 1}
slicer.cli.run(slicer.modules.otsuthresholdimagefilter, None, params, wait_for_completion=True)
return outputVolume
def generateZScore(self, inputVolumeNode, listFeatures,
thicknessVolumeNode, listZFeatures):
print("Doing features step:")
print("Registration:")
# Load feature templates
# To hold transform
regMNItoRefTransform = slicer.vtkMRMLBSplineTransformNode()
slicer.mrmlScene.AddNode(regMNItoRefTransform)
print("Registering flair image...")
outputFlair = slicer.vtkMRMLScalarVolumeNode()
slicer.mrmlScene.AddNode(outputFlair)
self.registerAndExtractZ(inputVolumeNode, outputFlair, "flair",
regMNItoRefTransform, True)
for featureNode in listFeatures:
print("Registering " + featureNode[0] + "...")
output = slicer.vtkMRMLScalarVolumeNode()
slicer.mrmlScene.AddNode(output)
self.registerAndExtractZ(featureNode[1], output, featureNode[0],
regMNItoRefTransform, False)
# Add to vectorFeatureNodes
# vectorFeatureNodes.append(output)
listZFeatures.append((featureNode[0] + "_z", output))
# vectorFeatureNodes.append(inputVolumeNode)
# vectorFeatureNodes.append(outputFlair)
listFeatures.append(("flair", inputVolumeNode))
listZFeatures.append(("flair_z", outputFlair))
if thicknessVolumeNode is not None:
print("Processing thickness...")
outputThick = slicer.vtkMRMLScalarVolumeNode()
slicer.mrmlScene.AddNode(outputThick)
self.registerAndExtractZ(thicknessVolumeNode, outputThick,
"thickness", regMNItoRefTransform, False)
listFeatures.append(("thickness", thicknessVolumeNode))
listZFeatures.append(("thickness_z", outputThick))
def test_GLFilters1(self):
"""Test a multi-input filter"""
import ShaderComputation
nodes = ShaderComputation.ShaderComputationTest().amigoMRUSPreIntraData()
outputNode = slicer.vtkMRMLScalarVolumeNode()
outputNode.SetName('output')
slicer.mrmlScene.AddNode(outputNode)
logic = GLFiltersLogic()
logic.run(nodes[0], outputNode, 1)
def applyBiasCorrection(self):
outputVolume = slicer.vtkMRMLScalarVolumeNode()
outputVolume.SetName('VOLUME-PREOP-N4')
slicer.mrmlScene.AddNode(outputVolume)
params = {'inputImageName': self.session.data.initialVolume.GetID(),
'maskImageName': self.session.data.initialLabel.GetID(),
'outputImageName': outputVolume.GetID(),
'numberOfIterations': '500,400,300'}
slicer.cli.run(slicer.modules.n4itkbiasfieldcorrection, None, params, wait_for_completion=True)
self.session.data.initialVolume = outputVolume
self.session.data.preopData.usedERC = True
def createDummyVolume(self):
imageData = vtk.vtkImageData()
imageData.SetDimensions(10,10,10)
imageData.AllocateScalars(vtk.VTK_UNSIGNED_CHAR, 1)
volumeNode = slicer.vtkMRMLScalarVolumeNode()
volumeNode.SetAndObserveImageData(imageData)
displayNode = slicer.vtkMRMLScalarVolumeDisplayNode()
slicer.mrmlScene.AddNode(volumeNode)
slicer.mrmlScene.AddNode(displayNode)
volumeNode.SetAndObserveDisplayNodeID(displayNode.GetID())
displayNode.SetAndObserveColorNodeID('vtkMRMLColorTableNodeGrey')
return volumeNode
def registerVolumesElastix(self,fixedVolumeNode, movingVolumeNode, outputTransform,
fixedVolumeMask, movingVolumeMask):
outputVolume = slicer.vtkMRMLScalarVolumeNode()
slicer.mrmlScene.AddNode(outputVolume)
outputVolume.CreateDefaultDisplayNodes()
logic = slicer.modules.elastix.logic()
parameterFilenames = logic.getRegistrationPresets()[0][RegistrationPresets_ParameterFilenames]
logic.registerVolumes(fixedVolumeNode, movingVolumeNode, parameterFilenames=parameterFilenames, outputVolumeNode=outputVolume,
outputTransformNode = outputTransform, fixedVolumeMaskNode = fixedVolumeMask, movingVolumeMaskNode = movingVolumeMask)
self.delayDisplay('Volumes Registered!')
def onGradientInNewVolBtnClicked(self):
# Result is not right!
volumeNode = slicer.util.getNode("MRHead")
ijkToRas = vtk.vtkMatrix4x4()
volumeNode.GetIJKToRASMatrix(ijkToRas)
imageData = volumeNode.GetImageData()
extent = imageData.GetExtent()
imageSize = imageData.GetDimensions()
imageSpacing = imageData.GetSpacing()
voxelType = vtk.VTK_FLOAT
# Create empty image volume
imageData_2 = vtk.vtkImageData()
imageData_2.SetDimensions(imageSize[0] / 2, imageSize[1] / 2, imageSize[2] / 2)
imageData_2.SetSpacing(imageSpacing)
imageData_2.AllocateScalars(voxelType, 0)
thresholder = vtk.vtkImageThreshold()
thresholder.SetInputData(imageData_2)
thresholder.SetInValue(0)
thresholder.SetOutValue(0)
volumeNode_2 = slicer.vtkMRMLScalarVolumeNode()
volumeNode_2.SetSpacing(imageSpacing)
volumeNode_2.SetImageDataConnection(thresholder.GetOutputPort())
# Add volume to scene
scene = slicer.mrmlScene
scene.AddNode(volumeNode_2)
displayNode = slicer.vtkMRMLScalarVolumeDisplayNode()
scene.AddNode(displayNode)
colorNode = slicer.util.getNode("Grey")
displayNode.SetAndObserveColorNodeID(colorNode.GetID())
volumeNode_2.SetAndObserveDisplayNodeID(displayNode.GetID())
volumeNode_2.CreateDefaultStorageNode()
# npData = slicer.util.array('MRHead')
impVol = vtk.vtkImplicitVolume()
impVol.SetVolume(imageData)
for k in xrange(extent[4], extent[5] / 2 + 1):
for j in xrange(extent[2], extent[3] / 2 + 1):
for i in xrange(extent[0], extent[1] / 2 + 1):
g = impVol.FunctionGradient(i, j, k)
gradient = math.sqrt(g[0] ** 2 + g[1] ** 2 + g[2] ** 2)
imageData_2.SetScalarComponentFromFloat(i, j, k, 0, gradient)
imageData_2.Modified()
def createMaskedVolume(inputVolume, labelVolume, outputVolumeName=None):
maskedVolume = slicer.vtkMRMLScalarVolumeNode()
if outputVolumeName:
maskedVolume.SetName(outputVolumeName)
slicer.mrmlScene.AddNode(maskedVolume)
params = {
'InputVolume': inputVolume,
'MaskVolume': labelVolume,
'OutputVolume': maskedVolume
}
slicer.cli.run(slicer.modules.maskscalarvolume,
None,
params,
wait_for_completion=True)
return maskedVolume
def AddVolumeNode(self):
# Create empty volume node
volumeNode = slicer.mrmlScene.GetNthNodeByClass(1, 'vtkMRMLScalarVolumeNode')
if volumeNode == None:
volumeNode = slicer.vtkMRMLScalarVolumeNode()
slicer.mrmlScene.AddNode(volumeNode)
displayNode = slicer.mrmlScene.GetNthNodeByClass(1,'vtkMRMLScalarVolumeDisplayNode')
if displayNode == None:
displayNode = slicer.vtkMRMLScalarVolumeDisplayNode()
colorNode = slicer.util.getNode('Grey')
displayNode.SetAndObserveColorNodeID(colorNode.GetID())
volumeNode.SetAndObserveDisplayNodeID(displayNode.GetID())
volumeNode.CreateDefaultStorageNode()
volumeNode.SetName("Volume Node")
def applyBiasCorrection(volume, label):
outputVolume = slicer.vtkMRMLScalarVolumeNode()
outputVolume.SetName('{}-N4'.format(volume.GetName()))
slicer.mrmlScene.AddNode(outputVolume)
params = {
'inputImageName': volume.GetID(),
'maskImageName': label.GetID(),
'outputImageName': outputVolume.GetID(),
'numberOfIterations': '500,400,300'
}
slicer.cli.run(slicer.modules.n4itkbiasfieldcorrection,
None,
params,
wait_for_completion=True)
return outputVolume
def applyOtsuFilter(volume):
outputVolume = slicer.vtkMRMLScalarVolumeNode()
outputVolume.SetName('ZFrame_Otsu_Output')
slicer.mrmlScene.AddNode(outputVolume)
params = {
'inputVolume': volume.GetID(),
'outputVolume': outputVolume.GetID(),
'insideValue': 0,
'outsideValue': 1
}
slicer.cli.run(slicer.modules.otsuthresholdimagefilter,
None,
params,
wait_for_completion=True)
return outputVolume
def test_BRAINSFitRigidRegistrationCrashIssue4139(self):
""" Ideally you should have several levels of tests. At the lowest level
tests should exercise the functionality of the logic with different inputs
(both valid and invalid). At higher levels your tests should emulate the
way the user would interact with your code and confirm that it still works
the way you intended.
One of the most important features of the tests is that it should alert other
developers when their changes will have an impact on the behavior of your
module. For example, if a developer removes a feature that you depend on,
your test should break so they know that the feature is needed.
"""
self.delayDisplay("Starting the test")
logic = BRAINSFitRigidRegistrationCrashIssue4139Logic()
import SampleData
from SampleData import SampleDataLogic
sampleDatalogic = SampleDataLogic()
fixed = sampleDatalogic.downloadMRBrainTumor1()
self.assertIsNotNone(logic.hasImageData(fixed))
moving = sampleDatalogic.downloadMRBrainTumor2()
self.assertIsNotNone(logic.hasImageData(moving))
self.delayDisplay('Finished with download and loading')
outputTransform = slicer.vtkMRMLLinearTransformNode()
slicer.mrmlScene.AddNode(outputTransform)
outputVolume = slicer.vtkMRMLScalarVolumeNode()
slicer.mrmlScene.AddNode(outputVolume)
parameters = {
'fixedVolume' : fixed,
'movingVolume' : moving,
'linearTransform' : outputTransform,
'outputVolume' : outputVolume,
'useRigid' : True
}
cmdLineNode = slicer.cli.runSync(slicer.modules.brainsfit, parameters=parameters)
self.assertIsNotNone(cmdLineNode)
# If test reach this point without crashing it is a success
self.delayDisplay('Test passed!')
def onNewVolBtnClicked(self):
imageSize = [128] * 3
imageSpacing = [1.0] * 3
voxelType = vtk.VTK_UNSIGNED_CHAR
# Create an empty image volume
imageData = vtk.vtkImageData()
imageData.SetDimensions(imageSize)
imageData.AllocateScalars(voxelType, 64)
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
scene = slicer.mrmlScene
scene.AddNode(volumeNode)
displayNode = slicer.vtkMRMLScalarVolumeDisplayNode()
scene.AddNode(displayNode)
colorNode = slicer.util.getNode("Grey")
displayNode.SetAndObserveColorNodeID(colorNode.GetID())
volumeNode.SetAndObserveDisplayNodeID(displayNode.GetID())
volumeNode.CreateDefaultStorageNode()
# Show the new volume in the Slice view
applicationLogic = slicer.app.applicationLogic()
selectionNode = applicationLogic.GetSelectionNode()
selectionNode.SetSecondaryVolumeID(volumeNode.GetID())
applicationLogic.PropagateForegroundVolumeSelection(0)
# Center the 3D View on the scene
# It works only after showing the 3D scene
layoutManager = slicer.app.layoutManager()
threeDWidget = layoutManager.threeDWidget(0)
threeDView = threeDWidget.threeDView()
threeDView.resetFocalPoint()
def loademup(self):
self.dirty=True
import EditorLib
editUtil = EditorLib.EditUtil.EditUtil()
imsainode = editUtil.getBackgroundVolume()
imsai = imsainode.GetImageData()
if imsai.GetNumberOfScalarComponents() > 3:
lala = self.Four2ThreeChannel(imsai)
print lala.GetNumberOfScalarComponents()
imsainode.SetAndObserveImageData(lala)
imsainode.Modified()
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)
# Create 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()
red_cn.SetForegroundVolumeID(fgrdVolID)
red_cn.SetBackgroundVolumeID(bgrdVolID)
red_cn.SetForegroundOpacity(1)
self.checkAndSetLUT()
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 setUp(self):
slicer.mrmlScene.AddNode(slicer.vtkMRMLScalarVolumeNode()).SetName("Volume1")
slicer.mrmlScene.AddNode(slicer.vtkMRMLScalarVolumeNode()).SetName("Volume2")
def createScalarVolumeNode(name): volume = slicer.vtkMRMLScalarVolumeNode() volume.SetName(name) slicer.mrmlScene.AddNode(volume) return volume
def load(self,loadable):
"""Load the selection as a MultiVolume, if multivolume attribute is
present
"""
mvNode = ''
try:
mvNode = loadable.multivolume
except AttributeError:
return None
nFrames = int(mvNode.GetAttribute('MultiVolume.NumberOfFrames'))
files = string.split(mvNode.GetAttribute('MultiVolume.FrameFileList'),',')
nFiles = len(files)
filesPerFrame = nFiles/nFrames
frames = []
mvImage = vtk.vtkImageData()
mvImageArray = None
scalarVolumePlugin = slicer.modules.dicomPlugins['DICOMScalarVolumePlugin']()
instanceUIDs = ""
for file in files:
uid = slicer.dicomDatabase.fileValue(file,self.tags['instanceUID'])
if uid == "":
uid = "Unknown"
instanceUIDs += uid+" "
instanceUIDs = instanceUIDs[:-1]
mvNode.SetAttribute("DICOM.instanceUIDs", instanceUIDs)
# read each frame into scalar volume
for frameNumber in range(nFrames):
sNode = slicer.vtkMRMLVolumeArchetypeStorageNode()
sNode.ResetFileNameList();
frameFileList = files[frameNumber*filesPerFrame:(frameNumber+1)*filesPerFrame]
# sv plugin will sort the filenames by geometric order
svLoadables = scalarVolumePlugin.examine([frameFileList])
if len(svLoadables) == 0:
return None
for f in svLoadables[0].files:
sNode.AddFileName(f)
sNode.SetFileName(frameFileList[0]) # only used when num files/frame = 1
sNode.SetSingleFile(0)
frame = slicer.vtkMRMLScalarVolumeNode()
sNode.ReadData(frame)
if frame.GetImageData() == None:
logging.error('Failed to read a multivolume frame!')
return None
if frameNumber == 0:
frameImage = frame.GetImageData()
frameExtent = frameImage.GetExtent()
frameSize = frameExtent[1]*frameExtent[3]*frameExtent[5]
mvImage.SetExtent(frameExtent)
if vtk.VTK_MAJOR_VERSION <= 5:
mvImage.SetNumberOfScalarComponents(nFrames)
mvImage.SetScalarType(frame.GetImageData().GetScalarType())
mvImage.AllocateScalars()
else:
mvImage.AllocateScalars(frame.GetImageData().GetScalarType(), nFrames)
mvImageArray = vtk.util.numpy_support.vtk_to_numpy(mvImage.GetPointData().GetScalars())
mvNode.SetScene(slicer.mrmlScene)
mat = vtk.vtkMatrix4x4()
frame.GetRASToIJKMatrix(mat)
mvNode.SetRASToIJKMatrix(mat)
frame.GetIJKToRASMatrix(mat)
mvNode.SetIJKToRASMatrix(mat)
frameImage = frame.GetImageData()
frameImageArray = vtk.util.numpy_support.vtk_to_numpy(frameImage.GetPointData().GetScalars())
mvImageArray.T[frameNumber] = frameImageArray
mvDisplayNode = slicer.mrmlScene.CreateNodeByClass('vtkMRMLMultiVolumeDisplayNode')
mvDisplayNode.SetReferenceCount(mvDisplayNode.GetReferenceCount()-1)
mvDisplayNode.SetScene(slicer.mrmlScene)
mvDisplayNode.SetDefaultColorMap()
slicer.mrmlScene.AddNode(mvDisplayNode)
mvNode.SetAndObserveDisplayNodeID(mvDisplayNode.GetID())
mvNode.SetAndObserveImageData(mvImage)
mvNode.SetNumberOfFrames(nFrames)
mvNode.SetName(loadable.name)
slicer.mrmlScene.AddNode(mvNode)
#
# automatically select the volume to display
#
appLogic = slicer.app.applicationLogic()
selNode = appLogic.GetSelectionNode()
selNode.SetReferenceActiveVolumeID(mvNode.GetID())
appLogic.PropagateVolumeSelection()
# file list is no longer needed - remove the attribute
mvNode.RemoveAttribute('MultiVolume.FrameFileList')
return mvNode
def TestSection_1_RunPlastimatchProtonDoseEngine(self):
logging.info('Test section 1: Run Plastimatch proton dose engine')
engineLogic = slicer.qSlicerDoseEngineLogic()
engineLogic.setMRMLScene(slicer.mrmlScene)
# Get input
ctVolumeNode = slicer.util.getNode('TinyPatient_CT')
segmentationNode = slicer.util.getNode('TinyPatient_Structures')
self.assertIsNotNone(ctVolumeNode)
self.assertIsNotNone(segmentationNode)
# Create node for output dose
totalDoseVolumeNode = slicer.vtkMRMLScalarVolumeNode()
totalDoseVolumeNode.SetName('TotalDose')
slicer.mrmlScene.AddNode(totalDoseVolumeNode)
# Setup plan
planNode = slicer.vtkMRMLRTPlanNode()
planNode.SetName('TestProtonPlan')
slicer.mrmlScene.AddNode(planNode)
planNode.SetAndObserveReferenceVolumeNode(ctVolumeNode);
planNode.SetAndObserveSegmentationNode(segmentationNode);
planNode.SetAndObserveOutputTotalDoseVolumeNode(totalDoseVolumeNode);
planNode.SetTargetSegmentID("Tumor_Contour");
planNode.SetIsocenterToTargetCenter();
planNode.SetDoseEngineName("Plastimatch proton")
# Add first beam
firstBeamNode = engineLogic.createBeamInPlan(planNode)
firstBeamNode.SetX1Jaw(-50.0)
firstBeamNode.SetX2Jaw(50.0)
firstBeamNode.SetY1Jaw(-50.0)
firstBeamNode.SetY2Jaw(75.0)
#TODO: For some reason the instance() function cannot be called as a class function although it's static
engineHandler = slicer.qSlicerDoseEnginePluginHandler()
engineHandlerSingleton = engineHandler.instance()
plastimatchProtonEngine = engineHandlerSingleton.doseEngineByName('Plastimatch proton')
plastimatchProtonEngine.setParameter(firstBeamNode, 'EnergyResolution', 4.0)
plastimatchProtonEngine.setParameter(firstBeamNode, 'RangeCompensatorSmearingRadius', 0.0)
plastimatchProtonEngine.setParameter(firstBeamNode, 'ProximalMargin', 0.0)
plastimatchProtonEngine.setParameter(firstBeamNode, 'DistalMargin', 0.0)
# Calculate dose
import time
startTime = time.time()
errorMessage = engineLogic.calculateDose(planNode)
self.assertNotEqual(errorMessage, "")
calculationTime = time.time() - startTime
logging.info('Dose computation time: ' + str(calculationTime) + ' s')
# Check computed output
imageAccumulate = vtk.vtkImageAccumulate()
imageAccumulate.SetInputConnection(totalDoseVolumeNode.GetImageDataConnection())
imageAccumulate.Update()
doseMax = imageAccumulate.GetMax()[0]
doseMean = imageAccumulate.GetMean()[0]
doseStdDev = imageAccumulate.GetStandardDeviation()[0]
doseVoxelCount = imageAccumulate.GetVoxelCount()
logging.info("Dose volume properties:\n Max=" + str(doseMax) + ", Mean=" + str(doseMean) + ", StdDev=" + str(doseStdDev) + ", NumberOfVoxels=" + str(doseVoxelCount))
self.assertTrue(self.isEqualWithTolerance(doseMax, 1.05797))
self.assertTrue(self.isEqualWithTolerance(doseMean, 0.0251127))
self.assertTrue(self.isEqualWithTolerance(doseStdDev, 0.144932))
self.assertTrue(self.isEqualWithTolerance(doseVoxelCount, 1000))
