Пример #1
0
    def GenerateMould(self, facePolydata, distanceFromMask, ROI, tubePolydata, clippedFace):
        ROIExtents = self.utility.GetROIExtents(ROI)
        outerFaceImplicitFunction = vtk.vtkImplicitModeller()
        outerFaceImplicitFunction.SetInputConnection(facePolydata.GetOutputPort())
        outerFaceImplicitFunction.SetSampleDimensions(70, 70, 70)
        outerFaceImplicitFunction.SetMaximumDistance(distanceFromMask)
        outerFaceImplicitFunction.SetModelBounds(ROIExtents)
        outerFaceImplicitFunction.SetProcessModeToPerVoxel()
        outerMaskContourFunction = vtk.vtkContourFilter()
        # TODO Find out the the allowed thinkness of the plastic
        THICKNESS = 3
        outerMaskContourFunction.SetValue(0, THICKNESS)
        outerMaskContourFunction.SetInputConnection(outerFaceImplicitFunction.GetOutputPort())

        outerFaceNormalsFunction = vtk.vtkPolyDataNormals()
        outerFaceNormalsFunction.AutoOrientNormalsOn()
        outerFaceNormalsFunction.AddInputConnection(outerMaskContourFunction.GetOutputPort())
        # Subtract the Tubes from the mask
        subtractionFilter1 = vtk.vtkBooleanOperationPolyDataFilter()
        subtractionFilter1.SetOperationToDifference()
        subtractionFilter1.SetInputConnection(0, outerFaceNormalsFunction.GetOutputPort())
        subtractionFilter1.SetInputConnection(1, tubePolydata.GetOutputPort())
        # Subtract the inner face from the outer face to make the mask
        subtractionFilter2 = vtk.vtkBooleanOperationPolyDataFilter()
        subtractionFilter2.SetOperationToDifference()
        subtractionFilter2.SetInputConnection(0, subtractionFilter1.GetOutputPort())
        subtractionFilter2.SetInputConnection(1, clippedFace.GetOutputPort())
        x = self.utility.DisplayPolyData("Mask", subtractionFilter2.GetOutput())
        x.SetColor(0.8, 0.8, 0.8)
        x.SetOpacity(1)
Пример #2
0
    def planeModel(self, scene, normal, origin, name, color):
        """ Create a plane model node which can be viewed in the 3D View """
        
        #A plane source
        plane = vtk.vtkPlane()
        plane.SetOrigin(origin)
        plane.SetNormal(normal)
        
        planeSample = vtk.vtkSampleFunction()
        planeSample.SetImplicitFunction(plane)
        planeSample.SetModelBounds(-100,100,-100,100,-100,100)
        planeSample.SetSampleDimensions(100,100,100)
        planeSample.ComputeNormalsOff()
        planeContour = vtk.vtkContourFilter()
        planeContour.SetInput(planeSample.GetOutput())
        
        # Create plane model node
        planeNode = slicer.vtkMRMLModelNode()
        planeNode.SetScene(scene)
        planeNode.SetName(name)
        planeNode.SetAndObservePolyData(planeContour.GetOutput())
        
        # Create plane display model node
        planeModelDisplay = slicer.vtkMRMLModelDisplayNode()
        planeModelDisplay.SetColor(color)
        planeModelDisplay.SetBackfaceCulling(0)
        planeModelDisplay.SetScene(scene)
        scene.AddNode(planeModelDisplay)
        planeNode.SetAndObserveDisplayNodeID(planeModelDisplay.GetID())

        #Add to scene
        planeModelDisplay.SetInputPolyData(planeContour.GetOutput())
        scene.AddNode(planeNode)
        return plane
