def updateSphere(self, position, radius):
    if self.sphereModel == None:
      # Create new model
      print "Creating new sphere model..."
      
      self.sphereModel = slicer.mrmlScene.CreateNodeByClass('vtkMRMLModelNode')
      self.sphereModel.SetName("RobotPlacementSimulatorModel")
      slicer.mrmlScene.AddNode(self.sphereModel)

      displayNode = slicer.mrmlScene.CreateNodeByClass('vtkMRMLModelDisplayNode')
      slicer.mrmlScene.AddNode(displayNode)
      displayNode.SetOpacity(0.35)
      displayNode.SetColor(1.0, 0.0, 0.0)
      self.sphereModel.SetAndObserveDisplayNodeID(displayNode.GetID())

      print "New model created"

    # Update model
    spherePolyData = vtk.vtkSphereSource()
    spherePolyData.SetCenter(position)
    spherePolyData.SetThetaResolution(20)
    spherePolyData.SetPhiResolution(20)
    spherePolyData.SetRadius(radius)
    spherePolyData.Update()

    self.sphereModel.SetAndObservePolyData(spherePolyData.GetOutput())
    self.sphereModel.Modified()
示例#2
0
  def createSampleModelVolume(self, name, color, volumeNode=None):
    if volumeNode:
      self.assertTrue( volumeNode.IsA('vtkMRMLScalarVolumeNode') )
      bounds = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
      volumeNode.GetRASBounds(bounds)
      x = (bounds[0] + bounds[1])/2
      y = (bounds[2] + bounds[3])/2
      z = (bounds[4] + bounds[5])/2
      radius = min(bounds[1]-bounds[0],bounds[3]-bounds[2],bounds[5]-bounds[4]) / 3.0
    else:
      radius = 50
      x = y = z = 0

    # Taken from: http://www.na-mic.org/Bug/view.php?id=1536
    sphere = vtk.vtkSphereSource()
    sphere.SetCenter(x, y, z)
    sphere.SetRadius(radius)

    modelNode = slicer.vtkMRMLModelNode()
    modelNode.SetName(name)
    modelNode = slicer.mrmlScene.AddNode(modelNode)
    if vtk.VTK_MAJOR_VERSION <= 5:
      modelNode.SetAndObservePolyData(sphere.GetOutput())
    else:
      modelNode.SetPolyDataConnection(sphere.GetOutputPort())
    modelNode.SetHideFromEditors(0)

    displayNode = slicer.vtkMRMLModelDisplayNode()
    slicer.mrmlScene.AddNode(displayNode)
    displayNode.SliceIntersectionVisibilityOn()
    displayNode.VisibilityOn()
    displayNode.SetColor(color[0], color[1], color[2])
    modelNode.SetAndObserveDisplayNodeID(displayNode.GetID())

    return modelNode
示例#3
0
  def createNeedleModelNode(self, name):

    locatorModel = self.scene.CreateNodeByClass('vtkMRMLModelNode')
    
    # Cylinder represents the locator stick
    cylinder = vtk.vtkCylinderSource()
    cylinder.SetRadius(1.5)
    cylinder.SetHeight(100)
    cylinder.SetCenter(0, 0, 0)
    cylinder.Update()

    # Rotate cylinder
    tfilter = vtk.vtkTransformPolyDataFilter()
    trans =   vtk.vtkTransform()
    trans.RotateX(90.0)
    trans.Translate(0.0, -50.0, 0.0)
    trans.Update()
    if vtk.VTK_MAJOR_VERSION <= 5:
      tfilter.SetInput(cylinder.GetOutput())
    else:
      tfilter.SetInputConnection(cylinder.GetOutputPort())
    tfilter.SetTransform(trans)
    tfilter.Update()

    # Sphere represents the locator tip
    sphere = vtk.vtkSphereSource()
    sphere.SetRadius(3.0)
    sphere.SetCenter(0, 0, 0)
    sphere.Update()

    apd = vtk.vtkAppendPolyData()

    if vtk.VTK_MAJOR_VERSION <= 5:
      apd.AddInput(sphere.GetOutput())
      apd.AddInput(tfilter.GetOutput())
    else:
      apd.AddInputConnection(sphere.GetOutputPort())
      apd.AddInputConnection(tfilter.GetOutputPort())
    apd.Update()
    
    locatorModel.SetAndObservePolyData(apd.GetOutput());

    self.scene.AddNode(locatorModel)
    locatorModel.SetScene(self.scene);
    locatorModel.SetName(name)
    
    locatorDisp = locatorModel.GetDisplayNodeID()
    if locatorDisp == None:
      locatorDisp = self.scene.CreateNodeByClass('vtkMRMLModelDisplayNode')
      self.scene.AddNode(locatorDisp)
      locatorDisp.SetScene(self.scene)
      locatorModel.SetAndObserveDisplayNodeID(locatorDisp.GetID());
      
    color = [0, 0, 0]
    color[0] = 0.5
    color[1] = 0.5
    color[2] = 1.0
    locatorDisp.SetColor(color)
    
    return locatorModel.GetID()
示例#4
0
  def test_array(self):
    # Test if convenience function of getting numpy array from various nodes works

    self.delayDisplay('Test array with scalar image')
    import SampleData
    sampleDataLogic = SampleData.SampleDataLogic()
    volumeNode = sampleDataLogic.downloadMRHead()
    voxelPos = [120,135,89]
    voxelValueVtk = volumeNode.GetImageData().GetScalarComponentAsDouble(voxelPos[0], voxelPos[1], voxelPos[2], 0)
    narray = slicer.util.arrayFromVolume(volumeNode)
    voxelValueNumpy = narray[voxelPos[2], voxelPos[1], voxelPos[0]]
    self.assertEqual(voxelValueVtk, voxelValueNumpy)

    self.delayDisplay('Test array with tensor image')
    import SampleData
    sampleDataLogic = SampleData.SampleDataLogic()
    tensorVolumeNode = sampleDataLogic.downloadDTIBrain()
    narray = slicer.util.array(tensorVolumeNode.GetName())
    self.assertEqual(narray.shape, (85, 144, 144, 3, 3))

    self.delayDisplay('Test array with model points')
    sphere = vtk.vtkSphereSource()
    modelNode = slicer.mrmlScene.AddNewNodeByClass('vtkMRMLModelNode')
    modelNode.SetPolyDataConnection(sphere.GetOutputPort())
    narray = slicer.util.array(modelNode.GetName())
    self.assertEqual(narray.shape, (50, 3))

    self.delayDisplay('Testing slicer.util.test_array passed')
示例#5
0
    def updateSphere(self, position, radius):
        if self.sphereModel == None:
            # Create new model
            print "Creating new sphere model..."

            self.sphereModel = slicer.mrmlScene.CreateNodeByClass(
                'vtkMRMLModelNode')
            self.sphereModel.SetName("RobotPlacementSimulatorModel")
            slicer.mrmlScene.AddNode(self.sphereModel)

            displayNode = slicer.mrmlScene.CreateNodeByClass(
                'vtkMRMLModelDisplayNode')
            slicer.mrmlScene.AddNode(displayNode)
            displayNode.SetOpacity(0.35)
            displayNode.SetColor(1.0, 0.0, 0.0)
            self.sphereModel.SetAndObserveDisplayNodeID(displayNode.GetID())

            print "New model created"

        # Update model
        spherePolyData = vtk.vtkSphereSource()
        spherePolyData.SetCenter(position)
        spherePolyData.SetThetaResolution(20)
        spherePolyData.SetPhiResolution(20)
        spherePolyData.SetRadius(radius)
        spherePolyData.Update()

        self.sphereModel.SetAndObservePolyData(spherePolyData.GetOutput())
        self.sphereModel.Modified()
示例#6
0
    def test_array(self):
        # Test if convenience function of getting numpy array from various nodes works

        self.delayDisplay('Test array with scalar image')
        import SampleData
        sampleDataLogic = SampleData.SampleDataLogic()
        volumeNode = sampleDataLogic.downloadMRHead()
        voxelPos = [120, 135, 89]
        voxelValueVtk = volumeNode.GetImageData().GetScalarComponentAsDouble(
            voxelPos[0], voxelPos[1], voxelPos[2], 0)
        narray = slicer.util.arrayFromVolume(volumeNode)
        voxelValueNumpy = narray[voxelPos[2], voxelPos[1], voxelPos[0]]
        self.assertEqual(voxelValueVtk, voxelValueNumpy)

        self.delayDisplay('Test array with tensor image')
        import SampleData
        sampleDataLogic = SampleData.SampleDataLogic()
        tensorVolumeNode = sampleDataLogic.downloadDTIBrain()
        narray = slicer.util.array(tensorVolumeNode.GetName())
        self.assertEqual(narray.shape, (85, 144, 144, 3, 3))

        self.delayDisplay('Test array with model points')
        sphere = vtk.vtkSphereSource()
        modelNode = slicer.mrmlScene.AddNewNodeByClass('vtkMRMLModelNode')
        modelNode.SetPolyDataConnection(sphere.GetOutputPort())
        narray = slicer.util.array(modelNode.GetName())
        self.assertEqual(narray.shape, (50, 3))

        self.delayDisplay('Testing slicer.util.test_array passed')
