コード例 #1
0
    def pathToPoly(self, path, poly):
        points = vtk.vtkPoints()
        cellArray = vtk.vtkCellArray()

        points = vtk.vtkPoints()
        poly.SetPoints(points)

        lines = vtk.vtkCellArray()
        poly.SetLines(lines)

        linesIDArray = lines.GetData()
        linesIDArray.Reset()
        linesIDArray.InsertNextTuple1(0)

        polygons = vtk.vtkCellArray()
        poly.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)
コード例 #2
0
ファイル: CurveMaker.py プロジェクト: tokjun/CurveMaker
  def pathToPoly(self, path, poly):
    points = vtk.vtkPoints()
    cellArray = vtk.vtkCellArray()

    points = vtk.vtkPoints()
    poly.SetPoints(points)

    lines = vtk.vtkCellArray()
    poly.SetLines(lines)

    linesIDArray = lines.GetData()
    linesIDArray.Reset()
    linesIDArray.InsertNextTuple1(0)
    
    polygons = vtk.vtkCellArray()
    poly.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)
コード例 #3
0
  def createGlyph(self):
    self.polyData = vtk.vtkPolyData()
    points = vtk.vtkPoints()
    lines = vtk.vtkCellArray()
    self.polyData.SetPoints( points )
    self.polyData.SetLines( lines )
    prevPoint = None
    firstPoint = None

    for x,y in ((0,0),)*4:
      p = points.InsertNextPoint( x, y, 0 )
      if prevPoint != None:
        idList = vtk.vtkIdList()
        idList.InsertNextId( prevPoint )
        idList.InsertNextId( p )
        self.polyData.InsertNextCell( vtk.VTK_LINE, idList )
      prevPoint = p
      if firstPoint == None:
        firstPoint = p

    # make the last line in the polydata
    idList = vtk.vtkIdList()
    idList.InsertNextId( p )
    idList.InsertNextId( firstPoint )
    self.polyData.InsertNextCell( vtk.VTK_LINE, idList )
コード例 #4
0
 def performPostProcessing(self, snrThreshold, distanceMinimumValue, distanceMaximumValue): 
   # Create new vtkPolyData
   newPoints = vtk.vtkPoints()
   newVertices = vtk.vtkCellArray()               
   newPolyData = vtk.vtkPolyData()
   newPolyData.SetPoints(newPoints)
   newPolyData.SetVerts(newVertices)
   colorArray = vtk.vtkDoubleArray()
   colorArray.SetNumberOfComponents(4)
   colorArray.SetName('Colors')
   newPolyData.GetPointData().SetScalars(colorArray)   
   # Filter accordingly to the input parameters
   recordedDataBufferFiltered = []    
   for idx in range(len(self.recordedDataBuffer)):
     d = self.recordedDataBuffer[idx][3]
     snr = self.recordedDataBuffer[idx][4]
     if (snr > snrThreshold and
         d < distanceMaximumValue and       
         d > distanceMinimumValue):
         recordedDataBufferFiltered.append(self.recordedDataBuffer[idx])   
         self.addPointToPolyData(newPolyData, self.recordedDataBuffer[idx][0:3])
   # Update recorded model and buffer
   self.recordedModelNode.GetPolyData().DeepCopy(newPolyData)     
   self.recordedModelNode.GetPolyData().Modified()  
   self.recordedDataBuffer = recordedDataBufferFiltered
コード例 #5
0
ファイル: RectangleEffect.py プロジェクト: steaff/Slicer
  def createGlyph(self):
    self.polyData = vtk.vtkPolyData()
    points = vtk.vtkPoints()
    lines = vtk.vtkCellArray()
    self.polyData.SetPoints( points )
    self.polyData.SetLines( lines )
    prevPoint = None
    firstPoint = None

    for x,y in ((0,0),)*4:
      p = points.InsertNextPoint( x, y, 0 )
      if prevPoint != None:
        idList = vtk.vtkIdList()
        idList.InsertNextId( prevPoint )
        idList.InsertNextId( p )
        self.polyData.InsertNextCell( vtk.VTK_LINE, idList )
      prevPoint = p
      if firstPoint == None:
        firstPoint = p

    # make the last line in the polydata
    idList = vtk.vtkIdList()
    idList.InsertNextId( p )
    idList.InsertNextId( firstPoint )
    self.polyData.InsertNextCell( vtk.VTK_LINE, idList )
コード例 #6
0
ファイル: CurveMaker.py プロジェクト: tokjun/CurveMaker
  def nodeToPolyCardinalSpline(self, sourceNode, outputPoly, closed=False):

    nOfControlPoints = sourceNode.GetNumberOfFiducials()
    pos = [0.0, 0.0, 0.0]

    # One spline for each direction.
    aSplineX = vtk.vtkCardinalSpline()
    aSplineY = vtk.vtkCardinalSpline()
    aSplineZ = vtk.vtkCardinalSpline()

    if closed:
      aSplineX.ClosedOn()
      aSplineY.ClosedOn()
      aSplineZ.ClosedOn()
    else:
      aSplineX.ClosedOff()
      aSplineY.ClosedOff()
      aSplineZ.ClosedOff()

    for i in range(0, nOfControlPoints):
      sourceNode.GetNthFiducialPosition(i, pos)
      aSplineX.AddPoint(i, pos[0])
      aSplineY.AddPoint(i, pos[1])
      aSplineZ.AddPoint(i, pos[2])
    
    # Interpolate x, y and z by using the three spline filters and
    # create new points
    nInterpolatedPoints = (self.interpResolution+2)*(nOfControlPoints-1) # One section is devided into self.interpResolution segments
    points = vtk.vtkPoints()
    r = [0.0, 0.0]
    aSplineX.GetParametricRange(r)
    t = r[0]
    p = 0
    tStep = (nOfControlPoints-1.0)/(nInterpolatedPoints-1.0)
    nOutputPoints = 0

    if closed:
      while t < r[1]+1.0:
        points.InsertPoint(p, aSplineX.Evaluate(t), aSplineY.Evaluate(t), aSplineZ.Evaluate(t))
        t = t + tStep
        p = p + 1
      ## Make sure to close the loop
      points.InsertPoint(p, aSplineX.Evaluate(r[0]), aSplineY.Evaluate(r[0]), aSplineZ.Evaluate(r[0]))
      p = p + 1
      points.InsertPoint(p, aSplineX.Evaluate(r[0]+tStep), aSplineY.Evaluate(r[0]+tStep), aSplineZ.Evaluate(r[0]+tStep))
      nOutputPoints = p + 1
    else:
      while t < r[1]:
        points.InsertPoint(p, aSplineX.Evaluate(t), aSplineY.Evaluate(t), aSplineZ.Evaluate(t))
        t = t + tStep
        p = p + 1
      nOutputPoints = p
    
    lines = vtk.vtkCellArray()
    lines.InsertNextCell(nOutputPoints)
    for i in range(0, nOutputPoints):
      lines.InsertCellPoint(i)
        
    outputPoly.SetPoints(points)
    outputPoly.SetLines(lines)
コード例 #7
0
ファイル: SmoothCurve.py プロジェクト: jumbojing/SlicerHeart
    def updateCurve(self):

        if self.controlPointsMarkupNode and self.curveModelNode:

            self.curvePoints.Reset()  # clear without deallocating memory
            lines = vtk.vtkCellArray()
            self.curvePoly.SetLines(lines)

            if self.controlPointsMarkupNode.GetNumberOfFiducials() >= 2:
                self.pointInterpolationFunction(self.controlPointsMarkupNode,
                                                self.curvePoints)
                nInterpolatedPoints = self.curvePoints.GetNumberOfPoints()
                lines.InsertNextCell(nInterpolatedPoints)
                for i in range(nInterpolatedPoints):
                    lines.InsertCellPoint(i)

            tubeFilter = vtk.vtkTubeFilter()
            tubeFilter.SetInputData(self.curvePoly)
            tubeFilter.SetRadius(self.tubeRadius)
            tubeFilter.SetNumberOfSides(self.tubeResolution)
            tubeFilter.SetCapping(not self.closed)

            # Triangulation is necessary to avoid discontinuous lines
            # in model/slice intersection display
            triangles = vtk.vtkTriangleFilter()
            triangles.SetInputConnection(tubeFilter.GetOutputPort())
            triangles.Update()

            self.curveModelNode.SetAndObservePolyData(triangles.GetOutput())
            self.curveModelNode.Modified()
