def showVolumeFromHierarchyNode(self, hierarchyNode): volume = self.loadVolumeFromHierarchyNode(hierarchyNode) if not volume: print "No volume" return if volume.IsA('vtkMRMLVolumeNode'): if not volume.GetDisplayNodeID(): displayNode = None if volume.IsA('vtkMRMLScalarVolumeNode'): displayNode = slicer.vtkMRMLScalarVolumeDisplayNode() displayNode.SetAndObserveColorNodeID("vtkMRMLColorTableNodeGrey") if volume.IsA('vtkMRMLVectorVolumeNode'): displayNode = slicer.vtkMRMLVectorVolumeDisplayNode() displayNode.SetAndObserveColorNodeID("vtkMRMLColorTableNodeGrey") if displayNode: slicer.mrmlScene.AddNode(displayNode) volume.SetAndObserveDisplayNodeID(displayNode.GetID()) else: volume.GetDisplayNode().SetAndObserveColorNodeID("vtkMRMLColorTableNodeGrey") selectionNode = slicer.app.applicationLogic().GetSelectionNode() selectionNode.SetReferenceActiveVolumeID(volume.GetID()) slicer.app.applicationLogic().PropagateVolumeSelection(0)
def CreateNewVolume(self, trial_num, numSamp, labelType): imageSize=[64, 64, 64] imageSpacing=[1.0, 1.0, 1.0] voxelType=vtk.VTK_UNSIGNED_CHAR # Create an empty image volume imageData=vtk.vtkImageData() imageData.SetDimensions(imageSize) imageData.AllocateScalars(voxelType, 1) thresholder=vtk.vtkImageThreshold() thresholder.SetInputData(imageData) thresholder.SetInValue(0) thresholder.SetOutValue(0) # Create volume node volumeNode=slicer.vtkMRMLScalarVolumeNode() volumeNode.SetSpacing(imageSpacing) volumeNode.SetImageDataConnection(thresholder.GetOutputPort()) # Add volume to scene slicer.mrmlScene.AddNode(volumeNode) displayNode=slicer.vtkMRMLScalarVolumeDisplayNode() slicer.mrmlScene.AddNode(displayNode) colorNode = slicer.util.getNode('Grey') displayNode.SetAndObserveColorNodeID(colorNode.GetID()) volumeNode.SetAndObserveDisplayNodeID(displayNode.GetID()) volumeNode.CreateDefaultStorageNode() # name volume volume_name = str(labelType)+'_trial_'+str(trial_num)+'_nsamp_'+str(numSamp) volumeNode.SetName(volume_name) return volumeNode
def setupScene(self): logging.info("UltraSound.setupScene") # live ultrasound liveUltrasoundNodeName = self.guideletParent.parameterNode.GetParameter("LiveUltrasoundNodeName") self.liveUltrasoundNode_Reference = slicer.util.getNode(liveUltrasoundNodeName) if not self.liveUltrasoundNode_Reference: imageSpacing = [0.2, 0.2, 0.2] # Create an empty image volume imageData = vtk.vtkImageData() imageData.SetDimensions(self.DEFAULT_IMAGE_SIZE) imageData.AllocateScalars(vtk.VTK_UNSIGNED_CHAR, 1) thresholder = vtk.vtkImageThreshold() thresholder.SetInputData(imageData) thresholder.SetInValue(0) thresholder.SetOutValue(0) # Create volume node self.liveUltrasoundNode_Reference = slicer.vtkMRMLScalarVolumeNode() self.liveUltrasoundNode_Reference.SetName(liveUltrasoundNodeName) self.liveUltrasoundNode_Reference.SetSpacing(imageSpacing) self.liveUltrasoundNode_Reference.SetImageDataConnection(thresholder.GetOutputPort()) # Add volume to scene slicer.mrmlScene.AddNode(self.liveUltrasoundNode_Reference) displayNode = slicer.vtkMRMLScalarVolumeDisplayNode() slicer.mrmlScene.AddNode(displayNode) colorNode = slicer.util.getNode("Grey") displayNode.SetAndObserveColorNodeID(colorNode.GetID()) self.liveUltrasoundNode_Reference.SetAndObserveDisplayNodeID(displayNode.GetID()) # self.liveUltrasoundNode_Reference.CreateDefaultStorageNode() self.setupResliceDriver()
def onSelectOutput(self): merge=self.outputSelector.currentNode() master=self.masterSelector.currentNode() if master and merge: if not merge.GetImageData(): print("create Output Volume") imd=vtk.vtkImageData() mim=master.GetImageData() imd.SetDimensions(mim.GetDimensions()) imd.SetSpacing(mim.GetSpacing()) imd.SetOrigin(mim.GetOrigin()) # if mim.GetScalarTypeMin()>=0: #unsigned # mim.SetScalarType(mim.GetScalarType()-1) # imd.SetScalarType(mim.GetScalarType()) IJK=vtk.vtkMatrix4x4() master.GetIJKToRASMatrix(IJK) merge.SetIJKToRASMatrix(IJK) nd=slicer.vtkMRMLScalarVolumeDisplayNode() slicer.mrmlScene.AddNode(nd) merge.AddAndObserveDisplayNodeID(nd.GetID()) merge.SetAndObserveImageData(imd) warnings = self.checkForVolumeWarnings(master,merge) if warnings != "": self.errorDialog( "Warning: %s" % warnings ) self.outputSelector.setCurrentNode(None)
def setupScene(self): logging.info("UltraSound.setupScene") ''' ReferenceToRas transform is used in almost all IGT applications. Reference is the coordinate system of a tool fixed to the patient. Tools are tracked relative to Reference, to compensate for patient motion. ReferenceToRas makes sure that everything is displayed in an anatomical coordinate system, i.e. R, A, and S (Right, Anterior, and Superior) directions in Slicer are correct relative to any images or tracked tools displayed. ReferenceToRas is needed for initialization, so we need to set it up before calling Guidelet.setupScene(). ''' if self.referenceToRas is None or ( self.referenceToRas and slicer.mrmlScene.GetNodeByID( self.referenceToRas.GetID()) is None): self.referenceToRas = slicer.mrmlScene.GetFirstNodeByName( 'ReferenceToRas') if self.referenceToRas is None: self.referenceToRas = slicer.vtkMRMLLinearTransformNode() self.referenceToRas.SetName("ReferenceToRas") m = self.guideletParent.logic.readTransformFromSettings( 'ReferenceToRas', self.guideletParent.configurationName) if m is None: m = self.guideletParent.logic.createMatrixFromString( '1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1') self.referenceToRas.SetMatrixTransformToParent(m) slicer.mrmlScene.AddNode(self.referenceToRas) # live ultrasound liveUltrasoundNodeName = self.guideletParent.parameterNode.GetParameter( 'LiveUltrasoundNodeName') self.liveUltrasoundNode_Reference = slicer.mrmlScene.GetFirstNodeByName( liveUltrasoundNodeName) if not self.liveUltrasoundNode_Reference: imageSpacing = [0.2, 0.2, 0.2] # Create an empty image volume imageData = vtk.vtkImageData() imageData.SetDimensions(self.DEFAULT_IMAGE_SIZE) imageData.AllocateScalars(vtk.VTK_UNSIGNED_CHAR, 1) thresholder = vtk.vtkImageThreshold() thresholder.SetInputData(imageData) thresholder.SetInValue(0) thresholder.SetOutValue(0) # Create volume node self.liveUltrasoundNode_Reference = slicer.vtkMRMLScalarVolumeNode( ) self.liveUltrasoundNode_Reference.SetName(liveUltrasoundNodeName) self.liveUltrasoundNode_Reference.SetSpacing(imageSpacing) self.liveUltrasoundNode_Reference.SetImageDataConnection( thresholder.GetOutputPort()) # Add volume to scene slicer.mrmlScene.AddNode(self.liveUltrasoundNode_Reference) displayNode = slicer.vtkMRMLScalarVolumeDisplayNode() slicer.mrmlScene.AddNode(displayNode) colorNode = slicer.mrmlScene.GetFirstNodeByName('Grey') displayNode.SetAndObserveColorNodeID(colorNode.GetID()) self.liveUltrasoundNode_Reference.SetAndObserveDisplayNodeID( displayNode.GetID()) self.setupResliceDriver()
def setupScene(self): logging.info("UltraSound.setupScene") ''' ReferenceToRas transform is used in almost all IGT applications. Reference is the coordinate system of a tool fixed to the patient. Tools are tracked relative to Reference, to compensate for patient motion. ReferenceToRas makes sure that everything is displayed in an anatomical coordinate system, i.e. R, A, and S (Right, Anterior, and Superior) directions in Slicer are correct relative to any images or tracked tools displayed. ReferenceToRas is needed for initialization, so we need to set it up before calling Guidelet.setupScene(). ''' if self.referenceToRas is None or (self.referenceToRas and slicer.mrmlScene.GetNodeByID(self.referenceToRas.GetID()) is None): self.referenceToRas = slicer.mrmlScene.GetFirstNodeByName('ReferenceToRas') if self.referenceToRas is None: self.referenceToRas = slicer.vtkMRMLLinearTransformNode() self.referenceToRas.SetName("ReferenceToRas") m = self.guideletParent.logic.readTransformFromSettings('ReferenceToRas', self.guideletParent.configurationName) if m is None: m = self.guideletParent.logic.createMatrixFromString('1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1') self.referenceToRas.SetMatrixTransformToParent(m) slicer.mrmlScene.AddNode(self.referenceToRas) # live ultrasound liveUltrasoundNodeName = self.guideletParent.parameterNode.GetParameter('LiveUltrasoundNodeName') self.liveUltrasoundNode_Reference = slicer.mrmlScene.GetFirstNodeByName(liveUltrasoundNodeName) if not self.liveUltrasoundNode_Reference: imageSpacing=[0.2, 0.2, 0.2] # Create an empty image volume imageData=vtk.vtkImageData() imageData.SetDimensions(self.DEFAULT_IMAGE_SIZE) imageData.AllocateScalars(vtk.VTK_UNSIGNED_CHAR, 1) thresholder=vtk.vtkImageThreshold() thresholder.SetInputData(imageData) thresholder.SetInValue(0) thresholder.SetOutValue(0) # Create volume node self.liveUltrasoundNode_Reference=slicer.vtkMRMLScalarVolumeNode() self.liveUltrasoundNode_Reference.SetName(liveUltrasoundNodeName) self.liveUltrasoundNode_Reference.SetSpacing(imageSpacing) self.liveUltrasoundNode_Reference.SetImageDataConnection(thresholder.GetOutputPort()) # Add volume to scene slicer.mrmlScene.AddNode(self.liveUltrasoundNode_Reference) displayNode=slicer.vtkMRMLScalarVolumeDisplayNode() slicer.mrmlScene.AddNode(displayNode) colorNode = slicer.mrmlScene.GetFirstNodeByName('Grey') displayNode.SetAndObserveColorNodeID(colorNode.GetID()) self.liveUltrasoundNode_Reference.SetAndObserveDisplayNodeID(displayNode.GetID()) self.plusRemoteNode = slicer.mrmlScene.GetFirstNodeByClass('vtkMRMLPlusRemoteNode') if self.plusRemoteNode is None: self.plusRemoteNode = slicer.vtkMRMLPlusRemoteNode() self.plusRemoteNode.SetName("PlusRemoteNode") slicer.mrmlScene.AddNode(self.plusRemoteNode) self.plusRemoteNode.AddObserver(slicer.vtkMRMLPlusRemoteNode.RecordingStartedEvent, self.recordingCommandCompleted) self.plusRemoteNode.AddObserver(slicer.vtkMRMLPlusRemoteNode.RecordingCompletedEvent, self.recordingCommandCompleted) self.plusRemoteNode.SetAndObserveOpenIGTLinkConnectorNode(self.guideletParent.connectorNode) self.setupResliceDriver()
def __init__(self, slicerVersion): self.volume = slicer.vtkMRMLScalarVolumeNode() self.display = slicer.vtkMRMLScalarVolumeDisplayNode() if slicerVersion == 4: self.fiducialList = slicer.vtkMRMLAnnotationHierarchyNode() self.newFiducial = slicer.vtkMRMLAnnotationFiducialNode() else: self.fiducialList = slicer.vtkMRMLFiducialListNode() self.newFiducial = slicer.vtkMRMLFiducial()
def fit(self, atlasName='DevelopmentalAtlas', range=[0, 5]): """ Create a volume of the slope across the range of years. least squares notation from: http://docs.scipy.org/doc/numpy/reference/generated/numpy.linalg.lstsq.html """ ijkToRAS = vtk.vtkMatrix4x4() atlasVolume = slicer.util.getNode(atlasName) atlasVolume.GetIJKToRASMatrix(ijkToRAS) fitVolume = slicer.vtkMRMLScalarVolumeNode() fitVolume.SetIJKToRASMatrix(ijkToRAS) ageRange = str(range).replace('[', '(').replace(']', ')') fitName = 'Slope_' + ageRange + '_' + atlasName fitVolume.SetName(fitName) colorNode = slicer.vtkMRMLColorTableNode() colorNode.SetTypeToGrey() slicer.mrmlScene.AddNode(colorNode) fitDisplayNode = slicer.vtkMRMLScalarVolumeDisplayNode() fitDisplayNode.SetAutoWindowLevel(False) fitDisplayNode.SetWindow(10) fitDisplayNode.SetLevel(45) slicer.mrmlScene.AddNode(fitDisplayNode) fitDisplayNode.SetAndObserveColorNodeID(colorNode.GetID()) fitImage = vtk.vtkImageData() fitImage.ShallowCopy(atlasVolume.GetImageData()) fitImage.AllocateScalars(vtk.VTK_FLOAT, 1) fitVolume.SetAndObserveImageData(fitImage) slicer.mrmlScene.AddNode(fitVolume) fitVolume.SetAndObserveDisplayNodeID(fitDisplayNode.GetID()) fitArray = slicer.util.array(fitName) atlasArray = slicer.util.array(atlasName) # make a regression against a scale more or less like the multivolume plot timePoints = self.agesInYears[range[0]:range[1]] timePoints = map(lambda x: x * 1000., timePoints) A = numpy.vstack([timePoints, numpy.ones(len(timePoints))]).T slices, rows, columns, frames = atlasArray.shape for slice in xrange(slices): for row in xrange(rows): for column in xrange(columns): if atlasArray[slice, row, column, 0] == 0: fit = 0 else: series = atlasArray[slice, row, column][range[0]:range[1]] slope, intercept = numpy.linalg.lstsq(A, series)[0] fit = -1. * numpy.degrees(numpy.arctan(slope)) fitArray[slice, row, column] = fit return fitVolume
def fit(self,atlasName='DevelopmentalAtlas', range=[0,5]): """ Create a volume of the slope across the range of years. least squares notation from: http://docs.scipy.org/doc/numpy/reference/generated/numpy.linalg.lstsq.html """ ijkToRAS = vtk.vtkMatrix4x4() atlasVolume = slicer.util.getNode(atlasName) atlasVolume.GetIJKToRASMatrix(ijkToRAS) fitVolume = slicer.vtkMRMLScalarVolumeNode() fitVolume.SetIJKToRASMatrix(ijkToRAS) ageRange = str(range).replace('[','(').replace(']',')') fitName = 'Slope_'+ageRange+'_'+atlasName fitVolume.SetName(fitName) colorNode = slicer.vtkMRMLColorTableNode() colorNode.SetTypeToGrey() slicer.mrmlScene.AddNode(colorNode) fitDisplayNode = slicer.vtkMRMLScalarVolumeDisplayNode() fitDisplayNode.SetAutoWindowLevel(False) fitDisplayNode.SetWindow(10) fitDisplayNode.SetLevel(45) slicer.mrmlScene.AddNode(fitDisplayNode) fitDisplayNode.SetAndObserveColorNodeID(colorNode.GetID()) fitImage = vtk.vtkImageData() fitImage.ShallowCopy(atlasVolume.GetImageData()) fitImage.AllocateScalars(vtk.VTK_FLOAT, 1) fitVolume.SetAndObserveImageData(fitImage) slicer.mrmlScene.AddNode(fitVolume) fitVolume.SetAndObserveDisplayNodeID(fitDisplayNode.GetID()) fitArray = slicer.util.array(fitName) atlasArray = slicer.util.array(atlasName) # make a regression against a scale more or less like the multivolume plot timePoints = self.agesInYears[range[0]:range[1]] timePoints = map(lambda x : x * 1000., timePoints) A = numpy.vstack([timePoints, numpy.ones(len(timePoints))]).T slices, rows, columns, frames = atlasArray.shape for slice in xrange(slices): for row in xrange(rows): for column in xrange(columns): if atlasArray[slice, row, column, 0] == 0: fit = 0 else: series = atlasArray[slice, row, column][range[0]:range[1]] slope, intercept = numpy.linalg.lstsq(A, series)[0] fit = -1. * numpy.degrees(numpy.arctan(slope)) fitArray[slice, row, column] = fit return fitVolume
def setupScene(self): layoutManager = slicer.app.layoutManager() # live ultrasound liveUltrasoundNodeName = self.guideletParent.parameterNode.GetParameter('LiveUltrasoundNodeName') self.liveUltrasoundNode_Reference = slicer.util.getNode(liveUltrasoundNodeName) if not self.liveUltrasoundNode_Reference: imageSize=[800, 600, 1] imageSpacing=[0.2, 0.2, 0.2] # Create an empty image volume imageData=vtk.vtkImageData() imageData.SetDimensions(imageSize) imageData.AllocateScalars(vtk.VTK_UNSIGNED_CHAR, 1) thresholder=vtk.vtkImageThreshold() thresholder.SetInputData(imageData) thresholder.SetInValue(0) thresholder.SetOutValue(0) # Create volume node self.liveUltrasoundNode_Reference=slicer.vtkMRMLScalarVolumeNode() self.liveUltrasoundNode_Reference.SetName(liveUltrasoundNodeName) self.liveUltrasoundNode_Reference.SetSpacing(imageSpacing) self.liveUltrasoundNode_Reference.SetImageDataConnection(thresholder.GetOutputPort()) # Add volume to scene slicer.mrmlScene.AddNode(self.liveUltrasoundNode_Reference) displayNode=slicer.vtkMRMLScalarVolumeDisplayNode() slicer.mrmlScene.AddNode(displayNode) colorNode = slicer.util.getNode('Grey') displayNode.SetAndObserveColorNodeID(colorNode.GetID()) self.liveUltrasoundNode_Reference.SetAndObserveDisplayNodeID(displayNode.GetID()) #self.liveUltrasoundNode_Reference.CreateDefaultStorageNode() # Show ultrasound in red view. redSlice = layoutManager.sliceWidget('Red') redSliceLogic = redSlice.sliceLogic() redSliceLogic.GetSliceCompositeNode().SetBackgroundVolumeID(self.liveUltrasoundNode_Reference.GetID()) # Set up volume reslice driver. resliceLogic = slicer.modules.volumereslicedriver.logic() if resliceLogic: redNode = slicer.util.getNode('vtkMRMLSliceNodeRed') # Typically the image is zoomed in, therefore it is faster if the original resolution is used # on the 3D slice (and also we can show the full image and not the shape and size of the 2D view) redNode.SetSliceResolutionMode(slicer.vtkMRMLSliceNode.SliceResolutionMatchVolumes) resliceLogic.SetDriverForSlice(self.liveUltrasoundNode_Reference.GetID(), redNode) resliceLogic.SetModeForSlice(6, redNode) # Transverse mode, default for PLUS ultrasound. resliceLogic.SetFlipForSlice(False, redNode) resliceLogic.SetRotationForSlice(180, redNode) redSliceLogic.FitSliceToAll() else: logging.warning('Logic not found for Volume Reslice Driver') self.liveUltrasoundNode_Reference.SetAndObserveTransformNodeID(self.guideletParent.ReferenceToRas.GetID())
def DisplayVolumeNode(self, volumeNode, name="Volume"): existingVolumeNode = slicer.util.getNode(name) if not existingVolumeNode: displayNode = slicer.vtkMRMLScalarVolumeDisplayNode() displayNode.SetAndObserveColorNodeID("vtkMRMLColorTableNodeGrey") volumeNode.SetName(name) slicer.mrmlScene.AddNode(volumeNode) slicer.mrmlScene.AddNode(displayNode) volumeNode.SetAndObserveDisplayNodeID(displayNode.GetID()) else: existingVolumeNode.SetImageData(volumeNode.GetImageData()) existingVolumeNode.SetIJKToRAS(volumeNode.GetIJKToRAS()) return
def DisplayVolumeNode(self, volumeNode, name="Volume"): existingVolumeNode=slicer.util.getNode(name) if not existingVolumeNode: displayNode=slicer.vtkMRMLScalarVolumeDisplayNode() displayNode.SetAndObserveColorNodeID("vtkMRMLColorTableNodeGrey") volumeNode.SetName(name) slicer.mrmlScene.AddNode(volumeNode) slicer.mrmlScene.AddNode(displayNode) volumeNode.SetAndObserveDisplayNodeID(displayNode.GetID()) else: existingVolumeNode.SetImageData(volumeNode.GetImageData()) existingVolumeNode.SetIJKToRAS(volumeNode.GetIJKToRAS()) return
def DisplayImageData(self, imageData_Ijk, referenceVolumeNode_Ras, name="ImageNode"): volumeNode_Ras=slicer.util.getNode(name) if (not volumeNode_Ras): displayNode=slicer.vtkMRMLScalarVolumeDisplayNode() displayNode.SetAndObserveColorNodeID("vtkMRMLColorTableNodeGrey") volumeNode_Ras=slicer.vtkMRMLScalarVolumeNode() volumeNode_Ras.SetName(name) slicer.mrmlScene.AddNode(volumeNode_Ras) slicer.mrmlScene.AddNode(displayNode) volumeNode_Ras.SetAndObserveDisplayNodeID(displayNode.GetID()) volumeNode_Ras.SetAndObserveImageData(imageData_Ijk) rasToIjkMatrix=vtk.vtkMatrix4x4() referenceVolumeNode_Ras.GetRASToIJKMatrix(rasToIjkMatrix) volumeNode_Ras.SetRASToIJKMatrix(rasToIjkMatrix) return volumeNode_Ras
def CreateNewLabelVolume(self,name): """ Creates a new labelmap volume with the inputted name """ # Create labelmap node labelNode=slicer.vtkMRMLLabelMapVolumeNode() labelNode.SetName(name) # Add volume to scene slicer.mrmlScene.AddNode(labelNode) displayNode=slicer.vtkMRMLScalarVolumeDisplayNode() slicer.mrmlScene.AddNode(displayNode) colorNode = slicer.util.getNode('Grey') displayNode.SetAndObserveColorNodeID(colorNode.GetID()) labelNode.SetAndObserveDisplayNodeID(displayNode.GetID()) labelNode.CreateDefaultStorageNode() return labelNode
def DisplayImageData(self, imageData_Ijk, referenceVolumeNode_Ras, name="ImageNode"): volumeNode_Ras = slicer.util.getNode(name) if (not volumeNode_Ras): displayNode = slicer.vtkMRMLScalarVolumeDisplayNode() displayNode.SetAndObserveColorNodeID("vtkMRMLColorTableNodeGrey") volumeNode_Ras = slicer.vtkMRMLScalarVolumeNode() volumeNode_Ras.SetName(name) slicer.mrmlScene.AddNode(volumeNode_Ras) slicer.mrmlScene.AddNode(displayNode) volumeNode_Ras.SetAndObserveDisplayNodeID(displayNode.GetID()) volumeNode_Ras.SetAndObserveImageData(imageData_Ijk) rasToIjkMatrix = vtk.vtkMatrix4x4() referenceVolumeNode_Ras.GetRASToIJKMatrix(rasToIjkMatrix) volumeNode_Ras.SetRASToIJKMatrix(rasToIjkMatrix) return volumeNode_Ras
def setupScene(self): logging.info("UltraSound.setupScene") # live ultrasound liveUltrasoundNodeName = self.guideletParent.parameterNode.GetParameter( 'LiveUltrasoundNodeName') self.liveUltrasoundNode_Reference = slicer.util.getNode( liveUltrasoundNodeName) if not self.liveUltrasoundNode_Reference: imageSpacing = [0.2, 0.2, 0.2] # Create an empty image volume imageData = vtk.vtkImageData() imageData.SetDimensions(self.DEFAULT_IMAGE_SIZE) imageData.AllocateScalars(vtk.VTK_UNSIGNED_CHAR, 1) thresholder = vtk.vtkImageThreshold() thresholder.SetInputData(imageData) thresholder.SetInValue(0) thresholder.SetOutValue(0) # Create volume node self.liveUltrasoundNode_Reference = slicer.vtkMRMLScalarVolumeNode( ) self.liveUltrasoundNode_Reference.SetName(liveUltrasoundNodeName) self.liveUltrasoundNode_Reference.SetSpacing(imageSpacing) self.liveUltrasoundNode_Reference.SetImageDataConnection( thresholder.GetOutputPort()) # Add volume to scene slicer.mrmlScene.AddNode(self.liveUltrasoundNode_Reference) displayNode = slicer.vtkMRMLScalarVolumeDisplayNode() slicer.mrmlScene.AddNode(displayNode) colorNode = slicer.util.getNode('Grey') displayNode.SetAndObserveColorNodeID(colorNode.GetID()) self.liveUltrasoundNode_Reference.SetAndObserveDisplayNodeID( displayNode.GetID()) #self.liveUltrasoundNode_Reference.CreateDefaultStorageNode() self.setupResliceDriver()
def takeUSSnapshot2(self,name): snapshotDisp = slicer.vtkMRMLModelDisplayNode() slicer.mrmlScene.AddNode(snapshotDisp) snapshotDisp.SetScene(slicer.mrmlScene) snapshotDisp.SetDisableModifiedEvent(1) snapshotDisp.SetOpacity(1.0) snapshotDisp.SetColor(1.0, 1.0, 1.0) snapshotDisp.SetAmbient(1.0) snapshotDisp.SetBackfaceCulling(0) snapshotDisp.SetDiffuse(0) snapshotDisp.SetSaveWithScene(0) snapshotDisp.SetDisableModifiedEvent(0) snapshotModel = slicer.vtkMRMLModelNode() snapshotModel.SetName(name) snapshotModel.SetDescription("Live Ultrasound Snapshot") snapshotModel.SetScene(slicer.mrmlScene) snapshotModel.SetAndObserveDisplayNodeID(snapshotDisp.GetID()) snapshotModel.SetHideFromEditors(0) snapshotModel.SetSaveWithScene(0) slicer.mrmlScene.AddNode(snapshotModel) image_RAS = slicer.util.getNode("Image_Image") dim = [0, 0, 0] imageData = image_RAS.GetImageData() imageData.GetDimensions(dim) plane = vtk.vtkPlaneSource() plane.Update() snapshotModel.SetAndObservePolyData(plane.GetOutput()) slicePolyData = snapshotModel.GetPolyData() slicePoints = slicePolyData.GetPoints() # In parent transform is saved the ReferenceToRAS transform parentTransform = vtk.vtkTransform() parentTransform.Identity() if not image_RAS.GetParentTransformNode() == None: parentMatrix = vtk.vtkMatrix4x4() parentTransformNode = image_RAS.GetParentTransformNode() parentTransformNode.GetMatrixTransformToWorld(parentMatrix) # aux=parentTransform.GetMatrix() # aux.DeepCopy(parentMatrix) # parentTransform.Update() parentTransform.SetMatrix(parentMatrix) inImageTransform = vtk.vtkTransform() inImageTransform.Identity() image_RAS.GetIJKToRASMatrix(inImageTransform.GetMatrix()) tImageToRAS = vtk.vtkTransform() tImageToRAS.Identity() tImageToRAS.PostMultiply() tImageToRAS.Concatenate(inImageTransform) tImageToRAS.Concatenate(parentTransform) tImageToRAS.Update() point1Image = [0.0, 0.0, 0.0, 1.0] point2Image = [dim[0], 0.0, 0.0, 1.0] point3Image = [0.0, dim[1], 0.0, 1.0] point4Image = [dim[0], dim[1], 0.0, 1.0] point1RAS = [0.0, 0.0, 0.0, 0.0] point2RAS = [0.0, 0.0, 0.0, 0.0] point3RAS = [0.0, 0.0, 0.0, 0.0] point4RAS = [0.0, 0.0, 0.0, 0.0] tImageToRAS.MultiplyPoint(point1Image, point1RAS) tImageToRAS.MultiplyPoint(point2Image, point2RAS) tImageToRAS.MultiplyPoint(point3Image, point3RAS) tImageToRAS.MultiplyPoint(point4Image, point4RAS) p1RAS = [point1RAS[0], point1RAS[1], point1RAS[2]] p2RAS = [point2RAS[0], point2RAS[1], point2RAS[2]] p3RAS = [point3RAS[0], point3RAS[1], point3RAS[2]] p4RAS = [point4RAS[0], point4RAS[1], point4RAS[2]] slicePoints.SetPoint(0, p1RAS) slicePoints.SetPoint(1, p2RAS) slicePoints.SetPoint(2, p3RAS) slicePoints.SetPoint(3, p4RAS) # # Add image texture. image = vtk.vtkImageData() image.DeepCopy(imageData) modelDisplayNode = snapshotModel.GetModelDisplayNode() modelDisplayNode.SetAndObserveTextureImageData(image) snapshotTexture = slicer.vtkMRMLScalarVolumeNode() snapshotTexture.SetAndObserveImageData(image) snapshotTexture.SetName(name + "_Texture") slicer.mrmlScene.AddNode(snapshotTexture) snapshotTexture.CopyOrientation( image_RAS ) snapshotTextureDisplayNode = slicer.vtkMRMLScalarVolumeDisplayNode() snapshotTextureDisplayNode.SetName(name + "_TextureDisplay") snapshotTextureDisplayNode.SetAutoWindowLevel(0); snapshotTextureDisplayNode.SetWindow(256); snapshotTextureDisplayNode.SetLevel(128); snapshotTextureDisplayNode.SetDefaultColorMap(); slicer.mrmlScene.AddNode(snapshotTextureDisplayNode) snapshotTexture.AddAndObserveDisplayNodeID( snapshotTextureDisplayNode.GetID() ) snapshotModel.SetAttribute( "TextureNodeID", snapshotTexture.GetID() ) snapshotModelDisplayNode= snapshotModel.GetModelDisplayNode() snapshotModelDisplayNode.SetAndObserveTextureImageData( snapshotTexture.GetImageData() )
def clipVolumeWithModel(self, inputVolume, clippingModel, clipOutsideSurface, fillOutsideValue, clipInsideSurface, fillInsideValue, outputVolume): """ Fill voxels of the input volume inside/outside the clipping model with the provided fill value """ # Determine the transform between the box and the image IJK coordinate systems rasToModel = vtk.vtkMatrix4x4() if clippingModel.GetTransformNodeID() != None: modelTransformNode = slicer.mrmlScene.GetNodeByID( clippingModel.GetTransformNodeID()) boxToRas = vtk.vtkMatrix4x4() modelTransformNode.GetMatrixTransformToWorld(boxToRas) rasToModel.DeepCopy(boxToRas) rasToModel.Invert() ijkToRas = vtk.vtkMatrix4x4() inputVolume.GetIJKToRASMatrix(ijkToRas) ijkToModel = vtk.vtkMatrix4x4() vtk.vtkMatrix4x4.Multiply4x4(rasToModel, ijkToRas, ijkToModel) modelToIjkTransform = vtk.vtkTransform() modelToIjkTransform.SetMatrix(ijkToModel) modelToIjkTransform.Inverse() transformModelToIjk = vtk.vtkTransformPolyDataFilter() transformModelToIjk.SetTransform(modelToIjkTransform) transformModelToIjk.SetInputConnection( clippingModel.GetPolyDataConnection()) # Use the stencil to fill the volume # Convert model to stencil polyToStencil = vtk.vtkPolyDataToImageStencil() polyToStencil.SetInputConnection(transformModelToIjk.GetOutputPort()) polyToStencil.SetOutputSpacing(inputVolume.GetImageData().GetSpacing()) polyToStencil.SetOutputOrigin(inputVolume.GetImageData().GetOrigin()) polyToStencil.SetOutputWholeExtent( inputVolume.GetImageData().GetExtent()) # Apply the stencil to the volume stencilToImage = vtk.vtkImageStencil() stencilToImage.SetInputConnection(inputVolume.GetImageDataConnection()) stencilToImage.SetStencilConnection(polyToStencil.GetOutputPort()) # Create a copy of the input volume to work on outputImageData = vtk.vtkImageData() outputImageData.DeepCopy(inputVolume.GetImageData()) outputVolume.SetAndObserveImageData(outputImageData) outputVolume.SetIJKToRASMatrix(ijkToRas) # Update volume with the stencil operation result depending on user choices if clipOutsideSurface: stencilToImage.ReverseStencilOff() stencilToImage.SetBackgroundValue(fillOutsideValue) stencilToImage.Update() outputImageData.DeepCopy(stencilToImage.GetOutput()) outputVolume.SetAndObserveImageData(outputImageData) outputVolume.SetIJKToRASMatrix(ijkToRas) if clipInsideSurface: stencilToImage.SetInputConnection( outputVolume.GetImageDataConnection()) stencilToImage.ReverseStencilOn() stencilToImage.SetBackgroundValue(fillInsideValue) stencilToImage.Update() outputImageData.DeepCopy(stencilToImage.GetOutput()) outputVolume.SetAndObserveImageData(outputImageData) outputVolume.SetIJKToRASMatrix(ijkToRas) # Add a default display node to output volume node if it does not exist yet if not outputVolume.GetDisplayNode: displayNode = slicer.vtkMRMLScalarVolumeDisplayNode() displayNode.SetAndObserveColorNodeID("vtkMRMLColorTableNodeGrey") slicer.mrmlScene.AddNode(displayNode) outputVolume.SetAndObserveDisplayNodeID(displayNode.GetID()) return True
def createLabelMap(self, dataNode, labelNode, outputDir, IDcurrPatient): """ self.sliceXarray = numpy.rollaxis(self.sliceXarray,1)[:,:,None] #512,36,1 #self.sliceXarray = self.sliceXarray[:,:,None] self.sliceYarray = numpy.rollaxis(self.sliceYarray,1)[:,:,None] #512,36,1 #self.sliceYarray = self.sliceYarray[:,:,None] #self.slizeZarray = numpy.rot90(self.sliceZarray) self.sliceZarray = self.sliceZarray[:,:,None] #512,512,1 self.sliceXnode = slicer.vtkMRMLScalarVolumeNode() self.sliceYnode = slicer.vtkMRMLScalarVolumeNode() self.sliceZnode = slicer.vtkMRMLScalarVolumeNode() self.sliceXnode.SetName('SliceX') self.sliceYnode.SetName('SliceY') self.sliceZnode.SetName('SliceZ') self.sliceXNodeDisplayNode = slicer.vtkMRMLVectorVolumeDisplayNode() slicer.mrmlScene.AddNode(self.sliceXNodeDisplayNode) self.sliceXnode.SetAndObserveDisplayNodeID(self.sliceXNodeDisplayNode.GetID()) self.sliceYNodeDisplayNode = slicer.vtkMRMLVectorVolumeDisplayNode() slicer.mrmlScene.AddNode(self.sliceYNodeDisplayNode) self.sliceYnode.SetAndObserveDisplayNodeID(self.sliceYNodeDisplayNode.GetID()) self.sliceZNodeDisplayNode = slicer.vtkMRMLVectorVolumeDisplayNode() slicer.mrmlScene.AddNode(self.sliceZNodeDisplayNode) self.sliceZnode.SetAndObserveDisplayNodeID(self.sliceZNodeDisplayNode.GetID()) """ imageFilePath = dataNode.GetStorageNode().GetFileName() imageName = os.path.basename(imageFilePath).replace('.nrrd','') reconDir = os.path.dirname(imageFilePath) studyDir = os.path.dirname(reconDir) segDir = [dirpath for dirpath in glob.glob(os.path.join(studyDir,'*')) if 'Segmentations' in dirpath][0] resourcesDir = [dirpath for dirpath in glob.glob(os.path.join(studyDir,'*')) if 'Resources' in dirpath][0] spacing = dataNode.GetSpacing() origin = dataNode.GetOrigin() #pdb.set_trace() arrays = [] for r,d,f in os.walk(studyDir): [arrays.append(os.path.join(r,file)) for file in fnmatch.filter(f, '*.npy')] try: name = os.path.basename(arrays[0]).replace('.npy', '') except IndexError: print(IDcurrPatient, ': FAILED TO PROCESS NPY FILE') return arr = numpy.load(arrays[0]) #arr = numpy.ascontiguousarray(arr) #nump_arr = reversedim(arr,0) nump_arr = numpy.swapaxes(arr, 0, 2) #nump_arr = nump_arr[...,::-1] #nump_arr = numpy.rollaxis(numpy.rollaxis(nump_arr,2),2,1) self.labelMapnode = slicer.vtkMRMLScalarVolumeNode() self.labelMapnode.SetName('labelMap') self.labelMapnode.LabelMapOn() self.labelMapnodeDisplayNode = slicer.vtkMRMLScalarVolumeDisplayNode() slicer.mrmlScene.AddNode(self.labelMapnodeDisplayNode) self.labelMapnode.SetAndObserveDisplayNodeID(self.labelMapnodeDisplayNode.GetID()) self.labelMapnodeDisplayNode.SetAndObserveColorNodeID('vtkMRMLColorTableNodeFileGenericColors.txt') try: self.labelMapnode = renderArray(self, nump_arr, self.labelMapnode, dataNode, shape=nump_arr.shape, spacing=spacing, origin=origin) except ValueError: print(IDcurrPatient, ': FAILED TO CONVERT TO LABEL MAP') return #self.sliceXnode = self.renderSlice(self.sliceXarray, self.sliceXnode, self.dataNode, shape=self.sliceXarray.shape, spacing=(x,z,1)) #self.sliceYnode = self.renderSlice(self.sliceYarray, self.sliceYnode, self.dataNode, shape=self.sliceYarray.shape, spacing=(y,z,1)) #self.sliceZnode = self.renderSlice(self.sliceZarray, self.sliceZnode, self.dataNode, shape=self.sliceZarray.shape, spacing=(x,y,1)) self.labelMapnode = binarizeLabelMapToValue(self.labelMapnode) self.labelMapnodeDisplayNode.SetInputImageDataConnection(self.labelMapnode.GetImageDataConnection()) self.labelMapnodeDisplayNode.UpdateImageDataPipeline() volumesLogic = slicer.vtkSlicerVolumesLogic() volumesLogic.CenterVolume(dataNode) volumesLogic.CenterVolume(self.labelMapnode) labelMapNodeFileName = os.path.join(segDir, imageName + '_labelMap.nrrd') saveLabelMap = slicer.util.saveNode(self.labelMapnode, labelMapNodeFileName, properties={"filetype": ".nrrd"}) #saveNode = slicer.util.saveNode(dataNode, imageFilePath, properties={"filetype": ".nrrd"}) arraysName = os.path.basename(arrays[0]) shutil.move(arrays[0],os.path.join(resourcesDir,arraysName)) labelMapNodeSITK = sitk.ReadImage(str(labelMapNodeFileName)) FlipZAxis = sitk.FlipImageFilter() FlipZAxis.SetDebug(False) FlipZAxis.SetFlipAxes([False, False, True]) FlipZAxis.SetFlipAboutOrigin(True) FlipZAxis.SetNumberOfThreads(4) labelMapNodeSITK = FlipZAxis.Execute(labelMapNodeSITK) FlipZAxis.Execute(labelMapNodeSITK) sitk.WriteImage(labelMapNodeSITK, str(labelMapNodeFileName) ) """
def computeAverage(self, inputFieldNodes, roi, outputAverageVolume, outputVarianceVolume): referenceVolume = self.createVectorVolumeFromRoi(roi, self.ReferenceVolumeSpacingMm) referenceVolume.SetName('ReferenceVolume') slicer.mrmlScene.AddNode( referenceVolume ) fieldNodes=[] fieldImageData=[] for fieldNode in inputFieldNodes: resampledFieldNode = self.resampleVolume(fieldNode, referenceVolume) fieldNodes.append(resampledFieldNode) fieldImageData.append(resampledFieldNode.GetImageData()) ijkToRasMatrix = vtk.vtkMatrix4x4() # Average volume averageImageData = vtk.vtkImageData() averageImageData.DeepCopy(referenceVolume.GetImageData()) outputAverageVolume.SetAndObserveImageData(averageImageData) referenceVolume.GetIJKToRASMatrix(ijkToRasMatrix) outputAverageVolume.SetIJKToRASMatrix(ijkToRasMatrix) # Variance volume varianceImageData = vtk.vtkImageData() varianceImageData.SetExtent(averageImageData.GetExtent()) if vtk.VTK_MAJOR_VERSION <= 5: varianceImageData.SetScalarType(vtk.VTK_DOUBLE) varianceImageData.SetNumberOfScalarComponents(1) varianceImageData.AllocateScalars() else: varianceImageData.AllocateScalars(vtk.VTK_DOUBLE, 1) outputVarianceVolume.SetIJKToRASMatrix(ijkToRasMatrix) outputVarianceVolume.SetAndObserveImageData(varianceImageData) # Compute dims = averageImageData.GetDimensions() # [field, component] voxelValues = numpy.zeros([len(fieldImageData), 3]) for z in xrange(dims[2]): for y in xrange(dims[1]): for x in xrange(dims[0]): fieldIndex = 0 for imageData in fieldImageData: voxelValues[fieldIndex,0] = imageData.GetScalarComponentAsDouble(x, y, z, 0) voxelValues[fieldIndex,1] = imageData.GetScalarComponentAsDouble(x, y, z, 1) voxelValues[fieldIndex,2] = imageData.GetScalarComponentAsDouble(x, y, z, 2) fieldIndex = fieldIndex+1 meanVoxelValues = numpy.mean(voxelValues, axis = 0) averageImageData.SetScalarComponentFromDouble(x, y, z, 0, meanVoxelValues[0]) averageImageData.SetScalarComponentFromDouble(x, y, z, 1, meanVoxelValues[1]) averageImageData.SetScalarComponentFromDouble(x, y, z, 2, meanVoxelValues[2]) # Compute the mean of the magnitude of the error vectors errorValues = voxelValues-meanVoxelValues errorVectorMagnitudes = numpy.sqrt(numpy.sum(errorValues*errorValues, axis=1)) varianceImageData.SetScalarComponentFromDouble(x, y, z, 0, numpy.mean(errorVectorMagnitudes)) averageImageData.Modified() varianceImageData.Modified() # Create display node if they have not created yet if not outputAverageVolume.GetNthDisplayNode(0): outputAverageVolumeDisplayNode = slicer.vtkMRMLVectorVolumeDisplayNode() slicer.mrmlScene.AddNode( outputAverageVolumeDisplayNode ) outputAverageVolumeDisplayNode.SetAndObserveColorNodeID("vtkMRMLColorTableNodeRainbow"); outputAverageVolume.SetAndObserveNthDisplayNodeID(0, outputAverageVolumeDisplayNode.GetID()); if not outputVarianceVolume.GetNthDisplayNode(0): outputVarianceVolumeDisplayNode = slicer.vtkMRMLScalarVolumeDisplayNode() slicer.mrmlScene.AddNode( outputVarianceVolumeDisplayNode ) outputVarianceVolumeDisplayNode.SetAndObserveColorNodeID("vtkMRMLColorTableNodeRainbow"); outputVarianceVolume.SetAndObserveNthDisplayNodeID(0, outputVarianceVolumeDisplayNode.GetID()); # Clean up temporary nodes for fieldNode in fieldNodes: slicer.mrmlScene.RemoveNode( fieldNode ) slicer.mrmlScene.RemoveNode( referenceVolume )
def computeAverage(self, inputFieldNodes, roi, outputAverageVolume, outputVarianceVolume): referenceVolume = self.createVectorVolumeFromRoi( roi, self.ReferenceVolumeSpacingMm) referenceVolume.SetName('ReferenceVolume') slicer.mrmlScene.AddNode(referenceVolume) fieldNodes = [] fieldImageData = [] for fieldNode in inputFieldNodes: resampledFieldNode = self.resampleVolume(fieldNode, referenceVolume) fieldNodes.append(resampledFieldNode) fieldImageData.append(resampledFieldNode.GetImageData()) ijkToRasMatrix = vtk.vtkMatrix4x4() # Average volume averageImageData = vtk.vtkImageData() averageImageData.DeepCopy(referenceVolume.GetImageData()) outputAverageVolume.SetAndObserveImageData(averageImageData) referenceVolume.GetIJKToRASMatrix(ijkToRasMatrix) outputAverageVolume.SetIJKToRASMatrix(ijkToRasMatrix) # Variance volume varianceImageData = vtk.vtkImageData() varianceImageData.SetExtent(averageImageData.GetExtent()) if vtk.VTK_MAJOR_VERSION <= 5: varianceImageData.SetScalarType(vtk.VTK_DOUBLE) varianceImageData.SetNumberOfScalarComponents(1) varianceImageData.AllocateScalars() else: varianceImageData.AllocateScalars(vtk.VTK_DOUBLE, 1) outputVarianceVolume.SetIJKToRASMatrix(ijkToRasMatrix) outputVarianceVolume.SetAndObserveImageData(varianceImageData) # Compute dims = averageImageData.GetDimensions() # [field, component] voxelValues = numpy.zeros([len(fieldImageData), 3]) for z in xrange(dims[2]): for y in xrange(dims[1]): for x in xrange(dims[0]): fieldIndex = 0 for imageData in fieldImageData: voxelValues[fieldIndex, 0] = imageData.GetScalarComponentAsDouble( x, y, z, 0) voxelValues[fieldIndex, 1] = imageData.GetScalarComponentAsDouble( x, y, z, 1) voxelValues[fieldIndex, 2] = imageData.GetScalarComponentAsDouble( x, y, z, 2) fieldIndex = fieldIndex + 1 meanVoxelValues = numpy.mean(voxelValues, axis=0) averageImageData.SetScalarComponentFromDouble( x, y, z, 0, meanVoxelValues[0]) averageImageData.SetScalarComponentFromDouble( x, y, z, 1, meanVoxelValues[1]) averageImageData.SetScalarComponentFromDouble( x, y, z, 2, meanVoxelValues[2]) # Compute the mean of the magnitude of the error vectors errorValues = voxelValues - meanVoxelValues errorVectorMagnitudes = numpy.sqrt( numpy.sum(errorValues * errorValues, axis=1)) varianceImageData.SetScalarComponentFromDouble( x, y, z, 0, numpy.mean(errorVectorMagnitudes)) averageImageData.Modified() varianceImageData.Modified() # Create display node if they have not created yet if not outputAverageVolume.GetNthDisplayNode(0): outputAverageVolumeDisplayNode = slicer.vtkMRMLVectorVolumeDisplayNode( ) slicer.mrmlScene.AddNode(outputAverageVolumeDisplayNode) outputAverageVolumeDisplayNode.SetAndObserveColorNodeID( "vtkMRMLColorTableNodeRainbow") outputAverageVolume.SetAndObserveNthDisplayNodeID( 0, outputAverageVolumeDisplayNode.GetID()) if not outputVarianceVolume.GetNthDisplayNode(0): outputVarianceVolumeDisplayNode = slicer.vtkMRMLScalarVolumeDisplayNode( ) slicer.mrmlScene.AddNode(outputVarianceVolumeDisplayNode) outputVarianceVolumeDisplayNode.SetAndObserveColorNodeID( "vtkMRMLColorTableNodeRainbow") outputVarianceVolume.SetAndObserveNthDisplayNodeID( 0, outputVarianceVolumeDisplayNode.GetID()) # Clean up temporary nodes for fieldNode in fieldNodes: slicer.mrmlScene.RemoveNode(fieldNode) slicer.mrmlScene.RemoveNode(referenceVolume)
def onHelloWorldButtonClicked(self): scene = slicer.mrmlScene inputModel = self.inputSelector.currentNode() bounds = [0, 0, 0, 0, 0, 0] inputModel.GetBounds(bounds) print('Model Name is:') print(inputModel.GetName()) X = bounds[1] - bounds[0] Y = bounds[3] - bounds[2] Z = bounds[5] - bounds[4] mid = (bounds[0] + X / 2, bounds[2] + Y / 2, bounds[4] + Z / 2) X_thick = .1 #TODO resolution input Y_thick = .1 #TODO resolution input Z_thick = .1 #TODO resolution input z_slices = int(math.ceil(Z / Z_thick)) y_slices = int(math.ceil(Y / Y_thick)) x_slices = int(math.ceil(X / X_thick)) x_thick = X / x_slices y_thick = Y / y_slices z_thick = Z / z_slices print('number of slices') print((x_slices, y_slices, z_slices)) print('midpoint') print(mid) #TODO Bounding box calculation imageSize = [x_slices, y_slices, z_slices] imageSpacing = [x_thick, y_thick, z_thick] voxelType = vtk.VTK_UNSIGNED_CHAR imageData = vtk.vtkImageData() imageData.SetDimensions(imageSize) imageData.AllocateScalars(voxelType, 1) thresholder = vtk.vtkImageThreshold() thresholder.SetInputData(imageData) thresholder.SetInValue(1) thresholder.SetOutValue(1) # Create volume node volumeNode = slicer.vtkMRMLScalarVolumeNode() volumeNode.SetSpacing(imageSpacing) volumeNode.SetImageDataConnection(thresholder.GetOutputPort()) # Add volume to scene slicer.mrmlScene.AddNode(volumeNode) displayNode = slicer.vtkMRMLScalarVolumeDisplayNode() slicer.mrmlScene.AddNode(displayNode) colorNode = slicer.util.getNode('Grey') displayNode.SetAndObserveColorNodeID(colorNode.GetID()) volumeNode.SetAndObserveDisplayNodeID(displayNode.GetID()) volumeNode.CreateDefaultStorageNode() #Transform the Volume to Fit Around the Model transform = slicer.vtkMRMLLinearTransformNode() scene.AddNode(transform) volumeNode.SetAndObserveTransformNodeID(transform.GetID()) vTransform = vtk.vtkTransform() vTransform.Translate( (-X / 2 + mid[0], -Y / 2 + mid[1], -Z / 2 + mid[2])) transform.SetAndObserveMatrixTransformToParent(vTransform.GetMatrix()) #Create a segmentation Node segmentationNode = slicer.vtkMRMLSegmentationNode() slicer.mrmlScene.AddNode(segmentationNode) segmentationNode.CreateDefaultDisplayNodes() segmentationNode.SetReferenceImageGeometryParameterFromVolumeNode( volumeNode) #Add the model as a segmentation #sphereSource = vtk.vtkSphereSource() #sphereSource.SetRadius(10) #sphereSource.SetCenter(6,30,28) #sphereSource.Update() #segmentationNode.AddSegmentFromClosedSurfaceRepresentation(sphereSource.GetOutput(), "Test") segmentID = segmentationNode.GetSegmentation().GenerateUniqueSegmentID( "Test") segmentationNode.AddSegmentFromClosedSurfaceRepresentation( inputModel.GetPolyData(), segmentID) #TODO, Unique ID segmentationNode.SetMasterRepresentationToBinaryLabelmap() modelLabelMap = segmentationNode.GetBinaryLabelmapRepresentation( segmentID) #TODO Unique ID segmentationNode.SetMasterRepresentationToBinaryLabelmap() shape = list(modelLabelMap.GetDimensions()) shape.reverse() #why reverse? labelArray = vtk.util.numpy_support.vtk_to_numpy( modelLabelMap.GetPointData().GetScalars()).reshape(shape) for n in range(1, shape[0] - 1): labelArray[n, :, :] = numpy.maximum(labelArray[n, :, :], labelArray[n - 1, :, :]) outputPolyData = vtk.vtkPolyData() slicer.vtkSlicerSegmentationsModuleLogic.GetSegmentClosedSurfaceRepresentation( segmentationNode, segmentID, outputPolyData) # Create model node model = slicer.vtkMRMLModelNode() model.SetScene(scene) model.SetName(scene.GenerateUniqueName("Model_Undercuts_Removed")) model.SetAndObservePolyData(outputPolyData) # Create display node modelDisplay = slicer.vtkMRMLModelDisplayNode() modelDisplay.SetColor(1, 1, 0) # yellow modelDisplay.SetBackfaceCulling(0) modelDisplay.SetScene(scene) scene.AddNode(modelDisplay) model.SetAndObserveDisplayNodeID(modelDisplay.GetID()) # Add to scene scene.AddNode(model)
def loadFilesWithPyDICOM(self): """ Experimental method - not ready to be used yet. * Goal is to perform timing comparisons between ITK dicom loading vs something that bypasses ITK """ import dicom import numpy import vtk.util.numpy_support dataset0 = dicom.read_file(self.files[0]) dims = (dataset0.Columns, dataset0.Rows, len(self.files)) originLPS = dataset0.ImagePositionPatient rowToLPS = dataset0.ImageOrientationPatient[:3] colToLPS = dataset0.ImageOrientationPatient[3:] originRAS = [-1 * originLPS[0], -1 * originLPS[1], originLPS[2]] rowToRAS = [-1 * rowToLPS[0], -1 * rowToLPS[1], rowToLPS[2]] colToRAS = [-1 * colToLPS[0], -1 * colToLPS[1], rowToLPS[2]] sliceToRAS = numpy.cross(rowToRAS, colToRAS) spacing = dataset0.PixelSpacing if len(self.files) > 1: dataset1 = dicom.read_file(self.files[1]) o0 = numpy.array(originLPS) o1 = numpy.array(dataset1.ImagePositionPatient) sliceSpacing = numpy.sqrt(abs(numpy.sum(o1-o0))) else: sliceSpacing = 1. spacing.append(sliceSpacing) typeMap = {'int16': 4, 'uint16' : 5} imageData = vtk.vtkImageData() imageData.SetDimensions(dims) imageData.SetScalarType(typeMap[str(dataset0.pixel_array.dtype)]) imageData.AllocateScalars() imageArray = vtk.util.numpy_support.vtk_to_numpy(imageData.GetPointData().GetScalars()) imageArray = imageArray.reshape(dims[::-1]) slice = 0 for f in self.files: dataset = dicom.read_file(f) imageArray[slice] = dataset.pixel_array slice += 1 #TODO: # figure out datatype... # set window/level # any error checking? # multi-frame data? # check number of components # detect DWI # add progress self.volumeNode = slicer.vtkMRMLScalarVolumeNode() self.volumeNode.SetName(self.name) self.volumeNode.SetOrigin(originRAS) self.volumeNode.SetIToRASDirection(rowToRAS[0], rowToRAS[1], rowToRAS[2]) self.volumeNode.SetJToRASDirection(colToRAS[0], colToRAS[1], colToRAS[2]) self.volumeNode.SetKToRASDirection(sliceToRAS[0], sliceToRAS[1], sliceToRAS[2]) self.volumeNode.SetSpacing(spacing) self.volumeNode.SetAndObserveImageData(imageData) displayNode = slicer.vtkMRMLScalarVolumeDisplayNode() colorLogic = slicer.modules.colors.logic() displayNode.SetAndObserveColorNodeID(colorLogic.GetDefaultVolumeColorNodeID()) slicer.mrmlScene.AddNode(displayNode) slicer.mrmlScene.AddNode(self.volumeNode) self.volumeNode.SetAndObserveDisplayNodeID(displayNode.GetID())
def clipVolumeWithModel(self, inputVolume, clippingModel, clipOutsideSurface, fillValue, outputVolume): """ Fill voxels of the input volume inside/outside the clipping model with the provided fill value """ # Determine the transform between the box and the image IJK coordinate systems rasToModel = vtk.vtkMatrix4x4() if clippingModel.GetTransformNodeID() != None: modelTransformNode = slicer.mrmlScene.GetNodeByID(clippingModel.GetTransformNodeID()) boxToRas = vtk.vtkMatrix4x4() modelTransformNode.GetMatrixTransformToWorld(boxToRas) rasToModel.DeepCopy(boxToRas) rasToModel.Invert() ijkToRas = vtk.vtkMatrix4x4() inputVolume.GetIJKToRASMatrix( ijkToRas ) ijkToModel = vtk.vtkMatrix4x4() vtk.vtkMatrix4x4.Multiply4x4(rasToModel,ijkToRas,ijkToModel) modelToIjkTransform = vtk.vtkTransform() modelToIjkTransform.SetMatrix(ijkToModel) modelToIjkTransform.Inverse() transformModelToIjk=vtk.vtkTransformPolyDataFilter() transformModelToIjk.SetTransform(modelToIjkTransform) transformModelToIjk.SetInputConnection(clippingModel.GetPolyDataConnection()) # Use the stencil to fill the volume # Convert model to stencil polyToStencil = vtk.vtkPolyDataToImageStencil() polyToStencil.SetInputConnection(transformModelToIjk.GetOutputPort()) polyToStencil.SetOutputSpacing(inputVolume.GetImageData().GetSpacing()) polyToStencil.SetOutputOrigin(inputVolume.GetImageData().GetOrigin()) polyToStencil.SetOutputWholeExtent(inputVolume.GetImageData().GetExtent()) # Apply the stencil to the volume stencilToImage=vtk.vtkImageStencil() stencilToImage.SetInputConnection(inputVolume.GetImageDataConnection()) stencilToImage.SetStencilConnection(polyToStencil.GetOutputPort()) if clipOutsideSurface: stencilToImage.ReverseStencilOff() else: stencilToImage.ReverseStencilOn() stencilToImage.SetBackgroundValue(fillValue) stencilToImage.Update() # Update the volume with the stencil operation result outputImageData = vtk.vtkImageData() outputImageData.DeepCopy(stencilToImage.GetOutput()) outputVolume.SetAndObserveImageData(outputImageData); outputVolume.SetIJKToRASMatrix(ijkToRas) # Add a default display node to output volume node if it does not exist yet if not outputVolume.GetDisplayNode: displayNode=slicer.vtkMRMLScalarVolumeDisplayNode() displayNode.SetAndObserveColorNodeID("vtkMRMLColorTableNodeGrey") slicer.mrmlScene.AddNode(displayNode) outputVolume.SetAndObserveDisplayNodeID(displayNode.GetID()) return True
def setupScene(self): logging.debug('setupScene') logging.debug('Create transforms') self.ReferenceToRas = slicer.util.getNode('ReferenceToRas') if not self.ReferenceToRas: self.ReferenceToRas=slicer.vtkMRMLLinearTransformNode() self.ReferenceToRas.SetName("ReferenceToRas") m = vtk.vtkMatrix4x4() m.SetElement( 0, 0, 0 ) m.SetElement( 0, 2, -1 ) m.SetElement( 1, 1, 0 ) m.SetElement( 1, 1, -1 ) m.SetElement( 2, 2, 0 ) m.SetElement( 2, 0, -1 ) self.ReferenceToRas.SetMatrixTransformToParent(m) slicer.mrmlScene.AddNode(self.ReferenceToRas) self.needleTipToNeedle = slicer.util.getNode('NeedleTipToNeedle') if not self.needleTipToNeedle: self.needleTipToNeedle=slicer.vtkMRMLLinearTransformNode() self.needleTipToNeedle.SetName("NeedleTipToNeedle") m = self.readTransformFromSettings('NeedleTipToNeedle') if m: self.needleTipToNeedle.SetMatrixTransformToParent(m) slicer.mrmlScene.AddNode(self.needleTipToNeedle) self.needleModelToNeedleTip = slicer.util.getNode('NeedleModelToNeedleTip') if not self.needleModelToNeedleTip: self.needleModelToNeedleTip=slicer.vtkMRMLLinearTransformNode() self.needleModelToNeedleTip.SetName("NeedleModelToNeedleTip") m = vtk.vtkMatrix4x4() m.SetElement( 0, 0, 0 ) m.SetElement( 1, 1, 0 ) m.SetElement( 2, 2, 0 ) m.SetElement( 0, 1, 1 ) m.SetElement( 1, 2, 1 ) m.SetElement( 2, 0, 1 ) self.needleModelToNeedleTip.SetMatrixTransformToParent(m) slicer.mrmlScene.AddNode(self.needleModelToNeedleTip) # Create transforms that will be updated through OpenIGTLink self.needleToReference = slicer.util.getNode('NeedleToReference') if not self.needleToReference: self.needleToReference=slicer.vtkMRMLLinearTransformNode() self.needleToReference.SetName("NeedleToReference") slicer.mrmlScene.AddNode(self.needleToReference) # Models logging.debug('Create models') self.needleModel_NeedleTip = slicer.util.getNode('NeedleModel') if not self.needleModel_NeedleTip: slicer.modules.createmodels.logic().CreateNeedle(80,1.0,2.5,0) self.needleModel_NeedleTip=slicer.util.getNode(pattern="NeedleModel") self.needleModel_NeedleTip.GetDisplayNode().SetColor(0.333333, 1.0, 1.0) self.needleModel_NeedleTip.SetName("NeedleModel") self.needleModel_NeedleTip.GetDisplayNode().SliceIntersectionVisibilityOn() liveUltrasoundNodeName = self.parameterNode.GetParameter('LiveUltrasoundNodeName') self.liveUltrasoundNode_Reference = slicer.util.getNode(liveUltrasoundNodeName) if not self.liveUltrasoundNode_Reference: imageSize=[800, 600, 1] imageSpacing=[0.2, 0.2, 0.2] # Create an empty image volume imageData=vtk.vtkImageData() imageData.SetDimensions(imageSize) imageData.AllocateScalars(vtk.VTK_UNSIGNED_CHAR, 1) thresholder=vtk.vtkImageThreshold() thresholder.SetInputData(imageData) thresholder.SetInValue(0) thresholder.SetOutValue(0) # Create volume node self.liveUltrasoundNode_Reference=slicer.vtkMRMLScalarVolumeNode() self.liveUltrasoundNode_Reference.SetName(liveUltrasoundNodeName) self.liveUltrasoundNode_Reference.SetSpacing(imageSpacing) self.liveUltrasoundNode_Reference.SetImageDataConnection(thresholder.GetOutputPort()) # Add volume to scene slicer.mrmlScene.AddNode(self.liveUltrasoundNode_Reference) displayNode=slicer.vtkMRMLScalarVolumeDisplayNode() slicer.mrmlScene.AddNode(displayNode) colorNode = slicer.util.getNode('Grey') displayNode.SetAndObserveColorNodeID(colorNode.GetID()) self.liveUltrasoundNode_Reference.SetAndObserveDisplayNodeID(displayNode.GetID()) #self.liveUltrasoundNode_Reference.CreateDefaultStorageNode() # Show ultrasound in red view. layoutManager = self.layoutManager redSlice = layoutManager.sliceWidget('Red') redSliceLogic = redSlice.sliceLogic() redSliceLogic.GetSliceCompositeNode().SetBackgroundVolumeID(self.liveUltrasoundNode_Reference.GetID()) # Set up volume reslice driver. resliceLogic = slicer.modules.volumereslicedriver.logic() if resliceLogic: redNode = slicer.util.getNode('vtkMRMLSliceNodeRed') # Typically the image is zoomed in, therefore it is faster if the original resolution is used # on the 3D slice (and also we can show the full image and not the shape and size of the 2D view) redNode.SetSliceResolutionMode(slicer.vtkMRMLSliceNode.SliceResolutionMatchVolumes) resliceLogic.SetDriverForSlice(self.liveUltrasoundNode_Reference.GetID(), redNode) resliceLogic.SetModeForSlice(6, redNode) # Transverse mode, default for PLUS ultrasound. resliceLogic.SetFlipForSlice(False, redNode) resliceLogic.SetRotationForSlice(180, redNode) redSliceLogic.FitSliceToAll() else: logging.warning('Logic not found for Volume Reslice Driver') # Build transform tree logging.debug('Set up transform tree') self.needleModel_NeedleTip.SetAndObserveTransformNodeID(self.needleModelToNeedleTip.GetID()) self.needleModelToNeedleTip.SetAndObserveTransformNodeID(self.needleTipToNeedle.GetID()) self.needleTipToNeedle.SetAndObserveTransformNodeID(self.needleToReference.GetID()) self.liveUltrasoundNode_Reference.SetAndObserveTransformNodeID(self.ReferenceToRas.GetID()) # Hide slice view annotations (patient name, scale, color bar, etc.) as they # decrease reslicing performance by 20%-100% logging.debug('Hide slice view annotations') import DataProbe dataProbeUtil=DataProbe.DataProbeLib.DataProbeUtil() dataProbeParameterNode=dataProbeUtil.getParameterNode() dataProbeParameterNode.SetParameter('showSliceViewAnnotations', '0')
def clipVolumeWithRoi(self, roiNode, volumeNode, fillValue, clipOutsideSurface, outputVolume): # Create a box implicit function that will be used as a stencil to fill the volume roiBox = vtk.vtkBox() roiCenter = [0, 0, 0] roiNode.GetXYZ(roiCenter) roiRadius = [0, 0, 0] roiNode.GetRadiusXYZ(roiRadius) roiBox.SetBounds(roiCenter[0] - roiRadius[0], roiCenter[0] + roiRadius[0], roiCenter[1] - roiRadius[1], roiCenter[1] + roiRadius[1], roiCenter[2] - roiRadius[2], roiCenter[2] + roiRadius[2]) # Determine the transform between the box and the image IJK coordinate systems rasToBox = vtk.vtkMatrix4x4() if roiNode.GetTransformNodeID() != None: roiBoxTransformNode = slicer.mrmlScene.GetNodeByID( roiNode.GetTransformNodeID()) boxToRas = vtk.vtkMatrix4x4() roiBoxTransformNode.GetMatrixTransformToWorld(boxToRas) rasToBox.DeepCopy(boxToRas) rasToBox.Invert() ijkToRas = vtk.vtkMatrix4x4() volumeNode.GetIJKToRASMatrix(ijkToRas) ijkToBox = vtk.vtkMatrix4x4() vtk.vtkMatrix4x4.Multiply4x4(rasToBox, ijkToRas, ijkToBox) ijkToBoxTransform = vtk.vtkTransform() ijkToBoxTransform.SetMatrix(ijkToBox) roiBox.SetTransform(ijkToBoxTransform) # Use the stencil to fill the volume imageData = volumeNode.GetImageData() # Convert the implicit function to a stencil functionToStencil = vtk.vtkImplicitFunctionToImageStencil() functionToStencil.SetInput(roiBox) functionToStencil.SetOutputOrigin(imageData.GetOrigin()) functionToStencil.SetOutputSpacing(imageData.GetSpacing()) functionToStencil.SetOutputWholeExtent(imageData.GetExtent()) functionToStencil.Update() # Apply the stencil to the volume stencilToImage = vtk.vtkImageStencil() stencilToImage.SetInputData(imageData) stencilToImage.SetStencilData(functionToStencil.GetOutput()) if clipOutsideSurface: stencilToImage.ReverseStencilOff() else: stencilToImage.ReverseStencilOn() stencilToImage.SetBackgroundValue(fillValue) stencilToImage.Update() # Update the volume with the stencil operation result outputImageData = vtk.vtkImageData() outputImageData.DeepCopy(stencilToImage.GetOutput()) outputVolume.SetAndObserveImageData(outputImageData) outputVolume.SetIJKToRASMatrix(ijkToRas) # Add a default display node to output volume node if it does not exist yet if not outputVolume.GetDisplayNode: displayNode = slicer.vtkMRMLScalarVolumeDisplayNode() displayNode.SetAndObserveColorNodeID("vtkMRMLColorTableNodeGrey") slicer.mrmlScene.AddNode(displayNode) outputVolume.SetAndObserveDisplayNodeID(displayNode.GetID())
def onApplyButton(self): inputVolume = self.inputSelector.currentNode() outputVolume = self.outputSelector.currentNode() if not (inputVolume and outputVolume): qt.QMessageBox.critical( slicer.util.mainWindow(), 'T1 Mapping', 'Input and output volumes are required for T1 Mapping') return # run T1Mapping # Create numpy array from images s=slicer.util.array(inputVolume.GetID()) # Create zero numpy arrays wich has the same dimension as the input images d=s.shape ssin=numpy.zeros(d,dtype=numpy.float) stan=numpy.zeros(d,dtype=numpy.float) # Read info from VTK node (FA and TR) v=slicer.util.getNode(inputVolume.GetID()) FA=string.split(v.GetAttribute('MultiVolume.FrameLabels'),',') nFrames=len(FA) for l in range(nFrames): FA[l]=float(FA[l]) TR=str(v.GetAttribute('MultiVolume.DICOM.RepetitionTime')) TR=float(TR) # convert degrees to radians FArdg=numpy.radians(FA) # create output array o=numpy.zeros((d[0],d[1],d[2])) # calculate the slope of the linear regression for i in range(nFrames): ssin[:,:,:,i]=s[:,:,:,i]/numpy.sin(FArdg[i]) stan[:,:,:,i]=s[:,:,:,i]/numpy.tan(FArdg[i]) for i in range(d[0]): for j in range(d[1]): for k in range(d[2]): [coef,res]=numpy.polyfit(stan[i,j,k,:],ssin[i,j,k,:],1) o[i,j,k]=coef # compute the real T1 T1=TR/numpy.log(o)*(-1) T1=numpy.uint16(T1) importer = vtk.vtkImageImport() data_string = T1.tostring() importer.CopyImportVoidPointer(data_string, len(data_string)) setDataType = 'importer.SetDataScalarTypeTo' + 'UnsignedShort' + '()' eval(setDataType) importer.SetNumberOfScalarComponents(1) importer.SetWholeExtent(0,T1.shape[2]-1,0,T1.shape[1]-1,0,T1.shape[0]-1) importer.SetDataExtentToWholeExtent() print importer.GetDataExtent() importer.Update() ijkToRAS = vtk.vtkMatrix4x4() inputVolume.GetIJKToRASMatrix(ijkToRAS) outputVolume.SetIJKToRASMatrix(ijkToRAS) outputVolume.SetAndObserveImageData(importer.GetOutput()) slicer.mrmlScene.AddNode(Volume) volumeDisplayNode = slicer.vtkMRMLScalarVolumeDisplayNode() slicer.mrmlScene.AddNode(volumeDisplayNode) greyColorTable = slicer.util.getNode('Grey') volumeDisplayNode.SetAndObserveColorNodeID(greyColorTable.GetID())