Example #1
0
  def __init__(self, sliceWidget):

    # keep a flag since events such as sliceNode modified
    # may come during superclass construction, which will
    # invoke our processEvents method
    self.initialized = False

    super(DrawEffectTool,self).__init__(sliceWidget)
    
    # create a logic instance to do the non-gui work
    self.logic = DrawEffectLogic(self.sliceWidget.sliceLogic())

    # interaction state variables
    self.activeSlice = None
    self.lastInsertSLiceNodeMTime = None
    self.actionState = None

    # initialization
    self.xyPoints = vtk.vtkPoints()
    self.rasPoints = vtk.vtkPoints()
    self.polyData = self.createPolyData()

    self.mapper = vtk.vtkPolyDataMapper2D()
    self.actor = vtk.vtkActor2D()
    self.mapper.SetInput(self.polyData)
    self.actor.SetMapper(self.mapper)
    property_ = self.actor.GetProperty()
    property_.SetColor(1,1,0)
    property_.SetLineWidth(1)
    self.renderer.AddActor2D( self.actor )
    self.actors.append( self.actor )

    self.initialized = True
Example #2
0
  def __init__(self, sliceWidget):
    super(LevelTracingEffectTool,self).__init__(sliceWidget)
    
    # create a logic instance to do the non-gui work
    self.logic = LevelTracingEffectLogic(self.sliceWidget.sliceLogic())

    # instance variables
    self.actionState = ''

    # initialization
    self.xyPoints = vtk.vtkPoints()
    self.rasPoints = vtk.vtkPoints()
    self.polyData = vtk.vtkPolyData()

    self.tracingFilter = vtkITK.vtkITKLevelTracingImageFilter()
    self.ijkToXY = vtk.vtkTransform()

    self.mapper = vtk.vtkPolyDataMapper2D()
    self.actor = vtk.vtkActor2D()
    property_ = self.actor.GetProperty()
    property_.SetColor( 107/255., 190/255., 99/255. )
    property_.SetLineWidth( 1 )
    self.mapper.SetInput(self.polyData)
    self.actor.SetMapper(self.mapper)
    property_ = self.actor.GetProperty()
    property_.SetColor(1,1,0)
    property_.SetLineWidth(1)
    self.renderer.AddActor2D( self.actor )
    self.actors.append( self.actor )
Example #3
0
    def __init__(self, sliceWidget):
        super(DrawEffectTool, self).__init__(sliceWidget)

        # create a logic instance to do the non-gui work
        self.logic = DrawEffectLogic(self.sliceWidget.sliceLogic())

        # interaction state variables
        self.activeSlice = None
        self.lastInsertSLiceNodeMTime = None
        self.actionState = None

        # initialization
        self.xyPoints = vtk.vtkPoints()
        self.rasPoints = vtk.vtkPoints()
        self.polyData = self.createPolyData()

        self.mapper = vtk.vtkPolyDataMapper2D()
        self.actor = vtk.vtkActor2D()
        self.mapper.SetInput(self.polyData)
        self.actor.SetMapper(self.mapper)
        property_ = self.actor.GetProperty()
        property_.SetColor(1, 1, 0)
        property_.SetLineWidth(1)
        self.renderer.AddActor2D(self.actor)
        self.actors.append(self.actor)
Example #4
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)
Example #5
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)
Example #6
0
    def __init__(self, sliceWidget):

        # keep a flag since events such as sliceNode modified
        # may come during superclass construction, which will
        # invoke our processEvents method
        self.initialized = False

        super(DrawEffectTool, self).__init__(sliceWidget)

        # create a logic instance to do the non-gui work
        self.logic = DrawEffectLogic(self.sliceWidget.sliceLogic())

        # interaction state variables
        self.activeSlice = None
        self.lastInsertSLiceNodeMTime = None
        self.actionState = None

        # initialization
        self.xyPoints = vtk.vtkPoints()
        self.rasPoints = vtk.vtkPoints()
        self.polyData = self.createPolyData()

        self.mapper = vtk.vtkPolyDataMapper2D()
        self.actor = vtk.vtkActor2D()
        self.mapper.SetInput(self.polyData)
        self.actor.SetMapper(self.mapper)
        property_ = self.actor.GetProperty()
        property_.SetColor(1, 1, 0)
        property_.SetLineWidth(1)
        self.renderer.AddActor2D(self.actor)
        self.actors.append(self.actor)

        self.initialized = True