示例#7
0
    def updateTipModelNode(self, tipModelNode, poly, p0, pe, radius, color,
                           opacity):

        points = vtk.vtkPoints()
        cellArray = vtk.vtkCellArray()
        points.SetNumberOfPoints(2)
        cellArray.InsertNextCell(2)

        points.SetPoint(0, p0)
        cellArray.InsertCellPoint(0)
        points.SetPoint(1, pe)
        cellArray.InsertCellPoint(1)

        poly.Initialize()
        poly.SetPoints(points)
        poly.SetLines(cellArray)

        tubeFilter = vtk.vtkTubeFilter()
        tubeFilter.SetInputData(poly)
        tubeFilter.SetRadius(radius)
        tubeFilter.SetNumberOfSides(20)
        tubeFilter.CappingOn()
        tubeFilter.Update()

        # Sphere represents the locator tip
        sphere = vtk.vtkSphereSource()
        sphere.SetRadius(radius * 2.0)
        sphere.SetCenter(pe)
        sphere.Update()

        apd = vtk.vtkAppendPolyData()

        if vtk.VTK_MAJOR_VERSION <= 5:
            apd.AddInput(sphere.GetOutput())
            apd.AddInput(tubeFilter.GetOutput())
        else:
            apd.AddInputConnection(sphere.GetOutputPort())
            apd.AddInputConnection(tubeFilter.GetOutputPort())
        apd.Update()

        tipModelNode.SetAndObservePolyData(apd.GetOutput())
        tipModelNode.Modified()

        tipDispID = tipModelNode.GetDisplayNodeID()
        if tipDispID == None:
            tipDispNode = self.scene.AddNewNodeByClass(
                'vtkMRMLModelDisplayNode')
            tipDispNode.SetScene(self.scene)
            tipModelNode.SetAndObserveDisplayNodeID(tipDispNode.GetID())
            tipDispID = tipModelNode.GetDisplayNodeID()

        tipDispNode = self.scene.GetNodeByID(tipDispID)

        prevState = tipDispNode.StartModify()
        tipDispNode.SetColor(color)
        tipDispNode.SetOpacity(opacity)
        tipDispNode.SliceIntersectionVisibilityOn()
        tipDispNode.SetSliceDisplayModeToIntersection()
        tipDispNode.EndModify(prevState)
  def __init__(self, targetFiducialListNode, radius):
    target = targetFiducialListNode
    
    scene = slicer.mrmlScene
    
    sphere = vtk.vtkSphereSource()
    sphere.SetRadius(radius)
    sphere.SetThetaResolution(20)
    sphere.SetPhiResolution(20)
    sphere.Update()

    # Create model node
    insertionRadiusModel = slicer.vtkMRMLModelNode()
    insertionRadiusModel.SetScene(scene)
    insertionRadiusModel.SetName("InsertionSphere-%s" % target.GetName())
    insertionRadiusModel.SetAndObservePolyData(sphere.GetOutput())

    # Create display node
    insertionRadiusModelDisplay = slicer.vtkMRMLModelDisplayNode()
    insertionRadiusModelDisplay.SetColor(0.8,0.8,0.8)
    insertionRadiusModelDisplay.SetOpacity(0.3)
    insertionRadiusModelDisplay.SliceIntersectionVisibilityOn()
    
    insertionRadiusModelDisplay.SetScene(scene)
    scene.AddNode(insertionRadiusModelDisplay)
    insertionRadiusModel.SetAndObserveDisplayNodeID(insertionRadiusModelDisplay.GetID())

    # Add to scene
    insertionRadiusModelDisplay.SetPolyData(sphere.GetOutput())
    
    scene.AddNode(insertionRadiusModel)
    
    # Create insertionRadiusTransform node
    insertionRadiusTransform = slicer.vtkMRMLLinearTransformNode()
    insertionRadiusTransform.SetName('InsertionRadiusTransform-%s' % target.GetName())
    
    scene.AddNode(insertionRadiusTransform)
    
    # Translation
    transformMatrix = vtk.vtkMatrix4x4()
    
    # get coordinates from current fiducial
    currentFiducialCoordinatesRAS = [0, 0, 0]
    
    target.GetFiducialCoordinates(currentFiducialCoordinatesRAS)
    
    transformMatrix.SetElement(0, 3, currentFiducialCoordinatesRAS[0])
    transformMatrix.SetElement(1, 3, currentFiducialCoordinatesRAS[1])
    transformMatrix.SetElement(2, 3, currentFiducialCoordinatesRAS[2])
    
    insertionRadiusTransform.ApplyTransformMatrix(transformMatrix)
    
    insertionRadiusModel.SetAndObserveTransformNodeID(insertionRadiusTransform.GetID())
    
    self.sphere = sphere
    self.insertionRadiusModel = insertionRadiusModel
    self.insertionRadiusModelDisplay = insertionRadiusModelDisplay
    self.insertionRadiusTransform = insertionRadiusTransform
示例#9
0
 def onDeleteAllFiducialsClicked(self):
     self.tumorMarkups_Needle.RemoveAllMarkups()
     self.deleteLastFiducialButton.setEnabled(False)
     self.deleteAllFiducialsButton.setEnabled(False)
     self.deleteLastFiducialDuringNavigationButton.setEnabled(False)
     sphereSource = vtk.vtkSphereSource()
     sphereSource.SetRadius(0.001)
     self.tumorModel_Needle.SetPolyDataConnection(sphereSource.GetOutputPort())
     self.tumorModel_Needle.Modified()
示例#10
0
 def onDeleteAllFiducialsClicked(self):
     self.tumorMarkups_Needle.RemoveAllMarkups()
     self.deleteLastFiducialButton.setEnabled(False)
     self.deleteAllFiducialsButton.setEnabled(False)
     self.deleteLastFiducialDuringNavigationButton.setEnabled(False)
     sphereSource = vtk.vtkSphereSource()
     sphereSource.SetRadius(0.001)
     self.tumorModel_Needle.SetPolyDataConnection(
         sphereSource.GetOutputPort())
     self.tumorModel_Needle.Modified()
示例#11
0
  def updateAblationVolume(self):

    if self.AutomaticUpdate == False:
      return

    if self.SourceNode and self.DestinationNode:

      pTip = [0.0, 0.0, 0.0]
      pTail = [0.0, 0.0, 0.0]
      #self.SourceNode.GetNthFiducialPosition(0,pTip)
      self.SourceNode.GetPosition1(pTip)
      #self.SourceNode.GetNthFiducialPosition(1,pTail)
      self.SourceNode.GetPosition2(pTail)
      
      if self.DestinationNode.GetDisplayNodeID() == None:
        modelDisplayNode = slicer.vtkMRMLModelDisplayNode()
        modelDisplayNode.SetColor(self.ModelColor)
        slicer.mrmlScene.AddNode(modelDisplayNode)
        self.DestinationNode.SetAndObserveDisplayNodeID(modelDisplayNode.GetID())
        
      displayNodeID = self.DestinationNode.GetDisplayNodeID()
      modelDisplayNode = slicer.mrmlScene.GetNodeByID(displayNodeID)

      if modelDisplayNode != None and self.SliceIntersection == True:
        modelDisplayNode.SliceIntersectionVisibilityOn()
      else:
        modelDisplayNode.SliceIntersectionVisibilityOff()
        
      if self.SphereSource == None:  
        self.SphereSource = vtk.vtkSphereSource()
        self.SphereSource.SetThetaResolution(20)
        self.SphereSource.SetPhiResolution(20)
        self.SphereSource.Update()
        
      # Scale sphere to make ellipsoid
      scale = vtk.vtkTransform()
      scale.Scale(self.MinorAxis, self.MinorAxis, self.MajorAxis)
      scaleFilter = vtk.vtkTransformPolyDataFilter()
      scaleFilter.SetInputConnection(self.SphereSource.GetOutputPort())
      scaleFilter.SetTransform(scale)
      scaleFilter.Update();
      
      # Transform
      transform = vtk.vtkTransform()
      self.computeTransform(pTip, pTail, self.TipOffset, transform)
      transformFilter = vtk.vtkTransformPolyDataFilter()
      transformFilter.SetInputConnection(scaleFilter.GetOutputPort())
      transformFilter.SetTransform(transform)
      transformFilter.Update();
      
      self.DestinationNode.SetAndObservePolyData(transformFilter.GetOutput())
      self.DestinationNode.Modified()
      
      if self.DestinationNode.GetScene() == None:
        slicer.mrmlScene.AddNode(self.DestinationNode)
 def defineSphere(self):
     sphereSource = vtk.vtkSphereSource()
     sphereSource.SetRadius(100.0)
     model = slicer.vtkMRMLModelNode()
     model.SetAndObservePolyData(sphereSource.GetOutput())
     modelDisplay = slicer.vtkMRMLModelDisplayNode()
     modelDisplay.SetColor(0.5,0.5,0.5)
     slicer.mrmlScene.AddNode(modelDisplay)
     model.SetAndObserveDisplayNodeID(modelDisplay.GetID())
     modelDisplay.SetInputPolyDataConnection(sphereSource.GetOutputPort())
     return model
  def updateSphere(self,radius):    
    sphereCenter = [0.0, 0.0, 0.0]
    if self.sphereSeedListSelector.currentNode():
      self.sphereSeedListSelector.currentNode().GetNthFiducialPosition(0,sphereCenter)

    sphere = vtk.vtkSphereSource()
    sphere.SetCenter(sphereCenter)
    sphere.SetThetaResolution(20)
    sphere.SetPhiResolution(20)
    sphere.SetRadius(radius)
    sphere.Update()
    
    self.sphereModel.SetAndObservePolyData(sphere.GetOutput())
    self.sphereModel.Modified()
示例#14
0
    def updateSphere(self, radius):
        sphereCenter = [0.0, 0.0, 0.0]
        if self.sphereSeedListSelector.currentNode():
            self.sphereSeedListSelector.currentNode().GetNthFiducialPosition(
                0, sphereCenter)

        sphere = vtk.vtkSphereSource()
        sphere.SetCenter(sphereCenter)
        sphere.SetThetaResolution(20)
        sphere.SetPhiResolution(20)
        sphere.SetRadius(radius)
        sphere.Update()

        self.sphereModel.SetAndObservePolyData(sphere.GetOutput())
        self.sphereModel.Modified()
