def IntersectBaseModel(self):
        transform = vtk.vtkTransform()
        matrix = vtk.vtkMatrix4x4()
        self.transformSelector.currentNode().GetMatrixTransformToParent(matrix)
        transform.SetMatrix(matrix)
        #transform.RotateX(-90.0)

        # cylinder = vtk.vtkCylinderSource()
        # cylinder.SetCenter(np.array([0.0, 0.0, 0.0]))
        # cylinder.SetRadius(25)
        # cylinder.SetHeight(60)
        # cylinder.SetResolution(100)
        # cylinder.Update()

        originalCylinder_path = os.path.dirname(
            os.path.realpath(__file__)) + "\\Models\\OriginalCylinder.stl"
        originalCylinderModelNode = slicer.util.loadModel(
            originalCylinder_path)

        transformFilter = vtk.vtkTransformPolyDataFilter()
        transformFilter.SetInputData(originalCylinderModelNode.GetPolyData())
        transformFilter.SetTransform(transform)
        transformFilter.ReleaseDataFlagOn()
        transformFilter.Update()

        modelNode = self.booleanModelSelector.currentNode()
        modelNode.SetAndObservePolyData(transformFilter.GetOutput())
        modelDisplayNode = modelNode.GetModelDisplayNode()
        if modelDisplayNode is None:
            modelDisplayNode = slicer.vtkMRMLModelDisplayNode()
            modelDisplayNode.SetScene(slicer.mrmlScene)
            slicer.mrmlScene.AddNode(modelDisplayNode)
            modelNode.SetAndObserveDisplayNodeID(modelDisplayNode.GetID())
        modelDisplayNode.SetOpacity(0.2)
        modelDisplayNode.SetColor(0, 1, 0)

        modelNode2 = self.transientModelSelector.currentNode()
        modelDisplayNode2 = self.transientModelSelector.currentNode(
        ).GetModelDisplayNode()
        if modelDisplayNode2 is None:
            modelDisplayNode2 = slicer.vtkMRMLModelDisplayNode()
            modelDisplayNode2.SetScene(slicer.mrmlScene)
            slicer.mrmlScene.AddNode(modelDisplayNode2)
            modelNode2.SetAndObserveDisplayNodeID(modelDisplayNode2.GetID())
        modelDisplayNode2.SetOpacity(1.0)
        modelDisplayNode2.SetColor(0, 1, 0)

        cylinder_path = os.path.dirname(
            os.path.realpath(__file__)) + "\\Models\\cylinder.stl"
        slicer.util.saveNode(modelNode, cylinder_path)

        slicer.mrmlScene.RemoveNode(originalCylinderModelNode)

        self.blenderBoolean()
    def updateCurve(self):
        if self.SourceNode and self.DestinationNode:
            if self.SourceNode.GetNumberOfFiducials() < 2:
                if self.CurvePoly != None:
                    self.CurvePoly.Initialize()
            else:
                if self.CurvePoly == None:
                    self.CurvePoly = vtk.vtkPolyData()
                if self.DestinationNode.GetDisplayNodeID() == None:
                    modelDisplayNode = slicer.vtkMRMLModelDisplayNode()
                    modelDisplayNode.SetColor(self.CurveColour)
                    slicer.mrmlScene.AddNode(modelDisplayNode)
                    self.DestinationNode.SetAndObserveDisplayNodeID(
                        modelDisplayNode.GetID())
                if self.InterpolationMethod == 0:
                    self.nodesToLinear(self.SourceNode, self.CurvePoly)
                elif self.InterpolationMethod == 1:
                    self.nodesToSpline(self.SourceNode, self.CurvePoly)

            tubeFilter = vtk.vtkTubeFilter()
            tubeFilter.SetInputData(self.CurvePoly)
            tubeFilter.SetRadius(self.CurveThickness)
            tubeFilter.SetNumberOfSides(self.CurveFaces)
            tubeFilter.CappingOn()
            tubeFilter.Update()

            self.DestinationNode.SetAndObservePolyData(tubeFilter.GetOutput())
            self.DestinationNode.Modified()

            if self.DestinationNode.GetScene() == None:
                slicer.mrmlScene.AddNode(self.DestinationNode)

            displayNode = self.DestinationNode.GetDisplayNode()
            if displayNode:
                displayNode.SetActiveScalarName('')
Beispiel #3
0
    def planeModel(self, scene, normal, origin, name, color):
        """ Create a plane model node which can be viewed in the 3D View """
        
        #A plane source
        plane = vtk.vtkPlane()
        plane.SetOrigin(origin)
        plane.SetNormal(normal)
        
        planeSample = vtk.vtkSampleFunction()
        planeSample.SetImplicitFunction(plane)
        planeSample.SetModelBounds(-100,100,-100,100,-100,100)
        planeSample.SetSampleDimensions(100,100,100)
        planeSample.ComputeNormalsOff()
        planeContour = vtk.vtkContourFilter()
        planeContour.SetInput(planeSample.GetOutput())
        
        # Create plane model node
        planeNode = slicer.vtkMRMLModelNode()
        planeNode.SetScene(scene)
        planeNode.SetName(name)
        planeNode.SetAndObservePolyData(planeContour.GetOutput())
        
        # Create plane display model node
        planeModelDisplay = slicer.vtkMRMLModelDisplayNode()
        planeModelDisplay.SetColor(color)
        planeModelDisplay.SetBackfaceCulling(0)
        planeModelDisplay.SetScene(scene)
        scene.AddNode(planeModelDisplay)
        planeNode.SetAndObserveDisplayNodeID(planeModelDisplay.GetID())

        #Add to scene
        planeModelDisplay.SetInputPolyData(planeContour.GetOutput())
        scene.AddNode(planeNode)
        return plane