Пример #3
0
    def MinimumDistanceMask(self,
                            vtkAlgorythmObject,
                            distanceFromMask,
                            ROI,
                            ruler,
                            isBubble=False):
        """ Takes an algorythm object which is will send through a pipeline to 
    create a mask defining the minimum distance value from the skin surface
    returns an algorythm object as well to preform GetOutput() -> polydata
    or GetOutputPort() -> algorythm
    see MinimumDistanceMask.pdf 
    """
        if distanceFromMask < 2:
            print "WARNING: MouldLogic: MinimumDistanceMask implicit",
            "modeling is very unstable below 1.5 , mask may degrade",
            "and lines will become discontinuous."
        Extents = self.utility.GetROIExtents(ROI)
        if (isBubble):
            Extents = self.utility.ExpandExtents(Extents, 100)
        implicitModeller = vtk.vtkImplicitModeller()
        implicitModeller.SetInputConnection(vtkAlgorythmObject.GetOutputPort())
        implicitModeller.SetMaximumDistance(distanceFromMask)
        implicitModeller.SetModelBounds(Extents)
        implicitModeller.AdjustBoundsOn()
        implicitModeller.SetAdjustBounds(10)  # Removes the boundary effects
        implicitModeller.CappingOff(
        )  # Important to create disjoint inner and outer masks
        implicitModeller.SetProcessModeToPerVoxel()
        implicitModeller.Update()

        contourFilter = vtk.vtkContourFilter()
        contourFilter.SetValue(0, distanceFromMask)
        contourFilter.SetInputConnection(implicitModeller.GetOutputPort())
        contourFilter.Update()

        normalsFunction = vtk.vtkPolyDataNormals()
        normalsFunction.FlipNormalsOn()
        normalsFunction.AddInputConnection(contourFilter.GetOutputPort())
        normalsFunction.Update()

        implicitBoxRegion = vtk.vtkBox()
        implicitBoxRegion.SetBounds(Extents)
        clipper2 = vtk.vtkClipPolyData()
        clipper2.InsideOutOn()  # Clip the regions outside of implicit function
        clipper2.SetInputConnection(normalsFunction.GetOutputPort())
        clipper2.SetClipFunction(implicitBoxRegion)
        clipper2.Update()

        closestPoint = [0, 0, 0]
        ruler.GetPosition1(closestPoint)
        connectivityFilter = vtk.vtkPolyDataConnectivityFilter()
        connectivityFilter.SetInputConnection(clipper2.GetOutputPort())
        connectivityFilter.SetExtractionModeToClosestPointRegion()
        connectivityFilter.SetClosestPoint(closestPoint)
        connectivityFilter.Update()

        return connectivityFilter.GetOutput()