示例#15
0
 def DisplayPoints(self, polyDataLine,name):
   """ Will display all of the points of a given Polydata Line
   """
   sphere= vtk.vtkSphereSource()
   sphere.SetRadius(0.3)
   sphere.Update()
   glyphFilter=vtk.vtkGlyph3D()
   glyphFilter.ScalingOff()
   glyphFilter.SetSourceData(sphere.GetOutput()) #object at eachPoint
   glyphFilter.SetInputData(polyDataLine)
   glyphFilter.Update()
   node=self.DisplayPolyData(name, glyphFilter.GetOutput())
   node.SetColor(0.3,0.4,1) #Max 1 for each column
   node.SetAmbient(1)
   return node
示例#16
0
 def DisplayPoints(self, polyDataLine, name):
     """ Will display all of the points of a given Polydata Line
 """
     sphere = vtk.vtkSphereSource()
     sphere.SetRadius(0.3)
     sphere.Update()
     glyphFilter = vtk.vtkGlyph3D()
     glyphFilter.ScalingOff()
     glyphFilter.SetSourceData(sphere.GetOutput())  #object at eachPoint
     glyphFilter.SetInputData(polyDataLine)
     glyphFilter.Update()
     node = self.DisplayPolyData(name, glyphFilter.GetOutput())
     node.SetColor(0.3, 0.4, 1)  #Max 1 for each column
     node.SetAmbient(1)
     return node
示例#17
0
    def putAtArucoCentre(self, markupList, listToAdd, heatmap_node_list, colour_list):
        p = slicer.mrmlScene.GetNodesByName(markupList)
        node = p.GetItemAsObject(0)
        for i in range(node.GetNumberOfFiducials()):
            coord = [0, 0, 0]
            node.GetNthFiducialPosition(i, coord)
            coord.append(1)
            # Multiply to put start point relative to aruco marker cube origin
            point = self.aruco_position_matrix.MultiplyPoint(coord)
            print 'List: ', markupList
            print 'Coord Number : ', i
            print 'Position: ', coord
            print 'oord wrt marker center in slicer: ', point

            listToAdd.append(point)
            # Create Models for Display
            names = ['center_cyl_{}'.format(i) + markupList, 'intermediate_cyl_{}'.format(i) + markupList,
                     'outer_cyl_{}'.format(i) + markupList]
           
            concentric_cylinders = []
            cylinder_model_nodes = []
            display_marker_cylinders = []
            for j in range(0, 1):
                if slicer.mrmlScene.GetFirstNodeByName(names[j]) is None:
                    model_node = slicer.mrmlScene.AddNewNodeByClass('vtkMRMLModelNode')
                    model_node.SetName(names[j])
                else:
                    model_node = slicer.mrmlScene.GetFirstNodeByName(names[j])
                cyl = vtk.vtkSphereSource()
                cyl.SetRadius(3 * (j + 1))
                # cyl.SetHeight(60.0)
                cyl.Update()
                model_node.SetAndObservePolyData(cyl.GetOutput())
                model_node.CreateDefaultDisplayNodes()
                model_node.GetDisplayNode().SetSliceIntersectionVisibility(True)
                model_node.GetDisplayNode().SetSliceDisplayMode(1)
                model_node.GetDisplayNode().SetColor(colour_list[j][0], colour_list[j][1], colour_list[j][2])
                concentric_cylinders.append(cyl)
                cylinder_model_nodes.append(model_node)
                if slicer.mrmlScene.GetFirstNodeByName(names[j] + 't_form') is None:
                    t_form_node = slicer.mrmlScene.AddNewNodeByClass('vtkMRMLTransformNode')
                    t_form_node.SetName(names[j] + 't_form')
                else:
                    t_form_node = slicer.mrmlScene.GetFirstNodeByName(names[j] + 't_form')
                model_node.SetAndObserveTransformNodeID(t_form_node.GetID())
                display_marker_cylinders.append(t_form_node)
            heatmap_node_list.append(display_marker_cylinders)
示例#18
0
  def test_arrayFromModelPoints(self):
    # Test if retrieving point coordinates as a numpy array works

    self.delayDisplay('Create a model containing a sphere')
    sphere = vtk.vtkSphereSource()
    sphere.SetRadius(30.0)
    sphere.Update()
    modelNode = slicer.mrmlScene.AddNewNodeByClass('vtkMRMLModelNode')
    modelNode.SetAndObservePolyData(sphere.GetOutput())
    modelNode.CreateDefaultDisplayNodes()
    a = slicer.util.arrayFromModelPoints(modelNode)

    self.delayDisplay('Change Y scaling')
    a[:,2] = a[:,2] * 2.5
    modelNode.GetPolyData().Modified()

    self.delayDisplay('Testing slicer.util.test_arrayFromModelPoints passed')
示例#19
0
    def test_arrayFromModelPoints(self):
        # Test if retrieving point coordinates as a numpy array works

        self.delayDisplay('Create a model containing a sphere')
        sphere = vtk.vtkSphereSource()
        sphere.SetRadius(30.0)
        sphere.Update()
        modelNode = slicer.mrmlScene.AddNewNodeByClass('vtkMRMLModelNode')
        modelNode.SetAndObservePolyData(sphere.GetOutput())
        modelNode.CreateDefaultDisplayNodes()
        a = slicer.util.arrayFromModelPoints(modelNode)

        self.delayDisplay('Change Y scaling')
        a[:, 2] = a[:, 2] * 2.5
        modelNode.GetPolyData().Modified()

        self.delayDisplay(
            'Testing slicer.util.test_arrayFromModelPoints passed')
示例#20
0
 def pointModel(self, scene, point, name, color):
     """ Create a point model using sphere"""
     #Point 
     sphere = vtk.vtkSphereSource()
     sphere.SetCenter(point)
     sphere.SetRadius(2)
     # Create model node
     pointModel = slicer.vtkMRMLModelNode()
     pointModel.SetScene(scene)
     pointModel.SetName(name)
     pointModel.SetAndObservePolyData(sphere.GetOutput())
     #Create display node
     pointModelDisplay = slicer.vtkMRMLModelDisplayNode()
     pointModelDisplay.SetColor(color)
     pointModelDisplay.SetScene(scene)
     scene.AddNode(pointModelDisplay)
     pointModel.SetAndObserveDisplayNodeID(pointModelDisplay.GetID())
     #Add to scene
     pointModelDisplay.SetInputPolyData(sphere.GetOutput())
     scene.AddNode(pointModel)
  def AddDamageTemplateModel(self,scene,LineLandmarkTransform ):
      # check if already implemented
      if ( self.DamageTemplateModel != None ):
        print "removing", self.DamageTemplateModel.GetName()
        scene.RemoveNode(self.DamageTemplateModel)
      # create sphere and scale
      vtkSphere = vtk.vtkSphereSource()
      vtkSphere.SetRadius(1.) 
      vtkSphere.SetThetaResolution(16)
      vtkSphere.SetPhiResolution(16)
      ScaleAffineTransform = vtk.vtkTransform()
      ScaleAffineTransform.Scale([self.AblationMinorAxis,self.AblationMajorAxis,self.AblationMinorAxis])
      vtkEllipsoid= vtk.vtkTransformFilter()
      vtkEllipsoid.SetInput(vtkSphere.GetOutput() ) 
      vtkEllipsoid.SetTransform( ScaleAffineTransform ) 
      vtkEllipsoid.Update()

      slicertransformFilter = vtk.vtkTransformFilter()
      slicertransformFilter.SetInput(vtkEllipsoid.GetOutput() ) 
      slicertransformFilter.SetTransform( LineLandmarkTransform ) 
      slicertransformFilter.Update()
      dampolyData=slicertransformFilter.GetOutput();

      # Create model node
      self.DamageTemplateModel = slicer.vtkMRMLModelNode()
      self.DamageTemplateModel.SetScene(scene)
      #self.DamageTemplateModel.SetName(scene.GenerateUniqueName("Treatment-%s" % fiducialsNode.GetName()))
      self.DamageTemplateModel.SetName( scene.GenerateUniqueName("Treatment") )
      self.DamageTemplateModel.SetAndObservePolyData(dampolyData)

      # Create display node
      modelDisplay = slicer.vtkMRMLModelDisplayNode()
      modelDisplay.SetColor(1,1,0) # yellow
      modelDisplay.SetOpacity(0.3) 
      modelDisplay.SetScene(scene)
      scene.AddNode(modelDisplay)
      self.DamageTemplateModel.SetAndObserveDisplayNodeID(modelDisplay.GetID())

      # Add to scene
      modelDisplay.SetInputPolyData(self.DamageTemplateModel.GetPolyData())
      scene.AddNode(self.DamageTemplateModel)