Beispiel #4
0
 def setupMRMLTracking(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 generate3DVisualisationNode(self,
                                    polydata,
                                    name,
                                    color=(1, 1, 1),
                                    initial_pos_x=0):
        #create Model Node
        shape_node = slicer.vtkMRMLModelNode()
        shape_node.SetAndObservePolyData(polydata)
        shape_node.SetName(name)

        #create display node
        model_display = slicer.vtkMRMLModelDisplayNode()
        model_display.SetColor(color[0], color[1], color[2])
        model_display.AutoScalarRangeOff()
        model_display.SetScene(slicer.mrmlScene)
        model_display.SetName("Display " + name)

        #create transform node
        transform = vtk.vtkTransform()
        transform.Translate(initial_pos_x, 0, 0)
        transform_node = slicer.vtkMRMLTransformNode()
        transform_node.SetName("Translation " + name)
        transform_node.SetAndObserveTransformToParent(transform)

        #Add Nodes to Slicer
        slicer.mrmlScene.AddNode(transform_node)
        slicer.mrmlScene.AddNode(model_display)
        slicer.mrmlScene.AddNode(shape_node)

        #Link nodes
        shape_node.SetAndObserveTransformNodeID(transform_node.GetID())
        shape_node.SetAndObserveDisplayNodeID(model_display.GetID())
Beispiel #6
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
    def DepthMapToPointCloud(self, depthmapFilename, rgbFilename):
        # Create point cloud
        depthImage = imageio.imread(depthmapFilename)
        rgbImage = imageio.imread(rgbFilename)

        height = len(depthImage)
        width = len(depthImage[0])

        minimumDepth = np.amin(depthImage)
        maximumDepth = np.amax(depthImage)
        print(maximumDepth)

        points = vtk.vtkPoints()

        fx_d = self.focalLengthBox.value
        fy_d = self.focalLengthBox.value

        for u in range(height):
            for v in range(width):
                vflipped = width - (v + 1)
                z = depthImage[u][vflipped]
                z = z[0] / self.depthDividerBox.value

                if z < 60:
                    #if True:
                    points.InsertNextPoint(
                        np.array([
                            z * (u - (height / 2)) / fx_d,
                            z * (v - (width / 2)) / fy_d, z
                        ]))

        # Create junk polygons so that Slicer can actually display the point cloud
        polydata = vtk.vtkPolyData()
        polydata.SetPoints(points)
        poly = vtk.vtkPolygon()
        poly.GetPointIds().SetNumberOfIds(points.GetNumberOfPoints())
        for n in range(points.GetNumberOfPoints()):
            poly.GetPointIds().SetId(n, n)
        polys = vtk.vtkCellArray()
        polys.InsertNextCell(poly)
        polydata.SetPolys(polys)

        # Display the point cloud
        modelNode = self.pointCloudSelector.currentNode()
        modelNode.SetAndObservePolyData(polydata)
        modelDisplayNode = modelNode.GetModelDisplayNode()
        if modelDisplayNode is None:
            modelDisplayNode = slicer.vtkMRMLModelDisplayNode()
            modelDisplayNode.SetScene(slicer.mrmlScene)
            slicer.mrmlScene.AddNode(modelDisplayNode)
            modelNode.SetAndObserveDisplayNodeID(modelDisplayNode.GetID())
        modelDisplayNode.SetRepresentation(
            modelDisplayNode.PointsRepresentation)
        modelDisplayNode.SetPointSize(4)
        modelDisplayNode.SetOpacity(0.2)
        modelDisplayNode.SetColor(1, 0, 0)

        return modelNode
  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
Beispiel #9
0
 def initializeModelNode(node):
   displayNode = slicer.vtkMRMLModelDisplayNode()
   storageNode = slicer.vtkMRMLModelStorageNode()
   displayNode.SetScene(slicer.mrmlScene)
   storageNode.SetScene(slicer.mrmlScene)
   slicer.mrmlScene.AddNode(displayNode)
   slicer.mrmlScene.AddNode(storageNode)
   node.SetAndObserveDisplayNodeID(displayNode.GetID())
   node.SetAndObserveStorageNodeID(storageNode.GetID())
    def blenderBoolean(self):
        bpy.ops.wm.read_factory_settings()

        for scene in bpy.data.scenes:
            for obj in scene.objects:
                scene.objects.unlink(obj)

        # only worry about data in the startup scene
        for bpy_data_iter in (bpy.data.objects, bpy.data.meshes,
                              bpy.data.lamps, bpy.data.cameras):
            for id_data in bpy_data_iter:
                bpy_data_iter.remove(id_data)

        dir_path = os.path.dirname(os.path.realpath(__file__)) + "\\Models\\"
        #dir_path = "D:\\w\\s\\DepthNetworkTracking\\Model\\"
        airwayPath = dir_path + "airwayNoWall.stl"
        cylinderPath = dir_path + "cylinder.stl"

        bpy.ops.import_mesh.stl(filepath=airwayPath)
        bpy.ops.import_mesh.stl(filepath=cylinderPath)

        objects = bpy.data.objects
        airwayNoWall = objects['airwayNoWall']
        cylinder = objects['Cylinder']

        airwayBoolean = airwayNoWall.modifiers.new(type="BOOLEAN",
                                                   name="bool_7")
        airwayBoolean.object = cylinder
        airwayBoolean.operation = 'INTERSECT'
        cylinder.hide = True
        bpy.context.scene.objects.active = bpy.data.objects['airwayNoWall']
        bpy.ops.object.modifier_apply(apply_as='DATA',
                                      modifier=airwayBoolean.name)

        airwayNoWall.select = False
        cylinder.select = True
        bpy.ops.object.delete()
        airwayNoWall.select = True
        airwayIsolatedPath = dir_path + "airwayIsolated.stl"
        bpy.ops.export_mesh.stl(filepath=airwayIsolatedPath)

        outputModelPath = dir_path + "airwayIsolated.STL"
        outputModelNode = slicer.util.loadModel(outputModelPath)

        modelNode2 = self.transientModelSelector.currentNode()
        modelDisplayNode2 = self.transientModelSelector.currentNode(
        ).GetModelDisplayNode()
        if modelDisplayNode2 is None:
            modelDisplayNode2 = slicer.vtkMRMLModelDisplayNode()
            modelDisplayNode2.SetScene(slicer.mrmlScene)
            slicer.mrmlScene.AddNode(modelDisplayNode2)
            modelNode2.SetAndObserveDisplayNodeID(modelDisplayNode2.GetID())
        modelDisplayNode2.SetOpacity(0.7)
        modelDisplayNode2.SetColor(0, 1, 0)

        modelNode2.SetAndObservePolyData(outputModelNode.GetPolyData())
        slicer.mrmlScene.RemoveNode(outputModelNode)
 def initializeModelNode(node):
     displayNode = slicer.vtkMRMLModelDisplayNode()
     storageNode = slicer.vtkMRMLModelStorageNode()
     displayNode.SetScene(slicer.mrmlScene)
     storageNode.SetScene(slicer.mrmlScene)
     slicer.mrmlScene.AddNode(displayNode)
     slicer.mrmlScene.AddNode(storageNode)
     node.SetAndObserveDisplayNodeID(displayNode.GetID())
     node.SetAndObserveStorageNodeID(storageNode.GetID())
  def updateModel(self):

    if self.AutomaticUpdate == False:
      return

    if not self.ModelNode:
      return

    if self.ModelNode.GetDisplayNodeID() == None:
      modelDisplayNode = slicer.vtkMRMLModelDisplayNode()
      modelDisplayNode.SetColor(self.ModelColor)
      slicer.mrmlScene.AddNode(modelDisplayNode)
      self.ModelNode.SetAndObserveDisplayNodeID(modelDisplayNode.GetID())
        
    displayNodeID = self.ModelNode.GetDisplayNodeID()
    modelDisplayNode = slicer.mrmlScene.GetNodeByID(displayNodeID)

    if modelDisplayNode:
      if self.SliceIntersection == True:
        modelDisplayNode.SliceIntersectionVisibilityOn()
      else:
        modelDisplayNode.SliceIntersectionVisibilityOff()

      modelDisplayNode.SetOpacity(0.5)
      
    if self.CylinderSource == None:  
      self.CylinderSource = vtk.vtkCylinderSource()
      self.CylinderSource.SetResolution(60)

    self.CylinderSource.SetRadius(self.Diameter/2.0)
    self.CylinderSource.SetHeight(self.Length)
    self.CylinderSource.SetCenter(self.Offset)
    self.CylinderSource.Update()

    ## Scale sphere to make ellipsoid
    #scale = vtk.vtkTransform()
    #scale.Scale(self.MinorAxis, self.MinorAxis, self.MajorAxis)
    #scaleFilter = vtk.vtkTransformPolyDataFilter()
    #scaleFilter.SetInputConnection(self.CylinderSource.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.SetInputConnection(self.CylinderSource.GetOutputPort())
    #transformFilter.SetTransform(transform)
    #transformFilter.Update();
    
    #self.ModelNode.SetAndObservePolyData(transformFilter.GetOutput())
    self.ModelNode.SetAndObservePolyData(self.CylinderSource.GetOutput())
    self.ModelNode.Modified()
    
    if self.ModelNode.GetScene() == None:
      slicer.mrmlScene.AddNode(self.ModelNode)
Beispiel #13
0
def ExtractMesh(outputModelNode, modelNode, colorRgb, colorTolerance):

    fullPolyData = modelNode.GetPolyData()
    pointData = fullPolyData.GetPointData()

    redValues = pointData.GetArray('ColorRed')
    greenValues = pointData.GetArray('ColorGreen')
    blueValues = pointData.GetArray('ColorBlue')

    redMaxTolerance = colorRgb[0] + colorTolerance
    redMinTolerance = colorRgb[0] - colorTolerance
    greenMaxTolerance = colorRgb[1] + colorTolerance
    greenMinTolerance = colorRgb[1] - colorTolerance
    blueMaxTolerance = colorRgb[2] + colorTolerance
    blueMinTolerance = colorRgb[2] - colorTolerance

    lengthTuples = int(redValues.GetNumberOfTuples())
    selectedPointIds = vtk.vtkIdTypeArray()

    for pointId in range(lengthTuples):
        if redValues.GetValue(
                pointId) >= redMinTolerance and redValues.GetValue(
                    pointId) <= redMaxTolerance and greenValues.GetValue(
                        pointId) >= greenMinTolerance and greenValues.GetValue(
                            pointId
                        ) <= greenMaxTolerance and blueValues.GetValue(
                            pointId
                        ) >= blueMinTolerance and blueValues.GetValue(
                            pointId) <= blueMaxTolerance:
            selectedPointIds.InsertNextValue(pointId)
            selectedPointIds.InsertNextValue(pointId)

    selectionNode = vtk.vtkSelectionNode()
    selectionNode.SetFieldType(vtk.vtkSelectionNode.POINT)
    selectionNode.SetContentType(vtk.vtkSelectionNode.INDICES)
    selectionNode.SetSelectionList(selectedPointIds)
    selectionNode.GetProperties().Set(vtk.vtkSelectionNode.CONTAINING_CELLS(),
                                      1)

    selection = vtk.vtkSelection()
    selection.AddNode(selectionNode)

    extractSelection = vtk.vtkExtractSelection()
    extractSelection.SetInputData(0, fullPolyData)
    extractSelection.SetInputData(1, selection)
    extractSelection.Update()

    convertToPolydata = vtk.vtkDataSetSurfaceFilter()
    convertToPolydata.SetInputConnection(extractSelection.GetOutputPort())
    convertToPolydata.Update()
    outputModelNode.SetAndObservePolyData(convertToPolydata.GetOutput())

    if not outputModelNode.GetDisplayNode():
        md2 = slicer.vtkMRMLModelDisplayNode()
        slicer.mrmlScene.AddNode(md2)
        outputModelNode.SetAndObserveDisplayNodeID(md2.GetID())
  def loadModels(self, skullModel, skullMarkersModel, pointerModel):
    self.skullModel=skullModel
    self.skullMarkersModel=skullMarkersModel
    self.pointerModel=pointerModel

    self.skull.SetName("SkullModel")
    self.skull.SetAndObservePolyData(self.skullModel.GetPolyData())     
    slicer.mrmlScene.AddNode(self.skull)
    # Add display node
    modelDisplayNode = slicer.vtkMRMLModelDisplayNode()
    modelDisplayNode.SetColor(1,1,1) # White
    modelDisplayNode.BackfaceCullingOff()
    modelDisplayNode.SliceIntersectionVisibilityOn()
    modelDisplayNode.SetSliceIntersectionThickness(4)
    modelDisplayNode.SetOpacity(1) # Between 0-1, 1 being opaque
    slicer.mrmlScene.AddNode(modelDisplayNode)
    self.skull.SetAndObserveDisplayNodeID(modelDisplayNode.GetID())
    
    self.skullMarkers.SetName("SkullMarkersModel")
    self.skullMarkers.SetAndObservePolyData(self.skullMarkersModel.GetPolyData())     
    slicer.mrmlScene.AddNode(self.skullMarkers)
    # Add display node
    modelDisplayNode = slicer.vtkMRMLModelDisplayNode()
    modelDisplayNode.SetColor(1,0,0) # White
    modelDisplayNode.BackfaceCullingOff()
    modelDisplayNode.SliceIntersectionVisibilityOn()
    modelDisplayNode.SetSliceIntersectionThickness(4)
    modelDisplayNode.SetOpacity(1) # Between 0-1, 1 being opaque
    slicer.mrmlScene.AddNode(modelDisplayNode)
    self.skullMarkers.SetAndObserveDisplayNodeID(modelDisplayNode.GetID())

    self.pointer.SetName("PointerModel")
    self.pointer.SetAndObservePolyData(self.pointerModel.GetPolyData())     
    slicer.mrmlScene.AddNode(self.pointer)
    # Add display node
    modelDisplayNode = slicer.vtkMRMLModelDisplayNode()
    modelDisplayNode.SetColor(0,0,0) # White
    modelDisplayNode.BackfaceCullingOff()
    modelDisplayNode.SliceIntersectionVisibilityOn()
    modelDisplayNode.SetSliceIntersectionThickness(4)
    modelDisplayNode.SetOpacity(1) # Between 0-1, 1 being opaque
    slicer.mrmlScene.AddNode(modelDisplayNode)
    self.pointer.SetAndObserveDisplayNodeID(modelDisplayNode.GetID())
 def DisplayPolyData(self, nameOfNode, polyData, overwrite=True):
   """ Function that Overwrites/Creates a Node to display Polydata
   """
   n=self.CreateNewNode(nameOfNode, "vtkMRMLModelNode", overwrite=True)
   outputMouldModelDisplayNode = slicer.vtkMRMLModelDisplayNode()
   slicer.mrmlScene.AddNode(outputMouldModelDisplayNode)
   outputMouldModelDisplayNode.BackfaceCullingOff()
   n.SetAndObserveDisplayNodeID(outputMouldModelDisplayNode.GetID())
   n.SetAndObservePolyData(polyData)
   return outputMouldModelDisplayNode
Beispiel #16
0
 def DisplayPolyData(self, nameOfNode, polyData, overwrite=True):
     """ Function that Overwrites/Creates a Node to display Polydata
 """
     n = self.CreateNewNode(nameOfNode, "vtkMRMLModelNode", overwrite=True)
     outputMouldModelDisplayNode = slicer.vtkMRMLModelDisplayNode()
     slicer.mrmlScene.AddNode(outputMouldModelDisplayNode)
     outputMouldModelDisplayNode.BackfaceCullingOff()
     n.SetAndObserveDisplayNodeID(outputMouldModelDisplayNode.GetID())
     n.SetAndObservePolyData(polyData)
     return outputMouldModelDisplayNode
  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
Beispiel #19
0
 def createModelNode(self, name, color):
     scene = slicer.mrmlScene
     modelNode = slicer.vtkMRMLModelNode()
     modelNode.SetScene(scene)
     modelNode.SetName(name)
     modelDisplay = slicer.vtkMRMLModelDisplayNode()
     modelDisplay.SetColor(color)
     modelDisplay.SetScene(scene)
     scene.AddNode(modelDisplay)
     modelNode.SetAndObserveDisplayNodeID(modelDisplay.GetID())
     scene.AddNode(modelNode)
     return modelNode
 def createModelNode(self, name, color):
   scene = slicer.mrmlScene
   modelNode = slicer.vtkMRMLModelNode()
   modelNode.SetScene(scene)
   modelNode.SetName(name)
   modelDisplay = slicer.vtkMRMLModelDisplayNode()
   modelDisplay.SetColor(color)
   modelDisplay.SetScene(scene)
   scene.AddNode(modelDisplay)
   modelNode.SetAndObserveDisplayNodeID(modelDisplay.GetID())
   scene.AddNode(modelNode)  
   return modelNode
Beispiel #21
0
 def addModelToScene(self, polyData, name):
   scene = slicer.mrmlScene
   node = slicer.vtkMRMLModelNode()
   node.SetScene(scene)
   node.SetName(name)
   node.SetAndObservePolyData(polyData)
   modelDisplay = slicer.vtkMRMLModelDisplayNode()
   modelDisplay.SetColor(0, 1, 0)
   modelDisplay.SetScene(scene)
   scene.AddNode(modelDisplay)
   node.SetAndObserveDisplayNodeID(modelDisplay.GetID())
   scene.AddNode(node)
   return node
 def enableSliceIntersection(self, state):
   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()
   displayNode = slicer.mrmlScene.GetNodeByID(displayNodeID)
   if displayNode != None:
     if state:
       displayNode.SliceIntersectionVisibilityOn()
     else:
       displayNode.SliceIntersectionVisibilityOff()
Beispiel #23
0
    def gradeScrew(self, screwModel, transformFid, fidName, screwIndex):
        #Reset screws
        #self.clearGrade()
        
        #Crop out head of screw
        croppedScrew = self.cropScrew(screwModel, 'head')
        
        #Clone screw model poly data
        inputModel = slicer.vtkMRMLModelNode()
        inputModel.SetAndObservePolyData(croppedScrew)
        inputModel.SetAndObserveTransformNodeID(transformFid.GetID())
        slicer.mrmlScene.AddNode(inputModel)
        slicer.vtkSlicerTransformLogic.hardenTransform(inputModel)
        
        #Create new model for output    
        output = slicer.vtkMRMLModelNode()
        output.SetName('Grade model-%s' % fidName)
        slicer.mrmlScene.AddNode(output)
                  
        #Parameters for ProbeVolumeWithModel
        parameters = {}
        parameters["InputVolume"] = self.__inputScalarVol.GetID()
        parameters["InputModel"] = inputModel.GetID()
        parameters["OutputModel"] = output.GetID()
        
        probe = slicer.modules.probevolumewithmodel
        slicer.cli.run(probe, None, parameters, wait_for_completion=True)
        
        #Hide original screw
        modelDisplay = screwModel.GetDisplayNode()
        modelDisplay.SetColor(0,1,0)
        modelDisplay.VisibilityOff()
        
        #Highlight screwh head
        headModel = slicer.vtkMRMLModelNode()
        headModel.SetName('Head %s' % fidName)
        headModel.SetAndObservePolyData(self.cropScrew(screwModel, 'shaft'))
        headModel.SetAndObserveTransformNodeID(transformFid.GetID())
        slicer.mrmlScene.AddNode(headModel)
        
        headDisplay = slicer.vtkMRMLModelDisplayNode()
        headDisplay.SetColor(0,1,0)
        slicer.mrmlScene.AddNode(headDisplay)
        headModel.SetAndObserveDisplayNodeID(headDisplay.GetID())

        #Remove clone    
        slicer.mrmlScene.RemoveNode(inputModel)
        
        #Grade and chart screw
        self.contact(output, screwModel, fidName, screwIndex)
    def gradeScrew(self, screwModel, transformFid, fidName, screwIndex):
        #Reset screws
        #self.clearGrade()

        #Crop out head of screw
        croppedScrew = self.cropScrew(screwModel, 'head')

        #Clone screw model poly data
        inputModel = slicer.vtkMRMLModelNode()
        inputModel.SetAndObservePolyData(croppedScrew)
        inputModel.SetAndObserveTransformNodeID(transformFid.GetID())
        slicer.mrmlScene.AddNode(inputModel)
        slicer.vtkSlicerTransformLogic.hardenTransform(inputModel)

        #Create new model for output
        output = slicer.vtkMRMLModelNode()
        output.SetName('Grade model-%s' % fidName)
        slicer.mrmlScene.AddNode(output)

        #Parameters for ProbeVolumeWithModel
        parameters = {}
        parameters["InputVolume"] = self.__inputScalarVol.GetID()
        parameters["InputModel"] = inputModel.GetID()
        parameters["OutputModel"] = output.GetID()

        probe = slicer.modules.probevolumewithmodel
        slicer.cli.run(probe, None, parameters, wait_for_completion=True)

        #Hide original screw
        modelDisplay = screwModel.GetDisplayNode()
        modelDisplay.SetColor(0, 1, 0)
        modelDisplay.VisibilityOff()

        #Highlight screwh head
        headModel = slicer.vtkMRMLModelNode()
        headModel.SetName('Head %s' % fidName)
        headModel.SetAndObservePolyData(self.cropScrew(screwModel, 'shaft'))
        headModel.SetAndObserveTransformNodeID(transformFid.GetID())
        slicer.mrmlScene.AddNode(headModel)

        headDisplay = slicer.vtkMRMLModelDisplayNode()
        headDisplay.SetColor(0, 1, 0)
        slicer.mrmlScene.AddNode(headDisplay)
        headModel.SetAndObserveDisplayNodeID(headDisplay.GetID())

        #Remove clone
        slicer.mrmlScene.RemoveNode(inputModel)

        #Grade and chart screw
        self.contact(output, screwModel, fidName, screwIndex)
 def addPolyDataToScene(self,polyData,name):
   print "addPolyDataToScene"
   self.outputDisplayNode = slicer.vtkMRMLModelDisplayNode()
   self.outputDisplayNode.SetName(name+"Display")
   self.outputDisplayNode.SetColor(0,0,1.0)
   self.outputDisplayNode.SetOpacity(0.5)
   slicer.mrmlScene.AddNode(self.outputDisplayNode)
   self.outputModelNode = slicer.vtkMRMLModelNode()
   self.outputModelNode.SetAndObservePolyData(polyData)
   self.outputModelNode.SetAndObserveDisplayNodeID(self.outputDisplayNode.GetID())
   if (self.transformGridToTargetNode):
     self.outputModelNode.SetAndObserveTransformNodeID(self.transformGridToTargetNode.GetID())
   self.outputModelNode.SetName(name)
   slicer.mrmlScene.AddNode(self.outputModelNode)
 def calculateFiducialDistance(self, modelNode, fiducial):
   closestFiducial = slicer.util.getNode('CP')
   if not closestFiducial:
     closestFiducial = slicer.vtkMRMLMarkupsFiducialNode()  
     closestFiducial.SetName('CP')
     closestFiducial.AddFiducial(0, 0, 0)
     closestFiducial.SetNthFiducialLabel(0, 'CP')
     slicer.mrmlScene.AddNode(closestFiducial)
     closestFiducial.SetDisplayVisibility(False)
       
   line = slicer.util.getNode('Line')
   if not line:
     line = slicer.vtkMRMLModelNode()
     line.SetName('Line')
     linePolyData = vtk.vtkPolyData()
     line.SetAndObservePolyData(linePolyData)      
     modelDisplay = slicer.vtkMRMLModelDisplayNode()
     modelDisplay.SetSliceIntersectionVisibility(True)
     modelDisplay.SetColor(0,1,0)
     slicer.mrmlScene.AddNode(modelDisplay)      
     line.SetAndObserveDisplayNodeID(modelDisplay.GetID())      
     slicer.mrmlScene.AddNode(line)
     
   cellLocator = vtk.vtkCellLocator()
   cellLocator.SetDataSet(modelNode.GetPolyData())
   cellLocator.BuildLocator()
   
   if fiducial.GetNumberOfFiducials() > 0:          
     ras = [0.0, 0.0, 0.0]
     closestPoint = [0.0, 0.0, 0.0]
     
     fiducial.GetNthFiducialPosition(0, ras)
     distanceSquared = vtk.mutable(0.0) 
     subId = vtk.mutable(0) 
     cellId = vtk.mutable(0) 
     cell = vtk.vtkGenericCell()
     
     cellLocator.FindClosestPoint(ras, closestPoint, cell, cellId, subId, distanceSquared);
     distance = math.sqrt(distanceSquared)
           
     closestFiducial.SetNthFiducialPosition(0,  closestPoint[0], closestPoint[1], closestPoint[2])
     closestFiducial.SetDisplayVisibility(True)
     
     self.drawLineBetweenPoints(line, ras, closestPoint)
     
     self.set3dViewConernerAnnotation('Distance = ' + "%.2f" % distance + 'mm')
   else:
     logging.warning('No fiducials in list!')     
Beispiel #27
0
    def lineModel(self, scene, point1, point2, name, color):

        """ Create a line to reflect the puncture path"""

        #Line mode source

        line = vtk.vtkLineSource()

        line.SetPoint1(point1)#(point1[0][0], point1[0][1], point1[0][2])

        line.SetPoint2(point2)#(point2[0][0], point2[0][1], point2[0][2])

        

        # Create model node

        lineModel = slicer.vtkMRMLModelNode()

        lineModel.SetScene(scene)

        lineModel.SetName(name)

        lineModel.SetAndObservePolyData(line.GetOutput())



        # Create display node

        lineModelDisplay = slicer.vtkMRMLModelDisplayNode()

        lineModelDisplay.SetColor(color)

        lineModelDisplay.SetScene(scene)

        scene.AddNode(lineModelDisplay)

        lineModel.SetAndObserveDisplayNodeID(lineModelDisplay.GetID())



        #Add to scene

#        lineModelDisplay.SetInputPolyData(line.GetOutput())
        lineModelDisplay.SetInputPolyDataConnection(line.GetOutputPort())

        scene.AddNode(lineModel)

        return line
Beispiel #28
0
 def addPolyDataToScene(self, polyData, name):
     print "addPolyDataToScene"
     self.outputDisplayNode = slicer.vtkMRMLModelDisplayNode()
     self.outputDisplayNode.SetName(name + "Display")
     self.outputDisplayNode.SetColor(0, 0, 1.0)
     self.outputDisplayNode.SetOpacity(0.5)
     slicer.mrmlScene.AddNode(self.outputDisplayNode)
     self.outputModelNode = slicer.vtkMRMLModelNode()
     self.outputModelNode.SetAndObservePolyData(polyData)
     self.outputModelNode.SetAndObserveDisplayNodeID(
         self.outputDisplayNode.GetID())
     if (self.transformGridToTargetNode):
         self.outputModelNode.SetAndObserveTransformNodeID(
             self.transformGridToTargetNode.GetID())
     self.outputModelNode.SetName(name)
     slicer.mrmlScene.AddNode(self.outputModelNode)
Beispiel #29
0
def ExtractMesh(outputModelNode, modelNode, colorRgb, colorTolerance):
  
  fullPolyData = modelNode.GetPolyData()
  pointData=fullPolyData.GetPointData()

  redValues = pointData.GetArray('ColorRed')
  greenValues = pointData.GetArray('ColorGreen')
  blueValues = pointData.GetArray('ColorBlue')

  redMaxTolerance = colorRgb[0] + colorTolerance
  redMinTolerance = colorRgb[0] - colorTolerance
  greenMaxTolerance = colorRgb[1] + colorTolerance
  greenMinTolerance = colorRgb[1] - colorTolerance
  blueMaxTolerance = colorRgb[2] + colorTolerance
  blueMinTolerance = colorRgb[2] - colorTolerance

  lengthTuples = int(redValues.GetNumberOfTuples()) 
  selectedPointIds = vtk.vtkIdTypeArray()

  for pointId in range(lengthTuples):
    if redValues.GetValue(pointId) >= redMinTolerance and redValues.GetValue(pointId) <= redMaxTolerance and greenValues.GetValue(pointId) >= greenMinTolerance and greenValues.GetValue(pointId) <= greenMaxTolerance and blueValues.GetValue(pointId) >= blueMinTolerance and blueValues.GetValue(pointId) <= blueMaxTolerance:
      selectedPointIds.InsertNextValue(pointId)  
      selectedPointIds.InsertNextValue(pointId)  

  selectionNode = vtk.vtkSelectionNode()
  selectionNode.SetFieldType(vtk.vtkSelectionNode.POINT)
  selectionNode.SetContentType(vtk.vtkSelectionNode.INDICES)
  selectionNode.SetSelectionList(selectedPointIds)
  selectionNode.GetProperties().Set(vtk.vtkSelectionNode.CONTAINING_CELLS(), 1);

  selection = vtk.vtkSelection()
  selection.AddNode(selectionNode)

  extractSelection = vtk.vtkExtractSelection()
  extractSelection.SetInputData(0,fullPolyData)
  extractSelection.SetInputData(1,selection);
  extractSelection.Update();

  convertToPolydata = vtk.vtkDataSetSurfaceFilter()
  convertToPolydata.SetInputConnection(extractSelection.GetOutputPort())
  convertToPolydata.Update()
  outputModelNode.SetAndObservePolyData(convertToPolydata.GetOutput())

  if not outputModelNode.GetDisplayNode():
    md2 = slicer.vtkMRMLModelDisplayNode()
    slicer.mrmlScene.AddNode(md2)
    outputModelNode.SetAndObserveDisplayNodeID(md2.GetID()) 
  def createOptionalPathModel(self, pos, holeInfoList, intNumOfOptionalPath):
    if intNumOfOptionalPath == 1:
      self.setOptionalPathVisibility(1)

    pathListRAS = []

    for i in range(len(holeInfoList)):
      pathListRAS.append(self.templateRAS[holeInfoList[i][3]])

    print "pathListRAS: ", pathListRAS

    #(not generate path -> pass, otherwise go on)

    self.optModelNode = slicer.mrmlScene.GetNodeByID(self.optionalPathModelNodeID)
    if self.optModelNode == None:
      self.optModelNode = slicer.vtkMRMLModelNode()
      self.optModelNode.SetName('AllOptionalPaths')
      slicer.mrmlScene.AddNode(self.optModelNode)
      self.optionalPathModelNodeID = self.optModelNode.GetID()

      self.dnodeOpt = slicer.vtkMRMLModelDisplayNode()
      self.dnodeOpt.SetColor(0.96,0.92,0.56)
      slicer.mrmlScene.AddNode(self.dnodeOpt)
      self.optModelNode.SetAndObserveDisplayNodeID(self.dnodeOpt.GetID())

    optModelAppend = vtk.vtkAppendPolyData()

    #for path in pathListRAS:
    for index in range(len(pathListRAS)):
      optLineSource = vtk.vtkLineSource()
      optLineSource.SetPoint1(pos)
      optLineSource.SetPoint2(pathListRAS[index])

      optTubeFilter = vtk.vtkTubeFilter()
      optTubeFilter.SetInputConnection(optLineSource.GetOutputPort())
      optTubeFilter.SetRadius(1.0)
      optTubeFilter.SetNumberOfSides(10)
      optTubeFilter.CappingOn()
      optTubeFilter.Update()

      if vtk.VTK_MAJOR_VERSION <= 5:
        optModelAppend.AddInput(optTubeFilter.GetOutput())
      else:
        optModelAppend.AddInputData(optTubeFilter.GetOutput())

      optModelAppend.Update()
      self.optModelNode.SetAndObservePolyData(optModelAppend.GetOutput())
Beispiel #31
0
    def handLine(self, whichHand='Left'):
        """Create a line to show the path from the hand to the table
    """
        handLineName = 'DropLine-%s' % whichHand
        handLineNode = slicer.util.getNode(handLineName)
        if not handLineNode:
            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 ((0, 0, 0), (1, 1, 1)):
                pointIndex = points.InsertNextPoint(*point)
                linesIDArray.InsertNextTuple1(pointIndex)
                linesIDArray.SetTuple1(0, linesIDArray.GetNumberOfTuples() - 1)
                lines.SetNumberOfCells(1)

            # Create handLineNode model node
            handLineNode = slicer.vtkMRMLModelNode()
            handLineNode.SetScene(slicer.mrmlScene)
            handLineNode.SetName("DropLine-%s" % whichHand)
            handLineNode.SetAndObservePolyData(polyData)

            # Create display node
            modelDisplay = slicer.vtkMRMLModelDisplayNode()
            modelDisplay.SetColor(1, 1, 0)  # yellow
            modelDisplay.SetScene(slicer.mrmlScene)
            slicer.mrmlScene.AddNode(modelDisplay)
            handLineNode.SetAndObserveDisplayNodeID(modelDisplay.GetID())

            # Add to slicer.mrmlScene
            modelDisplay.SetInputPolyData(handLineNode.GetPolyData())
            slicer.mrmlScene.AddNode(handLineNode)
        return handLineNode
Beispiel #32
0
  def handLine(self,whichHand='Left'):
    """Create a line to show the path from the hand to the table
    """
    handLineName = 'DropLine-%s' % whichHand
    handLineNode = slicer.util.getNode(handLineName)
    if not handLineNode:
      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 ( (0,0,0), (1,1,1) ):
        pointIndex = points.InsertNextPoint(*point)
        linesIDArray.InsertNextTuple1(pointIndex)
        linesIDArray.SetTuple1( 0, linesIDArray.GetNumberOfTuples() - 1 )
        lines.SetNumberOfCells(1)
        
      # Create handLineNode model node
      handLineNode = slicer.vtkMRMLModelNode()
      handLineNode.SetScene(slicer.mrmlScene)
      handLineNode.SetName("DropLine-%s" % whichHand)
      handLineNode.SetAndObservePolyData(polyData)

      # Create display node
      modelDisplay = slicer.vtkMRMLModelDisplayNode()
      modelDisplay.SetColor(1,1,0) # yellow
      modelDisplay.SetScene(slicer.mrmlScene)
      slicer.mrmlScene.AddNode(modelDisplay)
      handLineNode.SetAndObserveDisplayNodeID(modelDisplay.GetID())

      # Add to slicer.mrmlScene
      modelDisplay.SetInputPolyData(handLineNode.GetPolyData())
      slicer.mrmlScene.AddNode(handLineNode)
    return handLineNode
  def __init__(self):
    self.scene = slicer.mrmlScene
    self.scene.SetUndoOn()
    self.scene.SaveStateForUndo(self.scene.GetNodes())
    
    self.currentSlice = Slice('/luscinia/ProstateStudy/invivo/Patient59/loupas/RadialImagesCC_imwrite/arfi_ts3_26.57.png')

    # yay, adding images to slicer
    planeSource = vtk.vtkPlaneSource()
    planeSource.SetCenter(self.currentSlice.x, self.currentSlice.y, self.currentSlice.z)
    reader = vtk.vtkPNGReader()
    reader.SetFileName(self.currentSlice.name)

    # model node
    self.model = slicer.vtkMRMLModelNode()
    self.model.SetScene(self.scene)
    self.model.SetName(self.currentSlice.name)
    self.model.SetAndObservePolyData(planeSource.GetOutput())

    # model display node
    self.modelDisplay = slicer.vtkMRMLModelDisplayNode()
    self.modelDisplay.BackfaceCullingOff() # so plane can be seen from both front and back face
    self.modelDisplay.SetScene(self.scene)
    self.scene.AddNode(self.modelDisplay)

    # connecting model node w/ its model display node
    self.model.SetAndObserveDisplayNodeID(self.modelDisplay.GetID())

    # adding tiff file as texture to modelDisplay
    self.modelDisplay.SetAndObserveTextureImageData(reader.GetOutput())
    self.scene.AddNode(self.model)

    # now doing a linear transform to set coordinates and orientation of plane
    self.transform = slicer.vtkMRMLLinearTransformNode()
    self.scene.AddNode(self.transform)
    self.model.SetAndObserveTransformNodeID(self.transform.GetID())
    vTransform = vtk.vtkTransform()
    vTransform.Scale(150, 150, 150)
    vTransform.RotateX(0)
    vTransform.RotateY(0)
    vTransform.RotateZ(0)

    self.transform.SetAndObserveMatrixTransformToParent(vTransform.GetMatrix())
  def selectSlice(self, index):
    self.scene.Undo()
    self.scene.SaveStateForUndo(self.scene.GetNodes())
    imgFilePrefix = './data/test'
    imgFileSuffix = '.tiff'
    # yay, adding images to slicer
    planeSource = vtk.vtkPlaneSource()

    reader = vtk.vtkTIFFReader()
    reader.SetFileName(imgFilePrefix + str(self.imageList[index]) + imgFileSuffix)
    #reader.CanReadFile('imgFilePrefix + str(self.imageList[0]) + imgFileSuffix')

    # model node
    model = slicer.vtkMRMLModelNode()
    model.SetScene(self.scene)
    model.SetName("test " + str(self.imageList[index]) + "cow")
    model.SetAndObservePolyData(planeSource.GetOutput())

    # model display node
    modelDisplay = slicer.vtkMRMLModelDisplayNode()
    modelDisplay.BackfaceCullingOff() # so plane can be seen from both front and back face
    modelDisplay.SetScene(self.scene)
    self.scene.AddNode(modelDisplay)

    # connecting model node w/ its model display node
    model.SetAndObserveDisplayNodeID(modelDisplay.GetID())

    # adding tiff file as texture to modelDisplay
    modelDisplay.SetAndObserveTextureImageData(reader.GetOutput())
    self.scene.AddNode(model)

    # now doing a linear transform to set coordinates and orientation of plane
    transform = slicer.vtkMRMLLinearTransformNode()
    self.scene.AddNode(transform)
    model.SetAndObserveTransformNodeID(transform.GetID())
    vTransform = vtk.vtkTransform()
    vTransform.Scale(150, 150, 150)
    vTransform.RotateX(self.rotateXList[index])
    vTransform.RotateY(self.rotateYList[index])
    vTransform.RotateZ(self.rotateZList[index])

    transform.SetAndObserveMatrixTransformToParent(vTransform.GetMatrix())
Beispiel #35
0
        def __init__(self, markupID, radius, length, position):
            # We use the markupID to check whether this tool's markup has
            # been removed in the onMarkupRemoved event
            self.markupID = markupID

            # Create a vtkCylinderSource for rendering the tool
            self.toolSrc = vtk.vtkCylinderSource()
            self.toolSrc.SetRadius(radius)
            self.toolSrc.SetHeight(length)

            # Create tool model using cylinder source
            self.modelNode = slicer.vtkMRMLModelNode()
            self.modelNode.HideFromEditorsOn()
            self.modelNode.SetName(slicer.mrmlScene.GenerateUniqueName("Tool"))
            polyData = self.toolSrc.GetOutput()
            self.modelNode.SetAndObservePolyData(polyData)
            slicer.mrmlScene.AddNode(self.modelNode)

            # Create a DisplayNode for this node (so that it can control its
            # own visibility) and have modelNode observe it
            self.modelDisplay = slicer.vtkMRMLModelDisplayNode()
            self.modelDisplay.SetColor(0, 1, 1)  # cyan
            slicer.mrmlScene.AddNode(self.modelDisplay)
            self.modelNode.SetAndObserveDisplayNodeID(
                self.modelDisplay.GetID())

            # Create a transform for our tool model that will scale it to
            # the proper radius, length, and position. Leave the orientation
            # at the default.
            self.transformNode = slicer.vtkMRMLLinearTransformNode()
            self.transformNode.HideFromEditorsOn()
            self.transformNode.SetName(
                slicer.mrmlScene.GenerateUniqueName("Transform"))
            self.updatePosition(position)
            slicer.mrmlScene.AddNode(self.transformNode)

            # apply the new transform to our tool
            self.modelNode.SetAndObserveTransformNodeID(
                self.transformNode.GetID())

            # Set tool to be visible
            self.visible = True
def updateOutputNode(polydata):
    # clear scene
    scene=slicer.mrmlScene
    scene.Clear(0)
    
    # create fiber node
    fiber=slicer.vtkMRMLModelNode()
    fiber.SetScene(scene)
    fiber.SetName("QueryTract")
    fiber.SetAndObservePolyData(polydata)
    
    # create display model fiber node
    fiberDisplay=slicer.vtkMRMLModelDisplayNode()
    fiberDisplay.SetScene(scene)
    scene.AddNode(fiberDisplay)
    fiber.SetAndObserveDisplayNodeID(fiberDisplay.GetID())
    
    # add to scene
    fiberDisplay.SetInputPolyData(polydata)
    scene.AddNode(fiber)
Beispiel #37
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 updateOutputNode(polydata):
    # clear scene
    scene = slicer.mrmlScene
    scene.Clear(0)

    # create fiber node
    fiber = slicer.vtkMRMLModelNode()
    fiber.SetScene(scene)
    fiber.SetName("QueryTract")
    fiber.SetAndObservePolyData(polydata)

    # create display model fiber node
    fiberDisplay = slicer.vtkMRMLModelDisplayNode()
    fiberDisplay.SetScene(scene)
    scene.AddNode(fiberDisplay)
    fiber.SetAndObserveDisplayNodeID(fiberDisplay.GetID())

    # add to scene
    fiberDisplay.SetInputPolyData(polydata)
    scene.AddNode(fiber)
  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)
  def updateScene(self):
    #self.scene.Undo()
    #self.scene.SaveStateForUndo(self.scene.GetNodes())
    self.scene.RemoveNode(self.transform)
    self.scene.RemoveNode(self.modelDisplay)
    self.scene.RemoveNode(self.model)

    planeSource = vtk.vtkPlaneSource()
    planeSource.SetCenter(self.currentSlice.x, self.currentSlice.y, self.currentSlice.z)
    reader = vtk.vtkPNGReader()
    reader.SetFileName(self.currentSlice.name)

    # model node
    self.model = slicer.vtkMRMLModelNode()
    self.model.SetScene(self.scene)
    self.model.SetName(self.currentSlice.name)
    self.model.SetAndObservePolyData(planeSource.GetOutput())

    # model display node
    self.modelDisplay = slicer.vtkMRMLModelDisplayNode()
    self.modelDisplay.BackfaceCullingOff() # so plane can be seen from both front and back face
    self.modelDisplay.SetScene(self.scene)
    self.scene.AddNode(self.modelDisplay)

    # connecting model node w/ its model display node
    self.model.SetAndObserveDisplayNodeID(self.modelDisplay.GetID())

    # adding tiff file as texture to modelDisplay
    self.modelDisplay.SetAndObserveTextureImageData(reader.GetOutput())
    self.scene.AddNode(self.model)

    # now doing a linear transform to set coordinates and orientation of plane
    self.transform = slicer.vtkMRMLLinearTransformNode()
    self.scene.AddNode(self.transform)
    self.model.SetAndObserveTransformNodeID(self.transform.GetID())
    vTransform = vtk.vtkTransform()
    vTransform.Scale(self.currentSlice.scaling, self.currentSlice.scaling, self.currentSlice.scaling)
    vTransform.RotateX(self.currentSlice.xAngle)
    vTransform.RotateY(self.currentSlice.yAngle)
    vTransform.RotateZ(self.currentSlice.zAngle)
    self.transform.SetAndObserveMatrixTransformToParent(vTransform.GetMatrix())
  def startTransformMapping(self, groundTruthTransformNode, mappedTransformNode, outputVisitedPointsModelNode, positionErrorTransformNode, orientationErrorTransformNode):
    self.removeObservers()
    self.groundTruthTransformNode = groundTruthTransformNode
    self.mappedTransformNode = mappedTransformNode
    self.outputVisitedPointsModelNode = outputVisitedPointsModelNode
    self.positionErrorTransformNode = positionErrorTransformNode
    self.orientationErrorTransformNode = orientationErrorTransformNode

    self.positionErrorMagnitudeList = []
    self.orientationErrorMagnitudeList = []

    if self.outputVisitedPointsModelNode:

      if not self.outputVisitedPointsModelNode.GetDisplayNode():
        modelDisplay = slicer.vtkMRMLModelDisplayNode()
        #modelDisplay.SetSliceIntersectionVisibility(False) # Show in slice view
        #modelDisplay.SetEdgeVisibility(True) # Hide in 3D view
        modelDisplay.SetEdgeVisibility(True)
        slicer.mrmlScene.AddNode(modelDisplay)
        self.outputVisitedPointsModelNode.SetAndObserveDisplayNodeID(modelDisplay.GetID())

      self.visitedPoints = vtk.vtkPoints()
      self.visitedPointsPolydata = vtk.vtkPolyData()
      self.visitedPointsPolydata.SetPoints(self.visitedPoints)
      glyph = vtk.vtkPolyData()
      cubeSource = vtk.vtkCubeSource()
      cubeSource.SetXLength(self.minimumSamplingDistance)
      cubeSource.SetYLength(self.minimumSamplingDistance)
      cubeSource.SetZLength(self.minimumSamplingDistance)
      self.visitedPointsGlyph3d = vtk.vtkGlyph3D()
      self.visitedPointsGlyph3d.SetSourceConnection(cubeSource.GetOutputPort())
      self.visitedPointsGlyph3d.SetInputData(self.visitedPointsPolydata)
      self.visitedPointsGlyph3d.Update()
      self.outputVisitedPointsModelNode.SetPolyDataConnection(self.visitedPointsGlyph3d.GetOutputPort())

    self.initializeErrorTransform(self.positionErrorTransformNode)
    self.initializeErrorTransform(self.orientationErrorTransformNode)

    # Start the updates
    self.addObservers()
    self.onGroundTruthTransformNodeModified(0,0)