Пример #4
0
    def MinimumDistanceMask(self, vtkAlgorythmObject, distanceFromMask, ROI, ruler, isBubble=False):
        """ Takes an algorythm object which is will send through a pipeline to 
    create a mask defining the minimum distance value from the skin surface
    returns an algorythm object as well to preform GetOutput() -> polydata
    or GetOutputPort() -> algorythm
    see MinimumDistanceMask.pdf 
    """
        if distanceFromMask < 2:
            print "WARNING: MouldLogic: MinimumDistanceMask implicit",
            "modeling is very unstable below 1.5 , mask may degrade",
            "and lines will become discontinuous."
        Extents = self.utility.GetROIExtents(ROI)
        if isBubble:
            Extents = self.utility.ExpandExtents(Extents, 100)
        implicitModeller = vtk.vtkImplicitModeller()
        implicitModeller.SetInputConnection(vtkAlgorythmObject.GetOutputPort())
        implicitModeller.SetMaximumDistance(distanceFromMask)
        implicitModeller.SetModelBounds(Extents)
        implicitModeller.AdjustBoundsOn()
        implicitModeller.SetAdjustBounds(10)  # Removes the boundary effects
        implicitModeller.CappingOff()  # Important to create disjoint inner and outer masks
        implicitModeller.SetProcessModeToPerVoxel()
        implicitModeller.Update()

        contourFilter = vtk.vtkContourFilter()
        contourFilter.SetValue(0, distanceFromMask)
        contourFilter.SetInputConnection(implicitModeller.GetOutputPort())
        contourFilter.Update()

        normalsFunction = vtk.vtkPolyDataNormals()
        normalsFunction.FlipNormalsOn()
        normalsFunction.AddInputConnection(contourFilter.GetOutputPort())
        normalsFunction.Update()

        implicitBoxRegion = vtk.vtkBox()
        implicitBoxRegion.SetBounds(Extents)
        clipper2 = vtk.vtkClipPolyData()
        clipper2.InsideOutOn()  # Clip the regions outside of implicit function
        clipper2.SetInputConnection(normalsFunction.GetOutputPort())
        clipper2.SetClipFunction(implicitBoxRegion)
        clipper2.Update()

        closestPoint = [0, 0, 0]
        ruler.GetPosition1(closestPoint)
        connectivityFilter = vtk.vtkPolyDataConnectivityFilter()
        connectivityFilter.SetInputConnection(clipper2.GetOutputPort())
        connectivityFilter.SetExtractionModeToClosestPointRegion()
        connectivityFilter.SetClosestPoint(closestPoint)
        connectivityFilter.Update()

        return connectivityFilter.GetOutput()
  def PointsToSurfacePolyData( self, inPoints, reverse ):

    # Create a polydata object from the points
    pointsPolyData = vtk.vtkPolyData()
    pointsPolyData.SetPoints( inPoints )
  
    # Create the surface filter from the polydata
    surfaceFilter = vtk.vtkSurfaceReconstructionFilter()
    surfaceFilter.SetInputData( pointsPolyData )
    surfaceFilter.Update()
    
    # Do the contouring filter, and reverse to ensure it works properly
    contourFilter = vtk.vtkContourFilter()
    contourFilter.SetValue( 0, 0.0 )
    contourFilter.SetInputData( surfaceFilter.GetOutput() )
    contourFilter.Update()
    
    # Reverse the normals if necessary
    reverseFilter = vtk.vtkReverseSense()
    reverseFilter.SetInputData( contourFilter.GetOutput() )
    reverseFilter.SetReverseCells( reverse )
    reverseFilter.SetReverseNormals( reverse )
    reverseFilter.Update()
   
    # Reset the scaling to let the surface match the points
    fiducialBounds = [ 0, 0, 0, 0, 0, 0 ]
    pointsPolyData.GetBounds( fiducialBounds )
    
    tissueBounds = [ 0, 0, 0, 0, 0, 0 ]
    reverseFilter.GetOutput().GetBounds( tissueBounds )
    
    scaleX = ( fiducialBounds[1] - fiducialBounds[0] ) / ( tissueBounds[1] - tissueBounds[0] )
    scaleY = ( fiducialBounds[3] - fiducialBounds[2] ) / ( tissueBounds[3] - tissueBounds[2] )
    scaleZ = ( fiducialBounds[5] - fiducialBounds[4] ) / ( tissueBounds[5] - tissueBounds[4] )
    
    transform = vtk.vtkTransform()
    transform.Translate( fiducialBounds[0], fiducialBounds[2], fiducialBounds[4] )
    transform.Scale( scaleX, scaleY, scaleZ )
    transform.Translate( - tissueBounds[0], - tissueBounds[2], - tissueBounds[4] )
  
    transformFilter = vtk.vtkTransformPolyDataFilter()
    transformFilter.SetInputData( reverseFilter.GetOutput() )
    transformFilter.SetTransform( transform )
    transformFilter.Update()
  
    return transformFilter.GetOutput()
