def onCreateModelButtonClicked(self):
paramEndo = {}
paramWall = {}
wallLabelImage = self.wallLabelSelector.currentNode()
endoLabelImage = self.endoLabelSelector.currentNode()
if not (endoLabelImage):
qt.QMessageBox.critical(slicer.util.mainWindow(),
'Scar Visualization', 'Endo label image is required to generate a model.')
else:
paramEndo['InputVolume'] = endoLabelImage.GetID()
# Make a new model hierarchy node if needed
numNodes = slicer.mrmlScene.GetNumberOfNodesByClass( "vtkMRMLModelHierarchyNode" )
global endoHierarchy
endoHierarchy = None
for n in xrange(numNodes):
node = slicer.mrmlScene.GetNthNodeByClass( n, "vtkMRMLModelHierarchyNode" )
if node.GetName() == "Endo Model":
endoHierarchy = node
break
endoHierarchy = slicer.vtkMRMLModelHierarchyNode()
# endoHierarchy = slicer.vtkMRMLModelNode()
endoHierarchy.SetScene( slicer.mrmlScene )
endoHierarchy.SetName( "Endo Model" )
slicer.mrmlScene.AddNode( endoHierarchy )
paramEndo['ModelSceneFile'] = endoHierarchy
paramEndo['Name'] = "Endo"
# Pass parameters to Model Maker Module
slicer.cli.run( slicer.modules.modelmaker, None, paramEndo, wait_for_completion=True )
if not (wallLabelImage):
qt.QMessageBox.critical(slicer.util.mainWindow(),
'Scar Visualization', 'Wall label image is required to generate a model.')
else:
paramWall['InputVolume'] = wallLabelImage.GetID()
# Make a new model hierarchy node if needed
numNodes = slicer.mrmlScene.GetNumberOfNodesByClass( "vtkMRMLModelHierarchyNode" )
global wallHierarchy
wallHierarchy = None
for n in xrange(numNodes):
node = slicer.mrmlScene.GetNthNodeByClass( n, "vtkMRMLModelHierarchyNode" )
if node.GetName() == "Wall Model":
wallHierarchy = node
break
wallHierarchy = slicer.vtkMRMLModelHierarchyNode()
# wallHierarchy = slicer.vtkMRMLModelNode()
wallHierarchy.SetScene( slicer.mrmlScene )
wallHierarchy.SetName( "Wall Model" )
wallHierarchy.SetModelNodeID("Wall Model")
slicer.mrmlScene.AddNode( wallHierarchy )
paramWall['ModelSceneFile'] = wallHierarchy
paramWall['Name'] = "Wall"
# Pass parameters to Model Maker Module
slicer.cli.run( slicer.modules.modelmaker, None, paramWall, wait_for_completion=True )
def startModelMaker(self):
# Load endo segmentation volume from previous step
antrumCutVolumeID = pNode.GetParameter('antrumCutVolumeID')
antrumCutVolume = Helper.getNodeByID(antrumCutVolumeID)
# Initialize the parameters to run the Model Maker Module
if antrumCutVolume != None :
param = {}
param['InputVolume'] = antrumCutVolume.GetID()
# Make a new model hierarchy node if needed
numNodes = slicer.mrmlScene.GetNumberOfNodesByClass( "vtkMRMLModelHierarchyNode" )
global outHierarchy
outHierarchy = None
for n in xrange(numNodes):
node = slicer.mrmlScene.GetNthNodeByClass( n, "vtkMRMLModelHierarchyNode" )
if node.GetName() == "Endo Model":
outHierarchy = node
break
outHierarchy = slicer.vtkMRMLModelHierarchyNode()
outHierarchy.SetScene( slicer.mrmlScene )
outHierarchy.SetName( "Endo Model" )
slicer.mrmlScene.AddNode( outHierarchy )
param['ModelSceneFile'] = outHierarchy
slicer.cli.run( slicer.modules.modelmaker, None, param, wait_for_completion=True )
else:
qt.QMessageBox.critical(slicer.util.mainWindow(),
'Endo No Veins Isosurface', 'Endocardium segmentation image is required to run Model Maker.')
def onCut(self):
inputVolume = self.inputSelector.currentNode()
outputVolume = self.outputSelector.currentNode()
growCutAlgo.onApply() #apply growCut Algo
print("Iteration Complete! That was iteration number: %i" %
self.modelMethodCounter)
#define ROI vairables for cutting
scene = slicer.mrmlScene
self.modelMethodCounter += 1
self.modelIDString = "MRBrainTumor" + str(
self.modelMethodCounter) + "-label_grow"
#define nodes
hie_node = slicer.vtkMRMLModelHierarchyNode()
roi_node = slicer.util.getNode(self.modelIDString)
#generate model
scene.AddNode(hie_node)
params = {}
params['InputVolume'] = roi_node.GetID()
params['ModelSceneFile'] = hie_node.GetID()
slicer.cli.run(slicer.modules.modelmaker, None, params)
mod_node = hie_node.GetModelNode()
return
def startModelMaker(self):
if scarOutputVolume != None:
# Initialize the input parameters to run the Model Maker Module
param = {}
param['InputVolume'] = scarOutputVolume.GetID()
# Make a new model hierarchy node if needed
numNodes = slicer.mrmlScene.GetNumberOfNodesByClass( "vtkMRMLModelHierarchyNode" )
outHierarchy = None
for n in xrange(numNodes):
node = slicer.mrmlScene.GetNthNodeByClass( n, "vtkMRMLModelHierarchyNode" )
if node.GetName() == "Scar Model":
outHierarchy = node
break
outHierarchy = slicer.vtkMRMLModelHierarchyNode()
outHierarchy.SetScene( slicer.mrmlScene )
outHierarchy.SetName( "Scar Model" )
slicer.mrmlScene.AddNode( outHierarchy )
param['ModelSceneFile'] = outHierarchy
slicer.cli.run( slicer.modules.modelmaker, None, param, wait_for_completion=True )
else:
qt.QMessageBox.critical(slicer.util.mainWindow(),
'Model Maker',
'Please run Automatic Left Atrial Scar Module before generating the isosurface.')
def makeModel(self,labelNode,modelName,modelIndex,hierarchyName="Models"):
"""create a model using the command line module
based on the current editor parameters
- make a new hierarchy node
"""
self.delayDisplay("Starting model making",200)
parameters = {}
parameters["InputVolume"] = labelNode.GetID()
# create models for all labels
parameters["Name"] = modelName
parameters["Labels"] = modelIndex
parameters["GenerateAll"] = False
outHierarchy = slicer.vtkMRMLModelHierarchyNode()
outHierarchy.SetScene( slicer.mrmlScene )
outHierarchy.SetName( hierarchyName )
slicer.mrmlScene.AddNode( outHierarchy )
parameters["ModelSceneFile"] = outHierarchy
modelMaker = slicer.modules.modelmaker
self.CLINode = None
self.CLINode = slicer.cli.run(modelMaker, self.CLINode, parameters, delete_temporary_files=False)
waitCount = 0
while self.CLINode.GetStatusString() != 'Completed' and waitCount < 100:
self.delayDisplay("Model making in progress (%d)" % waitCount)
waitCount += 1
self.delayDisplay("Done",200)
def makeModel(self,
labelNode,
modelName,
modelIndex,
hierarchyName="Models"):
"""create a model using the command line module
based on the current editor parameters
- make a new hierarchy node
"""
self.delayDisplay("Starting model making", 200)
parameters = {}
parameters["InputVolume"] = labelNode.GetID()
# create models for all labels
parameters["Name"] = modelName
parameters["Labels"] = modelIndex
parameters["GenerateAll"] = False
outHierarchy = slicer.vtkMRMLModelHierarchyNode()
outHierarchy.SetScene(slicer.mrmlScene)
outHierarchy.SetName(hierarchyName)
slicer.mrmlScene.AddNode(outHierarchy)
parameters["ModelSceneFile"] = outHierarchy
modelMaker = slicer.modules.modelmaker
self.CLINode = None
self.CLINode = slicer.cli.run(modelMaker,
self.CLINode,
parameters,
delete_temporary_files=False)
waitCount = 0
while self.CLINode.GetStatusString(
) != 'Completed' and waitCount < 100:
self.delayDisplay("Model making in progress (%d)" % waitCount)
waitCount += 1
self.delayDisplay("Done", 200)
def MRModelMaker(self, inputMRlabel, smoothingValue):
""" Converts MRI tumor labelmap segemntation into slicer VTK model node
"""
# Print to Slicer CLI
print('Creating MRI Model...'),
start_time = time.time()
# Change input label value
self.ThresholdScalarVolume(inputMRlabel, 34)
# Set model parameters
parameters = {}
parameters["InputVolume"] = inputMRlabel.GetID()
parameters['FilterType'] = "Laplacian"
parameters['GenerateAll'] = True
parameters["JointSmoothing"] = True
parameters["SplitNormals"] = False
parameters["PointNormals"] = False
parameters["SkipUnNamed"] = False
parameters["StartLabel"] = -1
parameters["EndLabel"] = -1
parameters["Decimate"] = 0.1
parameters["Smooth"] = int(smoothingValue) # make sure it is an integer
parameters["Pad"] = True
parameters["Name"] = 'model'
# # Need to create new model heirarchy node for models to enter the scene
# numNodes = slicer.mrmlScene.GetNumberOfNodesByClass( "vtkMRMLModelHierarchyNode" )
# if numNodes > 0:
# # user wants to delete any existing models, so take down hierarchy and
# # delete the model nodes
# rr = range(numNodes)
# rr.reverse()
# for n in rr:
# node = slicer.mrmlScene.GetNthNodeByClass( n, "vtkMRMLModelHierarchyNode" )
# slicer.mrmlScene.RemoveNode( node.GetModelNode() )
# slicer.mrmlScene.RemoveNode( node )
# Create new output model heirarchy
outHierarchy = slicer.vtkMRMLModelHierarchyNode()
outHierarchy.SetScene( slicer.mrmlScene )
outHierarchy.SetName( ('MRI Models Smooth '+ str(smoothingValue)) )
slicer.mrmlScene.AddNode( outHierarchy )
# Set the parameter for the output model heirarchy
parameters["ModelSceneFile"] = outHierarchy
# Run the module from the command line
slicer.cli.run(slicer.modules.modelmaker, None, parameters, wait_for_completion=True)
# Define the output model as the created model in the scene
outputMRModel = slicer.util.getNode('model_34_34') # created model has label value of 34
# print to Slicer CLI
end_time = time.time()
print('done (%0.2f s)') % float(end_time-start_time)
return outputMRModel
def MRCapModelMaker(self, inputMRlabel):
""" Converts MRI labelmap segemntation into slicer VTK model node
"""
# Print to Slicer CLI
print('Creating MR Model...'),
start_time = time.time()
# Set model parameters
parameters = {}
parameters["InputVolume"] = inputMRlabel.GetID()
parameters['FilterType'] = "Laplacian"
parameters['GenerateAll'] = True
parameters["JointSmoothing"] = True
parameters["SplitNormals"] = False
parameters["PointNormals"] = False
parameters["SkipUnNamed"] = False
parameters["StartLabel"] = -1
parameters["EndLabel"] = -1
parameters["Decimate"] = 0.1
parameters["Smooth"] = 70
parameters["Name"] = 'mr-cap'
# Need to create new model heirarchy node for models to enter the scene
numNodes = slicer.mrmlScene.GetNumberOfNodesByClass( "vtkMRMLModelHierarchyNode" )
if numNodes > 0:
# user wants to delete any existing models, so take down hierarchy and
# delete the model nodes
rr = range(numNodes)
rr.reverse()
for n in rr:
node = slicer.mrmlScene.GetNthNodeByClass( n, "vtkMRMLModelHierarchyNode" )
slicer.mrmlScene.RemoveNode( node.GetModelNode() )
slicer.mrmlScene.RemoveNode( node )
# Create new output model heirarchy
outHierarchy = slicer.vtkMRMLModelHierarchyNode()
outHierarchy.SetScene( slicer.mrmlScene )
outHierarchy.SetName( "MRI Models" )
slicer.mrmlScene.AddNode( outHierarchy )
# Set the parameter for the output model heirarchy
parameters["ModelSceneFile"] = outHierarchy
# Run the module from the command line
slicer.cli.run(slicer.modules.modelmaker, None, parameters, wait_for_completion=True)
# Define the output model as the created model in the scene
outputMRModel = slicer.util.getNode('mr-cap_1_1') # cap label has label value of 1 so model created is Model_1_1
# print to Slicer CLI
end_time = time.time()
print('done (%0.2f s)') % float(end_time-start_time)
return outputMRModel
def makeModels(study, finding, colorTable):
if (study == None) | (finding == None) | (colorTable == None):
return
seg = finding.GetSegmentationMappedByStudyNodeID(study.GetID())
if seg:
labelVolume = seg.GetLabelVolumeNode()
#create a temporary model hierarchy for generating models
tempMH = slicer.vtkMRMLModelHierarchyNode()
slicer.mrmlScene.AddNode(tempMH)
if (labelVolume != None) & (tempMH != None):
parameters = {}
parameters['InputVolume'] = labelVolume.GetID()
parameters['ColorTable'] = colorTable.GetID()
parameters['ModelSceneFile'] = tempMH.GetID()
parameters['GenerateAll'] = False
parameters['StartLabel'] = finding.GetColorID()
parameters['EndLabel'] = finding.GetColorID()
parameters['Name'] = labelVolume.GetName() + "_" + finding.GetName()+"_M"
cliModelMaker = None
cliModelMaker = slicer.cli.run(slicer.modules.modelmaker, cliModelMaker, parameters, wait_for_completion = True)
genModelNodes = vtk.vtkCollection()
tempMH.GetChildrenModelNodes(genModelNodes)
if genModelNodes.GetNumberOfItems() > 0:
modelNode = genModelNodes.GetItemAsObject(0)
if modelNode:
if modelNode.IsA('vtkMRMLModelNode'):
hnode = slicer.vtkMRMLHierarchyNode.GetAssociatedHierarchyNode(modelNode.GetScene(), modelNode.GetID())
if hnode:
if seg.GetModelHierarchyNode():
SlicerLongitudinalPETCTModuleViewHelper.removeModelHierarchyAndChildModelNodesFromScene(seg.GetModelHierarchyNode())
hnode.SetName(seg.GetName()+"_Model")
seg.SetAndObserveModelHierarchyNodeID(hnode.GetID())
modelNode.SetName(labelVolume.GetName() + "_" + finding.GetName()+"_M")
if modelNode.GetDisplayNode():
modelNode.GetDisplayNode().SetName(labelVolume.GetName() + "_" + finding.GetName()+"_D")
modelNode.GetDisplayNode().AddViewNodeID(SlicerLongitudinalPETCTModuleViewHelper.getStandardViewNode().GetID())
hnode.SetName(labelVolume.GetName() + "_" + finding.GetName()+"_H")
modelNode.SetHideFromEditors(False)
else:
seg.SetAndObserveModelHierarchyNodeID("")
slicer.mrmlScene.RemoveNode(modelNode)
slicer.mrmlScene.RemoveNode(hnode)
slicer.mrmlScene.RemoveNode(tempMH.GetDisplayNode())
slicer.mrmlScene.RemoveNode(tempMH)
def makeModel(self, outputVolumeNodeName, outputVolumeNode):
""" Makes a model using the CLI 3D slicer model maker module
:param str outputVolumeNodeName: Name of the label map to be made into a model
:param obj outputVolumeNode: Node of the label map to made into a model
:return:
"""
print "make a model"
slicer.modules.WaspWidget.updateStatusLabel("Make model")
# Setup
parameters = {}
parameters['Name'] = outputVolumeNodeName
parameters["InputVolume"] = outputVolumeNode.GetID()
parameters['FilterType'] = "Sinc"
parameters['GenerateAll'] = True
parameters["JointSmoothing"] = False
parameters["SplitNormals"] = True
parameters["PointNormals"] = True
parameters["SkipUnNamed"] = True
parameters["Decimate"] = 0.25
parameters["Smooth"] = 65
# "add to scene" parameter
self.outHierarchy = slicer.vtkMRMLModelHierarchyNode()
self.outHierarchy.SetScene(slicer.mrmlScene)
self.outHierarchy.SetName("WS Models")
slicer.mrmlScene.AddNode(self.outHierarchy)
parameters["ModelSceneFile"] = self.outHierarchy
# Get an instance of the class
modelMaker = slicer.modules.modelmaker
#
# run the task (in the background)
# - use the GUI to provide progress feedback
# - use the GUI's Logic to invoke the task
# - model will show up when the processing is finished
#
slicer.modules.WaspWidget.updateStatusLabel("Making model")
self.CLINode = slicer.cli.run(modelMaker, None, parameters)
self.CLINode.AddObserver('ModifiedEvent', self.statusModel)
print "done"
return True
def startModelMaker(self):
# Load endo segmentation volume from previous step
antrumCutVolumeID = pNode.GetParameter('antrumCutVolumeID')
antrumCutVolume = Helper.getNodeByID(antrumCutVolumeID)
# Initialize the parameters to run the Model Maker Module
if antrumCutVolume != None:
param = {}
param['InputVolume'] = antrumCutVolume.GetID()
# Make a new model hierarchy node if needed
numNodes = slicer.mrmlScene.GetNumberOfNodesByClass(
"vtkMRMLModelHierarchyNode")
global outHierarchy
outHierarchy = None
for n in xrange(numNodes):
node = slicer.mrmlScene.GetNthNodeByClass(
n, "vtkMRMLModelHierarchyNode")
if node.GetName() == "Endo Model":
outHierarchy = node
break
outHierarchy = slicer.vtkMRMLModelHierarchyNode()
outHierarchy.SetScene(slicer.mrmlScene)
outHierarchy.SetName("Endo Model")
slicer.mrmlScene.AddNode(outHierarchy)
param['ModelSceneFile'] = outHierarchy
slicer.cli.run(slicer.modules.modelmaker,
None,
param,
wait_for_completion=True)
else:
qt.QMessageBox.critical(
slicer.util.mainWindow(), 'Endo No Veins Isosurface',
'Endocardium segmentation image is required to run Model Maker.'
)
def onCreateModelButtonClicked(self):
paramEndo = {}
paramWall = {}
wallLabelImage = self.wallLabelSelector.currentNode()
endoLabelImage = self.endoLabelSelector.currentNode()
if not (endoLabelImage):
qt.QMessageBox.critical(
slicer.util.mainWindow(), 'Scar Visualization',
'Endo label image is required to generate a model.')
else:
paramEndo['InputVolume'] = endoLabelImage.GetID()
# Make a new model hierarchy node if needed
numNodes = slicer.mrmlScene.GetNumberOfNodesByClass(
"vtkMRMLModelHierarchyNode")
global endoHierarchy
endoHierarchy = None
for n in xrange(numNodes):
node = slicer.mrmlScene.GetNthNodeByClass(
n, "vtkMRMLModelHierarchyNode")
if node.GetName() == "Endo Model":
endoHierarchy = node
break
endoHierarchy = slicer.vtkMRMLModelHierarchyNode()
# endoHierarchy = slicer.vtkMRMLModelNode()
endoHierarchy.SetScene(slicer.mrmlScene)
endoHierarchy.SetName("Endo Model")
slicer.mrmlScene.AddNode(endoHierarchy)
paramEndo['ModelSceneFile'] = endoHierarchy
paramEndo['Name'] = "Endo"
# Pass parameters to Model Maker Module
slicer.cli.run(slicer.modules.modelmaker,
None,
paramEndo,
wait_for_completion=True)
if not (wallLabelImage):
qt.QMessageBox.critical(
slicer.util.mainWindow(), 'Scar Visualization',
'Wall label image is required to generate a model.')
else:
paramWall['InputVolume'] = wallLabelImage.GetID()
# Make a new model hierarchy node if needed
numNodes = slicer.mrmlScene.GetNumberOfNodesByClass(
"vtkMRMLModelHierarchyNode")
global wallHierarchy
wallHierarchy = None
for n in xrange(numNodes):
node = slicer.mrmlScene.GetNthNodeByClass(
n, "vtkMRMLModelHierarchyNode")
if node.GetName() == "Wall Model":
wallHierarchy = node
break
wallHierarchy = slicer.vtkMRMLModelHierarchyNode()
# wallHierarchy = slicer.vtkMRMLModelNode()
wallHierarchy.SetScene(slicer.mrmlScene)
wallHierarchy.SetName("Wall Model")
wallHierarchy.SetModelNodeID("Wall Model")
slicer.mrmlScene.AddNode(wallHierarchy)
paramWall['ModelSceneFile'] = wallHierarchy
paramWall['Name'] = "Wall"
# Pass parameters to Model Maker Module
slicer.cli.run(slicer.modules.modelmaker,
None,
paramWall,
wait_for_completion=True)
def makeModel(self, modelName='EditorModel', smooth=True):
#
# create a model using the command line module
# based on the current editor parameters
#
volumeNode = self.editUtil.getLabelVolume()
if not volumeNode:
return
#
# set up the model maker node
#
parameters = {}
parameters['Name'] = modelName
parameters["InputVolume"] = volumeNode.GetID()
parameters['FilterType'] = "Sinc"
# build only the currently selected model.
parameters['Labels'] = self.editUtil.getLabel()
parameters["StartLabel"] = -1
parameters["EndLabel"] = -1
parameters['GenerateAll'] = False
parameters["JointSmoothing"] = False
parameters["SplitNormals"] = True
parameters["PointNormals"] = True
parameters["SkipUnNamed"] = True
if smooth:
parameters["Decimate"] = 0.25
parameters["Smooth"] = 10
else:
parameters["Decimate"] = 0
parameters["Smooth"] = 0
#
# output
# - make a new hierarchy node if needed
#
numNodes = slicer.mrmlScene.GetNumberOfNodesByClass(
"vtkMRMLModelHierarchyNode")
outHierarchy = None
for n in xrange(numNodes):
node = slicer.mrmlScene.GetNthNodeByClass(
n, "vtkMRMLModelHierarchyNode")
if node.GetName() == "Editor Models":
outHierarchy = node
break
if not outHierarchy:
outHierarchy = slicer.vtkMRMLModelHierarchyNode()
outHierarchy.SetScene(slicer.mrmlScene)
outHierarchy.SetName("Editor Models")
slicer.mrmlScene.AddNode(outHierarchy)
parameters["ModelSceneFile"] = outHierarchy
modelMaker = slicer.modules.modelmaker
#
# run the task (in the background)
# - use the GUI to provide progress feedback
# - use the GUI's Logic to invoke the task
# - model will show up when the processing is finished
#
slicer.cli.run(modelMaker, None, parameters)
slicer.util.showStatusMessage("Model Making Started...", 2000)
def onStartSegmentationButton(self):
inputVolume = self.inputSelector.currentNode()
inputName = inputVolume.GetName()
inputNode = slicer.util.getNode(inputName)
instUIDs = inputNode.GetAttribute('DICOM.instanceUIDs').split()
fileName = slicer.dicomDatabase.fileForInstance(instUIDs[0])
patientAge = slicer.dicomDatabase.fileValue(fileName,'0010,1010')
patientAge=patientAge[1:3]
age_str = str(patientAge)
self.age.setText(age_str)
# Analyze histogram of the image to work out the second peak intensity value
start = timeit.default_timer()
self.LungNoduleSegmentationButton.enabled = False
seedPoint = self.fiducialListSelector.currentNode()
inputNodeArray = slicer.util.array(inputVolume.GetID())
maskedImage = inputNodeArray[inputNodeArray >= -1024]
edges=[]
I_max = maskedImage.max()
I_min = maskedImage.min()
for val in range(I_min,I_max+2):
edges.append(val)
I_max =float(I_max)
I_min =float(I_min)
maskedImage = maskedImage.astype(float)
histogram,bins = numpy.histogram(maskedImage,bins=edges)
mx, mn = self.peakdetect(histogram)
threshold = (-1024+bins[mx[0][0]]) / 2
if threshold < -800:
maskedImage = inputNodeArray[inputNodeArray >= -1000]
edges=[]
I_max = maskedImage.max()
I_min = maskedImage.min()
for val in range(I_min,I_max+2):
edges.append(val)
I_max =float(I_max)
I_min =float(I_min)
maskedImage = maskedImage.astype(float)
histogram,bins = numpy.histogram(maskedImage,bins=edges)
mx, mn = self.peakdetect(histogram)
threshold = (-1024+bins[mx[0][0]]) / 2
print threshold
stop = timeit.default_timer()
print "Histogram anaylis: ", stop - start, "sec"
# Segment the lung surface
start = timeit.default_timer()
nodeType = 'vtkMRMLScalarVolumeNode'
self.lungLabelNode = slicer.mrmlScene.CreateNodeByClass(nodeType)
self.lungLabelNode.SetLabelMap(1)
self.lungLabelNode.SetScene(slicer.mrmlScene)
self.lungLabelNode.SetName(slicer.mrmlScene.GetUniqueNameByString('LungLabel'))
slicer.mrmlScene.AddNode(self.lungLabelNode)
LungSegmentationModule = slicer.modules.lungsegmentationcli
lungLabelColor = 1
parameters = {
"InputVolume": inputVolume,
"OutputVolume": self.lungLabelNode,
"Lower": -1024,
"Upper": threshold,
"lungColor": lungLabelColor,
}
slicer.cli.run( LungSegmentationModule, None, parameters, wait_for_completion = True )
stop = timeit.default_timer()
print "Lung segmentation: ", stop - start, "sec"
# Segment the selected nodule
start = timeit.default_timer()
nodeType = 'vtkMRMLScalarVolumeNode'
self.noduleLabelNode = slicer.mrmlScene.CreateNodeByClass(nodeType)
self.noduleLabelNode.SetLabelMap(1)
self.noduleLabelNode.SetScene(slicer.mrmlScene)
self.noduleLabelNode.SetName(slicer.mrmlScene.GetUniqueNameByString('NoduleLabel'))
slicer.mrmlScene.AddNode(self.noduleLabelNode)
LungNoduleSegmentationModule = slicer.modules.lungnodulesegmentationcli
labelColor = 6
parameters = {
"InputVolume": inputVolume,
"InputLungLabel": self.lungLabelNode,
"OutputVolume": self.noduleLabelNode,
"seed": seedPoint,
"noduleColor": labelColor,
}
NoduleSegmentationNode = slicer.cli.run( LungNoduleSegmentationModule, None, parameters, wait_for_completion = True )
stop = timeit.default_timer()
print "Nodule segmentation: ", stop - start, "sec"
self.FissuresNode = slicer.mrmlScene.CreateNodeByClass(nodeType)
self.FissuresNode.SetLabelMap(1)
self.FissuresNode.SetScene(slicer.mrmlScene)
self.FissuresNode.SetName(slicer.mrmlScene.GetUniqueNameByString('FissuresVolume'))
slicer.mrmlScene.AddNode(self.FissuresNode)
FissuresSegmentationModule = slicer.modules.lungfissuresegmentationcli
params = {
"InputVolume": inputVolume,
"InputLungLabel": self.lungLabelNode,
"OutputVolume": self.FissuresNode,
}
slicer.cli.run( FissuresSegmentationModule, None, params, wait_for_completion = True )
self.LobesNode = slicer.mrmlScene.CreateNodeByClass(nodeType)
self.LobesNode.SetLabelMap(1)
self.LobesNode.SetScene(slicer.mrmlScene)
self.LobesNode.SetName(slicer.mrmlScene.GetUniqueNameByString('LobesVolume'))
slicer.mrmlScene.AddNode(self.LobesNode)
LobesSegmentationModule = slicer.modules.lunglobesegmentationcli
params = {
"InputVolume": inputVolume,
"LabelMapVolume": self.lungLabelNode,
"FissuresVolume": self.FissuresNode,
"OutputVolume": self.LobesNode
}
slicer.cli.run( LobesSegmentationModule, None, params, wait_for_completion = True )
# Create 3D model of the segment nodule
start = timeit.default_timer()
modelHierarchyCollection = slicer.mrmlScene.GetNodesByName('NoduleModelHierarchy')
if( modelHierarchyCollection.GetNumberOfItems() >= 1 ):
modelHierarchy = modelHierarchyCollection.GetItemAsObject(0)
else:
modelHierarchy = slicer.vtkMRMLModelHierarchyNode()
modelHierarchy.SetName(slicer.mrmlScene.GetUniqueNameByString('NoduleModelHierarchy'))
slicer.mrmlScene.AddNode(modelHierarchy)
parameters = {}
parameters["InputVolume"] = self.noduleLabelNode.GetID()
parameters["ModelSceneFile"] = modelHierarchy.GetID()
parameters["Name"] = 'NoduleModel'
parameters["Smooth"] = 20
parameters["Decimate"] = 0.10
modelMaker = slicer.modules.modelmaker
slicer.cli.run( modelMaker, None, parameters, wait_for_completion = True )
lm = slicer.app.layoutManager()
threeDView = lm.threeDWidget( 0 ).threeDView()
threeDView.resetFocalPoint()
threeDView.lookFromViewAxis(ctk.ctkAxesWidget().Anterior)
stop = timeit.default_timer()
print "Model maker: ", stop - start, "sec"
# Evaluate malignancy of the nodule
nodulePosition = NoduleSegmentationNode.GetParameterDefault(2,0)
noduleSize = NoduleSegmentationNode.GetParameterDefault(2,1)
noduleRoundness = NoduleSegmentationNode.GetParameterDefault(2,2)
noduleCavityWallThickness = NoduleSegmentationNode.GetParameterDefault(2,3)
noduleCalcificationPattern = NoduleSegmentationNode.GetParameterDefault(2,4)
size_str = str(noduleSize) + ' mm'
self.size.setText(size_str)
smoothness_str = 'Smooth'
noduleRoundness = float(noduleRoundness)
if noduleRoundness < 0.7:
smoothness_str = 'Spiculated'
self.spiculation.setText(smoothness_str)
thickness_str = 'Not Cavitated'
noduleCavityWallThickness = float(noduleCavityWallThickness)
if (noduleCavityWallThickness >= 0.1 and noduleCavityWallThickness < 100.0):
print noduleCavityWallThickness
thickness_str = str(noduleCavityWallThickness) + ' mm'
self.thickness.setText(thickness_str)
lobesImageData = self.LobesNode.GetImageData()
nodulePosition = eval(nodulePosition)
lobeValue = lobesImageData.GetScalarComponentAsDouble(int(nodulePosition[0]),int(nodulePosition[1]),int(nodulePosition[2]), 0)
position_str = 'Right Upper Lobe'
if lobeValue == 5:
position_str = 'Right Middle Lobe'
elif lobeValue == 6:
position_str = 'Right Lower Lobe'
elif lobeValue == 7:
position_str = 'Left Upper Lobe'
elif lobeValue == 8:
position_str = 'Left Lower Lobe'
self.location.setText(position_str)
calc_str = 'Benign Pattern'
if noduleCalcificationPattern == 'false':
calc_str = 'No Calcification'
self.calcification.setText(calc_str)
self.LungNoduleSegmentationButton.enabled = True
self.calculateProbability()
self.RecomputeButton.enabled = True
def test_sceneImport24281(self):
""" Ideally you should have several levels of tests. At the lowest level
tests sould 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()
self.delayDisplay("Getting Data")
head = sampleDataLogic.downloadMRHead()
#
# create a label map and set it for editing
#
self.delayDisplay("Setting up LabelMap")
volumesLogic = slicer.modules.volumes.logic()
headLabel = volumesLogic.CreateAndAddLabelVolume(
slicer.mrmlScene, head,
head.GetName() + '-label')
selectionNode = slicer.app.applicationLogic().GetSelectionNode()
selectionNode.SetReferenceActiveVolumeID(head.GetID())
selectionNode.SetReferenceActiveLabelVolumeID(headLabel.GetID())
slicer.app.applicationLogic().PropagateVolumeSelection(0)
#
# got to the editor and do some drawing
#
import EditorLib
self.delayDisplay("Setting up Editor and drawing")
editUtil = EditorLib.EditUtil.EditUtil()
parameterNode = editUtil.getParameterNode()
lm = slicer.app.layoutManager()
paintEffectOptions = EditorLib.PaintEffectOptions()
paintEffectOptions.setMRMLDefaults()
paintEffectOptions.__del__()
self.delayDisplay('Paint radius is %s' %
parameterNode.GetParameter('PaintEffect,radius'))
sliceWidget = lm.sliceWidget('Red')
size = min(sliceWidget.width, sliceWidget.height)
step = size / 8
parameterNode.SetParameter('PaintEffect,radius', '20')
paintTool = EditorLib.PaintEffectTool(sliceWidget)
self.delayDisplay('Paint radius is %s, tool radius is %d' %
(parameterNode.GetParameter('PaintEffect,radius'),
paintTool.radius))
for label in xrange(1, 5):
editUtil.setLabel(label)
pos = step * label
paintTool.paintAddPoint(pos, pos)
paintTool.paintApply()
paintTool.cleanup()
paintTool = None
#
# now build:
# create a model using the command line module
# based on the current editor parameters
# - make a new hierarchy node
#
self.delayDisplay("Building...")
parameters = {}
parameters["InputVolume"] = headLabel.GetID()
# create models for all labels
parameters["JointSmoothing"] = True
parameters["StartLabel"] = -1
parameters["EndLabel"] = -1
outHierarchy = slicer.vtkMRMLModelHierarchyNode()
outHierarchy.SetScene(slicer.mrmlScene)
outHierarchy.SetName("sceneImport2428Hierachy")
slicer.mrmlScene.AddNode(outHierarchy)
parameters["ModelSceneFile"] = outHierarchy
modelMaker = slicer.modules.modelmaker
self.CLINode = None
self.CLINode = slicer.cli.run(modelMaker,
self.CLINode,
parameters,
delete_temporary_files=False)
waitCount = 0
while self.CLINode.GetStatusString(
) != 'Completed' and waitCount < 100:
self.delayDisplay("Making models... %d" % waitCount)
waitCount += 1
self.delayDisplay("Models built")
success = self.verifyModels()
success = success and (
slicer.mrmlScene.GetNumberOfNodesByClass("vtkMRMLModelNode") > 3)
self.delayDisplay("Test finished")
if success:
self.delayDisplay("Ahh... test passed.")
else:
self.delayDisplay("!$!$!#!@#!@!@$%! Test Failed!!")
self.assertTrue(success)
def build(self):
"""make models of current merge volume"""
#
# get the image data for the label layer
#
self.statusText("Building...")
merge = self.mergeVolume()
if not merge:
return
#
# create a model using the command line module
# based on the current editor parameters
#
parameters = {}
parameters["InputVolume"] = merge.GetID()
parameters['FilterType'] = "Sinc"
parameters['GenerateAll'] = True
# not needed: setting StartLabel and EndLabel instead
#parameters['Labels'] = self.getPaintLabel()
parameters["JointSmoothing"] = True
parameters["SplitNormals"] = True
parameters["PointNormals"] = True
parameters["SkipUnNamed"] = True
# create models for all labels
parameters["StartLabel"] = -1
parameters["EndLabel"] = -1
parameters["Decimate"] = 0.25
parameters["Smooth"] = 10
#
# output
# - make a new hierarchy node if needed
#
numNodes = slicer.mrmlScene.GetNumberOfNodesByClass(
"vtkMRMLModelHierarchyNode")
outHierarchy = None
for n in xrange(numNodes):
node = slicer.mrmlScene.GetNthNodeByClass(
n, "vtkMRMLModelHierarchyNode")
if node.GetName() == "Editor Models":
outHierarchy = node
break
if outHierarchy and self.replaceModels.checked and numNodes > 0:
# user wants to delete any existing models, so take down hierarchy and
# delete the model nodes
rr = range(numNodes)
rr.reverse()
for n in rr:
node = slicer.mrmlScene.GetNthNodeByClass(
n, "vtkMRMLModelHierarchyNode")
if node.GetParentNodeID() == outHierarchy.GetID():
slicer.mrmlScene.RemoveNode(node.GetModelNode())
slicer.mrmlScene.RemoveNode(node)
if not outHierarchy:
outHierarchy = slicer.vtkMRMLModelHierarchyNode()
outHierarchy.SetScene(slicer.mrmlScene)
outHierarchy.SetName("Editor Models")
slicer.mrmlScene.AddNode(outHierarchy)
parameters["ModelSceneFile"] = outHierarchy
try:
modelMaker = slicer.modules.modelmaker
#
# run the task (in the background)
# - use the GUI to provide progress feedback
# - use the GUI's Logic to invoke the task
# - model will show up when the processing is finished
#
self.CLINode = slicer.cli.run(modelMaker, self.CLINode, parameters)
self.statusText("Model Making Started...")
except AttributeError:
qt.QMessageBox.critical(
slicer.util.mainWindow(), 'Editor',
'The ModelMaker module is not available<p>Perhaps it was disabled in the application settings or did not load correctly.'
)
def makeModel(self,modelName='EditorModel',smooth=True):
#
# create a model using the command line module
# based on the current editor parameters
#
volumeNode = self.editUtil.getLabelVolume()
if not volumeNode:
return
#
# set up the model maker node
#
parameters = {}
parameters['Name'] = modelName
parameters["InputVolume"] = volumeNode.GetID()
parameters['FilterType'] = "Sinc"
# build only the currently selected model.
parameters['Labels'] = self.editUtil.getLabel()
parameters["StartLabel"] = -1
parameters["EndLabel"] = -1
parameters['GenerateAll'] = False
parameters["JointSmoothing"] = False
parameters["SplitNormals"] = True
parameters["PointNormals"] = True
parameters["SkipUnNamed"] = True
if smooth:
parameters["Decimate"] = 0.25
parameters["Smooth"] = 10
else:
parameters["Decimate"] = 0
parameters["Smooth"] = 0
#
# output
# - make a new hierarchy node if needed
#
numNodes = slicer.mrmlScene.GetNumberOfNodesByClass( "vtkMRMLModelHierarchyNode" )
outHierarchy = None
for n in xrange(numNodes):
node = slicer.mrmlScene.GetNthNodeByClass( n, "vtkMRMLModelHierarchyNode" )
if node.GetName() == "Editor Models":
outHierarchy = node
break
if not outHierarchy:
outHierarchy = slicer.vtkMRMLModelHierarchyNode()
outHierarchy.SetScene( slicer.mrmlScene )
outHierarchy.SetName( "Editor Models" )
slicer.mrmlScene.AddNode( outHierarchy )
parameters["ModelSceneFile"] = outHierarchy
modelMaker = slicer.modules.modelmaker
#
# run the task (in the background)
# - use the GUI to provide progress feedback
# - use the GUI's Logic to invoke the task
# - model will show up when the processing is finished
#
slicer.cli.run(modelMaker, None, parameters)
slicer.util.showStatusMessage( "Model Making Started...", 2000 )
def test_sceneImport24281(self):
""" Ideally you should have several levels of tests. At the lowest level
tests sould 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()
self.delayDisplay("Getting Data")
head = sampleDataLogic.downloadMRHead()
#
# create a label map and set it for editing
#
self.delayDisplay("Setting up LabelMap")
volumesLogic = slicer.modules.volumes.logic()
headLabel = volumesLogic.CreateAndAddLabelVolume( slicer.mrmlScene, head, head.GetName() + '-label' )
selectionNode = slicer.app.applicationLogic().GetSelectionNode()
selectionNode.SetReferenceActiveVolumeID( head.GetID() )
selectionNode.SetReferenceActiveLabelVolumeID( headLabel.GetID() )
slicer.app.applicationLogic().PropagateVolumeSelection(0)
#
# got to the editor and do some drawing
#
import EditorLib
self.delayDisplay("Setting up Editor and drawing")
editUtil = EditorLib.EditUtil.EditUtil()
parameterNode = editUtil.getParameterNode()
lm = slicer.app.layoutManager()
paintEffectOptions = EditorLib.PaintEffectOptions()
paintEffectOptions.setMRMLDefaults()
paintEffectOptions.__del__()
self.delayDisplay('Paint radius is %s' % parameterNode.GetParameter('PaintEffect,radius'))
sliceWidget = lm.sliceWidget('Red')
size = min(sliceWidget.width,sliceWidget.height)
step = size / 12
center = size / 2
parameterNode.SetParameter('PaintEffect,radius', '20')
paintTool = EditorLib.PaintEffectTool(sliceWidget)
self.delayDisplay('Paint radius is %s, tool radius is %d' % (parameterNode.GetParameter('PaintEffect,radius'),paintTool.radius))
for label in xrange(1,5):
editUtil.setLabel(label)
pos = center - 2*step + (step * label)
self.delayDisplay('Painting %d, at (%d,%d)' % (label,pos,pos),200)
paintTool.paintAddPoint(pos,pos)
paintTool.paintApply()
paintTool.cleanup()
paintTool = None
#
# now build:
# create a model using the command line module
# based on the current editor parameters
# - make a new hierarchy node
#
self.delayDisplay( "Building..." )
parameters = {}
parameters["InputVolume"] = headLabel.GetID()
# create models for all labels
parameters["JointSmoothing"] = True
parameters["StartLabel"] = -1
parameters["EndLabel"] = -1
outHierarchy = slicer.vtkMRMLModelHierarchyNode()
outHierarchy.SetScene( slicer.mrmlScene )
outHierarchy.SetName( "sceneImport2428Hierachy" )
slicer.mrmlScene.AddNode( outHierarchy )
parameters["ModelSceneFile"] = outHierarchy
modelMaker = slicer.modules.modelmaker
self.CLINode = None
self.CLINode = slicer.cli.run(modelMaker, self.CLINode, parameters, delete_temporary_files=False)
waitCount = 0
while self.CLINode.GetStatusString() != 'Completed' and waitCount < 100:
self.delayDisplay( "Making models... %d" % waitCount )
waitCount += 1
self.delayDisplay("Models built")
success = self.verifyModels()
success = success and (slicer.mrmlScene.GetNumberOfNodesByClass( "vtkMRMLModelNode" ) > 3)
self.delayDisplay("Test finished")
if success:
self.delayDisplay("Ahh... test passed.")
else:
self.delayDisplay("!$!$!#!@#!@!@$%! Test Failed!!")
self.assertTrue(success)
def applyModelMaker(self):
pNode = self.parameterNode()
range0 = self.__threshRange.minimumValue
range1 = self.__threshRange.maximumValue
self.__roiVolume = Helper.getNodeByID(pNode.GetParameter('croppedBaselineVolumeID'))
self.__roiSegmentationNode = Helper.getNodeByID(pNode.GetParameter('croppedBaselineVolumeSegmentationID'))
# update the label volume accordingly
thresh = vtk.vtkImageThreshold()
thresh.SetInput(self.__roiVolume.GetImageData())
thresh.ThresholdBetween(range0, range1)
thresh.SetInValue(10)
thresh.SetOutValue(0)
thresh.ReplaceOutOn()
thresh.ReplaceInOn()
thresh.Update()
# self.__modelNode = slicer.mrmlScene.CreateNodeByClass('vtkMRMLModelNode')
self.__roiSegmentationNode.SetAndObserveImageData(thresh.GetOutput())
Helper.SetBgFgVolumes(pNode.GetParameter('croppedBaselineVolumeID'),'')
self.__secondReg.setEnabled(1)
# set up the model maker node
parameters = {}
parameters['Name'] = self.__roiSegmentationNode.GetName()
parameters["InputVolume"] = self.__roiSegmentationNode.GetID()
parameters['FilterType'] = "Sinc"
# build only the currently selected model.
# parameters['Labels'] = self.getPaintLabel()
parameters["StartLabel"] = -1
parameters["EndLabel"] = -1
parameters['GenerateAll'] = True
parameters["JointSmoothing"] = False
parameters["SplitNormals"] = True
parameters["PointNormals"] = True
parameters["SkipUnNamed"] = True
parameters["Decimate"] = 0.25
parameters["Smooth"] = 10
# output
# - make a new hierarchy node if needed
#
numNodes = slicer.mrmlScene.GetNumberOfNodesByClass( "vtkMRMLModelHierarchyNode" )
self.segmentationModel = None
for n in xrange(numNodes):
node = slicer.mrmlScene.GetNthNodeByClass( n, "vtkMRMLModelHierarchyNode" )
if node.GetName() == "Segmentation Model":
self.segmentationModel = node
break
if not self.segmentationModel:
self.segmentationModel = slicer.vtkMRMLModelHierarchyNode()
self.segmentationModel.SetScene( slicer.mrmlScene )
self.segmentationModel.SetName( "Segmentation Model" )
slicer.mrmlScene.AddNode( self.segmentationModel )
parameters["ModelSceneFile"] = self.segmentationModel
modelMaker = slicer.modules.modelmaker
self.__cliNode = None
self.__cliNode = slicer.cli.run(modelMaker, self.__cliNode, parameters)
def build(self):
"""make models of current merge volume"""
#
# get the image data for the label layer
#
self.statusText( "Building..." )
merge = self.mergeVolume()
if not merge:
return
#
# create a model using the command line module
# based on the current editor parameters
#
parameters = {}
parameters["InputVolume"] = merge.GetID()
parameters['FilterType'] = "Sinc"
parameters['GenerateAll'] = True
# not needed: setting StartLabel and EndLabel instead
#parameters['Labels'] = self.getPaintLabel()
parameters["JointSmoothing"] = True
parameters["SplitNormals"] = True
parameters["PointNormals"] = True
parameters["SkipUnNamed"] = True
# create models for all labels
parameters["StartLabel"] = -1
parameters["EndLabel"] = -1
parameters["Decimate"] = 0.25
parameters["Smooth"] = 10
#
# output
# - make a new hierarchy node if needed
#
numNodes = slicer.mrmlScene.GetNumberOfNodesByClass( "vtkMRMLModelHierarchyNode" )
outHierarchy = None
for n in xrange(numNodes):
node = slicer.mrmlScene.GetNthNodeByClass( n, "vtkMRMLModelHierarchyNode" )
if node.GetName() == "Editor Models":
outHierarchy = node
break
if outHierarchy and self.replaceModels.checked and numNodes > 0:
# user wants to delete any existing models, so take down hierarchy and
# delete the model nodes
rr = range(numNodes)
rr.reverse()
for n in rr:
node = slicer.mrmlScene.GetNthNodeByClass( n, "vtkMRMLModelHierarchyNode" )
if node.GetParentNodeID() == outHierarchy.GetID():
slicer.mrmlScene.RemoveNode( node.GetModelNode() )
slicer.mrmlScene.RemoveNode( node )
if not outHierarchy:
outHierarchy = slicer.vtkMRMLModelHierarchyNode()
outHierarchy.SetScene( slicer.mrmlScene )
outHierarchy.SetName( "Editor Models" )
slicer.mrmlScene.AddNode( outHierarchy )
parameters["ModelSceneFile"] = outHierarchy
modelMaker = slicer.modules.modelmaker
#
# run the task (in the background)
# - use the GUI to provide progress feedback
# - use the GUI's Logic to invoke the task
# - model will show up when the processing is finished
#
self.CLINode = slicer.cli.run(modelMaker, self.CLINode, parameters)
self.statusText( "Model Making Started..." )
def pointBasedRegistration(self):
self.__registrationStatus.setText('Wait ...')
# image Data
vl = slicer.modules.volumes.logic()
#volumeNode = slicer.sliceWidgetRed_sliceLogic.GetBackgroundLayer().GetVolumeNode()
#imageData = slicer.sliceWidgetRed_sliceLogic.GetBackgroundLayer().GetVolumeNode().GetImageData()
volumeNode = self.__baselineVolume
imageData = volumeNode.GetImageData()
# min and max threshold values
minMax = imageData.GetScalarRange()
maxThresh = minMax[1]
imageDimensions = imageData.GetDimensions()
m = vtk.vtkMatrix4x4()
volumeNode.GetIJKToRASMatrix(m)
# set ROI
c = 9
roi = slicer.mrmlScene.CreateNodeByClass('vtkMRMLAnnotationROINode')
slicer.mrmlScene.AddNode(roi)
roi.SetROIAnnotationVisibility(1)
roi.SetRadiusXYZ(100,100,imageDimensions[2]/c)
roi.SetXYZ(0,0,m.GetElement(2,3)+imageDimensions[2]/c)
roi.SetLocked(1)
# crop volume
cropVolumeNode =slicer.mrmlScene.CreateNodeByClass('vtkMRMLCropVolumeParametersNode')
cropVolumeNode.SetScene(slicer.mrmlScene)
cropVolumeNode.SetName('obturator_CropVolume_node')
cropVolumeNode.SetIsotropicResampling(False)
slicer.mrmlScene.AddNode(cropVolumeNode)
cropVolumeNode.SetInputVolumeNodeID(volumeNode.GetID())
cropVolumeNode.SetROINodeID(roi.GetID())
cropVolumeLogic = slicer.modules.cropvolume.logic()
cropVolumeLogic.Apply(cropVolumeNode)
roiVolume = slicer.mrmlScene.GetNodeByID(cropVolumeNode.GetOutputVolumeNodeID())
roiVolume.SetName("template-area-ROI")
# label map
labelsColorNode = slicer.modules.colors.logic().GetColorTableNodeID(10)
roiSegmentation = vl.CreateAndAddLabelVolume(slicer.mrmlScene, roiVolume, 'marker_segmentation')
roiSegmentation.GetDisplayNode().SetAndObserveColorNodeID(labelsColorNode)
#threshold
thresh = vtk.vtkImageThreshold()
thresh.SetInput(roiVolume.GetImageData())
thresh.ThresholdBetween(150, maxThresh)
thresh.SetInValue(255)
thresh.SetOutValue(0)
thresh.ReplaceOutOn()
thresh.ReplaceInOn()
thresh.Update()
roiSegmentation.SetAndObserveImageData(thresh.GetOutput())
# Set Label
appLogic = slicer.app.applicationLogic()
selectionNode = appLogic.GetSelectionNode()
selectionNode.SetReferenceActiveLabelVolumeID(roiSegmentation.GetID())
appLogic.PropagateVolumeSelection()
# island effect
editUtil = EditorLib.EditUtil.EditUtil()
parameterNode = editUtil.getParameterNode()
sliceLogic = editUtil.getSliceLogic()
lm = slicer.app.layoutManager()
sliceWidget = lm.sliceWidget('Red')
islandsEffect = EditorLib.IdentifyIslandsEffectOptions()
islandsEffect.setMRMLDefaults()
islandsEffect.__del__()
islandTool = EditorLib.IdentifyIslandsEffectLogic(sliceLogic)
parameterNode.SetParameter("IslandEffect,minimumSize",'100')
islandTool.removeIslands()
LabelStatisticsLogic(volumeNode,roiSegmentation)
labelData = roiSegmentation.GetImageData()
labelDimensions = labelData.GetDimensions()
keys = ("Index", "Count", "Volume mm^3", "Volume cc", "Min", "Max", "Mean", "StdDev","Extent")
cubicMMPerVoxel = reduce(lambda x,y: x*y, roiSegmentation.GetSpacing())
ccPerCubicMM = 0.001
stataccum = vtk.vtkImageAccumulate()
stataccum.SetInput(labelData)
stataccum.Update()
lo = int(stataccum.GetMin()[0])
hi = int(stataccum.GetMax()[0])
labelStats = {}
labelStats['Labels'] = []
self.hierarchyNode = slicer.vtkMRMLModelHierarchyNode()
self.hierarchyNode.SetScene( slicer.mrmlScene )
self.hierarchyNode.SetName('LabelMarkers')
slicer.mrmlScene.AddNode(self.hierarchyNode)
labelsColorNodeX = slicer.modules.colors.logic().GetColorTableNodeID(10)
labelX = vl.CreateAndAddLabelVolume(slicer.mrmlScene, roiVolume, 'labelX')
labelX.GetDisplayNode().SetAndObserveColorNodeID(labelsColorNodeX)
#
center = []
#
for i in xrange(lo,hi+1):
#
labelsColorNodeX = slicer.modules.colors.logic().GetColorTableNodeID(10)
labelX = vl.CreateAndAddLabelVolume(slicer.mrmlScene, roiVolume, 'labelX')
labelX.GetDisplayNode().SetAndObserveColorNodeID(labelsColorNodeX)
thresholder = vtk.vtkImageThreshold()
thresholder.SetInput(roiSegmentation.GetImageData())
thresholder.SetInValue(i+1)
thresholder.SetOutValue(0)
thresholder.ReplaceOutOn()
thresholder.ThresholdBetween(i,i)
thresholder.SetOutputScalarType(roiSegmentation.GetImageData().GetScalarType())
thresholder.Update()
labelX.SetAndObserveImageData(thresholder.GetOutput())
#
#
stencil = vtk.vtkImageToImageStencil()
stencil.SetInput(thresholder.GetOutput())
stencil.ThresholdBetween(i+1, i+1)
#
stat1 = vtk.vtkImageAccumulate()
stat1.SetInput(labelX.GetImageData())
stat1.SetStencil(stencil.GetOutput())
stat1.Update()
#
if stat1.GetVoxelCount() > 0:
# add an entry to the LabelStats list
labelStats["Labels"].append(i)
labelStats[i,"Index"] = i
labelStats[i,"Count"] = stat1.GetVoxelCount()
mm3 = labelStats[i,"Count"] * cubicMMPerVoxel
labelStats[i,"Volume mm^3"] = mm3
labelStats[i,"Volume cc"] = labelStats[i,"Volume mm^3"] * ccPerCubicMM
labelStats[i,"Min"] = stat1.GetMin()[0]
labelStats[i,"Max"] = stat1.GetMax()[0]
labelStats[i,"Mean"] = stat1.GetMean()[0]
labelStats[i,"StdDev"] = stat1.GetStandardDeviation()[0]
labelStats[i,"Extent"] = stat1.GetComponentOrigin()
#
if mm3 <450 and mm3> 200:
#self.makeModel(labelX,self.hierarchyNode, i+1)
#node = slicer.util.getNode("label"+str(i+1))
#polydata = node.GetPolyData()
#center = polydata.GetCenter()
#print center
center.append(self.ijk2ras(self.getCenterOfMass(labelX,self.thresholdSlider.value ),labelX))
#print center
#print i
self.__registrationStatus.setText('Found Marker ' +str(i)+'...')
self.getAndSortFiducialPoints(center)
