Beispiel #1
0
    def generateGridPolyDataTriangular(self):
        polyDataCombiner = vtk.vtkAppendPolyData()

        lowerHorizontalBoundMm = self.evaluateLowerHorizontalBoundMm()
        upperHorizontalBoundMm = self.evaluateUpperHorizontalBoundMm()

        lowerVerticalBoundMm = self.evaluateLowerVerticalBoundMm()
        upperVerticalBoundMm = self.evaluateUpperVerticalBoundMm()

        # traditional 'for' loops would be very nice here... :-/
        yMm = lowerVerticalBoundMm
        while (yMm <= upperVerticalBoundMm):
            # determine whether to offset in horizontal axis -
            # this makes the triangular pattern if done on odd rows only
            offsetMm = 0
            oddRow = (round(yMm / self.gridSpacingVerticalMm) % 2 == 1)
            if oddRow:
                offsetMm = self.gridSpacingHorizontalMm / 2.0
            xMm = lowerHorizontalBoundMm + offsetMm
            while (xMm <= upperHorizontalBoundMm):
                cylinderPolyData = self.generateCylinderPolyData(xMm, yMm)
                polyDataCombiner.AddInputData(cylinderPolyData)
                xMm = xMm + self.gridSpacingHorizontalMm
            yMm = yMm + self.gridSpacingVerticalMm

        polyDataCombiner.Update()
        gridPolyData = polyDataCombiner.GetOutput()
        return gridPolyData
  def generateGridPolyDataTriangular(self):
    polyDataCombiner = vtk.vtkAppendPolyData()
    
    lowerHorizontalBoundMm = self.evaluateLowerHorizontalBoundMm()
    upperHorizontalBoundMm = self.evaluateUpperHorizontalBoundMm()
    
    lowerVerticalBoundMm = self.evaluateLowerVerticalBoundMm()
    upperVerticalBoundMm = self.evaluateUpperVerticalBoundMm()

    # traditional 'for' loops would be very nice here... :-/
    yMm = lowerVerticalBoundMm
    while (yMm <= upperVerticalBoundMm):
      # determine whether to offset in horizontal axis -
      # this makes the triangular pattern if done on odd rows only
      offsetMm = 0
      oddRow = (round(yMm / self.gridSpacingVerticalMm) % 2 == 1)
      if oddRow:
        offsetMm = self.gridSpacingHorizontalMm / 2.0
      xMm = lowerHorizontalBoundMm + offsetMm
      while (xMm <= upperHorizontalBoundMm):
        cylinderPolyData = self.generateCylinderPolyData(xMm,yMm)
        polyDataCombiner.AddInputData(cylinderPolyData)
        xMm = xMm + self.gridSpacingHorizontalMm
      yMm = yMm + self.gridSpacingVerticalMm
      
    polyDataCombiner.Update()
    gridPolyData = polyDataCombiner.GetOutput()
    return gridPolyData
Beispiel #3
0
  def createNeedleModelNode(self, name):

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

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

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

    apd = vtk.vtkAppendPolyData()

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

    self.scene.AddNode(locatorModel)
    locatorModel.SetScene(self.scene);
    locatorModel.SetName(name)
    
    locatorDisp = locatorModel.GetDisplayNodeID()
    if locatorDisp == None:
      locatorDisp = self.scene.CreateNodeByClass('vtkMRMLModelDisplayNode')
      self.scene.AddNode(locatorDisp)
      locatorDisp.SetScene(self.scene)
      locatorModel.SetAndObserveDisplayNodeID(locatorDisp.GetID());
      
    color = [0, 0, 0]
    color[0] = 0.5
    color[1] = 0.5
    color[2] = 1.0
    locatorDisp.SetColor(color)
    
    return locatorModel.GetID()