Пример #6
0
    def CreateBackLine(self, ruler, ROI, implicitPlane):
        """ Creates the polydata for where the cutting plane hits the the back
    of the ROI.  
    This backline will be used to close the catheter path allowing for the
    specification of Towards or Away from the face
    
    ASSERTION: that the ruler's second point will be closest to the 
    front of our mask. 
    """
        roiPoints = self.utility.GetROIPoints(ROI)
        frontExtentIndex = self.utility.GetClosestExtent(ruler, ROI)
        backExtentIndex = self.utility.GetOppositeExtent(frontExtentIndex)

        #Creating an implict plane for the back of the ROI
        ROICenterPoint = [0, 0, 0]
        ROI.GetXYZ(ROICenterPoint)
        backNormal = self.utility.GetVector(ROICenterPoint,
                                            roiPoints[backExtentIndex])
        backPlane = vtk.vtkPlane()
        backPlane.SetNormal(backNormal)
        backPlane.SetOrigin(roiPoints[backExtentIndex])

        #Finding the Intercept of this and the CuttingPlane
        sampleFunction = vtk.vtkSampleFunction()
        sampleFunction.SetSampleDimensions(10, 10, 10)
        sampleFunction.SetImplicitFunction(backPlane)
        bounds = self.utility.ExpandExtents(self.utility.GetROIExtents(ROI), 1)
        sampleFunction.SetModelBounds(bounds)
        sampleFunction.Update()

        contourFilter = vtk.vtkContourFilter()
        contourFilter.SetInputConnection(sampleFunction.GetOutputPort())
        contourFilter.GenerateValues(1, 1, 1)
        contourFilter.Update()

        cutter = vtk.vtkCutter()
        cutter.SetInputConnection(contourFilter.GetOutputPort())
        cutter.SetCutFunction(implicitPlane)
        cutter.GenerateValues(1, 1, 1)
        cutter.Update()
        self.listOfBackLines.append(cutter.GetOutput())
        PATH = self.ROOTPATH + "\\doc\\DebugPolyData\\" + "BackLine-" + str(
            len(self.listOfBackLines))
        self.utility.PolyDataWriter(self.listOfBackLines[-1], PATH + ".vtk")
Пример #7
0
    def CreateBackLine(self, ruler, ROI, implicitPlane):
        """ Creates the polydata for where the cutting plane hits the the back
    of the ROI.  
    This backline will be used to close the catheter path allowing for the
    specification of Towards or Away from the face
    
    ASSERTION: that the ruler's second point will be closest to the 
    front of our mask. 
    """
        roiPoints = self.utility.GetROIPoints(ROI)
        frontExtentIndex = self.utility.GetClosestExtent(ruler, ROI)
        backExtentIndex = self.utility.GetOppositeExtent(frontExtentIndex)

        # Creating an implict plane for the back of the ROI
        ROICenterPoint = [0, 0, 0]
        ROI.GetXYZ(ROICenterPoint)
        backNormal = self.utility.GetVector(ROICenterPoint, roiPoints[backExtentIndex])
        backPlane = vtk.vtkPlane()
        backPlane.SetNormal(backNormal)
        backPlane.SetOrigin(roiPoints[backExtentIndex])

        # Finding the Intercept of this and the CuttingPlane
        sampleFunction = vtk.vtkSampleFunction()
        sampleFunction.SetSampleDimensions(10, 10, 10)
        sampleFunction.SetImplicitFunction(backPlane)
        bounds = self.utility.ExpandExtents(self.utility.GetROIExtents(ROI), 1)
        sampleFunction.SetModelBounds(bounds)
        sampleFunction.Update()

        contourFilter = vtk.vtkContourFilter()
        contourFilter.SetInputConnection(sampleFunction.GetOutputPort())
        contourFilter.GenerateValues(1, 1, 1)
        contourFilter.Update()

        cutter = vtk.vtkCutter()
        cutter.SetInputConnection(contourFilter.GetOutputPort())
        cutter.SetCutFunction(implicitPlane)
        cutter.GenerateValues(1, 1, 1)
        cutter.Update()
        self.listOfBackLines.append(cutter.GetOutput())
        PATH = self.ROOTPATH + "\\doc\\DebugPolyData\\" + "BackLine-" + str(len(self.listOfBackLines))
        self.utility.PolyDataWriter(self.listOfBackLines[-1], PATH + ".vtk")