Beispiel #42
0
    def tableCursor(self, dimensions=(900, 30, 600)):
        """Create the mrml structure to represent the table if needed
    otherwise return the current transform
    dimensions : left-right, up-down, in-out size of table
    """
        transformName = 'Table-To-Camera'
        transformNode = slicer.util.getNode(transformName)
        if not transformNode:
            # make the mrml
            box = vtk.vtkCubeSource()
            box.SetXLength(dimensions[0])
            box.SetYLength(dimensions[1])
            box.SetZLength(dimensions[2])
            box.SetCenter(0, -dimensions[1] / 2., 0)

            box.Update()
            # Create model node
            cursor = slicer.vtkMRMLModelNode()
            cursor.SetScene(slicer.mrmlScene)
            cursor.SetName("Cursor-Table")
            cursor.SetAndObservePolyData(box.GetOutput())
            # Create display node
            cursorModelDisplay = slicer.vtkMRMLModelDisplayNode()
            cursorModelDisplay.SetColor(
                (0.86274509803921573, ) * 3)  # 'gainsboro'
            cursorModelDisplay.SetOpacity(0.5)
            cursorModelDisplay.SetScene(slicer.mrmlScene)
            slicer.mrmlScene.AddNode(cursorModelDisplay)
            cursor.SetAndObserveDisplayNodeID(cursorModelDisplay.GetID())
            # Add to slicer.mrmlScene
            cursorModelDisplay.SetInputPolyData(box.GetOutput())
            slicer.mrmlScene.AddNode(cursor)
            # Create transform node
            transformNode = slicer.vtkMRMLLinearTransformNode()
            transformNode.SetName(transformName)
            slicer.mrmlScene.AddNode(transformNode)
            tableToCamera = vtk.vtkMatrix4x4()
            tableToCamera.SetElement(1, 3, -100)
            transformNode.GetMatrixTransformToParent().DeepCopy(tableToCamera)
            cursor.SetAndObserveTransformNodeID(transformNode.GetID())
        return transformNode
  def startTransformMapping(self, groundTruthTransformNode, mappedTransformNode, outputVisitedPointsModelNode, positionErrorTransformNode, orientationErrorTransformNode):
    self.removeObservers()
    self.groundTruthTransformNode = groundTruthTransformNode
    self.mappedTransformNode = mappedTransformNode
    self.outputVisitedPointsModelNode = outputVisitedPointsModelNode
    self.positionErrorTransformNode = positionErrorTransformNode
    self.orientationErrorTransformNode = orientationErrorTransformNode

    self.positionErrorMagnitudeList = []
    self.orientationErrorMagnitudeList = []

    if self.outputVisitedPointsModelNode:

      if not self.outputVisitedPointsModelNode.GetDisplayNode():
        modelDisplay = slicer.vtkMRMLModelDisplayNode()
        #modelDisplay.SetSliceIntersectionVisibility(False) # Show in slice view
        #modelDisplay.SetEdgeVisibility(True) # Hide in 3D view
        modelDisplay.SetEdgeVisibility(True)
        slicer.mrmlScene.AddNode(modelDisplay)
        self.outputVisitedPointsModelNode.SetAndObserveDisplayNodeID(modelDisplay.GetID())

      self.visitedPoints = vtk.vtkPoints()
      self.visitedPointsPolydata = vtk.vtkPolyData()
      self.visitedPointsPolydata.SetPoints(self.visitedPoints)
      glyph = vtk.vtkPolyData()
      cubeSource = vtk.vtkCubeSource()
      cubeSource.SetXLength(self.minimumSamplingDistance)
      cubeSource.SetYLength(self.minimumSamplingDistance)
      cubeSource.SetZLength(self.minimumSamplingDistance)
      self.visitedPointsGlyph3d = vtk.vtkGlyph3D()
      self.visitedPointsGlyph3d.SetSourceConnection(cubeSource.GetOutputPort())
      self.visitedPointsGlyph3d.SetInputData(self.visitedPointsPolydata)
      self.visitedPointsGlyph3d.Update()
      self.outputVisitedPointsModelNode.SetPolyDataConnection(self.visitedPointsGlyph3d.GetOutputPort())

    self.initializeErrorTransform(self.positionErrorTransformNode)
    self.initializeErrorTransform(self.orientationErrorTransformNode)

    # Start the updates
    self.addObservers()
    self.onGroundTruthTransformNodeModified(0,0)