コード例 #8
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)
コード例 #9
0
  def WriteVTKPoints(self,vtkpoints,OutputFileName):
     # get data structures to convert to pixel ijk space
     outnode = self.outputSelector.currentNode()
     ras2ijk = vtk.vtkMatrix4x4()
     outnode.GetRASToIJKMatrix(ras2ijk)
     spacing = outnode.GetSpacing()
     origin  = outnode.GetOrigin()

     # write in meters
     MillimeterMeterConversion = .001;

     # loop over points an store in vtk data structure
     # write in pixel coordinates
     scalevtkPoints = vtk.vtkPoints()
     vtkvertices= vtk.vtkCellArray()
     for idpoint in range(vtkpoints.GetNumberOfPoints()):
         currentpoint = vtkpoints.GetPoint(idpoint)
         ijkpoint = ras2ijk.MultiplyPoint( (currentpoint[0],currentpoint[1],currentpoint[2],1.) )
         print 'ijkpoint %d' % idpoint, ijkpoint 
         vtkvertices.InsertNextCell( 1 ); vtkvertices.InsertCellPoint( scalevtkPoints.InsertNextPoint(
                [ MillimeterMeterConversion * (ijkpoint[0]*spacing[0] + origin[0])  , 
                  MillimeterMeterConversion * (ijkpoint[1]*spacing[1] + origin[1])  , 
                  MillimeterMeterConversion * (ijkpoint[2]*spacing[2] + origin[2])     ]
                                                                                               ) )
         #vtkvertices.InsertNextCell( 1 ); vtkvertices.InsertCellPoint( idpoint )
  
     # loop over points an store in vtk data structure
     scalerasPoints = vtk.vtkPoints()
     rasvertices= vtk.vtkCellArray()
     for idpoint in range(vtkpoints.GetNumberOfPoints()):
         point = MillimeterMeterConversion * numpy.array(vtkpoints.GetPoint(idpoint))
         rasvertices.InsertNextCell( 1 ); rasvertices.InsertCellPoint( scalerasPoints.InsertNextPoint(point) )
         #rasvertices.InsertNextCell( 1 ); rasvertices.InsertCellPoint( idpoint )

     for datapointsmeter,vertexofpoints,typeid in  [(scalerasPoints,rasvertices,'ras'),(scalevtkPoints,vtkvertices,'vtk')]:
       # set polydata
       polydata = vtk.vtkPolyData()
       polydata.SetPoints(datapointsmeter)
       polydata.SetVerts( vertexofpoints )
  
       # write to file
       print "WriteVTKPoints: writing",OutputFileName
       polydatawriter = vtk.vtkDataSetWriter()
       polydatawriter.SetFileName( "%s%s.vtk" % (OutputFileName,typeid ))
       polydatawriter.SetInput(polydata)
       polydatawriter.Update()
コード例 #10
0
    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
コード例 #11
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
コード例 #12
0
ファイル: SlicerHands.py プロジェクト: pieper/SlicerHands
  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
コード例 #13
0
 def clearPointsInPolyData(self,): 
   if self.recordedModelNode:
     newPoints = vtk.vtkPoints()
     newVertices = vtk.vtkCellArray()               
     newPolyData = vtk.vtkPolyData()
     newPolyData.SetPoints(newPoints)
     newPolyData.SetVerts(newVertices)    
     self.recordedModelNode.GetPolyData().DeepCopy(newPolyData)     
     self.recordedModelNode.GetPolyData().Modified()  
コード例 #14
0
ファイル: DrawEffect.py プロジェクト: ArashAkbarinia/Slicer
  def createPolyData(self):
    """make an empty single-polyline polydata"""

    polyData = vtk.vtkPolyData()
    polyData.SetPoints(self.xyPoints)

    lines = vtk.vtkCellArray()
    polyData.SetLines(lines)
    idArray = lines.GetData()
    idArray.Reset()
    idArray.InsertNextTuple1(0)

    polygons = vtk.vtkCellArray()
    polyData.SetPolys(polygons)
    idArray = polygons.GetData()
    idArray.Reset()
    idArray.InsertNextTuple1(0)

    return polyData
コード例 #15
0
    def createPolyData(self):
        """make an empty single-polyline polydata"""

        polyData = vtk.vtkPolyData()
        polyData.SetPoints(self.xyPoints)

        lines = vtk.vtkCellArray()
        polyData.SetLines(lines)
        idArray = lines.GetData()
        idArray.Reset()
        idArray.InsertNextTuple1(0)

        polygons = vtk.vtkCellArray()
        polyData.SetPolys(polygons)
        idArray = polygons.GetData()
        idArray.Reset()
        idArray.InsertNextTuple1(0)

        return polyData
コード例 #16
0
  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()
コード例 #17
0
ファイル: PaintEffect.py プロジェクト: SyamGadde/Slicer
  def createGlyph(self, polyData):
    """
    create a brush circle of the right radius in XY space
    - assume uniform scaling between XY and RAS which
      is enforced by the view interactors
    """
    sliceNode = self.sliceWidget.sliceLogic().GetSliceNode()
    self.rasToXY.DeepCopy(sliceNode.GetXYToRAS())
    self.rasToXY.Invert()
    maximum, maxIndex = 0,0
    for index in range(3):
      if abs(self.rasToXY.GetElement(0, index)) > maximum:
        maximum = abs(self.rasToXY.GetElement(0, index))
        maxIndex = index
    point = [0, 0, 0, 0]
    point[maxIndex] = self.radius
    xyRadius = self.rasToXY.MultiplyPoint(point)
    import math
    xyRadius = math.sqrt( xyRadius[0]**2 + xyRadius[1]**2 + xyRadius[2]**2 )

    if self.pixelMode:
      xyRadius = 0.01

    # make a circle paint brush
    points = vtk.vtkPoints()
    lines = vtk.vtkCellArray()
    polyData.SetPoints(points)
    polyData.SetLines(lines)
    PI = 3.1415926
    TWOPI = PI * 2
    PIoverSIXTEEN = PI / 16
    prevPoint = -1
    firstPoint = -1
    angle = 0
    while angle <= TWOPI:
      x = xyRadius * math.cos(angle)
      y = xyRadius * math.sin(angle)
      p = points.InsertNextPoint( x, y, 0 )
      if prevPoint != -1:
        idList = vtk.vtkIdList()
        idList.InsertNextId(prevPoint)
        idList.InsertNextId(p)
        polyData.InsertNextCell( vtk.VTK_LINE, idList )
      prevPoint = p
      if firstPoint == -1:
        firstPoint = p
      angle = angle + PIoverSIXTEEN

    # make the last line in the circle
    idList = vtk.vtkIdList()
    idList.InsertNextId(p)
    idList.InsertNextId(firstPoint)
    polyData.InsertNextCell( vtk.VTK_LINE, idList )
コード例 #18
0
    def createGlyph(self, polyData):
        """
    create a brush circle of the right radius in XY space
    - assume uniform scaling between XY and RAS which
      is enforced by the view interactors
    """
        sliceNode = self.sliceWidget.sliceLogic().GetSliceNode()
        self.rasToXY.DeepCopy(sliceNode.GetXYToRAS())
        self.rasToXY.Invert()
        maximum, maxIndex = 0, 0
        for index in range(3):
            if abs(self.rasToXY.GetElement(0, index)) > maximum:
                maximum = abs(self.rasToXY.GetElement(0, index))
                maxIndex = index
        point = [0, 0, 0, 0]
        point[maxIndex] = self.radius
        xyRadius = self.rasToXY.MultiplyPoint(point)
        import math
        xyRadius = math.sqrt(xyRadius[0]**2 + xyRadius[1]**2 + xyRadius[2]**2)

        if self.pixelMode:
            xyRadius = 0.01

        # make a circle paint brush
        points = vtk.vtkPoints()
        lines = vtk.vtkCellArray()
        polyData.SetPoints(points)
        polyData.SetLines(lines)
        PI = 3.1415926
        TWOPI = PI * 2
        PIoverSIXTEEN = PI / 16
        prevPoint = -1
        firstPoint = -1
        angle = 0
        while angle <= TWOPI:
            x = xyRadius * math.cos(angle)
            y = xyRadius * math.sin(angle)
            p = points.InsertNextPoint(x, y, 0)
            if prevPoint != -1:
                idList = vtk.vtkIdList()
                idList.InsertNextId(prevPoint)
                idList.InsertNextId(p)
                polyData.InsertNextCell(vtk.VTK_LINE, idList)
            prevPoint = p
            if firstPoint == -1:
                firstPoint = p
            angle = angle + PIoverSIXTEEN

        # make the last line in the circle
        idList = vtk.vtkIdList()
        idList.InsertNextId(p)
        idList.InsertNextId(firstPoint)
        polyData.InsertNextCell(vtk.VTK_LINE, idList)
コード例 #19
0
 def clearPointsInRecordedModel(self): 
   self.recordedDataBuffer = [] 
   newPoints = vtk.vtkPoints()
   newVertices = vtk.vtkCellArray()               
   newPolyData = vtk.vtkPolyData()
   newPolyData.SetPoints(newPoints)
   newPolyData.SetVerts(newVertices)
   colorArray = vtk.vtkDoubleArray()
   colorArray.SetNumberOfComponents(4)
   colorArray.SetName('Colors')
   newPolyData.GetPointData().SetScalars(colorArray)   
   self.recordedModelNode.GetPolyData().DeepCopy(newPolyData)     
   self.recordedModelNode.GetPolyData().Modified()        