Пример #8
0
 def DisplayImplicit(self,name,implicitFunction, ROI=None, Extents=None):
   """This function takes an implicitFunction and displays it within the ROI
   It will return the modelDisplaynode assosiated with in so that attributes 
   can be changed
   """
   sampleFunction=vtk.vtkSampleFunction()
   sampleFunction.SetSampleDimensions(70,70,70)
   sampleFunction.SetImplicitFunction(implicitFunction)
   ROIExtents=[0,0,0,0,0,0]
   if ROI==None:
     ROIExtents=Extents
   else:
     ROIExtents=self.GetROIExtents(ROI)
   sampleFunction.SetModelBounds(ROIExtents)
   sampleFunction.Update()
   contourFilter=vtk.vtkContourFilter()
   contourFilter.SetInputConnection(sampleFunction.GetOutputPort())
   contourFilter.GenerateValues(1,0,0)
   contourFilter.Update()
   polyData=contourFilter.GetOutput()
   modelDisplayNode=self.DisplayPolyData(name,polyData)
   return modelDisplayNode
Пример #9
0
 def DisplayImplicit(self, name, implicitFunction, ROI=None, Extents=None):
     """This function takes an implicitFunction and displays it within the ROI
 It will return the modelDisplaynode assosiated with in so that attributes 
 can be changed
 """
     sampleFunction = vtk.vtkSampleFunction()
     sampleFunction.SetSampleDimensions(70, 70, 70)
     sampleFunction.SetImplicitFunction(implicitFunction)
     ROIExtents = [0, 0, 0, 0, 0, 0]
     if ROI == None:
         ROIExtents = Extents
     else:
         ROIExtents = self.GetROIExtents(ROI)
     sampleFunction.SetModelBounds(ROIExtents)
     sampleFunction.Update()
     contourFilter = vtk.vtkContourFilter()
     contourFilter.SetInputConnection(sampleFunction.GetOutputPort())
     contourFilter.GenerateValues(1, 0, 0)
     contourFilter.Update()
     polyData = contourFilter.GetOutput()
     modelDisplayNode = self.DisplayPolyData(name, polyData)
     return modelDisplayNode
Пример #10
0
    def AddTubeToMask(self, maskPolydata, tube, ROI, radius, ruler):
        ROIExtents = self.utility.GetROIExtents(ROI)
        implicitFilter = vtk.vtkImplicitModeller()
        implicitFilter.SetInput(tube)
        implicitFilter.SetSampleDimensions(70, 70, 70)
        implicitFilter.SetMaximumDistance(radius)
        implicitFilter.SetModelBounds(ROIExtents)
        implicitFilter.SetProcessModeToPerVoxel()
        contourFilter = vtk.vtkContourFilter()
        contourFilter.SetValue(0, radius)
        implicitFilter.AdjustBoundsOn()
        implicitFilter.SetAdjustBounds(1)  # Removes the boundary effects
        implicitFilter.CappingOff()
        contourFilter.SetInputConnection(implicitFilter.GetOutputPort())
        normalsFunction = vtk.vtkPolyDataNormals()
        normalsFunction.AutoOrientNormalsOn()
        normalsFunction.AddInputConnection(contourFilter.GetOutputPort())

        unionFilter = vtk.vtkBooleanOperationPolyDataFilter()
        unionFilter.SetOperationToUnion()
        unionFilter.SetInput(0, normalsFunction.GetOutput())
        unionFilter.SetInput(1, maskPolydata)
        return unionFilter.GetOutput()