Example #7
0
    def __init__(self, sliceWidget):
        super(DrawEffectTool, self).__init__(sliceWidget)

        # create a logic instance to do the non-gui work
        self.logic = DrawEffectLogic(self.sliceWidget.sliceLogic())

        # interaction state variables
        self.activeSlice = None
        self.lastInsertSLiceNodeMTime = None
        self.actionState = None

        # initialization
        self.xyPoints = vtk.vtkPoints()
        self.rasPoints = vtk.vtkPoints()
        self.polyData = self.createPolyData()

        self.mapper = vtk.vtkPolyDataMapper2D()
        self.actor = vtk.vtkActor2D()
        self.mapper.SetInput(self.polyData)
        self.actor.SetMapper(self.mapper)
        property_ = self.actor.GetProperty()
        property_.SetColor(1, 1, 0)
        property_.SetLineWidth(1)
        self.renderer.AddActor2D(self.actor)
        self.actors.append(self.actor)
Example #8
0
  def performLinearRegistration(self,fixed,moving,landmarks,transform,transformed):
    """Perform the linear transform using the vtkLandmarkTransform class"""

    print('performing registration')
    transformed.SetAndObserveTransformNodeID(transform.GetID())

    # try to use user selection, but fall back if not enough points are available
    landmarkTransform = vtk.vtkLandmarkTransform()
    if self.linearMode == 'Rigid':
      landmarkTransform.SetModeToRigidBody()
    if self.linearMode == 'Similarity':
      landmarkTransform.SetModeToSimilarity()
    if self.linearMode == 'Affine':
      landmarkTransform.SetModeToAffine()
    if len(landmarks.values()) < 3:
      landmarkTransform.SetModeToRigidBody()

    points = {}
    point = [0,]*3
    for volumeNode in (fixed,moving):
      points[volumeNode] = vtk.vtkPoints()
    for fiducials in landmarks.values():
      for volumeNode,fid in zip((fixed,moving),fiducials):
        fid.GetFiducialCoordinates(point)
        points[volumeNode].InsertNextPoint(point)
        print("%s: %s" % (volumeNode.GetName(), str(point)))
    landmarkTransform.SetSourceLandmarks(points[moving])
    landmarkTransform.SetTargetLandmarks(points[fixed])
    landmarkTransform.Update()
    transform.SetAndObserveMatrixTransformToParent(landmarkTransform.GetMatrix())
Example #9
0
  def ComputeMeanDistance(self, inputFiducials, inputModel, transform):
    surfacePoints = vtk.vtkPoints()
    cellId = vtk.mutable(0)
    subId = vtk.mutable(0)
    dist2 = vtk.mutable(0.0)
    locator = vtk.vtkCellLocator()
    locator.SetDataSet(inputModel.GetPolyData())
    locator.SetNumberOfCellsPerBucket(1)
    locator.BuildLocator()
    totalDistance = 0.0

    n = inputFiducials.GetNumberOfFiducials()
    m = vtk.vtkMath()
    for fiducialIndex in range(0, n):
      originalPoint = [0, 0, 0]
      inputFiducials.GetNthFiducialPosition(fiducialIndex, originalPoint)
      transformedPoint = [0, 0, 0, 1]
      #transform.GetTransformToParent().TransformVector(originalPoint, transformedPoint)
      originalPoint.append(1)
      transform.GetTransformToParent().MultiplyPoint(originalPoint, transformedPoint)
      #transformedPoints.InsertNextPoint(transformedPoint)
      surfacePoint = [0, 0, 0]
      transformedPoint.pop()
      locator.FindClosestPoint(transformedPoint, surfacePoint, cellId, subId, dist2)
      totalDistance = totalDistance + math.sqrt(dist2)

    return (totalDistance / n)
  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 )
Example #11
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
  def ComputeMeanDistance(self, inputFiducials, inputModel, transform ):
    surfacePoints = vtk.vtkPoints()
    cellId = vtk.mutable(0)
    subId = vtk.mutable(0)
    dist2 = vtk.mutable(0.0)
    locator = vtk.vtkCellLocator()
    locator.SetDataSet( inputModel.GetPolyData() )
    locator.SetNumberOfCellsPerBucket( 1 )
    locator.BuildLocator()
    totalDistance = 0.0

    n = inputFiducials.GetNumberOfFiducials()
    m = vtk.vtkMath()
    for fiducialIndex in range( 0, n ):
      originalPoint = [0, 0, 0]
      inputFiducials.GetNthFiducialPosition( fiducialIndex, originalPoint )
      transformedPoint = [0, 0, 0, 1]
      #transform.GetTransformToParent().TransformVector( originalPoint, transformedPoint )
      originalPoint.append(1)
      transform.GetTransformToParent().MultiplyPoint( originalPoint, transformedPoint )
      #transformedPoints.InsertNextPoint( transformedPoint )
      surfacePoint = [0, 0, 0]
      transformedPoint.pop()
      locator.FindClosestPoint( transformedPoint, surfacePoint, cellId, subId, dist2 )
      totalDistance = totalDistance + math.sqrt(dist2)

    return ( totalDistance / n )