Beispiel #44
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
Beispiel #45
0
  def tableCursor(self,dimensions=(900,30,600)):
    """Create the mrml structure to represent the table if needed
    otherwise return the current transform
    dimensions : left-right, up-down, in-out size of table
    """
    transformName = 'Table-To-Camera'
    transformNode = slicer.util.getNode(transformName)
    if not transformNode:
      # make the mrml 
      box = vtk.vtkCubeSource()
      box.SetXLength(dimensions[0])
      box.SetYLength(dimensions[1])
      box.SetZLength(dimensions[2])
      box.SetCenter(0,-dimensions[1]/2.,0)

      box.Update()
      # Create model node
      cursor = slicer.vtkMRMLModelNode()
      cursor.SetScene(slicer.mrmlScene)
      cursor.SetName("Cursor-Table")
      cursor.SetAndObservePolyData(box.GetOutput())
      # Create display node
      cursorModelDisplay = slicer.vtkMRMLModelDisplayNode()
      cursorModelDisplay.SetColor((0.86274509803921573,)*3) # 'gainsboro'
      cursorModelDisplay.SetOpacity(0.5)
      cursorModelDisplay.SetScene(slicer.mrmlScene)
      slicer.mrmlScene.AddNode(cursorModelDisplay)
      cursor.SetAndObserveDisplayNodeID(cursorModelDisplay.GetID())
      # Add to slicer.mrmlScene
      cursorModelDisplay.SetInputPolyData(box.GetOutput())
      slicer.mrmlScene.AddNode(cursor)
      # Create transform node
      transformNode = slicer.vtkMRMLLinearTransformNode()
      transformNode.SetName(transformName)
      slicer.mrmlScene.AddNode(transformNode)
      tableToCamera = vtk.vtkMatrix4x4()
      tableToCamera.SetElement(1, 3, -100)
      transformNode.GetMatrixTransformToParent().DeepCopy(tableToCamera)
      cursor.SetAndObserveTransformNodeID(transformNode.GetID())
    return transformNode