示例#22
0
 def handCursor(self, whichHand='Left'):
     """Create the mrml structure to represent a hand cursor if needed
 otherwise return the current transform
 whichHand : 'Left' for left color, anything else for right
             also defines suffix for Transform and Cursor
 """
     transformName = '%s-To-Table' % whichHand
     transformNode = slicer.util.getNode(transformName)
     if not transformNode:
         # make the mrml
         sphere = vtk.vtkSphereSource()
         sphere.Update()
         # Create model node
         cursor = slicer.vtkMRMLModelNode()
         cursor.SetScene(slicer.mrmlScene)
         cursor.SetName("Cursor-%s" % whichHand)
         cursor.SetAndObservePolyData(sphere.GetOutput())
         # Create display node
         cursorModelDisplay = slicer.vtkMRMLModelDisplayNode()
         if whichHand == 'Left':
             color = (1, .84313725490196079, 0)  # gold (wedding ring hand)
         else:
             color = (0.69411764705882351, 0.47843137254901963,
                      0.396078431372549)  # slicer skin tone
         cursorModelDisplay.SetColor(color)
         cursorModelDisplay.SetScene(slicer.mrmlScene)
         slicer.mrmlScene.AddNode(cursorModelDisplay)
         cursor.SetAndObserveDisplayNodeID(cursorModelDisplay.GetID())
         # Add to slicer.mrmlScene
         cursorModelDisplay.SetInputPolyData(sphere.GetOutput())
         slicer.mrmlScene.AddNode(cursor)
         # Create transform node
         transformNode = slicer.vtkMRMLLinearTransformNode()
         transformNode.SetName(transformName)
         for i in xrange(3):
             transformNode.GetMatrixTransformToParent().SetElement(i, i, 10)
         slicer.mrmlScene.AddNode(transformNode)
         cursor.SetAndObserveTransformNodeID(transformNode.GetID())
     handLineNode = self.handLine(whichHand)
     return transformNode, handLineNode
示例#23
0
 def handCursor(self,whichHand='Left'):
   """Create the mrml structure to represent a hand cursor if needed
   otherwise return the current transform
   whichHand : 'Left' for left color, anything else for right
               also defines suffix for Transform and Cursor
   """
   transformName = '%s-To-Table' % whichHand
   transformNode = slicer.util.getNode(transformName)
   if not transformNode:
     # make the mrml 
     sphere = vtk.vtkSphereSource()
     sphere.Update()
     # Create model node
     cursor = slicer.vtkMRMLModelNode()
     cursor.SetScene(slicer.mrmlScene)
     cursor.SetName("Cursor-%s" % whichHand)
     cursor.SetAndObservePolyData(sphere.GetOutput())
     # Create display node
     cursorModelDisplay = slicer.vtkMRMLModelDisplayNode()
     if whichHand == 'Left':
       color = (1,.84313725490196079,0) # gold (wedding ring hand)
     else:
       color = (0.69411764705882351, 0.47843137254901963, 0.396078431372549) # slicer skin tone
     cursorModelDisplay.SetColor(color)
     cursorModelDisplay.SetScene(slicer.mrmlScene)
     slicer.mrmlScene.AddNode(cursorModelDisplay)
     cursor.SetAndObserveDisplayNodeID(cursorModelDisplay.GetID())
     # Add to slicer.mrmlScene
     cursorModelDisplay.SetInputPolyData(sphere.GetOutput())
     slicer.mrmlScene.AddNode(cursor)
     # Create transform node
     transformNode = slicer.vtkMRMLLinearTransformNode()
     transformNode.SetName(transformName)
     for i in xrange(3):
       transformNode.GetMatrixTransformToParent().SetElement(i, i, 10)
     slicer.mrmlScene.AddNode(transformNode)
     cursor.SetAndObserveTransformNodeID(transformNode.GetID())
   handLineNode = self.handLine(whichHand)
   return transformNode,handLineNode
示例#24
0
  def createNeedleModelNode(self, name,index):
    
    locatorModel = self.scene.CreateNodeByClass('vtkMRMLModelNode')
    
    # Cylinder represents the locator stick
    cylinder = vtk.vtkCylinderSource()
    cylinder.SetRadius(1.5)
    cylinder.SetHeight(100)
    cylinder.SetCenter(0, 0, 0)
    cylinder.Update()
    
    # Rotate cylinder
    tfilter = vtk.vtkTransformPolyDataFilter()
    trans =   vtk.vtkTransform()
    trans.RotateX(90.0)
    trans.Translate(0.0, -50.0, 0.0)
    trans.Update()
    if vtk.VTK_MAJOR_VERSION <= 5:
      tfilter.SetInput(cylinder.GetOutput())
    else:
      tfilter.SetInputConnection(cylinder.GetOutputPort())
    tfilter.SetTransform(trans)
    tfilter.Update()
    
    # Sphere represents the locator tip
    sphere = vtk.vtkSphereSource()
    sphere.SetRadius(3.0)
    sphere.SetCenter(0, 0, 0)
    sphere.Update()
    
    apd = vtk.vtkAppendPolyData()
    
    if vtk.VTK_MAJOR_VERSION <= 5:
      apd.AddInput(sphere.GetOutput())
      apd.AddInput(tfilter.GetOutput())
    else:
      apd.AddInputConnection(sphere.GetOutputPort())
      apd.AddInputConnection(tfilter.GetOutputPort())
    apd.Update()
    
    locatorModel.SetAndObservePolyData(apd.GetOutput());
    
    self.scene.AddNode(locatorModel)
    locatorModel.SetScene(self.scene);
    needleName = "Needle_%s" % name
    locatorModel.SetName(needleName)
    
    locatorDisp = locatorModel.GetDisplayNodeID()
    if locatorDisp == None:
      locatorDisp = self.scene.CreateNodeByClass('vtkMRMLModelDisplayNode')
      self.scene.AddNode(locatorDisp)
      locatorDisp.SetScene(self.scene)
      locatorModel.SetAndObserveDisplayNodeID(locatorDisp.GetID());

    color = [0, 0, 0]
    color[0] = 0.5
    color[1] = 0.5
    color[2] = 1.0
    locatorDisp.SetColor(color)
    print name
    if self.colorMap.get(name):
      locatorDisp.SetColor(self.colorMap.get(name))
      color = self.colorMap.get(name)
      colorName = "background:rgb({},{},{})".format(255*color[0], 255*color[1], 255*color[2])
      print colorName
      self.widget.colorSelectors[index].setStyleSheet(colorName)
      #qss = qt.QString("background-color: %1").arg(col.name());

    return locatorModel.GetID()
示例#25
0
    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
        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()))
        cursor.SetAndObservePolyData(sphere.GetOutput())

        # 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
        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