Example #13
0
  def onLandmarkMoved_NOT(self,state):
    """Perform the linear transform using the vtkLandmarkTransform class"""
    if state.transformed.GetTransformNodeID() != state.linearTransform.GetID():
      state.transformed.SetAndObserveTransformNodeID(state.linearTransform.GetID())

    self.linearMode = "Rigid"

    # try to use user selection, but fall back if not enough points are available
    landmarkTransform = vtk.vtkLandmarkTransform()
    if self.linearMode == 'Rigid':
      landmarkTransform.SetModeToRigidBody()
    if self.linearMode == 'Similarity':
      landmarkTransform.SetModeToSimilarity()
    if self.linearMode == 'Affine':
      landmarkTransform.SetModeToAffine()
    if state.fixedFiducials.GetNumberOfFiducials() < 3:
      landmarkTransform.SetModeToRigidBody()

    points = {}
    point = [0,]*3
    for volumeNode in (state.fixed,state.moving):
      points[volumeNode] = vtk.vtkPoints()
    indices = range(state.fixedFiducials.GetNumberOfFiducials())
    fiducialLists = (state.fixedFiducials,state.movingFiducials)
    volumeNodes = (state.fixed,state.moving)
    for fiducials,volumeNode in zip(fiducialLists,volumeNodes):
      for index in indices:
        fiducials.GetNthFiducialPosition(index,point)
        points[volumeNode].InsertNextPoint(point)
    landmarkTransform.SetSourceLandmarks(points[state.moving])
    landmarkTransform.SetTargetLandmarks(points[state.fixed])
    landmarkTransform.Update()
    t = state.linearTransform
    t.SetAndObserveMatrixTransformToParent(landmarkTransform.GetMatrix())
Example #14
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 )
Example #15
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)
Example #16
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 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()
 def initializeErrorTransform(self, errorTransformNode):
   if not errorTransformNode:
     return
   alwaysClearOutputTransformOnStart = True
   errorTransform=errorTransformNode.GetTransformToParentAs('vtkThinPlateSplineTransform', False)
   if alwaysClearOutputTransformOnStart or not errorTransform:
     errorTransform=vtk.vtkThinPlateSplineTransform()
     groundTruthPoints=vtk.vtkPoints()
     mappedPoints=vtk.vtkPoints()
     errorTransform.SetSourceLandmarks(groundTruthPoints)
     errorTransform.SetTargetLandmarks(mappedPoints)
     errorTransformNode.SetAndObserveTransformToParent(errorTransform)
     # We need to use R basis function to be able to save the transform
     # VTK does not set the basis for the inverse transform (probably a bug)
     # so we set that manually.
     errorTransformNode.GetTransformToParent().SetBasisToR()
     errorTransformNode.GetTransformFromParent().SetBasisToR()
 def initializeErrorTransform(self, errorTransformNode):
   if not errorTransformNode:
     return
   alwaysClearOutputTransformOnStart = True
   errorTransform=errorTransformNode.GetTransformToParentAs('vtkThinPlateSplineTransform', False)
   if alwaysClearOutputTransformOnStart or not errorTransform:
     errorTransform=vtk.vtkThinPlateSplineTransform()
     groundTruthPoints=vtk.vtkPoints()
     mappedPoints=vtk.vtkPoints()
     errorTransform.SetSourceLandmarks(groundTruthPoints)
     errorTransform.SetTargetLandmarks(mappedPoints)
     errorTransformNode.SetAndObserveTransformToParent(errorTransform)
     # We need to use R basis function to be able to save the transform
     # VTK does not set the basis for the inverse transform (probably a bug)
     # so we set that manually.
     errorTransformNode.GetTransformToParent().SetBasisToR()
     errorTransformNode.GetTransformFromParent().SetBasisToR()
    def DepthMapToPointCloud(self, depthmapFilename, rgbFilename):
        # Create point cloud
        depthImage = imageio.imread(depthmapFilename)
        rgbImage = imageio.imread(rgbFilename)

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

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

        points = vtk.vtkPoints()

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

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

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

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

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

        return modelNode
 def 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()  
  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()