コード例 #20
0
 def addUpdateObserver(self, inputNode, fixedNode):
   self.observedNode = inputNode
   self.fixedNode = fixedNode
   self.recordedModelNode = slicer.util.getNode('RecordedModel')
   if not self.recordedModelNode:
     recordedPoints = vtk.vtkPoints()
     recordedVertices = vtk.vtkCellArray()               
     recordedPolyData = vtk.vtkPolyData()
     recordedPolyData.SetPoints(recordedPoints)
     recordedPolyData.SetVerts(recordedVertices)
     self.recordedModelNode = self.addModelToScene(recordedPolyData, "RecordedModel")    
     self.recordedModelNode.GetModelDisplayNode().SetPointSize(3)
   if self.outputObserverTag == -1:
     self.outputObserverTag = inputNode.AddObserver('ModifiedEvent', self.updateSceneCallback)
コード例 #21
0
  def createScalingRuler(self, sliceViewName):
    #
    # Create the Scaling Ruler
    #
    self.points[sliceViewName] = vtk.vtkPoints()
    self.points[sliceViewName].SetNumberOfPoints(22)

    lines = []
    for i in xrange(0,21):
      line = vtk.vtkLine()
      lines.append(line)

    # setting the points to lines
    for i in xrange(0,21):
      if (i%2 == 0):
        lines[i].GetPointIds().SetId(0,i)
        lines[i].GetPointIds().SetId(1,i+1)
      else:
        lines[i].GetPointIds().SetId(0,i-1)
        lines[i].GetPointIds().SetId(1,i+1)

    # Create a cell array to store the lines in and add the lines to it
    linesArray = vtk.vtkCellArray()
    for i in xrange(0,21):
      linesArray.InsertNextCell(lines[i])

    # Create a polydata to store everything in
    linesPolyData = vtk.vtkPolyData()

    # Add the points to the dataset
    linesPolyData.SetPoints(self.points[sliceViewName])

    # Add the lines to the dataset
    linesPolyData.SetLines(linesArray)

    # mapper
    mapper = vtk.vtkPolyDataMapper2D()
    if vtk.VTK_MAJOR_VERSION <= 5:
      mapper.SetInput(linesPolyData)
    else:
      mapper.SetInputData(linesPolyData)
    # actor
    actor = self.scalingRulerActors[sliceViewName]
    actor.SetMapper(mapper)
    # color actor
    actor.GetProperty().SetColor(1,1,1)
    actor.GetProperty().SetLineWidth(1)
    textActor = self.scalingRulerTextActors[sliceViewName]
    textProperty = textActor.GetTextProperty()
コード例 #22
0
  def createScalingRuler(self, sliceViewName):
    #
    # Create the Scaling Ruler
    #
    self.points[sliceViewName] = vtk.vtkPoints()
    self.points[sliceViewName].SetNumberOfPoints(22)

    lines = []
    for i in xrange(0,21):
      line = vtk.vtkLine()
      lines.append(line)

    # setting the points to lines
    for i in xrange(0,21):
      if (i%2 == 0):
        lines[i].GetPointIds().SetId(0,i)
        lines[i].GetPointIds().SetId(1,i+1)
      else:
        lines[i].GetPointIds().SetId(0,i-1)
        lines[i].GetPointIds().SetId(1,i+1)

    # Create a cell array to store the lines in and add the lines to it
    linesArray = vtk.vtkCellArray()
    for i in xrange(0,21):
      linesArray.InsertNextCell(lines[i])

    # Create a polydata to store everything in
    linesPolyData = vtk.vtkPolyData()

    # Add the points to the dataset
    linesPolyData.SetPoints(self.points[sliceViewName])

    # Add the lines to the dataset
    linesPolyData.SetLines(linesArray)

    # mapper
    mapper = vtk.vtkPolyDataMapper2D()
    if vtk.VTK_MAJOR_VERSION <= 5:
      mapper.SetInput(linesPolyData)
    else:
      mapper.SetInputData(linesPolyData)
    # actor
    actor = self.scalingRulerActors[sliceViewName]
    actor.SetMapper(mapper)
    # color actor
    actor.GetProperty().SetColor(1,1,1)
    actor.GetProperty().SetLineWidth(1)
    textActor = self.scalingRulerTextActors[sliceViewName]
    textProperty = textActor.GetTextProperty()
コード例 #23
0
    def import_obj_from_blender(self, data):
        slicer.util.confirmOkCancelDisplay("Received object(s) from Blender.",
                                           "linkSlicerBlender Info:")

        def mkVtkIdList(it):
            vil = vtk.vtkIdList()
            for i in it:
                vil.InsertNextId(int(i))
            return vil

        #print(data)
        obj, xml = data.split("_XML_DATA_")
        obj_points, obj_polys = obj.split("_POLYS_")
        obj_points = eval(obj_points)
        obj_polys = eval(obj_polys)
        blender_faces = []
        offset = 0  #unflatten the list from blender
        while (offset < len(obj_polys)):
            vertices_per_face = obj_polys[offset]
            offset += 1
            vertex_indices = obj_polys[offset:offset + vertices_per_face]
            blender_faces.append(vertex_indices)
            offset += vertices_per_face
        tree = ET.ElementTree(ET.fromstring(xml))
        x_scene = tree.getroot()

        mesh = vtk.vtkPolyData()
        points = vtk.vtkPoints()
        polys = vtk.vtkCellArray()
        #print(blender_faces)
        for i in range(len(obj_points)):
            points.InsertPoint(i, obj_points[i])
        for i in range(len(blender_faces)):
            polys.InsertNextCell(mkVtkIdList(blender_faces[i]))
        mesh.SetPoints(points)
        mesh.SetPolys(polys)

        # Create model node and add to scene
        modelNode = slicer.mrmlScene.AddNewNodeByClass('vtkMRMLModelNode')
        modelNode.SetName(
            x_scene[0].get('name')
        )  #only expecting one obj in the xml, since sent w/ OBJ together
        modelNode.SetAndObservePolyData(mesh)
        modelNode.CreateDefaultDisplayNodes()
        modelNode.GetDisplayNode().SetSliceIntersectionVisibility(True)
        modelNode.GetDisplayNode().SetSliceIntersectionThickness(2)

        #update object location in scene
        self.update_scene(xml)
コード例 #24
0
  def drawLineBetweenPoints(self, lineModel, point1, point2):        
    # Create a vtkPoints object and store the points in it
    points = vtk.vtkPoints()
    points.InsertNextPoint(point1)
    points.InsertNextPoint(point2)

    # Create line
    line = vtk.vtkLine()
    line.GetPointIds().SetId(0,0) 
    line.GetPointIds().SetId(1,1)
    lineCellArray = vtk.vtkCellArray()
    lineCellArray.InsertNextCell(line)
    
    # Update model data
    lineModel.GetPolyData().SetPoints(points)
    lineModel.GetPolyData().SetLines(lineCellArray)
コード例 #25
0
    def updatePoints(self):
        points = vtk.vtkPoints()
        cellArray = vtk.vtkCellArray()

        numberOfPoints = self.FiducialNode.GetNumberOfFiducials()
        points.SetNumberOfPoints(numberOfPoints)
        new_coord = [0.0, 0.0, 0.0]

        for i in range(numberOfPoints):
            self.FiducialNode.GetNthFiducialPosition(i, new_coord)
            points.SetPoint(i, new_coord)

        cellArray.InsertNextCell(numberOfPoints)
        for i in range(numberOfPoints):
            cellArray.InsertCellPoint(i)

        self.PolyData.SetLines(cellArray)
        self.PolyData.SetPoints(points)
コード例 #26
0
  def updatePoints(self):
    points = vtk.vtkPoints()
    cellArray = vtk.vtkCellArray()

    numberOfPoints = self.FiducialNode.GetNumberOfFiducials()
    points.SetNumberOfPoints(numberOfPoints)
    new_coord = [0.0, 0.0, 0.0]

    for i in range(numberOfPoints):
      self.FiducialNode.GetNthFiducialPosition(i,new_coord)
      points.SetPoint(i, new_coord)

    cellArray.InsertNextCell(numberOfPoints)
    for i in range(numberOfPoints):
      cellArray.InsertCellPoint(i)

    self.PolyData.SetLines(cellArray)
    self.PolyData.SetPoints(points)