示例#26
0
# This module was tested on 3D Slicer version 4.3.1
示例#27
0
    def setupScene(self):  # applet specific
        logging.debug("setupScene")
        Guidelet.setupScene(self)

        logging.debug("Create transforms")

        self.cauteryTipToCautery = slicer.util.getNode("CauteryTipToCautery")
        if not self.cauteryTipToCautery:
            self.cauteryTipToCautery = slicer.vtkMRMLLinearTransformNode()
            self.cauteryTipToCautery.SetName("CauteryTipToCautery")
            m = self.readTransformFromSettings("CauteryTipToCautery")
            if m:
                self.cauteryTipToCautery.SetMatrixTransformToParent(m)
            slicer.mrmlScene.AddNode(self.cauteryTipToCautery)

        self.cauteryModelToCauteryTip = slicer.util.getNode("CauteryModelToCauteryTip")
        if not self.cauteryModelToCauteryTip:
            self.cauteryModelToCauteryTip = slicer.vtkMRMLLinearTransformNode()
            self.cauteryModelToCauteryTip.SetName("CauteryModelToCauteryTip")
            m = self.readTransformFromSettings("CauteryModelToCauteryTip")
            if m:
                self.cauteryModelToCauteryTip.SetMatrixTransformToParent(m)
            self.cauteryModelToCauteryTip.SetMatrixTransformToParent(m)
            slicer.mrmlScene.AddNode(self.cauteryModelToCauteryTip)

        self.needleTipToNeedle = slicer.util.getNode("NeedleTipToNeedle")
        if not self.needleTipToNeedle:
            self.needleTipToNeedle = slicer.vtkMRMLLinearTransformNode()
            self.needleTipToNeedle.SetName("NeedleTipToNeedle")
            m = self.readTransformFromSettings("NeedleTipToNeedle")
            if m:
                self.needleTipToNeedle.SetMatrixTransformToParent(m)
            slicer.mrmlScene.AddNode(self.needleTipToNeedle)

        self.needleModelToNeedleTip = slicer.util.getNode("NeedleModelToNeedleTip")
        if not self.needleModelToNeedleTip:
            self.needleModelToNeedleTip = slicer.vtkMRMLLinearTransformNode()
            self.needleModelToNeedleTip.SetName("NeedleModelToNeedleTip")
            m = self.readTransformFromSettings("NeedleModelToNeedleTip")
            if m:
                self.needleModelToNeedleTip.SetMatrixTransformToParent(m)
            self.needleModelToNeedleTip.SetMatrixTransformToParent(m)
            slicer.mrmlScene.AddNode(self.needleModelToNeedleTip)

        self.cauteryCameraToCautery = slicer.util.getNode("CauteryCameraToCautery")
        if not self.cauteryCameraToCautery:
            self.cauteryCameraToCautery = slicer.vtkMRMLLinearTransformNode()
            self.cauteryCameraToCautery.SetName("CauteryCameraToCautery")
            m = vtk.vtkMatrix4x4()
            m.SetElement(0, 0, 0)
            m.SetElement(0, 2, -1)
            m.SetElement(1, 1, 0)
            m.SetElement(1, 0, 1)
            m.SetElement(2, 2, 0)
            m.SetElement(2, 1, -1)
            self.cauteryCameraToCautery.SetMatrixTransformToParent(m)
            slicer.mrmlScene.AddNode(self.cauteryCameraToCautery)

        self.CauteryToNeedle = slicer.util.getNode("CauteryToNeedle")
        if not self.CauteryToNeedle:
            self.CauteryToNeedle = slicer.vtkMRMLLinearTransformNode()
            self.CauteryToNeedle.SetName("CauteryToNeedle")
            slicer.mrmlScene.AddNode(self.CauteryToNeedle)

        # Create transforms that will be updated through OpenIGTLink

        self.cauteryToReference = slicer.util.getNode("CauteryToReference")
        if not self.cauteryToReference:
            self.cauteryToReference = slicer.vtkMRMLLinearTransformNode()
            self.cauteryToReference.SetName("CauteryToReference")
            slicer.mrmlScene.AddNode(self.cauteryToReference)

        self.needleToReference = slicer.util.getNode("NeedleToReference")
        if not self.needleToReference:
            self.needleToReference = slicer.vtkMRMLLinearTransformNode()
            self.needleToReference.SetName("NeedleToReference")
            slicer.mrmlScene.AddNode(self.needleToReference)

        # Cameras
        logging.debug("Create cameras")

        self.LeftCamera = slicer.util.getNode("Left Camera")
        if not self.LeftCamera:
            self.LeftCamera = slicer.vtkMRMLCameraNode()
            self.LeftCamera.SetName("Left Camera")
            slicer.mrmlScene.AddNode(self.LeftCamera)

        self.RightCamera = slicer.util.getNode("Right Camera")
        if not self.RightCamera:
            self.RightCamera = slicer.vtkMRMLCameraNode()
            self.RightCamera.SetName("Right Camera")
            slicer.mrmlScene.AddNode(self.RightCamera)

        # Models
        logging.debug("Create models")

        self.cauteryModel_CauteryTip = slicer.util.getNode("CauteryModel")
        if not self.cauteryModel_CauteryTip:
            if self.parameterNode.GetParameter("TestMode") == "True":
                moduleDirectoryPath = slicer.modules.lumpnav.path.replace("LumpNav.py", "")
                slicer.util.loadModel(
                    qt.QDir.toNativeSeparators(moduleDirectoryPath + "../../../models/temporary/cautery.stl")
                )
                self.cauteryModel_CauteryTip = slicer.util.getNode(pattern="cautery")
            else:
                slicer.modules.createmodels.logic().CreateNeedle(100, 1.0, 2.5, 0)
                self.cauteryModel_CauteryTip = slicer.util.getNode(pattern="NeedleModel")
                self.cauteryModel_CauteryTip.GetDisplayNode().SetColor(1.0, 1.0, 0)
            self.cauteryModel_CauteryTip.SetName("CauteryModel")

        self.needleModel_NeedleTip = slicer.util.getNode("NeedleModel")
        if not self.needleModel_NeedleTip:
            slicer.modules.createmodels.logic().CreateNeedle(80, 1.0, 2.5, 0)
            self.needleModel_NeedleTip = slicer.util.getNode(pattern="NeedleModel")
            self.needleModel_NeedleTip.GetDisplayNode().SetColor(0.333333, 1.0, 1.0)
            self.needleModel_NeedleTip.SetName("NeedleModel")
            self.needleModel_NeedleTip.GetDisplayNode().SliceIntersectionVisibilityOn()

        # Create surface from point set

        logging.debug("Create surface from point set")

        self.tumorModel_Needle = slicer.util.getNode("TumorModel")
        if not self.tumorModel_Needle:
            self.tumorModel_Needle = slicer.vtkMRMLModelNode()
            self.tumorModel_Needle.SetName("TumorModel")
            sphereSource = vtk.vtkSphereSource()
            sphereSource.SetRadius(0.001)
            self.tumorModel_Needle.SetPolyDataConnection(sphereSource.GetOutputPort())
            slicer.mrmlScene.AddNode(self.tumorModel_Needle)
            # Add display node
            modelDisplayNode = slicer.vtkMRMLModelDisplayNode()
            modelDisplayNode.SetColor(0, 1, 0)  # Green
            modelDisplayNode.BackfaceCullingOff()
            modelDisplayNode.SliceIntersectionVisibilityOn()
            modelDisplayNode.SetSliceIntersectionThickness(4)
            modelDisplayNode.SetOpacity(0.3)  # Between 0-1, 1 being opaque
            slicer.mrmlScene.AddNode(modelDisplayNode)
            self.tumorModel_Needle.SetAndObserveDisplayNodeID(modelDisplayNode.GetID())

        tumorMarkups_Needle = slicer.util.getNode("T")
        if not tumorMarkups_Needle:
            tumorMarkups_Needle = slicer.vtkMRMLMarkupsFiducialNode()
            tumorMarkups_Needle.SetName("T")
            slicer.mrmlScene.AddNode(tumorMarkups_Needle)
            tumorMarkups_Needle.CreateDefaultDisplayNodes()
            tumorMarkups_Needle.GetDisplayNode().SetTextScale(0)
        self.setAndObserveTumorMarkupsNode(tumorMarkups_Needle)

        # Set up breach warning node
        logging.debug("Set up breach warning")
        self.breachWarningNode = slicer.util.getNode("LumpNavBreachWarning")

        if not self.breachWarningNode:
            self.breachWarningNode = slicer.mrmlScene.CreateNodeByClass("vtkMRMLBreachWarningNode")
            self.breachWarningNode.SetName("LumpNavBreachWarning")
            slicer.mrmlScene.AddNode(self.breachWarningNode)
            self.breachWarningNode.SetPlayWarningSound(True)
            self.breachWarningNode.SetWarningColor(1, 0, 0)
            self.breachWarningNode.SetOriginalColor(self.tumorModel_Needle.GetDisplayNode().GetColor())
            self.breachWarningNode.SetAndObserveToolTransformNodeId(self.cauteryTipToCautery.GetID())
            self.breachWarningNode.SetAndObserveWatchedModelNodeID(self.tumorModel_Needle.GetID())

        # Set up breach warning light
        import BreachWarningLight

        logging.debug("Set up breach warning light")
        self.breachWarningLightLogic = BreachWarningLight.BreachWarningLightLogic()
        self.breachWarningLightLogic.setMarginSizeMm(
            float(self.parameterNode.GetParameter("BreachWarningLightMarginSizeMm"))
        )
        if self.parameterNode.GetParameter("EnableBreachWarningLight") == "True":
            logging.debug("BreachWarningLight: active")
            self.breachWarningLightLogic.startLightFeedback(self.breachWarningNode, self.connectorNode)
        else:
            logging.debug("BreachWarningLight: shutdown")
            self.breachWarningLightLogic.shutdownLight(self.connectorNode)

        # Build transform tree
        logging.debug("Set up transform tree")
        self.cauteryToReference.SetAndObserveTransformNodeID(self.ReferenceToRas.GetID())
        self.cauteryCameraToCautery.SetAndObserveTransformNodeID(self.cauteryToReference.GetID())
        self.cauteryTipToCautery.SetAndObserveTransformNodeID(self.cauteryToReference.GetID())
        self.cauteryModelToCauteryTip.SetAndObserveTransformNodeID(self.cauteryTipToCautery.GetID())
        self.needleToReference.SetAndObserveTransformNodeID(self.ReferenceToRas.GetID())
        self.needleTipToNeedle.SetAndObserveTransformNodeID(self.needleToReference.GetID())
        self.needleModelToNeedleTip.SetAndObserveTransformNodeID(self.needleTipToNeedle.GetID())
        self.cauteryModel_CauteryTip.SetAndObserveTransformNodeID(self.cauteryModelToCauteryTip.GetID())
        self.needleModel_NeedleTip.SetAndObserveTransformNodeID(self.needleModelToNeedleTip.GetID())
        self.tumorModel_Needle.SetAndObserveTransformNodeID(self.needleToReference.GetID())
        self.tumorMarkups_Needle.SetAndObserveTransformNodeID(self.needleToReference.GetID())
        # self.liveUltrasoundNode_Reference.SetAndObserveTransformNodeID(self.ReferenceToRas.GetID())

        # Hide slice view annotations (patient name, scale, color bar, etc.) as they
        # decrease reslicing performance by 20%-100%
        logging.debug("Hide slice view annotations")
        import DataProbe

        dataProbeUtil = DataProbe.DataProbeLib.DataProbeUtil()
        dataProbeParameterNode = dataProbeUtil.getParameterNode()
        dataProbeParameterNode.SetParameter("showSliceViewAnnotations", "0")