Example #23
0
def ConvertTextureToPointAttribute(modelNode, textureImageNode):
  polyData=modelNode.GetPolyData()
  textureImageFlipVert=vtk.vtkImageFlip()
  textureImageFlipVert.SetFilteredAxis(1)
  textureImageFlipVert.SetInputConnection(textureImageNode.GetImageDataConnection())
  textureImageFlipVert.Update()
  textureImageData=textureImageFlipVert.GetOutput()
  pointData=polyData.GetPointData()
  tcoords=pointData.GetTCoords()
  numOfPoints=pointData.GetNumberOfTuples()
  assert numOfPoints==tcoords.GetNumberOfTuples(), "Number of texture coordinates does not equal number of points"
  textureSamplingPointsUv=vtk.vtkPoints()
  textureSamplingPointsUv.SetNumberOfPoints(numOfPoints)
  for pointIndex in xrange(numOfPoints):
    uv=tcoords.GetTuple2(pointIndex)
    textureSamplingPointsUv.SetPoint(pointIndex, uv[0], uv[1], 0)

  textureSamplingPointDataUv=vtk.vtkPolyData()
  uvToXyz=vtk.vtkTransform()
  textureImageDataSpacingSpacing=textureImageData.GetSpacing()
  textureImageDataSpacingOrigin=textureImageData.GetOrigin()
  textureImageDataSpacingDimensions=textureImageData.GetDimensions()
  uvToXyz.Scale(textureImageDataSpacingDimensions[0]/textureImageDataSpacingSpacing[0], textureImageDataSpacingDimensions[1]/textureImageDataSpacingSpacing[1], 1)
  uvToXyz.Translate(textureImageDataSpacingOrigin)
  textureSamplingPointDataUv.SetPoints(textureSamplingPointsUv)
  transformPolyDataToXyz=vtk.vtkTransformPolyDataFilter()
  transformPolyDataToXyz.SetInputData(textureSamplingPointDataUv)
  transformPolyDataToXyz.SetTransform(uvToXyz)
  probeFilter=vtk.vtkProbeFilter()
  probeFilter.SetInputConnection(transformPolyDataToXyz.GetOutputPort())
  probeFilter.SetSourceData(textureImageData)
  probeFilter.Update()
  rgbPoints=probeFilter.GetOutput().GetPointData().GetArray('ImageScalars')
  colorArrayRed=vtk.vtkDoubleArray()
  colorArrayRed.SetName('ColorRed')
  colorArrayRed.SetNumberOfTuples(numOfPoints)
  colorArrayGreen=vtk.vtkDoubleArray()
  colorArrayGreen.SetName('ColorGreen')
  colorArrayGreen.SetNumberOfTuples(numOfPoints)
  colorArrayBlue=vtk.vtkDoubleArray()
  colorArrayBlue.SetName('ColorBlue')
  colorArrayBlue.SetNumberOfTuples(numOfPoints)
  for pointIndex in xrange(numOfPoints):
    rgb=rgbPoints.GetTuple3(pointIndex)
    colorArrayRed.SetValue(pointIndex,rgb[0])
    colorArrayGreen.SetValue(pointIndex,rgb[1])
    colorArrayBlue.SetValue(pointIndex,rgb[2])
  colorArrayRed.Modified()
  colorArrayGreen.Modified()
  colorArrayBlue.Modified()
  pointData.AddArray(colorArrayRed)
  pointData.AddArray(colorArrayGreen)
  pointData.AddArray(colorArrayBlue)
  pointData.Modified()
  polyData.Modified()
Example #24
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 )
Example #25
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)
  def CalculatePlane( self, inPoints, base, dir1, dir2, normal ):

    # Create arrays for the dataset
    points2D = vtk.vtkPoints()
  
    arrayX = vtk.vtkDoubleArray()
    arrayX.SetNumberOfComponents( 1 )
    arrayX.SetName ( 'X' )
    arrayY = vtk.vtkDoubleArray()
    arrayY.SetNumberOfComponents( 1 )
    arrayY.SetName ( 'Y' )
    arrayZ = vtk.vtkDoubleArray()
    arrayZ.SetNumberOfComponents( 1 )
    arrayZ.SetName ( 'Z' )
    
    # Add the points to the table
    for i in range( 0, inPoints.GetNumberOfPoints() ):
    
      currPoint = [ 0, 0, 0 ]
      inPoints.GetPoint( i, currPoint )   
      
      arrayX.InsertNextValue( currPoint[ 0 ] )
      arrayY.InsertNextValue( currPoint[ 1 ] ) 
      arrayZ.InsertNextValue( currPoint[ 2 ] )
    
    # Create a table for the dataset
    table = vtk.vtkTable()
    table.AddColumn( arrayX )
    table.AddColumn( arrayY )
    table.AddColumn( arrayZ )
    
    # Setting up the PCA
    pca = vtk.vtkPCAStatistics()
    pca.SetInputData( vtk.vtkStatisticsAlgorithm.INPUT_DATA, table )
    pca.SetColumnStatus( 'X', 1 )
    pca.SetColumnStatus( 'Y', 1 )
    pca.SetColumnStatus( 'Z', 1 )
    pca.RequestSelectedColumns()
    pca.SetDeriveOption( True )
    pca.Update()
    
    eigvec = vtk.vtkDoubleArray()
    pca.GetEigenvectors( eigvec )
  
    
    eigvec.GetTuple( 0, dir1 )
    eigvec.GetTuple( 1, dir2 )
    eigvec.GetTuple( 2, normal )
  
    mean = self.CalculateMean( inPoints )
    base[0] = mean[0]
    base[1] = mean[1]
    base[2] = mean[2]