コード例 #27
0
    def nodeToPoly(self, sourceNode, outputPoly, closed=False):
        points = vtk.vtkPoints()
        cellArray = vtk.vtkCellArray()

        nOfControlPoints = sourceNode.GetNumberOfFiducials()
        pos = [0.0, 0.0, 0.0]
        posStartEnd = [0.0, 0.0, 0.0]

        offset = 0

        if not closed:
            points.SetNumberOfPoints(nOfControlPoints)
            cellArray.InsertNextCell(nOfControlPoints)
        else:
            posStart = [0.0, 0.0, 0.0]
            posEnd = [0.0, 0.0, 0.0]
            sourceNode.GetNthFiducialPosition(0, posStart)
            sourceNode.GetNthFiducialPosition(nOfControlPoints - 1, posEnd)
            posStartEnd[0] = (posStart[0] + posEnd[0]) / 2.0
            posStartEnd[1] = (posStart[1] + posEnd[1]) / 2.0
            posStartEnd[2] = (posStart[2] + posEnd[2]) / 2.0
            points.SetNumberOfPoints(nOfControlPoints + 2)
            cellArray.InsertNextCell(nOfControlPoints + 2)

            points.SetPoint(0, posStartEnd)
            cellArray.InsertCellPoint(0)

            offset = 1

        for i in range(nOfControlPoints):
            sourceNode.GetNthFiducialPosition(i, pos)
            points.SetPoint(offset + i, pos)
            cellArray.InsertCellPoint(offset + i)

        offset = offset + nOfControlPoints

        if closed:
            points.SetPoint(offset, posStartEnd)
            cellArray.InsertCellPoint(offset)

        outputPoly.Initialize()
        outputPoly.SetPoints(points)
        outputPoly.SetLines(cellArray)
コード例 #28
0
ファイル: CurveMaker.py プロジェクト: tokjun/CurveMaker
  def nodeToPoly(self, sourceNode, outputPoly, closed=False):
    points = vtk.vtkPoints()
    cellArray = vtk.vtkCellArray()

    nOfControlPoints = sourceNode.GetNumberOfFiducials()
    pos = [0.0, 0.0, 0.0]
    posStartEnd = [0.0, 0.0, 0.0]

    offset = 0
    
    if not closed:
      points.SetNumberOfPoints(nOfControlPoints)
      cellArray.InsertNextCell(nOfControlPoints)
    else:
      posStart = [0.0, 0.0, 0.0]
      posEnd = [0.0, 0.0, 0.0]
      sourceNode.GetNthFiducialPosition(0,posStart)
      sourceNode.GetNthFiducialPosition(nOfControlPoints-1,posEnd)
      posStartEnd[0] = (posStart[0]+posEnd[0])/2.0
      posStartEnd[1] = (posStart[1]+posEnd[1])/2.0
      posStartEnd[2] = (posStart[2]+posEnd[2])/2.0
      points.SetNumberOfPoints(nOfControlPoints+2)
      cellArray.InsertNextCell(nOfControlPoints+2)

      points.SetPoint(0,posStartEnd)
      cellArray.InsertCellPoint(0)

      offset = 1
      
    for i in range(nOfControlPoints):
      sourceNode.GetNthFiducialPosition(i,pos)
      points.SetPoint(offset+i,pos)
      cellArray.InsertCellPoint(offset+i)

    offset = offset + nOfControlPoints
    
    if closed:
      points.SetPoint(offset,posStartEnd)
      cellArray.InsertCellPoint(offset)

    outputPoly.Initialize()
    outputPoly.SetPoints(points)
    outputPoly.SetLines(cellArray)
コード例 #29
0
 def undoPostProcessing(self):
   # Create new vtkPolyData
   newPoints = vtk.vtkPoints()
   newVertices = vtk.vtkCellArray()               
   newPolyData = vtk.vtkPolyData()
   newPolyData.SetPoints(newPoints)
   newPolyData.SetVerts(newVertices)
   colorArray = vtk.vtkDoubleArray()
   colorArray.SetNumberOfComponents(4)
   colorArray.SetName('Colors')
   newPolyData.GetPointData().SetScalars(colorArray)   
   # Filter accordingly to the input parameters
   recordedDataBufferFiltered = []    
   for idx in range(len(self.recordedDataBufferDefault)):
     self.addPointToPolyData(newPolyData, self.recordedDataBufferDefault[idx][0:3])
   # Update recorded model and buffer
   self.recordedModelNode.GetPolyData().DeepCopy(newPolyData)     
   self.recordedModelNode.GetPolyData().Modified()  
   self.recordedDataBuffer = self.recordedDataBufferDefault
コード例 #30
0
    def nodesToSpline(self, sourceNode, outputPoly):
        numControlPoints = sourceNode.GetNumberOfFiducials()
        pos = [0.0, 0.0, 0.0]

        #Three independent splines for x, y, and z
        xSpline = vtk.vtkCardinalSpline()
        ySpline = vtk.vtkCardinalSpline()
        zSpline = vtk.vtkCardinalSpline()
        xSpline.ClosedOff()
        ySpline.ClosedOff()
        zSpline.ClosedOff()

        for i in range(0, numControlPoints):
            sourceNode.GetNthFiducialPosition(i, pos)
            xSpline.AddPoint(i, pos[0])
            ySpline.AddPoint(i, pos[1])
            zSpline.AddPoint(i, pos[2])

        #There will be a self.resolution number of intermediate points
        interpolatedPoints = (self.Resolution + 2) * (numControlPoints - 1)
        points = vtk.vtkPoints()
        r = [0.0, 0.0]
        xSpline.GetParametricRange(r)
        t = r[0]
        p = 0
        tStep = (numControlPoints - 1.0) / (interpolatedPoints - 1.0)
        numOutputPoints = 0

        while t < r[1]:
            points.InsertPoint(p, xSpline.Evaluate(t), ySpline.Evaluate(t),
                               zSpline.Evaluate(t))
            t = t + tStep
            p = p + 1
        numOutputPoints = p

        lines = vtk.vtkCellArray()
        lines.InsertNextCell(numOutputPoints)
        for i in range(0, numOutputPoints):
            lines.InsertCellPoint(i)

        outputPoly.SetPoints(points)
        outputPoly.SetLines(lines)
コード例 #31
0
    def nodesToLinear(self, sourceNode, outputPoly):
        points = vtk.vtkPoints()
        cells = vtk.vtkCellArray()
        numControlPoints = sourceNode.GetNumberOfFiducials()
        pos = [0.0, 0.0, 0.0]
        offset = 0

        points.SetNumberOfPoints(numControlPoints)
        cells.InsertNextCell(numControlPoints)

        for i in range(numControlPoints):
            sourceNode.GetNthFiducialPosition(i, pos)
            points.SetPoint(offset + i, pos)
            cells.InsertCellPoint(offset + i)

        offset = offset + numControlPoints

        outputPoly.Initialize()
        outputPoly.SetPoints(points)
        outputPoly.SetLines(cells)
コード例 #32
0
ファイル: util.py プロジェクト: jumbojing/SlicerHeart
def createPolyDataFromPointArray(pointArray):
    """Create vtkPolyData from a numpy array. Performs deep copy."""

    from __main__ import vtk, slicer
    number_of_points = pointArray.shape[0]
    # Points
    points = vtk.vtkPoints()
    points.SetNumberOfPoints(number_of_points)
    import vtk.util.numpy_support
    pointArrayDestination = vtk.util.numpy_support.vtk_to_numpy(
        points.GetData())
    pointArrayDestination[:] = pointArray[:]
    # Vertices
    vertices = vtk.vtkCellArray()
    for i in range(number_of_points):
        vertices.InsertNextCell(1)
        vertices.InsertCellPoint(i)
    # PolyData
    polyData = vtk.vtkPolyData()
    polyData.SetPoints(points)
    polyData.SetVerts(vertices)
    return polyData
コード例 #33
0
    def computeSurfaceBetweenLines(self):
        """
    Update model with a surface between base and margin lines.
    """

        numberOfBasePoints = self.baseLine.curvePoints.GetNumberOfPoints()
        numberOfMarginPoints = self.marginLine.curvePoints.GetNumberOfPoints()
        if numberOfBasePoints == 0 or numberOfMarginPoints == 0:
            self.surfaceModelNode.SetAndObservePolyData(None)
            return

        boundaryPoints = vtk.vtkPoints()
        boundaryPoints.DeepCopy(self.baseLine.curvePoints)
        boundaryPoints.InsertPoints(numberOfBasePoints, numberOfMarginPoints,
                                    0, self.marginLine.curvePoints)

        # Add a triangle strip between the base and margin lines
        strips = vtk.vtkCellArray()
        strips.InsertNextCell(numberOfBasePoints * 2)
        basePointToMarginPointScale = float(numberOfMarginPoints) / float(
            numberOfBasePoints)
        for basePointIndex in range(numberOfBasePoints):
            strips.InsertCellPoint(basePointIndex)
            strips.InsertCellPoint(
                int(numberOfBasePoints +
                    basePointIndex * basePointToMarginPointScale))

        clippingSurfacePolyData = vtk.vtkPolyData()
        clippingSurfacePolyData.SetPoints(boundaryPoints)
        clippingSurfacePolyData.SetStrips(strips)

        triangulator = vtk.vtkTriangleFilter()
        triangulator.SetInputData(clippingSurfacePolyData)
        triangulator.Update()

        clippingPolyData = triangulator.GetOutput()

        self.surfaceModelNode.SetAndObservePolyData(clippingPolyData)