Beispiel #46
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
Beispiel #47
0
    def __init__(self, markupID, radius, length, position):
      # We use the markupID to check whether this tool's markup has
      # been removed in the onMarkupRemoved event
      self.markupID = markupID

      # Create a vtkCylinderSource for rendering the tool
      self.toolSrc = vtk.vtkCylinderSource()
      self.toolSrc.SetRadius(radius)
      self.toolSrc.SetHeight(length)

      # Create tool model using cylinder source
      self.modelNode = slicer.vtkMRMLModelNode()
      self.modelNode.HideFromEditorsOn()
      self.modelNode.SetName(slicer.mrmlScene.GenerateUniqueName("Tool"))
      polyData = self.toolSrc.GetOutput()
      self.modelNode.SetAndObservePolyData(polyData)
      slicer.mrmlScene.AddNode(self.modelNode)

      # Create a DisplayNode for this node (so that it can control its
      # own visibility) and have modelNode observe it
      self.modelDisplay = slicer.vtkMRMLModelDisplayNode()
      self.modelDisplay.SetColor(0,1,1) # cyan
      slicer.mrmlScene.AddNode(self.modelDisplay)
      self.modelNode.SetAndObserveDisplayNodeID(self.modelDisplay.GetID())

      # Create a transform for our tool model that will scale it to
      # the proper radius, length, and position. Leave the orientation
      # at the default.
      self.transformNode = slicer.vtkMRMLLinearTransformNode()
      self.transformNode.HideFromEditorsOn()
      self.transformNode.SetName(slicer.mrmlScene.GenerateUniqueName("Transform"))
      self.updatePosition(position)
      slicer.mrmlScene.AddNode(self.transformNode)

      # apply the new transform to our tool
      self.modelNode.SetAndObserveTransformNodeID(self.transformNode.GetID())

      # Set tool to be visible
      self.visible = True