Example #27
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()        
Example #28
0
def convertNumpyToVTK(A):
    x,y=A.shape
    points=vtk.vtkPoints()
    for i in range(x):
        points.InsertNextPoint(A[i,0], A[i,1], A[i,2])
#
    return points


# def test():
#     mrml=slicer.mrmlScene
#     tnode=slicer.vtkMRMLScalarVolumeNode()
#     mrml.AddNode(tnode)
# #
#     movingNode=getNode('3958-f_baseline')
#     movingLM=getNode('3958-f_baseline-landmarks')
# #
#     fixedNode=getNode('3964-m_baseline')
#     fixedLM=getNode('3964-m_baseline-landmarks')
#     #
#     fixedPoints=convertFudicialToVTKPoint(fixedLM)
#     movingPoints=convertFudicialToVTKPoint(movingLM)
#     #
#     performThinPlateRegistration(movingNode, fixedNode, fixedPoints,movingPoints,movingNode)


# #to visualize the transform
# tnode=slicer.vtkMRMLNonlinearTransformNode()
# mrml=slicer.mrmlScene
# mrml.AddNode(tnode)
# movingNode=getNode('3958-f_baseline')
# fixedNode=getNode('3964-m_baseline')
# fFNode=getNode('3958-f_baseline-landmarks')
# mFNode=getNode('3964-m_baseline-landmarks')
# mLM=convertFudicialToVTKPoint(mFNode)
# fLM=convertFudicialToVTKPoint(fFNode)
# tps=performThinPlateRegistration(mLM,fLM)
# log=slicer.modulelogic.vtkSlicerVolumesLogic()
# log.CloneVolume(slicer.mrmlScene,movingNode, 'tmpNode')
# tmpNode=getNode("tmpNode")
# resliceThroughTransform( movingNode, tps, fixedNode, tmpNode)

# tnode.SetAndObserveTransformFromParent(tps)
# tnode.SetAndObserveTransformToParent(tps3.inInverse())
# Traceback (most recent call last):
#   File "<console>", line 1, in <module>
# AttributeError: inInverse
# >>> tnode.SetAndObserveTransformToParent(tps3.Inverse())
# >>> tps3.SetTargetLandmarks(mLM)
# >>> tps3.SetTargetLandmarks(fLM)
# >>>
        def updateTpsTransform(caller, eventid):
            numPerEdge = self.fromFids.GetNumberOfFiducials()
            if numPerEdge != self.toFids.GetNumberOfFiducials():
                print
                'Error: Fiducial numbers are not equal!'
                return

            fp = vtk.vtkPoints()
            tp = vtk.vtkPoints()
            f = [0, 0, 0]
            t = [0, 0, 0]

            for i in range(numPerEdge):
                self.fromFids.GetNthFiducialPosition(i, f)
                self.toFids.GetNthFiducialPosition(i, t)
                fp.InsertNextPoint(f)
                tp.InsertNextPoint(t)

            tps = vtk.vtkThinPlateSplineTransform()
            tps.SetSourceLandmarks(fp)
            tps.SetTargetLandmarks(tp)
            tps.SetBasisToR()
            tNode.SetAndObserveTransformToParent(tps)
 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)
Example #31
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()
Example #32
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)
Example #33
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()
 def initialize(self):
     self.layoutManager=slicer.app.layoutManager()
     self.threeDWidget=self.layoutManager.threeDWidget(0)
     self.threeDView=self.threeDWidget.threeDView()
     self.renderWindow=self.threeDView.renderWindow()
     self.renderers=self.renderWindow.GetRenderers()
     self.renderer=self.renderers.GetFirstRenderer()
     
     self.polydata = vtk.vtkPolyData()
     self.points = vtk.vtkPoints()
     self.planeSource = vtk.vtkPlaneSource()
     self.mapper = vtk.vtkPolyDataMapper()
     self.actor = vtk.vtkActor()
     self.renderer.AddViewProp(self.actor)
     self.renderWindow.AddRenderer(self.renderer)