Beispiel #4
0
    def updateTipModelNode(self, tipModelNode, poly, p0, pe, radius, color,
                           opacity):

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

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

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

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

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

        apd = vtk.vtkAppendPolyData()

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

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

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

        tipDispNode = self.scene.GetNodeByID(tipDispID)

        prevState = tipDispNode.StartModify()
        tipDispNode.SetColor(color)
        tipDispNode.SetOpacity(opacity)
        tipDispNode.SliceIntersectionVisibilityOn()
        tipDispNode.SetSliceDisplayModeToIntersection()
        tipDispNode.EndModify(prevState)
  def JoinBoundaryPoints( self, hullPoints1, hullPoints2, offset ):

    if ( hullPoints1.GetNumberOfPoints() != hullPoints2.GetNumberOfPoints() ):
      return
    
    joiningAppend = vtk.vtkAppendPolyData()
    numPoints = hullPoints1.GetNumberOfPoints()
  
    for i in range( 0, numPoints ):
    
      currPointsForSurface = vtk.vtkPoints()
    
      point1 = [ 0, 0, 0 ]
      hullPoints1.GetPoint( ( i - offset )% numPoints, point1 )
      currPointsForSurface.InsertNextPoint( point1[ 0 ], point1[ 1 ], point1[ 2 ] )
    
      point2 = [ 0, 0, 0 ]
      hullPoints2.GetPoint( ( - i ) % numPoints, point2 )
      currPointsForSurface.InsertNextPoint( point2[ 0 ], point2[ 1 ], point2[ 2 ] )
    
      # Observe that the deep is flipped from the surface
      # Must proceed in opposite orders
      point3 = [ 0, 0, 0 ]
      hullPoints1.GetPoint( ( i + 1 - offset ) % numPoints, point3 )
      currPointsForSurface.InsertNextPoint( point3[ 0 ], point3[ 1 ], point3[ 2 ] )
    
      point4 = [ 0, 0, 0 ]
      hullPoints2.GetPoint( ( - ( i + 1 ) ) % numPoints, point4 )
      currPointsForSurface.InsertNextPoint( point4[ 0 ], point4[ 1 ], point4[ 2 ] )
      
      
      # We know what the triangles should look like, so create them manually
      # Note: The order here is important - ensure the triangles face the correct way
      triangle1 = vtk.vtkTriangle()
      triangle1.GetPointIds().SetId( 0, 0 )
      triangle1.GetPointIds().SetId( 1, 1 )
      triangle1.GetPointIds().SetId( 2, 2 )
      
      triangle2 = vtk.vtkTriangle()
      triangle2.GetPointIds().SetId( 0, 3 )
      triangle2.GetPointIds().SetId( 1, 2 )
      triangle2.GetPointIds().SetId( 2, 1 )
      
      triangles = vtk.vtkCellArray()
      triangles.InsertNextCell( triangle1 )
      triangles.InsertNextCell( triangle2 )
      
      currPolyDataForSurface = vtk.vtkPolyData()
      currPolyDataForSurface.SetPoints( currPointsForSurface )
      currPolyDataForSurface.SetPolys( triangles )
         
      joiningAppend.AddInputData( currPolyDataForSurface )
    
    joiningAppend.Update()
    return joiningAppend.GetOutput()
  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 #7
0
    def Combine_Surfaces(self, polydata_list):
        # Combine some number of polydata together
        # For example, useful for combining all the bones of a joint back together for saving to a .PLY file

        # Append the meshes together
        appendFilter = vtk.vtkAppendPolyData()

        # Loop through each surface in the list of polydata and input into the filter
        for i in range(0, len(polydata_list)):
            appendFilter.AddInputData(polydata_list[i])

        # Update the combinded polydata filter
        appendFilter.Update()

        # Get the output of the filter (i.e. combined_polydata holds the combined surfaces)
        combined_polydata = appendFilter.GetOutput()

        return combined_polydata