Пример #11
0
    def AddTubeToMask(self, maskPolydata, tube, ROI, radius, ruler):
        ROIExtents = self.utility.GetROIExtents(ROI)
        implicitFilter = vtk.vtkImplicitModeller()
        implicitFilter.SetInput(tube)
        implicitFilter.SetSampleDimensions(70, 70, 70)
        implicitFilter.SetMaximumDistance(radius)
        implicitFilter.SetModelBounds(ROIExtents)
        implicitFilter.SetProcessModeToPerVoxel()
        contourFilter = vtk.vtkContourFilter()
        contourFilter.SetValue(0, radius)
        implicitFilter.AdjustBoundsOn()
        implicitFilter.SetAdjustBounds(1)  # Removes the boundary effects
        implicitFilter.CappingOff()
        contourFilter.SetInputConnection(implicitFilter.GetOutputPort())
        normalsFunction = vtk.vtkPolyDataNormals()
        normalsFunction.AutoOrientNormalsOn()
        normalsFunction.AddInputConnection(contourFilter.GetOutputPort())

        unionFilter = vtk.vtkBooleanOperationPolyDataFilter()
        unionFilter.SetOperationToUnion()
        unionFilter.SetInput(0, normalsFunction.GetOutput())
        unionFilter.SetInput(1, maskPolydata)
        return unionFilter.GetOutput()
Пример #12
0
    def GenerateMould(self, facePolydata, distanceFromMask, ROI, tubePolydata,
                      clippedFace):
        ROIExtents = self.utility.GetROIExtents(ROI)
        outerFaceImplicitFunction = vtk.vtkImplicitModeller()
        outerFaceImplicitFunction.SetInputConnection(
            facePolydata.GetOutputPort())
        outerFaceImplicitFunction.SetSampleDimensions(70, 70, 70)
        outerFaceImplicitFunction.SetMaximumDistance(distanceFromMask)
        outerFaceImplicitFunction.SetModelBounds(ROIExtents)
        outerFaceImplicitFunction.SetProcessModeToPerVoxel()
        outerMaskContourFunction = vtk.vtkContourFilter()
        #TODO Find out the the allowed thinkness of the plastic
        THICKNESS = 3
        outerMaskContourFunction.SetValue(0, THICKNESS)
        outerMaskContourFunction.SetInputConnection(
            outerFaceImplicitFunction.GetOutputPort())

        outerFaceNormalsFunction = vtk.vtkPolyDataNormals()
        outerFaceNormalsFunction.AutoOrientNormalsOn()
        outerFaceNormalsFunction.AddInputConnection(
            outerMaskContourFunction.GetOutputPort())
        # Subtract the Tubes from the mask
        subtractionFilter1 = vtk.vtkBooleanOperationPolyDataFilter()
        subtractionFilter1.SetOperationToDifference()
        subtractionFilter1.SetInputConnection(
            0, outerFaceNormalsFunction.GetOutputPort())
        subtractionFilter1.SetInputConnection(1, tubePolydata.GetOutputPort())
        # Subtract the inner face from the outer face to make the mask
        subtractionFilter2 = vtk.vtkBooleanOperationPolyDataFilter()
        subtractionFilter2.SetOperationToDifference()
        subtractionFilter2.SetInputConnection(
            0, subtractionFilter1.GetOutputPort())
        subtractionFilter2.SetInputConnection(1, clippedFace.GetOutputPort())
        x = self.utility.DisplayPolyData("Mask",
                                         subtractionFilter2.GetOutput())
        x.SetColor(0.8, 0.8, 0.8)
        x.SetOpacity(1)
Пример #13
0
    def updateModelFromMarkup(self, inputMarkup, outputModel):
        """
    Update model to enclose all points in the input markup list
    """

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

        # Create polydata point set from markup points

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

        numberOfPoints = inputMarkup.GetNumberOfFiducials()

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

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

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

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

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

        # Create surface from point set

        if useDelaunay:

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

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

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

            outputModel.SetPolyDataConnection(smoother.GetOutputPort())

        else:

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

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

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

            outputModel.SetPolyDataConnection(reverse.GetOutputPort())

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

        outputModel.GetDisplayNode().SliceIntersectionVisibilityOn()

        outputModel.Modified()
