def setUp(self):
self.vtkObjs = [vtk.vtkObject() for _ in range(30)]
self.collection = vtk.vtkCollection()
for obj in self.vtkObjs:
self.collection.AddItem(obj)
self.emptyCollection = vtk.vtkCollection()
def setUp(self):
self.vtkObjs = [vtk.vtkObject() for _ in range(30)]
self.collection = vtk.vtkCollection()
for obj in self.vtkObjs:
self.collection.AddItem(obj)
self.emptyCollection = vtk.vtkCollection()
def _onToggled(self, checked):
if self.cannulaNode:
layoutManager = slicer.app.layoutManager()
threeDView = layoutManager.threeDWidget(0).threeDView()
if checked == True and self.calculateAnglesBasedOnCannula():
displayManagers = vtk.vtkCollection()
threeDView.getDisplayableManagers(displayManagers)
for index in range(displayManagers.GetNumberOfItems()):
if displayManagers.GetItemAsObject(index).GetClassName(
) == 'vtkMRMLCameraDisplayableManager':
self.camera = displayManagers.GetItemAsObject(
index).GetCameraNode().GetCamera()
self.cameraPos = self.camera.GetPosition()
if not self.cameraReversePos:
threeDView.lookFromViewAxis(ctkAxesWidget.Posterior)
threeDView.pitchDirection = threeDView.PitchUp
threeDView.yawDirection = threeDView.YawRight
threeDView.setPitchRollYawIncrement(self._pitchAngle)
threeDView.pitch()
if self._yawAngle < 0:
threeDView.setPitchRollYawIncrement(self._yawAngle)
else:
threeDView.setPitchRollYawIncrement(360 -
self._yawAngle)
threeDView.yaw()
if self.cannulaNode and self.cannulaNode.GetNumberOfFiducials(
) >= 2:
posSecond = [0.0] * 3
self.cannulaNode.GetNthFiducialPosition(1, posSecond)
threeDView.setFocalPoint(posSecond[0], posSecond[1],
posSecond[2])
self.cameraReversePos = self.camera.GetPosition()
else:
self.camera.SetPosition(self.cameraReversePos)
threeDView.zoomIn(
) # to refresh the 3D viewer, when the view position is inside the skull model, the model is not rendered,
threeDView.zoomOut(
) # Zoom in and out will refresh the viewer
slicer.mrmlScene.InvokeEvent(
VentriculostomyUserEvents.ReverseViewClicked)
else:
displayManagers = vtk.vtkCollection()
threeDView.getDisplayableManagers(displayManagers)
for index in range(displayManagers.GetNumberOfItems()):
if displayManagers.GetItemAsObject(index).GetClassName(
) == 'vtkMRMLCameraDisplayableManager':
self.camera = displayManagers.GetItemAsObject(
index).GetCameraNode().GetCamera()
self.cameraReversePos = self.camera.GetPosition()
self.camera.SetPosition(self.cameraPos)
threeDView.zoomIn(
) # to refresh the 3D viewer, when the view position is inside the skull model, the model is not rendered,
threeDView.zoomOut() # Zoom in and out will refresh the viewer
slicer.mrmlScene.InvokeEvent(
VentriculostomyUserEvents.ReverseViewClicked)
def printModelName(self, observer, eventid):
modelDisplayableManager = None
threeDViewWidget = slicer.app.layoutManager().threeDWidget(0)
managers = vtk.vtkCollection()
threeDViewWidget.getDisplayableManagers(managers)
for i in range(managers.GetNumberOfItems()):
obj = managers.GetItemAsObject(i)
if obj.IsA('vtkMRMLModelDisplayableManager'):
modelDisplayableManager = obj
break
if modelDisplayableManager is None:
logging.error('Failed to find the model displayable manager')
crosshairNode = slicer.mrmlScene.GetNodeByID(
"vtkMRMLCrosshairNodedefault")
modelDisplayableManager.Pick3D(crosshairNode.GetCrosshairRAS())
# Only print name once and make sure that the crosshair is not on nothing
if (slicer.mrmlScene.GetNodeByID(
modelDisplayableManager.GetPickedNodeID())):
modelNode = slicer.mrmlScene.GetNodeByID(
modelDisplayableManager.GetPickedNodeID()).GetDisplayableNode(
)
if (modelNode.GetName() != self.previousModelPrinted):
print(modelNode.GetName()).split('_')[1]
self.previousModelPrinted = modelNode.GetName()
def examineForImport(self, fileLists):
""" Returns a list of qSlicerDICOMLoadable
instances corresponding to ways of interpreting the
fileLists parameter.
"""
# Create loadables for each file list
loadables = []
for fileList in fileLists: # Each file list corresponds to one series, so do loadables
# Convert file list to VTK object to be able to pass it for examining
# (VTK class cannot have Qt object as argument, otherwise it is not python wrapped)
vtkFileList = vtk.vtkStringArray()
for file in fileList:
vtkFileList.InsertNextValue(slicer.util.toVTKString(file))
# Examine files
loadablesCollection = vtk.vtkCollection()
slicer.modules.dicomrtimportexport.logic().ExamineForLoad(
vtkFileList, loadablesCollection)
for loadableIndex in xrange(
0, loadablesCollection.GetNumberOfItems()):
vtkLoadable = loadablesCollection.GetItemAsObject(
loadableIndex)
# Create Qt loadable if confidence is greater than 0
if vtkLoadable.GetConfidence() > 0:
# Convert to Qt loadable to pass it back
qtLoadable = slicer.qSlicerDICOMLoadable()
qtLoadable.copyFromVtkLoadable(vtkLoadable)
qtLoadable.tooltip = 'Valid RT object in selection'
qtLoadable.selected = True
loadables.append(qtLoadable)
return loadables
def addRuler(widget, color=None):
color = color if color else [0.25, 0.25, 0.75]
controller = widget.sliceController()
sliceView = widget.sliceView()
controller.setRulerType(2)
collection = vtk.vtkCollection()
sliceView.getDisplayableManagers(collection)
manager = None
for i in range(collection.GetNumberOfItems()):
if type(collection.GetItemAsObject(i)) is slicer.vtkMRMLRulerDisplayableManager:
manager = collection.GetItemAsObject(i)
break
renderers = manager.GetRenderer().GetRenderWindow().GetRenderers()
axisActor = None
textActor = None
for i in range(renderers.GetNumberOfItems()):
actors2D = renderers.GetItemAsObject(i).GetActors2D()
for j in range(actors2D.GetNumberOfItems()):
if type(actors2D.GetItemAsObject(j)) is vtk.vtkTextActor:
textActor = actors2D.GetItemAsObject(j)
elif type(actors2D.GetItemAsObject(j)) is vtk.vtkAxisActor2D:
axisActor = actors2D.GetItemAsObject(j)
if axisActor and textActor:
axisActor.GetProperty().SetColor(color)
textActor.GetProperty().SetColor(color)
sliceView.update()
break
def loadNode(self, uri, name, fileType='VolumeFile', fileProperties={}):
self.logMessage('<b>Requesting load</b> <i>%s</i> from %s...\n' %
(name, uri))
fileProperties['fileName'] = uri
fileProperties['name'] = name
firstLoadedNode = None
loadedNodes = vtk.vtkCollection()
success = slicer.app.coreIOManager().loadNodes(fileType,
fileProperties,
loadedNodes)
if not success or loadedNodes.GetNumberOfItems() < 1:
self.logMessage('<b><font color="red">\tLoad failed!</font></b>\n')
return None
self.logMessage('<b>Load finished</b>\n')
# since nodes were read from a temp directory remove the storage nodes
for i in range(loadedNodes.GetNumberOfItems()):
loadedNode = loadedNodes.GetItemAsObject(i)
if not loadedNode.IsA("vtkMRMLStorableNode"):
continue
storageNode = loadedNode.GetStorageNode()
if not storageNode:
continue
slicer.mrmlScene.RemoveNode(storageNode)
loadedNode.SetAndObserveStorageNodeID(None)
return loadedNodes.GetItemAsObject(0)
def loadNode(self, uri, name, fileType = 'VolumeFile', fileProperties = {}):
self.logMessage('<b>Requesting load</b> <i>%s</i> from %s...\n' % (name, uri))
fileProperties['fileName'] = uri
fileProperties['name'] = name
firstLoadedNode = None
loadedNodes = vtk.vtkCollection()
success = slicer.app.coreIOManager().loadNodes(fileType, fileProperties, loadedNodes)
if not success or loadedNodes.GetNumberOfItems()<1:
self.logMessage('<b><font color="red">\tLoad failed!</font></b>\n')
return None
self.logMessage('<b>Load finished</b>\n')
# since nodes were read from a temp directory remove the storage nodes
for i in range(loadedNodes.GetNumberOfItems()):
loadedNode = loadedNodes.GetItemAsObject(i)
if not loadedNode.IsA("vtkMRMLStorableNode"):
continue
storageNode = loadedNode.GetStorageNode()
if not storageNode:
continue
slicer.mrmlScene.RemoveNode(storageNode)
loadedNode.SetAndObserveStorageNodeID(None)
return loadedNodes.GetItemAsObject(0)
def setInteractor(self):
self.renderWindow = slicer.app.layoutManager().threeDWidget(0).threeDView().renderWindow()
self.iren = self.renderWindow.GetInteractor()
lm = slicer.app.layoutManager()
for v in range(lm.threeDViewCount):
td = lm.threeDWidget(v)
ms = vtk.vtkCollection()
td.getDisplayableManagers(ms)
for i in range(ms.GetNumberOfItems()):
m = ms.GetItemAsObject(i)
if m.GetClassName() == "vtkMRMLModelDisplayableManager":
self.dispManager = m
break
self.propPicker = vtk.vtkPropPicker()
self.iren.SetPicker(self.propPicker)
#self.propPicker.AddObserver("EndPickEvent", self.PickProp)
#self.propPicker.AddObserver("PickEvent", self.PickProp)
self.renderer = slicer.app.layoutManager().threeDWidget(0).threeDView().renderWindow().GetRenderers().GetFirstRenderer()
tag = self.iren.AddObserver("LeftButtonReleaseEvent", self.processEvent, self.priority)
self.observerTags.append([self.iren,tag])
tag = self.iren.AddObserver("MouseMoveEvent", self.processEvent, self.priority)
self.observerTags.append([self.iren,tag])
self.mouseInteractor = MouseInteractorActor()
self.mouseInteractor.SetDefaultRenderer(self.renderer)
self.iterStyleSave = iren.GetInteractorStyle()
self.iren.SetInteractorStyle(self.mouseInteractor)
def addRuler(widget, color=None):
color = color if color else [0.25, 0.25, 0.75]
controller = widget.sliceController()
sliceView = widget.sliceView()
controller.setRulerType(2)
collection = vtk.vtkCollection()
sliceView.getDisplayableManagers(collection)
manager = None
for i in range(collection.GetNumberOfItems()):
if type(collection.GetItemAsObject(i)) is slicer.vtkMRMLRulerDisplayableManager:
manager = collection.GetItemAsObject(i)
break
renderers = manager.GetRenderer().GetRenderWindow().GetRenderers()
axisActor = None
textActor = None
for i in range(renderers.GetNumberOfItems()):
actors2D = renderers.GetItemAsObject(i).GetActors2D()
for j in range(actors2D.GetNumberOfItems()):
if type(actors2D.GetItemAsObject(j)) is vtk.vtkTextActor:
textActor = actors2D.GetItemAsObject(j)
elif type(actors2D.GetItemAsObject(j)) is vtk.vtkAxisActor2D:
axisActor = actors2D.GetItemAsObject(j)
if axisActor and textActor:
axisActor.GetProperty().SetColor(color)
textActor.GetProperty().SetColor(color)
sliceView.update()
break
def generateSequence(self,animationNode):
sequenceBrowserNode = self.compileScript(animationNode)
sequenceNodes = vtk.vtkCollection()
sequenceBrowserNode.GetSynchronizedSequenceNodes(sequenceNodes, True) # include master
sequenceNode = sequenceNodes.GetItemAsObject(0)
animationNode.SetAttribute('Animator.sequenceBrowserNodeID', sequenceBrowserNode.GetID())
animationNode.SetAttribute('Animator.sequenceNodeID', sequenceNode.GetID())
def IgnoreIrrelevantMetrics(metricDict, peNode):
if (peNode is None or
PythonMetricsCalculatorLogic.GetPerkEvaluatorLogic() is None):
return
irrelevantTransformMetrics = []
relevantTransformNodes = vtk.vtkCollection()
PythonMetricsCalculatorLogic.GetPerkEvaluatorLogic(
).GetProxyRelevantTransformNodes(
peNode.GetTrackedSequenceBrowserNode(), relevantTransformNodes)
for metricInstanceID in metricDict:
metricTransformRoles = PythonMetricsCalculatorLogic.GetTransformRoles(
metricDict[metricInstanceID])
metricInstanceNode = PythonMetricsCalculatorLogic.GetMRMLScene(
).GetNodeByID(metricInstanceID)
for role in metricTransformRoles:
transformNode = metricInstanceNode.GetRoleNode(
role, metricInstanceNode.TransformRole)
transformNodeRelevant = relevantTransformNodes.IsItemPresent(
transformNode)
if (not transformNodeRelevant):
irrelevantTransformMetrics.append(metricInstanceID)
for metricInstanceID in irrelevantTransformMetrics:
metricDict.pop(metricInstanceID)
def examineForImport(self,fileLists):
""" Returns a list of qSlicerDICOMLoadable
instances corresponding to ways of interpreting the
fileLists parameter.
"""
# Create loadables for each file list
loadables = []
for fileList in fileLists: # Each file list corresponds to one series, so do loadables
# Convert file list to VTK object to be able to pass it for examining
# (VTK class cannot have Qt object as argument, otherwise it is not python wrapped)
vtkFileList = vtk.vtkStringArray()
for file in fileList:
vtkFileList.InsertNextValue(slicer.util.toVTKString(file))
# Examine files
loadablesCollection = vtk.vtkCollection()
slicer.modules.dicomrtimportexport.logic().ExamineForLoad(vtkFileList, loadablesCollection)
for loadableIndex in xrange(0,loadablesCollection.GetNumberOfItems()):
vtkLoadable = loadablesCollection.GetItemAsObject(loadableIndex)
# Create Qt loadable if confidence is greater than 0
if vtkLoadable.GetConfidence() > 0:
# Convert to Qt loadable to pass it back
qtLoadable = slicer.qSlicerDICOMLoadable()
qtLoadable.copyFromVtkLoadable(vtkLoadable)
qtLoadable.tooltip = 'Valid RT object in selection'
qtLoadable.selected = True
loadables.append(qtLoadable)
return loadables
def getRulerNodeForVolumeAndStructure(self,
volumeId,
structureId,
createIfNotExist=True,
callbackWhenRulerModified=None):
""" Search for the right ruler node to be created based on the volume and the selected
structure (Aorta or PA).
It also creates the necessary node hierarchy if it doesn't exist.
:param volumeId:
:param structureId: Aorta (1), PA (2)
:param createIfNotExist: create the ruler node if it doesn't exist yet
:param callbackWhenRulerModified: function to call when the ruler node is modified
:return: node and a boolean indicating if the node has been created now
"""
isNewNode = False
if structureId == 0: # none
return None, isNewNode
if structureId == self.AORTA: # Aorta
#nodeName = volumeId + '_paaRulers_aorta'
nodeName = "A"
elif structureId == self.PA: # 'Pulmonary Arterial':
# nodeName = volumeId + '_paaRulers_pa'
nodeName = "PA"
# Get the node that contains all the rulers for this volume
rulersListNode = self.getRulersListNode(
volumeId, createIfNotExist=createIfNotExist)
node = None
if rulersListNode:
# Search for the node
for i in range(rulersListNode.GetNumberOfChildrenNodes()):
nodeWrapper = rulersListNode.GetNthChildNode(i)
# nodeWrapper is also a HierarchyNode. We need to look for its only child that will be the rulerNode
col = vtk.vtkCollection()
nodeWrapper.GetChildrenDisplayableNodes(col)
rulerNode = col.GetItemAsObject(0)
if rulerNode.GetName() == nodeName:
node = rulerNode
break
if node is None and createIfNotExist:
# Create the node
# Set the active node, so that the new ruler is a child node
annotationsLogic = slicer.modules.annotations.logic()
annotationsLogic.SetActiveHierarchyNodeID(
rulersListNode.GetID())
node = slicer.mrmlScene.CreateNodeByClass(
'vtkMRMLAnnotationRulerNode')
node.SetName(nodeName)
self.__changeColor__(node, self.defaultColor)
slicer.mrmlScene.AddNode(node)
isNewNode = True
node.AddObserver(vtk.vtkCommand.ModifiedEvent,
callbackWhenRulerModified)
logging.debug("Created node " + nodeName + " for volume " +
volumeId)
return node, isNewNode
def getModel3DDisplayableManager(self):
threeDViewWidget = slicer.app.layoutManager().threeDWidget(0)
managers = vtk.vtkCollection()
threeDViewWidget.getDisplayableManagers(managers)
for i in range(managers.GetNumberOfItems()):
obj = managers.GetItemAsObject(i)
if obj.IsA('vtkMRMLLinearTransformsDisplayableManager3D'):
return obj
return None
def export(self, exportables):
exportablesCollection = vtk.vtkCollection()
for exportable in exportables:
vtkExportable = slicer.vtkSlicerDICOMExportable()
exportable.copyToVtkExportable(vtkExportable)
exportablesCollection.AddItem(vtkExportable)
self.exportAsDICOMSEG(exportablesCollection)
def getModel3DDisplayableManager(self):
threeDViewWidget = slicer.app.layoutManager().threeDWidget(0)
managers = vtk.vtkCollection()
threeDViewWidget.getDisplayableManagers(managers)
for i in range(managers.GetNumberOfItems()):
obj = managers.GetItemAsObject(i)
if obj.IsA('vtkMRMLLinearTransformsDisplayableManager3D'):
return obj
return None
def export(self, exportables):
exportablesCollection = vtk.vtkCollection()
for exportable in exportables:
vtkExportable = slicer.vtkSlicerDICOMExportable()
exportable.copyToVtkExportable(vtkExportable)
exportablesCollection.AddItem(vtkExportable)
self.exportAsDICOMSEG(exportablesCollection)
def getFiducialSliceDisplayableManagerHelper(self,sliceName='Red'):
sliceWidget = slicer.app.layoutManager().sliceWidget(sliceName)
sliceView = sliceWidget.sliceView()
collection = vtk.vtkCollection()
sliceView.getDisplayableManagers(collection)
for i in range(collection.GetNumberOfItems()):
m = collection.GetItemAsObject(i)
if m.GetClassName() == "vtkMRMLMarkupsFiducialDisplayableManager2D":
return m.GetHelper()
return None
def getFiducialSliceDisplayableManagerHelper(self,sliceName='Red'):
sliceWidget = slicer.app.layoutManager().sliceWidget(sliceName)
sliceView = sliceWidget.sliceView()
collection = vtk.vtkCollection()
sliceView.getDisplayableManagers(collection)
for i in range(collection.GetNumberOfItems()):
m = collection.GetItemAsObject(i)
if m.GetClassName() == "vtkMRMLMarkupsFiducialDisplayableManager2D":
return m.GetHelper()
return None
def export(self,exportables):
# Convert Qt loadables to VTK ones for the RT export logic
exportablesCollection = vtk.vtkCollection()
for exportable in exportables:
vtkExportable = slicer.vtkSlicerDICOMExportable()
exportable.copyToVtkExportable(vtkExportable)
exportablesCollection.AddItem(vtkExportable)
# Export RT study
message = slicer.modules.dicomrtimportexport.logic().ExportDicomRTStudy(exportablesCollection)
return message
def mergeTree(self, treeWidget, landmarkNode, modelNode,rowColNumber):
nodeIDs=treeWidget.selectedIndexes()
nodeList = vtk.vtkCollection()
for id in nodeIDs:
if id.column() == 0:
currentNode = slicer.util.getNode(id.data())
nodeList.AddItem(currentNode)
mergedNodeName = landmarkNode.GetName() + "_mergedNode"
mergedNode = slicer.mrmlScene.AddNewNodeByClass('vtkMRMLMarkupsFiducialNode', mergedNodeName)
self.mergeList(nodeList, landmarkNode, modelNode,rowColNumber,mergedNode)
return True
def testSubclassGhost(self):
"""Make sure ghosting of the class works"""
o = vtkCustomObject()
c = vtk.vtkCollection()
c.AddItem(o)
i = id(o)
del o
o = vtk.vtkObject()
o = c.GetItemAsObject(0)
# make sure the id has changed, but class the same
self.assertEqual(o.__class__, vtkCustomObject)
self.assertNotEqual(i, id(o))
def UpdateProxyNodeMetrics( taskMetrics, proxyNodes, time ):
if ( PythonMetricsCalculatorLogic.GetMRMLScene() == None or PythonMetricsCalculatorLogic.GetPerkEvaluatorLogic() == None ):
return
# Get all transforms in the scene
relevantTransformNodes = vtk.vtkCollection()
PythonMetricsCalculatorLogic.GetPerkEvaluatorLogic().GetProxyRelevantTransformNodes( proxyNodes, relevantTransformNodes )
# Update all metrics associated with children of the recorded transform
for j in range( relevantTransformNodes.GetNumberOfItems() ):
currentTransformNode = relevantTransformNodes.GetItemAsObject( j )
PythonMetricsCalculatorLogic.UpdateMetrics( taskMetrics, currentTransformNode, time )
def getModelDisplayableManager(self):
if self.viewWidget is None:
logging.error('View widget is not created')
return None
managers = vtk.vtkCollection()
self.viewWidget.getDisplayableManagers(managers)
for i in range(managers.GetNumberOfItems()):
obj = managers.GetItemAsObject(i)
if obj.IsA('vtkMRMLModelDisplayableManager'):
return obj
logging.error('Failed to find the model displayable manager')
return None
def testSubclassGhost(self):
"""Make sure ghosting of the class works"""
o = vtkCustomObject()
c = vtk.vtkCollection()
c.AddItem(o)
i = id(o)
del o
o = vtk.vtkObject()
o = c.GetItemAsObject(0)
# make sure the id has changed, but class the same
self.assertEqual(o.__class__, vtkCustomObject)
self.assertNotEqual(i, id(o))
def UpdateProxyNodeMetrics( taskMetrics, proxyNodes, time ):
if ( PythonMetricsCalculatorLogic.GetMRMLScene() == None or PythonMetricsCalculatorLogic.GetPerkEvaluatorLogic() == None ):
return
# Get all transforms in the scene
relevantTransformNodes = vtk.vtkCollection()
PythonMetricsCalculatorLogic.GetPerkEvaluatorLogic().GetProxyRelevantTransformNodes( proxyNodes, relevantTransformNodes )
# Update all metrics associated with children of the recorded transform
for j in range( relevantTransformNodes.GetNumberOfItems() ):
currentTransformNode = relevantTransformNodes.GetItemAsObject( j )
PythonMetricsCalculatorLogic.UpdateMetrics( taskMetrics, currentTransformNode, time )
def loadNodeFromFile(filename, filetype, properties={}, returnNode=False):
from slicer import app
from vtk import vtkCollection
properties['fileName'] = filename
if returnNode:
loadedNodes = vtkCollection()
success = app.coreIOManager().loadNodes(filetype, properties, loadedNodes)
return success, loadedNodes.GetItemAsObject(0)
else:
success = app.coreIOManager().loadNodes(filetype, properties)
return success
def loadNodeFromFile(filename, filetype, properties={}, returnNode=False):
from slicer import app
from vtk import vtkCollection
properties['fileName'] = filename
if returnNode:
loadedNodes = vtkCollection()
success = app.coreIOManager().loadNodes(filetype, properties, loadedNodes)
return success, loadedNodes.GetItemAsObject(0)
else:
success = app.coreIOManager().loadNodes(filetype, properties)
return success
def export(self, exportables):
# Convert Qt loadables to VTK ones for the RT export logic
exportablesCollection = vtk.vtkCollection()
for exportable in exportables:
vtkExportable = slicer.vtkSlicerDICOMExportable()
exportable.copyToVtkExportable(vtkExportable)
exportablesCollection.AddItem(vtkExportable)
# Export RT study
message = slicer.modules.dicomrtimportexport.logic(
).ExportDicomRTStudy(exportablesCollection)
return message
def removeModelHierarchyAndChildModelNodesFromScene(modelHierarchyNode):
if modelHierarchyNode:
cmn = vtk.vtkCollection()
modelHierarchyNode.GetChildrenModelNodes(cmn)
for i in range(cmn.GetNumberOfItems()):
model = cmn.GetItemAsObject(i)
if model.IsA('vtkMRMLModelNode'):
slicer.mrmlScene.RemoveNode(model)
slicer.mrmlScene.RemoveNode(modelHierarchyNode)
def widgetVisible(self, fidNode, viewNodeID):
lm = slicer.app.layoutManager()
for v in range(lm.threeDViewCount):
td = lm.threeDWidget(v)
ms = vtk.vtkCollection()
td.getDisplayableManagers(ms)
for i in range(ms.GetNumberOfItems()):
m = ms.GetItemAsObject(i)
if m.GetClassName() == "vtkMRMLMarkupsFiducialDisplayableManager3D" and m.GetMRMLViewNode().GetID() == viewNodeID:
h = m.GetHelper()
seedWidget = h.GetWidget(fidNode)
return seedWidget.GetEnabled()
return 0
def widgetVisible(self, fidNode, viewNodeID):
lm = slicer.app.layoutManager()
for v in range(lm.threeDViewCount):
td = lm.threeDWidget(v)
ms = vtk.vtkCollection()
td.getDisplayableManagers(ms)
for i in range(ms.GetNumberOfItems()):
m = ms.GetItemAsObject(i)
if m.GetClassName() == "vtkMRMLMarkupsFiducialDisplayableManager3D" and m.GetMRMLViewNode().GetID() == viewNodeID:
h = m.GetHelper()
seedWidget = h.GetWidget(fidNode)
return seedWidget.GetEnabled()
return 0
def rulersVisible(self, volumeId, visible):
""" Show or hide all the ruler nodes
"""
if volumeId is not None:
rulersListNode = self.getRulersListNode(volumeId, False)
if rulersListNode:
for i in range(rulersListNode.GetNumberOfChildrenNodes()):
nodeWrapper = rulersListNode.GetNthChildNode(i)
# nodeWrapper is also a HierarchyNode. We need to look for its only child that will be the rulerNode
col = vtk.vtkCollection()
nodeWrapper.GetChildrenDisplayableNodes(col)
rulerNode = col.GetItemAsObject(0)
rulerNode.SetDisplayVisibility(visible)
def makeModels(study, finding, colorTable):
if (study is None) | (finding is None) | (colorTable is 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 is not None) & (tempMH is not None):
parameters = {'InputVolume': labelVolume.GetID(), 'ColorTable': colorTable.GetID(),
'ModelSceneFile': tempMH.GetID(), 'GenerateAll': False, 'StartLabel': finding.GetColorID(),
'EndLabel': finding.GetColorID(), '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)
#return '#%02X%02X%02X' % (r,g,b)
def runCurves(self, markupsTreeView, continuousCurveOption):
nodeIDs = markupsTreeView.selectedIndexes()
nodeList = vtk.vtkCollection()
for id in nodeIDs:
if id.column() == 0:
currentNode = slicer.util.getNode(id.data())
nodeList.AddItem(currentNode)
mergedNodeName = "mergedMarkupsNode"
mergedNode = slicer.mrmlScene.AddNewNodeByClass(
'vtkMRMLMarkupsCurveNode', mergedNodeName)
purple = [1, 0, 1]
mergedNode.GetDisplayNode().SetSelectedColor(purple)
self.mergeList(nodeList, mergedNode, continuousCurveOption)
return True
def execute(self):
output_collection = vtk.vtkCollection()
cluster = ClusterParticles(input,
output_collection,
feature_extractor=self.feature_extractor)
cluster._number_of_clusters = 2
#cluster._method='MiniBatchKMeans'
cluster._method = 'KMeans'
cluster.execute()
points = vtk_to_numpy(input.GetPoints().GetData())
p_centroids = np.zeros([2, 3])
for ii, ll in enumerate(cluster._unique_labels):
p_centroids[ii, :] = np.mean(points[cluster._labels == ll, :],
axis=0)
if p_centroids[0, 0] > p_centroids[1, 0]:
self.cluster_tags = ['left', 'right']
chest_region = [3, 2]
chest_type = [3, 3]
else:
self.cluster_tags = ['right', 'left']
chest_region = [2, 3]
chest_type = [3, 3]
append = vtk.vtkAppendPolyData()
for k, tag, cr, ct in zip([0, 1], self.cluster_tags, chest_region,
chest_type):
self._out_vtk[tag] = output_collection.GetItemAsObject(k)
chest_region_arr = vtk.vtkUnsignedCharArray()
chest_region_arr.SetName('ChestRegion')
chest_type_arr = vtk.vtkUnsignedCharArray()
chest_type_arr.SetName('ChestType')
n_p = self._out_vtk[tag].GetNumberOfPoints()
chest_region_arr.SetNumberOfTuples(n_p)
chest_type_arr.SetNumberOfTuples(n_p)
for ii in xrange(self._out_vtk[tag].GetNumberOfPoints()):
chest_region_arr.SetValue(ii, cr)
chest_type_arr.SetValue(ii, ct)
self._out_vtk[tag].GetPointData().AddArray(chest_region_arr)
self._out_vtk[tag].GetPointData().AddArray(chest_type_arr)
append.AddInput(self._out_vtk[tag])
append.Update()
self._out_vtk['all'] = append.GetOutput()
return self._out_vtk
def widgetVisibleOnSlice(self, fidNode, sliceNodeID):
lm = slicer.app.layoutManager()
sliceNames = lm.sliceViewNames()
for sliceName in sliceNames:
sliceWidget = lm.sliceWidget(sliceName)
sliceView = sliceWidget.sliceView()
ms = vtk.vtkCollection()
sliceView.getDisplayableManagers(ms)
for i in range(ms.GetNumberOfItems()):
m = ms.GetItemAsObject(i)
if m.GetClassName() == 'vtkMRMLMarkupsFiducialDisplayableManager2D' and m.GetMRMLSliceNode().GetID() == sliceNodeID:
h = m.GetHelper()
seedWidget = h.GetWidget(fidNode)
return seedWidget.GetEnabled()
return 0
def applyColor(self, red, green, blue, opacity):
print("Color applied: " + str(red) + "," + str(green) + "," +
str(blue) + ", with opacity:" + str(opacity))
modelDisplayableManager = None
threeDViewWidget = slicer.app.layoutManager().threeDWidget(0)
managers = vtk.vtkCollection()
threeDViewWidget.getDisplayableManagers(managers)
for i in range(managers.GetNumberOfItems()):
obj = managers.GetItemAsObject(i)
if obj.IsA('vtkMRMLModelDisplayableManager'):
modelDisplayableManager = obj
break
if modelDisplayableManager is None:
logging.error('Failed to find the model displayable manager')
def widgetVisibleOnSlice(self, fidNode, sliceNodeID):
lm = slicer.app.layoutManager()
sliceNames = lm.sliceViewNames()
for sliceName in sliceNames:
sliceWidget = lm.sliceWidget(sliceName)
sliceView = sliceWidget.sliceView()
ms = vtk.vtkCollection()
sliceView.getDisplayableManagers(ms)
for i in range(ms.GetNumberOfItems()):
m = ms.GetItemAsObject(i)
if m.GetClassName() == 'vtkMRMLMarkupsFiducialDisplayableManager2D' and m.GetMRMLSliceNode().GetID() == sliceNodeID:
h = m.GetHelper()
seedWidget = h.GetWidget(fidNode)
return seedWidget.GetEnabled()
return 0
def controlPointVisible3D(self, fidNode, viewNodeID, controlPointIndex):
lm = slicer.app.layoutManager()
for v in range(lm.threeDViewCount):
td = lm.threeDWidget(v)
if td.viewLogic().GetViewNode().GetID() != viewNodeID:
continue
td.threeDView().forceRender()
slicer.app.processEvents()
ms = vtk.vtkCollection()
td.getDisplayableManagers(ms)
for i in range(ms.GetNumberOfItems()):
m = ms.GetItemAsObject(i)
if m.GetClassName() == "vtkMRMLMarkupsDisplayableManager":
markupsWidget = m.GetWidget(fidNode.GetDisplayNode())
return markupsWidget.GetMarkupsRepresentation(
).GetNthControlPointViewVisibility(controlPointIndex)
return False
def execute(self):
output_collection = vtk.vtkCollection()
cluster=ClusterParticles(input,output_collection,feature_extractor=self.feature_extractor)
cluster._number_of_clusters=2
#cluster._method='MiniBatchKMeans'
cluster._method='KMeans'
cluster.execute()
points = vtk_to_numpy(input.GetPoints().GetData())
p_centroids = np.zeros([2,3])
for ii,ll in enumerate(cluster._unique_labels):
p_centroids[ii,:]=np.mean(points[cluster._labels==ll,:],axis=0)
if p_centroids[0,0] > p_centroids[1,0]:
self.cluster_tags=['left','right']
chest_region=[3,2]
chest_type=[3,3]
else:
self.cluster_tags=['right','left']
chest_region=[2,3]
chest_type=[3,3]
append=vtk.vtkAppendPolyData()
for k,tag,cr,ct in zip([0,1],self.cluster_tags,chest_region,chest_type):
self._out_vtk[tag]=output_collection.GetItemAsObject(k)
chest_region_arr = vtk.vtkUnsignedCharArray()
chest_region_arr.SetName('ChestRegion')
chest_type_arr = vtk.vtkUnsignedCharArray()
chest_type_arr.SetName('ChestType')
n_p = self._out_vtk[tag].GetNumberOfPoints()
chest_region_arr.SetNumberOfTuples(n_p)
chest_type_arr.SetNumberOfTuples(n_p)
for ii in xrange(self._out_vtk[tag].GetNumberOfPoints()):
chest_region_arr.SetValue(ii,cr)
chest_type_arr.SetValue(ii,ct)
self._out_vtk[tag].GetPointData().AddArray(chest_region_arr)
self._out_vtk[tag].GetPointData().AddArray(chest_type_arr)
append.AddInput(self._out_vtk[tag])
append.Update()
self._out_vtk['all']=append.GetOutput()
return self._out_vtk
def iniVTK(self):
self.last_added_sphere_ren1 = None
self.newed_spheres = vtk.vtkCollection()
self.sphere_radius_ren1 = 2.0
self.bouttons_spheres = []
self.slice_assembly = None
self.image_roi = None
self.im_importer = vtk.vtkImageImport()
self.sphere = vtk.vtkSphereSource()
self.sphere.SetRadius(2.0)
self.sphere_mapper = vtk.vtkPolyDataMapper()
self.sphere_mapper.SetInputConnection(self.sphere.GetOutputPort())
self.sphere_actor_ren2 = vtk.vtkActor()
self.sphere.SetCenter(show_height / 2, show_width / 2, 0)
self.sphere_actor_ren2.SetMapper(self.sphere_mapper)
self.sphere_actor_ren2.GetProperty().SetColor(255.0, 0, 0)
self.vtk_widget.GetRenderWindow().SetSize(800, 400)
self.image_actor = vtk.vtkImageActor()
self.ren1 = vtk.vtkRenderer()
self.ren2 = vtk.vtkRenderer()
self.interactorStyle = BouttonInteractorStyle()
self.vtk_widget.SetInteractorStyle(self.interactorStyle)
self.vtk_widget.GetRenderWindow().AddRenderer(self.ren1)
self.vtk_widget.GetRenderWindow().AddRenderer(self.ren2)
self.ren1.SetViewport(0.0, 0.0, 0.5, 1.0)
self.ren2.SetViewport(0.5, 0.0, 1.0, 1.0)
self.ren2.AddActor(self.sphere_actor_ren2)
self.imageLevelFilter = vtk.vtkImageMapToWindowLevelColors()
self.imageLevelFilter.SetLevel(400)
self.imageLevelFilter.SetWindow(800)
self.im_importer.SetNumberOfScalarComponents(1)
self.im_importer.SetDataScalarTypeToUnsignedShort()
self.im_importer.SetDataExtent(0, show_width - 1, 0, show_height - 1,
0, 0)
self.im_importer.SetWholeExtent(0, show_width - 1, 0, show_height - 1,
0, 0)
self.imageLevelFilter.SetInputConnection(
self.im_importer.GetOutputPort())
self.image_actor.SetInput(self.imageLevelFilter.GetOutput())
self.ren1_sphere_actors = vtk.vtkActorCollection()
self.pointPicker = vtk.vtkPointPicker()
self.actorPicker = vtk.vtkPropPicker()
self.pickedActor = None
self.ren1.AddActor(self.image_actor)
self.ren2.AddActor(self.image_actor)
def onExport(self):
# set up the threeDWidget at the correct render size
layoutManager = slicer.app.layoutManager()
oldLayout = layoutManager.layout
threeDWidget = layoutManager.threeDWidget(0)
threeDWidget.setParent(None)
threeDWidget.show()
geometry = threeDWidget.geometry
size = self.sizes[self.sizeSelector.currentText]
threeDWidget.threeDController().visible = False
threeDWidget.setGeometry(geometry.x(), geometry.y(), size["width"], size["height"])
# set up the animation nodes
viewNode = threeDWidget.threeDView().mrmlViewNode()
animationNode = self.animationSelector.currentNode()
sequenceBrowserNode = slicer.util.getNode(animationNode.GetAttribute('Animator.sequenceBrowserNodeID'))
sequenceNodes = vtk.vtkCollection()
sequenceBrowserNode.GetSynchronizedSequenceNodes(sequenceNodes, True) # include master
sequenceNode = sequenceNodes.GetItemAsObject(0)
frameCount = sequenceNode.GetNumberOfDataNodes()
tempDir = qt.QTemporaryDir()
fileExtension = self.fileFormats[self.fileFormatSelector.currentText]
# perform the screen capture and video creation
from ScreenCapture import ScreenCaptureLogic
logic = ScreenCaptureLogic()
logic.captureSequence(
viewNode,
sequenceBrowserNode,
0, frameCount-1, frameCount,
tempDir.path(),
"Slicer-%04d.png")
logic.createVideo(
60,
"-pix_fmt yuv420p",
tempDir.path(),
"Slicer-%04d.png",
self.outputFileButton.text+fileExtension)
# reset the view
threeDWidget.threeDController().visible = True
layoutManager.setLayout(slicer.vtkMRMLLayoutNode.SlicerLayoutFinalView) ;# force change
layoutManager.setLayout(oldLayout)
def iniVTK(self):
self.last_added_sphere_ren1 = None
self.newed_spheres = vtk.vtkCollection()
self.sphere_radius_ren1 = 2.0
self.bouttons_spheres = []
self.slice_assembly = None
self.image_roi = None
self.im_importer = vtk.vtkImageImport()
self.sphere = vtk.vtkSphereSource()
self.sphere.SetRadius(2.0)
self.sphere_mapper = vtk.vtkPolyDataMapper()
self.sphere_mapper.SetInputConnection(self.sphere.GetOutputPort())
self.sphere_actor_ren2 = vtk.vtkActor()
self.sphere.SetCenter(show_height / 2, show_width / 2, 0)
self.sphere_actor_ren2.SetMapper(self.sphere_mapper)
self.sphere_actor_ren2.GetProperty().SetColor(255.0, 0, 0)
self.vtk_widget.GetRenderWindow().SetSize(800, 400)
self.image_actor = vtk.vtkImageActor()
self.ren1 = vtk.vtkRenderer()
self.ren2 = vtk.vtkRenderer()
self.interactorStyle = BouttonInteractorStyle()
self.vtk_widget.SetInteractorStyle(self.interactorStyle)
self.vtk_widget.GetRenderWindow().AddRenderer(self.ren1)
self.vtk_widget.GetRenderWindow().AddRenderer(self.ren2)
self.ren1.SetViewport(0.0, 0.0, 0.5, 1.0)
self.ren2.SetViewport(0.5, 0.0, 1.0, 1.0)
self.ren2.AddActor(self.sphere_actor_ren2)
self.imageLevelFilter = vtk.vtkImageMapToWindowLevelColors()
self.imageLevelFilter.SetLevel(400)
self.imageLevelFilter.SetWindow(800)
self.im_importer.SetNumberOfScalarComponents(1)
self.im_importer.SetDataScalarTypeToUnsignedShort()
self.im_importer.SetDataExtent(0, show_width - 1, 0, show_height - 1, 0, 0)
self.im_importer.SetWholeExtent(0, show_width - 1, 0, show_height - 1, 0, 0)
self.imageLevelFilter.SetInputConnection(self.im_importer.GetOutputPort())
self.image_actor.SetInput(self.imageLevelFilter.GetOutput())
self.ren1_sphere_actors = vtk.vtkActorCollection()
self.pointPicker = vtk.vtkPointPicker()
self.actorPicker = vtk.vtkPropPicker()
self.pickedActor = None
self.ren1.AddActor(self.image_actor)
self.ren2.AddActor(self.image_actor)
def __init__(self, text="", parent=None, **kwargs):
super(ReverseViewOnCannulaButton,
self).__init__(text, parent, **kwargs)
self._cannulaNode = None
self._pitchAngle = 0.0
self._yawAngle = 0.0
self.cameraPos = [0.0] * 3
self.cameraReversePos = None
self.camera = None
layoutManager = slicer.app.layoutManager()
threeDView = layoutManager.threeDWidget(0).threeDView()
displayManagers = vtk.vtkCollection()
threeDView.getDisplayableManagers(displayManagers)
for index in range(displayManagers.GetNumberOfItems()):
if displayManagers.GetItemAsObject(
index).GetClassName() == 'vtkMRMLCameraDisplayableManager':
self.camera = displayManagers.GetItemAsObject(
index).GetCameraNode().GetCamera()
self.cameraPos = self.camera.GetPosition()
self.toolTip = "Reverse the view of the cannula from the other end"
def controlPointVisibleSlice(self, fidNode, sliceNodeID, controlPointIndex):
import vtkSlicerMarkupsModuleVTKWidgetsPython
lm = slicer.app.layoutManager()
sliceNames = lm.sliceViewNames()
for sliceName in sliceNames:
sliceWidget = lm.sliceWidget(sliceName)
sliceView = sliceWidget.sliceView()
sliceNode = sliceView.mrmlSliceNode()
if sliceNode.GetID() != sliceNodeID:
continue
sliceView.forceRender()
slicer.app.processEvents()
ms = vtk.vtkCollection()
sliceView.getDisplayableManagers(ms)
for i in range(ms.GetNumberOfItems()):
m = ms.GetItemAsObject(i)
if m.GetClassName() == 'vtkMRMLMarkupsDisplayableManager':
markupsWidget = m.GetWidget(fidNode.GetDisplayNode())
return markupsWidget.GetMarkupsRepresentation().GetNthControlPointViewVisibility(controlPointIndex)
return False
def IgnoreIrrelevantMetrics( metricDict, peNode ):
if ( peNode is None or PythonMetricsCalculatorLogic.GetPerkEvaluatorLogic() is None ):
return
irrelevantTransformMetrics = []
relevantTransformNodes = vtk.vtkCollection()
PythonMetricsCalculatorLogic.GetPerkEvaluatorLogic().GetProxyRelevantTransformNodes( peNode.GetTrackedSequenceBrowserNode(), relevantTransformNodes )
for metricInstanceID in metricDict:
metricTransformRoles = PythonMetricsCalculatorLogic.GetTransformRoles( metricDict[ metricInstanceID ] )
metricInstanceNode = PythonMetricsCalculatorLogic.GetMRMLScene().GetNodeByID( metricInstanceID )
for role in metricTransformRoles:
transformNode = metricInstanceNode.GetRoleNode( role, metricInstanceNode.TransformRole )
transformNodeRelevant = relevantTransformNodes.IsItemPresent( transformNode )
if ( not transformNodeRelevant ):
irrelevantTransformMetrics.append( metricInstanceID )
for metricInstanceID in irrelevantTransformMetrics:
metricDict.pop( metricInstanceID )
def load(self,loadable):
""" Load the DICOM SEG object
"""
print('DICOM SEG load()')
labelNodes = vtk.vtkCollection()
uid = None
try:
uid = loadable.uid
print ('in load(): uid = ', uid)
except AttributeError:
return False
res = False
# make the output directory
outputDir = os.path.join(slicer.app.temporaryPath,"QIICR","SEG",loadable.uid)
try:
os.makedirs(outputDir)
except:
pass
# produces output label map files, one per segment, and information files with
# the terminology information for each segment
segFileName = slicer.dicomDatabase.fileForInstance(uid)
if segFileName is None:
print 'Failed to get the filename from the DICOM database for ', uid
return False
parameters = {
"inputSEGFileName": segFileName,
"outputDirName": outputDir,
}
seg2nrrd = None
try:
seg2nrrd = slicer.modules.seg2nrrd
except AttributeError:
print 'Unable to find CLI module SEG2NRRD, unable to load DICOM Segmentation object'
return False
cliNode = None
cliNode = slicer.cli.run(seg2nrrd, cliNode, parameters, wait_for_completion=True)
if cliNode.GetStatusString() != 'Completed':
print 'SEG2NRRD did not complete successfully, unable to load DICOM Segmentation'
return False
# create a new color node to be set up with the colors in these segments
colorLogic = slicer.modules.colors.logic()
segmentationColorNode = slicer.vtkMRMLColorTableNode()
segmentationColorNode.SetName(loadable.name)
segmentationColorNode.SetTypeToUser();
segmentationColorNode.SetHideFromEditors(0)
segmentationColorNode.SetAttribute("Category", "File")
segmentationColorNode.NamesInitialisedOff()
slicer.mrmlScene.AddNode(segmentationColorNode)
# also create a new terminology and associate it with this color node
colorLogic.CreateNewTerminology(segmentationColorNode.GetName())
import glob
numberOfSegments = len(glob.glob(os.path.join(outputDir,'*.nrrd')))
# resize the color table to include the segments plus 0 for the background
print ('number of segments = ',numberOfSegments)
segmentationColorNode.SetNumberOfColors(numberOfSegments + 1)
segmentationColorNode.SetColor(0, 'background', 0.0, 0.0, 0.0, 0.0)
seriesName = self.referencedSeriesName(loadable)
segmentNodes = []
for segmentId in range(numberOfSegments):
# load each of the segments' segmentations
# Initialize color and terminology from .info file
# See SEG2NRRD.cxx and EncodeSEG.cxx for how it's written.
# Format of the .info file (no leading spaces, labelNum, RGBColor, SegmentedPropertyCategory and
# SegmentedPropertyCategory are required):
# labelNum;RGB:R,G,B;SegmentedPropertyCategory:code,scheme,meaning;SegmentedPropertyType:code,scheme,meaning;SegmentedPropertyTypeModifier:code,scheme,meaning;AnatomicRegion:code,scheme,meaning;AnatomicRegionModifier:code,scheme,meaning
# R, G, B are 0-255 in file, but mapped to 0-1 for use in color node
# set defaults in case of missing fields, modifiers are optional
rgb = (0., 0., 0.)
colorIndex = segmentId + 1
categoryCode = 'T-D0050'
categoryCodingScheme = 'SRT'
categoryCodeMeaning = 'Tissue'
typeCode = 'T-D0050'
typeCodeMeaning = 'Tissue'
typeCodingScheme = 'SRT'
typeModCode = ''
typeModCodingScheme = ''
typeModCodeMeaning = ''
regionCode = 'T-D0010'
regionCodingScheme = 'SRT'
regionCodeMeaning = 'Entire Body'
regionModCode = ''
regionModCodingScheme = ''
regionModCodeMeaning = ''
infoFileName = os.path.join(outputDir,str(segmentId+1)+".info")
print ('Parsing info file', infoFileName)
with open(infoFileName, 'r') as infoFile:
for line in infoFile:
line = line.rstrip()
if len(line) == 0:
# empty line
continue
terms = line.split(';')
for term in terms:
# label number is the first thing, no key
if len(term.split(':')) == 1:
colorIndex = int(term)
else:
key = term.split(':')[0]
if key == "RGB":
rgb255 = term.split(':')[1].split(',')
rgb = map(lambda c: float(c) / 255., rgb255)
elif key == "AnatomicRegion":
# Get the Region information
region = term.split(':')[1]
# use partition to deal with any commas in the meaning
regionCode, sep, regionCodingSchemeAndCodeMeaning = region.partition(',')
regionCodingScheme, sep, regionCodeMeaning = regionCodingSchemeAndCodeMeaning.partition(',')
elif key == "AnatomicRegionModifier":
regionMod = term.split(':')[1]
regionModCode, sep, regionModCodingSchemeAndCodeMeaning = regionMod.partition(',')
regionModCodingScheme, sep, regionModCodeMeaning = regionModCodingSchemeAndCodeMeaning.partition(',')
elif key == "SegmentedPropertyCategory":
# Get the Category information
category = term.split(':')[1]
categoryCode, sep, categoryCodingSchemeAndCodeMeaning = category.partition(',')
categoryCodingScheme, sep, categoryCodeMeaning = categoryCodingSchemeAndCodeMeaning.partition(',')
elif key == "SegmentedPropertyType":
# Get the Type information
types = term.split(':')[1]
typeCode, sep, typeCodingSchemeAndCodeMeaning = types.partition(',')
typeCodingScheme, sep, typeCodeMeaning = typeCodingSchemeAndCodeMeaning.partition(',')
elif key == "SegmentedPropertyTypeModifier":
typeMod = term.split(':')[1]
typeModCode, sep, typeModCodingSchemeAndCodeMeaning = typeMod.partition(',')
typeModCodingScheme, sep, typeModCodeMeaning = typeModCodingSchemeAndCodeMeaning.partition(',')
# set the color name from the terminology
colorName = typeCodeMeaning
segmentationColorNode.SetColor(colorIndex, colorName, *rgb)
colorLogic.AddTermToTerminology(segmentationColorNode.GetName(), colorIndex,
categoryCode, categoryCodingScheme, categoryCodeMeaning,
typeCode, typeCodingScheme, typeCodeMeaning,
typeModCode, typeModCodingScheme, typeModCodeMeaning,
regionCode, regionCodingScheme, regionCodeMeaning,
regionModCode, regionModCodingScheme, regionModCodeMeaning)
# end of processing a line of terminology
infoFile.close()
#TODO: Create logic class that both CLI and this plugin uses so that we don't need to have temporary NRRD files and labelmap nodes
#if not hasattr(slicer.modules, 'segmentations'):
# load the segmentation volume file and name it for the reference series and segment color
labelFileName = os.path.join(outputDir,str(segmentId+1)+".nrrd")
segmentName = seriesName + "-" + colorName + "-label"
(success,labelNode) = slicer.util.loadLabelVolume(labelFileName,
properties = {'name' : segmentName},
returnNode=True)
segmentNodes.append(labelNode)
# point the label node to the color node we're creating
labelDisplayNode = labelNode.GetDisplayNode()
if labelDisplayNode == None:
print ('Warning: no label map display node for segment ',segmentId,', creating!')
labelNode.CreateDefaultDisplayNodes()
labelDisplayNode = labelNode.GetDisplayNode()
labelDisplayNode.SetAndObserveColorNodeID(segmentationColorNode.GetID())
# TODO: initialize referenced UID (and segment number?) attribute(s)
# create Subject hierarchy nodes for the loaded series
self.addSeriesInSubjectHierarchy(loadable, labelNode)
# create a combined (merge) label volume node (only if a segment was created)
if labelNode:
volumeLogic = slicer.modules.volumes.logic()
mergeNode = volumeLogic.CloneVolume(labelNode, seriesName + "-label")
combiner = slicer.vtkImageLabelCombine()
for segmentNode in segmentNodes:
combiner.SetInputConnection(0, mergeNode.GetImageDataConnection() )
combiner.SetInputConnection(1, segmentNode.GetImageDataConnection() )
combiner.Update()
mergeNode.GetImageData().DeepCopy( combiner.GetOutput() )
for segmentNode in segmentNodes:
segmentNode.Modified() # sets the MTime so the editor won't think they are older than mergeNode
# display the mergeNode
selectionNode = slicer.app.applicationLogic().GetSelectionNode()
selectionNode.SetReferenceActiveLabelVolumeID( mergeNode.GetID() )
slicer.app.applicationLogic().PropagateVolumeSelection(0)
# finalize the color node
segmentationColorNode.NamesInitialisedOn()
# TODO: the outputDir should be cleaned up
if hasattr(slicer.modules, 'segmentations'):
import vtkSlicerSegmentationsModuleLogic
import vtkSlicerSegmentationsModuleMRML
import vtkSegmentationCore
segmentationNode = vtkSlicerSegmentationsModuleMRML.vtkMRMLSegmentationNode()
segmentationNode.SetName(seriesName)
segmentationNode.AddNodeReferenceID('colorNodeID', segmentationColorNode.GetID())
slicer.mrmlScene.AddNode(segmentationNode)
segmentationDisplayNode = vtkSlicerSegmentationsModuleMRML.vtkMRMLSegmentationDisplayNode()
segmentationNode.SetAndObserveDisplayNodeID(segmentationDisplayNode.GetID())
slicer.mrmlScene.AddNode(segmentationDisplayNode)
segmentation = vtkSegmentationCore.vtkSegmentation()
segmentation.SetMasterRepresentationName(vtkSegmentationCore.vtkSegmentationConverter.GetSegmentationBinaryLabelmapRepresentationName())
segmentationNode.SetAndObserveSegmentation(segmentation)
self.addSeriesInSubjectHierarchy(loadable, segmentationNode)
colorID = 1
for segmentNode in segmentNodes:
segment = vtkSegmentationCore.vtkSegment()
segment.SetName(segmentNode.GetName())
segmentColor = [0,0,0,0]
segmentationColorNode.GetColor(colorID, segmentColor)
segment.SetDefaultColor(segmentColor[0:3])
colorID += 1
#TODO: when the logic class is created, this will need to be changed
logic = vtkSlicerSegmentationsModuleLogic.vtkSlicerSegmentationsModuleLogic()
orientedImage = logic.CreateOrientedImageDataFromVolumeNode(segmentNode)
segment.AddRepresentation(vtkSegmentationCore.vtkSegmentationConverter.GetSegmentationBinaryLabelmapRepresentationName(), orientedImage)
segmentation.AddSegment(segment)
segmentDisplayNode = segmentNode.GetDisplayNode()
slicer.mrmlScene.RemoveNode(segmentDisplayNode)
slicer.mrmlScene.RemoveNode(segmentNode)
segmentation.CreateRepresentation(vtkSegmentationCore.vtkSegmentationConverter.GetSegmentationClosedSurfaceRepresentationName(), True)
slicer.mrmlScene.RemoveNode(mergeNode)
return True
def processEvent(self,observee,event):
# TODO: use a timer to delay calculation and compress events
insideView = False
ras = [0.0,0.0,0.0]
xyz = [0.0,0.0,0.0]
sliceNode = None
if self.CrosshairNode:
insideView = self.CrosshairNode.GetCursorPositionRAS(ras)
sliceNode = self.CrosshairNode.GetCursorPositionXYZ(xyz)
sliceLogic = None
if sliceNode:
appLogic = slicer.app.applicationLogic()
if appLogic:
sliceLogic = appLogic.GetSliceLogic(sliceNode)
if not insideView or not sliceNode or not sliceLogic:
# reset all the readouts
self.viewerColor.text = ""
self.viewInfo.text = ""
layers = ('L', 'F', 'B')
for layer in layers:
self.layerNames[layer].setText( "" )
self.layerIJKs[layer].setText( "" )
self.layerValues[layer].setText( "" )
self.imageLabel.hide()
self.viewerColor.hide()
self.viewInfo.hide()
self.viewerFrame.hide()
self.showImageFrame.show()
return
self.viewerColor.show()
self.viewInfo.show()
self.viewerFrame.show()
self.showImageFrame.hide()
# populate the widgets
self.viewerColor.setText( " " )
rgbColor = sliceNode.GetLayoutColor();
color = qt.QColor.fromRgbF(rgbColor[0], rgbColor[1], rgbColor[2])
if hasattr(color, 'name'):
self.viewerColor.setStyleSheet('QLabel {background-color : %s}' % color.name())
self.viewInfo.text = self.generateViewDescription(xyz, ras, sliceNode, sliceLogic)
def _roundInt(value):
try:
return int(round(value))
except ValueError:
return 0
hasVolume = False
layerLogicCalls = (('L', sliceLogic.GetLabelLayer),
('F', sliceLogic.GetForegroundLayer),
('B', sliceLogic.GetBackgroundLayer))
for layer,logicCall in layerLogicCalls:
layerLogic = logicCall()
volumeNode = layerLogic.GetVolumeNode()
ijk = [0, 0, 0]
if volumeNode:
hasVolume = True
xyToIJK = layerLogic.GetXYToIJKTransform()
ijkFloat = xyToIJK.TransformDoublePoint(xyz)
ijk = [_roundInt(value) for value in ijkFloat]
self.layerNames[layer].setText(self.generateLayerName(layerLogic))
self.layerIJKs[layer].setText(self.generateIJKPixelDescription(ijk, layerLogic))
self.layerValues[layer].setText(self.generateIJKPixelValueDescription(ijk, layerLogic))
# collect information from displayable managers
displayableManagerCollection = vtk.vtkCollection()
if sliceNode:
sliceView = slicer.app.layoutManager().sliceWidget(sliceNode.GetLayoutName()).sliceView()
sliceView.getDisplayableManagers(displayableManagerCollection)
aggregatedDisplayableManagerInfo = ''
for index in range(displayableManagerCollection.GetNumberOfItems()):
displayableManager = displayableManagerCollection.GetItemAsObject(index)
infoString = displayableManager.GetDataProbeInfoStringForPosition(xyz)
if infoString != "":
aggregatedDisplayableManagerInfo += infoString + "<br>"
if aggregatedDisplayableManagerInfo != '':
self.displayableManagerInfo.text = '<html>' + aggregatedDisplayableManagerInfo + '</html>'
self.displayableManagerInfo.show()
else:
self.displayableManagerInfo.hide()
# set image
if (not slicer.mrmlScene.IsBatchProcessing()) and sliceLogic and hasVolume and self.showImage:
pixmap = self._createMagnifiedPixmap(
xyz, sliceLogic.GetBlend().GetOutputPort(), self.imageLabel.size, color)
if pixmap:
self.imageLabel.setPixmap(pixmap)
self.onShowImage(self.showImage)
if hasattr(self.frame.parent(), 'text'):
sceneName = slicer.mrmlScene.GetURL()
if sceneName != "":
self.frame.parent().text = "Data Probe: %s" % self.fitName(sceneName,nameSize=2*self.nameSize)
else:
self.frame.parent().text = "Data Probe"
import vtk
c = vtk.vtkCollection()
i = vtk.vtkCollectionIterator()
a1 = vtk.vtkActor()
a2 = vtk.vtkActor()
c.AddItem(a1)
c.AddItem(a2)
c.InitTraversal()
ai = c.GetNextItemAsObject()
matrix1 = vtk.vtkMatrix4x4()
print matrix1
s = vtk.vtkAssemblyPath()
s.AddNode(a1, matrix1)
s.AddNode(a2, matrix1)
s.InitTraversal()
ai = s.GetNextNode()
while ai:
ai = s.GetNextNode()
labeler = LeftRightParticleLabeling(input)
else:
labeler = LobeParticleLabeling(input)
output = labeler.execute()
if op.label_flag == True:
writer=vtk.vtkPolyDataWriter()
writer.SetInput(output['all'])
writer.SetFileTypeToBinary()
writer.SetFileName(op.output_prefix + op.output_suffix)
writer.Update()
else:
for tag in labeler.cluster_tags:
writer=vtk.vtkPolyDataWriter()
writer.SetInput(output[tag])
writer.SetFileName(op.output_prefix + '_%s%s' % (tag,op.output_suffix))
writer.SetFileTypeToBinary()
writer.Update()
else:
output_collection=vtk.vtkCollection()
cluster=ClusterParticles(input,output_collection)
cluster._method='DBSCAN'
cluster.execute()
for k in xrange(output_collection.GetNumberOfItems()):
writer=vtk.vtkPolyDataWriter()
writer.SetInput(output_collection.GetItemAsObject(k))
writer.SetFileName(op.output_prefix + '_cluster%03d%s' % (k,op.output_suffix) )
writer.SetFileTypeToBinary()
writer.Update()
def CalculateAllMetrics( peNodeID ):
if ( PythonMetricsCalculatorLogic.GetMRMLScene() == None or PythonMetricsCalculatorLogic.GetPerkEvaluatorLogic() == None ):
return
peNode = PythonMetricsCalculatorLogic.GetMRMLScene().GetNodeByID( peNodeID )
if ( peNode == None or peNode.GetTrackedSequenceBrowserNode() == None ):
return dict()
# Note that with the tracked sequence browser node, all of the frames should be synced.
# So, we just need to iterate through the master sequence node
masterSequenceNode = peNode.GetTrackedSequenceBrowserNode().GetMasterSequenceNode()
if ( masterSequenceNode is None ):
logging.warning( "PythonMetricsCalculatorLogic::CalculateAllMetrics: Sequence browser has no associated sequence nodes." )
return
if ( masterSequenceNode.GetIndexType() != slicer.vtkMRMLSequenceNode.NumericIndex ):
logging.warning( "PythonMetricsCalculatorLogic::CalculateAllMetrics: Cannot analyze sequence with non-numeric index type." )
return
if ( masterSequenceNode.GetNumberOfDataNodes() == 0 ):
return
proxyNodes = vtk.vtkCollection()
peNode.GetTrackedSequenceBrowserNode().GetAllProxyNodes( proxyNodes )
# Overall metrics
allMetrics = collections.OrderedDict()
allMetrics[ PythonMetricsCalculatorLogic.METRIC_VALUE ] = PythonMetricsCalculatorLogic.GetFreshMetrics( peNodeID )
# Task-specific metrics
trLogic = slicer.modules.transformrecorder.logic()
if ( peNode.GetComputeTaskSpecificMetrics() ):
if ( trLogic is None ):
logging.warning( "PythonMetricsCalculatorLogic::CalculateAllMetrics: Cannot create task-specific metrics. Perhaps the Transform Recorder logic cannot be found." )
return
messageSequenceNode = trLogic.GetMessageSequenceNode( peNode.GetTrackedSequenceBrowserNode() )
for itemNumber in range( messageSequenceNode.GetNumberOfDataNodes() ):
messageString = messageSequenceNode.GetNthDataNode( itemNumber ).GetAttribute( "Message" )
allMetrics[ messageString ] = PythonMetricsCalculatorLogic.GetFreshMetrics( peNodeID )
# Start at the beginning (but remember where we were)
originalItemNumber = peNode.GetTrackedSequenceBrowserNode().GetSelectedItemNumber()
peNode.GetTrackedSequenceBrowserNode().SetSelectedItemNumber( 0 )
peNode.GetTrackedSequenceBrowserNode().Modified() # Force update the proxy nodes
peNode.SetAnalysisState( 0 )
for i in range( masterSequenceNode.GetNumberOfDataNodes() ):
try:
time = float( masterSequenceNode.GetNthIndexValue( i ) )
except:
logging.warning( "PythonMetricsCalculatorLogic::CalculateAllMetrics: Index" + i + "has non-numeric index type." )
continue
if ( time < peNode.GetMarkBegin() or time > peNode.GetMarkEnd() ):
continue
# Update the scene so that all proxy nodes are at the appropriate frame
peNode.GetTrackedSequenceBrowserNode().SetSelectedItemNumber( i )
# Overall metrics
PythonMetricsCalculatorLogic.UpdateProxyNodeMetrics( allMetrics[ PythonMetricsCalculatorLogic.METRIC_VALUE ], proxyNodes, time )
# Task-specific metrics
# TODO
if ( peNode.GetComputeTaskSpecificMetrics() ):
if ( trLogic is not None ):
messageString = trLogic.GetPriorMessageString( peNode.GetTrackedSequenceBrowserNode(), str( time ) )
if ( messageString is not "" ):
PythonMetricsCalculatorLogic.UpdateProxyNodeMetrics( allMetrics[ messageString ], proxyNodes, time )
else:
logging.warning( "PythonMetricsCalculatorLogic::CalculateAllMetrics: Cannot determine task at index value " + str( time ) + "." )
# Update the progress
progressPercent = 100 * ( time - peNode.GetMarkBegin() ) / ( peNode.GetMarkEnd() - peNode.GetMarkBegin() )
peNode.SetAnalysisState( int( progressPercent ) )
if ( peNode.GetAnalysisState() < 0 ): # If the user hits cancel
break
if ( peNode.GetAnalysisState() >= 0 ): # If the user has not hit cancel
PythonMetricsCalculatorLogic.OutputAllMetricsToMetricsTable( peNode.GetMetricsTableNode(), allMetrics )
peNode.GetTrackedSequenceBrowserNode().SetSelectedItemNumber( originalItemNumber ) # Scene automatically updated
peNode.SetAnalysisState( 0 )
def __init__(self, fiducialListNode, dl = 0.5):
import numpy
self.dl = dl # desired world space step size (in mm)
self.dt = dl # current guess of parametric stepsize
self.fids = fiducialListNode
# hermite interpolation functions
self.h00 = lambda t: 2*t**3 - 3*t**2 + 1
self.h10 = lambda t: t**3 - 2*t**2 + t
self.h01 = lambda t:-2*t**3 + 3*t**2
self.h11 = lambda t: t**3 - t**2
# n is the number of control points in the piecewise curve
if self.fids.GetClassName() == "vtkMRMLAnnotationHierarchyNode":
# slicer4 style hierarchy nodes
collection = vtk.vtkCollection()
self.fids.GetChildrenDisplayableNodes(collection)
self.n = collection.GetNumberOfItems()
if self.n == 0:
return
self.p = numpy.zeros((self.n,3))
for i in xrange(self.n):
f = collection.GetItemAsObject(i)
coords = [0,0,0]
f.GetFiducialCoordinates(coords)
self.p[i] = coords
elif self.fids.GetClassName() == "vtkMRMLMarkupsFiducialNode":
# slicer4 Markups node
self.n = self.fids.GetNumberOfFiducials()
n = self.n
if n == 0:
return
# get fiducial positions
# sets self.p
self.p = numpy.zeros((n,3))
for i in xrange(n):
coord = [0.0, 0.0, 0.0]
self.fids.GetNthFiducialPosition(i, coord)
self.p[i] = coord
else:
# slicer3 style fiducial lists
self.n = self.fids.GetNumberOfFiducials()
n = self.n
if n == 0:
return
# get control point data
# sets self.p
self.p = numpy.zeros((n,3))
for i in xrange(n):
self.p[i] = self.fids.GetNthFiducialXYZ(i)
# calculate the tangent vectors
# - fm is forward difference
# - m is average of in and out vectors
# - first tangent is out vector, last is in vector
# - sets self.m
n = self.n
fm = numpy.zeros((n,3))
for i in xrange(0,n-1):
fm[i] = self.p[i+1] - self.p[i]
self.m = numpy.zeros((n,3))
for i in xrange(1,n-1):
self.m[i] = (fm[i-1] + fm[i]) / 2.
self.m[0] = fm[0]
self.m[n-1] = fm[n-2]
self.path = [self.p[0]]
self.calculatePath()
def __init__( self ): self.realTimeMetrics = dict() self.realTimeMetricsTable = None self.realTimeProxyNodeCollection = vtk.vtkCollection()
def execute(self):
chest_region = list()
chest_type = list()
output_collection = vtk.vtkCollection()
left_right_splitter = LeftRightParticleLabeling(input)
leftright_output=left_right_splitter.execute()
#Right splitter
print "Right splitter"
cluster=ClusterParticles(leftright_output['right'],output_collection,feature_extractor=self.feature_extractor_right)
cluster._number_of_clusters=3
#cluster._method='MiniBatchKMeans'
cluster._method='KMeans'
cluster.execute()
points = vtk_to_numpy(leftright_output['right'].GetPoints().GetData())
p_centroids = np.zeros([3,3])
for ii,ll in enumerate(cluster._unique_labels):
p_centroids[ii,:]=np.mean(points[cluster._labels==ll,:],axis=0)
#Sort centroids and get values
sortval = np.sort(p_centroids[:,2])
indices = np.array(range(0,cluster._number_of_clusters))
region_labels=['RLL','RML','RUL']
region_values=[6,5,4]
for ii,ll in enumerate(cluster._unique_labels):
idx_region = indices[sortval==p_centroids[ii,2]][0]
self.cluster_tags.append(region_labels[idx_region])
chest_region.append(region_values[idx_region])
chest_type.append(3)
#Left splitter
print "Left splitter"
print leftright_output['left'].GetNumberOfPoints()
cluster=ClusterParticles(leftright_output['left'],output_collection,feature_extractor=self.feature_extractor_left)
cluster._number_of_clusters=2
#cluster._method='MiniBatchKMeans'
cluster._method='KMeans'
cluster.execute()
print "Done left clustering"
points = vtk_to_numpy(leftright_output['left'].GetPoints().GetData())
p_centroids = np.zeros([2,3])
for ii,ll in enumerate(cluster._unique_labels):
p_centroids[ii,:]=np.mean(points[cluster._labels==ll,:],axis=0)
#Sort centroids and get values
sortval = np.sort(p_centroids[:,2])
indices = np.array(range(0,cluster._number_of_clusters))
region_labels=['LLL','LUL']
region_values=[8,7]
for ii,ll in enumerate(cluster._unique_labels):
idx_region = indices[sortval==p_centroids[ii,2]][0]
self.cluster_tags.append(region_labels[idx_region])
chest_region.append(region_values[idx_region])
chest_type.append(3)
append=vtk.vtkAppendPolyData()
for k,tag,cr,ct in zip([0,1],self.cluster_tags,chest_region,chest_type):
self._out_vtk[tag]=output_collection.GetItemAsObject(k)
chest_region_arr = vtk.vtkUnsignedCharArray()
chest_region_arr.SetName('ChestRegion')
chest_type_arr = vtk.vtkUnsignedCharArray()
chest_type_arr.SetName('ChestType')
n_p = self._out_vtk[tag].GetNumberOfPoints()
chest_region_arr.SetNumberOfTuples(n_p)
chest_type_arr.SetNumberOfTuples(n_p)
for ii in xrange(self._out_vtk[tag].GetNumberOfPoints()):
chest_region_arr.SetValue(ii,cr)
chest_type_arr.SetValue(ii,ct)
self._out_vtk[tag].GetPointData().AddArray(chest_region_arr)
self._out_vtk[tag].GetPointData().AddArray(chest_type_arr)
append.AddInput(self._out_vtk[tag])
append.Update()
self._out_vtk['all']=append.GetOutput()
return self._out_vtk