Beispiel #8
0
    def generateGridPolyDataRectangular(self):
        polyDataCombiner = vtk.vtkAppendPolyData()

        lowerHorizontalBoundMm = self.evaluateLowerHorizontalBoundMm()
        upperHorizontalBoundMm = self.evaluateUpperHorizontalBoundMm()

        lowerVerticalBoundMm = self.evaluateLowerVerticalBoundMm()
        upperVerticalBoundMm = self.evaluateUpperVerticalBoundMm()

        # traditional 'for' loops would be very nice here... :-/
        yMm = lowerVerticalBoundMm
        while (yMm <= upperVerticalBoundMm):
            xMm = lowerHorizontalBoundMm
            while (xMm <= upperHorizontalBoundMm):
                cylinderPolyData = self.generateCylinderPolyData(xMm, yMm)
                polyDataCombiner.AddInputData(cylinderPolyData)
                xMm = xMm + self.gridSpacingHorizontalMm
            yMm = yMm + self.gridSpacingVerticalMm

        polyDataCombiner.Update()
        gridPolyData = polyDataCombiner.GetOutput()
        return gridPolyData
  def generateGridPolyDataRectangular(self):
    polyDataCombiner = vtk.vtkAppendPolyData()
    
    lowerHorizontalBoundMm = self.evaluateLowerHorizontalBoundMm()
    upperHorizontalBoundMm = self.evaluateUpperHorizontalBoundMm()
    
    lowerVerticalBoundMm = self.evaluateLowerVerticalBoundMm()
    upperVerticalBoundMm = self.evaluateUpperVerticalBoundMm()

    # traditional 'for' loops would be very nice here... :-/
    yMm = lowerVerticalBoundMm
    while (yMm <= upperVerticalBoundMm):
      xMm = lowerHorizontalBoundMm    
      while (xMm <= upperHorizontalBoundMm):
        cylinderPolyData = self.generateCylinderPolyData(xMm,yMm)
        polyDataCombiner.AddInputData(cylinderPolyData)
        xMm = xMm + self.gridSpacingHorizontalMm
      yMm = yMm + self.gridSpacingVerticalMm
      
    polyDataCombiner.Update()
    gridPolyData = polyDataCombiner.GetOutput()
    return gridPolyData
Beispiel #10
0
  def createNeedleModelNode(self, name,index):
    
    locatorModel = self.scene.CreateNodeByClass('vtkMRMLModelNode')
    
    # Cylinder represents the locator stick
    cylinder = vtk.vtkCylinderSource()
    cylinder.SetRadius(1.5)
    cylinder.SetHeight(100)
    cylinder.SetCenter(0, 0, 0)
    cylinder.Update()
    
    # Rotate cylinder
    tfilter = vtk.vtkTransformPolyDataFilter()
    trans =   vtk.vtkTransform()
    trans.RotateX(90.0)
    trans.Translate(0.0, -50.0, 0.0)
    trans.Update()
    if vtk.VTK_MAJOR_VERSION <= 5:
      tfilter.SetInput(cylinder.GetOutput())
    else:
      tfilter.SetInputConnection(cylinder.GetOutputPort())
    tfilter.SetTransform(trans)
    tfilter.Update()
    
    # Sphere represents the locator tip
    sphere = vtk.vtkSphereSource()
    sphere.SetRadius(3.0)
    sphere.SetCenter(0, 0, 0)
    sphere.Update()
    
    apd = vtk.vtkAppendPolyData()
    
    if vtk.VTK_MAJOR_VERSION <= 5:
      apd.AddInput(sphere.GetOutput())
      apd.AddInput(tfilter.GetOutput())
    else:
      apd.AddInputConnection(sphere.GetOutputPort())
      apd.AddInputConnection(tfilter.GetOutputPort())
    apd.Update()
    
    locatorModel.SetAndObservePolyData(apd.GetOutput());
    
    self.scene.AddNode(locatorModel)
    locatorModel.SetScene(self.scene);
    needleName = "Needle_%s" % name
    locatorModel.SetName(needleName)
    
    locatorDisp = locatorModel.GetDisplayNodeID()
    if locatorDisp == None:
      locatorDisp = self.scene.CreateNodeByClass('vtkMRMLModelDisplayNode')
      self.scene.AddNode(locatorDisp)
      locatorDisp.SetScene(self.scene)
      locatorModel.SetAndObserveDisplayNodeID(locatorDisp.GetID());

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

    return locatorModel.GetID()
    print "Computing queries"
    evaluated_queries = tract_querier.eval_queries(
        query_file_body,
        tractography_spatial_indexing,
    )
    
    query_names = evaluated_queries.keys()
    print query_names
    if options.query_selection != '':
        selected_queries = set(options.query_selection.lower().split(','))
        query_names = list(set(query_names) & set(selected_queries))

    query_names.sort()

    print 'save_query'
    polyDataOut=vtk.vtkAppendPolyData()
    for query_name in query_names:
        tr_out_temp=save_query( query_name, tr, options, evaluated_queries)
        if tr_out_temp is not None:
             tr_polydata=tracts_to_vtkPolyData64(tr_out_temp)
             polyDataOut.AddInput(tr_polydata)
    updateOutputNode(polyDataOut.GetOutput())
    return   