コード例 #34
0
 def __init__(self):  
   # Member variables
   self.outputLabels = None    
   self.recordedDataBuffer = []   
   self.record = False
   self.reset = False
   self.outputObserverTag = -1
   self.rigidBodyToTrackerTransformNode = None
   self.measurementToMeasurerTransformNode = None
   self.parametersToMeasurerTransformNode = None
   self.plus = None
   self.m = vtk.vtkMatrix4x4()
   self.direction = -1
   self.ras = [0, 0, 0, 1]
   self.d = 0.0
   self.snr = 0
   self.total = 0
   self.LABEL_UPDATE_RATE = 10  
   self.labelUpdateCount = 0
   self.snrThreshold = 40       
   self.distanceMaximumValue = 1000.0       
   self.distanceMinimumValue = 0.0 
   self.lensMaxDistance = 0.0
   self.lensMinDistance = 0.0
   self.normalizingConstant = 0.0
   self.min = -1000.0
   self.addColours = True
   import Viewpoint # Viewpoint
   self.viewpointLogic = Viewpoint.ViewpointLogic()
   self.stopWatch = None # StopWatch        
   # Create style sheets        
   self.errorStyleSheet = "QLabel { color : #FF0000; \
                               font: bold 14px}"
   self.defaultStyleSheet = "QLabel { color : #000000; \
                                 font: bold 14px}"        
   # Create rainbow colour table                                      
   self.colorTable=slicer.vtkMRMLColorTableNode()
   self.colorTable.SetTypeToRainbow ()                                    
   # Add MeasurementPoint
   self.measurementPointMarkupsFiducialNode = slicer.util.getNode('MeasurementPoint')
   if not self.measurementPointMarkupsFiducialNode:
     self.measurementPointMarkupsFiducialNode = slicer.vtkMRMLMarkupsFiducialNode()  
     self.measurementPointMarkupsFiducialNode.SetName('MeasurementPoint')
     self.measurementPointMarkupsFiducialNode.AddFiducial(0, 0, 0)
     self.measurementPointMarkupsFiducialNode.SetNthFiducialLabel(0, '')
     slicer.mrmlScene.AddNode(self.measurementPointMarkupsFiducialNode)
     self.measurementPointMarkupsFiducialNode.GetDisplayNode().SetGlyphScale(2.0)
     self.measurementPointMarkupsFiducialNode.GetDisplayNode().SetGlyphType(13) # Sphere3D
     self.measurementPointMarkupsFiducialNode.GetDisplayNode().SetSelectedColor(1, 0, 0)     
   # Add RecordedModel
   self.recordedModelNode = slicer.util.getNode('RecordedModel')
   if not self.recordedModelNode:
     recordedPoints = vtk.vtkPoints()
     recordedVertices = vtk.vtkCellArray()               
     recordedPolyData = vtk.vtkPolyData()
     recordedPolyData.SetPoints(recordedPoints)
     recordedPolyData.SetVerts(recordedVertices)
     self.recordedModelNode = self.addModelToScene(recordedPolyData, "RecordedModel")    
     self.recordedModelNode.GetModelDisplayNode().SetPointSize(3)
     # Set up coloured scalars  
     colorArray = vtk.vtkDoubleArray()
     colorArray.SetNumberOfComponents(4)
     colorArray.SetName('Colors')
     self.recordedModelNode.GetPolyData().GetPointData().SetScalars(colorArray)          
   # Create share directory
   self.pathToCreatedSaveDir = self.createShareDirectory()    
   # Post-Processing default (for undo)
   self.recordedDataBufferDefault = []
コード例 #35
0
    def onApplyThreshold(self):
        min,max = self.getDistanceBound()
		
        newPoints = vtk.vtkPoints()
        newLines = vtk.vtkCellArray()
        newTensors = vtk.vtkFloatArray()
        newTensors.SetNumberOfComponents(9)
        newScalars = vtk.vtkFloatArray()

        points = self.inputPolyData.GetPoints()
        lines = self.inputPolyData.GetLines()
        tensors = self.inputPolyData.GetPointData().GetTensors()
        lines.InitTraversal()

        newId = 0
        for length in self.distanceTable:
            if length<=self.thresholdMax.value and length>=self.thresholdMin.value:
                ids = vtk.vtkIdList()
                lines.GetNextCell(ids)
                newLine = vtk.vtkPolyLine()
                #print(ids.GetNumberOfIds())
                newLine.GetPointIds().SetNumberOfIds(ids.GetNumberOfIds())
                #print(((length-min)/(max-min))*100)
                for i in range(ids.GetNumberOfIds()): 
                    newPoints.InsertNextPoint(points.GetPoint(ids.GetId(i)))
                    newLine.GetPointIds().SetId(i,newId)
                    newScalars.InsertNextValue(((length-min)/(max-min)))
                    newId += 1
                    tensorValue = [0]*9
                    if(tensors != None):
                        for j in range(9):
                            tensorValue[j] = tensors.GetComponent(ids.GetId(i),j)
                    newTensors.InsertNextTuple(tensorValue)
                newLines.InsertNextCell(newLine)

        self.outputPolyData = vtk.vtkPolyData()
        self.outputPolyData.SetPoints(newPoints)
        self.outputPolyData.SetLines(newLines)
        self.outputPolyData.GetPointData().SetTensors(newTensors)
        newScalars.SetName("Length")
        self.outputPolyData.GetPointData().AddArray(newScalars)
        self.outputNode.SetAndObservePolyData(self.outputPolyData)
		
        chartViewNodes = slicer.mrmlScene.GetNodesByClass('vtkMRMLChartViewNode')
        chartViewNodes.InitTraversal()
        chartViewNode = chartViewNodes.GetNextItemAsObject()
		
        arrayNode = slicer.mrmlScene.AddNode(slicer.vtkMRMLDoubleArrayNode())
        array = arrayNode.GetArray()
        array.SetNumberOfTuples(10)
        step = (max-min)/10
        interMin = min
        interMax = min+step
        for i in range(10):
            numberOfFibers = 0
            for length in self.distanceTable:
                if length<=interMax and length>=interMin and length<=self.thresholdMax.value and length>=self.thresholdMin.value:
                    numberOfFibers += 1
            array.SetComponent(i,0,(interMin+interMax)/2)
            array.SetComponent(i,1,numberOfFibers)
            array.SetComponent(i,2,0)
            interMin += step
            interMax += step
        chartNode = slicer.mrmlScene.AddNode(slicer.vtkMRMLChartNode())
        chartNode.AddArray("Fiber Length",arrayNode.GetID())
        chartViewNode.SetChartNodeID(chartNode.GetID())
		
        chartNode.SetProperty('default', 'title', 'Length Distribution')
        chartNode.SetProperty('default', 'xAxisLabel', 'Length')
        chartNode.SetProperty('default', 'yAxisLabel', 'Distribution')
        chartNode.SetProperty('default', 'type', 'Bar')
コード例 #36
0
ファイル: Endoscopy.py プロジェクト: yuzhengZ/Slicer
    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
コード例 #37
0
ファイル: Endoscopy.py プロジェクト: steaff/Slicer
  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
コード例 #38
0
def tracts_to_vtkPolyData64(tracts, tracts_data={}, lines_indices=None):
  #  if isinstance(tracts, Tractography):
    tracts_data = tracts.tracts_data()
    tracts = tracts.tracts()
    lengths = [len(p) for p in tracts]
    line_starts = ns.numpy.r_[0, ns.numpy.cumsum(lengths)]
    if lines_indices is None:
        lines_indices = [
            ns.numpy.arange(length) + line_start
            for length, line_start in izip(lengths, line_starts)
        ]

    ids = ns.numpy.hstack([
        ns.numpy.r_[c[0], c[1]]
        for c in izip(lengths, lines_indices)
    ])
    ids=np.int64(ids)
    vtk_ids = ns.numpy_to_vtkIdTypeArray(ids, deep=True)

    cell_array = vtk.vtkCellArray()
    cell_array.SetCells(len(tracts), vtk_ids)
    points = ns.numpy.vstack(tracts).astype(
        ns.get_vtk_to_numpy_typemap()[vtk.VTK_DOUBLE]
    )
    points_array = ns.numpy_to_vtk(points, deep=True)

    poly_data = vtk.vtkPolyData()
    vtk_points = vtk.vtkPoints()
    vtk_points.SetData(points_array)
    poly_data.SetPoints(vtk_points)
    poly_data.SetLines(cell_array)

    saved_keys = set()
    for key, value in tracts_data.items():
        if key in saved_keys:
            continue
        if key.startswith('Active'):
            saved_keys.add(value)
            name = value
            value = tracts_data[value]
        else:
            name = key

        if len(value) == len(tracts):
            if value[0].ndim == 1:
                value_ = ns.numpy.hstack(value)[:, None]
            else:
                value_ = ns.numpy.vstack(value)
        elif len(value) == len(points):
            value_ = value
        else:
            raise ValueError(
                "Data in %s does not have the correct number of items")

        vtk_value = ns.numpy_to_vtk(np.ascontiguousarray(value_), deep=True)
        vtk_value.SetName(name)
        if key == 'ActiveScalars' or key == 'Scalars_':
            poly_data.GetPointData().SetScalars(vtk_value)
        elif key == 'ActiveVectors' or key == 'Vectors_':
            poly_data.GetPointData().SetVectors(vtk_value)
        elif key == 'ActiveTensors' or key == 'Tensors_':
            poly_data.GetPointData().SetTensors(vtk_value)
        else:
            poly_data.GetPointData().AddArray(vtk_value)

    poly_data.BuildCells()

    return poly_data