Example #35
0
    def initialize(self):
        self.layoutManager = slicer.app.layoutManager()
        self.threeDWidget = self.layoutManager.threeDWidget(0)
        self.threeDView = self.threeDWidget.threeDView()
        self.renderWindow = self.threeDView.renderWindow()
        self.renderers = self.renderWindow.GetRenderers()
        self.renderer = self.renderers.GetFirstRenderer()

        self.polydata = vtk.vtkPolyData()
        self.points = vtk.vtkPoints()
        self.planeSource = vtk.vtkPlaneSource()
        self.mapper = vtk.vtkPolyDataMapper()
        self.actor = vtk.vtkActor()
        self.renderer.AddViewProp(self.actor)
        self.renderWindow.AddRenderer(self.renderer)
Example #36
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)
 def vtkPointForVolumes(self, volumeNodes, fiducialNodes):
   """Return dictionary of vtkPoints instances containing the fiducial points
   associated with current landmarks, indexed by volume"""
   points = {}
   point = [0,]*3
   for volumeNode in volumeNodes:
     points[volumeNode] = vtk.vtkPoints()
   ficucialCount = fiducialNodes[0].GetNumberOfFiducials()
   for fiducialNode in fiducialNodes:
     if ficucialCount != fiducialNode.GetNumberOfFiducials():
       raise Exception("Fiducial counts don't match {0}".format(ficucialCount))
   indices = range(ficucialCount)
   for fiducials,volumeNode in zip(fiducialNodes,volumeNodes):
     for index in indices:
       fiducials.GetNthFiducialPosition(index,point)
       points[volumeNode].InsertNextPoint(point)
   return points
Example #38
0
def convertFudicialToVTKPoint(fnode):
    import numpy as np
    numberOfLM=fnode.GetNumberOfFiducials()
    x=y=z=0
    loc=[x,y,z]
    lmData=np.zeros((numberOfLM,3))
    #
    for i in range(numberOfLM):
        fnode.GetNthFiducialPosition(i,loc)
        lmData[i,:]=np.asarray(loc)
    #return lmData
    #
    points=vtk.vtkPoints()
    for i in range(numberOfLM):
        points.InsertNextPoint(lmData[i,0], lmData[i,1], lmData[i,2])
#
    return points
  def FiducialsToPolyData(self, fiducials, polyData):

    points = vtk.vtkPoints()
    n = fiducials.GetNumberOfFiducials()
    for fiducialIndex in range( 0, n ):
      p = [0, 0, 0]
      fiducials.GetNthFiducialPosition( fiducialIndex, p )
      points.InsertNextPoint( p )

    tempPolyData = vtk.vtkPolyData()
    tempPolyData.SetPoints( points )

    vertex = vtk.vtkVertexGlyphFilter()
    vertex.SetInputData( tempPolyData )
    vertex.Update()

    polyData.ShallowCopy( vertex.GetOutput() )
Example #40
0
  def FiducialsToPolyData(self, fiducials, polyData):

    points = vtk.vtkPoints()
    n = fiducials.GetNumberOfFiducials()
    for fiducialIndex in range(0, n):
      p = [0, 0, 0]
      fiducials.GetNthFiducialPosition(fiducialIndex, p)
      points.InsertNextPoint(p)

    tempPolyData = vtk.vtkPolyData()
    tempPolyData.SetPoints(points)

    vertex = vtk.vtkVertexGlyphFilter()
    vertex.SetInputData(tempPolyData)
    vertex.Update()

    polyData.ShallowCopy(vertex.GetOutput())
Example #41
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
Example #42
0
    def handLine(self, whichHand='Left'):
        """Create a line to show the path from the hand to the table
    """
        handLineName = 'DropLine-%s' % whichHand
        handLineNode = slicer.util.getNode(handLineName)
        if not handLineNode:
            points = vtk.vtkPoints()
            polyData = vtk.vtkPolyData()
            polyData.SetPoints(points)

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

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

            for point in ((0, 0, 0), (1, 1, 1)):
                pointIndex = points.InsertNextPoint(*point)
                linesIDArray.InsertNextTuple1(pointIndex)
                linesIDArray.SetTuple1(0, linesIDArray.GetNumberOfTuples() - 1)
                lines.SetNumberOfCells(1)

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

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

            # Add to slicer.mrmlScene
            modelDisplay.SetInputPolyData(handLineNode.GetPolyData())
            slicer.mrmlScene.AddNode(handLineNode)
        return handLineNode
  def 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)
    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)
Example #45
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)
Example #46
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)
Example #47
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
    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)