def vtkMatrix_2_array(m):
    import numpy
    out=numpy.zeros(shape=(4,4))
    for i in range(4):
        for j in range(4):
             out[i][j]=m.GetElement(i,j)
    return out
    print "Computing queries"
    evaluated_queries = tract_querier.eval_queries(
        query_file_body,
        tractography_spatial_indexing,
    )

    query_names = evaluated_queries.keys()
    print query_names
    if options.query_selection != '':
        selected_queries = set(options.query_selection.lower().split(','))
        query_names = list(set(query_names) & set(selected_queries))

    query_names.sort()

    print 'save_query'
    polyDataOut = vtk.vtkAppendPolyData()
    for query_name in query_names:
        tr_out_temp = save_query(query_name, tr, options, evaluated_queries)
        if tr_out_temp is not None:
            tr_polydata = tracts_to_vtkPolyData64(tr_out_temp)
            polyDataOut.AddInput(tr_polydata)
    updateOutputNode(polyDataOut.GetOutput())
    return


def vtkMatrix_2_array(m):
    import numpy
    out = numpy.zeros(shape=(4, 4))
    for i in range(4):
        for j in range(4):
            out[i][j] = m.GetElement(i, j)
Beispiel #13
0
# This module was tested on 3D Slicer version 4.3.1
  def visualNeedlePath(self, pos, pointOnTemplateRAS):
    if type(pointOnTemplateRAS) == list:
      pass
    elif type(pointOnTemplateRAS) == int:
      pointOnTemplateRAS = self.templateRAS[pointOnTemplateRAS]

    self.pathModelNode = slicer.mrmlScene.GetNodeByID(self.needlePathModelNodeID)
    if self.pathModelNode == None:
      self.pathModelNode = slicer.vtkMRMLModelNode()
      self.pathModelNode.SetName('AngulatedNeedlePath')
      slicer.mrmlScene.AddNode(self.pathModelNode)
      self.needlePathModelNodeID = self.pathModelNode.GetID()

      self.dnodeSelectedPath = slicer.vtkMRMLModelDisplayNode()
      self.dnodeSelectedPath.SetColor(0, 1, 1)
      slicer.mrmlScene.AddNode(self.dnodeSelectedPath)
      self.pathModelNode.SetAndObserveDisplayNodeID(self.dnodeSelectedPath.GetID())

    pathModelAppend = vtk.vtkAppendPolyData()

    tempLineSource = vtk.vtkLineSource()
    tempLineSource.SetPoint1(pos)  # target in RAS
    tempLineSource.SetPoint2(pointOnTemplateRAS)  # point on template in RAS

    tempTubeFilter = vtk.vtkTubeFilter()
    tempTubeFilter.SetInputConnection(tempLineSource.GetOutputPort())
    tempTubeFilter.SetRadius(1.0)
    tempTubeFilter.SetNumberOfSides(18)
    tempTubeFilter.CappingOn()
    tempTubeFilter.Update()

    self.setModelSliceIntersectionVisibilityByID(self.needlePathModelNodeID, 1)

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

    pathModelAppend.Update()
    self.pathModelNode.SetAndObservePolyData(pathModelAppend.GetOutput())


    #
    # Reslice along with the selected needle
    #

    print "(target) pos: ", pos
    print "pointOnTemplateRAS: ", pointOnTemplateRAS

    R = pointOnTemplateRAS[0]
    A = pointOnTemplateRAS[1]
    S = pointOnTemplateRAS[2]

    deltaR = pos[0] - R
    deltaA = pos[1] - A
    deltaS = pos[2] - S

    pathVector = numpy.array([deltaR, deltaA, deltaS])
    tR = numpy.array([1.0, 0, 0])

    vectorA = numpy.cross(pathVector, tR)
    vectorS = numpy.cross(pathVector, vectorA)


    pathVectorNorm = numpy.linalg.norm(pathVector)
    vectorANorm = numpy.linalg.norm(vectorA)
    vectorSNorm = numpy.linalg.norm(vectorS)

    matrix = vtk.vtkMatrix4x4()
    matrix.Identity()

    ## TODO: if pathVector is parallel to R
    matrix.SetElement(0, 0, pathVector[0]/pathVectorNorm)
    matrix.SetElement(1, 0, pathVector[1]/pathVectorNorm)
    matrix.SetElement(2, 0, pathVector[2]/pathVectorNorm)

    matrix.SetElement(0, 1, vectorA[0]/vectorANorm)
    matrix.SetElement(1, 1, vectorA[1]/vectorANorm)
    matrix.SetElement(2, 1, vectorA[2]/vectorANorm)

    matrix.SetElement(0, 2, vectorS[0]/vectorSNorm)
    matrix.SetElement(1, 2, vectorS[1]/vectorSNorm)
    matrix.SetElement(2, 2, vectorS[2]/vectorSNorm)

    matrix.SetElement(0, 3, R)
    matrix.SetElement(1, 3, A)
    matrix.SetElement(2, 3, S)


    selectNeedleNode = slicer.mrmlScene.GetNodeByID(self.selectNeedleNodeID)
    if selectNeedleNode == None:
      selectNeedleNode = slicer.vtkMRMLLinearTransformNode()
      selectNeedleNode.SetName('SelectedNeedle')
      slicer.mrmlScene.AddNode(selectNeedleNode)
      self.selectNeedleNodeID = selectNeedleNode.GetID()

    selectNeedleNode.SetAndObserveMatrixTransformToParent(matrix)

    modelNodes = slicer.mrmlScene.GetNodesByClass("vtkMRMLModelNode")
    for index in range(modelNodes.GetNumberOfItems()):
      indexNode = modelNodes.GetItemAsObject(index)
      if indexNode.GetTransformNodeID() == selectNeedleNode.GetID():
        indexNode.SetDisplayVisibility(1)
        self.selectNeedleModelNode = indexNode
        print indexNode.GetID()

    red = slicer.mrmlScene.GetNodeByID("vtkMRMLSliceNodeRed")
    yellow = slicer.mrmlScene.GetNodeByID("vtkMRMLSliceNodeYellow")
    green = slicer.mrmlScene.GetNodeByID("vtkMRMLSliceNodeGreen")