示例#28
0
    def setupScene(self):  #applet specific
        logging.debug('setupScene')
        Guidelet.setupScene(self)

        logging.debug('Create transforms')

        self.cauteryTipToCautery = slicer.util.getNode('CauteryTipToCautery')
        if not self.cauteryTipToCautery:
            self.cauteryTipToCautery = slicer.vtkMRMLLinearTransformNode()
            self.cauteryTipToCautery.SetName("CauteryTipToCautery")
            m = self.readTransformFromSettings('CauteryTipToCautery')
            if m:
                self.cauteryTipToCautery.SetMatrixTransformToParent(m)
            slicer.mrmlScene.AddNode(self.cauteryTipToCautery)

        self.cauteryModelToCauteryTip = slicer.util.getNode(
            'CauteryModelToCauteryTip')
        if not self.cauteryModelToCauteryTip:
            self.cauteryModelToCauteryTip = slicer.vtkMRMLLinearTransformNode()
            self.cauteryModelToCauteryTip.SetName("CauteryModelToCauteryTip")
            m = self.readTransformFromSettings('CauteryModelToCauteryTip')
            if m:
                self.cauteryModelToCauteryTip.SetMatrixTransformToParent(m)
            self.cauteryModelToCauteryTip.SetMatrixTransformToParent(m)
            slicer.mrmlScene.AddNode(self.cauteryModelToCauteryTip)

        self.needleTipToNeedle = slicer.util.getNode('NeedleTipToNeedle')
        if not self.needleTipToNeedle:
            self.needleTipToNeedle = slicer.vtkMRMLLinearTransformNode()
            self.needleTipToNeedle.SetName("NeedleTipToNeedle")
            m = self.readTransformFromSettings('NeedleTipToNeedle')
            if m:
                self.needleTipToNeedle.SetMatrixTransformToParent(m)
            slicer.mrmlScene.AddNode(self.needleTipToNeedle)

        self.needleModelToNeedleTip = slicer.util.getNode(
            'NeedleModelToNeedleTip')
        if not self.needleModelToNeedleTip:
            self.needleModelToNeedleTip = slicer.vtkMRMLLinearTransformNode()
            self.needleModelToNeedleTip.SetName("NeedleModelToNeedleTip")
            m = self.readTransformFromSettings('NeedleModelToNeedleTip')
            if m:
                self.needleModelToNeedleTip.SetMatrixTransformToParent(m)
            self.needleModelToNeedleTip.SetMatrixTransformToParent(m)
            slicer.mrmlScene.AddNode(self.needleModelToNeedleTip)

        self.cauteryCameraToCautery = slicer.util.getNode(
            'CauteryCameraToCautery')
        if not self.cauteryCameraToCautery:
            self.cauteryCameraToCautery = slicer.vtkMRMLLinearTransformNode()
            self.cauteryCameraToCautery.SetName("CauteryCameraToCautery")
            m = vtk.vtkMatrix4x4()
            m.SetElement(0, 0, 0)
            m.SetElement(0, 2, -1)
            m.SetElement(1, 1, 0)
            m.SetElement(1, 0, 1)
            m.SetElement(2, 2, 0)
            m.SetElement(2, 1, -1)
            self.cauteryCameraToCautery.SetMatrixTransformToParent(m)
            slicer.mrmlScene.AddNode(self.cauteryCameraToCautery)

        self.CauteryToNeedle = slicer.util.getNode('CauteryToNeedle')
        if not self.CauteryToNeedle:
            self.CauteryToNeedle = slicer.vtkMRMLLinearTransformNode()
            self.CauteryToNeedle.SetName("CauteryToNeedle")
            slicer.mrmlScene.AddNode(self.CauteryToNeedle)

        # Create transforms that will be updated through OpenIGTLink

        self.cauteryToReference = slicer.util.getNode('CauteryToReference')
        if not self.cauteryToReference:
            self.cauteryToReference = slicer.vtkMRMLLinearTransformNode()
            self.cauteryToReference.SetName("CauteryToReference")
            slicer.mrmlScene.AddNode(self.cauteryToReference)

        self.needleToReference = slicer.util.getNode('NeedleToReference')
        if not self.needleToReference:
            self.needleToReference = slicer.vtkMRMLLinearTransformNode()
            self.needleToReference.SetName("NeedleToReference")
            slicer.mrmlScene.AddNode(self.needleToReference)

        # Cameras
        logging.debug('Create cameras')

        self.LeftCamera = slicer.util.getNode('Left Camera')
        if not self.LeftCamera:
            self.LeftCamera = slicer.vtkMRMLCameraNode()
            self.LeftCamera.SetName("Left Camera")
            slicer.mrmlScene.AddNode(self.LeftCamera)

        self.RightCamera = slicer.util.getNode('Right Camera')
        if not self.RightCamera:
            self.RightCamera = slicer.vtkMRMLCameraNode()
            self.RightCamera.SetName("Right Camera")
            slicer.mrmlScene.AddNode(self.RightCamera)

        # Models
        logging.debug('Create models')

        self.cauteryModel_CauteryTip = slicer.util.getNode('CauteryModel')
        if not self.cauteryModel_CauteryTip:
            if (self.parameterNode.GetParameter('TestMode') == 'True'):
                moduleDirectoryPath = slicer.modules.lumpnav.path.replace(
                    'LumpNav.py', '')
                slicer.util.loadModel(
                    qt.QDir.toNativeSeparators(
                        moduleDirectoryPath +
                        '../../../models/temporary/cautery.stl'))
                self.cauteryModel_CauteryTip = slicer.util.getNode(
                    pattern="cautery")
            else:
                slicer.modules.createmodels.logic().CreateNeedle(
                    100, 1.0, 2.5, 0)
                self.cauteryModel_CauteryTip = slicer.util.getNode(
                    pattern="NeedleModel")
                self.cauteryModel_CauteryTip.GetDisplayNode().SetColor(
                    1.0, 1.0, 0)
            self.cauteryModel_CauteryTip.SetName("CauteryModel")

        self.needleModel_NeedleTip = slicer.util.getNode('NeedleModel')
        if not self.needleModel_NeedleTip:
            slicer.modules.createmodels.logic().CreateNeedle(80, 1.0, 2.5, 0)
            self.needleModel_NeedleTip = slicer.util.getNode(
                pattern="NeedleModel")
            self.needleModel_NeedleTip.GetDisplayNode().SetColor(
                0.333333, 1.0, 1.0)
            self.needleModel_NeedleTip.SetName("NeedleModel")
            self.needleModel_NeedleTip.GetDisplayNode(
            ).SliceIntersectionVisibilityOn()

        # Create surface from point set

        logging.debug('Create surface from point set')

        self.tumorModel_Needle = slicer.util.getNode('TumorModel')
        if not self.tumorModel_Needle:
            self.tumorModel_Needle = slicer.vtkMRMLModelNode()
            self.tumorModel_Needle.SetName("TumorModel")
            sphereSource = vtk.vtkSphereSource()
            sphereSource.SetRadius(0.001)
            self.tumorModel_Needle.SetPolyDataConnection(
                sphereSource.GetOutputPort())
            slicer.mrmlScene.AddNode(self.tumorModel_Needle)
            # Add display node
            modelDisplayNode = slicer.vtkMRMLModelDisplayNode()
            modelDisplayNode.SetColor(0, 1, 0)  # Green
            modelDisplayNode.BackfaceCullingOff()
            modelDisplayNode.SliceIntersectionVisibilityOn()
            modelDisplayNode.SetSliceIntersectionThickness(4)
            modelDisplayNode.SetOpacity(0.3)  # Between 0-1, 1 being opaque
            slicer.mrmlScene.AddNode(modelDisplayNode)
            self.tumorModel_Needle.SetAndObserveDisplayNodeID(
                modelDisplayNode.GetID())

        tumorMarkups_Needle = slicer.util.getNode('T')
        if not tumorMarkups_Needle:
            tumorMarkups_Needle = slicer.vtkMRMLMarkupsFiducialNode()
            tumorMarkups_Needle.SetName("T")
            slicer.mrmlScene.AddNode(tumorMarkups_Needle)
            tumorMarkups_Needle.CreateDefaultDisplayNodes()
            tumorMarkups_Needle.GetDisplayNode().SetTextScale(0)
        self.setAndObserveTumorMarkupsNode(tumorMarkups_Needle)

        # Set up breach warning node
        logging.debug('Set up breach warning')
        self.breachWarningNode = slicer.util.getNode('LumpNavBreachWarning')

        if not self.breachWarningNode:
            self.breachWarningNode = slicer.mrmlScene.CreateNodeByClass(
                'vtkMRMLBreachWarningNode')
            self.breachWarningNode.SetName("LumpNavBreachWarning")
            slicer.mrmlScene.AddNode(self.breachWarningNode)
            self.breachWarningNode.SetPlayWarningSound(True)
            self.breachWarningNode.SetWarningColor(1, 0, 0)
            self.breachWarningNode.SetOriginalColor(
                self.tumorModel_Needle.GetDisplayNode().GetColor())
            self.breachWarningNode.SetAndObserveToolTransformNodeId(
                self.cauteryTipToCautery.GetID())
            self.breachWarningNode.SetAndObserveWatchedModelNodeID(
                self.tumorModel_Needle.GetID())

        # Set up breach warning light
        import BreachWarningLight
        logging.debug('Set up breach warning light')
        self.breachWarningLightLogic = BreachWarningLight.BreachWarningLightLogic(
        )
        self.breachWarningLightLogic.setMarginSizeMm(
            float(
                self.parameterNode.GetParameter(
                    'BreachWarningLightMarginSizeMm')))
        if (self.parameterNode.GetParameter('EnableBreachWarningLight') ==
                'True'):
            logging.debug("BreachWarningLight: active")
            self.breachWarningLightLogic.startLightFeedback(
                self.breachWarningNode, self.connectorNode)
        else:
            logging.debug("BreachWarningLight: shutdown")
            self.breachWarningLightLogic.shutdownLight(self.connectorNode)

        # Build transform tree
        logging.debug('Set up transform tree')
        self.cauteryToReference.SetAndObserveTransformNodeID(
            self.ReferenceToRas.GetID())
        self.cauteryCameraToCautery.SetAndObserveTransformNodeID(
            self.cauteryToReference.GetID())
        self.cauteryTipToCautery.SetAndObserveTransformNodeID(
            self.cauteryToReference.GetID())
        self.cauteryModelToCauteryTip.SetAndObserveTransformNodeID(
            self.cauteryTipToCautery.GetID())
        self.needleToReference.SetAndObserveTransformNodeID(
            self.ReferenceToRas.GetID())
        self.needleTipToNeedle.SetAndObserveTransformNodeID(
            self.needleToReference.GetID())
        self.needleModelToNeedleTip.SetAndObserveTransformNodeID(
            self.needleTipToNeedle.GetID())
        self.cauteryModel_CauteryTip.SetAndObserveTransformNodeID(
            self.cauteryModelToCauteryTip.GetID())
        self.needleModel_NeedleTip.SetAndObserveTransformNodeID(
            self.needleModelToNeedleTip.GetID())
        self.tumorModel_Needle.SetAndObserveTransformNodeID(
            self.needleToReference.GetID())
        self.tumorMarkups_Needle.SetAndObserveTransformNodeID(
            self.needleToReference.GetID())
        # self.liveUltrasoundNode_Reference.SetAndObserveTransformNodeID(self.ReferenceToRas.GetID())

        # Hide slice view annotations (patient name, scale, color bar, etc.) as they
        # decrease reslicing performance by 20%-100%
        logging.debug('Hide slice view annotations')
        import DataProbe
        dataProbeUtil = DataProbe.DataProbeLib.DataProbeUtil()
        dataProbeParameterNode = dataProbeUtil.getParameterNode()
        dataProbeParameterNode.SetParameter('showSliceViewAnnotations', '0')