Example #49
0
 def PointsToPolyData(self, listOfPoints):
     """ Converts 3D list of points of an array into a polyData line
 The connections between this line are simply the order in which 
 they are provided
 """
     points = vtk.vtkPoints()
     idlist = vtk.vtkIdList()
     numOfPoints = len(listOfPoints)
     if numOfPoints == 0:
         print("WARNING:No points to convert to polyData")
         return vtk.vtkPolyData()  #returning Blank PolyData
     points.SetNumberOfPoints(numOfPoints)
     for i in range(numOfPoints):
         points.InsertPoint(i, listOfPoints[i])  #Add the points
         idlist.InsertNextId(i)
     polyData = vtk.vtkPolyData()
     polyData.Allocate()
     polyData.InsertNextCell(vtk.VTK_LINE, idlist)
     polyData.SetPoints(points)
     return polyData
Example #50
0
 def PointsToPolyData(self,listOfPoints):
   """ Converts 3D list of points of an array into a polyData line
   The connections between this line are simply the order in which 
   they are provided
   """
   points=vtk.vtkPoints()
   idlist = vtk.vtkIdList()
   numOfPoints=len(listOfPoints)
   if numOfPoints==0:
     print ("WARNING:No points to convert to polyData")
     return vtk.vtkPolyData() #returning Blank PolyData
   points.SetNumberOfPoints(numOfPoints)
   for i in range (numOfPoints):
     points.InsertPoint(i, listOfPoints[i]) #Add the points
     idlist.InsertNextId(i)
   polyData=vtk.vtkPolyData()
   polyData.Allocate()
   polyData.InsertNextCell(vtk.VTK_LINE,idlist)
   polyData.SetPoints(points)
   return polyData
    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)
Example #52
0
    def __init__(self):
        self.controlPointsMarkupNode = None
        self.curveModelNode = None

        self.tubeRadius = 5.0
        self.tubeResolution = 20

        self.numberOfIntermediatePoints = 20

        self.curvePoly = vtk.vtkPolyData()
        self.curvePoints = vtk.vtkPoints()
        self.curvePoly.SetPoints(self.curvePoints)

        self.curvePointsLocator = vtk.vtkPointLocator()
        self.curvePointsLocator.SetDataSet(self.curvePoly)

        self.interpolationMethod = InterpolationLinear
        self.pointInterpolationFunction = self.getInterpolatedPointsLinear

        self.closed = False
  def startTransformMapping(self, groundTruthTransformNode, mappedTransformNode, outputVisitedPointsModelNode, positionErrorTransformNode, orientationErrorTransformNode):
    self.removeObservers()
    self.groundTruthTransformNode = groundTruthTransformNode
    self.mappedTransformNode = mappedTransformNode
    self.outputVisitedPointsModelNode = outputVisitedPointsModelNode
    self.positionErrorTransformNode = positionErrorTransformNode
    self.orientationErrorTransformNode = orientationErrorTransformNode

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

    if self.outputVisitedPointsModelNode:

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

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

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

    # Start the updates
    self.addObservers()
    self.onGroundTruthTransformNodeModified(0,0)
  def startTransformMapping(self, groundTruthTransformNode, mappedTransformNode, outputVisitedPointsModelNode, positionErrorTransformNode, orientationErrorTransformNode):
    self.removeObservers()
    self.groundTruthTransformNode = groundTruthTransformNode
    self.mappedTransformNode = mappedTransformNode
    self.outputVisitedPointsModelNode = outputVisitedPointsModelNode
    self.positionErrorTransformNode = positionErrorTransformNode
    self.orientationErrorTransformNode = orientationErrorTransformNode

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

    if self.outputVisitedPointsModelNode:

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

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

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

    # Start the updates
    self.addObservers()
    self.onGroundTruthTransformNodeModified(0,0)
Example #55
0
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
Example #56
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)
    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')