##   Changed by yz, Sep/25
##   If 3D Slicer includes the extension "SlicerIGT", uncomment the below code

#    vrdLogic = slicer.modules.volumereslicedriver.logic()
#    redDriver = vrdLogic.SetDriverForSlice(selectNeedleNode.GetID(), red)
#    redMode = vrdLogic.SetModeForSlice(vrdLogic.MODE_INPLANE, red)
#    yellowDriver = vrdLogic.SetDriverForSlice(selectNeedleNode.GetID(), yellow)
#    yellowMode = vrdLogic.SetModeForSlice(vrdLogic.MODE_INPLANE90, yellow)
#    greenDriver = vrdLogic.SetDriverForSlice(selectNeedleNode.GetID(), green)
#    greenMode = vrdLogic.SetModeForSlice(vrdLogic.MODE_TRANSVERSE, green)
#    vrdLogic.Modified()

    return pointOnTemplateRAS
Beispiel #15
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 #16
0
    def createNeedleModelNode(self, name):

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

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

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

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

        apd = vtk.vtkAppendPolyData()

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

        locatorModel.SetAndObservePolyData(apd.GetOutput())

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

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

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

        return locatorModel.GetID()
  def createTemplateModel(self):
    self.templatePathVectors = []
    self.templatePathOrigins = []

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

      dnode = slicer.vtkMRMLModelDisplayNode()
      slicer.mrmlScene.AddNode(dnode)
      tempModelNode.SetAndObserveDisplayNodeID(dnode.GetID())
      self.modelNodetag = tempModelNode.AddObserver(slicer.vtkMRMLTransformableNode.TransformModifiedEvent,
                                                    self.onTemplateTransformUpdated)

    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()
      tempModelNode.SetAndObservePolyData(tempModelAppend.GetOutput())
  def run( self, markupNode, depth, fitPlane, flip ):
    """
    Run the actual algorithm
    """
    
    # Get all of the fiducial nodes and convert to vtkPoints
    points = vtk.vtkPoints()
    
    for i in range( 0, markupNode.GetNumberOfFiducials() ):
      currentCoordinates = [ 0, 0, 0 ]
      markupNode.GetNthFiducialPosition( i, currentCoordinates )
      points.InsertNextPoint( currentCoordinates )
      
    # Check that there is non-zero range in all coordinate directions
    pointsBounds = [ 0, 0, 0, 0, 0, 0 ]
    points.GetBounds( pointsBounds )
    if ( pointsBounds[0] == pointsBounds [1] or pointsBounds[2] == pointsBounds [3] or pointsBounds[4] == pointsBounds [5] ):
      print "Tissue Model Creator: Points have no extent in one or more coordinate directions."
      return False
      
    # Create a polydata object from the points
    # The reversiness doesn't matter - we will fix it later if it os wrong
    if ( fitPlane ):
      surfacePolyData = self.PointsToPlanePolyData( points, True )
    else:
      surfacePolyData = self.PointsToSurfacePolyData( points, True )
      
    surfaceCleaner = vtk.vtkCleanPolyData()
    surfaceCleaner.SetInputData( surfacePolyData )
    surfaceCleaner.Update()
    surfacePolyData = surfaceCleaner.GetOutput()
    
    mean = self.CalculateMean( points )
    
    surfaceBase = [ 0, 0, 0 ]
    surfaceDir1 = [ 0, 0, 0 ]
    surfaceDir2 = [ 0, 0, 0 ]
    surfaceNormal = [ 0, 0, 0 ]
    self.CalculatePlane( surfacePolyData.GetPoints(), surfaceBase, surfaceDir1, surfaceDir2, surfaceNormal )
    
    if ( flip == True ):
      surfaceNormal[ 0 ] = - surfaceNormal[ 0 ]
      surfaceNormal[ 1 ] = - surfaceNormal[ 1 ]
      surfaceNormal[ 2 ] = - surfaceNormal[ 2 ]
    
    extremePointIndex = self.FindExtremePoint( surfacePolyData.GetPoints(), surfaceBase, surfaceNormal )
    reverse = self.ReverseNormals( extremePointIndex, surfacePolyData, surfaceNormal )
    
    # Reverse the normals if necessary
    reverseFilter = vtk.vtkReverseSense()
    reverseFilter.SetInputData( surfacePolyData )
    reverseFilter.SetReverseCells( reverse )
    reverseFilter.SetReverseNormals( reverse )
    reverseFilter.Update()
    surfacePolyData = reverseFilter.GetOutput()
    
    untransDeepPolyData = vtk.vtkPolyData()
    untransDeepPolyData.DeepCopy( surfacePolyData )
    
    # Make the normals opposite the surface's normals
    reverseFilter = vtk.vtkReverseSense()
    reverseFilter.SetInputData( untransDeepPolyData )
    reverseFilter.SetReverseCells( True )
    reverseFilter.SetReverseNormals( True )
    reverseFilter.Update()
    untransDeepPolyData = reverseFilter.GetOutput()
    
    deepTransform = vtk.vtkTransform()
    deepTransform.Translate( depth * surfaceNormal[0], depth * surfaceNormal[1], depth * surfaceNormal[2] )  
    deepTransformFilter = vtk.vtkTransformPolyDataFilter()
    deepTransformFilter.SetInputData( untransDeepPolyData )
    deepTransformFilter.SetTransform( deepTransform )
    deepTransformFilter.Update()
    
    deepPolyData = deepTransformFilter.GetOutput()

    
    surfaceHullPoints = self.GetBoundaryPoints( surfacePolyData )
    
    deepHullPoints = self.GetBoundaryPoints( deepPolyData )
    
    # Apparently, the joining needs an offset for the plane, but not for the surface reconstruction
    if ( fitPlane ):
      jointHullPolyData = self.JoinBoundaryPoints( surfaceHullPoints, deepHullPoints, 1 )
    else:
      jointHullPolyData = self.JoinBoundaryPoints( surfaceHullPoints, deepHullPoints, 0 )
    
    
    # Append all of the polydata together
    tissuePolyDataAppend = vtk.vtkAppendPolyData()
    tissuePolyDataAppend.AddInputData( surfacePolyData )
    tissuePolyDataAppend.AddInputData( deepPolyData )
    tissuePolyDataAppend.AddInputData( jointHullPolyData )   
    tissuePolyDataAppend.Update()

    # Clean up so the surface is closed
    tissueCleaner = vtk.vtkCleanPolyData()
    tissueCleaner.SetInputData( tissuePolyDataAppend.GetOutput() )
    tissueCleaner.Update()
    
    tissueModelPolyData = tissueCleaner.GetOutput()
    
    # Add the data to a model 
    tissueModel = slicer.mrmlScene.CreateNodeByClass( "vtkMRMLModelNode" )
    slicer.mrmlScene.AddNode( tissueModel )
    tissueModel.SetName( "TissueModel" )
    tissueModel.SetAndObservePolyData( tissueModelPolyData )    
    tissueModel.SetScene( slicer.mrmlScene )
    
    # Finally display the model
    tissueModelDisplay = slicer.mrmlScene.CreateNodeByClass( "vtkMRMLModelDisplayNode" )
    slicer.mrmlScene.AddNode( tissueModelDisplay )
    tissueModel.SetAndObserveDisplayNodeID( tissueModelDisplay.GetID() )
    tissueModelDisplay.SetScene( slicer.mrmlScene )
    tissueModelDisplay.SetInputPolyDataConnection( tissueModel.GetPolyDataConnection() )


    # Check to make sure the model is a closed surface
    edgesFilter = vtk.vtkFeatureEdges()
    edgesFilter.FeatureEdgesOff()
    edgesFilter.BoundaryEdgesOn()
    edgesFilter.NonManifoldEdgesOn()
    edgesFilter.SetInputData( tissueModel.GetPolyData() )
    edgesFilter.Update()
    
    if ( edgesFilter.GetOutput().GetNumberOfCells() != 0 ):
      print "Tissue Model Creator: Surface is not closed."
      return False
      
    return True