示例#29
0
  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
    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()))
    cursor.SetAndObservePolyData(sphere.GetOutput())

    # 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
    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
示例#30
0
  def test_ShadedModels1(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")

    import SampleData
    sampleDataLogic = SampleData.SampleDataLogic()
    print("Getting MR Head Volume")
    mrHeadVolume = sampleDataLogic.downloadMRHead()

    resize = vtk.vtkImageResize()
    resize.SetInputDataObject(mrHeadVolume.GetImageData())
    resize.SetOutputDimensions(256,256,128)
    resize.Update()


    tdw = slicer.qMRMLThreeDWidget()
    tdw.setMRMLScene(slicer.mrmlScene)
    tdw.setMRMLViewNode(slicer.util.getNode("*ViewNode*"))
    tdw.show()

    from vtkSlicerShadedActorModuleLogicPython import *

    shadedActor=vtkOpenGLShadedActor()
    tdv = tdw.threeDView()
    rw = tdv.renderWindow()
    rens = rw.GetRenderers()
    ren = rens.GetItemAsObject(0)
    ren.AddActor(shadedActor)
    mapper = vtk.vtkPolyDataMapper()
    shadedActor.SetMapper(mapper)
    shadedActor.SetVertexShaderSource("""
      #version 120
      attribute vec3 vertexAttribute;
      attribute vec2 textureCoordinateAttribute;
      varying vec4 interpolatedColor;
      varying vec3 interpolatedTextureCoordinate;
      void main()
      {
        interpolatedColor = vec4(0.5) + vec4(vertexAttribute, 1.);
        interpolatedTextureCoordinate = vec3(textureCoordinateAttribute, .5);
        gl_Position = vec4(vertexAttribute, 1.);
      }
    """)

    shadedActor.SetFragmentShaderSource("""
      #version 120
      varying vec4 interpolatedColor;
      varying vec3 interpolatedTextureCoordinate;
      uniform sampler3D volumeSampler;
      void main()
      {
        gl_FragColor = vec4 ( 1.0, 0.0, 0.0, 1.0 );
        gl_FragColor = interpolatedColor;
        vec4 volumeSample = texture3D(volumeSampler, interpolatedTextureCoordinate);
        volumeSample *= 100;
        gl_FragColor = mix( volumeSample, interpolatedColor, 0.5);
        
        vec4 integratedRay = vec4(0.);
        for (int i = 0; i < 256; i++) {
          vec3 samplePoint = vec3(interpolatedTextureCoordinate.st, i/256.);
          vec4 volumeSample = texture3D(volumeSampler, samplePoint);
          integratedRay += volumeSample;
        }
        gl_FragColor = integratedRay;
      }
    """)
    shadedActor.SetTextureImageData(resize.GetOutputDataObject(0))
    #shadedActor.SetTextureImageData(mrHeadVolume.GetImageData())
    sphereSource = vtk.vtkSphereSource()
    mapper.SetInputConnection(sphereSource.GetOutputPort())
    actor = vtk.vtkActor()
    actor.SetScale(20,20,20)
    actor.SetMapper(mapper)
    ren.AddActor(actor)
    rw.Render()

    wti = vtk.vtkWindowToImageFilter()
    wti.SetInput(rw)
    iv = vtk.vtkImageViewer()
    iv.SetColorLevel(128)
    iv.SetColorWindow(256)
    iv.SetInputConnection(wti.GetOutputPort())
    iv.Render()

    extensionManager = vtk.vtkOpenGLExtensionManager()
    extensionManager.SetRenderWindow(rw)
    extensionManager.Update()
    print(extensionManager) 
    print(extensionManager.GetDriverGLVendor()) 
    print(extensionManager.GetDriverGLVersion()) 
    print(extensionManager.GetDriverGLRenderer()) 

    slicer.modules.ShadedModelsWidget.tdw = tdw
    slicer.modules.ShadedModelsWidget.iv = iv
示例#31
0
文件: Locator.py 项目: tokjun/Locator
    def createNeedleModelNode(self, name):

        locatorModel = self.scene.CreateNodeByClass('vtkMRMLModelNode')

        # Cylinder represents the locator stick
        cylinder = vtk.vtkCylinderSource()
        cylinder.SetRadius(1.5)
        cylinder.SetHeight(100)
        cylinder.SetCenter(0, 0, 0)
        cylinder.Update()

        # Rotate cylinder
        tfilter = vtk.vtkTransformPolyDataFilter()
        trans = vtk.vtkTransform()
        trans.RotateX(90.0)
        trans.Translate(0.0, -50.0, 0.0)
        trans.Update()
        if vtk.VTK_MAJOR_VERSION <= 5:
            tfilter.SetInput(cylinder.GetOutput())
        else:
            tfilter.SetInputConnection(cylinder.GetOutputPort())
        tfilter.SetTransform(trans)
        tfilter.Update()

        # Sphere represents the locator tip
        sphere = vtk.vtkSphereSource()
        sphere.SetRadius(3.0)
        sphere.SetCenter(0, 0, 0)
        sphere.Update()

        apd = vtk.vtkAppendPolyData()

        if vtk.VTK_MAJOR_VERSION <= 5:
            apd.AddInput(sphere.GetOutput())
            apd.AddInput(tfilter.GetOutput())
        else:
            apd.AddInputConnection(sphere.GetOutputPort())
            apd.AddInputConnection(tfilter.GetOutputPort())
        apd.Update()

        locatorModel.SetAndObservePolyData(apd.GetOutput())

        self.scene.AddNode(locatorModel)
        locatorModel.SetScene(self.scene)
        locatorModel.SetName(name)

        locatorDisp = locatorModel.GetDisplayNodeID()
        if locatorDisp == None:
            locatorDisp = self.scene.CreateNodeByClass(
                'vtkMRMLModelDisplayNode')
            self.scene.AddNode(locatorDisp)
            locatorDisp.SetScene(self.scene)
            locatorModel.SetAndObserveDisplayNodeID(locatorDisp.GetID())

        color = [0, 0, 0]
        color[0] = 0.5
        color[1] = 0.5
        color[2] = 1.0
        locatorDisp.SetColor(color)

        return locatorModel.GetID()
  def __init__(self, entryPointFiducialListNode, targetFiducialListNode, shape, shapeRadius, shapeHeight, shapeVolume, ablationZoneColor):
    
    entryPointFid = entryPointFiducialListNode
    targetFid = targetFiducialListNode
    
    scene = slicer.mrmlScene
    
    
    if (shape == 'sphere'):
      source = vtk.vtkSphereSource()
      source.SetRadius(shapeRadius)
      source.Update()
    elif (shape == 'cylinder'):
      source = vtk.vtkCylinderSource()
      source.SetRadius(shapeRadius)
      source.SetHeight(shapeHeight)
      source.Update()
    elif (shape == 'ellipsoid'):
      source = vtk.vtkSphereSource()
      source.SetRadius(shapeRadius)
      source.Update()
    else:
      source = vtk.vtkSphereSource()
      source.SetRadius(shapeRadius)
      source.Update()
    
    
    # get coordinates from current entry point fiducial
    currentEntryPointFiducialCoordinatesRAS = [0, 0, 0]
    
    entryPointFid.GetFiducialCoordinates(currentEntryPointFiducialCoordinatesRAS)
    
    currentTargetFiducialCoordinatesRAS = [0, 0, 0]
    
    targetFid.GetFiducialCoordinates(currentTargetFiducialCoordinatesRAS)
    
    translationTarget = [currentTargetFiducialCoordinatesRAS[0], currentTargetFiducialCoordinatesRAS[1], currentTargetFiducialCoordinatesRAS[2]]

    # Generate a random start and end point
    random.seed(8775070)
    startPoint = [0 for i in range(3)]
    startPoint[0] = currentEntryPointFiducialCoordinatesRAS[0]
    startPoint[1] = currentEntryPointFiducialCoordinatesRAS[1]
    startPoint[2] = currentEntryPointFiducialCoordinatesRAS[2]
    endPoint = [0 for i in range(3)]
    endPoint[0] = currentTargetFiducialCoordinatesRAS[0]
    endPoint[1] = currentTargetFiducialCoordinatesRAS[1]
    endPoint[2] = currentTargetFiducialCoordinatesRAS[2]
     
    # Compute a basis
    normalizedX = [0 for i in range(3)]
    normalizedY = [0 for i in range(3)]
    normalizedZ = [0 for i in range(3)]
     
    # The X axis is a vector from start to end
    math = vtk.vtkMath()
    math.Subtract(endPoint, startPoint, normalizedX)
    # length = math.Norm(normalizedX)
    math.Normalize(normalizedX)
    
    # The Z axis is an arbitrary vector cross X
    arbitrary = [0 for i in range(3)]
    arbitrary[0] = random.uniform(-10,10)
    arbitrary[1] = random.uniform(-10,10)
    arbitrary[2] = random.uniform(-10,10)
    math.Cross(normalizedX, arbitrary, normalizedZ)
    math.Normalize(normalizedZ)
    
    # The Y axis is Z cross X
    math.Cross(normalizedZ, normalizedX, normalizedY)
    matrix = vtk.vtkMatrix4x4()
     
    # Create the direction cosine matrix
    matrix.Identity()
    for i in range(3):
      matrix.SetElement(i, 0, normalizedX[i])
      matrix.SetElement(i, 1, normalizedY[i])
      matrix.SetElement(i, 2, normalizedZ[i])
      matrix.SetElement(i, 3, currentTargetFiducialCoordinatesRAS[i])
      
    # Apply the transforms
    transform = vtk.vtkTransform()
    transform.Concatenate(matrix)
    transform.RotateZ(90)
    
    '''
    ps = vtk.vtkProgrammableSource()
    
    import math 
    numPts = 80
    polyLinePoints = vtk.vtkPoints() 
    polyLinePoints.SetNumberOfPoints(numPts) 
    R=1.0 
    for i in range(0,numPts):
      x = R*math.cos(i*2*math.pi/numPts) 
      y = R*math.sin(i*2*math.pi/numPts) 
      polyLinePoints.InsertPoint(i, x, y, 0)
    aPolyLine1 = vtk.vtkPolyLine() 
    aPolyLine1.GetPointIds().SetNumberOfIds(numPts+1) 
    for i in range(0,numPts):
      aPolyLine1.GetPointIds().SetId(i,i) 
    # add one more cell at the end to close the circle on itself 
    aPolyLine1.GetPointIds().SetId(numPts, 0)
    aPolyLineGrid = ps.GetOutput()
    aPolyLineGrid.Allocate(1,1)
    aPolyLineGrid.InsertNextCell(aPolyLine1.GetCellType(), aPolyLine1.GetPointIds())
    aPolyLineGrid.SetPoints(polyLinePoints)
    '''
    
    '''
    #This script generates a helix double.
    #This is intended as the script of a 'Programmable Source'
    import math
     
    ps = vtk.vtkSphereSource()
    
    
    numPts = 80 # Points along each Helix
    length = 8 # Length of each Helix
    rounds = 3 # Number of times around
    phase_shift = math.pi/1.5 # Phase shift between Helixes
     
    #Get a vtk.PolyData object for the output
    pdo = ps.GetOutput()
    print "before"
    print pdo
    
    #This will store the points for the Helix
    newPts = vtk.vtkPoints()
    for i in range(0, numPts):
       #Generate Points for first Helix
       x = i*length/numPts
       y = math.sin(i*rounds*2*math.pi/numPts)
       z = math.cos(i*rounds*2*math.pi/numPts)
       newPts.InsertPoint(i, x,y,z)
     
       #Generate Points for second Helix. Add a phase offset to y and z.
       y = math.sin(i*rounds*2*math.pi/numPts+phase_shift)
       z = math.cos(i*rounds*2*math.pi/numPts+phase_shift)
       #Offset Helix 2 pts by 'numPts' to keep separate from Helix 1 Pts
       newPts.InsertPoint(i+numPts, x,y,z)
     
    #Add the points to the vtkPolyData object
    pdo.SetPoints(newPts)
     
    #Make two vtkPolyLine objects to hold curve construction data
    aPolyLine1 = vtk.vtkPolyLine()
    aPolyLine2 = vtk.vtkPolyLine()
     
    #Indicate the number of points along the line
    aPolyLine1.GetPointIds().SetNumberOfIds(numPts)
    aPolyLine2.GetPointIds().SetNumberOfIds(numPts)
    for i in range(0,numPts):
       #First Helix - use the first set of points
       aPolyLine1.GetPointIds().SetId(i, i)
       #Second Helix - use the second set of points
       #(Offset the point reference by 'numPts').
       aPolyLine2.GetPointIds().SetId(i,i+numPts)
     
    #Allocate the number of 'cells' that will be added. 
    #Two 'cells' for the Helix curves, and one 'cell'
    #for every 3rd point along the Helixes.
    links = range(0,numPts,3)
    pdo.Allocate(2+len(links), 1)
     
    #Add the poly line 'cell' to the vtkPolyData object.
    pdo.InsertNextCell(aPolyLine1.GetCellType(), aPolyLine1.GetPointIds())
    pdo.InsertNextCell(aPolyLine2.GetCellType(), aPolyLine2.GetPointIds())
     
    for i in links:
       #Add a line connecting the two Helixes.
       aLine = vtk.vtkLine()
       aLine.GetPointIds().SetId(0, i)
       aLine.GetPointIds().SetId(1, i+numPts)
       pdo.InsertNextCell(aLine.GetCellType(), aLine.GetPointIds())
       
    print "after"
    print pdo
    '''    
    # Create model node
    lesionModel = slicer.vtkMRMLModelNode()
    lesionModel.SetScene(scene)
    lesionModel.SetName("Ablationzone-%s" % targetFid.GetName())
    lesionModel.SetAndObservePolyData(source.GetOutput())
    self.lesionModel = lesionModel
    # Create display node
    lesionModelDisplay = slicer.vtkMRMLModelDisplayNode()
    lesionModelDisplay.SetColor(ablationZoneColor)
    lesionModelDisplay.SetOpacity(0.4)
    lesionModelDisplay.SliceIntersectionVisibilityOn()
    
    lesionModelDisplay.SetScene(scene)
    scene.AddNode(lesionModelDisplay)
    lesionModel.SetAndObserveDisplayNodeID(lesionModelDisplay.GetID())

    
    # Add to scene
    lesionModelDisplay.SetPolyData(source.GetOutput())
    self.lesionModelDisplay = lesionModelDisplay
    self.lesionModel= lesionModel
    
    scene.AddNode(lesionModel)
    
    # Create ablationZoneTransform node
    ablationZoneTransform = slicer.vtkMRMLLinearTransformNode()
    ablationZoneTransform.SetName('AblationZoneTransform-%s' % targetFid.GetName())
    
    scene.AddNode(ablationZoneTransform)
    
    ablationZoneTransform.ApplyTransformMatrix(transform.GetMatrix())
    
    lesionModel.SetAndObserveTransformNodeID(ablationZoneTransform.GetID())
    
    self.ablationZoneTransform = ablationZoneTransform
示例#33
0
    def test_ShadedModels1(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")

        import SampleData
        sampleDataLogic = SampleData.SampleDataLogic()
        print("Getting MR Head Volume")
        mrHeadVolume = sampleDataLogic.downloadMRHead()

        resize = vtk.vtkImageResize()
        resize.SetInputDataObject(mrHeadVolume.GetImageData())
        resize.SetOutputDimensions(256, 256, 128)
        resize.Update()

        tdw = slicer.qMRMLThreeDWidget()
        tdw.setMRMLScene(slicer.mrmlScene)
        tdw.setMRMLViewNode(slicer.util.getNode("*ViewNode*"))
        tdw.show()

        from vtkSlicerShadedActorModuleLogicPython import *

        shadedActor = vtkOpenGLShadedActor()
        tdv = tdw.threeDView()
        rw = tdv.renderWindow()
        rens = rw.GetRenderers()
        ren = rens.GetItemAsObject(0)
        ren.AddActor(shadedActor)
        mapper = vtk.vtkPolyDataMapper()
        shadedActor.SetMapper(mapper)
        shadedActor.SetVertexShaderSource("""
      #version 120
      attribute vec3 vertexAttribute;
      attribute vec2 textureCoordinateAttribute;
      varying vec4 interpolatedColor;
      varying vec3 interpolatedTextureCoordinate;
      void main()
      {
        interpolatedColor = vec4(0.5) + vec4(vertexAttribute, 1.);
        interpolatedTextureCoordinate = vec3(textureCoordinateAttribute, .5);
        gl_Position = vec4(vertexAttribute, 1.);
      }
    """)

        shadedActor.SetFragmentShaderSource("""
      #version 120
      varying vec4 interpolatedColor;
      varying vec3 interpolatedTextureCoordinate;
      uniform sampler3D volumeSampler;
      void main()
      {
        gl_FragColor = vec4 ( 1.0, 0.0, 0.0, 1.0 );
        gl_FragColor = interpolatedColor;
        vec4 volumeSample = texture3D(volumeSampler, interpolatedTextureCoordinate);
        volumeSample *= 100;
        gl_FragColor = mix( volumeSample, interpolatedColor, 0.5);
        
        vec4 integratedRay = vec4(0.);
        for (int i = 0; i < 256; i++) {
          vec3 samplePoint = vec3(interpolatedTextureCoordinate.st, i/256.);
          vec4 volumeSample = texture3D(volumeSampler, samplePoint);
          integratedRay += volumeSample;
        }
        gl_FragColor = integratedRay;
      }
    """)
        shadedActor.SetTextureImageData(resize.GetOutputDataObject(0))
        #shadedActor.SetTextureImageData(mrHeadVolume.GetImageData())
        sphereSource = vtk.vtkSphereSource()
        mapper.SetInputConnection(sphereSource.GetOutputPort())
        actor = vtk.vtkActor()
        actor.SetScale(20, 20, 20)
        actor.SetMapper(mapper)
        ren.AddActor(actor)
        rw.Render()

        wti = vtk.vtkWindowToImageFilter()
        wti.SetInput(rw)
        iv = vtk.vtkImageViewer()
        iv.SetColorLevel(128)
        iv.SetColorWindow(256)
        iv.SetInputConnection(wti.GetOutputPort())
        iv.Render()

        extensionManager = vtk.vtkOpenGLExtensionManager()
        extensionManager.SetRenderWindow(rw)
        extensionManager.Update()
        print(extensionManager)
        print(extensionManager.GetDriverGLVendor())
        print(extensionManager.GetDriverGLVersion())
        print(extensionManager.GetDriverGLRenderer())

        slicer.modules.ShadedModelsWidget.tdw = tdw
        slicer.modules.ShadedModelsWidget.iv = iv