Beispiel #48
0
    def onHelloWorldButtonClicked(self):

        scene = slicer.mrmlScene
        inputModel = self.inputSelector.currentNode()

        bounds = [0, 0, 0, 0, 0, 0]
        inputModel.GetBounds(bounds)

        print('Model Name is:')
        print(inputModel.GetName())

        X = bounds[1] - bounds[0]
        Y = bounds[3] - bounds[2]
        Z = bounds[5] - bounds[4]

        mid = (bounds[0] + X / 2, bounds[2] + Y / 2, bounds[4] + Z / 2)

        X_thick = .1  #TODO resolution input
        Y_thick = .1  #TODO resolution input
        Z_thick = .1  #TODO resolution input

        z_slices = int(math.ceil(Z / Z_thick))
        y_slices = int(math.ceil(Y / Y_thick))
        x_slices = int(math.ceil(X / X_thick))

        x_thick = X / x_slices
        y_thick = Y / y_slices
        z_thick = Z / z_slices

        print('number of slices')
        print((x_slices, y_slices, z_slices))
        print('midpoint')
        print(mid)
        #TODO Bounding box calculation
        imageSize = [x_slices, y_slices, z_slices]
        imageSpacing = [x_thick, y_thick, z_thick]

        voxelType = vtk.VTK_UNSIGNED_CHAR

        imageData = vtk.vtkImageData()
        imageData.SetDimensions(imageSize)
        imageData.AllocateScalars(voxelType, 1)
        thresholder = vtk.vtkImageThreshold()
        thresholder.SetInputData(imageData)
        thresholder.SetInValue(1)
        thresholder.SetOutValue(1)
        # Create volume node
        volumeNode = slicer.vtkMRMLScalarVolumeNode()
        volumeNode.SetSpacing(imageSpacing)
        volumeNode.SetImageDataConnection(thresholder.GetOutputPort())
        # Add volume to scene
        slicer.mrmlScene.AddNode(volumeNode)
        displayNode = slicer.vtkMRMLScalarVolumeDisplayNode()
        slicer.mrmlScene.AddNode(displayNode)
        colorNode = slicer.util.getNode('Grey')
        displayNode.SetAndObserveColorNodeID(colorNode.GetID())
        volumeNode.SetAndObserveDisplayNodeID(displayNode.GetID())
        volumeNode.CreateDefaultStorageNode()

        #Transform the Volume to Fit Around the Model
        transform = slicer.vtkMRMLLinearTransformNode()
        scene.AddNode(transform)
        volumeNode.SetAndObserveTransformNodeID(transform.GetID())

        vTransform = vtk.vtkTransform()
        vTransform.Translate(
            (-X / 2 + mid[0], -Y / 2 + mid[1], -Z / 2 + mid[2]))
        transform.SetAndObserveMatrixTransformToParent(vTransform.GetMatrix())

        #Create a segmentation Node
        segmentationNode = slicer.vtkMRMLSegmentationNode()
        slicer.mrmlScene.AddNode(segmentationNode)
        segmentationNode.CreateDefaultDisplayNodes()
        segmentationNode.SetReferenceImageGeometryParameterFromVolumeNode(
            volumeNode)

        #Add the model as a segmentation
        #sphereSource = vtk.vtkSphereSource()
        #sphereSource.SetRadius(10)
        #sphereSource.SetCenter(6,30,28)
        #sphereSource.Update()
        #segmentationNode.AddSegmentFromClosedSurfaceRepresentation(sphereSource.GetOutput(), "Test")

        segmentID = segmentationNode.GetSegmentation().GenerateUniqueSegmentID(
            "Test")
        segmentationNode.AddSegmentFromClosedSurfaceRepresentation(
            inputModel.GetPolyData(), segmentID)
        #TODO, Unique ID
        segmentationNode.SetMasterRepresentationToBinaryLabelmap()

        modelLabelMap = segmentationNode.GetBinaryLabelmapRepresentation(
            segmentID)  #TODO Unique ID

        segmentationNode.SetMasterRepresentationToBinaryLabelmap()

        shape = list(modelLabelMap.GetDimensions())
        shape.reverse()  #why reverse?
        labelArray = vtk.util.numpy_support.vtk_to_numpy(
            modelLabelMap.GetPointData().GetScalars()).reshape(shape)

        for n in range(1, shape[0] - 1):
            labelArray[n, :, :] = numpy.maximum(labelArray[n, :, :],
                                                labelArray[n - 1, :, :])

        outputPolyData = vtk.vtkPolyData()
        slicer.vtkSlicerSegmentationsModuleLogic.GetSegmentClosedSurfaceRepresentation(
            segmentationNode, segmentID, outputPolyData)

        # Create model node
        model = slicer.vtkMRMLModelNode()
        model.SetScene(scene)
        model.SetName(scene.GenerateUniqueName("Model_Undercuts_Removed"))

        model.SetAndObservePolyData(outputPolyData)

        # Create display node
        modelDisplay = slicer.vtkMRMLModelDisplayNode()
        modelDisplay.SetColor(1, 1, 0)  # yellow
        modelDisplay.SetBackfaceCulling(0)
        modelDisplay.SetScene(scene)
        scene.AddNode(modelDisplay)
        model.SetAndObserveDisplayNodeID(modelDisplay.GetID())

        # Add to scene
        scene.AddNode(model)
Beispiel #49
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
Beispiel #50
0
  def createTemplateModel(self):
    
    self.templatePathVectors = []
    self.templatePathOrigins = []

    self.tempModelNode = slicer.mrmlScene.GetNodeByID(self.templateModelNodeID)
    if self.tempModelNode is None:
      self.tempModelNode = slicer.vtkMRMLModelNode()
      self.tempModelNode.SetName('NeedleGuideTemplate')
      slicer.mrmlScene.AddNode(self.tempModelNode)
      self.templateModelNodeID = self.tempModelNode.GetID()

      dnode = slicer.vtkMRMLModelDisplayNode()
      #dnode.SetColor(self.ModelColor)
      slicer.mrmlScene.AddNode(dnode)
      self.tempModelNode.SetAndObserveDisplayNodeID(dnode.GetID())
      self.modelNodetag = self.tempModelNode.AddObserver(slicer.vtkMRMLTransformableNode.TransformModifiedEvent,
                                                         self.onTemplateTransformUpdated)
      
    self.pathModelNode = slicer.mrmlScene.GetNodeByID(self.needlePathModelNodeID)
    if self.pathModelNode is None:
      self.pathModelNode = slicer.vtkMRMLModelNode()
      self.pathModelNode.SetName('NeedleGuideNeedlePath')
      slicer.mrmlScene.AddNode(self.pathModelNode)
      self.needlePathModelNodeID = self.pathModelNode.GetID()

      dnode = slicer.vtkMRMLModelDisplayNode()
      slicer.mrmlScene.AddNode(dnode)
      self.pathModelNode.SetAndObserveDisplayNodeID(dnode.GetID())
      
    pathModelAppend = vtk.vtkAppendPolyData()
    tempModelAppend = vtk.vtkAppendPolyData()
    
    for row in self.templateConfig:

      p1 = numpy.array(row[0:3])
      p2 = numpy.array(row[3:6])
      tempLineSource = vtk.vtkLineSource()
      tempLineSource.SetPoint1(p1)
      tempLineSource.SetPoint2(p2)
 
      tempTubeFilter = vtk.vtkTubeFilter()
      tempTubeFilter.SetInputConnection(tempLineSource.GetOutputPort())
      tempTubeFilter.SetRadius(1.0)
      tempTubeFilter.SetNumberOfSides(18)
      tempTubeFilter.CappingOn()
      tempTubeFilter.Update()

      pathLineSource = vtk.vtkLineSource()
      v = p2-p1
      nl = numpy.linalg.norm(v)
      n = v/nl  # normal vector
      l = row[6]
      p3 = p1 + l * n
      pathLineSource.SetPoint1(p1)
      pathLineSource.SetPoint2(p3)

      self.templatePathOrigins.append([row[0], row[1], row[2], 1.0])
      self.templatePathVectors.append([n[0], n[1], n[2], 1.0])
      self.templateMaxDepth.append(row[6])
 
      pathTubeFilter = vtk.vtkTubeFilter()
      pathTubeFilter.SetInputConnection(pathLineSource.GetOutputPort())
      pathTubeFilter.SetRadius(0.8)
      pathTubeFilter.SetNumberOfSides(18)
      pathTubeFilter.CappingOn()
      pathTubeFilter.Update()

      if vtk.VTK_MAJOR_VERSION <= 5:
        tempModelAppend.AddInput(tempTubeFilter.GetOutput())
        pathModelAppend.AddInput(pathTubeFilter.GetOutput())
      else:
        tempModelAppend.AddInputData(tempTubeFilter.GetOutput())
        pathModelAppend.AddInputData(pathTubeFilter.GetOutput())

      tempModelAppend.Update()
      self.tempModelNode.SetAndObservePolyData(tempModelAppend.GetOutput())
      pathModelAppend.Update()
      self.pathModelNode.SetAndObservePolyData(pathModelAppend.GetOutput())
Beispiel #51
0
 def takeUSSnapshot2(self,name):
   snapshotDisp = slicer.vtkMRMLModelDisplayNode()
   slicer.mrmlScene.AddNode(snapshotDisp)
   snapshotDisp.SetScene(slicer.mrmlScene)
   snapshotDisp.SetDisableModifiedEvent(1)
   snapshotDisp.SetOpacity(1.0)
   snapshotDisp.SetColor(1.0, 1.0, 1.0)
   snapshotDisp.SetAmbient(1.0)
   snapshotDisp.SetBackfaceCulling(0)
   snapshotDisp.SetDiffuse(0)
   snapshotDisp.SetSaveWithScene(0)
   snapshotDisp.SetDisableModifiedEvent(0)
   
   snapshotModel = slicer.vtkMRMLModelNode()
   snapshotModel.SetName(name)
   snapshotModel.SetDescription("Live Ultrasound Snapshot")
   snapshotModel.SetScene(slicer.mrmlScene)
   snapshotModel.SetAndObserveDisplayNodeID(snapshotDisp.GetID())
   snapshotModel.SetHideFromEditors(0)
   snapshotModel.SetSaveWithScene(0)
   slicer.mrmlScene.AddNode(snapshotModel)
   
   image_RAS = slicer.util.getNode("Image_Image")
   
   dim = [0, 0, 0]
   imageData = image_RAS.GetImageData()
   imageData.GetDimensions(dim)
   
   plane = vtk.vtkPlaneSource()
   plane.Update()
   snapshotModel.SetAndObservePolyData(plane.GetOutput())
   
   slicePolyData = snapshotModel.GetPolyData()
   slicePoints = slicePolyData.GetPoints()
   
   # In parent transform is saved the ReferenceToRAS transform
   parentTransform = vtk.vtkTransform()
   parentTransform.Identity()
   if not image_RAS.GetParentTransformNode() == None:
     parentMatrix = vtk.vtkMatrix4x4()
     parentTransformNode = image_RAS.GetParentTransformNode()
     parentTransformNode.GetMatrixTransformToWorld(parentMatrix)
     # aux=parentTransform.GetMatrix()
     # aux.DeepCopy(parentMatrix)
     # parentTransform.Update()
     parentTransform.SetMatrix(parentMatrix)
     
   inImageTransform = vtk.vtkTransform()
   inImageTransform.Identity()
   image_RAS.GetIJKToRASMatrix(inImageTransform.GetMatrix())
   
   tImageToRAS = vtk.vtkTransform()
   tImageToRAS.Identity()
   tImageToRAS.PostMultiply()
   tImageToRAS.Concatenate(inImageTransform)
   tImageToRAS.Concatenate(parentTransform)
  
   tImageToRAS.Update()
   
   point1Image = [0.0, 0.0, 0.0, 1.0]
   point2Image = [dim[0], 0.0, 0.0, 1.0]
   point3Image = [0.0, dim[1], 0.0, 1.0]
   point4Image = [dim[0], dim[1], 0.0, 1.0]
   
   point1RAS = [0.0, 0.0, 0.0, 0.0]
   point2RAS = [0.0, 0.0, 0.0, 0.0]
   point3RAS = [0.0, 0.0, 0.0, 0.0]
   point4RAS = [0.0, 0.0, 0.0, 0.0]
   tImageToRAS.MultiplyPoint(point1Image, point1RAS)
   tImageToRAS.MultiplyPoint(point2Image, point2RAS)
   tImageToRAS.MultiplyPoint(point3Image, point3RAS)
   tImageToRAS.MultiplyPoint(point4Image, point4RAS)  
   
   p1RAS = [point1RAS[0], point1RAS[1], point1RAS[2]]
   p2RAS = [point2RAS[0], point2RAS[1], point2RAS[2]]
   p3RAS = [point3RAS[0], point3RAS[1], point3RAS[2]]
   p4RAS = [point4RAS[0], point4RAS[1], point4RAS[2]]
   slicePoints.SetPoint(0, p1RAS)
   slicePoints.SetPoint(1, p2RAS)
   slicePoints.SetPoint(2, p3RAS)
   slicePoints.SetPoint(3, p4RAS)
   # # Add image texture.
   image = vtk.vtkImageData()
   image.DeepCopy(imageData)
   modelDisplayNode = snapshotModel.GetModelDisplayNode()
   modelDisplayNode.SetAndObserveTextureImageData(image)   
   
   snapshotTexture = slicer.vtkMRMLScalarVolumeNode()
   snapshotTexture.SetAndObserveImageData(image)
   snapshotTexture.SetName(name + "_Texture")
   slicer.mrmlScene.AddNode(snapshotTexture)
   snapshotTexture.CopyOrientation( image_RAS )
   
   snapshotTextureDisplayNode = slicer.vtkMRMLScalarVolumeDisplayNode()
   snapshotTextureDisplayNode.SetName(name + "_TextureDisplay")
   snapshotTextureDisplayNode.SetAutoWindowLevel(0);
   snapshotTextureDisplayNode.SetWindow(256);
   snapshotTextureDisplayNode.SetLevel(128);
   snapshotTextureDisplayNode.SetDefaultColorMap();
   slicer.mrmlScene.AddNode(snapshotTextureDisplayNode)
   
   snapshotTexture.AddAndObserveDisplayNodeID( snapshotTextureDisplayNode.GetID() )
   
   snapshotModel.SetAttribute( "TextureNodeID", snapshotTexture.GetID() )
   snapshotModelDisplayNode= snapshotModel.GetModelDisplayNode()
   snapshotModelDisplayNode.SetAndObserveTextureImageData( snapshotTexture.GetImageData() )