Example #58
0
    def __init__(self, path, fiducialListNode):

        fids = fiducialListNode
        scene = slicer.mrmlScene

        points = vtk.vtkPoints()
        polyData = vtk.vtkPolyData()
        polyData.SetPoints(points)

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

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

        for point in path:
            pointIndex = points.InsertNextPoint(*point)
            linesIDArray.InsertNextTuple1(pointIndex)
            linesIDArray.SetTuple1(0, linesIDArray.GetNumberOfTuples() - 1)
            lines.SetNumberOfCells(1)

        # Create model node
        model = slicer.vtkMRMLModelNode()
        model.SetScene(scene)
        model.SetName(scene.GenerateUniqueName("Path-%s" % fids.GetName()))
        model.SetAndObservePolyData(polyData)

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

        # Add to scene
        modelDisplay.SetInputPolyData(model.GetPolyData())
        scene.AddNode(model)

        # Camera cursor
        sphere = vtk.vtkSphereSource()
        sphere.Update()

        # Create model node
        cursor = slicer.vtkMRMLModelNode()
        cursor.SetScene(scene)
        cursor.SetName(scene.GenerateUniqueName("Cursor-%s" % fids.GetName()))
        cursor.SetAndObservePolyData(sphere.GetOutput())

        # Create display node
        cursorModelDisplay = slicer.vtkMRMLModelDisplayNode()
        cursorModelDisplay.SetColor(1, 0, 0)  # red
        cursorModelDisplay.SetScene(scene)
        scene.AddNode(cursorModelDisplay)
        cursor.SetAndObserveDisplayNodeID(cursorModelDisplay.GetID())

        # Add to scene
        cursorModelDisplay.SetInputPolyData(sphere.GetOutput())
        scene.AddNode(cursor)

        # Create transform node
        transform = slicer.vtkMRMLLinearTransformNode()
        transform.SetName(
            scene.GenerateUniqueName("Transform-%s" % fids.GetName()))
        scene.AddNode(transform)
        cursor.SetAndObserveTransformNodeID(transform.GetID())

        self.transform = transform
    def clipSurfaceAtEndPoints(self, networkPolyData, surfacePolyData):
        '''
        Clips the surfacePolyData on the endpoints identified using the networkPolyData.
        
        Returns a tupel of the form [clippedPolyData, endpointsPoints]
        '''
        # import the vmtk libraries
        try:
            from libvtkvmtkComputationalGeometryPython import *
            from libvtkvmtkMiscPython import *
        except ImportError:
            print "FAILURE: Unable to import the SlicerVmtk4 libraries!"

        cleaner = vtk.vtkCleanPolyData()
        cleaner.SetInput(networkPolyData)
        cleaner.Update()
        network = cleaner.GetOutput()
        network.BuildCells()
        network.BuildLinks(0)
        endpointIds = vtk.vtkIdList()

        radiusArray = network.GetPointData().GetArray('Radius')

        endpoints = vtk.vtkPolyData()
        endpointsPoints = vtk.vtkPoints()
        endpointsRadius = vtk.vtkDoubleArray()
        endpointsRadius.SetName('Radius')
        endpoints.SetPoints(endpointsPoints)
        endpoints.GetPointData().AddArray(endpointsRadius)

        radiusFactor = 1.2
        minRadius = 0.01

        for i in range(network.GetNumberOfCells()):
            numberOfCellPoints = network.GetCell(i).GetNumberOfPoints()
            pointId0 = network.GetCell(i).GetPointId(0)
            pointId1 = network.GetCell(i).GetPointId(numberOfCellPoints - 1)

            pointCells = vtk.vtkIdList()
            network.GetPointCells(pointId0, pointCells)
            numberOfEndpoints = endpointIds.GetNumberOfIds()
            if pointCells.GetNumberOfIds() == 1:
                pointId = endpointIds.InsertUniqueId(pointId0)
                if pointId == numberOfEndpoints:
                    point = network.GetPoint(pointId0)
                    radius = radiusArray.GetValue(pointId0)
                    radius = max(radius, minRadius)
                    endpointsPoints.InsertNextPoint(point)
                    endpointsRadius.InsertNextValue(radiusFactor * radius)

            pointCells = vtk.vtkIdList()
            network.GetPointCells(pointId1, pointCells)
            numberOfEndpoints = endpointIds.GetNumberOfIds()
            if pointCells.GetNumberOfIds() == 1:
                pointId = endpointIds.InsertUniqueId(pointId1)
                if pointId == numberOfEndpoints:
                    point = network.GetPoint(pointId1)
                    radius = radiusArray.GetValue(pointId1)
                    radius = max(radius, minRadius)
                    endpointsPoints.InsertNextPoint(point)
                    endpointsRadius.InsertNextValue(radiusFactor * radius)

        polyBall = vtkvmtkPolyBall()
        polyBall.SetInput(endpoints)
        polyBall.SetPolyBallRadiusArrayName('Radius')

        clipper = vtk.vtkClipPolyData()
        clipper.SetInput(surfacePolyData)
        clipper.SetClipFunction(polyBall)
        clipper.Update()

        connectivityFilter = vtk.vtkPolyDataConnectivityFilter()
        connectivityFilter.SetInput(clipper.GetOutput())
        connectivityFilter.ColorRegionsOff()
        connectivityFilter.SetExtractionModeToLargestRegion()
        connectivityFilter.Update()

        clippedSurface = connectivityFilter.GetOutput()

        outPolyData = vtk.vtkPolyData()
        outPolyData.DeepCopy(clippedSurface)
        outPolyData.Update()

        return [outPolyData, endpointsPoints]