def computeFA(self, inputVolume): # Create intermediate output volumes dtiVolume = slicer.mrmlScene.AddNode(slicer.vtkMRMLDiffusionTensorVolumeNode()) outputBaseline = slicer.mrmlScene.AddNode(slicer.vtkMRMLScalarVolumeNode()) # Compute the DTI output volume using the "DWI to DTI estimation" CLI module module = slicer.modules.dwitodtiestimation self.delayDisplay(module.title) logging.info('"%s" started' % module.title) cliParams = { 'inputVolume': inputVolume.GetID(), 'outputTensor': dtiVolume.GetID(), 'outputBaseline' : outputBaseline.GetID() } cliNode = slicer.cli.run(module, None, cliParams, wait_for_completion=True) logging.info('"%s" completed' % module.title) # Create output volume outputScalar = slicer.mrmlScene.AddNode(slicer.vtkMRMLScalarVolumeNode()) # Compute FA output volume using "Diffusion Tensor Scalar Measurements" CLI module module = slicer.modules.diffusiontensorscalarmeasurements self.delayDisplay(module.title) logging.info('"%s" started' % module.title) cliParams = { 'inputVolume': dtiVolume.GetID(), 'outputScalar': outputScalar.GetID() } cliNode = slicer.cli.run(module, None, cliParams, wait_for_completion=True) logging.info('"%s" completed' % module.title) return (outputBaseline, outputScalar)
def run(self,inputVolume,outputVolume,pixelSizeX,pixelSizeY,pixelSizeZ): """ Run the actual algorithm """ #Run Label Map Smoothing Module: Smooth the moving label with Max RMs Err = 1 and Sigma =2. tmpImageLMS = slicer.vtkMRMLScalarVolumeNode() tmpImageLMS.SetName('tmp_LMS') slicer.mrmlScene.AddNode(tmpImageLMS) self.delayDisplay('Label Map Smoothing') lms = slicer.modules.labelmapsmoothing parameters = {} parameters['labelToSmooth'] = -1 parameters['numberOfIterations'] = 50 parameters['maxRMSError'] = 1.0 parameters['gaussianSigma'] = 2.0 parameters['inputVolume'] = inputVolume.GetID() parameters['outputVolume'] = tmpImageLMS.GetID() slicer.cli.run(lms, None, parameters, True) #Run Resample Scalar Volume Module:Increase the resolution of the output of previous step by dividing the third entity by 2. tmpImageRSV = slicer.vtkMRMLScalarVolumeNode() tmpImageLMS.SetName('tmp_RSV') slicer.mrmlScene.AddNode(tmpImageRSV) self.delayDisplay('Resample Scalar Volume') rsv = slicer.modules.resamplescalarvolume parameters = {} parameters['outputPixelSpacing'] = "%f,%f,%f" % (pixelSizeX, pixelSizeY, pixelSizeZ) parameters['interpolationType'] = 'linear' parameters['InputVolume'] = tmpImageLMS.GetID() parameters['OutputVolume'] = tmpImageRSV.GetID() slicer.cli.run(rsv, None, parameters, True) #Run Label Smoothing Module: Smooth the output of previous step with Max RMs Err = 0.5 and Sigma =1. self.delayDisplay('Label Map Smoothing') parameters = {} parameters['labelToSmooth'] = -1 parameters['numberOfIterations'] = 50 parameters['maxRMSError'] = 0.5 parameters['gaussianSigma'] = 1 parameters['inputVolume'] = tmpImageRSV.GetID() parameters['outputVolume'] = outputVolume.GetID() slicer.cli.run(lms, None, parameters, True) #Remove temporary nodes. slicer.mrmlScene.RemoveNode(tmpImageLMS) slicer.mrmlScene.RemoveNode(tmpImageRSV) #Run Image Resample module: Use your Transformation and apply it on the output of the previous step. #Registration Metric: Calculate HD and DSC. return True
def onApply(self): fixedVolumeNode = self.fixedImageSelector.currentNode() movingVolumeSequenceNode = self.movingImageSequenceSelector.currentNode() maskROINode = self.InputROISelector.currentNode() initialTransformNode = self.linearTransformSelector.currentNode() initializeTransformModeOption = self.initializeTransformModeOption outputTransformSequenceNode = self.outputTransformSequenceSelector.currentNode() outputVolumeSequenceNode = self.outputImageSequenceSelector.currentNode() logic = SequenceRegistrationLogic() if maskROINode: print("create the mask from ROI") if self.maskVolumeNode == None: self.maskVolumeNode = slicer.vtkMRMLScalarVolumeNode() slicer.mrmlScene.AddNode(self.maskVolumeNode) logic.makeMaskVolumeFromROI(fixedVolumeNode, self.maskVolumeNode, maskROINode) else: slicer.mrmlScene.RemoveNode(self.maskVolumeNode) self.maskVolumeNode = None print("Start the registration") logic.RegisterImageSequence(fixedVolumeNode, movingVolumeSequenceNode, outputTransformSequenceNode, outputVolumeSequenceNode, initializeTransformModeOption, initialTransformNode, self.maskVolumeNode) print("finish the registration")
def registerVolumes(self, fixedVolumeName, fixedTransformName, movingVolumeName, movingTransformName, registrationTransformName): # self.Registered = False # get the nodes fixedTransformNode = slicer.util.getNode(fixedTransformName) movingTransformNode = slicer.util.getNode(movingTransformName) fixedVolumeNode = slicer.util.getNode(fixedVolumeName) movingVolumeNode = slicer.util.getNode(movingVolumeName) # check volumes if not fixedVolumeNode or not movingVolumeNode: print('Registration failed: the volume nodes are not set correctly') return False # setup the brainsfit CLI module parameters = {} parameters["fixedVolume"] = fixedVolumeNode.GetID() parameters["movingVolume"] = movingVolumeNode.GetID() parameters["useRigid"] = True transformNode = slicer.util.getNode(registrationTransformName); if not transformNode == None: slicer.mrmlScene.RemoveNode(transformNode) registrationTransformNode = slicer.vtkMRMLLinearTransformNode() registrationTransformNode.SetName(registrationTransformName) slicer.mrmlScene.AddNode(registrationTransformNode) parameters["linearTransform"] = registrationTransformNode.GetID() parameters["initializeTransformMode"] = "useCenterOfHeadAlign" outputVolumeName = movingVolumeNode.GetName() + "_" + fixedVolumeNode.GetName(); outputVolumeNode = slicer.util.getNode(outputVolumeName) if outputVolumeNode is None: outputVolumeNode = slicer.vtkMRMLScalarVolumeNode() slicer.mrmlScene.AddNode(outputVolumeNode) outputVolumeNode.SetName(outputVolumeName) parameters["outputVolume"] = outputVolumeNode.GetID() brainsfit = slicer.modules.brainsfit # run the registration cliBrainsFitRigidNode = slicer.cli.run(brainsfit, None, parameters) # cliBrainsFitRigidNode = slicer.cli.run(brainsfit, None, parameters, True) # El ultimo true es para que espere hasta la finalizacion waitCount = 0 while cliBrainsFitRigidNode.GetStatusString() != 'Completed' and waitCount < self.REGISTRATION_TIMEOUT: self.delayDisplay("Register " + movingVolumeNode.GetName() + " to " + fixedVolumeNode.GetName() + "... %d" % waitCount) waitCount += 1 self.delayDisplay("Register " + movingVolumeNode.GetName() + "to " + fixedVolumeNode.GetName() + " finished") qt.QApplication.restoreOverrideCursor() if not cliBrainsFitRigidNode: slicer.mrmlScene.RemoveNode(registrationTransformNode.GetID()) print('Registration failed: Brainsfit module failed') else: # attach the transform to the moving volume movingVolumeNode.SetAndObserveTransformNodeID(registrationTransformNode.GetID()) pass return cliBrainsFitRigidNode
def onSubtractionRequest(self): """ This method subtracts two images pixel-for-pixel using Slicer's subtractscalarvolumes module. It apparently can deal with differently sized images. A new volume is created and displayed, subtractVolume. """ pNode = self.parameterNode() baselineVolumeID = pNode.GetParameter('baselineVolumeID') followupVolumeID = pNode.GetParameter('followupVolumeID') followupVolume = Helper.getNodeByID(followupVolumeID) baselineVolume = Helper.getNodeByID(baselineVolumeID) subtractVolume = slicer.vtkMRMLScalarVolumeNode() subtractVolume.SetScene(slicer.mrmlScene) subtractVolume.SetName(Helper.getNodeByID(baselineVolumeID).GetName() + '_subtraction') slicer.mrmlScene.AddNode(subtractVolume) pNode.SetParameter('subtractVolumeID', subtractVolume.GetID()) # TO-D0: Understand the math behind interpolation order in image subtraction parameters = {} parameters["inputVolume1"] = followupVolume parameters["inputVolume2"] = baselineVolume parameters['outputVolume'] = subtractVolume parameters['order'] = '1' self.__cliNode = None self.__cliNode = slicer.cli.run(slicer.modules.subtractscalarvolumes, self.__cliNode, parameters) # An event listener for the CLI. To-Do: Add a progress bar. self.__cliObserverTag = self.__cliNode.AddObserver('ModifiedEvent', self.processSubtractionCompletion) self.__subtractionButton.setText('Subtraction running...') self.__subtractionButton.setEnabled(0)
def extractFrame(scalarVolumeNode, multiVolumeNode, frameId): # Extract frame from multiVolumeNode and put it into scalarVolumeNode # if no scalar volume given, create one if scalarVolumeNode is None: scalarVolumeNode = slicer.vtkMRMLScalarVolumeNode() scalarVolumeNode.SetScene(slicer.mrmlScene) slicer.mrmlScene.AddNode(scalarVolumeNode) # Extract the image data mvImage = multiVolumeNode.GetImageData() extract = vtk.vtkImageExtractComponents() extract.SetInputData(mvImage) extract.SetComponents(frameId) extract.Update() ras2ijk = vtk.vtkMatrix4x4() ijk2ras = vtk.vtkMatrix4x4() multiVolumeNode.GetRASToIJKMatrix(ras2ijk) multiVolumeNode.GetIJKToRASMatrix(ijk2ras) scalarVolumeNode.SetRASToIJKMatrix(ras2ijk) scalarVolumeNode.SetIJKToRASMatrix(ijk2ras) scalarVolumeNode.SetAndObserveImageData(extract.GetOutput()) displayNode = scalarVolumeNode.GetDisplayNode() if displayNode is None: displayNode = slicer.mrmlScene.CreateNodeByClass( 'vtkMRMLScalarVolumeDisplayNode') displayNode.SetReferenceCount(1) displayNode.SetScene(slicer.mrmlScene) slicer.mrmlScene.AddNode(displayNode) displayNode.SetDefaultColorMap() scalarVolumeNode.SetAndObserveDisplayNodeID(displayNode.GetID()) return scalarVolumeNode
def onSubtractionRequest(self): """ This method subtracts two images pixel-for-pixel using Slicer's subtractscalarvolumes module. It apparently can deal with differently sized images. A new volume is created and displayed, subtractVolume. """ pNode = self.parameterNode() baselineVolumeID = pNode.GetParameter('baselineVolumeID') followupVolumeID = pNode.GetParameter('followupVolumeID') followupVolume = Helper.getNodeByID(followupVolumeID) baselineVolume = Helper.getNodeByID(baselineVolumeID) subtractVolume = slicer.vtkMRMLScalarVolumeNode() subtractVolume.SetScene(slicer.mrmlScene) subtractVolume.SetName( Helper.getNodeByID(baselineVolumeID).GetName() + '_subtraction') slicer.mrmlScene.AddNode(subtractVolume) pNode.SetParameter('subtractVolumeID', subtractVolume.GetID()) # TO-D0: Understand the math behind interpolation order in image subtraction parameters = {} parameters["inputVolume1"] = followupVolume parameters["inputVolume2"] = baselineVolume parameters['outputVolume'] = subtractVolume parameters['order'] = '1' self.__cliNode = None self.__cliNode = slicer.cli.run(slicer.modules.subtractscalarvolumes, self.__cliNode, parameters) # An event listener for the CLI. To-Do: Add a progress bar. self.__cliObserverTag = self.__cliNode.AddObserver( 'ModifiedEvent', self.processSubtractionCompletion) self.__subtractionButton.setText('Subtraction running...') self.__subtractionButton.setEnabled(0)
def onSubtractButtonClicked(self): scene = slicer.mrmlScene subtractmodule = slicer.modules.subtractscalarvolumes vols = self.loadVolumesForTesting() fixedVolume = vols["fixedVolume"] movingVolume = vols["movingVolume"] parameters = {} parameters["inputVolume1"] = fixedVolume parameters["inputVolume2"] = movingVolume outputVolume = slicer.vtkMRMLScalarVolumeNode() outputVolume.SetModifiedSinceRead(1) outputVolume.SetName('subtracted_volume') scene.AddNode(outputVolume) # Important before GetID()! parameters["outputVolume"] = outputVolume.GetID() print "Calling subtract volumes CLI..." self.__cliNode = None self.__cliNode = slicer.cli.run(subtractmodule, self.__cliNode, parameters) # Each time the event is modified, the function processSubtractCompletion will be called. self.__cliObserverTag = self.__cliNode.AddObserver('ModifiedEvent', self.processSubtractCompletion) self.__subtractStatus.setText('Wait ...') self.__subtractButton.setEnabled(0)
def loadTCGAData(self): slicer.util.openAddVolumeDialog() red_logic = slicer.app.layoutManager().sliceWidget("Red").sliceLogic() red_cn = red_logic.GetSliceCompositeNode() fgrdVolID = red_cn.GetBackgroundVolumeID() fgrdNode = slicer.util.getNode(fgrdVolID) fMat=vtk.vtkMatrix4x4() fgrdNode.GetIJKToRASDirectionMatrix(fMat) bgrdName = fgrdNode.GetName() + '_gray' self.tilename = fgrdNode.GetName() + '_gray' self.parameterNode.SetParameter("SlicerPathology,tilename", self.tilename) # Get dummy grayscale image magnitude = vtk.vtkImageMagnitude() magnitude.SetInputData(fgrdNode.GetImageData()) magnitude.Update() bgrdNode = slicer.vtkMRMLScalarVolumeNode() bgrdNode.SetImageDataConnection(magnitude.GetOutputPort()) bgrdNode.SetName(bgrdName) bgrdNode.SetIJKToRASDirectionMatrix(fMat) slicer.mrmlScene.AddNode(bgrdNode) bgrdVolID = bgrdNode.GetID() # Reset slice configuration red_cn.SetForegroundVolumeID(fgrdVolID) red_cn.SetBackgroundVolumeID(bgrdVolID) red_cn.SetForegroundOpacity(1) self.checkAndSetLUT() print bgrdName cv = slicer.util.getNode(bgrdName) self.volumesLogic = slicer.modules.volumes.logic() labelName = bgrdName+'-label' refLabel = self.volumesLogic.CreateAndAddLabelVolume(slicer.mrmlScene,cv,labelName) refLabel.GetDisplayNode().SetAndObserveColorNodeID(self.SlicerPathologyColorNode.GetID()) self.editorWidget.helper.setMasterVolume(cv)
def testElastixLogic(self): print("Starting the test") # # first, get some data # slicer.mrmlScene.Clear(0) import SampleData sampleDataLogic = SampleData.SampleDataLogic() tumor1 = sampleDataLogic.downloadMRBrainTumor1() tumor2 = sampleDataLogic.downloadMRBrainTumor2() outputVolume = slicer.vtkMRMLScalarVolumeNode() slicer.mrmlScene.AddNode(outputVolume) outputVolume.CreateDefaultDisplayNodes() #self.useLocalRegisterVolumes = False self.setLogic() parameterFilenames = ["QuickCenteringRigid.txt"] self.registrationLogic.registerVolumes( tumor1, tumor2, parameterFilenames=parameterFilenames, outputVolumeNode=outputVolume) selectionNode = slicer.app.applicationLogic().GetSelectionNode() selectionNode.SetReferenceActiveVolumeID(outputVolume.GetID()) slicer.app.applicationLogic().PropagateVolumeSelection(0)
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 CreateNewNode(self, colorName, color, dim, origin): # we add a pseudo-random number to the name of our empty volume to avoid the risk of having a volume called # exactly the same by the user which could be confusing. We could also have used slicer.app.sessionId() if colorName not in self.colorSliceVolumes.keys(): VolumeName = "EasyClip_EmptyVolume_" + str(slicer.app.applicationPid()) + "_" + colorName # Do NOT set the spacing and the origin of imageData (vtkImageData) # The spacing and the origin should only be set in the vtkMRMLScalarVolumeNode!!!!!! # We only create an image of 1 voxel (as we only use it to color the planes imageData = vtk.vtkImageData() imageData.SetDimensions(1, 1, 1) imageData.AllocateScalars(vtk.VTK_UNSIGNED_CHAR, 1) imageData.SetScalarComponentFromDouble(0, 0, 0, 0, color) if hasattr(slicer, 'vtkMRMLLabelMapVolumeNode'): sampleVolumeNode = slicer.vtkMRMLLabelMapVolumeNode() else: sampleVolumeNode = slicer.vtkMRMLScalarVolumeNode() sampleVolumeNode = slicer.mrmlScene.AddNode(sampleVolumeNode) sampleVolumeNode.SetName(VolumeName) labelmapVolumeDisplayNode = slicer.vtkMRMLLabelMapVolumeDisplayNode() slicer.mrmlScene.AddNode(labelmapVolumeDisplayNode) colorNode = slicer.util.getNode('GenericAnatomyColors') labelmapVolumeDisplayNode.SetAndObserveColorNodeID(colorNode.GetID()) sampleVolumeNode.SetAndObserveImageData(imageData) sampleVolumeNode.SetAndObserveDisplayNodeID(labelmapVolumeDisplayNode.GetID()) labelmapVolumeDisplayNode.VisibilityOff() self.colorSliceVolumes[colorName] = sampleVolumeNode.GetID() sampleVolumeNode = slicer.mrmlScene.GetNodeByID(self.colorSliceVolumes[colorName]) sampleVolumeNode.HideFromEditorsOn() sampleVolumeNode.SetOrigin(origin[0], origin[1], origin[2]) sampleVolumeNode.SetSpacing(dim[0], dim[1], dim[2]) if not hasattr(slicer, 'vtkMRMLLabelMapVolumeNode'): sampleVolumeNode.SetLabelMap(1) sampleVolumeNode.SetHideFromEditors(True) sampleVolumeNode.SetSaveWithScene(False) return sampleVolumeNode
def onSubtractButtonClicked(self): scene = slicer.mrmlScene subtractmodule = slicer.modules.subtractscalarvolumes vols = self.loadVolumesForTesting() fixedVolume = vols["fixedVolume"] movingVolume = vols["movingVolume"] parameters = {} parameters["inputVolume1"] = fixedVolume parameters["inputVolume2"] = movingVolume outputVolume = slicer.vtkMRMLScalarVolumeNode() outputVolume.SetModifiedSinceRead(1) outputVolume.SetName('subtracted_volume') scene.AddNode(outputVolume) # Important before GetID()! parameters["outputVolume"] = outputVolume.GetID() print "Calling subtract volumes CLI..." self.__cliNode = None self.__cliNode = slicer.cli.run(subtractmodule, self.__cliNode, parameters) # Each time the event is modified, the function processSubtractCompletion will be called. self.__cliObserverTag = self.__cliNode.AddObserver( 'ModifiedEvent', self.processSubtractCompletion) self.__subtractStatus.setText('Wait ...') self.__subtractButton.setEnabled(0)
def interpolateScalarVolumeNode3D(selNode, outputPixelSpacing=(3, 3, 3)): from __main__ import vtk, qt, ctk, slicer, os resampledNode = slicer.vtkMRMLScalarVolumeNode() resampledImageNode.SetName(selNode.GetName() + "_resampled") slicer.mrmlScene.AddNode(resampledNode) resampleScalarVolume(selNode, resampledNode, outputPixelSpacing) return resampledNode
def setWarpVolume(self): warpVolume = slicer.vtkMRMLScalarVolumeNode() slicer.mrmlScene.AddNode(warpVolume) storageNode = warpVolume.CreateDefaultStorageNode() slicer.mrmlScene.AddNode(storageNode) warpVolume.SetAndObserveStorageNodeID(storageNode.GetID()) self.warpVolume = warpVolume
def downsampleCT(self, input_image): """Downsample input image by factor 2 :params input_image: image to downsample """ oldSpacing = input_image.GetSpacing() newSpacing = [] newSpacing.append(oldSpacing[0] * 2) newSpacing.append(oldSpacing[1] * 2) newSpacing.append(oldSpacing[2]) resamplescalarvolume = slicer.modules.resamplescalarvolume upsampledNode = slicer.mrmlScene.AddNode( slicer.vtkMRMLScalarVolumeNode()) parameters = { "outputPixelSpacing": newSpacing, "InputVolume": input_image.GetID(), "OutputVolume": upsampledNode.GetID(), } slicer.cli.run(resamplescalarvolume, None, parameters, wait_for_completion=True) return upsampledNode
def test_VolumeClipWithRoi1(self): # Download MRHead from sample data import SampleData sampleDataLogic = SampleData.SampleDataLogic() self.delayDisplay("Getting MR Head Volume") mrHeadVolume = sampleDataLogic.downloadMRHead() # Create output volume outputVolume = slicer.vtkMRMLScalarVolumeNode() slicer.mrmlScene.AddNode(outputVolume) # Create clipping ROI roiNode = slicer.vtkMRMLAnnotationROINode() roiNode.SetXYZ(36, 17, -10) roiNode.SetRadiusXYZ(25, 40, 65) roiNode.Initialize(slicer.mrmlScene) fillValue = 17 clipOutsideSurface = True logic = VolumeClipWithRoiLogic() logic.clipVolumeWithRoi(roiNode, mrHeadVolume, fillValue, clipOutsideSurface, outputVolume) self.delayDisplay("Test passed!")
def createSampleLabelmapVolumeNode(self, volumeNode, name, label, colorNode=None): self.assertTrue( volumeNode != None ) self.assertTrue( volumeNode.IsA('vtkMRMLScalarVolumeNode') ) self.assertTrue( label > 0 ) sampleLabelmapNode = slicer.vtkMRMLScalarVolumeNode() sampleLabelmapNode.SetName(name) sampleLabelmapNode.SetLabelMap(1) sampleLabelmapNode = slicer.mrmlScene.AddNode(sampleLabelmapNode) sampleLabelmapNode.Copy(volumeNode) imageData = vtk.vtkImageData() imageData.DeepCopy(volumeNode.GetImageData()) sampleLabelmapNode.SetAndObserveImageData(imageData) extent = imageData.GetExtent() for x in xrange(extent[0], extent[1]+1): for y in xrange(extent[2], extent[3]+1): for z in xrange(extent[4], extent[5]+1): if (x >= (extent[1]/4) and x <= (extent[1]/4) * 3) and (y >= (extent[3]/4) and y <= (extent[3]/4) * 3) and (z >= (extent[5]/4) and z <= (extent[5]/4) * 3): imageData.SetScalarComponentFromDouble(x,y,z,0,label) else: imageData.SetScalarComponentFromDouble(x,y,z,0,0) # Display labelmap labelmapVolumeDisplayNode = slicer.vtkMRMLLabelMapVolumeDisplayNode() slicer.mrmlScene.AddNode(labelmapVolumeDisplayNode) if colorNode == None: colorNode = slicer.util.getNode('GenericAnatomyColors') self.assertTrue( colorNode != None ) labelmapVolumeDisplayNode.SetAndObserveColorNodeID(colorNode.GetID()) labelmapVolumeDisplayNode.VisibilityOn() sampleLabelmapNode.SetAndObserveDisplayNodeID(labelmapVolumeDisplayNode.GetID()) return sampleLabelmapNode
def cropVolumeFromLandmarks(self, name, clipOutside): # Input Volume inputVolume = slicer.mrmlScene.GetNodeByID('vtkMRMLScalarVolumeNode1') # Create empty model node clippingModel = slicer.vtkMRMLModelNode() clippingModel.SetName('clipModel') slicer.mrmlScene.AddNode(clippingModel) # Create output volume outputVolume = slicer.vtkMRMLScalarVolumeNode() outputVolume.SetName(name) slicer.mrmlScene.AddNode(outputVolume) # Get crop landmarks landmarks = slicer.mrmlScene.GetNodesByName('Crop Landmarks') cropLandmarks = landmarks.GetItemAsObject(0) # Clip volume #logic = VolumeClipWithModelLogic() logic = VolumeClipWithModel.VolumeClipWithModelLogic() clipOutsideSurface = clipOutside fillValue = -1000 logic.updateModelFromMarkup(cropLandmarks, clippingModel) logic.clipVolumeWithModel(inputVolume, clippingModel, clipOutsideSurface, fillValue, outputVolume) logic.showInSliceViewers(outputVolume, ["Red", "Yellow", "Green"]) clippingModel.SetDisplayVisibility(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") ''' 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 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 readFrame(self, file): sNode = slicer.vtkMRMLVolumeArchetypeStorageNode() sNode.ResetFileNameList() sNode.SetFileName(file) sNode.SetSingleFile(0) frame = slicer.vtkMRMLScalarVolumeNode() success = sNode.ReadData(frame) return (success, frame)
def readFrame(self, file): sNode = slicer.vtkMRMLVolumeArchetypeStorageNode() sNode.ResetFileNameList() sNode.SetFileName(file) sNode.SetSingleFile(1) frame = slicer.vtkMRMLScalarVolumeNode() sNode.ReadData(frame) return frame
def CrearIzquierda(self): ### imagenes a trabajar inputVolume = self.inputSelector.currentNode() outputVolume = self.outputSelector.currentNode() petVolume = self.petSelector.currentNode() mascaraIzquierdaVolume = self.mascaraIzquierdaSelector.currentNode() salida = slicer.vtkMRMLScalarVolumeNode() slicer.mrmlScene.AddNode(salida) salida.SetName('salida') parameters = {} parameters['InputVolume'] = inputVolume parameters['OutputVolume'] = salida parameters['ThresholdType'] = 'Above' parameters['Lower'] = 0 parameters['Upper'] = 0 parameters['Outsite'] = 0 parameters['ThresholdValue'] = 3 cliNode = slicer.cli.run(slicer.modules.thresholdscalarvolume, None, parameters, wait_for_completion=True) parameters = {} parameters['InputVolume'] = salida parameters['OutputVolume'] = outputVolume parameters['ThresholdType'] = 'Below' parameters['Lower'] = 0 parameters['Upper'] = 0 parameters['Outsite'] = 0 parameters['ThresholdValue'] = 3 cliNode = slicer.cli.run(slicer.modules.thresholdscalarvolume, None, parameters, wait_for_completion=True) parameters = {} parameters['InputVolume'] = petVolume parameters['MaskVolume'] = outputVolume parameters['OutputVolume'] = mascaraIzquierdaVolume parameters['Label'] = 3 parameters['Replace'] = 0 cliNode = slicer.cli.run(slicer.modules.maskscalarvolume, None, parameters, wait_for_completion=True) imagenIzquierda = slicer.util.getNode('Volume_2') imagenDataIzquierda = imagenIzquierda.GetImageData() intensidadTotalIzquierda = 0 for i in range(127): for j in range(127, 0, -1): intensidadTotalIzquierda = intensidadTotalIzquierda + ( imagenDataIzquierda.GetScalarComponentAsDouble( int(i), int(j), int(45), 0)) print(intensidadTotalIzquierda)
def fit(self, atlasName='DevelopmentalAtlas', range=[0, 5]): """ Create a volume of the slope across the range of years. least squares notation from: http://docs.scipy.org/doc/numpy/reference/generated/numpy.linalg.lstsq.html """ ijkToRAS = vtk.vtkMatrix4x4() atlasVolume = slicer.util.getNode(atlasName) atlasVolume.GetIJKToRASMatrix(ijkToRAS) fitVolume = slicer.vtkMRMLScalarVolumeNode() fitVolume.SetIJKToRASMatrix(ijkToRAS) ageRange = str(range).replace('[', '(').replace(']', ')') fitName = 'Slope_' + ageRange + '_' + atlasName fitVolume.SetName(fitName) colorNode = slicer.vtkMRMLColorTableNode() colorNode.SetTypeToGrey() slicer.mrmlScene.AddNode(colorNode) fitDisplayNode = slicer.vtkMRMLScalarVolumeDisplayNode() fitDisplayNode.SetAutoWindowLevel(False) fitDisplayNode.SetWindow(10) fitDisplayNode.SetLevel(45) slicer.mrmlScene.AddNode(fitDisplayNode) fitDisplayNode.SetAndObserveColorNodeID(colorNode.GetID()) fitImage = vtk.vtkImageData() fitImage.ShallowCopy(atlasVolume.GetImageData()) fitImage.AllocateScalars(vtk.VTK_FLOAT, 1) fitVolume.SetAndObserveImageData(fitImage) slicer.mrmlScene.AddNode(fitVolume) fitVolume.SetAndObserveDisplayNodeID(fitDisplayNode.GetID()) fitArray = slicer.util.array(fitName) atlasArray = slicer.util.array(atlasName) # make a regression against a scale more or less like the multivolume plot timePoints = self.agesInYears[range[0]:range[1]] timePoints = map(lambda x: x * 1000., timePoints) A = numpy.vstack([timePoints, numpy.ones(len(timePoints))]).T slices, rows, columns, frames = atlasArray.shape for slice in xrange(slices): for row in xrange(rows): for column in xrange(columns): if atlasArray[slice, row, column, 0] == 0: fit = 0 else: series = atlasArray[slice, row, column][range[0]:range[1]] slope, intercept = numpy.linalg.lstsq(A, series)[0] fit = -1. * numpy.degrees(numpy.arctan(slope)) fitArray[slice, row, column] = fit return fitVolume
def __init__(self, slicerVersion): self.volume = slicer.vtkMRMLScalarVolumeNode() self.display = slicer.vtkMRMLScalarVolumeDisplayNode() if slicerVersion == 4: self.fiducialList = slicer.vtkMRMLAnnotationHierarchyNode() self.newFiducial = slicer.vtkMRMLAnnotationFiducialNode() else: self.fiducialList = slicer.vtkMRMLFiducialListNode() self.newFiducial = slicer.vtkMRMLFiducial()
def onApply(self): fixedImage = self.fixedSelector.currentNode() movingImage = self.movingSelector.currentNode() #outputImage = self.outputSelector.currentNode() fixedExtract = vtk.vtkImageExtractComponents() fixedExtract.SetComponents(0,1,2) fixedLuminance = vtk.vtkImageLuminance() fixedExtract.SetInputConnection(fixedImage.GetImageDataConnection()) fixedLuminance.SetInputConnection(fixedExtract.GetOutputPort()) fixedLuminance.Update() fixedIJKToRAS = vtk.vtkMatrix4x4() fixedImage.GetIJKToRASMatrix(fixedIJKToRAS) fixedScalarVolume = slicer.vtkMRMLScalarVolumeNode() fixedScalarVolume.SetName('fixedScalarImage') fixedScalarVolume.SetIJKToRASMatrix(fixedIJKToRAS) fixedScalarVolume.SetImageDataConnection(fixedLuminance.GetOutputPort()) slicer.mrmlScene.AddNode(fixedScalarVolume) movingExtract = vtk.vtkImageExtractComponents() movingExtract.SetComponents(0,1,2) movingLuminance = vtk.vtkImageLuminance() movingExtract.SetInputConnection(movingImage.GetImageDataConnection()) movingLuminance.SetInputConnection(movingExtract.GetOutputPort()) movingLuminance.Update() movingIJKToRAS = vtk.vtkMatrix4x4() movingImage.GetIJKToRASMatrix(movingIJKToRAS) movingScalarVolume = slicer.vtkMRMLScalarVolumeNode() movingScalarVolume.SetName('movingScalarImage') movingScalarVolume.SetIJKToRASMatrix(movingIJKToRAS) movingScalarVolume.SetImageDataConnection(movingLuminance.GetOutputPort()) slicer.mrmlScene.AddNode(movingScalarVolume) anglesNumber = self.numberOfAnglesBox.value print anglesNumber imageRegistration = slicer.modules.imageregistrationcli parameters = { "fixedImage": fixedScalarVolume, "movingImage": movingScalarVolume, "anglesNumber": anglesNumber, } slicer.cli.run( imageRegistration,None,parameters,wait_for_completion=True )
def createVectorVolumeFromRoi(self, exportRoi, spacingMm, numberOfComponents=3): roiCenter = [0, 0, 0] exportRoi.GetXYZ(roiCenter) roiRadius = [0, 0, 0] exportRoi.GetRadiusXYZ(roiRadius) roiOrigin_Roi = [ roiCenter[0] - roiRadius[0], roiCenter[1] - roiRadius[1], roiCenter[2] - roiRadius[2], 1 ] roiToRas = vtk.vtkMatrix4x4() if exportRoi.GetTransformNodeID() != None: roiBoxTransformNode = slicer.mrmlScene.GetNodeByID( exportRoi.GetTransformNodeID()) roiBoxTransformNode.GetMatrixTransformToWorld(roiToRas) exportVolumeSize = [ roiRadius[0] * 2 / spacingMm, roiRadius[1] * 2 / spacingMm, roiRadius[2] * 2 / spacingMm ] exportVolumeSize = [int(math.ceil(x)) for x in exportVolumeSize] exportImageData = vtk.vtkImageData() exportImageData.SetExtent(0, exportVolumeSize[0] - 1, 0, exportVolumeSize[1] - 1, 0, exportVolumeSize[2] - 1) if vtk.VTK_MAJOR_VERSION <= 5: exportImageData.SetScalarType(vtk.VTK_DOUBLE) exportImageData.SetNumberOfScalarComponents(numberOfComponents) exportImageData.AllocateScalars() else: exportImageData.AllocateScalars(vtk.VTK_DOUBLE, numberOfComponents) exportVolume = None if numberOfComponents == 1: exportVolume = slicer.vtkMRMLScalarVolumeNode() else: exportVolume = slicer.vtkMRMLVectorVolumeNode() exportVolume.SetAndObserveImageData(exportImageData) exportVolume.SetIJKToRASDirections(roiToRas.GetElement(0, 0), roiToRas.GetElement(0, 1), roiToRas.GetElement(0, 2), roiToRas.GetElement(1, 0), roiToRas.GetElement(1, 1), roiToRas.GetElement(1, 2), roiToRas.GetElement(2, 0), roiToRas.GetElement(2, 1), roiToRas.GetElement(2, 2)) exportVolume.SetSpacing(spacingMm, spacingMm, spacingMm) roiOrigin_Ras = roiToRas.MultiplyPoint(roiOrigin_Roi) exportVolume.SetOrigin(roiOrigin_Ras[0:3]) return exportVolume
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 onHelloWorldButtonClicked(self): print "Hello World !" #frame volume sera el scalar volume de referencia# self.__mvNode = self.mvSelector.currentNode() #NODO REFERENCIA frameVolume = slicer.vtkMRMLScalarVolumeNode() frameVolume.SetScene(slicer.mrmlScene) slicer.mrmlScene.AddNode(frameVolume) nComponents = self.__mvNode.GetNumberOfFrames() f=int(self.__veInitial.value) frameId = min(f,nComponents-1) ras2ijk = vtk.vtkMatrix4x4() ijk2ras = vtk.vtkMatrix4x4() self.__mvNode.GetRASToIJKMatrix(ras2ijk) self.__mvNode.GetIJKToRASMatrix(ijk2ras) frameImage = frameVolume.GetImageData() if frameImage == None: frameVolume.SetRASToIJKMatrix(ras2ijk) frameVolume.SetIJKToRASMatrix(ijk2ras) mvImage = self.__mvNode.GetImageData() for i in range(nComponents-1): extract = vtk.vtkImageExtractComponents() extract.SetInput(mvImage) extract.SetComponents(i) extract.Update() if i == 0: frameVolume.SetAndObserveImageData(extract.GetOutput()) elif i < frameId+1 : s=vtk.vtkImageMathematics() s.SetOperationToAdd() s.SetInput1(frameVolume.GetImageData()) s.SetInput2(extract.GetOutput()) s.Update() frameVolume.SetAndObserveImageData(s.GetOutput()) frameName = 'Holaaa' frameVolume.SetName(frameName) selectionNode = slicer.app.applicationLogic().GetSelectionNode() selectionNode.SetReferenceActiveVolumeID(frameVolume.GetID()) slicer.app.applicationLogic().PropagateVolumeSelection(0)
def TestNeedleDetection(self): parameters = {} scene = slicer.mrmlScene collection = scene.GetNodesByClass('vtkMRMLScalarVolumeNode'); nimages = collection.GetNumberOfItems() collection.InitTraversal() n = 0 cliList = [] while n < nimages: inImage = collection.GetNextItemAsObject() if inImage == None: break id = inImage.GetID() print('Processing image node = %s...' % id) # Create a new image node outImage = slicer.vtkMRMLScalarVolumeNode() name = inImage.GetName() + '_Needle' outImage.SetName(name) scene.AddNode(outImage) outImage.SetLabelMap(1) # Create a new linear transform node (for needle position/orientation) needleTransform = slicer.vtkMRMLLinearTransformNode() name = inImage.GetName() + '_Transform' needleTransform.SetName(name) scene.AddNode(needleTransform) parameters = {} parameters['inputVolume'] = inImage.GetID() parameters['outputVolume'] = outImage.GetID() parameters['needleTransform'] = needleTransform.GetID() parameters['sigma1'] = 0.5 parameters['minsigma'] = 0.5 parameters['maxsigma'] = 1.3 parameters['stepsigma'] = 5 parameters['minlinemeasure'] = 40 parameters['alpha1'] = 0.5 parameters['alpha2'] = 2 parameters['anglethreshold'] = 25 parameters['normal'] = [0.0, 0.0, 1.0] parameters['numberOfBins'] = 128 parameters['minimumObjectSize'] = 50 parameters['minPrincipalAxisLength'] = 50 parameters['closestPoint'] = [0.0, 0.0, 0.0] nd = slicer.modules.needledetection c = slicer.cli.run(nd, None, parameters) c.AddObserver('ModifiedEvent', self.printStatus) self.cliList.append(c) n = n + 1
def CreateVolumeFromRoi(self, roiNode, spacingMm): """Creates a volume node with image data of proper spacing inside of it PARAM : roi and spacing we wish to have RETURN : vtkMRMLScalarVolumeNode() """ roiCenter = [0, 0, 0] roiNode.GetXYZ(roiCenter) roiRadius = [0, 0, 0] roiNode.GetRadiusXYZ(roiRadius) roiOrigin_Roi = [ roiCenter[0] - roiRadius[0], roiCenter[1] - roiRadius[1], roiCenter[2] - roiRadius[2], 1 ] roiToRas = vtk.vtkMatrix4x4() if roiNode.GetTransformNodeID() != None: roiBoxTransformNode = slicer.mrmlScene.GetNodeByID( roiNode.GetTransformNodeID()) roiBoxTransformNode.GetMatrixTransformToWorld(roiToRas) outputVolumeSize = [ roiRadius[0] * 2 / spacingMm, roiRadius[1] * 2 / spacingMm, roiRadius[2] * 2 / spacingMm ] outputVolumeSize = [int(math.ceil(x)) for x in outputVolumeSize] outputImageData = vtk.vtkImageData() outputImageData.SetExtent(0, outputVolumeSize[0] - 1, 0, outputVolumeSize[1] - 1, 0, outputVolumeSize[2] - 1) if vtk.VTK_MAJOR_VERSION <= 5: outputImageData.SetScalarType(vtk.VTK_UNSIGNED_CHAR) outputImageData.SetNumberOfScalarComponents(3) outputImageData.AllocateScalars() else: outputImageData.AllocateScalars(vtk.VTK_UNSIGNED_CHAR, 1) outputVolumeNode = slicer.vtkMRMLScalarVolumeNode() outputVolumeNode.SetAndObserveImageData(outputImageData) outputVolumeNode.SetIJKToRASDirections(roiToRas.GetElement(0, 0), roiToRas.GetElement(0, 1), roiToRas.GetElement(0, 2), roiToRas.GetElement(1, 0), roiToRas.GetElement(1, 1), roiToRas.GetElement(1, 2), roiToRas.GetElement(2, 0), roiToRas.GetElement(2, 1), roiToRas.GetElement(2, 2)) outputVolumeNode.SetSpacing(spacingMm, spacingMm, spacingMm) roiOrigin_Ras = roiToRas.MultiplyPoint(roiOrigin_Roi) outputVolumeNode.SetOrigin(roiOrigin_Ras[0:3]) return outputVolumeNode
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 onSliderChanged(self, newValue): value = self.__mdSlider.value if self.__mvNode != None: mvDisplayNode = self.__mvNode.GetDisplayNode() mvDisplayNode.SetFrameComponent(newValue) else: return if self.extractFrame == True: frameVolume = self.__vfSelector.currentNode() if frameVolume == None: mvNodeFrameCopy = slicer.vtkMRMLScalarVolumeNode() mvNodeFrameCopy.SetName(self.__mvNode.GetName() + ' frame') mvNodeFrameCopy.SetScene(slicer.mrmlScene) slicer.mrmlScene.AddNode(mvNodeFrameCopy) self.__vfSelector.setCurrentNode(mvNodeFrameCopy) frameVolume = self.__vfSelector.currentNode() mvImage = self.__mvNode.GetImageData() frameId = newValue extract = vtk.vtkImageExtractComponents() extract.SetInput(mvImage) extract.SetComponents(frameId) extract.Update() ras2ijk = vtk.vtkMatrix4x4() ijk2ras = vtk.vtkMatrix4x4() self.__mvNode.GetRASToIJKMatrix(ras2ijk) self.__mvNode.GetIJKToRASMatrix(ijk2ras) frameImage = frameVolume.GetImageData() if frameImage == None: frameVolume.SetRASToIJKMatrix(ras2ijk) frameVolume.SetIJKToRASMatrix(ijk2ras) frameVolume.SetAndObserveImageData(extract.GetOutput()) displayNode = frameVolume.GetDisplayNode() if displayNode == None: displayNode = slicer.mrmlScene.CreateNodeByClass( 'vtkMRMLScalarVolumeDisplayNode') displayNode.SetReferenceCount(1) displayNode.SetScene(slicer.mrmlScene) slicer.mrmlScene.AddNode(displayNode) displayNode.SetDefaultColorMap() frameVolume.SetAndObserveDisplayNodeID(displayNode.GetID()) frameName = '%s frame %d' % (self.__mvNode.GetName(), frameId) frameVolume.SetName(frameName)
def onSliderChanged(self, newValue): value = self.__mdSlider.value if self.__mvNode != None: mvDisplayNode = self.__mvNode.GetDisplayNode() mvDisplayNode.SetFrameComponent(newValue) else: return if self.extractFrame == True: frameVolume = self.__vfSelector.currentNode() if frameVolume == None: mvNodeFrameCopy = slicer.vtkMRMLScalarVolumeNode() mvNodeFrameCopy.SetName(self.__mvNode.GetName()+' frame') mvNodeFrameCopy.SetScene(slicer.mrmlScene) slicer.mrmlScene.AddNode(mvNodeFrameCopy) self.__vfSelector.setCurrentNode(mvNodeFrameCopy) frameVolume = self.__vfSelector.currentNode() mvImage = self.__mvNode.GetImageData() frameId = newValue extract = vtk.vtkImageExtractComponents() extract.SetInput(mvImage) extract.SetComponents(frameId) extract.Update() ras2ijk = vtk.vtkMatrix4x4() ijk2ras = vtk.vtkMatrix4x4() self.__mvNode.GetRASToIJKMatrix(ras2ijk) self.__mvNode.GetIJKToRASMatrix(ijk2ras) frameImage = frameVolume.GetImageData() if frameImage == None: frameVolume.SetRASToIJKMatrix(ras2ijk) frameVolume.SetIJKToRASMatrix(ijk2ras) frameVolume.SetAndObserveImageData(extract.GetOutput()) displayNode = frameVolume.GetDisplayNode() if displayNode == None: displayNode = slicer.mrmlScene.CreateNodeByClass('vtkMRMLScalarVolumeDisplayNode') displayNode.SetReferenceCount(1) displayNode.SetScene(slicer.mrmlScene) slicer.mrmlScene.AddNode(displayNode) displayNode.SetDefaultColorMap() frameVolume.SetAndObserveDisplayNodeID(displayNode.GetID()) frameName = '%s frame %d' % (self.__mvNode.GetName(), frameId) frameVolume.SetName(frameName)
def saveIntermediateImage(self,name,image): node=slicer.mrmlScene.GetNodesByClassByName('vtkMRMLScalarVolumeNode',name).GetItemAsObject(0) if not node: node=slicer.vtkMRMLScalarVolumeNode() IJK=vtk.vtkMatrix4x4() self.input.GetIJKToRASMatrix(IJK) node.SetName(name) node.SetIJKToRASMatrix(IJK) #node.SetLabelMap(1) slicer.mrmlScene.AddNode(node) node.SetAndObserveImageData(image)
def generateDistanceMap(self): print("Generating distance map.") ## Create an scalar volume node for distance map self.distanceMapNode = slicer.vtkMRMLScalarVolumeNode() slicer.mrmlScene.AddNode(self.distanceMapNode) ## Call CLI parameters = {} parameters["inputVolume"] = self.tumorLabelSelector.currentNode().GetID() parameters["outputVolume"] = self.distanceMapNode.GetID() parameters["physicalDistance"] = True distanceMap = slicer.modules.distancemap cliNode = slicer.cli.run(distanceMap, None, parameters) cliNode.AddObserver('ModifiedEvent', self.probeDistanceMap)
def detectEdgeInROI(self,edge,alternateEdge=None): qu=QCLib.QCUtil() VOIROI=qu.getVOIfromRectROI(self.ROI) eV=vtk.vtkExtractVOI() eV.SetInputData(self.input.GetImageData()) eV.SetVOI(VOIROI) eV.Update() imROI=eV.GetOutput() thr=[0,0] if self.algorithm==0: #find threshold for edge detection mL=makeROIGhostLogic() ghost=vtk.vtkImageData() ghnode=slicer.vtkMRMLScalarVolumeNode() ghnode.SetAndObserveImageData(ghost) mL.run(self.input,ghnode) rL=ROIStatisticsLogic() rL.run(self.input,ghnode) zROI=VOIROI[4] ghVals=[] stats=rL.stats.values() for n in range(rL.stats.__len__()): ghVals.append(stats[n][zROI]['mean']+stats[n][zROI]['sd']) thr=[max(ghVals),2*max(ghVals)] else: alternateEdge=None cast=vtk.vtkImageCast() cast.SetOutputScalarTypeToDouble() cast.SetInputData(imROI) cast.Update() em=slicer.vtkITKEdgeDetection() em.SetInputData(cast.GetOutput()) em.SetAlgorithmInt(self.algorithm) em.Setthreshold(thr) em.Setvariance(5) em.Update() edge.DeepCopy(em.GetOutput()) if alternateEdge: self.signedDistance(edge,alternateEdge)
def CreateSkinModel(self, parameters, wait_for_completion=False): self.CLINode.SetStatus(self.CLINode.Running) erodeSkin = len(parameters['SkinLabel']) > 0 # 0 - Add intermediate volume to the scene self.NewVolume = None if erodeSkin: self.NewVolume = slicer.vtkMRMLScalarVolumeNode() self.NewVolume.SetName('SkinModelMakerTemp') slicer.mrmlScene.AddNode(self.NewVolume) # 1 - Setup change label parameters self.ChangeLabelParameters["RunChangeLabel"] = erodeSkin self.ChangeLabelParameters["InputVolume"] = parameters["InputVolume"] self.ChangeLabelParameters["OutputVolume"] = self.NewVolume self.ChangeLabelParameters["InputLabelNumber"] = str( len(parameters['SkinLabel'].split(','))) self.ChangeLabelParameters["InputLabel"] = parameters['SkinLabel'] self.ChangeLabelParameters["OutputLabel"] = parameters[ 'BackgroundLabel'] # 2 Setup generate model parameters if erodeSkin: self.GenerateModelParameters["InputVolume"] = self.NewVolume else: self.GenerateModelParameters["InputVolume"] = parameters[ "InputVolume"] self.GenerateModelParameters["OutputGeometry"] = parameters[ "OutputGeometry"] self.GenerateModelParameters[ "Threshold"] = parameters['BackgroundLabel'] + 0.1 if parameters['Decimate']: self.GenerateModelParameters["Decimate"] = 0.0 self.GenerateModelParameters["Smooth"] = 0 # 3 Setup decimator parameters self.DecimateParameters["RunDecimator"] = parameters['Decimate'] self.DecimateParameters["InputModel"] = parameters["OutputGeometry"] self.DecimateParameters["DecimatedModel"] = parameters[ "OutputGeometry"] self.DecimateParameters["Spacing"] = parameters['Spacing'] self.DecimateParameters['UseInputPoints'] = True self.DecimateParameters['UseFeatureEdges'] = True self.DecimateParameters['UseFeaturePoints'] = True # Start CLI chain self.WaitForCompletion = wait_for_completion self.runChangeLabel()
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 generateDistanceMap(self): print("Generating distance map.") ## Create an scalar volume node for distance map self.distanceMapNode = slicer.vtkMRMLScalarVolumeNode() slicer.mrmlScene.AddNode(self.distanceMapNode) ## Call CLI parameters = {} parameters["inputVolume"] = self.tumorLabelSelector.currentNode( ).GetID() parameters["outputVolume"] = self.distanceMapNode.GetID() parameters["physicalDistance"] = True distanceMap = slicer.modules.distancemap cliNode = slicer.cli.run(distanceMap, None, parameters) cliNode.AddObserver('ModifiedEvent', self.probeDistanceMap)
def RegisterImageSequence(self, fixedVolumeNode, movingVolumeSequenceNode, linearTransformSequenceNode, outputVolumeSequenceNode, initializeTransformMode='useGeometryAlign', initialTransformNode=None, maskVolumeNode=None): if linearTransformSequenceNode: linearTransformSequenceNode.RemoveAllDataNodes() if outputVolumeSequenceNode: outputVolumeSequenceNode.RemoveAllDataNodes() numOfImageNodes = movingVolumeSequenceNode.GetNumberOfDataNodes() lastTransformNode = None for i in range(numOfImageNodes): movingVolumeNode = movingVolumeSequenceNode.GetNthDataNode(i) movingVolumeIndexValue = movingVolumeSequenceNode.GetNthIndexValue(i) slicer.mrmlScene.AddNode(movingVolumeNode) outputTransformNode = slicer.vtkMRMLLinearTransformNode() #outputTransformNode = slicer.vtkMRMLBSplineTransformNode() slicer.mrmlScene.AddNode(outputTransformNode) outputVolumeNode = None if outputVolumeSequenceNode: outputVolumeNode = slicer.vtkMRMLScalarVolumeNode() slicer.mrmlScene.AddNode(outputVolumeNode) initialTransformNode = linearTransformSequenceNode.GetNthDataNode(i-1) if initialTransformNode: slicer.mrmlScene.AddNode(initialTransformNode) else: initialTransformNode = None self.RegisterImage(fixedVolumeNode, movingVolumeNode, outputTransformNode, outputVolumeNode, initializeTransformMode, initialTransformNode, maskVolumeNode) if linearTransformSequenceNode: linearTransformSequenceNode.SetDataNodeAtValue(outputTransformNode, movingVolumeIndexValue) if outputVolumeSequenceNode: outputVolumeSequenceNode.SetDataNodeAtValue(outputVolumeNode, movingVolumeIndexValue) if initialTransformNode: slicer.mrmlScene.RemoveNode(initialTransformNode) slicer.mrmlScene.RemoveNode(movingVolumeNode) if outputVolumeNode: slicer.mrmlScene.RemoveNode(outputVolumeNode) # Initialize the lastTransform so the next registration can start with this transform lastTransform = outputTransformNode slicer.mrmlScene.RemoveNode(outputTransformNode) # This is required as a temp workaround to use the transform sequence to map baseline ROI to sequence ROI if linearTransformSequenceNode: for i in range(numOfImageNodes): transformNode = linearTransformSequenceNode.GetNthDataNode(i) transformNode.Inverse()
def onHelloWorldButtonClicked(self): print "Hello World !" #frame volume sera el scalar volume de referencia# self.__mvNode = self.mvSelector.currentNode() #NODO REFERENCIA frameVolume = slicer.vtkMRMLScalarVolumeNode() frameVolume.SetScene(slicer.mrmlScene) slicer.mrmlScene.AddNode(frameVolume) nComponents = self.__mvNode.GetNumberOfFrames() f = int(self.__veInitial.value) frameId = min(f, nComponents - 1) ras2ijk = vtk.vtkMatrix4x4() ijk2ras = vtk.vtkMatrix4x4() self.__mvNode.GetRASToIJKMatrix(ras2ijk) self.__mvNode.GetIJKToRASMatrix(ijk2ras) frameImage = frameVolume.GetImageData() if frameImage == None: frameVolume.SetRASToIJKMatrix(ras2ijk) frameVolume.SetIJKToRASMatrix(ijk2ras) mvImage = self.__mvNode.GetImageData() for i in range(nComponents - 1): extract = vtk.vtkImageExtractComponents() extract.SetInput(mvImage) extract.SetComponents(i) extract.Update() if i == 0: frameVolume.SetAndObserveImageData(extract.GetOutput()) elif i < frameId + 1: s = vtk.vtkImageMathematics() s.SetOperationToAdd() s.SetInput1(frameVolume.GetImageData()) s.SetInput2(extract.GetOutput()) s.Update() frameVolume.SetAndObserveImageData(s.GetOutput()) frameName = 'Holaaa' frameVolume.SetName(frameName) selectionNode = slicer.app.applicationLogic().GetSelectionNode() selectionNode.SetReferenceActiveVolumeID(frameVolume.GetID()) slicer.app.applicationLogic().PropagateVolumeSelection(0)
def run(self, referenceSequenceNode, inputNode, transformSequenceNode, outputSequenceNode): """ Run the actual algorithm """ if outputSequenceNode: outputSequenceNode.RemoveAllDataNodes() numOfImageNodes = referenceSequenceNode.GetNumberOfDataNodes() for i in xrange(numOfImageNodes): referenceNode = referenceSequenceNode.GetNthDataNode(i) referenceNodeIndexValue = referenceSequenceNode.GetNthIndexValue(i) dimensions = [1, 1, 1] referenceNode.GetImageData().GetDimensions(dimensions) transformNode = transformSequenceNode.GetNthDataNode(i) inputIJK2RASMatrix = vtk.vtkMatrix4x4() inputNode.GetIJKToRASMatrix(inputIJK2RASMatrix) referenceRAS2IJKMatrix = vtk.vtkMatrix4x4() referenceNode.GetRASToIJKMatrix(referenceRAS2IJKMatrix) inputRAS2RASMatrix = transformNode.GetTransformToParent() resampleTransform = vtk.vtkGeneralTransform() resampleTransform.Identity() resampleTransform.PostMultiply() resampleTransform.Concatenate(inputIJK2RASMatrix) resampleTransform.Concatenate(inputRAS2RASMatrix) resampleTransform.Concatenate(referenceRAS2IJKMatrix) resampleTransform.Inverse() resampler = vtk.vtkImageReslice() resampler.SetInput(inputNode.GetImageData()) resampler.SetOutputOrigin(0, 0, 0) resampler.SetOutputSpacing(1, 1, 1) resampler.SetOutputExtent(0, dimensions[0], 0, dimensions[1], 0, dimensions[2]) resampler.SetResliceTransform(resampleTransform) resampler.Update() outputNode = slicer.vtkMRMLScalarVolumeNode() outputNode.CopyOrientation(referenceNode) outputNode.SetAndObserveImageData(resampler.GetOutput()) outputSequenceNode.SetDataNodeAtValue(outputNode, referenceNodeIndexValue) return True
def onRegisterButtonClicked(self): scene = slicer.mrmlScene fixedVolume = self.__fixedVolumeSelector.currentNode() movingVolume = self.__movingVolumeSelector.currentNode() brainsWarp = slicer.modules.brainsdemonwarp # takes forever! brainsFit = slicer.modules.brainsfit # Tested during Image Analysis II. Takes about 20mins bsplinedeformable = slicer.modules.bsplinedeformableregistration # Tested during Image Analysis II parameters = {} # TODO remove the automatic loading and leave this one #parameters["movingVolume"] = movingVolume.GetID() #parameters["fixedVolume"] = fixedVolume.GetID() # Only for testing. Load volumes automatically # TODO Remove when out of testing vols = self.loadVolumesForTesting() fixedVolume = vols["fixedVolume"] movingVolume = vols["movingVolume"] parameters["movingVolume"] = movingVolume parameters["fixedVolume"] = fixedVolume # ONLY for brainsfit parameters['initializeTransformMode'] = 'useCenterOfHeadAlign' parameters['useRigid'] = True # Create an output volume outputVolume = slicer.vtkMRMLScalarVolumeNode() outputVolume.SetModifiedSinceRead(1) outputVolume.SetName('registered_volume') scene.AddNode(outputVolume) # Important before GetID()! parameters["outputVolume"] = outputVolume.GetID() print "Calling register volumes CLI..." self.__cliNode = None self.__cliNode = slicer.cli.run(brainsFit, self.__cliNode, parameters) # Each time the event is modified, the function processSubtractCompletion will be called. self.__cliObserverTag = self.__cliNode.AddObserver( 'ModifiedEvent', self.processRegistrationCompletion) self.__registerStatus.setText('Wait ...') self.__registerButton.setEnabled(0)
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 onRegisterButtonClicked(self): scene = slicer.mrmlScene fixedVolume = self.__fixedVolumeSelector.currentNode() movingVolume = self.__movingVolumeSelector.currentNode() brainsWarp = slicer.modules.brainsdemonwarp # takes forever! brainsFit = slicer.modules.brainsfit # Tested during Image Analysis II. Takes about 20mins bsplinedeformable = slicer.modules.bsplinedeformableregistration # Tested during Image Analysis II parameters = {} # TODO remove the automatic loading and leave this one #parameters["movingVolume"] = movingVolume.GetID() #parameters["fixedVolume"] = fixedVolume.GetID() # Only for testing. Load volumes automatically # TODO Remove when out of testing vols = self.loadVolumesForTesting() fixedVolume = vols["fixedVolume"] movingVolume = vols["movingVolume"] parameters["movingVolume"] = movingVolume parameters["fixedVolume"] = fixedVolume # ONLY for brainsfit parameters['initializeTransformMode'] = 'useCenterOfHeadAlign' parameters['useRigid'] = True # Create an output volume outputVolume = slicer.vtkMRMLScalarVolumeNode() outputVolume.SetModifiedSinceRead(1) outputVolume.SetName('registered_volume') scene.AddNode(outputVolume) # Important before GetID()! parameters["outputVolume"] = outputVolume.GetID() print "Calling register volumes CLI..." self.__cliNode = None self.__cliNode = slicer.cli.run(brainsFit, self.__cliNode, parameters) # Each time the event is modified, the function processSubtractCompletion will be called. self.__cliObserverTag = self.__cliNode.AddObserver('ModifiedEvent', self.processRegistrationCompletion) self.__registerStatus.setText('Wait ...') self.__registerButton.setEnabled(0)
def test_VolumeClipWithModel1(self): # Download MRHead from sample data import SampleData sampleDataLogic = SampleData.SampleDataLogic() self.delayDisplay("Getting MR Head Volume") inputVolume = sampleDataLogic.downloadMRHead() # Create empty model node clippingModel = slicer.vtkMRMLModelNode() slicer.mrmlScene.AddNode(clippingModel) # Create markup fiducials displayNode = slicer.vtkMRMLMarkupsDisplayNode() slicer.mrmlScene.AddNode(displayNode) inputMarkup = slicer.vtkMRMLMarkupsFiducialNode() inputMarkup.SetName('C') slicer.mrmlScene.AddNode(inputMarkup) inputMarkup.SetAndObserveDisplayNodeID(displayNode.GetID()) inputMarkup.AddFiducial(35, -10, -10) inputMarkup.AddFiducial(-15, 20, -10) inputMarkup.AddFiducial(-25, -25, -10) inputMarkup.AddFiducial(-5, -60, -15) inputMarkup.AddFiducial(-5, 5, 60) inputMarkup.AddFiducial(-5, -35, -30) # Create output volume outputVolume = slicer.vtkMRMLScalarVolumeNode() slicer.mrmlScene.AddNode(outputVolume) # Clip volume logic = VolumeClipWithModelLogic() clipOutsideSurface = True fillOutsideValue = 0 clipInsideSurface = True fillInsideValue = 255 logic.updateModelFromMarkup(inputMarkup, clippingModel) logic.clipVolumeWithModel(inputVolume, clippingModel, clipOutsideSurface, fillOutsideValue, outputVolume) logic.showInSliceViewers(outputVolume, ["Red", "Yellow", "Green"]) self.delayDisplay("Test passed!")
def run(self,referenceSequenceNode, inputNode, transformSequenceNode, outputSequenceNode): """ Run the actual algorithm """ if outputSequenceNode: outputSequenceNode.RemoveAllDataNodes() numOfImageNodes = referenceSequenceNode.GetNumberOfDataNodes() for i in xrange(numOfImageNodes): referenceNode = referenceSequenceNode.GetNthDataNode(i) referenceNodeIndexValue = referenceSequenceNode.GetNthIndexValue(i) dimensions = [1,1,1] referenceNode.GetImageData().GetDimensions(dimensions) transformNode = transformSequenceNode.GetNthDataNode(i) inputIJK2RASMatrix = vtk.vtkMatrix4x4() inputNode.GetIJKToRASMatrix(inputIJK2RASMatrix) referenceRAS2IJKMatrix = vtk.vtkMatrix4x4() referenceNode.GetRASToIJKMatrix(referenceRAS2IJKMatrix) inputRAS2RASMatrix = transformNode.GetTransformToParent() resampleTransform = vtk.vtkGeneralTransform() resampleTransform.Identity() resampleTransform.PostMultiply() resampleTransform.Concatenate(inputIJK2RASMatrix) resampleTransform.Concatenate(inputRAS2RASMatrix) resampleTransform.Concatenate(referenceRAS2IJKMatrix) resampleTransform.Inverse() resampler = vtk.vtkImageReslice() resampler.SetInput(inputNode.GetImageData()) resampler.SetOutputOrigin(0,0,0) resampler.SetOutputSpacing(1,1,1) resampler.SetOutputExtent(0,dimensions[0],0,dimensions[1],0,dimensions[2]) resampler.SetResliceTransform(resampleTransform) resampler.Update() outputNode = slicer.vtkMRMLScalarVolumeNode() outputNode.CopyOrientation(referenceNode) outputNode.SetAndObserveImageData(resampler.GetOutput()) outputSequenceNode.SetDataNodeAtValue(outputNode, referenceNodeIndexValue) return True
def CreateSkinModel(self, parameters, wait_for_completion = False): self.CLINode.SetStatus(self.CLINode.Running) erodeSkin = len(parameters['SkinLabel']) > 0 # 0 - Add intermediate volume to the scene self.NewVolume = None if erodeSkin: self.NewVolume = slicer.vtkMRMLScalarVolumeNode() self.NewVolume.SetName('SkinModelMakerTemp') slicer.mrmlScene.AddNode(self.NewVolume) # 1 - Setup change label parameters self.ChangeLabelParameters["RunChangeLabel"] = erodeSkin self.ChangeLabelParameters["InputVolume"] = parameters["InputVolume"] self.ChangeLabelParameters["OutputVolume"] = self.NewVolume self.ChangeLabelParameters["InputLabelNumber"] = str(len(parameters['SkinLabel'].split(','))) self.ChangeLabelParameters["InputLabel"] = parameters['SkinLabel'] self.ChangeLabelParameters["OutputLabel"] = parameters['BackgroundLabel'] # 2 Setup generate model parameters if erodeSkin: self.GenerateModelParameters["InputVolume"] = self.NewVolume else: self.GenerateModelParameters["InputVolume"] = parameters["InputVolume"] self.GenerateModelParameters["OutputGeometry"] = parameters["OutputGeometry"] self.GenerateModelParameters["Threshold"] = parameters['BackgroundLabel'] + 0.1 if parameters['Decimate']: self.GenerateModelParameters["Decimate"] = 0.0 self.GenerateModelParameters["Smooth"] = 0 # 3 Setup decimator parameters self.DecimateParameters["RunDecimator"] = parameters['Decimate'] self.DecimateParameters["InputModel"] = parameters["OutputGeometry"] self.DecimateParameters["DecimatedModel"] = parameters["OutputGeometry"] self.DecimateParameters["Spacing"] = parameters['Spacing'] self.DecimateParameters['UseInputPoints'] = True self.DecimateParameters['UseFeatureEdges'] = True self.DecimateParameters['UseFeaturePoints'] = True # Start CLI chain self.WaitForCompletion = wait_for_completion self.runChangeLabel()
def onApplyButton2(self): logic = VolumeClipIntegrationLogic() print("onApplyButton2") # initialize Label Map outputLabelMap=slicer.vtkMRMLScalarVolumeNode() outputLabelMap.SetLabelMap(1) slicer.mrmlScene.AddNode(outputLabelMap) # get clippingModel Node clipModelNode=slicer.mrmlScene.GetNodesByName('clipModelNode') clippingModel=clipModelNode.GetItemAsObject(0) # run CLI-Module logic.modelToLabelmap(self.inputSelector.currentNode(),clippingModel,outputLabelMap) # set Label Outline slicer.mrmlScene.GetNodeByID("vtkMRMLSliceNodeRed").SetUseLabelOutline(True) slicer.mrmlScene.GetNodeByID("vtkMRMLSliceNodeYellow").SetUseLabelOutline(True) slicer.mrmlScene.GetNodeByID("vtkMRMLSliceNodeGreen").SetUseLabelOutline(True)
def makeSlicerObject(self, sitk_img, name, label,end=False): """ Make simpleITK object into slicer object :param obj sitk_img: SimpleITK image object :param str name: What the slicer object should be called :param bool label: True if label map. False if normal volume """ # Get a slicer volume node ready slicer.modules.WaspWidget.updateStatusLabel("Converting sitk image into slicer object") slice_vol = slicer.vtkMRMLScalarVolumeNode() slice_vol.SetScene(slicer.mrmlScene) if name == "ws_level": # Name is taken from the ws_level array. Reduces the array as it goes along. Not very elegant but for # reason putting the full name into the function was not working. level = self.ws_list_4_slicer_obj[0] name = name+str(level) self.ws_list_4_slicer_obj = np.delete(self.ws_list_4_slicer_obj, [0]) print self.ws_list_4_slicer_obj slice_vol.SetName(name) # check if it is to be a label map if label == True: slice_vol.LabelMapOn() # Add to scene slicer.mrmlScene.AddNode(slice_vol) # # get the node address outputNodeName = slice_vol.GetName() nodeWriteAddress = sitkUtils.GetSlicerITKReadWriteAddress(outputNodeName) # # # simpleitk can now write to that node address sitk.WriteImage(sitk_img, nodeWriteAddress) slice_vol.UnRegister(slicer.mrmlScene) sitk_img = None slicer.modules.WaspWidget.updateStatusLabel("")