def resetVariables(self): self.models_path = slicer.modules.arhealth.path.replace("ARHealth.py", "") + "Resources/Models/" self.models = dict() # Mode self.selected_mode = 1 # Center Model Transform slicer.mrmlScene.RemoveNode(self.centerModelsTransform) self.centerModelsTransform = slicer.vtkMRMLLinearTransformNode() self.centerModelsTransform.SetName("centerModelsTransform") slicer.mrmlScene.AddNode(self.centerModelsTransform) # Base height self.baseHeightMode_val = 10 # Scaling slicer.mrmlScene.RemoveNode(self.scaleTransform) self.scaleTransform = slicer.vtkMRMLLinearTransformNode() self.scaleTransform.SetName("scaleTransform") slicer.mrmlScene.AddNode(self.scaleTransform) self.scaleVal = 100.0 # Translation slicer.mrmlScene.RemoveNode(self.translationTransform) self.translationTransform = slicer.vtkMRMLLinearTransformNode() self.translationTransform.SetName("translationTransform") slicer.mrmlScene.AddNode(self.translationTransform) self.translation_PA = 0.0 self.translation_LR = 0.0 self.translation_IS = 0.0 # Rotation slicer.mrmlScene.RemoveNode(self.rotationTransform) self.rotationTransform = slicer.vtkMRMLLinearTransformNode() self.rotationTransform.SetName("rotationTransform") slicer.mrmlScene.AddNode(self.rotationTransform) self.rotation_LR = 0.0 self.rotation_PA = 0.0 self.rotation_IS = 0.0 # Positioning Transform slicer.mrmlScene.RemoveNode(self.positioningTransform) self.positioningTransform = slicer.vtkMRMLLinearTransformNode() self.positioningTransform.SetName("positioningTransform") slicer.mrmlScene.AddNode(self.positioningTransform) # Color code self.color_code_i = 0
def onConnectButtonClicked(self): # Creates a connector Node if self.connectorNode is None: if self.connectCheck == 1: if self.imageNode or self.transformNode is None: if self.imageNode is None: print('Please select an US volume') if self.trandformNode is None: print('Please select the tip to probe transform') if self.imageNode is not None and self.transformNode is not None: if self.fiducialNode is not None: self.fiducialNode.RemoveAllMarkups() self.numFid = self.numFid+1 self.numFidLabel.setText(str(self.numFid)) self.manualOutputRegistrationTransformNode = slicer.vtkMRMLLinearTransformNode() slicer.mrmlScene.AddNode(self.manualOutputRegistrationTransformNode) self.manualOutputRegistrationTransformNode.SetName('ImageToProbeMan') slicer.modules.markups.logic().StartPlaceMode(0) slicer.app.layoutManager().sliceWidget('Red').setCursor(qt.QCursor(2)) else: self.connectorNode = slicer.vtkMRMLIGTLConnectorNode() # Adds this node to the scene, not there is no need for self here as it is its own node slicer.mrmlScene.AddNode(self.connectorNode) # Configures the connector self.connectorNode.SetTypeClient(self.inputIPLineEdit.text, int(self.inputPortLineEdit.text)) self.connectorNode.Start() else: if self.connectorNode.GetState() == 2: # Connected self.connectorNode.Stop() self.connectButton.text = "Connect" self.freezeButton.text = "Unfreeze" if self.imageSelector.currentNode() or self.TransformSelector.currentNode() is None: if self.imageNode is None: print('Please select an US volume') if self.transformNode is None: print('Please select the tip to probe transform') if self.imageNode is not None and self.transformNode is not None: self.numFid = self.numFid + 1 self.numFidLabel.setText(str(self.numFid)) self.manualOutputRegistrationTransformNode = slicer.vtkMRMLLinearTransformNode() slicer.mrmlScene.AddNode(self.manualOutputRegistrationTransformNode) self.manualOutputRegistrationTransformNode.SetName('ImageToProbeMan') slicer.modules.markups.logic().StartPlaceMode(0) slicer.app.layoutManager().sliceWidget('Red').setCursor(qt.QCursor(2)) else: # This starts the connection self.connectorNode.Start() self.connectButton.text = "Disconnect" self.freezeButton.text = "Freeze" if self.fiducialNode is not None: self.fiducialNode.RemoveAllMarkups()
def __init__(self): # Variable Definition self.m = vtk.vtkMatrix4x4() # 4x4 VTK matrix to save the transformation matrix sent through Plus. self.transform=numpy.zeros((3,3), dtype=numpy.float64) # Numpy matrix used as input for the transformation decomposition. self.observedNode = None self.outputObserverTag = -1 self.record = False self.timerActive=False self.recordingTime_mode1=10 # 5 seconds to record initial position self.recordingTime_mode2=10 # 5 seconds to record initial position self.mode=0 self.myTimer=Timer() self.recordedDataBuffer = [] self.processedRotation =[] self.name = '' # To save data self.prename = '' #To save data self.alarmCounter = 0 self.rotationMatrix=list() self.rotationMatrices=list() # Variables to control the repetition number of each movement. self.repIDflexoext=0 self.repIDflexlat=0 self.repIDrotation=0 # Arrays to save measured data. self.timeStamp=numpy.array([]) # Defines Alarm file path and mode self.sound = qt.QSound('G:/ModulesSlicer/src/AlgiaCervical/Resources/Alarm/alarm.wav') self.sound.setLoops(1) # Labels for Data Visualization self.outputROMLabel = None self.outputMaxVariabilityLabel = None self.outputMinVariabilityLabel = None import Viewpoint # Viewpoint Module must have been added to Slicer self.viewpointLogic = Viewpoint.ViewpointLogic() # Transform matrix of viewpoint in order to center head model in 3D view self.headCameraToHead = slicer.util.getNode('headCameraToHead') if not self.headCameraToHead: self.headCameraToHead=slicer.vtkMRMLLinearTransformNode() self.headCameraToHead.SetName("headCameraToHead") matrixHeadCamera = vtk.vtkMatrix4x4() matrixHeadCamera.SetElement( 0, 0, 1.0 ) # Row 1 matrixHeadCamera.SetElement( 0, 1, 0.05 ) matrixHeadCamera.SetElement( 0, 2, 0.01 ) matrixHeadCamera.SetElement( 0, 3, 9.42 ) matrixHeadCamera.SetElement( 1, 0, 0.0 ) # Row 2 matrixHeadCamera.SetElement( 1, 1, 0.28 ) matrixHeadCamera.SetElement( 1, 2, -0.96 ) matrixHeadCamera.SetElement( 1, 3, -252.69 ) matrixHeadCamera.SetElement( 2, 0, -0.05 ) # Row 3 matrixHeadCamera.SetElement( 2, 1, 0.96 ) matrixHeadCamera.SetElement( 2, 2, 0.28 ) matrixHeadCamera.SetElement( 2, 3, 122.39 ) self.headCameraToHead.SetMatrixTransformToParent(matrixHeadCamera) slicer.mrmlScene.AddNode(self.headCameraToHead)
def alignSegments(self): # Rotation self.alignmentTransform = slicer.vtkMRMLLinearTransformNode() self.alignmentTransform.SetName("alignmentTransform") slicer.mrmlScene.AddNode(self.alignmentTransform) # Create transformation matrix rotMatrix = vtk.vtkTransform() rotMatrix.RotateZ(-180.0) self.alignmentTransform.SetMatrixTransformToParent( rotMatrix.GetMatrix()) # Build transform tree self.segment2.SetAndObserveTransformNodeID( self.alignmentTransform.GetID()) # Harden transform self.segment2.HardenTransform() # Delete transform from scene slicer.mrmlScene.RemoveNode(self.alignmentTransform) # Center 3D view layoutManager = slicer.app.layoutManager() threeDWidget = layoutManager.threeDWidget(0) threeDView = threeDWidget.threeDView() threeDView.resetFocalPoint()
def onVisualizeButtonClicked(self): if self.fiducialNode is not None: self.fiducialNode.RemoveAllMarkups() if self.isVisualizing: slicer.app.layoutManager().setLayout( slicer.vtkMRMLLayoutNode.SlicerLayoutOneUpRedSliceView) self.isVisualizing = False self.visualizeButton.text = 'Show 3D Scene' self.manualOutputRegistrationTransformNode.SetMatrixTransformToParent( None) else: self.isVisualizing = True slicer.app.layoutManager().sliceWidget( 'Red').sliceLogic().GetSliceNode().SetSliceVisible(True) slicer.app.layoutManager().setLayout( slicer.vtkMRMLLayoutNode.SlicerLayoutOneUp3DView) self.visualizeButton.text = 'Show ultrasound stream' if self.transformNode is None: print('Please select an US volume') else: if self.manualOutputRegistrationTransformNode is None: self.manualOutputRegistrationTransformNode = slicer.vtkMRMLLinearTransformNode( ) slicer.mrmlScene.AddNode( self.manualOutputRegistrationTransformNode) self.manualOutputRegistrationTransformNode.SetName( 'ImageToProbeMan') self.imageNode.SetAndObserveTransformNodeID( self.manualOutputRegistrationTransformNode.GetID()) self.manualOutputRegistrationTransformNode.SetMatrixTransformToParent( self.ImageToProbeMan)
def rigidReg(fixedImg, movingImg, outTfm, outImg=None, initTfm=None): '''Rigid registration using BRAINS Registration fixedImg: full path to the fixed image; movingImg: full path to the moving image; outImg: full path to the output co-registered image; outTfm: full path to the output transform file (.tfm). ''' slicer.mrmlScene.Clear(0) fixed = slicer.util.loadVolume(fixedImg) moving = slicer.util.loadVolume(movingImg) cliModule = slicer.modules.brainsfit p = {} p['fixedVolume'] = fixed.GetID() p['movingVolume'] = moving.GetID() outVolume = slicer.vtkMRMLScalarVolumeNode() slicer.mrmlScene.AddNode(outVolume) p['outputVolume'] = outVolume.GetID() p['transformType'] = 'Rigid' tfm = slicer.vtkMRMLLinearTransformNode() slicer.mrmlScene.AddNode(tfm) p['outputTransform'] = tfm.GetID() if initTfm: _tfm = slicer.util.loadTransform(initTfm) p['initialTransform'] = _tfm.GetID() slicer.cli.run(cliModule, None, p, wait_for_completion=True) result = {} if outImg: state1 = slicer.util.saveNode(outVolume, outImg) result.update({outImg: state1}) state2 = slicer.util.saveNode(tfm, outTfm) result.update({outTfm: state2}) slicer.mrmlScene.Clear(0) return result
def copyAndHardenModel(self,originalModel): # copy model outputModel = slicer.vtkMRMLModelNode() fullPolyData = originalModel.GetPolyData() outputModel.SetAndObservePolyData(fullPolyData) md2 = slicer.vtkMRMLModelDisplayNode() slicer.mrmlScene.AddNode(outputModel) slicer.mrmlScene.AddNode(md2) outputModel.SetAndObserveDisplayNodeID(md2.GetID()) md2.SetVisibility(0) # apply transforms tree to copied model parent_transform = originalModel.GetParentTransformNode() try: t = slicer.util.getNode('DefinedTransform') identityTransform = vtk.vtkMatrix4x4() t.SetMatrixTransformToParent(identityTransform) except: t=slicer.vtkMRMLLinearTransformNode() t.SetName('DefinedTransform') slicer.mrmlScene.AddNode(t) t.SetAndObserveTransformNodeID(parent_transform.GetID()) t.HardenTransform() outputModel.SetAndObserveTransformNodeID(t.GetID()) outputModel.HardenTransform() return outputModel,t
def save_electrode_properties(self, electrode): """ Save electrode properties to model attributes. Args: electrode (vtkMRMLModelNode): Electrode to save properties of. """ if not self.switching_electrodes: # Save its full transform electrode_transform = slicer.vtkMRMLLinearTransformNode() trans = vtk.vtkMatrix4x4() # create an inverse electrode_transform.GetMatrixTransformFromNode( slicer.util.getNode("Arc"), trans) electrode_transform = slicer.util.getNode("Transform_" + electrode.GetName()) electrode_transform.SetMatrixTransformToParent(trans) # save specific values electrode.SetAttribute("X", str(self.x_origin_widget.value)) electrode.SetAttribute("Y", str(self.y_origin_widget.value)) electrode.SetAttribute("Z", str(self.z_origin_widget.value)) electrode.SetAttribute("Arc", str(self.arc_angle_widget.value)) electrode.SetAttribute("Collar", str(self.collar_angle_widget.value)) entry_point = np.array([0.0, 0.0, 0.0]) self.targs.GetNthFiducialPosition(1, entry_point) electrode.SetAttribute("Entry", str(list(entry_point)))
def initializeLinearTransformNode(self, name): logging.debug('initializeLinearTransformNode') transformNode = slicer.mrmlScene.GetFirstNodeByName(name) if not transformNode: transformNode = slicer.vtkMRMLLinearTransformNode() transformNode.SetName(name) slicer.mrmlScene.AddNode(transformNode) return transformNode
def setHeadModelVisualization(self, RigidBodyToTrackerTransform, HeadModel): # From matrix to transform node headToRigidBodyTransform=slicer.vtkMRMLLinearTransformNode() headToRigidBodyTransform.SetName("headToRigidBodyTransform") headToRigidBodyTransform.SetMatrixTransformToParent(self.headToRigidBodyTransformMatrix) slicer.mrmlScene.AddNode(headToRigidBodyTransform) # Build transform tree HeadModel.SetAndObserveTransformNodeID(headToRigidBodyTransform.GetID()) headToRigidBodyTransform.SetAndObserveTransformNodeID(RigidBodyToTrackerTransform.GetID())
def getLastApprovedRigidTransformation(self): if sum([1 for result in self._registrationResults.values() if result.approved]) == 1: lastRigidTfm = None else: lastRigidTfm = self.getMostRecentApprovedResult().rigidTransform if not lastRigidTfm: lastRigidTfm = slicer.vtkMRMLLinearTransformNode() slicer.mrmlScene.AddNode(lastRigidTfm) return lastRigidTfm
def getLastApprovedRigidTransformation(self): if sum([1 for result in self.registrationResults.values() if result.approved]) == 1: lastRigidTfm = None else: lastRigidTfm = self.getMostRecentApprovedResult().transforms.rigid if not lastRigidTfm: lastRigidTfm = slicer.vtkMRMLLinearTransformNode() slicer.mrmlScene.AddNode(lastRigidTfm) return lastRigidTfm
def onFiducialClicked(self): if self.fiducialNode is not None: self.fiducialNode.RemoveAllMarkups() self.numFid = self.numFid + 1 self.numFidLabel.setText(str(self.numFid)) self.OutputRegistrationTransformNode = slicer.vtkMRMLLinearTransformNode() slicer.mrmlScene.AddNode(self.OutputRegistrationTransformNode) self.OutputRegistrationTransformNode.SetName('ImageToProbe') slicer.modules.markups.logic().StartPlaceMode(0) slicer.app.layoutManager().sliceWidget('Red').setCursor(qt.QCursor(2))
def _setTransform(self): if self.inputVolume: seriesNumber = self.inputVolume.GetName().split(":")[0] name = seriesNumber + "-ZFrameTransform" if self.outputTransform: self.mrmlScene.RemoveNode(self.outputTransform) self.outputTransform = None self.outputTransform = slicer.vtkMRMLLinearTransformNode() self.outputTransform.SetName(name) self.mrmlScene.AddNode(self.outputTransform)
def __init__(self): self.camera = slicer.util.getNode('Default Scene Camera') self.transform = slicer.vtkMRMLLinearTransformNode() slicer.mrmlScene.AddNode(self.transform) self.camera.SetAndObserveTransformNodeID(self.transform.GetID()) self.vtkcam = self.camera.GetCamera() self.matrix = vtk.vtkTransform() self.degrees = 1 self.rotateX = True self.rotateY = True self.rotateZ = True
def onInputTransformSelect(self): self.TipTransform = slicer.vtkMRMLLinearTransformNode() newName = self.inputtransformSelector.currentNode().GetName().rstrip( 'ToReference') self.TipTransform.SetName(newName + 'TipTo' + newName) slicer.mrmlScene.AddNode(self.TipTransform) self.outputtransformSelector.setCurrentNodeID( self.TipTransform.GetID()) self.inputSelector.currentNode().SetAndObserveTransformNodeID( self.TipTransform.GetID()) self.TipTransform.SetAndObserveTransformNodeID( self.inputtransformSelector.currentNode().GetID())
def onVisualizeButtonClicked(self): self.clippingModel.SetDisplayVisibility(False) if self.imageNode or self.imageNode2 or self.transformNode is None: if self.imageNode is None: print('Please select the left image') if self.imageNode2 is None: print('Please select the right image') if self.transformNode is None: print('Please select a tip to probe transform') if self.imageNode and self.imageNode2 and self.transformNode is not None: self.OutputRegistrationTransformNode = slicer.vtkMRMLLinearTransformNode() self.OutputRegistrationTransformNodeX = slicer.vtkMRMLLinearTransformNode() slicer.mrmlScene.AddNode(self.OutputRegistrationTransformNode) slicer.mrmlScene.AddNode(self.OutputRegistrationTransformNodeX) self.OutputRegistrationTransformNode.SetName('ImageToProbe') self.OutputRegistrationTransformNodeX.SetName('ImageToProbeX') if self.fiducialNode is not None: self.fiducialNode.RemoveAllMarkups() if self.isVisualizing: slicer.app.layoutManager().setLayout(slicer.vtkMRMLLayoutNode.SlicerLayoutSideBySideView) self.isVisualizing = False self.visualizeButton.text = 'Show 3D Scene' self.OutputRegistrationTransformNode.SetMatrixTransformToParent(None) self.OutputRegistrationTransformNodeX.SetMatrixTransformToParent(None) else: self.isVisualizing = True slicer.app.layoutManager().sliceWidget('Red').sliceLogic().GetSliceNode().SetSliceVisible(True) slicer.app.layoutManager().sliceWidget('Yellow').sliceLogic().GetSliceNode().SetSliceVisible(True) slicer.app.layoutManager().setLayout(slicer.vtkMRMLLayoutNode.SlicerLayoutOneUp3DView) self.visualizeButton.text = 'Show ultrasound stream' if self.imageSelector.currentNode is None: print('Please select an US volume') else: self.leftTransform.Concatenate(self.ImageToProbe) self.rightTransform.Concatenate(self.ImageToProbe) self.imageSelector.currentNode().SetAndObserveTransformNodeID(self.OutputRegistrationTransformNode.GetID()) self.imageSelector2.currentNode().SetAndObserveTransformNodeID(self.OutputRegistrationTransformNodeX.GetID()) self.OutputRegistrationTransformNode.SetMatrixTransformToParent(self.leftTransform.GetMatrix()) self.OutputRegistrationTransformNodeX.SetMatrixTransformToParent(self.rightTransform.GetMatrix())
def getTransformNode(self): if len(slicer.util.getNodes('ras2lps*')) > 0: transformNode = slicer.util.getNode('ras2lps*') else: transformNode = slicer.vtkMRMLLinearTransformNode() transformNode.SetScene(slicer.mrmlScene) transformNode.HideFromEditorsOn() transformNode.SetName("ras2lps") t = vtk.vtkTransform() t.Identity() t.Scale([-1, -1, 1]) transformNode.SetMatrixTransformToParent(t.GetMatrix()) slicer.mrmlScene.AddNode(transformNode) return transformNode
def __init__(self, parent=None): ScriptedLoadableModuleWidget.__init__(self, parent) # Set member variables equal to None self.tempNode = None self.connectorNode = None self.sceneObserverTag = None self.logic = GuidedUSCalLogic() self.resliceLogic = slicer.modules.volumereslicedriver.logic() self.imageNode = None self.probeNode = None self.sequenceNode = None self.sequenceNode2 = None self.sequenceBrowserNode = None self.transformNode = None self.dataStack = None self.numFid = 0 self.sequenceLogic = slicer.modules.sequencebrowser.logic() self.counter = 0 self.centroid = [0,0,0] self.isVisualizing = False self.currentMatrix = np.matrix('1,0,0,0;0,1,0,0;0,0,1,0;0,0,0,1', dtype = np.float64) slicer.mymod = self self.connectCheck = 0 self.node = slicer.mrmlScene.AddNewNodeByClass('vtkMRMLScalarVolumeNode') self.path = os.path.dirname(os.path.abspath(__file__)) self.model = load_model(os.path.join(self.path,'Resources\Models\cnn_model_best.keras.h5')) self.fiducialNode = slicer.mrmlScene.AddNewNodeByClass('vtkMRMLMarkupsFiducialNode') self.fiducialNode.CreateDefaultDisplayNodes() self.displayNode = self.fiducialNode.GetDisplayNode() self.displayNode.SetGlyphType(7) self.displayNode.SetGlyphScale(2) self.displayNode.SetTextScale(0) self.displayNode.PointLabelsVisibilityOff() self.displayNode.SetSelectedColor(0, 0, 1) self.defaultDisplayNode = slicer.modules.markups.logic().GetDefaultMarkupsDisplayNode() self.defaultDisplayNode.SetGlyphType(7) self.defaultDisplayNode.SetGlyphScale(2) self.defaultDisplayNode.SetTextScale(0) self.defaultDisplayNode.SetSelectedColor(0, 0, 1) self.defaultDisplayNode.PointLabelsVisibilityOff() self.wResized = self.model.layers[0].output_shape[0][1] self.hResized = self.model.layers[0].output_shape[0][2] self.tipToProbeTransform = vtk.vtkMatrix4x4() self.outputRegistrationTransformNode = slicer.vtkMRMLLinearTransformNode() slicer.mrmlScene.AddNode(self.outputRegistrationTransformNode) self.outputRegistrationTransformNode.SetName('ImageToProbe') self.needleModel = slicer.modules.createmodels.logic().CreateNeedle(150, 0.4, 0, False) self.imageToProbe = vtk.vtkMatrix4x4() self.redoStack = None
def createSampleModels_NoCollisions(self): # Create a cautery model moduleDirectoryPath = slicer.modules.autotransparency.path.replace('AutoTransparency.py', '') slicer.util.loadModel(qt.QDir.toNativeSeparators(moduleDirectoryPath + 'Resources/CAD/Cautery.stl')) self.cauteryModelNode = slicer.util.getNode(pattern = "Cautery") self.cauteryModelNode.GetDisplayNode().SetColor(1.0, 1.0, 0) self.cauteryModelNode.SetName("CauteryModel") self.cauteryModelNode.GetDisplayNode().SliceIntersectionVisibilityOn() # Create transform node and set transform of transform node self.cauteryModelToRAS = slicer.vtkMRMLLinearTransformNode() self.cauteryModelToRAS.SetName('CauteryModelToRAS') slicer.mrmlScene.AddNode(self.cauteryModelToRAS) cauteryModelToRASTransform = vtk.vtkTransform() cauteryModelToRASTransform.PreMultiply() cauteryModelToRASTransform.Translate(0, 100, 0) cauteryModelToRASTransform.RotateX(30) cauteryModelToRASTransform.Update() self.cauteryModelToRAS.SetAndObserveTransformToParent(cauteryModelToRASTransform) # Transform the cautery model self.cauteryModelNode.SetAndObserveTransformNodeID(self.cauteryModelToRAS.GetID()) # Create a sphere tumor model self.tumorModelNode = slicer.modules.createmodels.logic().CreateSphere(10) self.tumorModelNode.GetDisplayNode().SetColor(0,1,0) #Green self.tumorModelNode.SetName('TumorModel') # Create transform node and set transform of transform node self.tumorModelToRAS = slicer.vtkMRMLLinearTransformNode() self.tumorModelToRAS.SetName('tumorModelToRAS') slicer.mrmlScene.AddNode(self.tumorModelToRAS) tumorModelToRASTransform = vtk.vtkTransform() self.tumorModelToRAS.SetAndObserveTransformToParent(tumorModelToRASTransform) # Transform the tumor model self.tumorModelNode.SetAndObserveTransformNodeID(self.tumorModelToRAS.GetID())
def onFiducialClicked(self): if self.fiducialNode is not None: self.fiducialNode.RemoveAllMarkups() if self.imageNode or self.transformNode is None: if self.imageNode is None: print('Please select an US volume') if self.transformNode is None: print('Please select the tip to probe transform') if self.imageNode is not None and self.transformNode is not None: self.numFid = self.numFid+1 self.numFidLabel.setText(str(self.numFid)) self.manualOutputRegistrationTransformNode = slicer.vtkMRMLLinearTransformNode() slicer.mrmlScene.AddNode(self.manualOutputRegistrationTransformNode) self.manualOutputRegistrationTransformNode.SetName('ImageToProbeMan') slicer.modules.markups.logic().StartPlaceMode(0) slicer.app.layoutManager().sliceWidget('Red').setCursor(qt.QCursor(2))
def test_BRAINSFitRigidRegistrationCrashIssue4139(self): """ Ideally you should have several levels of tests. At the lowest level tests should exercise the functionality of the logic with different inputs (both valid and invalid). At higher levels your tests should emulate the way the user would interact with your code and confirm that it still works the way you intended. One of the most important features of the tests is that it should alert other developers when their changes will have an impact on the behavior of your module. For example, if a developer removes a feature that you depend on, your test should break so they know that the feature is needed. """ self.delayDisplay("Starting the test") logic = BRAINSFitRigidRegistrationCrashIssue4139Logic() import SampleData from SampleData import SampleDataLogic sampleDatalogic = SampleDataLogic() fixed = sampleDatalogic.downloadMRBrainTumor1() self.assertIsNotNone(logic.hasImageData(fixed)) moving = sampleDatalogic.downloadMRBrainTumor2() self.assertIsNotNone(logic.hasImageData(moving)) self.delayDisplay('Finished with download and loading') outputTransform = slicer.vtkMRMLLinearTransformNode() slicer.mrmlScene.AddNode(outputTransform) outputVolume = slicer.vtkMRMLScalarVolumeNode() slicer.mrmlScene.AddNode(outputVolume) parameters = { 'fixedVolume' : fixed, 'movingVolume' : moving, 'linearTransform' : outputTransform, 'outputVolume' : outputVolume, 'useRigid' : True } cmdLineNode = slicer.cli.runSync(slicer.modules.brainsfit, parameters=parameters) self.assertIsNotNone(cmdLineNode) # If test reach this point without crashing it is a success self.delayDisplay('Test passed!')
def run(self): """ Run the actual algorithm """ #generating Nodes for displaying a new model modelNode = slicer.vtkMRMLModelNode() dispNode = slicer.vtkMRMLModelDisplayNode() transform = slicer.vtkMRMLLinearTransformNode() #Display node characteristics dispNode.SetVisibility(True) dispNode.SetSliceIntersectionVisibility(True) dispNode.SetOpacity(1) dispNode.SetColor(1, 1, 0) dispNode.SetScene(slicer.mrmlScene) #generate sphere data sphere = vtk.vtkSphereSource() sphere.SetCenter(10,10,10) sphere.SetRadius(40) sphere.Update() #adding necessary nodes to the Scene slicer.mrmlScene.AddNode(dispNode) slicer.mrmlScene.AddNode(transform) slicer.mrmlScene.AddNode(modelNode) #model node name and associations! modelNode.SetName("SphereModelNode") modelNode.SetScene(slicer.mrmlScene) modelNode.SetAndObserveTransformNodeID(transform.GetID()) modelNode.SetAndObserveDisplayNodeID(dispNode.GetID()) apd = vtk.vtkAppendPolyData() apd.AddInputData(sphere.GetOutput()) apd.Update() #adding model node poly data! Here there are sphere's data!!! modelNode.SetAndObservePolyData(apd.GetOutput()) #update the scene slicer.mrmlScene.Modified() return True
def TextureMappedPlane(self, obj, event): # use dummy image data here e = vtk.vtkImageEllipsoidSource() scene = slicer.mrmlScene # Create model node model = slicer.vtkMRMLModelNode() model.SetScene(scene) model.SetName(scene.GenerateUniqueName("2DImageModel")) planeSource = vtk.vtkPlaneSource() model.SetAndObservePolyData(planeSource.GetOutput()) # 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()) modelDisplay.SetSliceIntersectionVisibility(True) modelDisplay.SetVisibility(True) # Add to scene modelDisplay.SetTextureImageDataConnection(e.GetOutputPort()) # modelDisplay.SetInputPolyDataConnection(model.GetPolyDataConnection()) scene.AddNode(model) transform = slicer.vtkMRMLLinearTransformNode() scene.AddNode(transform) model.SetAndObserveTransformNodeID(transform.GetID()) vTransform = vtk.vtkTransform() vTransform.Scale(50, 50, 50) vTransform.RotateX(30) # transform.SetAndObserveMatrixTransformToParent(vTransform.GetMatrix()) transform.SetMatrixTransformToParent(vTransform.GetMatrix())
def run(self, initialModel, inputModel, fidList, LeftBreast, volume, modelFids, reverseNormal, setInsideOut, noBreast, registrationFlag): """ Run the actual algorithm """ meanDis = 0 transformNode = slicer.vtkMRMLLinearTransformNode() if initialModel != None: #If the models need to registered if registrationFlag == True: transformNode = self.surfaceRegistration(initialModel, inputModel) meanDis = self.distanceAfterRegistration(initialModel, inputModel, fidList, transformNode) else: meanDis = self.distanceAfterRegistration(initialModel, inputModel, fidList, transformNode) # Creates the closed breast model modelNode = self.cropWithCurve(inputModel, fidList, LeftBreast, reverseNormal, setInsideOut, noBreast) self.AddVolumeNode() # Computes the volume of the closed breast model volumeVal = self.AddSegmentNode(modelNode, volume) return [volumeVal, meanDis] logging.info('Processing completed')
def surfaceRegistration(self, initialModel, inputModel): # Registers the input scan to the initial scan where the breast boundaries were defined # Uses ICP to create the transform icpTransform = vtk.vtkIterativeClosestPointTransform() icpTransform.SetSource(initialModel.GetPolyData()) icpTransform.SetTarget(inputModel.GetPolyData()) icpTransform.GetLandmarkTransform().SetModeToRigidBody() icpTransform.SetMaximumNumberOfIterations(100) icpTransform.Inverse() icpTransform.Modified() icpTransform.Update() # Applies the transform transformNode = slicer.vtkMRMLLinearTransformNode() transformNode.SetAndObserveMatrixTransformToParent(icpTransform.GetMatrix()) slicer.mrmlScene.AddNode(transformNode) inputModel.SetAndObserveTransformNodeID(transformNode.GetID()) inputModel.HardenTransform() return transformNode
def setupMRMLTracking(self): """ For the tracking endpoint this creates a kind of 'cursor' in the scene. Adds "trackingDevice" (model node) to self. """ if not hasattr(self, "trackingDevice"): """ set up the mrml parts or use existing """ nodes = slicer.mrmlScene.GetNodesByName('trackingDevice') if nodes.GetNumberOfItems() > 0: self.trackingDevice = nodes.GetItemAsObject(0) nodes = slicer.mrmlScene.GetNodesByName('tracker') self.tracker = nodes.GetItemAsObject(0) else: # trackingDevice cursor self.cube = vtk.vtkCubeSource() self.cube.SetXLength(30) self.cube.SetYLength(70) self.cube.SetZLength(5) self.cube.Update() # display node self.modelDisplay = slicer.vtkMRMLModelDisplayNode() self.modelDisplay.SetColor(1, 1, 0) # yellow slicer.mrmlScene.AddNode(self.modelDisplay) # self.modelDisplay.SetPolyData(self.cube.GetOutputPort()) # Create model node self.trackingDevice = slicer.vtkMRMLModelNode() self.trackingDevice.SetScene(slicer.mrmlScene) self.trackingDevice.SetName("trackingDevice") self.trackingDevice.SetAndObservePolyData( self.cube.GetOutputDataObject(0)) self.trackingDevice.SetAndObserveDisplayNodeID( self.modelDisplay.GetID()) slicer.mrmlScene.AddNode(self.trackingDevice) # tracker self.tracker = slicer.vtkMRMLLinearTransformNode() self.tracker.SetName('tracker') slicer.mrmlScene.AddNode(self.tracker) self.trackingDevice.SetAndObserveTransformNodeID( self.tracker.GetID())
def rigidVolumeRegistration(self, fixedVolume, movingVolume, movingBinaryVolume = None, fixedBinaryVolume = None, Rigid = True, RigidScale = False): parameters = {} brainsFit = slicer.modules.brainsfit parameters['fixedVolume'] = fixedVolume.GetID() parameters ['movingVolume'] = movingVolume.GetID() # parameters["initialTransform"] = initialTransform.GetID() parameters["useRigid"] = Rigid parameters["useRigid"] = RigidScale parameters["useScaleVersor3D"] = True outputTransform = slicer.vtkMRMLLinearTransformNode() outputTransform.SetName('PreopToIntraopAutoRegTransform') slicer.mrmlScene.AddNode(outputTransform) parameters ["outputTransform"] = outputTransform.GetID() parameters['fixedBinaryVolume'] = fixedBinaryVolume parameters['movingBinaryVolume'] = movingBinaryVolume cliBrainsFitNode = slicer.cli.run(brainsFit, None, parameters) waitCount = 0 while cliBrainsFitNode.GetStatusString() != 'Completed': print( "Performing Deformable Registration... %d" % waitCount ) #print cliBrainsFitNode.GetStatusString() waitCount += 1 print("Automatic Rigid Registration Completed.")
def createTransformPoints(randErr, N): Scale = 30.0 Sigma = randErr # radius of random error fromNormCoordinates = numpy.random.rand(N, 3) # An array of random numbers noise = numpy.random.normal(0.0, Sigma, N * 3) # Homework for Jan 24: referenceToRas = slicer.vtkMRMLLinearTransformNode() slicer.mrmlScene.AddNode(referenceToRas) referenceToRas.SetName('ReferenceToRas') referenceFids = slicer.vtkMRMLMarkupsFiducialNode() referenceFids.SetName('ReferenceFiducials') slicer.mrmlScene.AddNode(referenceFids) referenceFids.GetDisplayNode().SetSelectedColor(0, 0, 1) RASFids = slicer.vtkMRMLMarkupsFiducialNode() RASFids.SetName('RASFiducials') slicer.mrmlScene.AddNode(RASFids) RASFids.GetDisplayNode().SetSelectedColor(1, 1, 0) alphaPoints = vtk.vtkPoints() betaPoints = vtk.vtkPoints() for i in range(N): x = (fromNormCoordinates[i, 0] - 0.5) * Scale y = (fromNormCoordinates[i, 1] - 0.5) * Scale z = (fromNormCoordinates[i, 2] - 0.5) * Scale numFids = referenceFids.AddFiducial(x, y, z) numPoints = alphaPoints.InsertNextPoint(x, y, z) xx = x + noise[i * 3] yy = y + noise[i * 3 + 1] zz = z + noise[i * 3 + 2] numFids = RASFids.AddFiducial(xx, yy, zz) numPoints = betaPoints.InsertNextPoint(xx, yy, zz) return [alphaPoints, betaPoints, referenceToRas]
def __init__(self, path, fiducialListNode): fids = fiducialListNode scene = slicer.mrmlScene points = vtk.vtkPoints() polyData = vtk.vtkPolyData() polyData.SetPoints(points) lines = vtk.vtkCellArray() polyData.SetLines(lines) linesIDArray = lines.GetData() linesIDArray.Reset() linesIDArray.InsertNextTuple1(0) polygons = vtk.vtkCellArray() polyData.SetPolys( polygons ) idArray = polygons.GetData() idArray.Reset() idArray.InsertNextTuple1(0) for point in path: pointIndex = points.InsertNextPoint(*point) linesIDArray.InsertNextTuple1(pointIndex) linesIDArray.SetTuple1( 0, linesIDArray.GetNumberOfTuples() - 1 ) lines.SetNumberOfCells(1) import vtk.util.numpy_support as VN pointsArray = VN.vtk_to_numpy(points.GetData()) self.planePosition, self.planeNormal = self.planeFit(pointsArray.T) # Create model node model = slicer.vtkMRMLModelNode() model.SetScene(scene) model.SetName(scene.GenerateUniqueName("Path-%s" % fids.GetName())) model.SetAndObservePolyData(polyData) # Create display node modelDisplay = slicer.vtkMRMLModelDisplayNode() modelDisplay.SetColor(1,1,0) # yellow modelDisplay.SetScene(scene) scene.AddNode(modelDisplay) model.SetAndObserveDisplayNodeID(modelDisplay.GetID()) # Add to scene scene.AddNode(model) # Camera cursor sphere = vtk.vtkSphereSource() sphere.Update() # Create model node cursor = slicer.vtkMRMLModelNode() cursor.SetScene(scene) cursor.SetName(scene.GenerateUniqueName("Cursor-%s" % fids.GetName())) cursor.SetPolyDataConnection(sphere.GetOutputPort()) # Create display node cursorModelDisplay = slicer.vtkMRMLModelDisplayNode() cursorModelDisplay.SetColor(1,0,0) # red cursorModelDisplay.SetScene(scene) scene.AddNode(cursorModelDisplay) cursor.SetAndObserveDisplayNodeID(cursorModelDisplay.GetID()) # Add to scene scene.AddNode(cursor) # Create transform node transform = slicer.vtkMRMLLinearTransformNode() transform.SetName(scene.GenerateUniqueName("Transform-%s" % fids.GetName())) scene.AddNode(transform) cursor.SetAndObserveTransformNodeID(transform.GetID()) self.transform = transform
def onApplyButton(self): mvNode = self.outputSelector.currentNode() inputVolume= self.inputSelector.currentNode() """ Run the actual algorithm """ #se obtiene la escena y se obtiene el volumen 4D a partir del Volumen 4D de #entrada de la ventana desplegable escena = slicer.mrmlScene imagenvtk4D = inputVolume.GetImageData() #Se obtiene el número de volúmenes que tiene el volumen 4D numero_imagenes = inputVolume.GetNumberOfFrames() print('imagenes: ' + str(numero_imagenes)) #filtro vtk para descomponer un volumen 4D extract1 = vtk.vtkImageExtractComponents() extract1.SetInputData(imagenvtk4D) #matriz de transformación ras2ijk = vtk.vtkMatrix4x4() ijk2ras = vtk.vtkMatrix4x4() #le solicitamos al volumen original que nos devuelva sus matrices inputVolume.GetRASToIJKMatrix(ras2ijk) inputVolume.GetIJKToRASMatrix(ijk2ras) #creo un volumen nuevo volumenFijo = slicer.vtkMRMLScalarVolumeNode() volumenSalida = slicer.vtkMRMLMultiVolumeNode() #le asigno las transformaciones volumenFijo.SetRASToIJKMatrix(ras2ijk) volumenFijo.SetIJKToRASMatrix(ijk2ras) #le asigno el volumen 3D fijo imagen_fija = extract1.SetComponents(0) extract1.Update() volumenFijo.SetName('fijo') volumenFijo.SetAndObserveImageData(extract1.GetOutput()) #anado el nuevo volumen a la escena escena.AddNode(volumenFijo) #se crea un vector para guardar el número del volumen que tenga un #desplazamiento de mas de 4mm en cualquier dirección v=[] #se hace un ciclo for para registrar todos los demás volúmenes del volumen 4D #con el primer volumen que se definió como fijo frameLabelsAttr='' frames = [] volumeLabels = vtk.vtkDoubleArray() volumeLabels.SetNumberOfTuples(numero_imagenes) volumeLabels.SetNumberOfComponents(1) volumeLabels.Allocate(numero_imagenes) for i in range(numero_imagenes): # extraigo la imagen móvil en la posición i+1 ya que el primero es el fijo imagen_movil = extract1.SetComponents(i+1) #Seleccionar un volumen i+1 extract1.Update() #Creo el volumen móvil, y realizo el mismo procedimiento que con el fijo volumenMovil = slicer.vtkMRMLScalarVolumeNode(); volumenMovil.SetRASToIJKMatrix(ras2ijk) volumenMovil.SetIJKToRASMatrix(ijk2ras) volumenMovil.SetAndObserveImageData(extract1.GetOutput()) volumenMovil.SetName('movil '+str(i+1)) escena.AddNode(volumenMovil) #creamos la transformada para alinear los volúmenes transformadaSalida = slicer.vtkMRMLLinearTransformNode() transformadaSalida.SetName('Transformadaderegistro'+str(i+1)) slicer.mrmlScene.AddNode(transformadaSalida) #parámetros para la operación de registro parameters = {} #parameters['InitialTransform'] = transI.GetID() parameters['fixedVolume'] = volumenFijo.GetID() parameters['movingVolume'] = volumenMovil.GetID() parameters['transformType'] = 'Rigid' parameters['outputTransform'] = transformadaSalida.GetID() frames.append(volumenMovil) ## parameters['outputVolume']=volumenSalida.GetID() #Realizo el registro cliNode = slicer.cli.run( slicer.modules.brainsfit,None,parameters,wait_for_completion=True) #obtengo la transformada lineal que se usó en el registro transformada=escena.GetFirstNodeByName('Transformadaderegistro'+str(i+1)) #Obtengo la matriz de la transformada, esta matriz es de dimensiones 4x4 #en la cual estan todos los desplazamientos y rotaciones que se hicieron #en la transformada, a partir de ella se obtienen los volumenes que se #desplazaron mas de 4mm en cualquier direccion frameId = i; volumeLabels.SetComponent(i, 0, frameId) frameLabelsAttr += str(frameId)+',' Matriz=transformada.GetMatrixTransformToParent() LR=Matriz.GetElement(0,3)#dirección izquierda o derecha en la fila 1, columna 4 PA=Matriz.GetElement(1,3)#dirección anterior o posterior en la fila 2, columna 4 IS=Matriz.GetElement(2,3)#dirección inferior o superior en la fila 3, columna 4 #Se mira si el volumen "i" en alguna dirección tuvo un desplazamiento #mayor a 4mm, en caso de ser cierto se guarda en el vector "v" if abs(LR)>4: v.append(i+2) elif abs(PA)>4: v.append(i+2) elif abs(IS)>4: v.append(i+2) print("MovilExtent: "+str(volumenMovil.GetImageData().GetExtent())) ## print("valor de f: "+ str(volumenMovil)) frameLabelsAttr = frameLabelsAttr[:-1] mvImage = vtk.vtkImageData() mvImage.SetExtent(volumenMovil.GetImageData().GetExtent())##Se le asigna la dimensión del miltuvolumen mvImage.AllocateScalars(volumenMovil.GetImageData().GetScalarType(), numero_imagenes)##Se le asigna el tipo y número de cortes al multivolumen mvImageArray = vtk.util.numpy_support.vtk_to_numpy(mvImage.GetPointData().GetScalars())## Se crea la matriz de datos donde va a ir la imagen mat = vtk.vtkMatrix4x4() ##Se hace la conversión y se obtiene la matriz de transformación del nodo volumenMovil.GetRASToIJKMatrix(mat) mvNode.SetRASToIJKMatrix(mat) volumenMovil.GetIJKToRASMatrix(mat) mvNode.SetIJKToRASMatrix(mat) print("frameId: "+str(frameId)) print("# imag: "+str(numero_imagenes)) ## print("Long frame1: "+str(len(frame))) print("Long frames: "+str(len(frames))) ## for frameId in range(numero_imagenes): # TODO: check consistent size and orientation! frame = frames[frameId] frameImage = frame.GetImageData() frameImageArray = vtk.util.numpy_support.vtk_to_numpy(frameImage.GetPointData().GetScalars()) mvImageArray.T[frameId] = frameImageArray ##Se crea el nodo del multivolumen mvDisplayNode = slicer.mrmlScene.CreateNodeByClass('vtkMRMLMultiVolumeDisplayNode') mvDisplayNode.SetScene(slicer.mrmlScene) slicer.mrmlScene.AddNode(mvDisplayNode) mvDisplayNode.SetReferenceCount(mvDisplayNode.GetReferenceCount()-1) mvDisplayNode.SetDefaultColorMap() mvNode.SetAndObserveDisplayNodeID(mvDisplayNode.GetID()) mvNode.SetAndObserveImageData(mvImage) mvNode.SetNumberOfFrames(numero_imagenes) mvNode.SetLabelArray(volumeLabels) mvNode.SetLabelName('na') mvNode.SetAttribute('MultiVolume.FrameLabels',frameLabelsAttr) mvNode.SetAttribute('MultiVolume.NumberOfFrames',str(numero_imagenes)) mvNode.SetAttribute('MultiVolume.FrameIdentifyingDICOMTagName','NA') mvNode.SetAttribute('MultiVolume.FrameIdentifyingDICOMTagUnits','na') mvNode.SetName('MultiVolume Registrado') Helper.SetBgFgVolumes(mvNode.GetID(),None) print('Registro completo') #al terminar el ciclo for con todos los volúmenes registrados se genera una #ventana emergente con un mensaje("Registro completo!") y mostrando los #volúmenes que se desplazaron mas de 4mm qt.QMessageBox.information(slicer.util.mainWindow(),'Slicer Python','Registro completo!\nVolumenes con movimiento mayor a 4mm:\n'+str(v)) return True
def refineLandmark(self, state): """Refine the specified landmark""" # Refine landmark, or if none, do nothing # Crop images around the fiducial # Affine registration of the cropped images # Transform the fiducial using the transformation # # No need to take into account the current transformation because landmarks are in World RAS timing = False if self.VerboseMode == "Verbose": timing = True if state.logic.cropLogic is None: print( "Cannot refine landmarks. CropVolume module is not available.") if state.fixed == None or state.moving == None or state.fixedFiducials == None or state.movingFiducials == None or state.currentLandmarkName == None: print "Cannot refine landmarks. Images or landmarks not selected." return print("Refining landmark " + state.currentLandmarkName) + " using " + self.name start = time.time() volumes = (state.fixed, state.moving) (fixedVolume, movingVolume) = volumes slicer.mrmlScene.StartState(slicer.mrmlScene.BatchProcessState) landmarks = state.logic.landmarksForVolumes(volumes) cvpn = slicer.vtkMRMLCropVolumeParametersNode() cvpn.SetInterpolationMode(1) cvpn.SetVoxelBased(1) fixedPoint = [ 0, ] * 3 movingPoint = [ 0, ] * 3 (fixedFiducial, movingFiducial) = landmarks[state.currentLandmarkName] (fixedList, fixedIndex) = fixedFiducial (movingList, movingIndex) = movingFiducial # define an roi for the fixed if timing: roiStart = time.time() roiFixed = slicer.vtkMRMLAnnotationROINode() slicer.mrmlScene.AddNode(roiFixed) fixedList.GetNthFiducialPosition(fixedIndex, fixedPoint) roiFixed.SetDisplayVisibility(0) roiFixed.SelectableOff() roiFixed.SetXYZ(fixedPoint) roiFixed.SetRadiusXYZ(30, 30, 30) # crop the fixed. note we hide the display node temporarily to avoid the automated # window level calculation on temporary nodes created by cloning cvpn.SetROINodeID(roiFixed.GetID()) cvpn.SetInputVolumeNodeID(fixedVolume.GetID()) fixedDisplayNode = fixedVolume.GetDisplayNode() fixedVolume.SetAndObserveDisplayNodeID( 'This is not a valid DisplayNode ID') if timing: roiEnd = time.time() if timing: cropStart = time.time() state.logic.cropLogic.Apply(cvpn) if timing: cropEnd = time.time() croppedFixedVolume = slicer.mrmlScene.GetNodeByID( cvpn.GetOutputVolumeNodeID()) fixedVolume.SetAndObserveDisplayNodeID(fixedDisplayNode.GetID()) # define an roi for the moving if timing: roi2Start = time.time() roiMoving = slicer.vtkMRMLAnnotationROINode() slicer.mrmlScene.AddNode(roiMoving) movingList.GetNthFiducialPosition(movingIndex, movingPoint) roiMoving.SetDisplayVisibility(0) roiMoving.SelectableOff() roiMoving.SetXYZ(movingPoint) if self.LocalBRAINSFitMode == "Small": roiMoving.SetRadiusXYZ(45, 45, 45) else: roiMoving.SetRadiusXYZ(60, 60, 60) # crop the moving. note we hide the display node temporarily to avoid the automated # window level calculation on temporary nodes created by cloning cvpn.SetROINodeID(roiMoving.GetID()) cvpn.SetInputVolumeNodeID(movingVolume.GetID()) movingDisplayNode = movingVolume.GetDisplayNode() movingVolume.SetAndObserveDisplayNodeID( 'This is not a valid DisplayNode ID') if timing: roi2End = time.time() if timing: crop2Start = time.time() state.logic.cropLogic.Apply(cvpn) if timing: crop2End = time.time() croppedMovingVolume = slicer.mrmlScene.GetNodeByID( cvpn.GetOutputVolumeNodeID()) movingVolume.SetAndObserveDisplayNodeID(movingDisplayNode.GetID()) if timing: print 'Time to set up fixed ROI was ' + str(roiEnd - roiStart) + ' seconds' if timing: print 'Time to set up moving ROI was ' + str( roi2End - roi2Start) + ' seconds' if timing: print 'Time to crop fixed volume ' + str(cropEnd - cropStart) + ' seconds' if timing: print 'Time to crop moving volume ' + str(crop2End - crop2Start) + ' seconds' # transform = slicer.vtkMRMLLinearTransformNode() slicer.mrmlScene.AddNode(transform) matrix = vtk.vtkMatrix4x4() # define the registration parameters minPixelSpacing = min(croppedFixedVolume.GetSpacing()) parameters = {} parameters['fixedVolume'] = croppedFixedVolume.GetID() parameters['movingVolume'] = croppedMovingVolume.GetID() parameters['linearTransform'] = transform.GetID() parameters['useRigid'] = True parameters['initializeTransformMode'] = 'useGeometryAlign' parameters['samplingPercentage'] = 0.2 parameters['minimumStepLength'] = 0.1 * minPixelSpacing parameters['maximumStepLength'] = minPixelSpacing # run the registration if timing: regStart = time.time() slicer.cli.run(slicer.modules.brainsfit, None, parameters, wait_for_completion=True) if timing: regEnd = time.time() if timing: print 'Time for local registration ' + str(regEnd - regStart) + ' seconds' # apply the local transform to the landmark #print transform if timing: resultStart = time.time() transform.GetMatrixTransformToWorld(matrix) matrix.Invert() tp = [ 0, ] * 4 tp = matrix.MultiplyPoint(fixedPoint + [ 1, ]) #print fixedPoint, movingPoint, tp[:3] movingList.SetNthFiducialPosition(movingIndex, tp[0], tp[1], tp[2]) if timing: resultEnd = time.time() if timing: print 'Time for transforming landmark was ' + str( resultEnd - resultStart) + ' seconds' # clean up cropped volmes, need to reset the foreground/background display before we delete it if timing: cleanUpStart = time.time() slicer.mrmlScene.RemoveNode(croppedFixedVolume) slicer.mrmlScene.RemoveNode(croppedMovingVolume) slicer.mrmlScene.RemoveNode(roiFixed) slicer.mrmlScene.RemoveNode(roiMoving) slicer.mrmlScene.RemoveNode(transform) roiFixed = None roiMoving = None transform = None matrix = None if timing: cleanUpEnd = time.time() if timing: print 'Cleanup took ' + str(cleanUpEnd - cleanUpStart) + ' seconds' end = time.time() print 'Refined landmark ' + state.currentLandmarkName + ' in ' + str( end - start) + ' seconds' slicer.mrmlScene.EndState(slicer.mrmlScene.BatchProcessState)
def TestSection_04_RegisterDay2CTToDay1CT(self): try: scene = slicer.mrmlScene slicer.util.selectModule('BRAINSFit') brainsFit = slicer.modules.brainsfit # Hide isodose shNode = slicer.vtkMRMLSubjectHierarchyNode.GetSubjectHierarchyNode(slicer.mrmlScene) self.assertIsNotNone( shNode ) day2IsodoseShItemID = shNode.GetItemByDataNode(slicer.util.getNode(self.day2IsodosesName)) shNode.SetDisplayVisibilityForBranch(day2IsodoseShItemID, 0) # Register Day 2 CT to Day 1 CT using rigid registration self.delayDisplay("Register Day 2 CT to Day 1 CT using rigid registration.\n It may take a few minutes...",self.delayMs) parametersRigid = {} day1CT = slicer.util.getNode(self.day1CTName) parametersRigid["fixedVolume"] = day1CT.GetID() day2CT = slicer.util.getNode(self.day2CTName) parametersRigid["movingVolume"] = day2CT.GetID() linearTransform = slicer.vtkMRMLLinearTransformNode() linearTransform.SetName(self.transformDay2ToDay1RigidName) slicer.mrmlScene.AddNode( linearTransform ) parametersRigid["linearTransform"] = linearTransform.GetID() parametersRigid["useRigid"] = True parametersRigid["samplingPercentage"] = 0.0002 self.cliBrainsFitRigidNode = None self.cliBrainsFitRigidNode = slicer.cli.run(brainsFit, None, parametersRigid) waitCount = 0 while self.cliBrainsFitRigidNode.GetStatusString() != 'Completed' and waitCount < 200: self.delayDisplay( "Register Day 2 CT to Day 1 CT using rigid registration... %d" % waitCount ) waitCount += 1 self.delayDisplay("Register Day 2 CT to Day 1 CT using rigid registration finished",self.delayMs) self.assertEqual( self.cliBrainsFitRigidNode.GetStatusString(), 'Completed' ) # Register Day 2 CT to Day 1 CT using BSpline registration # TODO: Move this to workflow 2 # if self.performDeformableRegistration: # self.delayDisplay("Register Day 2 CT to Day 1 CT using BSpline registration.\n It may take a few minutes...",self.delayMs) # parametersBSpline = {} # parametersBSpline["fixedVolume"] = day1CT.GetID() # parametersBSpline["movingVolume"] = day2CT.GetID() # parametersBSpline["initialTransform"] = linearTransform.GetID() # bsplineTransform = slicer.vtkMRMLBSplineTransformNode() # bsplineTransform.SetName(self.transformDay2ToDay1BSplineName) # slicer.mrmlScene.AddNode( bsplineTransform ) # parametersBSpline["bsplineTransform"] = bsplineTransform.GetID() # parametersBSpline["useBSpline"] = True # self.cliBrainsFitBSplineNode = None # self.cliBrainsFitBSplineNode = slicer.cli.run(brainsFit, None, parametersBSpline) # waitCount = 0 # while self.cliBrainsFitBSplineNode.GetStatusString() != 'Completed' and waitCount < 600: # self.delayDisplay( "Register Day 2 CT to Day 1 CT using BSpline registration... %d" % waitCount ) # waitCount += 1 # self.delayDisplay("Register Day 2 CT to Day 1 CT using BSpline registration finished",self.delayMs) # self.assertEqual( self.cliBrainsFitBSplineNode.GetStatusString(), 'Completed' ) except Exception, e: import traceback traceback.print_exc() self.delayDisplay('Test caused exception!\n' + str(e),self.delayMs*2) raise Exception("Exception occurred, handled, thrown further to workflow level")
def __init__(self): self.toolTipToTool = slicer.util.getNode('toolTipToTool') self.pointerTipToReference = None self.targetCreatedTransformed = False self.firstFiducial = True if not self.toolTipToTool: self.toolTipToTool=slicer.vtkMRMLLinearTransformNode() self.toolTipToTool.SetName("toolTipToTool") m = vtk.vtkMatrix4x4() m.SetElement( 0, 0, 1 ) # Row 1 m.SetElement( 0, 1, 0 ) m.SetElement( 0, 2, 0 ) m.SetElement( 0, 3, 0 ) m.SetElement( 1, 0, 0 ) # Row 2 m.SetElement( 1, 1, 1 ) m.SetElement( 1, 2, 0 ) m.SetElement( 1, 3, 0 ) m.SetElement( 2, 0, 0 ) # Row 3 m.SetElement( 2, 1, 0 ) m.SetElement( 2, 2, 1 ) m.SetElement( 2, 3, 0 ) self.toolTipToTool.SetMatrixTransformToParent(m) slicer.mrmlScene.AddNode(self.toolTipToTool) self.line = slicer.util.getNode('Line') if not self.line: self.line = slicer.vtkMRMLModelNode() self.line.SetName('Line') linePolyData = vtk.vtkPolyData() self.line.SetAndObservePolyData(linePolyData) modelDisplay = slicer.vtkMRMLModelDisplayNode() modelDisplay.SetSliceIntersectionVisibility(True) modelDisplay.SetColor(0,1,0) slicer.mrmlScene.AddNode(modelDisplay) self.line.SetAndObserveDisplayNodeID(modelDisplay.GetID()) slicer.mrmlScene.AddNode(self.line) # VTK objects self.transformPolyDataFilter = vtk.vtkTransformPolyDataFilter() self.cellLocator = vtk.vtkCellLocator() # 3D View threeDWidget = slicer.app.layoutManager().threeDWidget(0) self.threeDView = threeDWidget.threeDView() self.callbackObserverTag = -1 self.observerTag=None # Output Distance Label self.outputDistanceLabel=None import Viewpoint # Viewpoint Module must have been added to Slicer self.viewpointLogic = Viewpoint.ViewpointLogic() # Camera transformations self.needleCameraToNeedle = slicer.util.getNode('needleCameraToNeedle') if not self.needleCameraToNeedle: self.needleCameraToNeedle=slicer.vtkMRMLLinearTransformNode() self.needleCameraToNeedle.SetName("needleCameraToNeedle") matrixNeedleCamera = vtk.vtkMatrix4x4() matrixNeedleCamera.SetElement( 0, 0, -0.05 ) # Row 1 matrixNeedleCamera.SetElement( 0, 1, 0.09 ) matrixNeedleCamera.SetElement( 0, 2, -0.99 ) matrixNeedleCamera.SetElement( 0, 3, 60.72 ) matrixNeedleCamera.SetElement( 1, 0, -0.01 ) # Row 2 matrixNeedleCamera.SetElement( 1, 1, 1 ) matrixNeedleCamera.SetElement( 1, 2, 0.09 ) matrixNeedleCamera.SetElement( 1, 3, 12.17 ) matrixNeedleCamera.SetElement( 2, 0, 1 ) # Row 3 matrixNeedleCamera.SetElement( 2, 1, 0.01 ) matrixNeedleCamera.SetElement( 2, 2, -0.05 ) matrixNeedleCamera.SetElement( 2, 3, -7.26 ) self.needleCameraToNeedle.SetMatrixTransformToParent(matrixNeedleCamera) slicer.mrmlScene.AddNode(self.needleCameraToNeedle) self.pointerCameraToPointer = slicer.util.getNode('pointerCameraToPointer') if not self.pointerCameraToPointer: self.pointerCameraToPointer=slicer.vtkMRMLLinearTransformNode() self.pointerCameraToPointer.SetName("pointerCameraToPointer") matrixPointerCamera = vtk.vtkMatrix4x4() matrixPointerCamera.SetElement( 0, 0, -0.05 ) # Row 1 matrixPointerCamera.SetElement( 0, 1, 0.09 ) matrixPointerCamera.SetElement( 0, 2, -0.99 ) matrixPointerCamera.SetElement( 0, 3, 121.72 ) matrixPointerCamera.SetElement( 1, 0, -0.01 ) # Row 2 matrixPointerCamera.SetElement( 1, 1, 1 ) matrixPointerCamera.SetElement( 1, 2, 0.09 ) matrixPointerCamera.SetElement( 1, 3, 17.17 ) matrixPointerCamera.SetElement( 2, 0, 1 ) # Row 3 matrixPointerCamera.SetElement( 2, 1, 0.01 ) matrixPointerCamera.SetElement( 2, 2, -0.05 ) matrixPointerCamera.SetElement( 2, 3, -7.26 ) self.pointerCameraToPointer.SetMatrixTransformToParent(matrixPointerCamera) slicer.mrmlScene.AddNode(self.pointerCameraToPointer) # Tranformations to fix models orientation self.needleModelToNeedleTip = slicer.util.getNode('needleModelToNeedleTip') if not self.needleModelToNeedleTip: self.needleModelToNeedleTip=slicer.vtkMRMLLinearTransformNode() self.needleModelToNeedleTip.SetName("needleModelToNeedleTip") matrixNeedleModel = vtk.vtkMatrix4x4() matrixNeedleModel.SetElement( 0, 0, -1 ) # Row 1 matrixNeedleModel.SetElement( 0, 1, 0 ) matrixNeedleModel.SetElement( 0, 2, 0 ) matrixNeedleModel.SetElement( 0, 3, 0 ) matrixNeedleModel.SetElement( 1, 0, 0 ) # Row 2 matrixNeedleModel.SetElement( 1, 1, 1 ) matrixNeedleModel.SetElement( 1, 2, 0 ) matrixNeedleModel.SetElement( 1, 3, 0 ) matrixNeedleModel.SetElement( 2, 0, 0 ) # Row 3 matrixNeedleModel.SetElement( 2, 1, 0 ) matrixNeedleModel.SetElement( 2, 2, -1 ) matrixNeedleModel.SetElement( 2, 3, 0 ) self.needleModelToNeedleTip.SetMatrixTransformToParent(matrixNeedleModel) slicer.mrmlScene.AddNode(self.needleModelToNeedleTip) self.pointerModelToPointerTip = slicer.util.getNode('pointerModelToPointerTip') if not self.pointerModelToPointerTip: self.pointerModelToPointerTip=slicer.vtkMRMLLinearTransformNode() self.pointerModelToPointerTip.SetName("pointerModelToPointerTip") matrixPointerModel = vtk.vtkMatrix4x4() matrixPointerModel.SetElement( 0, 0, 0 ) # Row 1 matrixPointerModel.SetElement( 0, 1, 0 ) matrixPointerModel.SetElement( 0, 2, 1 ) matrixPointerModel.SetElement( 0, 3, 0 ) matrixPointerModel.SetElement( 1, 0, 0 ) # Row 2 matrixPointerModel.SetElement( 1, 1, 1 ) matrixPointerModel.SetElement( 1, 2, 0 ) matrixPointerModel.SetElement( 1, 3, 0 ) matrixPointerModel.SetElement( 2, 0, -1 ) # Row 3 matrixPointerModel.SetElement( 2, 1, 0 ) matrixPointerModel.SetElement( 2, 2, 0 ) matrixPointerModel.SetElement( 2, 3, 0 ) self.pointerModelToPointerTip.SetMatrixTransformToParent(matrixPointerModel) slicer.mrmlScene.AddNode(self.pointerModelToPointerTip) self.fRBLToSLPR = slicer.util.getNode('FRBLToSLPR') if not self.fRBLToSLPR: self.fRBLToSLPR = slicer.vtkMRMLLinearTransformNode() self.fRBLToSLPR.SetName('FRBLToSLPR') slicer.mrmlScene.AddNode(self.fRBLToSLPR) # Create fiducials to orientate model self.fiducialsFRBL = slicer.util.getNode('FiducialsFRBL') if not self.fiducialsFRBL: self.fiducialsFRBL = slicer.vtkMRMLMarkupsFiducialNode() self.fiducialsFRBL.SetName('FiducialsFRBL') slicer.mrmlScene.AddNode(self.fiducialsFRBL) self.fiducialsFRBL.SetDisplayVisibility(False) self.fiducialsSLPR = slicer.util.getNode('FiducialsSLPR') if not self.fiducialsSLPR: self.fiducialsSLPR = slicer.vtkMRMLMarkupsFiducialNode() self.fiducialsSLPR.SetName('FiducialsSLPR') self.fiducialsSLPR.AddFiducial(0, 100, 0) self.fiducialsSLPR.SetNthFiducialLabel(0, 'S') self.fiducialsSLPR.AddFiducial(-100, 0, 0) self.fiducialsSLPR.SetNthFiducialLabel(1, 'L') self.fiducialsSLPR.AddFiducial(0, -100, 0) self.fiducialsSLPR.SetNthFiducialLabel(2, 'P') self.fiducialsSLPR.AddFiducial(100, 0, 0) self.fiducialsSLPR.SetNthFiducialLabel(3, 'R') slicer.mrmlScene.AddNode(self.fiducialsSLPR) self.fiducialsSLPR.SetDisplayVisibility(False)
def createDummyTransform(self): transformNode = slicer.vtkMRMLLinearTransformNode() slicer.mrmlScene.AddNode(transformNode) return transformNode
def __init__(self, path, fiducialListNode): fids = fiducialListNode scene = slicer.mrmlScene points = vtk.vtkPoints() polyData = vtk.vtkPolyData() polyData.SetPoints(points) lines = vtk.vtkCellArray() polyData.SetLines(lines) linesIDArray = lines.GetData() linesIDArray.Reset() linesIDArray.InsertNextTuple1(0) polygons = vtk.vtkCellArray() polyData.SetPolys( polygons ) idArray = polygons.GetData() idArray.Reset() idArray.InsertNextTuple1(0) for point in path: pointIndex = points.InsertNextPoint(*point) linesIDArray.InsertNextTuple1(pointIndex) linesIDArray.SetTuple1( 0, linesIDArray.GetNumberOfTuples() - 1 ) lines.SetNumberOfCells(1) # Create model node model = slicer.vtkMRMLModelNode() model.SetScene(scene) model.SetName(scene.GenerateUniqueName("Path-%s" % fids.GetName())) model.SetAndObservePolyData(polyData) # Create display node modelDisplay = slicer.vtkMRMLModelDisplayNode() modelDisplay.SetColor(1,1,0) # yellow modelDisplay.SetScene(scene) scene.AddNode(modelDisplay) model.SetAndObserveDisplayNodeID(modelDisplay.GetID()) # Add to scene if vtk.VTK_MAJOR_VERSION <= 5: # shall not be needed. modelDisplay.SetInputPolyData(model.GetPolyData()) scene.AddNode(model) # Camera cursor sphere = vtk.vtkSphereSource() sphere.Update() # Create model node cursor = slicer.vtkMRMLModelNode() cursor.SetScene(scene) cursor.SetName(scene.GenerateUniqueName("Cursor-%s" % fids.GetName())) if vtk.VTK_MAJOR_VERSION <= 5: cursor.SetAndObservePolyData(sphere.GetOutput()) else: cursor.SetPolyDataConnection(sphere.GetOutputPort()) # Create display node cursorModelDisplay = slicer.vtkMRMLModelDisplayNode() cursorModelDisplay.SetColor(1,0,0) # red cursorModelDisplay.SetScene(scene) scene.AddNode(cursorModelDisplay) cursor.SetAndObserveDisplayNodeID(cursorModelDisplay.GetID()) # Add to scene if vtk.VTK_MAJOR_VERSION <= 5: # Shall not be needed. cursorModelDisplay.SetInputPolyData(sphere.GetOutput()) scene.AddNode(cursor) # Create transform node transform = slicer.vtkMRMLLinearTransformNode() transform.SetName(scene.GenerateUniqueName("Transform-%s" % fids.GetName())) scene.AddNode(transform) cursor.SetAndObserveTransformNodeID(transform.GetID()) self.transform = transform
def TestSection_03_qMRMLSegmentationGeometryWidget(self): logging.info('Test section 2: qMRMLSegmentationGeometryWidget') binaryLabelmapReprName = slicer.vtkSegmentationConverter.GetBinaryLabelmapRepresentationName( ) closedSurfaceReprName = slicer.vtkSegmentationConverter.GetClosedSurfaceRepresentationName( ) # Use MRHead and Tinypatient for testing import SampleData mrVolumeNode = SampleData.downloadSample("MRHead") [tinyVolumeNode, tinySegmentationNode] = SampleData.downloadSamples('TinyPatient') # Convert MRHead to oriented image data import vtkSlicerSegmentationsModuleLogicPython as vtkSlicerSegmentationsModuleLogic mrOrientedImageData = vtkSlicerSegmentationsModuleLogic.vtkSlicerSegmentationsModuleLogic.CreateOrientedImageDataFromVolumeNode( mrVolumeNode) mrOrientedImageData.UnRegister(None) # Create segmentation node with binary labelmap master and one segment with MRHead geometry segmentationNode = slicer.mrmlScene.AddNewNodeByClass( 'vtkMRMLSegmentationNode') segmentationNode.GetSegmentation().SetMasterRepresentationName( binaryLabelmapReprName) geometryStr = slicer.vtkSegmentationConverter.SerializeImageGeometry( mrOrientedImageData) segmentationNode.GetSegmentation().SetConversionParameter( slicer.vtkSegmentationConverter. GetReferenceImageGeometryParameterName(), geometryStr) threshold = vtk.vtkImageThreshold() threshold.SetInputData(mrOrientedImageData) threshold.ThresholdByUpper(16.0) threshold.SetInValue(1) threshold.SetOutValue(0) threshold.SetOutputScalarType(vtk.VTK_UNSIGNED_CHAR) threshold.Update() segmentOrientedImageData = slicer.vtkOrientedImageData() segmentOrientedImageData.DeepCopy(threshold.GetOutput()) mrImageToWorldMatrix = vtk.vtkMatrix4x4() mrOrientedImageData.GetImageToWorldMatrix(mrImageToWorldMatrix) segmentOrientedImageData.SetImageToWorldMatrix(mrImageToWorldMatrix) segment = slicer.vtkSegment() segment.SetName('Brain') segment.SetColor(0.0, 0.0, 1.0) segment.AddRepresentation(binaryLabelmapReprName, segmentOrientedImageData) segmentationNode.GetSegmentation().AddSegment(segment) # Create geometry widget geometryWidget = slicer.qMRMLSegmentationGeometryWidget() geometryWidget.setSegmentationNode(segmentationNode) geometryWidget.editEnabled = True geometryImageData = slicer.vtkOrientedImageData( ) # To contain the output later # Volume source with no transforms geometryWidget.setSourceNode(tinyVolumeNode) geometryWidget.geometryImageData(geometryImageData) self.assertTrue( self.compareOutputGeometry( geometryImageData, (49, 49, 23), (248.8439, 248.2890, -123.75), [[-1.0, 0.0, 0.0], [0.0, -1.0, 0.0], [0.0, 0.0, 1.0]])) slicer.vtkOrientedImageDataResample.ResampleOrientedImageToReferenceOrientedImage( segmentOrientedImageData, geometryImageData, geometryImageData, False, True) self.assertEqual(self.getForegroundVoxelCount(geometryImageData), 92) # Transformed volume source translationTransformMatrix = vtk.vtkMatrix4x4() translationTransformMatrix.SetElement(0, 3, 24.5) translationTransformMatrix.SetElement(1, 3, 24.5) translationTransformMatrix.SetElement(2, 3, 11.5) translationTransformNode = slicer.vtkMRMLLinearTransformNode() translationTransformNode.SetName('TestTranslation') slicer.mrmlScene.AddNode(translationTransformNode) translationTransformNode.SetMatrixTransformToParent( translationTransformMatrix) tinyVolumeNode.SetAndObserveTransformNodeID( translationTransformNode.GetID()) geometryWidget.geometryImageData(geometryImageData) self.assertTrue( self.compareOutputGeometry( geometryImageData, (49, 49, 23), (273.3439, 272.7890, -112.25), [[-1.0, 0.0, 0.0], [0.0, -1.0, 0.0], [0.0, 0.0, 1.0]])) slicer.vtkOrientedImageDataResample.ResampleOrientedImageToReferenceOrientedImage( segmentOrientedImageData, geometryImageData, geometryImageData, False, True) self.assertEqual(self.getForegroundVoxelCount(geometryImageData), 94) # Volume source with isotropic spacing tinyVolumeNode.SetAndObserveTransformNodeID(None) geometryWidget.setIsotropicSpacing(True) geometryWidget.geometryImageData(geometryImageData) self.assertTrue( self.compareOutputGeometry( geometryImageData, (23, 23, 23), (248.8439, 248.2890, -123.75), [[-1.0, 0.0, 0.0], [0.0, -1.0, 0.0], [0.0, 0.0, 1.0]])) slicer.vtkOrientedImageDataResample.ResampleOrientedImageToReferenceOrientedImage( segmentOrientedImageData, geometryImageData, geometryImageData, False, True) self.assertEqual(self.getForegroundVoxelCount(geometryImageData), 414) # Volume source with oversampling geometryWidget.setIsotropicSpacing(False) geometryWidget.setOversamplingFactor(2.0) geometryWidget.geometryImageData(geometryImageData) self.assertTrue( self.compareOutputGeometry( geometryImageData, (24.5, 24.5, 11.5), (261.0939, 260.5390, -129.5), [[-1.0, 0.0, 0.0], [0.0, -1.0, 0.0], [0.0, 0.0, 1.0]])) slicer.vtkOrientedImageDataResample.ResampleOrientedImageToReferenceOrientedImage( segmentOrientedImageData, geometryImageData, geometryImageData, False, True) self.assertEqual(self.getForegroundVoxelCount(geometryImageData), 751) slicer.util.delayDisplay('Volume source cases - OK') # Segmentation source with binary labelmap master geometryWidget.setOversamplingFactor(1.0) geometryWidget.setSourceNode(tinySegmentationNode) geometryWidget.geometryImageData(geometryImageData) self.assertTrue( self.compareOutputGeometry( geometryImageData, (49, 49, 23), (248.8439, 248.2890, -123.75), [[-1.0, 0.0, 0.0], [0.0, -1.0, 0.0], [0.0, 0.0, 1.0]])) slicer.vtkOrientedImageDataResample.ResampleOrientedImageToReferenceOrientedImage( segmentOrientedImageData, geometryImageData, geometryImageData, False, True) self.assertEqual(self.getForegroundVoxelCount(geometryImageData), 92) # Segmentation source with closed surface master tinySegmentationNode.GetSegmentation().SetConversionParameter( 'Smoothing factor', '0.0') self.assertTrue( tinySegmentationNode.GetSegmentation().CreateRepresentation( closedSurfaceReprName)) tinySegmentationNode.GetSegmentation().SetMasterRepresentationName( closedSurfaceReprName) tinySegmentationNode.Modified( ) # Trigger re-calculation of geometry (only generic Modified event is observed) geometryWidget.geometryImageData(geometryImageData) self.assertTrue( self.compareOutputGeometry( geometryImageData, (1, 1, 1), (-86.645, 133.929, 116.786), # current origin of the segmentation is kept [[0.0, 0.0, 1.0], [-1.0, 0.0, 0.0], [0.0, -1.0, 0.0]])) slicer.vtkOrientedImageDataResample.ResampleOrientedImageToReferenceOrientedImage( segmentOrientedImageData, geometryImageData, geometryImageData, False, True) self.assertEqual(self.getForegroundVoxelCount(geometryImageData), 5223040) slicer.util.delayDisplay('Segmentation source cases - OK') # Model source with no transform shNode = slicer.vtkMRMLSubjectHierarchyNode.GetSubjectHierarchyNode( slicer.mrmlScene) outputFolderId = shNode.CreateFolderItem(shNode.GetSceneItemID(), 'ModelsFolder') success = vtkSlicerSegmentationsModuleLogic.vtkSlicerSegmentationsModuleLogic.ExportVisibleSegmentsToModels( tinySegmentationNode, outputFolderId) self.assertTrue(success) modelNode = slicer.util.getNode('Body_Contour') geometryWidget.setSourceNode(modelNode) geometryWidget.geometryImageData(geometryImageData) self.assertTrue( self.compareOutputGeometry( geometryImageData, (1, 1, 1), (-86.645, 133.929, 116.786), # current origin of the segmentation is kept [[0.0, 0.0, 1.0], [-1.0, 0.0, 0.0], [0.0, -1.0, 0.0]])) slicer.vtkOrientedImageDataResample.ResampleOrientedImageToReferenceOrientedImage( segmentOrientedImageData, geometryImageData, geometryImageData, False, True) self.assertEqual(self.getForegroundVoxelCount(geometryImageData), 5223040) # Transformed model source rotationTransform = vtk.vtkTransform() rotationTransform.RotateX(45) rotationTransformMatrix = vtk.vtkMatrix4x4() rotationTransform.GetMatrix(rotationTransformMatrix) rotationTransformNode = slicer.vtkMRMLLinearTransformNode() rotationTransformNode.SetName('TestRotation') slicer.mrmlScene.AddNode(rotationTransformNode) rotationTransformNode.SetMatrixTransformToParent( rotationTransformMatrix) modelNode.SetAndObserveTransformNodeID(rotationTransformNode.GetID()) modelNode.Modified() geometryWidget.geometryImageData(geometryImageData) self.assertTrue( self.compareOutputGeometry( geometryImageData, (1, 1, 1), (-86.645, 177.282, -12.122), [[0.0, 0.0, 1.0], [-0.7071, -0.7071, 0.0], [0.7071, -0.7071, 0.0]])) slicer.vtkOrientedImageDataResample.ResampleOrientedImageToReferenceOrientedImage( segmentOrientedImageData, geometryImageData, geometryImageData, False, True) self.assertEqual(self.getForegroundVoxelCount(geometryImageData), 5229164) # ROI source roiNode = slicer.mrmlScene.AddNewNodeByClass( "vtkMRMLAnnotationROINode", 'SourceROI') xyz = [0.0, 0.0, 0.0] center = [0.0, 0.0, 0.0] slicer.vtkMRMLSliceLogic.GetVolumeRASBox(tinyVolumeNode, xyz, center) radius = [x / 2.0 for x in xyz] roiNode.SetXYZ(center) roiNode.SetRadiusXYZ(radius) geometryWidget.setSourceNode(roiNode) geometryWidget.geometryImageData(geometryImageData) self.assertTrue( self.compareOutputGeometry( geometryImageData, (1, 1, 1), (0.0, 0.0, 0.0), [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]])) slicer.vtkOrientedImageDataResample.ResampleOrientedImageToReferenceOrientedImage( segmentOrientedImageData, geometryImageData, geometryImageData, False, True) self.assertEqual(self.getForegroundVoxelCount(geometryImageData), 5224232) slicer.util.delayDisplay('Model and ROI source cases - OK') slicer.util.delayDisplay('Segmentation geometry widget test passed')
def TestSection_2_qMRMLSegmentationGeometryWidget(self): logging.info('Test section 2: qMRMLSegmentationGeometryWidget') import vtkSegmentationCore binaryLabelmapReprName = vtkSegmentationCore.vtkSegmentationConverter.GetBinaryLabelmapRepresentationName() closedSurfaceReprName = vtkSegmentationCore.vtkSegmentationConverter.GetClosedSurfaceRepresentationName() # Use MRHead and Tinypatient for testing import SampleData sampleDataLogic = SampleData.SampleDataLogic() mrVolumeNode = sampleDataLogic.downloadMRHead() [tinyVolumeNode, tinySegmentationNode] = sampleDataLogic.downloadSample('TinyPatient') # Convert MRHead to oriented image data import vtkSlicerSegmentationsModuleLogicPython as vtkSlicerSegmentationsModuleLogic mrOrientedImageData = vtkSlicerSegmentationsModuleLogic.vtkSlicerSegmentationsModuleLogic.CreateOrientedImageDataFromVolumeNode(mrVolumeNode) mrOrientedImageData.UnRegister(None) # Create segmentation node with binary labelmap master and one segment with MRHead geometry segmentationNode = slicer.vtkMRMLSegmentationNode() segmentationNode.GetSegmentation().SetMasterRepresentationName(binaryLabelmapReprName) geometryStr = vtkSegmentationCore.vtkSegmentationConverter.SerializeImageGeometry(mrOrientedImageData) segmentationNode.GetSegmentation().SetConversionParameter( vtkSegmentationCore.vtkSegmentationConverter.GetReferenceImageGeometryParameterName(), geometryStr) slicer.mrmlScene.AddNode(segmentationNode) threshold = vtk.vtkImageThreshold() threshold.SetInputData(mrOrientedImageData) threshold.ThresholdByUpper(16.0) threshold.SetInValue(1) threshold.SetOutValue(0) threshold.SetOutputScalarType(vtk.VTK_UNSIGNED_CHAR) threshold.Update() segmentOrientedImageData = vtkSegmentationCore.vtkOrientedImageData() segmentOrientedImageData.DeepCopy(threshold.GetOutput()) mrImageToWorldMatrix = vtk.vtkMatrix4x4() mrOrientedImageData.GetImageToWorldMatrix(mrImageToWorldMatrix) segmentOrientedImageData.SetImageToWorldMatrix(mrImageToWorldMatrix) segment = vtkSegmentationCore.vtkSegment() segment.SetName('Brain') segment.SetColor(0.0,0.0,1.0) segment.AddRepresentation(binaryLabelmapReprName, segmentOrientedImageData) segmentationNode.GetSegmentation().AddSegment(segment) # Create geometry widget geometryWidget = slicer.qMRMLSegmentationGeometryWidget() geometryWidget.setSegmentationNode(segmentationNode) geometryWidget.editEnabled = True geometryImageData = vtkSegmentationCore.vtkOrientedImageData() # To contain the output later # Volume source with no transforms geometryWidget.setSourceNode(tinyVolumeNode) geometryWidget.geometryImageData(geometryImageData) self.assertTrue(self.compareOutputGeometry(geometryImageData, (49,49,23), (248.8439, 248.2890, -123.75), [[-1.0, 0.0, 0.0], [0.0, -1.0, 0.0], [0.0, 0.0, 1.0]])) vtkSegmentationCore.vtkOrientedImageDataResample.ResampleOrientedImageToReferenceOrientedImage( segmentOrientedImageData, geometryImageData, geometryImageData, False, True) self.assertEqual(self.getForegroundVoxelCount(geometryImageData), 92) # Transformed volume source translationTransformMatrix = vtk.vtkMatrix4x4() translationTransformMatrix.SetElement(0,3,24.5) translationTransformMatrix.SetElement(1,3,24.5) translationTransformMatrix.SetElement(2,3,11.5) translationTransformNode = slicer.vtkMRMLLinearTransformNode() translationTransformNode.SetName('TestTranslation') slicer.mrmlScene.AddNode(translationTransformNode) translationTransformNode.SetMatrixTransformToParent(translationTransformMatrix) tinyVolumeNode.SetAndObserveTransformNodeID(translationTransformNode.GetID()) geometryWidget.geometryImageData(geometryImageData) self.assertTrue(self.compareOutputGeometry(geometryImageData, (49,49,23), (224.3439, 223.7890, -135.25), [[-1.0, 0.0, 0.0], [0.0, -1.0, 0.0], [0.0, 0.0, 1.0]])) vtkSegmentationCore.vtkOrientedImageDataResample.ResampleOrientedImageToReferenceOrientedImage( segmentOrientedImageData, geometryImageData, geometryImageData, False, True) self.assertEqual(self.getForegroundVoxelCount(geometryImageData), 94) # Volume source with isotropic spacing tinyVolumeNode.SetAndObserveTransformNodeID(None) geometryWidget.setIsotropicSpacing(True) geometryWidget.geometryImageData(geometryImageData) self.assertTrue(self.compareOutputGeometry(geometryImageData, (23,23,23), (248.8439, 248.2890, -123.75), [[-1.0, 0.0, 0.0], [0.0, -1.0, 0.0], [0.0, 0.0, 1.0]])) vtkSegmentationCore.vtkOrientedImageDataResample.ResampleOrientedImageToReferenceOrientedImage( segmentOrientedImageData, geometryImageData, geometryImageData, False, True) self.assertEqual(self.getForegroundVoxelCount(geometryImageData), 414) # Volume source with oversampling geometryWidget.setIsotropicSpacing(False) geometryWidget.setOversamplingFactor(2.0) geometryWidget.geometryImageData(geometryImageData) self.assertTrue(self.compareOutputGeometry(geometryImageData, (24.5, 24.5, 11.5), (261.0939, 260.5390, -129.5), [[-1.0, 0.0, 0.0], [0.0, -1.0, 0.0], [0.0, 0.0, 1.0]])) vtkSegmentationCore.vtkOrientedImageDataResample.ResampleOrientedImageToReferenceOrientedImage( segmentOrientedImageData, geometryImageData, geometryImageData, False, True) self.assertEqual(self.getForegroundVoxelCount(geometryImageData), 751) slicer.util.delayDisplay('Volume source cases - OK') # Segmentation source with binary labelmap master geometryWidget.setOversamplingFactor(1.0) geometryWidget.setSourceNode(tinySegmentationNode) geometryWidget.geometryImageData(geometryImageData) self.assertTrue(self.compareOutputGeometry(geometryImageData, (49,49,23), (248.8439, 248.2890, -123.75), [[-1.0, 0.0, 0.0], [0.0, -1.0, 0.0], [0.0, 0.0, 1.0]])) vtkSegmentationCore.vtkOrientedImageDataResample.ResampleOrientedImageToReferenceOrientedImage( segmentOrientedImageData, geometryImageData, geometryImageData, False, True) self.assertEqual(self.getForegroundVoxelCount(geometryImageData), 92) # Segmentation source with closed surface master tinySegmentationNode.GetSegmentation().SetConversionParameter('Smoothing factor', '0.0') self.assertTrue(tinySegmentationNode.GetSegmentation().CreateRepresentation(closedSurfaceReprName)) tinySegmentationNode.GetSegmentation().SetMasterRepresentationName(closedSurfaceReprName) tinySegmentationNode.Modified() # Trigger re-calculation of geometry (only generic Modified event is observed) geometryWidget.geometryImageData(geometryImageData) self.assertTrue(self.compareOutputGeometry(geometryImageData, (1,1,1), (-167.156, -217.711, -135.75), [[0.0, 0.0, 1.0], [-1.0, 0.0, 0.0], [0.0, -1.0, 0.0]])) vtkSegmentationCore.vtkOrientedImageDataResample.ResampleOrientedImageToReferenceOrientedImage( segmentOrientedImageData, geometryImageData, geometryImageData, False, True) self.assertEqual(self.getForegroundVoxelCount(geometryImageData), 5223846) slicer.util.delayDisplay('Segmentation source cases - OK') # Model source with no transform outputModelHierarchy = slicer.vtkMRMLModelHierarchyNode() slicer.mrmlScene.AddNode(outputModelHierarchy) success = vtkSlicerSegmentationsModuleLogic.vtkSlicerSegmentationsModuleLogic.ExportVisibleSegmentsToModelHierarchy( tinySegmentationNode, outputModelHierarchy ) self.assertTrue(success) modelNode = slicer.util.getNode('Body_Contour') geometryWidget.setSourceNode(modelNode) geometryWidget.geometryImageData(geometryImageData) self.assertTrue(self.compareOutputGeometry(geometryImageData, (1,1,1), (-167.156, -217.711, -135.75), [[0.0, 0.0, 1.0], [-1.0, 0.0, 0.0], [0.0, -1.0, 0.0]])) vtkSegmentationCore.vtkOrientedImageDataResample.ResampleOrientedImageToReferenceOrientedImage( segmentOrientedImageData, geometryImageData, geometryImageData, False, True) self.assertEqual(self.getForegroundVoxelCount(geometryImageData), 5223846) # Transformed model source rotationTransform = vtk.vtkTransform() rotationTransform.RotateX(45) rotationTransformMatrix = vtk.vtkMatrix4x4() rotationTransform.GetMatrix(rotationTransformMatrix) rotationTransformNode = slicer.vtkMRMLLinearTransformNode() rotationTransformNode.SetName('TestRotation') slicer.mrmlScene.AddNode(rotationTransformNode) rotationTransformNode.SetMatrixTransformToParent(rotationTransformMatrix) modelNode.SetAndObserveTransformNodeID(rotationTransformNode.GetID()) modelNode.Modified() geometryWidget.geometryImageData(geometryImageData) self.assertTrue(self.compareOutputGeometry(geometryImageData, (1,1,1), (-167.156, -58.6623, -249.228), [[0.0, 0.0, 1.0], [-0.7071, -0.7071, 0.0], [0.7071, -0.7071, 0.0]])) vtkSegmentationCore.vtkOrientedImageDataResample.ResampleOrientedImageToReferenceOrientedImage( segmentOrientedImageData, geometryImageData, geometryImageData, False, True) self.assertEqual(self.getForegroundVoxelCount(geometryImageData), 5221241) # ROI source roiNode = slicer.vtkMRMLAnnotationROINode() roiNode.SetName('SourceROI') slicer.mrmlScene.AddNode(roiNode) roiNode.UnRegister(None) xyz = [0]*3 center = [0]*3 slicer.vtkMRMLSliceLogic.GetVolumeRASBox(tinyVolumeNode, xyz, center) radius = map(lambda x: x/2.0, xyz) roiNode.SetXYZ(center) roiNode.SetRadiusXYZ(radius) geometryWidget.setSourceNode(roiNode) geometryWidget.geometryImageData(geometryImageData) self.assertTrue(self.compareOutputGeometry(geometryImageData, (1,1,1), (-216.156, -217.711, -135.75), [[0.0, 0.0, 1.0], [-1.0, 0.0, 0.0], [0.0, -1.0, 0.0]])) vtkSegmentationCore.vtkOrientedImageDataResample.ResampleOrientedImageToReferenceOrientedImage( segmentOrientedImageData, geometryImageData, geometryImageData, False, True) self.assertEqual(self.getForegroundVoxelCount(geometryImageData), 5223846) slicer.util.delayDisplay('Model and ROI source cases - OK') slicer.util.delayDisplay('Segmentation geometry widget test passed')
def transform(self,cmd): if not hasattr(self,'p'): self.p = numpy.zeros(3) self.dpdt = numpy.zeros(3) self.d2pdt2 = numpy.zeros(3) self.o = numpy.zeros(3) self.dodt = numpy.zeros(3) self.d2odt2 = numpy.zeros(3) p = urlparse.urlparse(cmd) q = urlparse.parse_qs(p.query) print (q) dt = float(q['interval'][0]) self.d2pdt2 = 1000 * numpy.array([float(q['x'][0]), float(q['y'][0]), float(q['z'][0])]) if not hasattr(self,'g0'): self.g0 = self.d2pdt2 self.d2pdt2 = self.d2pdt2 - self.g0 self.dpdt = self.dpdt + dt * self.d2pdt2 self.p = self.p + dt * self.dpdt # TODO: integrate rotations if not hasattr(self, "idevice"): """ set up the mrml parts or use existing """ nodes = slicer.mrmlScene.GetNodesByName('idevice') if nodes.GetNumberOfItems() > 0: self.idevice = nodes.GetItemAsObject(0) nodes = slicer.mrmlScene.GetNodesByName('tracker') self.tracker = nodes.GetItemAsObject(0) else: # idevice cursor self.cube = vtk.vtkCubeSource() self.cube.SetXLength(30) self.cube.SetYLength(70) self.cube.SetZLength(5) self.cube.Update() # display node self.modelDisplay = slicer.vtkMRMLModelDisplayNode() self.modelDisplay.SetColor(1,1,0) # yellow slicer.mrmlScene.AddNode(self.modelDisplay) self.modelDisplay.SetPolyData(self.cube.GetOutput()) # Create model node self.idevice = slicer.vtkMRMLModelNode() self.idevice.SetScene(slicer.mrmlScene) self.idevice.SetName("idevice") self.idevice.SetAndObservePolyData(self.cube.GetOutput()) self.idevice.SetAndObserveDisplayNodeID(self.modelDisplay.GetID()) slicer.mrmlScene.AddNode(self.idevice) # tracker self.tracker = slicer.vtkMRMLLinearTransformNode() self.tracker.SetName('tracker') slicer.mrmlScene.AddNode(self.tracker) self.idevice.SetAndObserveTransformNodeID(self.tracker.GetID()) m = self.tracker.GetMatrixTransformToParent() m.Identity() up = numpy.zeros(3) up[2] = 1 d = self.d2pdt2 dd = d / numpy.sqrt(numpy.dot(d,d)) xx = numpy.cross(dd,up) yy = numpy.cross(dd,xx) for row in xrange(3): m.SetElement(row,0, dd[row]) m.SetElement(row,1, xx[row]) m.SetElement(row,2, yy[row]) #m.SetElement(row,3, self.p[row]) return ( "got it" )
def __init__(self): self.toolTipToTool = slicer.util.getNode('toolTipToTool') if not self.toolTipToTool: self.toolTipToTool=slicer.vtkMRMLLinearTransformNode() self.toolTipToTool.SetName("toolTipToTool") m = vtk.vtkMatrix4x4() m.SetElement( 0, 0, 1 ) # Row 1 m.SetElement( 0, 1, 0 ) m.SetElement( 0, 2, 0 ) m.SetElement( 0, 3, 0 ) m.SetElement( 1, 0, 0 ) # Row 2 m.SetElement( 1, 1, 1 ) m.SetElement( 1, 2, 0 ) m.SetElement( 1, 3, 0 ) m.SetElement( 2, 0, 0 ) # Row 3 m.SetElement( 2, 1, 0 ) m.SetElement( 2, 2, 1 ) m.SetElement( 2, 3, 0 ) self.toolTipToTool.SetMatrixTransformToParent(m) slicer.mrmlScene.AddNode(self.toolTipToTool) self.toolToReference = slicer.util.getNode('toolToReference') if not self.toolToReference: self.toolToReference=slicer.vtkMRMLLinearTransformNode() self.toolToReference.SetName("toolToReference") matrixRef = vtk.vtkMatrix4x4() matrixRef.SetElement( 0, 0, 1 ) # Row 1 matrixRef.SetElement( 0, 1, 0 ) matrixRef.SetElement( 0, 2, 0 ) matrixRef.SetElement( 0, 3, 0 ) matrixRef.SetElement( 1, 0, 0 ) # Row 2 matrixRef.SetElement( 1, 1, 1 ) matrixRef.SetElement( 1, 2, 0 ) matrixRef.SetElement( 1, 3, 0 ) matrixRef.SetElement( 2, 0, 0 ) # Row 3 matrixRef.SetElement( 2, 1, 0 ) matrixRef.SetElement( 2, 2, 1 ) matrixRef.SetElement( 2, 3, 0 ) self.toolToReference.SetMatrixTransformToParent(matrixRef) slicer.mrmlScene.AddNode(self.toolToReference) self.tipFiducial = slicer.util.getNode('Tip') if not self.tipFiducial: self.tipFiducial = slicer.vtkMRMLMarkupsFiducialNode() self.tipFiducial.SetName('Tip') self.tipFiducial.AddFiducial(0, 0, 0) self.tipFiducial.SetNthFiducialLabel(0, '') slicer.mrmlScene.AddNode(self.tipFiducial) self.tipFiducial.SetDisplayVisibility(True) self.tipFiducial.GetDisplayNode().SetGlyphType(1) # Vertex2D self.tipFiducial.GetDisplayNode().SetTextScale(1.3) self.tipFiducial.GetDisplayNode().SetSelectedColor(1,1,1) self.targetFiducial = slicer.util.getNode('Target') if not self.targetFiducial: self.targetFiducial = slicer.vtkMRMLMarkupsFiducialNode() self.targetFiducial.SetName('Target') self.targetFiducial.AddFiducial(0, 0, 0) self.targetFiducial.SetNthFiducialLabel(0, '') slicer.mrmlScene.AddNode(self.targetFiducial) self.targetFiducial.SetDisplayVisibility(True) self.targetFiducial.GetDisplayNode().SetGlyphType(1) # Vertex2D self.targetFiducial.GetDisplayNode().SetTextScale(1.3) self.targetFiducial.GetDisplayNode().SetSelectedColor(1,1,1) self.line = slicer.util.getNode('Line') if not self.line: self.line = slicer.vtkMRMLModelNode() self.line.SetName('Line') linePolyData = vtk.vtkPolyData() self.line.SetAndObservePolyData(linePolyData) modelDisplay = slicer.vtkMRMLModelDisplayNode() modelDisplay.SetSliceIntersectionVisibility(True) modelDisplay.SetColor(0,1,0) slicer.mrmlScene.AddNode(modelDisplay) self.line.SetAndObserveDisplayNodeID(modelDisplay.GetID()) slicer.mrmlScene.AddNode(self.line) # VTK objects self.transformPolyDataFilter = vtk.vtkTransformPolyDataFilter() self.cellLocator = vtk.vtkCellLocator() # 3D View threeDWidget = slicer.app.layoutManager().threeDWidget(0) self.threeDView = threeDWidget.threeDView() self.callbackObserverTag = -1 self.observerTag=None # Output Distance Label self.outputDistanceLabel=None import Viewpoint # Viewpoint Module must have been added to Slicer self.viewpointLogic = Viewpoint.ViewpointLogic() # Camera transformations self.needleCameraToNeedle = slicer.util.getNode('needleCameraToNeedle') if not self.needleCameraToNeedle: self.needleCameraToNeedle=slicer.vtkMRMLLinearTransformNode() self.needleCameraToNeedle.SetName("needleCameraToNeedle") matrixNeedleCamera = vtk.vtkMatrix4x4() matrixNeedleCamera.SetElement( 0, 0, -0.05 ) # Row 1 matrixNeedleCamera.SetElement( 0, 1, 0.09 ) matrixNeedleCamera.SetElement( 0, 2, -0.99 ) matrixNeedleCamera.SetElement( 0, 3, 60.72 ) matrixNeedleCamera.SetElement( 1, 0, -0.01 ) # Row 2 matrixNeedleCamera.SetElement( 1, 1, 1 ) matrixNeedleCamera.SetElement( 1, 2, 0.09 ) matrixNeedleCamera.SetElement( 1, 3, 12.17 ) matrixNeedleCamera.SetElement( 2, 0, 1 ) # Row 3 matrixNeedleCamera.SetElement( 2, 1, 0.01 ) matrixNeedleCamera.SetElement( 2, 2, -0.05 ) matrixNeedleCamera.SetElement( 2, 3, -7.26 ) self.needleCameraToNeedle.SetMatrixTransformToParent(matrixNeedleCamera) slicer.mrmlScene.AddNode(self.needleCameraToNeedle) self.pointerCameraToPointer = slicer.util.getNode('pointerCameraToPointer') if not self.pointerCameraToPointer: self.pointerCameraToPointer=slicer.vtkMRMLLinearTransformNode() self.pointerCameraToPointer.SetName("pointerCameraToPointer") matrixPointerCamera = vtk.vtkMatrix4x4() matrixPointerCamera.SetElement( 0, 0, -0.05 ) # Row 1 matrixPointerCamera.SetElement( 0, 1, 0.09 ) matrixPointerCamera.SetElement( 0, 2, -0.99 ) matrixPointerCamera.SetElement( 0, 3, 121.72 ) matrixPointerCamera.SetElement( 1, 0, -0.01 ) # Row 2 matrixPointerCamera.SetElement( 1, 1, 1 ) matrixPointerCamera.SetElement( 1, 2, 0.09 ) matrixPointerCamera.SetElement( 1, 3, 17.17 ) matrixPointerCamera.SetElement( 2, 0, 1 ) # Row 3 matrixPointerCamera.SetElement( 2, 1, 0.01 ) matrixPointerCamera.SetElement( 2, 2, -0.05 ) matrixPointerCamera.SetElement( 2, 3, -7.26 ) self.pointerCameraToPointer.SetMatrixTransformToParent(matrixPointerCamera) slicer.mrmlScene.AddNode(self.pointerCameraToPointer)
def findAxisOfMotion(self, origins): #Following guide from: http://sebastianraschka.com/Articles/2014_pca_step_by_step.html #scale factor for better display: scale = 100 #Calculate mean position meanVector = [0, 0 ,0] for i in range(3): meanVector[i] = np.mean(origins[i, :]) #Computing covariance matrix convMatrix = np.cov([origins[0, :], origins[1, :], origins[2, :]]) #Get eigenvectors eig_val, eig_vec = np.linalg.eig(convMatrix) # Make a list of (eigenvalue, eigenvector) tuples eig_pairs = [(np.abs(eig_val[i]), eig_vec[:,i]) for i in range(len(eig_val))] # Sort the (eigenvalue, eigenvector) tuples from high to low eig_pairs.sort() # eig_pairs.reverse() matrix_w = np.hstack((eig_pairs[0][1].reshape(3, 1), eig_pairs[1][1].reshape(3, 1), eig_pairs[2][1].reshape(3, 1))) print('Matrix W:\n', matrix_w) #Create linear transform for contour propagation vtkMatrix = vtk.vtkMatrix4x4() transform = slicer.vtkMRMLLinearTransformNode() slicer.mrmlScene.AddNode(transform) for i in range(3): for j in range(3): vtkMatrix.SetElement(j, i, matrix_w[i, j]) transform.SetAndObserveMatrixTransformFromParent(vtkMatrix) #Plot eigenvectors from mean position fiducials = slicer.vtkMRMLMarkupsFiducialNode() displayNode = slicer.vtkMRMLMarkupsDisplayNode() # vtkNew<vtkMRMLMarkupsFiducialStorageNode> wFStorageNode; slicer.mrmlScene.AddNode(displayNode) slicer.mrmlScene.AddNode(fiducials) fiducials.SetAndObserveDisplayNodeID(displayNode.GetID()) fiducials.AddFiducialFromArray(meanVector, "Mean Position") for i in range(len(eig_vec)): # fiducials.AddFiducialFromArray(meanVector + scale * eig_vec[i], " P " + str(i+1)) #Plot ruler ruler = slicer.vtkMRMLAnnotationRulerNode() displayRuler = slicer.vtkMRMLAnnotationLineDisplayNode() displayRuler.SetLabelVisibility(0) displayRuler.SetMaxTicks(0) displayRuler.SetLineWidth(5) slicer.mrmlScene.AddNode(displayRuler) slicer.mrmlScene.AddNode(ruler) ruler.SetAndObserveDisplayNodeID(displayRuler.GetID()) ruler.SetPosition1(meanVector) ruler.SetPosition2(meanVector + scale * eig_vec[i]) return matrix_w
def run(self, inputT1Volume, inputFLAIRVolume, outputVolume, isBET, absError, gamma, WMMath, minLesionSize, GMlabel, WMLabel): """ Run the actual algorithm """ if not self.isValidInputOutputData(inputT1Volume, outputVolume): slicer.util.errorDisplay('Input T1 volume is the same as output volume. Choose a different output volume.') return False if not self.isValidInputOutputData(inputFLAIRVolume, outputVolume): slicer.util.errorDisplay('Input FLAIR volume is the same as output volume. Choose a different output volume.') return False logging.info('Processing started') # Creating FLAIR image copy for processing pipeline inputFLAIRVolume_tmp = slicer.vtkMRMLScalarVolumeNode() slicer.mrmlScene.AddNode(inputFLAIRVolume_tmp) inputT1Volume_tmp = slicer.vtkMRMLScalarVolumeNode() slicer.mrmlScene.AddNode(inputT1Volume_tmp) slicer.util.showStatusMessage("Step 1: Bias field correction...") ################################################################################################################# # Image Processing # ################################################################################################################# ################################################################################################################# # T2-FLAIR Bias Field Correction # ################################################################################################################# regParams = {} regParams["inputImageName"] = inputFLAIRVolume.GetID() regParams["outputImageName"] = inputFLAIRVolume_tmp.GetID() slicer.cli.run(slicer.modules.n4itkbiasfieldcorrection, None, regParams, wait_for_completion=True) ################################################################################################################# # T1 Bias Field Correction # ################################################################################################################# regParams = {} regParams["inputImageName"] = inputT1Volume.GetID() regParams["outputImageName"] = inputT1Volume_tmp.GetID() slicer.cli.run(slicer.modules.n4itkbiasfieldcorrection, None, regParams, wait_for_completion=True) # Get the path to LSSegmenter-Data files path2files = os.path.dirname(slicer.modules.lssegmenter.path) ################################################################################################################# # Registration - MNI to Native space # ################################################################################################################# if platform.system() is "Windows": if isBET: (read, MNITemplateNode) = slicer.util.loadVolume( path2files + '\\Resources\\LSSegmenter-Data\\MNI152_T1_1mm_brain.nii.gz', {}, True) else: (read, MNITemplateNode) = slicer.util.loadVolume( path2files + '\\Resources\\LSSegmenter-Data\\MNI152_T1_1mm.nii.gz', {}, True) else: if isBET: (read, MNITemplateNode) = slicer.util.loadVolume( path2files + '/Resources/LSSegmenter-Data/MNI152_T1_1mm_brain.nii.gz', {}, True) else: (read, MNITemplateNode) = slicer.util.loadVolume( path2files + '/Resources/LSSegmenter-Data/MNI152_T1_1mm.nii.gz', {}, True) # # Registering the FLAIR to T1 space. # slicer.util.showStatusMessage("Step 2: FLAIR to T1 space registration...") regParams = {} regParams["fixedVolume"] = inputT1Volume.GetID() regParams["movingVolume"] = inputFLAIRVolume_tmp.GetID() regParams["outputVolume"] = inputFLAIRVolume_tmp.GetID() regParams["samplingPercentage"] = 0.02 regParams["splineGridSize"] = '8,8,8' regParams["initializeTransformMode"] = "useMomentsAlign" regParams["useRigid"] = True # regParams["useAffine"] = True # regParams["useBSpline"] = True regParams["interpolationMode"] = "Linear" slicer.cli.run(slicer.modules.brainsfit, None, regParams, wait_for_completion=True) # # Registering the MNI template to native space. # registrationMNI2NativeTransform = slicer.vtkMRMLLinearTransformNode() registrationMNI2NativeTransform.SetName("regMNI2Native_linear") slicer.mrmlScene.AddNode(registrationMNI2NativeTransform) slicer.util.showStatusMessage("Step 3: MNI152 to native space registration...") regParams = {} regParams["fixedVolume"] = inputT1Volume_tmp.GetID() regParams["movingVolume"] = MNITemplateNode.GetID() regParams["outputVolume"] = MNITemplateNode.GetID() regParams["samplingPercentage"] = 0.02 regParams["splineGridSize"] = '8,8,8' regParams["linearTransform"] = registrationMNI2NativeTransform.GetID() regParams["initializeTransformMode"] = "useMomentsAlign" regParams["useRigid"] = True regParams["useAffine"] = True regParams["useBSpline"] = True regParams["interpolationMode"] = "Linear" slicer.cli.run(slicer.modules.brainsfit, None, regParams, wait_for_completion=True) if platform.system() is "Windows": (read, MNIBrainTissues) = slicer.util.loadLabelVolume( path2files + '\\Resources\\LSSegmenter-Data\\MNI152_T1_1mm_brain_tissues.nii.gz', {}, True) else: (read, MNIBrainTissues) = slicer.util.loadLabelVolume( path2files + '/Resources/LSSegmenter-Data/MNI152_T1_1mm_brain_tissues.nii.gz', {}, True) slicer.util.showStatusMessage("Step 4: MNI brain template conforming...") params = {} params["inputVolume"] = MNIBrainTissues.GetID() params["referenceVolume"] = inputT1Volume_tmp.GetID() params["outputVolume"] = MNIBrainTissues.GetID() params["transformationFile"] = registrationMNI2NativeTransform.GetID() params["inverseITKTransformation"] = False params["interpolationType"] = "nn" slicer.cli.run(slicer.modules.resamplescalarvectordwivolume, None, params, wait_for_completion=True) slicer.util.showStatusMessage("Step 5: MS lesion segmentation...") cliParams={} cliParams["inputT1Volume"] = inputT1Volume_tmp.GetID() cliParams["inputT2FLAIRVolume"] = inputFLAIRVolume_tmp.GetID() cliParams["inputMNIVolume"] = MNITemplateNode.GetID() cliParams["brainLabels"] = MNIBrainTissues.GetID() cliParams["outputLesionMap"] = outputVolume.GetID() cliParams["absErrorThreshold"] = absError cliParams["gamma"] = gamma cliParams["wmMatch"] = WMMath cliParams["minimumSize"] = minLesionSize cliParams["gmMaskValue"] = GMlabel cliParams["wmMaskValue"] = WMLabel slicer.cli.run(slicer.modules.automaticflairthreshold, None, cliParams, wait_for_completion=True) logging.info('Processing completed') # Removing unnecessary nodes slicer.mrmlScene.RemoveNode(MNIBrainTissues) slicer.mrmlScene.RemoveNode(MNITemplateNode) slicer.mrmlScene.RemoveNode(registrationMNI2NativeTransform) slicer.mrmlScene.RemoveNode(inputFLAIRVolume_tmp) slicer.mrmlScene.RemoveNode(inputT1Volume_tmp) return True
def TestSection_ImportExportSegment(self): # Import/export, both one label and all labels logging.info('Test section: Import/export segment') # Export single segment to model node bodyModelNode = slicer.vtkMRMLModelNode() bodyModelNode.SetName('BodyModel') slicer.mrmlScene.AddNode(bodyModelNode) bodySegment = self.inputSegmentationNode.GetSegmentation().GetSegment(self.bodySegmentName) result = slicer.vtkSlicerSegmentationsModuleLogic.ExportSegmentToRepresentationNode(bodySegment, bodyModelNode) self.assertTrue(result) self.assertIsNotNone(bodyModelNode.GetPolyData()) #TODO: Number of points increased to 1677 due to end-capping, need to investigate! #self.assertEqual(bodyModelNode.GetPolyData().GetNumberOfPoints(), 302) #TODO: On Linux and Windows it is 588, on Mac it is 580. Need to investigate # self.assertEqual(bodyModelNode.GetPolyData().GetNumberOfCells(), 588) #self.assertTrue(bodyModelNode.GetPolyData().GetNumberOfCells() == 588 or bodyModelNode.GetPolyData().GetNumberOfCells() == 580) # Export single segment to volume node bodyLabelmapNode = slicer.vtkMRMLLabelMapVolumeNode() bodyLabelmapNode.SetName('BodyLabelmap') slicer.mrmlScene.AddNode(bodyLabelmapNode) result = slicer.vtkSlicerSegmentationsModuleLogic.ExportSegmentToRepresentationNode(bodySegment, bodyLabelmapNode) self.assertTrue(result) bodyImageData = bodyLabelmapNode.GetImageData() self.assertIsNotNone(bodyImageData) imageStat = vtk.vtkImageAccumulate() imageStat.SetInputData(bodyImageData) imageStat.Update() self.assertEqual(imageStat.GetVoxelCount(), 792) self.assertEqual(imageStat.GetMin()[0], 0) self.assertEqual(imageStat.GetMax()[0], 1) # Export multiple segments to volume node allSegmentsLabelmapNode = slicer.vtkMRMLLabelMapVolumeNode() allSegmentsLabelmapNode.SetName('AllSegmentsLabelmap') slicer.mrmlScene.AddNode(allSegmentsLabelmapNode) result = slicer.vtkSlicerSegmentationsModuleLogic.ExportAllSegmentsToLabelmapNode(self.inputSegmentationNode, allSegmentsLabelmapNode) self.assertTrue(result) allSegmentsImageData = allSegmentsLabelmapNode.GetImageData() self.assertIsNotNone(allSegmentsImageData) imageStat = vtk.vtkImageAccumulate() imageStat.SetInputData(allSegmentsImageData) imageStat.SetComponentExtent(0,5,0,0,0,0) imageStat.SetComponentOrigin(0,0,0) imageStat.SetComponentSpacing(1,1,1) imageStat.Update() imageStatResult = imageStat.GetOutput() for i in range(4): logging.info("Volume {0}: {1}".format(i, imageStatResult.GetScalarComponentAsDouble(i,0,0,0))) self.assertEqual(imageStat.GetVoxelCount(), 127109360) self.assertEqual(imageStatResult.GetScalarComponentAsDouble(0,0,0,0), 78967249) self.assertEqual(imageStatResult.GetScalarComponentAsDouble(1,0,0,0), 39705288) self.assertEqual(imageStatResult.GetScalarComponentAsDouble(2,0,0,0), 890883) self.assertEqual(imageStatResult.GetScalarComponentAsDouble(3,0,0,0), 7545940) # Import model to segment modelImportSegmentationNode = slicer.mrmlScene.AddNewNodeByClass('vtkMRMLSegmentationNode', 'ModelImport') modelImportSegmentationNode.GetSegmentation().SetMasterRepresentationName(self.closedSurfaceReprName) modelSegment = slicer.vtkSlicerSegmentationsModuleLogic.CreateSegmentFromModelNode(bodyModelNode) modelSegment.UnRegister(None) # Need to release ownership self.assertIsNotNone(modelSegment) self.assertIsNotNone(modelSegment.GetRepresentation(self.closedSurfaceReprName)) # Import multi-label labelmap to segmentation multiLabelImportSegmentationNode = slicer.mrmlScene.AddNewNodeByClass('vtkMRMLSegmentationNode', 'MultiLabelImport') multiLabelImportSegmentationNode.GetSegmentation().SetMasterRepresentationName(self.binaryLabelmapReprName) result = slicer.vtkSlicerSegmentationsModuleLogic.ImportLabelmapToSegmentationNode(allSegmentsLabelmapNode, multiLabelImportSegmentationNode) self.assertTrue(result) self.assertEqual(multiLabelImportSegmentationNode.GetSegmentation().GetNumberOfSegments(), 3) # Import labelmap into single segment singleLabelImportSegmentationNode = slicer.mrmlScene.AddNewNodeByClass('vtkMRMLSegmentationNode', 'SingleLabelImport') singleLabelImportSegmentationNode.GetSegmentation().SetMasterRepresentationName(self.binaryLabelmapReprName) # Should not import multi-label labelmap to segment nullSegment = slicer.vtkSlicerSegmentationsModuleLogic.CreateSegmentFromLabelmapVolumeNode(allSegmentsLabelmapNode) self.assertIsNone(nullSegment) logging.info('(This error message is a result of testing an impossible scenario, it is supposed to appear)') # Make labelmap single-label and import again threshold = vtk.vtkImageThreshold() threshold.SetInValue(0) threshold.SetOutValue(1) threshold.ReplaceInOn() threshold.ThresholdByLower(0) threshold.SetOutputScalarType(vtk.VTK_UNSIGNED_CHAR) if vtk.VTK_MAJOR_VERSION <= 5: threshold.SetInput(allSegmentsLabelmapNode.GetImageData()) else: threshold.SetInputData(allSegmentsLabelmapNode.GetImageData()) threshold.Update() allSegmentsLabelmapNode.GetImageData().ShallowCopy(threshold.GetOutput()) labelSegment = slicer.vtkSlicerSegmentationsModuleLogic.CreateSegmentFromLabelmapVolumeNode(allSegmentsLabelmapNode) labelSegment.UnRegister(None) # Need to release ownership self.assertIsNotNone(labelSegment) self.assertIsNotNone(labelSegment.GetRepresentation(self.binaryLabelmapReprName)) # Import/export with transforms logging.info('Test subsection: Import/export with transforms') # Create transform node that will be used to transform the tested nodes bodyModelTransformNode = slicer.vtkMRMLLinearTransformNode() slicer.mrmlScene.AddNode(bodyModelTransformNode) bodyModelTransform = vtk.vtkTransform() bodyModelTransform.Translate(1000.0, 0.0, 0.0) bodyModelTransformNode.ApplyTransformMatrix(bodyModelTransform.GetMatrix()) # Set transform as parent to input segmentation node self.inputSegmentationNode.SetAndObserveTransformNodeID(bodyModelTransformNode.GetID()) # Export single segment to model node from transformed segmentation bodyModelNodeTransformed = slicer.vtkMRMLModelNode() bodyModelNodeTransformed.SetName('BodyModelTransformed') slicer.mrmlScene.AddNode(bodyModelNodeTransformed) bodySegment = self.inputSegmentationNode.GetSegmentation().GetSegment(self.bodySegmentName) result = slicer.vtkSlicerSegmentationsModuleLogic.ExportSegmentToRepresentationNode(bodySegment, bodyModelNodeTransformed) self.assertTrue(result) self.assertIsNotNone(bodyModelNodeTransformed.GetParentTransformNode()) # Export single segment to volume node from transformed segmentation bodyLabelmapNodeTransformed = slicer.vtkMRMLLabelMapVolumeNode() bodyLabelmapNodeTransformed.SetName('BodyLabelmapTransformed') slicer.mrmlScene.AddNode(bodyLabelmapNodeTransformed) result = slicer.vtkSlicerSegmentationsModuleLogic.ExportSegmentToRepresentationNode(bodySegment, bodyLabelmapNodeTransformed) self.assertTrue(result) self.assertIsNotNone(bodyLabelmapNodeTransformed.GetParentTransformNode()) # Create transform node that will be used to transform the tested nodes modelTransformedImportSegmentationTransformNode = slicer.vtkMRMLLinearTransformNode() slicer.mrmlScene.AddNode(modelTransformedImportSegmentationTransformNode) modelTransformedImportSegmentationTransform = vtk.vtkTransform() modelTransformedImportSegmentationTransform.Translate(-500.0, 0.0, 0.0) modelTransformedImportSegmentationTransformNode.ApplyTransformMatrix(modelTransformedImportSegmentationTransform.GetMatrix()) # Import transformed model to segment in transformed segmentation modelTransformedImportSegmentationNode = slicer.mrmlScene.AddNewNodeByClass('vtkMRMLSegmentationNode', 'ModelImportTransformed') modelTransformedImportSegmentationNode.GetSegmentation().SetMasterRepresentationName(self.closedSurfaceReprName) modelTransformedImportSegmentationNode.SetAndObserveTransformNodeID(modelTransformedImportSegmentationTransformNode.GetID()) modelSegmentTranformed = slicer.vtkSlicerSegmentationsModuleLogic.CreateSegmentFromModelNode(bodyModelNodeTransformed, modelTransformedImportSegmentationNode) modelSegmentTranformed.UnRegister(None) # Need to release ownership self.assertIsNotNone(modelSegmentTranformed) modelSegmentTransformedPolyData = modelSegmentTranformed.GetRepresentation(self.closedSurfaceReprName) self.assertIsNotNone(modelSegmentTransformedPolyData) self.assertEqual(int(modelSegmentTransformedPolyData.GetBounds()[0]), 1332) self.assertEqual(int(modelSegmentTransformedPolyData.GetBounds()[1]), 1675) # Clean up temporary nodes slicer.mrmlScene.RemoveNode(bodyModelNode) slicer.mrmlScene.RemoveNode(bodyLabelmapNode) slicer.mrmlScene.RemoveNode(allSegmentsLabelmapNode) slicer.mrmlScene.RemoveNode(modelImportSegmentationNode) slicer.mrmlScene.RemoveNode(multiLabelImportSegmentationNode) slicer.mrmlScene.RemoveNode(singleLabelImportSegmentationNode) slicer.mrmlScene.RemoveNode(bodyModelTransformNode) slicer.mrmlScene.RemoveNode(bodyModelNodeTransformed) slicer.mrmlScene.RemoveNode(bodyLabelmapNodeTransformed) slicer.mrmlScene.RemoveNode(modelTransformedImportSegmentationNode)
def TestSection_3_ImportExportSegment(self): # Import/export, both one label and all labels logging.info('Test section 3: Import/export segment') # Export single segment to model node bodyModelNode = slicer.vtkMRMLModelNode() bodyModelNode.SetName('BodyModel') slicer.mrmlScene.AddNode(bodyModelNode) bodySegment = self.inputSegmentationNode.GetSegmentation().GetSegment('Body_Contour') result = vtkSlicerSegmentationsModuleLogic.ExportSegmentToRepresentationNode(bodySegment, bodyModelNode) self.assertTrue(result) self.assertIsNotNone(bodyModelNode.GetPolyData()) self.assertEqual(bodyModelNode.GetPolyData().GetNumberOfPoints(), 302) #TODO: On Linux and Windows it is 588, on Mac it is 580. Need to investigate # self.assertEqual(bodyModelNode.GetPolyData().GetNumberOfCells(), 588) self.assertTrue(bodyModelNode.GetPolyData().GetNumberOfCells() == 588 or bodyModelNode.GetPolyData().GetNumberOfCells() == 580) # Export single segment to volume node bodyLabelmapNode = slicer.vtkMRMLLabelMapVolumeNode() bodyLabelmapNode.SetName('BodyLabelmap') slicer.mrmlScene.AddNode(bodyLabelmapNode) result = vtkSlicerSegmentationsModuleLogic.ExportSegmentToRepresentationNode(bodySegment, bodyLabelmapNode) self.assertTrue(result) bodyImageData = bodyLabelmapNode.GetImageData() self.assertIsNotNone(bodyImageData) imageStat = vtk.vtkImageAccumulate() imageStat.SetInputData(bodyImageData) imageStat.Update() self.assertEqual(imageStat.GetVoxelCount(), 648) self.assertEqual(imageStat.GetMin()[0], 0) self.assertEqual(imageStat.GetMax()[0], 1) # Export multiple segments to volume node allSegmentsLabelmapNode = slicer.vtkMRMLLabelMapVolumeNode() allSegmentsLabelmapNode.SetName('AllSegmentsLabelmap') slicer.mrmlScene.AddNode(allSegmentsLabelmapNode) result = vtkSlicerSegmentationsModuleLogic.ExportAllSegmentsToLabelmapNode(self.inputSegmentationNode, allSegmentsLabelmapNode) self.assertTrue(result) allSegmentsImageData = allSegmentsLabelmapNode.GetImageData() self.assertIsNotNone(allSegmentsImageData) imageStat = vtk.vtkImageAccumulate() imageStat.SetInputData(allSegmentsImageData) imageStat.SetComponentExtent(0,5,0,0,0,0) imageStat.SetComponentOrigin(0,0,0) imageStat.SetComponentSpacing(1,1,1) imageStat.Update() self.assertEqual(imageStat.GetVoxelCount(), 54872000) imageStatResult = imageStat.GetOutput() self.assertEqual(imageStatResult.GetScalarComponentAsDouble(0,0,0,0), 46678738) self.assertEqual(imageStatResult.GetScalarComponentAsDouble(1,0,0,0), 0) self.assertEqual(imageStatResult.GetScalarComponentAsDouble(2,0,0,0), 7618805) self.assertEqual(imageStatResult.GetScalarComponentAsDouble(3,0,0,0), 128968) self.assertEqual(imageStatResult.GetScalarComponentAsDouble(4,0,0,0), 0) # Built from color table and color four is removed in previous test section self.assertEqual(imageStatResult.GetScalarComponentAsDouble(5,0,0,0), 445489) # Import model to segment modelImportSegmentationNode = vtkMRMLSegmentationNode() modelImportSegmentationNode.SetName('ModelImport') modelImportSegmentationNode.GetSegmentation().SetMasterRepresentationName(self.closedSurfaceReprName) slicer.mrmlScene.AddNode(modelImportSegmentationNode) modelSegment = vtkSlicerSegmentationsModuleLogic.CreateSegmentFromModelNode(bodyModelNode) modelSegment.UnRegister(None) # Need to release ownership self.assertIsNotNone(modelSegment) self.assertIsNotNone(modelSegment.GetRepresentation(self.closedSurfaceReprName)) # Import multi-label labelmap to segmentation multiLabelImportSegmentationNode = vtkMRMLSegmentationNode() multiLabelImportSegmentationNode.SetName('MultiLabelImport') multiLabelImportSegmentationNode.GetSegmentation().SetMasterRepresentationName(self.binaryLabelmapReprName) slicer.mrmlScene.AddNode(multiLabelImportSegmentationNode) result = vtkSlicerSegmentationsModuleLogic.ImportLabelmapToSegmentationNode(allSegmentsLabelmapNode, multiLabelImportSegmentationNode) self.assertTrue(result) self.assertEqual(multiLabelImportSegmentationNode.GetSegmentation().GetNumberOfSegments(), 3) # Import labelmap into single segment singleLabelImportSegmentationNode = vtkMRMLSegmentationNode() singleLabelImportSegmentationNode.SetName('SingleLabelImport') singleLabelImportSegmentationNode.GetSegmentation().SetMasterRepresentationName(self.binaryLabelmapReprName) slicer.mrmlScene.AddNode(singleLabelImportSegmentationNode) # Should not import multi-label labelmap to segment nullSegment = vtkSlicerSegmentationsModuleLogic.CreateSegmentFromLabelmapVolumeNode(allSegmentsLabelmapNode) self.assertIsNone(nullSegment) logging.info('(This error message tests an impossible scenario, it is supposed to appear)') # Make labelmap single-label and import again threshold = vtk.vtkImageThreshold() threshold.ThresholdByUpper(0.5) threshold.SetInValue(1) threshold.SetOutValue(0) threshold.SetOutputScalarType(vtk.VTK_UNSIGNED_CHAR) if vtk.VTK_MAJOR_VERSION <= 5: threshold.SetInput(allSegmentsLabelmapNode.GetImageData()) else: threshold.SetInputData(allSegmentsLabelmapNode.GetImageData()) threshold.SetOutput(allSegmentsLabelmapNode.GetImageData()) threshold.Update() labelSegment = vtkSlicerSegmentationsModuleLogic.CreateSegmentFromLabelmapVolumeNode(allSegmentsLabelmapNode) labelSegment.UnRegister(None) # Need to release ownership self.assertIsNotNone(labelSegment) self.assertIsNotNone(labelSegment.GetRepresentation(self.binaryLabelmapReprName)) # Import/export with transforms logging.info('Test section 4/2: Import/export with transforms') # Create transform node that will be used to transform the tested nodes bodyModelTransformNode = slicer.vtkMRMLLinearTransformNode() slicer.mrmlScene.AddNode(bodyModelTransformNode) bodyModelTransform = vtk.vtkTransform() bodyModelTransform.Translate(1000.0, 0.0, 0.0) bodyModelTransformNode.ApplyTransformMatrix(bodyModelTransform.GetMatrix()) # Set transform as parent to input segmentation node self.inputSegmentationNode.SetAndObserveTransformNodeID(bodyModelTransformNode.GetID()) # Export single segment to model node from transformed segmentation bodyModelNodeTransformed = slicer.vtkMRMLModelNode() bodyModelNodeTransformed.SetName('BodyModelTransformed') slicer.mrmlScene.AddNode(bodyModelNodeTransformed) bodySegment = self.inputSegmentationNode.GetSegmentation().GetSegment('Body_Contour') result = vtkSlicerSegmentationsModuleLogic.ExportSegmentToRepresentationNode(bodySegment, bodyModelNodeTransformed) self.assertTrue(result) self.assertIsNotNone(bodyModelNodeTransformed.GetParentTransformNode()) # Export single segment to volume node from transformed segmentation bodyLabelmapNodeTransformed = slicer.vtkMRMLLabelMapVolumeNode() bodyLabelmapNodeTransformed.SetName('BodyLabelmapTransformed') slicer.mrmlScene.AddNode(bodyLabelmapNodeTransformed) result = vtkSlicerSegmentationsModuleLogic.ExportSegmentToRepresentationNode(bodySegment, bodyLabelmapNodeTransformed) self.assertTrue(result) self.assertIsNotNone(bodyLabelmapNodeTransformed.GetParentTransformNode()) # Create transform node that will be used to transform the tested nodes modelTransformedImportSegmentationTransformNode = slicer.vtkMRMLLinearTransformNode() slicer.mrmlScene.AddNode(modelTransformedImportSegmentationTransformNode) modelTransformedImportSegmentationTransform = vtk.vtkTransform() modelTransformedImportSegmentationTransform.Translate(-500.0, 0.0, 0.0) modelTransformedImportSegmentationTransformNode.ApplyTransformMatrix(modelTransformedImportSegmentationTransform.GetMatrix()) # Import transformed model to segment in transformed segmentation modelTransformedImportSegmentationNode = vtkMRMLSegmentationNode() modelTransformedImportSegmentationNode.SetName('ModelImportTransformed') modelTransformedImportSegmentationNode.GetSegmentation().SetMasterRepresentationName(self.closedSurfaceReprName) slicer.mrmlScene.AddNode(modelTransformedImportSegmentationNode) modelTransformedImportSegmentationNode.SetAndObserveTransformNodeID(modelTransformedImportSegmentationTransformNode.GetID()) modelSegmentTranformed = vtkSlicerSegmentationsModuleLogic.CreateSegmentFromModelNode(bodyModelNodeTransformed, modelTransformedImportSegmentationNode) modelSegmentTranformed.UnRegister(None) # Need to release ownership self.assertIsNotNone(modelSegmentTranformed) modelSegmentTransformedPolyData = modelSegmentTranformed.GetRepresentation(self.closedSurfaceReprName) self.assertIsNotNone(modelSegmentTransformedPolyData) self.assertEqual(int(modelSegmentTransformedPolyData.GetBounds()[0]), 1332) self.assertEqual(int(modelSegmentTransformedPolyData.GetBounds()[1]), 1675) # Clean up temporary nodes slicer.mrmlScene.RemoveNode(bodyModelNode) slicer.mrmlScene.RemoveNode(bodyLabelmapNode) slicer.mrmlScene.RemoveNode(allSegmentsLabelmapNode) slicer.mrmlScene.RemoveNode(modelImportSegmentationNode) slicer.mrmlScene.RemoveNode(multiLabelImportSegmentationNode) slicer.mrmlScene.RemoveNode(singleLabelImportSegmentationNode) slicer.mrmlScene.RemoveNode(bodyModelTransformNode) slicer.mrmlScene.RemoveNode(bodyModelNodeTransformed) slicer.mrmlScene.RemoveNode(bodyLabelmapNodeTransformed) slicer.mrmlScene.RemoveNode(modelTransformedImportSegmentationNode)
def refineLandmark(self, state): """Refine the specified landmark""" # Refine landmark, or if none, do nothing # Crop images around the fiducial # Affine registration of the cropped images # Transform the fiducial using the transformation # # No need to take into account the current transformation because landmarks are in World RAS timing = False if self.VerboseMode == "Verbose": timing = True if state.logic.cropLogic is None: print("Cannot refine landmarks. CropVolume module is not available.") if state.fixed == None or state.moving == None or state.fixedFiducials == None or state.movingFiducials == None or state.currentLandmarkName == None: print "Cannot refine landmarks. Images or landmarks not selected." return print ("Refining landmark " + state.currentLandmarkName) + " using " + self.name start = time.time() volumes = (state.fixed, state.moving) (fixedVolume, movingVolume) = volumes slicer.mrmlScene.StartState(slicer.mrmlScene.BatchProcessState) landmarks = state.logic.landmarksForVolumes(volumes) cvpn = slicer.vtkMRMLCropVolumeParametersNode() cvpn.SetInterpolationMode(1) cvpn.SetVoxelBased(1) fixedPoint = [0,]*3 movingPoint = [0,]*3 (fixedFiducial, movingFiducial) = landmarks[state.currentLandmarkName] (fixedList,fixedIndex) = fixedFiducial (movingList, movingIndex) = movingFiducial # define an roi for the fixed if timing: roiStart = time.time() roiFixed = slicer.vtkMRMLAnnotationROINode() slicer.mrmlScene.AddNode(roiFixed) fixedList.GetNthFiducialPosition(fixedIndex,fixedPoint) roiFixed.SetDisplayVisibility(0) roiFixed.SelectableOff() roiFixed.SetXYZ(fixedPoint) roiFixed.SetRadiusXYZ(30, 30, 30) # crop the fixed. note we hide the display node temporarily to avoid the automated # window level calculation on temporary nodes created by cloning cvpn.SetROINodeID( roiFixed.GetID() ) cvpn.SetInputVolumeNodeID( fixedVolume.GetID() ) fixedDisplayNode = fixedVolume.GetDisplayNode() fixedVolume.SetAndObserveDisplayNodeID('This is not a valid DisplayNode ID') if timing: roiEnd = time.time() if timing: cropStart = time.time() state.logic.cropLogic.Apply( cvpn ) if timing: cropEnd = time.time() croppedFixedVolume = slicer.mrmlScene.GetNodeByID( cvpn.GetOutputVolumeNodeID() ) fixedVolume.SetAndObserveDisplayNodeID(fixedDisplayNode.GetID()) # define an roi for the moving if timing: roi2Start = time.time() roiMoving = slicer.vtkMRMLAnnotationROINode() slicer.mrmlScene.AddNode(roiMoving) movingList.GetNthFiducialPosition(movingIndex,movingPoint) roiMoving.SetDisplayVisibility(0) roiMoving.SelectableOff() roiMoving.SetXYZ(movingPoint) if self.LocalBRAINSFitMode == "Small": roiMoving.SetRadiusXYZ(45, 45, 45) else: roiMoving.SetRadiusXYZ(60, 60, 60) # crop the moving. note we hide the display node temporarily to avoid the automated # window level calculation on temporary nodes created by cloning cvpn.SetROINodeID( roiMoving.GetID() ) cvpn.SetInputVolumeNodeID( movingVolume.GetID() ) movingDisplayNode = movingVolume.GetDisplayNode() movingVolume.SetAndObserveDisplayNodeID('This is not a valid DisplayNode ID') if timing: roi2End = time.time() if timing: crop2Start = time.time() state.logic.cropLogic.Apply( cvpn ) if timing: crop2End = time.time() croppedMovingVolume = slicer.mrmlScene.GetNodeByID( cvpn.GetOutputVolumeNodeID() ) movingVolume.SetAndObserveDisplayNodeID(movingDisplayNode.GetID()) if timing: print 'Time to set up fixed ROI was ' + str(roiEnd - roiStart) + ' seconds' if timing: print 'Time to set up moving ROI was ' + str(roi2End - roi2Start) + ' seconds' if timing: print 'Time to crop fixed volume ' + str(cropEnd - cropStart) + ' seconds' if timing: print 'Time to crop moving volume ' + str(crop2End - crop2Start) + ' seconds' # transform = slicer.vtkMRMLLinearTransformNode() slicer.mrmlScene.AddNode(transform) matrix = vtk.vtkMatrix4x4() # define the registration parameters minPixelSpacing = min(croppedFixedVolume.GetSpacing()) parameters = {} parameters['fixedVolume'] = croppedFixedVolume.GetID() parameters['movingVolume'] = croppedMovingVolume.GetID() parameters['linearTransform'] = transform.GetID() parameters['useRigid'] = True parameters['initializeTransformMode'] = 'useGeometryAlign'; parameters['samplingPercentage'] = 0.2 parameters['minimumStepLength'] = 0.1 * minPixelSpacing parameters['maximumStepLength'] = minPixelSpacing # run the registration if timing: regStart = time.time() slicer.cli.run(slicer.modules.brainsfit, None, parameters, wait_for_completion=True) if timing: regEnd = time.time() if timing: print 'Time for local registration ' + str(regEnd - regStart) + ' seconds' # apply the local transform to the landmark #print transform if timing: resultStart = time.time() transform.GetMatrixTransformToWorld(matrix) matrix.Invert() tp = [0,]*4 tp = matrix.MultiplyPoint(fixedPoint + [1,]) #print fixedPoint, movingPoint, tp[:3] movingList.SetNthFiducialPosition(movingIndex, tp[0], tp[1], tp[2]) if timing: resultEnd = time.time() if timing: print 'Time for transforming landmark was ' + str(resultEnd - resultStart) + ' seconds' # clean up cropped volmes, need to reset the foreground/background display before we delete it if timing: cleanUpStart = time.time() slicer.mrmlScene.RemoveNode(croppedFixedVolume) slicer.mrmlScene.RemoveNode(croppedMovingVolume) slicer.mrmlScene.RemoveNode(roiFixed) slicer.mrmlScene.RemoveNode(roiMoving) slicer.mrmlScene.RemoveNode(transform) roiFixed = None roiMoving = None transform = None matrix = None if timing: cleanUpEnd = time.time() if timing: print 'Cleanup took ' + str(cleanUpEnd - cleanUpStart) + ' seconds' end = time.time() print 'Refined landmark ' + state.currentLandmarkName + ' in ' + str(end - start) + ' seconds' slicer.mrmlScene.EndState(slicer.mrmlScene.BatchProcessState)
def setup(self): ScriptedLoadableModuleWidget.setup(self) self.logic = SoundGuidanceLogic() # Instantiate and connect widgets ... self.defaultStyleSheet = "QLabel { color : #000000; \ font: bold 14px}" # Load models first self.SoundGuidanceModuleModelsPath = slicer.modules.soundguidance.path.replace("SoundGuidance.py","") + 'Resources/Models/' self.boxModel = slicer.util.getNode('boxModel') if not self.boxModel: slicer.util.loadModel(self.SoundGuidanceModuleModelsPath + 'box.stl') self.boxModel = slicer.util.getNode(pattern="box") self.boxModelDisplay=self.boxModel.GetModelDisplayNode() self.boxModelDisplay.SetColor([0.098,0.5,0.42]) self.boxModelDisplay.SetOpacity(0.3) self.aroModel = slicer.util.getNode('aroModel') if not self.aroModel: slicer.util.loadModel(self.SoundGuidanceModuleModelsPath + 'aro.stl') self.aroModel = slicer.util.getNode(pattern="aro") self.aroModelDisplay=self.aroModel.GetModelDisplayNode() self.aroModelDisplay.SetColor([0.063,0.14,0.5]) #We create models self.needleModel = slicer.util.getNode('NeedleModel') if not self.needleModel: slicer.util.loadModel(self.SoundGuidanceModuleModelsPath + 'NeedleModel.stl') self.needleModel = slicer.util.getNode(pattern="NeedleModel") self.needleModelDisplay=self.needleModel.GetModelDisplayNode() self.needleModelDisplay.SetColor([0,1,1]) self.pointerModel = slicer.util.getNode('PointerModel') if not self.pointerModel: slicer.util.loadModel(self.SoundGuidanceModuleModelsPath + 'PointerModel.stl') self.pointerModel = slicer.util.getNode(pattern="PointerModel") self.pointerModelDisplay=self.pointerModel.GetModelDisplayNode() self.pointerModelDisplay.SetColor([0,0,0]) self.targetFiducial = slicer.util.getNode('targetFiducial') if not self.targetFiducial: slicer.util.loadMarkupsFiducialList(self.SoundGuidanceModuleModelsPath + 'Target.fcsv') self.targetFiducial = slicer.util.getNode(pattern="Target") self.surfaceFiducial = slicer.util.getNode('surfaceFiducial') if not self.surfaceFiducial: slicer.util.loadMarkupsFiducialList(self.SoundGuidanceModuleModelsPath + 'surfacePoint.fcsv') self.surfaceFiducial = slicer.util.getNode(pattern="surfacePoint") self.xAxisFiducial = slicer.util.getNode('xAxisFiducial') if not self.xAxisFiducial: slicer.util.loadMarkupsFiducialList(self.SoundGuidanceModuleModelsPath + 'xAxisFiducial.fcsv') self.xAxisFiducial= slicer.util.getNode(pattern="xAxisFiducial") # Parameters Area # Parameters Area # parametersCollapsibleButton = ctk.ctkCollapsibleButton() parametersCollapsibleButton.text = "Parameters" self.layout.addWidget(parametersCollapsibleButton) # Layout within the dummy collapsible button parametersFormLayout = qt.QFormLayout(parametersCollapsibleButton) # # Apply Button # self.applyButton = qt.QPushButton("Calculate Distance") self.applyButton.toolTip = "Run the algorithm." self.applyButton.enabled = True self.applyButton.checkable = True parametersFormLayout.addRow(self.applyButton) # Calculate Distance Label self.calculateDistanceLabel = qt.QLabel('-') self.calculateDistanceLabel.setStyleSheet(self.defaultStyleSheet) self.QFormLayoutLabel = qt.QLabel('Distance to target (mm): ') self.QFormLayoutLabel.setStyleSheet(self.defaultStyleSheet) parametersFormLayout.addRow(self.QFormLayoutLabel, self.calculateDistanceLabel) # # Sound Button # self.playSoundButton = qt.QPushButton("Play Sound") self.playSoundButton.enabled = True self.playSoundButton.checkable = True parametersFormLayout.addRow(self.playSoundButton) #Load transformations self.pointerToTracker = slicer.util.getNode('PointerToTracker') if not self.pointerToTracker: print('ERROR: pointerToTracker transform node was not found') self.needleToTracker = slicer.util.getNode('NeedleToTracker') if not self.needleToTracker: print('ERROR: needleToTracker transform node was not found') self.referenceToTracker = slicer.util.getNode('ReferenceToTracker') if not self.referenceToTracker: print('ERROR: referenceToTracker transform node was not found') self.trackerToReference = slicer.util.getNode('TrackerToReference') if not self.trackerToReference: print('ERROR: TrackerToReference transform node was not found') # Load models first self.SoundGuidanceModuleDataPath = slicer.modules.soundguidance.path.replace("SoundGuidance.py","") + 'Resources/Data/' self.needleTipToNeedle = slicer.util.getNode('NeedleTipToNeedle') if not self.needleTipToNeedle: slicer.util.loadTransform(self.SoundGuidanceModuleDataPath + 'NeedleTipToNeedle.h5') self.needleTipToNeedle = slicer.util.getNode(pattern="NeedleTipToNeedle") self.pointerTipToPointer = slicer.util.getNode('PointerTipToPointer') if not self.pointerTipToPointer: slicer.util.loadTransform(self.SoundGuidanceModuleDataPath + 'PointerTipToPointer.h5') self.pointerTipToPointer = slicer.util.getNode(pattern="PointerTipToPointer") self.boxToReference = slicer.util.getNode('BoxToReference') if not self.boxToReference: slicer.util.loadTransform(self.SoundGuidanceModuleDataPath + 'BoxToReference.h5') self.boxToReference = slicer.util.getNode(pattern="BoxToReference") # Tranformations to fix models orientation self.needleModelToNeedleTip = slicer.util.getNode('needleModelToNeedleTip') if not self.needleModelToNeedleTip: self.needleModelToNeedleTip=slicer.vtkMRMLLinearTransformNode() self.needleModelToNeedleTip.SetName("needleModelToNeedleTip") matrixNeedleModel = vtk.vtkMatrix4x4() matrixNeedleModel.SetElement( 0, 0, -1 ) # Row 1 matrixNeedleModel.SetElement( 0, 1, 0 ) matrixNeedleModel.SetElement( 0, 2, 0 ) matrixNeedleModel.SetElement( 0, 3, 0 ) matrixNeedleModel.SetElement( 1, 0, 0 ) # Row 2 matrixNeedleModel.SetElement( 1, 1, 1 ) matrixNeedleModel.SetElement( 1, 2, 0 ) matrixNeedleModel.SetElement( 1, 3, 0 ) matrixNeedleModel.SetElement( 2, 0, 0 ) # Row 3 matrixNeedleModel.SetElement( 2, 1, 0 ) matrixNeedleModel.SetElement( 2, 2, -1 ) matrixNeedleModel.SetElement( 2, 3, 0 ) self.needleModelToNeedleTip.SetMatrixTransformToParent(matrixNeedleModel) slicer.mrmlScene.AddNode(self.needleModelToNeedleTip) self.pointerModelToPointerTip = slicer.util.getNode('pointerModelToPointerTip') if not self.pointerModelToPointerTip: self.pointerModelToPointerTip=slicer.vtkMRMLLinearTransformNode() self.pointerModelToPointerTip.SetName("pointerModelToPointerTip") matrixPointerModel = vtk.vtkMatrix4x4() matrixPointerModel.SetElement( 0, 0, 0 ) # Row 1 matrixPointerModel.SetElement( 0, 1, 0 ) matrixPointerModel.SetElement( 0, 2, 1 ) matrixPointerModel.SetElement( 0, 3, 0 ) matrixPointerModel.SetElement( 1, 0, 0 ) # Row 2 matrixPointerModel.SetElement( 1, 1, 1 ) matrixPointerModel.SetElement( 1, 2, 0 ) matrixPointerModel.SetElement( 1, 3, 0 ) matrixPointerModel.SetElement( 2, 0, -1 ) # Row 3 matrixPointerModel.SetElement( 2, 1, 0 ) matrixPointerModel.SetElement( 2, 2, 0 ) matrixPointerModel.SetElement( 2, 3, 0 ) self.pointerModelToPointerTip.SetMatrixTransformToParent(matrixPointerModel) slicer.mrmlScene.AddNode(self.pointerModelToPointerTip) # connections self.applyButton.connect('clicked(bool)', self.onCalculateDistanceButton) self.playSoundButton.connect('clicked(bool)', self.onplaySoundButtonClicked) #Build Transforms tree # Pointer self.pointerModel.SetAndObserveTransformNodeID(self.pointerModelToPointerTip.GetID()) self.pointerModelToPointerTip.SetAndObserveTransformNodeID(self.pointerTipToPointer.GetID()) self.pointerTipToPointer.SetAndObserveTransformNodeID(self.pointerToTracker.GetID()) # Needle self.needleModel.SetAndObserveTransformNodeID(self.needleModelToNeedleTip.GetID()) self.needleModelToNeedleTip.SetAndObserveTransformNodeID(self.needleTipToNeedle.GetID()) self.needleTipToNeedle.SetAndObserveTransformNodeID(self.needleToTracker.GetID()) #Box and aro self.boxModel.SetAndObserveTransformNodeID(self.boxToReference.GetID()) self.aroModel.SetAndObserveTransformNodeID(self.boxToReference.GetID()) self.targetFiducial.SetAndObserveTransformNodeID(self.boxToReference.GetID()) self.surfaceFiducial.SetAndObserveTransformNodeID(self.boxToReference.GetID()) self.xAxisFiducial.SetAndObserveTransformNodeID(self.boxToReference.GetID()) self.boxToReference.SetAndObserveTransformNodeID(self.referenceToTracker.GetID()) # Add vertical spacer self.layout.addStretch(1)
import slicer # test that brainsfit is available and can run # if this fails, changetracker cannot be used tfm = slicer.vtkMRMLLinearTransformNode() slicer.mrmlScene.AddNode(tfm) vl = slicer.modules.volumes.logic() if len(sys.argv) > 1: path1 = sys.argv[1] path2 = sys.argv[2] else: path1 = slicer.app.slicerHome + "/../../Slicer/Libs/MRML/Core/Testing/TestData/fixed.nrrd" path2 = slicer.app.slicerHome + "/../../Slicer/Libs/MRML/Core/Testing/TestData/moving.nrrd" vol1 = vl.AddArchetypeVolume(path1, 'fixed', 0) vol2 = vl.AddArchetypeVolume(path2, 'moving', 1) parameters = {} parameters['fixedVolume'] = vol1.GetID() parameters['movingVolume'] = vol2.GetID() parameters['useRigid'] = True #parameters['outputVolume'] = '/tmp/test.nrrd' parameters['linearTransform'] = tfm.GetID() print 'ChangeTrackerTest1 brainsfit parameters: ', parameters cliNode = None cliNode = slicer.cli.run(slicer.modules.brainsfit, cliNode, parameters, wait_for_completion = True)
def onAddprobe2Button(self): [success_2, probmodel_2] = slicer.util.loadModel( 'C:\Users\Deniz\Documents\RFNavigation\Probe_removed_casing_Binary_noWire.ply', returnNode=True) Probe_2_Transformation = slicer.vtkMRMLLinearTransformNode() Probe_2_Transformation.ApplyTransform(probmodel_2)
def createTransformNode(name, isBSpline): node = slicer.vtkMRMLBSplineTransformNode() if isBSpline else slicer.vtkMRMLLinearTransformNode() node.SetName(name) slicer.mrmlScene.AddNode(node) return node