コード例 #39
0
    def nodeToPolyCardinalSpline(self, sourceNode, outputPoly, closed=False):

        nOfControlPoints = sourceNode.GetNumberOfFiducials()
        pos = [0.0, 0.0, 0.0]

        # One spline for each direction.
        aSplineX = vtk.vtkCardinalSpline()
        aSplineY = vtk.vtkCardinalSpline()
        aSplineZ = vtk.vtkCardinalSpline()

        if closed:
            aSplineX.ClosedOn()
            aSplineY.ClosedOn()
            aSplineZ.ClosedOn()
        else:
            aSplineX.ClosedOff()
            aSplineY.ClosedOff()
            aSplineZ.ClosedOff()

        for i in range(0, nOfControlPoints):
            sourceNode.GetNthFiducialPosition(i, pos)
            aSplineX.AddPoint(i, pos[0])
            aSplineY.AddPoint(i, pos[1])
            aSplineZ.AddPoint(i, pos[2])

        # Interpolate x, y and z by using the three spline filters and
        # create new points
        nInterpolatedPoints = (self.interpResolution + 2) * (nOfControlPoints -
                                                             1)
        # One section is devided into self.interpResolution segments
        points = vtk.vtkPoints()
        r = [0.0, 0.0]
        aSplineX.GetParametricRange(r)
        t = r[0]
        p = 0
        tStep = (nOfControlPoints - 1.0) / (nInterpolatedPoints - 1.0)
        nOutputPoints = 0

        if closed:
            while t < r[1] + 1.0:
                points.InsertPoint(p, aSplineX.Evaluate(t),
                                   aSplineY.Evaluate(t), aSplineZ.Evaluate(t))
                t = t + tStep
                p = p + 1
            ## Make sure to close the loop
            points.InsertPoint(p, aSplineX.Evaluate(r[0]),
                               aSplineY.Evaluate(r[0]),
                               aSplineZ.Evaluate(r[0]))
            p = p + 1
            points.InsertPoint(p, aSplineX.Evaluate(r[0] + tStep),
                               aSplineY.Evaluate(r[0] + tStep),
                               aSplineZ.Evaluate(r[0] + tStep))
            nOutputPoints = p + 1
        else:
            while t < r[1]:
                points.InsertPoint(p, aSplineX.Evaluate(t),
                                   aSplineY.Evaluate(t), aSplineZ.Evaluate(t))
                t = t + tStep
                p = p + 1
            nOutputPoints = p

        lines = vtk.vtkCellArray()
        lines.InsertNextCell(nOutputPoints)
        for i in range(0, nOutputPoints):
            lines.InsertCellPoint(i)

        outputPoly.SetPoints(points)
        outputPoly.SetLines(lines)
コード例 #40
0
def tracts_to_vtkPolyData64(tracts, tracts_data={}, lines_indices=None):
    #  if isinstance(tracts, Tractography):
    tracts_data = tracts.tracts_data()
    tracts = tracts.tracts()
    lengths = [len(p) for p in tracts]
    line_starts = ns.numpy.r_[0, ns.numpy.cumsum(lengths)]
    if lines_indices is None:
        lines_indices = [
            ns.numpy.arange(length) + line_start
            for length, line_start in izip(lengths, line_starts)
        ]

    ids = ns.numpy.hstack(
        [ns.numpy.r_[c[0], c[1]] for c in izip(lengths, lines_indices)])
    ids = np.int64(ids)
    vtk_ids = ns.numpy_to_vtkIdTypeArray(ids, deep=True)

    cell_array = vtk.vtkCellArray()
    cell_array.SetCells(len(tracts), vtk_ids)
    points = ns.numpy.vstack(tracts).astype(
        ns.get_vtk_to_numpy_typemap()[vtk.VTK_DOUBLE])
    points_array = ns.numpy_to_vtk(points, deep=True)

    poly_data = vtk.vtkPolyData()
    vtk_points = vtk.vtkPoints()
    vtk_points.SetData(points_array)
    poly_data.SetPoints(vtk_points)
    poly_data.SetLines(cell_array)

    saved_keys = set()
    for key, value in tracts_data.items():
        if key in saved_keys:
            continue
        if key.startswith('Active'):
            saved_keys.add(value)
            name = value
            value = tracts_data[value]
        else:
            name = key

        if len(value) == len(tracts):
            if value[0].ndim == 1:
                value_ = ns.numpy.hstack(value)[:, None]
            else:
                value_ = ns.numpy.vstack(value)
        elif len(value) == len(points):
            value_ = value
        else:
            raise ValueError(
                "Data in %s does not have the correct number of items")

        vtk_value = ns.numpy_to_vtk(np.ascontiguousarray(value_), deep=True)
        vtk_value.SetName(name)
        if key == 'ActiveScalars' or key == 'Scalars_':
            poly_data.GetPointData().SetScalars(vtk_value)
        elif key == 'ActiveVectors' or key == 'Vectors_':
            poly_data.GetPointData().SetVectors(vtk_value)
        elif key == 'ActiveTensors' or key == 'Tensors_':
            poly_data.GetPointData().SetTensors(vtk_value)
        else:
            poly_data.GetPointData().AddArray(vtk_value)

    poly_data.BuildCells()

    return poly_data
コード例 #41
0
ファイル: LumpNav.py プロジェクト: brudfors/LumpNav
    def createTumorFromMarkups(self):
        logging.debug("createTumorFromMarkups")
        # self.tumorMarkups_Needle.SetDisplayVisibility(0)

        # Create polydata point set from markup points
        points = vtk.vtkPoints()
        cellArray = vtk.vtkCellArray()

        numberOfPoints = self.tumorMarkups_Needle.GetNumberOfFiducials()

        if numberOfPoints > 0:
            self.deleteLastFiducialButton.setEnabled(True)
            self.deleteAllFiducialsButton.setEnabled(True)
            self.deleteLastFiducialDuringNavigationButton.setEnabled(True)

        # Surface generation algorithms behave unpredictably when there are not enough points
        # return if there are very few points
        if numberOfPoints < 1:
            return

        points.SetNumberOfPoints(numberOfPoints)
        new_coord = [0.0, 0.0, 0.0]

        for i in range(numberOfPoints):
            self.tumorMarkups_Needle.GetNthFiducialPosition(i, new_coord)
            points.SetPoint(i, new_coord)

        cellArray.InsertNextCell(numberOfPoints)
        for i in range(numberOfPoints):
            cellArray.InsertCellPoint(i)

        pointPolyData = vtk.vtkPolyData()
        pointPolyData.SetLines(cellArray)
        pointPolyData.SetPoints(points)

        delaunay = vtk.vtkDelaunay3D()

        if numberOfPoints < 10:
            logging.debug("use glyphs")
            sphere = vtk.vtkCubeSource()
            glyph = vtk.vtkGlyph3D()
            glyph.SetInputData(pointPolyData)
            glyph.SetSourceConnection(sphere.GetOutputPort())
            # glyph.SetVectorModeToUseNormal()
            # glyph.SetScaleModeToScaleByVector()
            # glyph.SetScaleFactor(0.25)
            delaunay.SetInputConnection(glyph.GetOutputPort())
        else:
            delaunay.SetInputData(pointPolyData)

        surfaceFilter = vtk.vtkDataSetSurfaceFilter()
        surfaceFilter.SetInputConnection(delaunay.GetOutputPort())

        smoother = vtk.vtkButterflySubdivisionFilter()
        smoother.SetInputConnection(surfaceFilter.GetOutputPort())
        smoother.SetNumberOfSubdivisions(3)
        smoother.Update()

        forceConvexShape = True

        if forceConvexShape == True:
            delaunaySmooth = vtk.vtkDelaunay3D()
            delaunaySmooth.SetInputData(smoother.GetOutput())
            delaunaySmooth.Update()

            smoothSurfaceFilter = vtk.vtkDataSetSurfaceFilter()
            smoothSurfaceFilter.SetInputConnection(delaunaySmooth.GetOutputPort())
            self.tumorModel_Needle.SetPolyDataConnection(smoothSurfaceFilter.GetOutputPort())
        else:
            self.tumorModel_Needle.SetPolyDataConnection(smoother.GetOutputPort())

        self.tumorModel_Needle.Modified()