Beispiel #52
0
    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)
        self.logMessage(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")
Beispiel #53
0
    def computeSpline(self, spline, startVertexID, endVertexID, startPointPosition, endPointPosition, resolution):
        print ("compute spline")
        scene = slicer.mrmlScene

        dijkstra = vtk.vtkDijkstraGraphGeodesicPath()
        dijkstra.SetInputData(self.modelNode.GetPolyData())
        dijkstra.SetStartVertex(startVertexID)
        dijkstra.SetEndVertex(endVertexID)
        dijkstra.Update()

        #compute step size in according to resolution

        vertices = dijkstra.GetOutput().GetPoints()
        numVertices = vertices.GetNumberOfPoints()
        resStepSize = float(numVertices) / (float(resolution) - 1.0)# -2 because of start and end point

        print (numVertices)
        print (resolution)
        print (resStepSize)
        equidistantIndices = []

        curStep = 0
        for i in range(0, int(resolution)):
            curStep = (i * resStepSize) - 1
            equidistantIndices.append(int(curStep + 0.5))

        #create spline
        splinePoints = []
        points = vtk.vtkPoints()
        for index in equidistantIndices:
            print ("index")
            print (index)
            print ("position")
            position = [0, 0, 0]
            vertices.GetPoint(index, position)
            print (position)
            points.InsertNextPoint(position)
            splinePoints.append(position)

        spline.points = splinePoints

        parametricSpline = vtk.vtkParametricSpline()
        parametricSpline.SetPoints(points)

        functionSource = vtk.vtkParametricFunctionSource()
        functionSource.SetParametricFunction(parametricSpline)
        functionSource.Update()

        #create model node
        splineModel = slicer.vtkMRMLModelNode()
        splineModel.SetScene(scene)
        splineModel.SetName("splineModel-%i" % 1) #todo
        splineModel.SetAndObservePolyData(functionSource.GetOutput())

        #create display node
        splineModelDisplay = slicer.vtkMRMLModelDisplayNode()
        splineModelDisplay.SetColor(1, 0, 0)
        splineModelDisplay.SetOpacity(1)
        splineModelDisplay.SetLineWidth(4)
        splineModelDisplay.SliceIntersectionVisibilityOn()

        splineModelDisplay.SetScene(scene)
        scene.AddNode(splineModelDisplay)
        splineModel.SetAndObserveDisplayNodeID(splineModelDisplay.GetID())

        # add to scene
        splineModelDisplay.GetPolyData = functionSource.GetOutput()

        scene.AddNode(splineModel)

        splineModelTransform = slicer.vtkMRMLLinearTransformNode()
        splineModelTransform.SetName("SplineModelTransform-%i" % 1) # todo

        scene.AddNode(splineModelTransform)
Beispiel #54
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')
Beispiel #55
0
    def onCompute(self):
        slicer.app.processEvents()

        import time
        # Show the status bar
        self.progressBar.show()

        # Initilize various parameters
        self.bone_labels = np.fromstring(self.lineedit.text,
                                         dtype=int,
                                         sep=',')

        # Check to see if self.bone_labels is set to negative on and if so set to the default labels
        if self.bone_labels[0] == -1:
            # Use the minimum and maximum of the Ref_Bone_Slider (which is based on the minimum and maximum label in the first image)
            self.bone_labels = range(int(self.Ref_Bone_Slider.minimum),
                                     int(self.Ref_Bone_Slider.maximum) + 1)

        self.max_bone_label = np.max(self.bone_labels)

        # Find all the files in the input folder
        self.files = os.listdir(self.directory_path)

        # Sort the files to be in order now
        self.files.sort(key=self.alphanum_key)

        if self.num_files > len(self.files):
            self.num_files = len(self.files)

        # Initilize a list of file indicies
        if self.num_files == -1:
            self.file_list = range(0, len(self.files))
        else:
            self.file_list = range(0, int(self.num_files))

        # Initilize Python list to hold all of the polydata
        # One index for each bone label (ranges from 1 to 9)
        polydata_list = []

        for i in range(0, self.max_bone_label + 1):
            polydata_list.append([])

        # Load all of the images from the input folder
        images_list = []

        for curr_file in self.file_list:

            # Update the status bar
            self.progressBar.setValue(
                float(curr_file) / len(self.file_list) * 100 /
                10)  # Use 10% of the status bar for loading the images
            slicer.app.processEvents()
            slicer.util.showStatusMessage("Loading Images...")

            if self.files[curr_file][-3:] == 'nii':
                print(str('Running file number ' + str(curr_file)))

                # Load the nifti (.nii) or analyze image (.img/.hdr) using SimpleITK
                filename = os.path.join(self.directory_path,
                                        self.files[curr_file])
                image = self.load_image(filename)

                # It's upside-down when loaded, so add a flip filter
                if self.flip_image_vertically.checked == True:
                    imflip = vtk.vtkImageFlip()
                    try:
                        imflip.SetInputData(image.GetOutput())
                    except:
                        imflip.SetInputData(image)
                    imflip.SetFilteredAxis(1)
                    imflip.Update()
                    image = imflip.GetOutput()

                # If the images are flipped left/right so use a flip filter
                if self.flip_image_horizontally.checked == True:
                    imflip = vtk.vtkImageFlip()
                    try:
                        imflip.SetInputData(image.GetOutput())
                    except:
                        imflip.SetInputData(image)
                    imflip.SetFilteredAxis(0)
                    imflip.Update()
                    image = imflip.GetOutput()

                # Append the loaded image to the images_list
                images_list.append(image)

                # Temporarily push the image to Slicer (to have the correct class type for the model maker Slicer module)
                if self.debug_show_images.checked == True:
                    image = sitk.ReadImage(filename)
                    sitkUtils.PushToSlicer(image,
                                           str(curr_file),
                                           0,
                                           overwrite=True)
                    node = slicer.util.getNode(str(curr_file))

        # If there is a non .nii file in the folder the images_list will be shorter than file_list
        # Redefine the file_list here
        self.file_list = range(0, len(images_list))

        iter = 0  # For status bar

        # Extract the surface from each image (i.e. the polydata)
        for label in self.bone_labels:
            for curr_file in self.file_list:

                # Update the status bar (start at 10%)
                self.progressBar.setValue(
                    10 + float(iter) /
                    (len(self.bone_labels) * len(self.file_list)) * 100 /
                    5)  # Use 20% of the bar for this
                slicer.app.processEvents()
                iter = iter + 1
                slicer.util.showStatusMessage("Extracting Surfaces...")

                polydata = self.Extract_Surface(images_list[curr_file], label)
                polydata_list[label].append(polydata)

                # Create model node ("Extract_Shapes") and add to scene
                if self.show_extracted_shapes.checked == True:
                    Extract_Shapes = slicer.vtkMRMLModelNode()
                    Extract_Shapes.SetAndObservePolyData(polydata)
                    modelDisplay = slicer.vtkMRMLModelDisplayNode()
                    modelDisplay.SetSliceIntersectionVisibility(
                        True)  # Show in slice view
                    modelDisplay.SetVisibility(True)  # Show in 3D view
                    slicer.mrmlScene.AddNode(modelDisplay)
                    Extract_Shapes.SetAndObserveDisplayNodeID(
                        modelDisplay.GetID())
                    slicer.mrmlScene.AddNode(Extract_Shapes)

        # Save each registered bone separately?
        if self.Save_Extracted_Bones_Separately.checked == True:

            for label in self.bone_labels:
                for i in range(0, len(self.file_list)):
                    path = os.path.join(
                        self.output_directory_path,
                        'Bone_' + str(label) + '_position_' + str(i) + '.ply')
                    plyWriter = vtk.vtkPLYWriter()
                    plyWriter.SetFileName(path)
                    plyWriter.SetInputData(polydata_list[label][i])
                    plyWriter.Write()
                    print('Saved: ' + path)

        # If this is set to true, stop the computation after extracting and smoothing the bones
        if self.Skip_Registration.checked == True:

            # Set the status bar to 100%
            self.progressBar.setValue(100)

            slicer.app.processEvents()
            slicer.util.showStatusMessage("Skipping Registration Step...")

            # Hide the status bar
            self.progressBar.hide()

            # Reset the status message on bottom of 3D Slicer
            slicer.util.showStatusMessage(" ")

            return 0

        # Update the status bar (start at 30%)
        self.progressBar.setValue(30 + 20)  # Use 20% of the bar for this
        slicer.app.processEvents()
        slicer.util.showStatusMessage("Calculating Reference Shapes...")

        # Don't use the mean shapes
        # Use the bone shapes from volunteer 1 instead of the mean shape for each bone

        # Initialize a Python list to hold the reference shapes
        reference_shapes = []

        # One index for each bone label (ranges from 1 to 9)
        for i in range(0, self.max_bone_label + 1):
            reference_shapes.append([])

        # Get the bone shapes from the first volunteer and save them
        for label in self.bone_labels:
            reference_shapes[label].append(polydata_list[label][0])

        ######### Register the reference shape to each bone position #########

        iter_bar = 0  # For status bar

        for label in self.bone_labels:
            for i in range(0, len(self.file_list)):

                # Update the status bar (start at 50%)
                self.progressBar.setValue(
                    50 + float(iter_bar) /
                    (len(self.bone_labels) * len(self.file_list)) * 100 /
                    5)  # Use 20% of the bar for this
                slicer.app.processEvents()
                iter_bar = iter_bar + 1
                slicer.util.showStatusMessage(
                    "Registering Reference Shapes...")

                transformedSource = self.IterativeClosestPoint(
                    target=polydata_list[label][i],
                    source=reference_shapes[label][0])

                # Replace the surface of file i and label with the registered reference shape for that particular bone
                polydata_list[label][i] = transformedSource

        iter_bar = 0  # For status bar

        ######### Register the reference bone (usually the radius for the wrist) for all the volunteers together #########
        for label in self.bone_labels:
            for i in range(0, len(self.file_list)):

                # !! IMPORTANT !! Register the reference bone last (or else the bones afterwards will not register correctly)
                # Skip the reference label for now (register after all the other bones are registered)

                if label != self.ref_label:

                    # Update the status bar (start at 70%)
                    self.progressBar.setValue(
                        70 + float(iter_bar) /
                        (len(self.bone_labels) * len(self.file_list)) * 100 /
                        5)  # Use 20% of the bar for this
                    slicer.app.processEvents()
                    iter_bar = iter_bar + 1
                    slicer.util.showStatusMessage(
                        "Registering Radius Together...")

                    polydata_list[label][i] = self.IterativeClosestPoint(
                        target=polydata_list[self.ref_label][0],
                        source=polydata_list[self.ref_label][i],
                        reference=polydata_list[label][i])

        # Now register the reference label bones together
        for i in range(0, len(self.file_list)):
            polydata_list[self.ref_label][i] = self.IterativeClosestPoint(
                target=polydata_list[self.ref_label][0],
                source=polydata_list[self.ref_label][i],
                reference=polydata_list[self.ref_label][i])

        ######### Save the output #########

        # Should the reference bone be remove (i.e. not saved) in the final PLY surface file?
        if self.Remove_Ref_Bone.checked == True:
            index = np.argwhere(self.bone_labels == self.ref_label)
            self.bone_labels = np.delete(self.bone_labels, index)

        # Combine the surfaces of the wrist for each person and save as a .PLY file
        for i in range(0, len(self.file_list)):
            temp_combine_list = []

            # Update the status bar (start at 90%)
            self.progressBar.setValue(90 + float(i) / len(self.file_list) *
                                      100 / 10)  # Use 10% of the bar for this
            slicer.app.processEvents()
            iter_bar = iter_bar + 1
            slicer.util.showStatusMessage("Saving Output Surfaces...")

            total_points = [0]

            # Get all the bones in a Python list for volunteer 'i'
            for label in self.bone_labels:
                temp_combine_list.append(polydata_list[label][i])

                # Print the number of surface points for this bone
                num_points = polydata_list[label][i].GetNumberOfPoints()
                print("Bone " + str(label) + " points: " + str(num_points))

                total_points.append(total_points[-1] + num_points)

            print("Total Cumulative Points" + str(total_points))

            # Combined the surfaces in the list into a single polydata surface
            combined_polydata = self.Combine_Surfaces(temp_combine_list)

            # Create model node ("ICP_Result") and add to scene
            if self.show_registered_shapes.checked == True:
                ICP_Result = slicer.vtkMRMLModelNode()
                ICP_Result.SetAndObservePolyData(combined_polydata)
                modelDisplay = slicer.vtkMRMLModelDisplayNode()
                modelDisplay.SetSliceIntersectionVisibility(
                    True)  # Show in slice view
                modelDisplay.SetVisibility(True)  # Show in 3D view
                slicer.mrmlScene.AddNode(modelDisplay)
                ICP_Result.SetAndObserveDisplayNodeID(modelDisplay.GetID())
                slicer.mrmlScene.AddNode(ICP_Result)

            # Write the combined polydata surface to a .PLY file
            plyWriter = vtk.vtkPLYWriter()
            path = os.path.join(self.output_directory_path,
                                str(self.files[i][:-4]) + '_combined.ply')
            plyWriter.SetFileName(path)
            plyWriter.SetInputData(combined_polydata)
            plyWriter.Write()
            print('Saved: ' + path)

            # Save each registered bone separately as well?
            if self.Save_Registered_Bones_Separately.checked == True:

                for label in self.bone_labels:
                    path = os.path.join(
                        self.output_directory_path,
                        'Position_' + str(i) + '_bone_' + str(label) + '.ply')
                    plyWriter.SetFileName(path)
                    plyWriter.SetInputData(polydata_list[label][i])
                    plyWriter.Write()
                    print('Saved: ' + path)

        # Set the status bar to 100%
        self.progressBar.setValue(100)

        # Hide the status bar
        self.progressBar.hide()

        # Reset the status message on bottom of 3D Slicer
        slicer.util.showStatusMessage(" ")

        return 0
Beispiel #56
0
    def updateCurve(self):

        if self.AutomaticUpdate == False:
            return

        if self.SourceNode and self.DestinationNode:

            if self.SourceNode.GetNumberOfFiducials() < 2:
                if self.CurvePoly != None:
                    self.CurvePoly.Initialize()

                self.CurveLength = 0.0

            else:

                if self.CurvePoly == None:
                    self.CurvePoly = vtk.vtkPolyData()

                if self.DestinationNode.GetDisplayNodeID() == None:
                    modelDisplayNode = slicer.vtkMRMLModelDisplayNode()
                    modelDisplayNode.SetColor(self.ModelColor)
                    slicer.mrmlScene.AddNode(modelDisplayNode)
                    self.DestinationNode.SetAndObserveDisplayNodeID(
                        modelDisplayNode.GetID())

                if self.InterpolationMethod == 0:

                    if self.RingMode > 0:
                        self.nodeToPoly(self.SourceNode, self.CurvePoly, True)
                    else:
                        self.nodeToPoly(self.SourceNode, self.CurvePoly, False)

                elif self.InterpolationMethod == 1:  # Cardinal Spline

                    if self.RingMode > 0:
                        self.nodeToPolyCardinalSpline(self.SourceNode,
                                                      self.CurvePoly, True)
                    else:
                        self.nodeToPolyCardinalSpline(self.SourceNode,
                                                      self.CurvePoly, False)

                elif self.InterpolationMethod == 2:  # Hermite Spline

                    if self.RingMode > 0:
                        self.nodeToPolyHermiteSpline(self.SourceNode,
                                                     self.CurvePoly, True)
                    else:
                        self.nodeToPolyHermiteSpline(self.SourceNode,
                                                     self.CurvePoly, False)

                self.CurveLength = self.calculateLineLength(self.CurvePoly)

            tubeFilter = vtk.vtkTubeFilter()
            curvatureValues = vtk.vtkDoubleArray()

            if self.Curvature:
                ## If the curvature option is ON, calculate the curvature along the curve.
                (meanKappa, minKappa,
                 maxKappa) = self.computeCurvatures(self.CurvePoly,
                                                    curvatureValues)
                self.CurvePoly.GetPointData().AddArray(curvatureValues)
                self.curvatureMeanKappa = meanKappa
                self.curvatureMinKappa = minKappa
                self.curvatureMaxKappa = maxKappa
            else:
                self.curvatureMeanKappa = None
                self.curvatureMinKappa = None
                self.curvatureMaxKappa = None

            tubeFilter.SetInputData(self.CurvePoly)
            tubeFilter.SetRadius(self.TubeRadius)
            tubeFilter.SetNumberOfSides(20)
            tubeFilter.CappingOn()
            tubeFilter.Update()

            # self.DestinationNode.SetAndObservePolyData(tubeFilter.GetOutput())
            self.DestinationNode.SetAndObservePolyData(self.CurvePoly)
            self.DestinationNode.Modified()

            if self.DestinationNode.GetScene() == None:
                slicer.mrmlScene.AddNode(self.DestinationNode)

            displayNode = self.DestinationNode.GetDisplayNode()
            if displayNode:
                if self.Curvature:
                    displayNode.SetActiveScalarName('Curvature')
                else:
                    displayNode.SetActiveScalarName('')
    def runSegmentation(self, elList, volume, parentPath, deetoExe, models,
                        createVTK):
        ### CHECK that both the fiducials and ct volume have been selected
        if (len(elList) == 0):
            # notify error
            slicer.util.showStatusMessage("Error, no electrode list selected")
            return
        if (volume == None):
            # notify error
            slicer.util.showStatusMessage("Error, no volume selected")
            return

        ### COMPUTE THE THRESHOLD the 45% of points not null(0.0)
        im = volume.GetImageData()
        # linearize the 3D image in a vector
        vector = vtk.util.numpy_support.vtk_to_numpy(
            im.GetPointData().GetScalars())
        # eliminate 0.0 value from the vector
        n_vector = vector[vector != 0]
        # sort the intensity values
        n_vector.sort()
        # compute the threshold as the 45% of points not null
        threshold = n_vector[int(n_vector.size * 0.45)]

        ### CREATE A NEW FIDUCIAL LIST CALLED ...... [TODO]
        mlogic = slicer.modules.markups.logic()

        ###
        ### [TODO] Accrocchio, non so come cambiare questi parametri solo
        ### per il nodo corrente, invece che di default
        mlogic.SetDefaultMarkupsDisplayNodeTextScale(1.3)
        mlogic.SetDefaultMarkupsDisplayNodeGlyphScale(1.5)
        mlogic.SetDefaultMarkupsDisplayNodeColor(0.39, 0.78, 0.78)  # AZZURRO
        mlogic.SetDefaultMarkupsDisplayNodeSelectedColor(0.39, 1.0,
                                                         0.39)  # VERDONE

        fidNode = slicer.util.getNode(mlogic.AddNewFiducialNode("recon"))

        # Save the volume as has been modified
        self.tmpVolumeFile = parentPath + "/Tmp/tmp.nii.gz"
        self.saveNode(volume, self.tmpVolumeFile)

        # Set the parameters of the progess bar and show it
        self.pb.setRange(0, len(elList))
        self.pb.show()
        self.pb.setValue(0)
        slicer.app.processEvents()

        # For each electrode "e":
        for i in xrange(len(elList)):
            tFlag = "-l" if (elList[i].tailCheckBox.isChecked()
                             == True) else "-t"
            hFlag = "-h" if (elList[i].headCheckBox.isChecked()
                             == True) else "-e"

            # Construct the cmdLine to run the segmentation on "e"
            cmdLine = [str(deetoExe), '-s', str(threshold), '-ct', str(self.tmpVolumeFile), \
                       hFlag, str(-1 * elList[i].entry[0]), str(-1 * elList[i].entry[1]), \
                       str(elList[i].entry[2]), tFlag, \
                       str(-1 * elList[i].target[0]), str(-1 * elList[i].target[1]), \
                       str(elList[i].target[2]), '-m'] + \
                      map(str, models[elList[i].model.currentText][:-1])
            print cmdLine
            # RUN the command line cmdLine.
            # [NOTE] : I have used Popen since subprocess.check_output wont work at the moment
            # It Looks a problem of returning code from deetoS
            points = subprocess.Popen(
                cmdLine, stdout=subprocess.PIPE).communicate()[0].splitlines()
            # print points

            ### For each of the point returned by deeto we add it to the new markup fiducial
            name = elList[i].name.text
            for p in range(0, (len(points) - 1), 3):
                a = fidNode.AddFiducial(float(points[p]), float(points[p + 1]),
                                        float(points[p + 2]))
                fidNode.SetNthFiducialLabel(a, name + str((p / 3) + 1))

            ### For each electrode we create a line from the start point to the last + 3mm
            ### Look for two points p1 and p3 starting from p1 and p2 (first and last point segmented
            last = len(points) - 1
            p1 = [float(points[0]), float(points[1]), float(points[2])]
            p2 = [
                float(points[last - 2]),
                float(points[last - 1]),
                float(points[last])
            ]
            delta = math.sqrt(
                math.pow((p1[0] - p2[0]), 2) + math.pow((p1[1] - p2[1]), 2) +
                math.pow((p1[2] - p2[2]), 2))
            p3 = [0.0, 0.0, 0.0]
            p3[0] = p2[0] + (p2[0] - p1[0]) / delta * 3  # distance 3mm
            p3[1] = p2[1] + (p2[1] - p1[1]) / delta * 3  # distance 3mm
            p3[2] = p2[2] + (p2[2] - p1[2]) / delta * 3  # distance 3mm
            if createVTK.checked:
                ### Create a vtk line
                lineSource = vtk.vtkLineSource()
                lineSource.SetPoint1(p1)
                lineSource.SetPoint2(p3)
                lineSource.SetResolution(100)  ## why?
                lineSource.Update()
                ### Create a model of the line to add to the scene
                model = slicer.vtkMRMLModelNode()
                model.SetName(name + "_direction")
                model.SetAndObservePolyData(lineSource.GetOutput())
                modelDisplay = slicer.vtkMRMLModelDisplayNode()
                modelDisplay.SetSliceIntersectionVisibility(
                    True)  # Hide in slice view
                modelDisplay.SetVisibility(True)  # Show in 3D view
                modelDisplay.SetColor(1, 0, 0)
                modelDisplay.SetLineWidth(2)
                slicer.mrmlScene.AddNode(modelDisplay)
                model.SetAndObserveDisplayNodeID(modelDisplay.GetID())
                slicer.mrmlScene.AddNode(model)

            # Lock all markup
            mlogic.SetAllMarkupsLocked(fidNode, True)

            # update progress bar
            self.pb.setValue(i + 1)
            slicer.app.processEvents()

        self.pb.hide()