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
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 )
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)
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)
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)
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
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())
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 )
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 )
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())
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)
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 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()
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()
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 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]
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()
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)
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 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)
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)
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)
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
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() )
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())
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 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)
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)
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)
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)
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 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)
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 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
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')
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]