コード例 #42
0
    def updateModelFromMarkup(self, inputMarkup, outputModel):
        """
    Update model to enclose all points in the input markup list
    """

        # Delaunay triangulation is robust and creates nice smooth surfaces from a small number of points,
        # however it can only generate convex surfaces robustly.
        useDelaunay = True

        # Create polydata point set from markup points

        points = vtk.vtkPoints()
        cellArray = vtk.vtkCellArray()

        numberOfPoints = inputMarkup.GetNumberOfFiducials()

        # Surface generation algorithms behave unpredictably when there are not enough points
        # return if there are very few points
        if useDelaunay:
            if numberOfPoints < 3:
                return
        else:
            if numberOfPoints < 10:
                return

        points.SetNumberOfPoints(numberOfPoints)
        new_coord = [0.0, 0.0, 0.0]

        for i in range(numberOfPoints):
            inputMarkup.GetNthFiducialPosition(i, new_coord)
            points.SetPoint(i, new_coord)

        cellArray.InsertNextCell(numberOfPoints)
        for i in range(numberOfPoints):
            cellArray.InsertCellPoint(i)

        pointPolyData = vtk.vtkPolyData()
        pointPolyData.SetLines(cellArray)
        pointPolyData.SetPoints(points)

        # Create surface from point set

        if useDelaunay:

            delaunay = vtk.vtkDelaunay3D()
            delaunay.SetInputData(pointPolyData)

            surfaceFilter = vtk.vtkDataSetSurfaceFilter()
            surfaceFilter.SetInputConnection(delaunay.GetOutputPort())

            smoother = vtk.vtkButterflySubdivisionFilter()
            smoother.SetInputConnection(surfaceFilter.GetOutputPort())
            smoother.SetNumberOfSubdivisions(3)
            smoother.Update()

            outputModel.SetPolyDataConnection(smoother.GetOutputPort())

        else:

            surf = vtk.vtkSurfaceReconstructionFilter()
            surf.SetInputData(pointPolyData)
            surf.SetNeighborhoodSize(20)
            surf.SetSampleSpacing(
                80
            )  # lower value follows the small details more closely but more dense pointset is needed as input

            cf = vtk.vtkContourFilter()
            cf.SetInputConnection(surf.GetOutputPort())
            cf.SetValue(0, 0.0)

            # Sometimes the contouring algorithm can create a volume whose gradient
            # vector and ordering of polygon (using the right hand rule) are
            # inconsistent. vtkReverseSense cures this problem.
            reverse = vtk.vtkReverseSense()
            reverse.SetInputConnection(cf.GetOutputPort())
            reverse.ReverseCellsOff()
            reverse.ReverseNormalsOff()

            outputModel.SetPolyDataConnection(reverse.GetOutputPort())

        # Create default model display node if does not exist yet
        if not outputModel.GetDisplayNode():
            modelDisplayNode = slicer.mrmlScene.CreateNodeByClass(
                "vtkMRMLModelDisplayNode")
            modelDisplayNode.SetColor(0, 0, 1)  # Blue
            modelDisplayNode.BackfaceCullingOff()
            modelDisplayNode.SliceIntersectionVisibilityOn()
            modelDisplayNode.SetOpacity(0.3)  # Between 0-1, 1 being opaque
            slicer.mrmlScene.AddNode(modelDisplayNode)
            outputModel.SetAndObserveDisplayNodeID(modelDisplayNode.GetID())

        outputModel.GetDisplayNode().SliceIntersectionVisibilityOn()

        outputModel.Modified()
コード例 #43
0
    def createTumorFromMarkups(self):
        logging.debug('createTumorFromMarkups')
        #self.tumorMarkups_Needle.SetDisplayVisibility(0)

        # Create polydata point set from markup points
        points = vtk.vtkPoints()
        cellArray = vtk.vtkCellArray()

        numberOfPoints = self.tumorMarkups_Needle.GetNumberOfFiducials()

        if numberOfPoints > 0:
            self.deleteLastFiducialButton.setEnabled(True)
            self.deleteAllFiducialsButton.setEnabled(True)
            self.deleteLastFiducialDuringNavigationButton.setEnabled(True)

        # Surface generation algorithms behave unpredictably when there are not enough points
        # return if there are very few points
        if numberOfPoints < 1:
            return

        points.SetNumberOfPoints(numberOfPoints)
        new_coord = [0.0, 0.0, 0.0]

        for i in range(numberOfPoints):
            self.tumorMarkups_Needle.GetNthFiducialPosition(i, new_coord)
            points.SetPoint(i, new_coord)

        cellArray.InsertNextCell(numberOfPoints)
        for i in range(numberOfPoints):
            cellArray.InsertCellPoint(i)

        pointPolyData = vtk.vtkPolyData()
        pointPolyData.SetLines(cellArray)
        pointPolyData.SetPoints(points)

        delaunay = vtk.vtkDelaunay3D()

        if numberOfPoints < 10:
            logging.debug("use glyphs")
            sphere = vtk.vtkCubeSource()
            glyph = vtk.vtkGlyph3D()
            glyph.SetInputData(pointPolyData)
            glyph.SetSourceConnection(sphere.GetOutputPort())
            #glyph.SetVectorModeToUseNormal()
            #glyph.SetScaleModeToScaleByVector()
            #glyph.SetScaleFactor(0.25)
            delaunay.SetInputConnection(glyph.GetOutputPort())
        else:
            delaunay.SetInputData(pointPolyData)

        surfaceFilter = vtk.vtkDataSetSurfaceFilter()
        surfaceFilter.SetInputConnection(delaunay.GetOutputPort())

        smoother = vtk.vtkButterflySubdivisionFilter()
        smoother.SetInputConnection(surfaceFilter.GetOutputPort())
        smoother.SetNumberOfSubdivisions(3)
        smoother.Update()

        forceConvexShape = True

        if (forceConvexShape == True):
            delaunaySmooth = vtk.vtkDelaunay3D()
            delaunaySmooth.SetInputData(smoother.GetOutput())
            delaunaySmooth.Update()

            smoothSurfaceFilter = vtk.vtkDataSetSurfaceFilter()
            smoothSurfaceFilter.SetInputConnection(
                delaunaySmooth.GetOutputPort())
            self.tumorModel_Needle.SetPolyDataConnection(
                smoothSurfaceFilter.GetOutputPort())
        else:
            self.tumorModel_Needle.SetPolyDataConnection(
                smoother.GetOutputPort())

        self.tumorModel_Needle.Modified()
コード例 #44
0
    def onApplyThreshold(self):
        min, max = self.getDistanceBound()

        newPoints = vtk.vtkPoints()
        newLines = vtk.vtkCellArray()
        newTensors = vtk.vtkFloatArray()
        newTensors.SetNumberOfComponents(9)
        newScalars = vtk.vtkFloatArray()

        points = self.inputPolyData.GetPoints()
        lines = self.inputPolyData.GetLines()
        tensors = self.inputPolyData.GetPointData().GetTensors()
        lines.InitTraversal()

        newId = 0
        for length in self.distanceTable:
            if length <= self.thresholdMax.value and length >= self.thresholdMin.value:
                ids = vtk.vtkIdList()
                lines.GetNextCell(ids)
                newLine = vtk.vtkPolyLine()
                #print(ids.GetNumberOfIds())
                newLine.GetPointIds().SetNumberOfIds(ids.GetNumberOfIds())
                #print(((length-min)/(max-min))*100)
                for i in range(ids.GetNumberOfIds()):
                    newPoints.InsertNextPoint(points.GetPoint(ids.GetId(i)))
                    newLine.GetPointIds().SetId(i, newId)
                    newScalars.InsertNextValue(((length - min) / (max - min)))
                    newId += 1
                    tensorValue = [0] * 9
                    if (tensors != None):
                        for j in range(9):
                            tensorValue[j] = tensors.GetComponent(
                                ids.GetId(i), j)
                    newTensors.InsertNextTuple(tensorValue)
                newLines.InsertNextCell(newLine)

        self.outputPolyData = vtk.vtkPolyData()
        self.outputPolyData.SetPoints(newPoints)
        self.outputPolyData.SetLines(newLines)
        self.outputPolyData.GetPointData().SetTensors(newTensors)
        newScalars.SetName("Length")
        self.outputPolyData.GetPointData().AddArray(newScalars)
        self.outputNode.SetAndObservePolyData(self.outputPolyData)

        chartViewNodes = slicer.mrmlScene.GetNodesByClass(
            'vtkMRMLChartViewNode')
        chartViewNodes.InitTraversal()
        chartViewNode = chartViewNodes.GetNextItemAsObject()

        arrayNode = slicer.mrmlScene.AddNode(slicer.vtkMRMLDoubleArrayNode())
        array = arrayNode.GetArray()
        array.SetNumberOfTuples(10)
        step = (max - min) / 10
        interMin = min
        interMax = min + step
        for i in range(10):
            numberOfFibers = 0
            for length in self.distanceTable:
                if length <= interMax and length >= interMin and length <= self.thresholdMax.value and length >= self.thresholdMin.value:
                    numberOfFibers += 1
            array.SetComponent(i, 0, (interMin + interMax) / 2)
            array.SetComponent(i, 1, numberOfFibers)
            array.SetComponent(i, 2, 0)
            interMin += step
            interMax += step
        chartNode = slicer.mrmlScene.AddNode(slicer.vtkMRMLChartNode())
        chartNode.AddArray("Fiber Length", arrayNode.GetID())
        chartViewNode.SetChartNodeID(chartNode.GetID())

        chartNode.SetProperty('default', 'title', 'Length Distribution')
        chartNode.SetProperty('default', 'xAxisLabel', 'Length')
        chartNode.SetProperty('default', 'yAxisLabel', 'Distribution')
        chartNode.SetProperty('default', 'type', 'Bar')