Пример #14
0
  def iceCream(self):

    # based on iceCream.py from VTK/Examples/Modelling

    # This example demonstrates how to use boolean combinations of implicit
    # functions to create a model of an ice cream cone.

    import vtk
    from vtk.util.colors import chocolate, mint

    # Create implicit function primitives. These have been carefully
    # placed to give the effect that we want. We are going to use various
    # combinations of these functions to create the shape we want; for
    # example, we use planes intersected with a cone (which is infinite in
    # extent) to get a finite cone.
    cone = vtk.vtkCone()
    cone.SetAngle(20)
    vertPlane = vtk.vtkPlane()
    vertPlane.SetOrigin(.1, 0, 0)
    vertPlane.SetNormal(-1, 0, 0)
    basePlane = vtk.vtkPlane()
    basePlane.SetOrigin(1.2, 0, 0)
    basePlane.SetNormal(1, 0, 0)
    iceCream = vtk.vtkSphere()
    iceCream.SetCenter(1.333, 0, 0)
    iceCream.SetRadius(0.5)
    bite = vtk.vtkSphere()
    bite.SetCenter(1.5, 0, 0.5)
    bite.SetRadius(0.25)

    # Combine primitives to build ice-cream cone. Clip the cone with planes.
    theCone = vtk.vtkImplicitBoolean()
    theCone.SetOperationTypeToIntersection()
    theCone.AddFunction(cone)
    theCone.AddFunction(vertPlane)
    theCone.AddFunction(basePlane)

    # Take a bite out of the ice cream.
    theCream = vtk.vtkImplicitBoolean()
    theCream.SetOperationTypeToDifference()
    theCream.AddFunction(iceCream)
    theCream.AddFunction(bite)

    # The sample function generates a distance function from the implicit
    # function (which in this case is the cone). This is then contoured to
    # get a polygonal surface.
    theConeSample = vtk.vtkSampleFunction()
    theConeSample.SetImplicitFunction(theCone)
    theConeSample.SetModelBounds(-1, 1.5, -1.25, 1.25, -1.25, 1.25)
    theConeSample.SetSampleDimensions(60, 60, 60)
    theConeSample.ComputeNormalsOff()
    theConeSurface = vtk.vtkContourFilter()
    theConeSurface.SetInputConnection(theConeSample.GetOutputPort())
    theConeSurface.SetValue(0, 0.0)
    coneMapper = vtk.vtkPolyDataMapper()
    coneMapper.SetInputConnection(theConeSurface.GetOutputPort())
    coneMapper.ScalarVisibilityOff()
    coneActor = vtk.vtkActor()
    coneActor.SetMapper(coneMapper)
    coneActor.GetProperty().SetColor(chocolate)

    # The same here for the ice cream.
    theCreamSample = vtk.vtkSampleFunction()
    theCreamSample.SetImplicitFunction(theCream)
    theCreamSample.SetModelBounds(0, 2.5, -1.25, 1.25, -1.25, 1.25)
    theCreamSample.SetSampleDimensions(60, 60, 60)
    theCreamSample.ComputeNormalsOff()
    theCreamSurface = vtk.vtkContourFilter()
    theCreamSurface.SetInputConnection(theCreamSample.GetOutputPort())
    theCreamSurface.SetValue(0, 0.0)
    creamMapper = vtk.vtkPolyDataMapper()
    creamMapper.SetInputConnection(theCreamSurface.GetOutputPort())
    creamMapper.ScalarVisibilityOff()
    creamActor = vtk.vtkActor()
    creamActor.SetMapper(creamMapper)
    creamActor.GetProperty().SetColor(mint)

    # Create the usual rendering stuff
    ren = vtk.vtkRenderer()
    renWin = vtk.vtkRenderWindow()
    renWin.AddRenderer(ren)
    iren = vtk.vtkRenderWindowInteractor()
    iren.SetRenderWindow(renWin)

    # Add the actors to the renderer, set the background and size
    ren.AddActor(coneActor)
    ren.AddActor(creamActor)
    ren.SetBackground(1, 1, 1)
    renWin.SetSize(500, 500)
    ren.ResetCamera()
    ren.GetActiveCamera().Roll(90)
    ren.GetActiveCamera().Dolly(1.5)
    ren.ResetCameraClippingRange()

    iren.Initialize()
    renWin.Render()
    iren.Start()
    return iren