コード例 #45
0
ファイル: ValveRoi.py プロジェクト: jumbojing/SlicerHeart
    def updateRoi(self):
        if not self.roiModelNode:
            return

        numberOfContourPoints = 0
        annulusPoints = None
        planePosition = None
        planeNormal = None
        if self.annulusContourCurve:
            contourPoints = self.annulusContourCurve.curvePoints  # vtk.vtkPoints()
            numberOfContourPoints = contourPoints.GetNumberOfPoints()
            if numberOfContourPoints > 0:
                annulusPoints = self.annulusContourCurve.getInterpolatedPointsAsArray(
                )  # formerly contourPointsArray_Ras
                [planePosition,
                 planeNormal] = HeartValveLib.planeFit(annulusPoints)
        elif self.valveModel is not None and self.leafletSegmentId is not None:
            annulusPoints = self.getLeafletBoundary()
            if annulusPoints is not None:
                numberOfContourPoints = annulusPoints.shape[1]
                [planePosition,
                 planeNormal] = self.valveModel.getAnnulusContourPlane()

        if numberOfContourPoints <= 0:
            clippingPolyData = vtk.vtkPolyData()
            self.roiModelNode.SetAndObservePolyData(clippingPolyData)
            self.roiModelNode.Modified()
            return

        scale = float(self.roiModelNode.GetAttribute(self.PARAM_SCALE)) * 0.01
        topDistance = float(
            self.roiModelNode.GetAttribute(self.PARAM_TOP_DISTANCE))
        topScale = float(self.roiModelNode.GetAttribute(
            self.PARAM_TOP_SCALE)) * 0.01
        bottomDistance = float(
            self.roiModelNode.GetAttribute(self.PARAM_BOTTOM_DISTANCE))
        bottomScale = float(
            self.roiModelNode.GetAttribute(self.PARAM_BOTTOM_SCALE)) * 0.01

        transformPlaneToWorld = vtk.vtkTransform()
        transformWorldToPlaneMatrix = HeartValveLib.getTransformToPlane(
            planePosition, planeNormal)

        numberOfPoints = annulusPoints.shape[1]
        # Concatenate a 4th line containing 1s so that we can transform the positions using
        # a single matrix multiplication.
        annulusPoints_World = np.row_stack(
            (annulusPoints, np.ones(numberOfPoints)))
        # Point positions in the plane coordinate system:
        annulusPoints_Plane = np.dot(transformWorldToPlaneMatrix,
                                     annulusPoints_World)
        # remove the last row (all ones)
        annulusPoints_Plane = annulusPoints_Plane[0:3, :]

        # Add points for middle, top, and bottom planes
        clippingSurfacePoints = vtk.vtkPoints()
        clippingSurfacePoints.Allocate(
            3 * numberOfContourPoints
        )  # annulus contour + 2x shifted annulus contour
        # Middle plane
        annulusPoints_Plane[0, :] = (
            annulusPoints_Plane[0, :] - annulusPoints_Plane[0, :].mean()
        ) * scale + annulusPoints_Plane[0, :].mean()
        annulusPoints_Plane[1, :] = (
            annulusPoints_Plane[1, :] - annulusPoints_Plane[1, :].mean()
        ) * scale + annulusPoints_Plane[1, :].mean()
        for contourPoint in annulusPoints_Plane.T:
            clippingSurfacePoints.InsertNextPoint(contourPoint)
        meanPosZ = annulusPoints_Plane[:, 2].mean()
        # Top plane
        contourPointsArrayTop_Ras = np.copy(annulusPoints_Plane)
        contourPointsArrayTop_Ras[0, :] = (
            contourPointsArrayTop_Ras[0, :] - annulusPoints_Plane[0, :].mean()
        ) * topScale + annulusPoints_Plane[0, :].mean()
        contourPointsArrayTop_Ras[1, :] = (
            contourPointsArrayTop_Ras[1, :] - annulusPoints_Plane[1, :].mean()
        ) * topScale + annulusPoints_Plane[1, :].mean()
        contourPointsArrayTop_Ras[2, :] = topDistance  # make the plane planar
        for contourPoint in contourPointsArrayTop_Ras.T:
            clippingSurfacePoints.InsertNextPoint(contourPoint)
        # Bottom plane
        contourPointsArrayBottom_Ras = np.copy(annulusPoints_Plane)
        contourPointsArrayBottom_Ras[
            0, :] = (contourPointsArrayBottom_Ras[0, :] - annulusPoints_Plane[
                0, :].mean()) * bottomScale + annulusPoints_Plane[0, :].mean()
        contourPointsArrayBottom_Ras[
            1, :] = (contourPointsArrayBottom_Ras[1, :] - annulusPoints_Plane[
                1, :].mean()) * bottomScale + annulusPoints_Plane[1, :].mean()
        contourPointsArrayBottom_Ras[
            2, :] = -bottomDistance  # make the plane planar
        for contourPoint in contourPointsArrayBottom_Ras.T:
            clippingSurfacePoints.InsertNextPoint(contourPoint)

        # Add frustum surfaces
        strips = vtk.vtkCellArray()
        # Between middle and top
        strips.InsertNextCell(numberOfContourPoints * 2 + 2)
        firstTopPointIndex = numberOfContourPoints
        for i in range(numberOfContourPoints):
            strips.InsertCellPoint(i)
            strips.InsertCellPoint(i + firstTopPointIndex)
        strips.InsertCellPoint(0)
        strips.InsertCellPoint(firstTopPointIndex)
        # Between middle and bottom
        strips.InsertNextCell(numberOfContourPoints * 2 + 2)
        firstBottomPointIndex = numberOfContourPoints * 2
        for i in range(numberOfContourPoints):
            strips.InsertCellPoint(i)
            strips.InsertCellPoint(i + firstBottomPointIndex)
        strips.InsertCellPoint(0)
        strips.InsertCellPoint(firstBottomPointIndex)
        # Top and bottom caps
        polys = vtk.vtkCellArray()
        polys.InsertNextCell(numberOfContourPoints)
        for i in range(numberOfContourPoints, numberOfContourPoints * 2):
            polys.InsertCellPoint(i)
        polys.InsertNextCell(numberOfContourPoints)
        for i in range(numberOfContourPoints * 2, numberOfContourPoints * 3):
            polys.InsertCellPoint(i)

        clippingSurfacePolyData = vtk.vtkPolyData()
        clippingSurfacePolyData.SetPoints(clippingSurfacePoints)
        clippingSurfacePolyData.SetStrips(strips)
        clippingSurfacePolyData.SetPolys(polys)

        triangulator = vtk.vtkTriangleFilter()
        triangulator.SetInputData(clippingSurfacePolyData)

        transformPlaneToWorldMatrix = np.linalg.inv(
            transformWorldToPlaneMatrix)
        transformPlaneToWorldMatrixVtk = vtk.vtkMatrix4x4()
        for colIndex in range(4):
            for rowIndex in range(3):
                transformPlaneToWorldMatrixVtk.SetElement(
                    rowIndex, colIndex, transformPlaneToWorldMatrix[rowIndex,
                                                                    colIndex])
        transformPlaneToWorld.SetMatrix(transformPlaneToWorldMatrixVtk)
        polyTransformToWorld = vtk.vtkTransformPolyDataFilter()
        polyTransformToWorld.SetTransform(transformPlaneToWorld)
        polyTransformToWorld.SetInputConnection(triangulator.GetOutputPort())

        polyTransformToWorld.Update()
        clippingPolyData = polyTransformToWorld.GetOutput()

        self.roiModelNode.SetAndObservePolyData(clippingPolyData)
        self.roiModelNode.Modified()