Exemplo n.º 1
0
def MaskWithPatch(id,t,c,r,maskArray,centerlines,voronoi):
   patch = ExtractPatch(id,centerlines)

   tubeFunction = vtkvmtk.vtkvmtkPolyBallLine()
   tubeFunction.SetInput(patch)
   tubeFunction.SetPolyBallRadiusArrayName(radiusArrayName)

   lastSphere = vtk.vtkSphere()
   lastSphere.SetRadius(r*1.5)
   lastSphere.SetCenter(c)

   for i in range(voronoi.GetNumberOfPoints()):
      point = [0.0,0.0,0.0]
      voronoiVector = [0.0,0.0,0.0]

      voronoi.GetPoint(i,point)
      voronoiVector[0] = point[0]-c[0]
      voronoiVector[1] = point[1]-c[1]
      voronoiVector[2] = point[2]-c[2]
      voronoiVectorDot = vtk.vtkMath.Dot(voronoiVector,t)   

      tubevalue = tubeFunction.EvaluateFunction(point)
      spherevalue = lastSphere.EvaluateFunction(point)
      if (spherevalue<0.0) & (voronoiVectorDot<0.0): continue
      elif (tubevalue<=0.0):
         maskArray.SetTuple1(i,1)
Exemplo n.º 2
0
    def _Clip(self, pd):
        # The plane implicit function will be >0 for all the points in the positive side
        # of the plane (i.e. x s.t. n.(x-o)>0, where n is the plane normal and o is the 
        # plane origin).
        plane = vtkPlane()
        plane.SetOrigin(self.Iolet.Centre.x, self.Iolet.Centre.y, self.Iolet.Centre.z)
        plane.SetNormal(self.Iolet.Normal.x, self.Iolet.Normal.y, self.Iolet.Normal.z)
        
        # The sphere implicit function will be >0 for all the points outside the sphere.
        sphere = vtkSphere()
        sphere.SetCenter(self.Iolet.Centre.x, self.Iolet.Centre.y, self.Iolet.Centre.z)
        sphere.SetRadius(self.Iolet.Radius)
        
        # The VTK_INTERSECTION operator takes the maximum value of all the registered 
        # implicit functions. This will result in the function evaluating to >0 for all 
        # the points outside the sphere plus those inside the sphere in the positive 
        # side of the plane.
        clippingFunction = vtkImplicitBoolean()
        clippingFunction.AddFunction(plane)
        clippingFunction.AddFunction(sphere)
        clippingFunction.SetOperationTypeToIntersection() 
        
        clipper = vtkClipPolyData()
        clipper.SetInput(pd)
        clipper.SetClipFunction(clippingFunction)

        # Filter to get part closest to seed point
        connectedRegionGetter = vtkPolyDataConnectivityFilter()
        connectedRegionGetter.SetExtractionModeToClosestPointRegion()
        connectedRegionGetter.SetClosestPoint(*self.SeedPoint)
        connectedRegionGetter.SetInputConnection(clipper.GetOutputPort())
        connectedRegionGetter.Update()
        return connectedRegionGetter.GetOutput()
Exemplo n.º 3
0
    def testStructured(self):
        rt = vtk.vtkRTAnalyticSource()
        rt.SetWholeExtent(-5, 5, -5, 5, -5, 5)
        rt.Update()
        i = rt.GetOutput()

        st = vtk.vtkStructuredGrid()
        st.SetDimensions(i.GetDimensions())

        nps = i.GetNumberOfPoints()
        ps = vtk.vtkPoints()
        ps.SetNumberOfPoints(nps)
        for idx in xrange(nps):
            ps.SetPoint(idx, i.GetPoint(idx))

        st.SetPoints(ps)

        s = vtk.vtkSphere()
        s.SetRadius(2)
        s.SetCenter(0,0,0)

        c = vtk.vtkTableBasedClipDataSet()
        c.SetInputData(st)
        c.SetClipFunction(s)
        c.SetInsideOut(1)

        c.Update()

        self.assertEqual(c.GetOutput().GetNumberOfCells(), 64)
    def openSurfaceAtPoint(self, polyData, seed):
        '''
        Returns a new surface with an opening at the given seed.
        '''

        someradius = 1.0

        pointLocator = vtk.vtkPointLocator()
        pointLocator.SetDataSet(polyData)
        pointLocator.BuildLocator()

        # find the closest point next to the seed on the surface
        # id = pointLocator.FindClosestPoint(int(seed[0]),int(seed[1]),int(seed[2]))
        id = pointLocator.FindClosestPoint(seed)

        # the seed is now guaranteed on the surface
        seed = polyData.GetPoint(id)

        sphere = vtk.vtkSphere()
        sphere.SetCenter(seed[0], seed[1], seed[2])
        sphere.SetRadius(someradius)

        clip = vtk.vtkClipPolyData()
        clip.SetInputData(polyData)
        clip.SetClipFunction(sphere)
        clip.Update()

        outPolyData = vtk.vtkPolyData()
        outPolyData.DeepCopy(clip.GetOutput())

        return outPolyData
Exemplo n.º 5
0
    def _add_ugrid_nodes_to_grid(self, name, diff_node_ids, nodes):
        """
        based on:
          _add_nastran_nodes_to_grid
        """
        nnodes = nodes.shape[0]
        assert nnodes > 0, nnodes
        # if nnodes == 0:
            # return
        nnodes = len(diff_node_ids)
        points = vtk.vtkPoints()
        points.SetNumberOfPoints(nnodes)

        for nid in diff_node_ids:
            node = nodes[nid, :]
            print('nid=%s node=%s' % (nid, node))
            points.InsertPoint(nid, *node)

            if 1:
                elem = vtk.vtkVertex()
                elem.GetPointIds().SetId(0, nid)
            else:
                elem = vtk.vtkSphere()
                sphere_size = self._get_sphere_size(dim_max)
                elem.SetRadius(sphere_size)
                elem.SetCenter(points.GetPoint(nid))

            self.alt_grids[name].InsertNextCell(elem.GetCellType(), elem.GetPointIds())
        self.alt_grids[name].SetPoints(points)
    def SphereDrill(self, m_holelist, m_holeRadius, m_quiet=False):
        """
        Drill sphere at locations specified by m_holelist.

        :param m_holelist:      [list]  A list of coordinates where holes are to be drilled
        :param m_holeRadius:    [float] The radius of the hole to drill
        :param m_quiet:         [bool]
        :return:
        """
        m_totalNumOfHoles = len(m_holelist)
        if not m_quiet:
            t = time.time()
            print "Drilling"

        for i in xrange(m_totalNumOfHoles):
            m_sphere = vtk.vtkSphere()
            m_sphere.SetCenter(m_holelist[i])
            m_sphere.SetRadius(m_holeRadius)

            clipper = vtk.vtkClipPolyData()
            clipper.SetInputData(self._data)
            clipper.SetClipFunction(m_sphere)
            clipper.Update()

            clipped = clipper.GetOutput()
            self._data.DeepCopy(clipped)

            if not m_quiet:
                print "\t%s/%s -- %.2f %%" % (i + 1, m_totalNumOfHoles, (i + 1) * 100 / float(m_totalNumOfHoles))
        if not m_quiet:
            print "Finished: Totaltime used = %.2f s" % (time.time() - t)
        pass
Exemplo n.º 7
0
    def testUnstructured(self):
        rt = vtk.vtkRTAnalyticSource()
        rt.SetWholeExtent(-5, 5, -5, 5, -5, 5)

        t = vtk.vtkThreshold()
        t.SetInputConnection(rt.GetOutputPort())
        t.ThresholdByUpper(-10)

        s = vtk.vtkSphere()
        s.SetRadius(2)
        s.SetCenter(0,0,0)

        c = vtk.vtkTableBasedClipDataSet()
        c.SetInputConnection(t.GetOutputPort())
        c.SetClipFunction(s)
        c.SetInsideOut(1)

        c.Update()

        self.assertEqual(c.GetOutput().GetNumberOfCells(), 64)

        eg = vtk.vtkEnSightGoldReader()
        eg.SetCaseFileName(VTK_DATA_ROOT + "/Data/EnSight/elements.case")
        eg.Update()

        pl = vtk.vtkPlane()
        pl.SetOrigin(3.5, 3.5, 0.5)
        pl.SetNormal(0, 0, 1)

        c.SetInputConnection(eg.GetOutputPort())
        c.SetClipFunction(pl)
        c.SetInsideOut(1)

        c.Update()
        data = c.GetOutputDataObject(0).GetBlock(0)
        self.assertEqual(data.GetNumberOfCells(), 75)

        rw = vtk.vtkRenderWindow()
        ren = vtk.vtkRenderer()
        rw.AddRenderer(ren)
        mapper = vtk.vtkDataSetMapper()
        mapper.SetInputData(data)
        actor = vtk.vtkActor()
        actor.SetMapper(mapper)
        ren.AddActor(actor)
        ac = ren.GetActiveCamera()
        ac.SetPosition(-7.9, 9.7, 14.6)
        ac.SetFocalPoint(3.5, 3.5, 0.5)
        ac.SetViewUp(0.08, 0.93, -0.34)
        rw.Render()
        ren.ResetCameraClippingRange()

        rtTester = vtk.vtkTesting()
        for arg in sys.argv[1:]:
            rtTester.AddArgument(arg)
        rtTester.AddArgument("-V")
        rtTester.AddArgument("tableBasedClip.png")
        rtTester.SetRenderWindow(rw)
        rw.Render()
        rtResult = rtTester.RegressionTest(10)
Exemplo n.º 8
0
    def __init__(self, parent = None):
        super(VTKFrame, self).__init__(parent)

        self.vtkWidget = QVTKRenderWindowInteractor(self)
        vl = QtGui.QVBoxLayout(self)
        vl.addWidget(self.vtkWidget)
        vl.setContentsMargins(0, 0, 0, 0)
 
        self.ren = vtk.vtkRenderer()
        self.ren.SetBackground(0.1, 0.2, 0.4)
        self.vtkWidget.GetRenderWindow().AddRenderer(self.ren)
        self.iren = self.vtkWidget.GetRenderWindow().GetInteractor()
 
        sphere1 = vtk.vtkSphere()
        sphere1.SetCenter(0.9, 0, 0)
        sphere2 = vtk.vtkSphere()
        sphere2.SetCenter(-0.9, 0, 0)

        implicitBoolean = vtk.vtkImplicitBoolean()
        implicitBoolean.AddFunction(sphere1)
        implicitBoolean.AddFunction(sphere2)
        implicitBoolean.SetOperationTypeToUnion()
        #implicitBoolean.SetOperationTypeToIntersection()

        # Sample the function
        sample = vtk.vtkSampleFunction()
        sample.SetSampleDimensions(50, 50, 50)
        sample.SetImplicitFunction(implicitBoolean)
        sample.SetModelBounds(-3, 3, -3, 3, -3, 3)

        # Create the 0 isosurface
        contours = vtk.vtkContourFilter()
        contours.SetInputConnection(sample.GetOutputPort())
        contours.GenerateValues(1, 1, 1)
 
        # Create a mapper
        mapper = vtk.vtkPolyDataMapper()
        mapper.SetInputConnection(contours.GetOutputPort())
 
        # Create an actor
        actor = vtk.vtkActor()
        actor.SetMapper(mapper)
 
        self.ren.AddActor(actor)
        self.ren.ResetCamera()

        self._initialized = False
Exemplo n.º 9
0
    def Execute(self):

        if self.Surface == None:
            self.PrintError('Error: no Surface.')

        if self.WidgetType == "box":
            self.ClipFunction = vtk.vtkPlanes()
        elif self.WidgetType == "sphere":
            self.ClipFunction = vtk.vtkSphere()

        self.Clipper = vtk.vtkClipPolyData()
        self.Clipper.SetInput(self.Surface)
        self.Clipper.SetClipFunction(self.ClipFunction)
        self.Clipper.GenerateClippedOutputOn()
        self.Clipper.InsideOutOn()
        
        if not self.vmtkRenderer:
            self.vmtkRenderer = vmtkrenderer.vmtkRenderer()
            self.vmtkRenderer.Initialize()
            self.OwnRenderer = 1

        mapper = vtk.vtkPolyDataMapper()
        mapper.SetInput(self.Surface)
        mapper.ScalarVisibilityOff()
        self.Actor = vtk.vtkActor()
        self.Actor.SetMapper(mapper)
        self.vmtkRenderer.Renderer.AddActor(self.Actor)

        if self.WidgetType == "box":
            self.ClipWidget = vtk.vtkBoxWidget()
            self.ClipWidget.GetFaceProperty().SetColor(0.6,0.6,0.2)
            self.ClipWidget.GetFaceProperty().SetOpacity(0.25)
        elif self.WidgetType == "sphere":
            self.ClipWidget = vtk.vtkSphereWidget()
            self.ClipWidget.GetSphereProperty().SetColor(0.6,0.6,0.2)
            self.ClipWidget.GetSphereProperty().SetOpacity(0.25)
            self.ClipWidget.GetSelectedSphereProperty().SetColor(0.6,0.0,0.0)
            self.ClipWidget.GetSelectedSphereProperty().SetOpacity(0.75)
            self.ClipWidget.SetRepresentationToSurface()
            self.ClipWidget.SetPhiResolution(20)
            self.ClipWidget.SetThetaResolution(20)

        self.ClipWidget.SetInteractor(self.vmtkRenderer.RenderWindowInteractor)
        self.Display()

        self.Transform = vtk.vtkTransform()
        self.ClipWidget.GetTransform(self.Transform)

        if self.OwnRenderer:
            self.vmtkRenderer.Deallocate()

        if self.CleanOutput == 1:
            cleaner = vtk.vtkCleanPolyData()
            cleaner.SetInput(self.Surface)
            cleaner.Update()
            self.Surface = cleaner.GetOutput()

        if self.Surface.GetSource():
            self.Surface.GetSource().UnRegisterAllOutputs()
Exemplo n.º 10
0
    def getImplicitSphere(self):
        impSphere = vtk.vtkSphere()  # implicit sphere
        centerPoint = self.getCentralPoint()
        radius = self.getRadius()

        impSphere.SetRadius(radius)
        impSphere.SetCenter(centerPoint)
        return impSphere
Exemplo n.º 11
0
    def Execute(self):

        if (self.Surface == None):
            self.PrintError('Error: no Surface.')

        if self.WidgetType == "box":
            self.ClipFunction = vtk.vtkPlanes()
        elif self.WidgetType == "sphere":
            self.ClipFunction = vtk.vtkSphere()

        self.Clipper = vtk.vtkClipPolyData()
        self.Clipper.SetInput(self.Surface)
        self.Clipper.SetClipFunction(self.ClipFunction)
        self.Clipper.GenerateClippedOutputOn()
        self.Clipper.InsideOutOn()

        if not self.vmtkRenderer:
            self.vmtkRenderer = vmtkrenderer.vmtkRenderer()
            self.vmtkRenderer.Initialize()
            self.OwnRenderer = 1

        mapper = vtk.vtkPolyDataMapper()
        mapper.SetInput(self.Surface)
        mapper.ScalarVisibilityOff()
        self.Actor = vtk.vtkActor()
        self.Actor.SetMapper(mapper)
        self.vmtkRenderer.Renderer.AddActor(self.Actor)

        if self.WidgetType == "box":
            self.ClipWidget = vtk.vtkBoxWidget()
            self.ClipWidget.GetFaceProperty().SetColor(0.6, 0.6, 0.2)
            self.ClipWidget.GetFaceProperty().SetOpacity(0.25)
        elif self.WidgetType == "sphere":
            self.ClipWidget = vtk.vtkSphereWidget()
            self.ClipWidget.GetSphereProperty().SetColor(0.6, 0.6, 0.2)
            self.ClipWidget.GetSphereProperty().SetOpacity(0.25)
            self.ClipWidget.GetSelectedSphereProperty().SetColor(0.6, 0.0, 0.0)
            self.ClipWidget.GetSelectedSphereProperty().SetOpacity(0.75)
            self.ClipWidget.SetRepresentationToSurface()
            self.ClipWidget.SetPhiResolution(20)
            self.ClipWidget.SetThetaResolution(20)

        self.ClipWidget.SetInteractor(self.vmtkRenderer.RenderWindowInteractor)
        self.Display()

        if self.OwnRenderer:
            self.vmtkRenderer.Deallocate()

        if self.CleanOutput == 1:
            cleaner = vtk.vtkCleanPolyData()
            cleaner.SetInput(self.Surface)
            cleaner.Update()
            self.Surface = cleaner.GetOutput()

        if self.Surface.GetSource():
            self.Surface.GetSource().UnRegisterAllOutputs()
Exemplo n.º 12
0
    def __init__(self, map_actor, text_actor):
        self.AddObserver("MouseMoveEvent", self.mouse_move_event)
        self.map_actor = map_actor
        self.text_actor = text_actor

        self.elevation_actor = vtk.vtkActor()
        self.sphere = vtk.vtkSphere()
        self.cutter = vtk.vtkCutter()
        self.stripper = vtk.vtkStripper()
        self.tube_filter = vtk.vtkTubeFilter()
        self.mapper = vtk.vtkDataSetMapper()
        self.picker = vtk.vtkPointPicker()
Exemplo n.º 13
0
def create_sphere(radius, center, thetaResolution=50, phiResolution=50):
    s = vtk.vtkSphere()
    s.SetRadius(radius)
    s.SetCenter(center)

    ss = vtk.vtkSphereSource()
    ss.SetThetaResolution(thetaResolution)
    ss.SetPhiResolution(phiResolution)
    ss.SetCenter(center)
    ss.SetRadius(radius)

    return s, ss
Exemplo n.º 14
0
def extract_sphere(data, origin, radius):
    """Extracts a spherical slice of data from VTK data object
    """
    sphere = vtk.vtkSphere()
    sphere.SetRadius(radius)

    cutter = vtk.vtkCutter()
    cutter.SetInputDataObject(data.reader.GetOutput())
    cutter.SetCutFunction(sphere)
    cutter.Update()

    return cutter.GetOutputDataObject(0)
Exemplo n.º 15
0
def CreateSkinClipping(cf):

    sphere = vtk.vtkSphere()
    sphere.SetCenter(xCenter, yCenter, zCenter)
    sphere.SetRadius(radius)

    clipper = vtk.vtkClipPolyData()
    clipper.SetInputConnection(cf.GetOutputPort())
    clipper.SetClipFunction(sphere)
    clipper.SetValue(0)
    clipper.Update()

    return clipper
Exemplo n.º 16
0
def getBoundaryNodes(mesh, radius1, radius2, used_nodes):
    numPts = mesh.GetNumberOfPoints()
    boundary_nodes = vtk.vtkIdList()
    #First get the points within a sphere on the boundaries using the boundary points as seed points
    for ptID in xrange(0, numPts):
        if (mesh.GetPointData().GetArray('GlobalBoundaryPoints').GetValue(ptID)
                > 0):
            x0, y0, z0 = mesh.GetPoint(ptID)

            neighbrs = vtk.vtkExtractGeometry()
            sphere1 = vtk.vtkSphere()
            sphere1.SetCenter(x0, y0, z0)
            sphere1.SetRadius(float(radius1))
            sphere2 = vtk.vtkSphere()
            sphere2.SetCenter(x0, y0, z0)
            sphere2.SetRadius(float(radius2))
            diff = vtk.vtkImplicitBoolean()
            diff.AddFunction(sphere2)
            diff.AddFunction(sphere1)
            diff.SetOperationTypeToDifference()
            neighbrs.SetImplicitFunction(sphere2)
            neighbrs.ExtractInsideOn()
            neighbrs.ExtractBoundaryCellsOn()
            neighbrs.SetInputData(mesh)
            neighbrs.Update()

            neighbors = vtk.vtkConnectivityFilter()
            neighbors.SetInputData(neighbrs.GetOutput())
            neighbors.SetExtractionModeToClosestPointRegion()
            neighbors.SetClosestPoint(x0, y0, z0)
            neighbors.Update()
            neighbors = neighbors.GetOutput()
            for neighborID in xrange(0, neighbors.GetNumberOfPoints()):
                meshID = mesh.FindPoint(neighbors.GetPoint(neighborID))
                if (used_nodes.IsId(meshID) < 0):
                    boundary_nodes.InsertNextId(meshID)
                    used_nodes.InsertNextId(meshID)
    writeVTU(neighbors, 'test_extraction.vtu')
    return [boundary_nodes, used_nodes]
Exemplo n.º 17
0
def FindClippingPointOnParentArtery(centerlines, parentCenterlines, toll):
    divergingPointID = -1
    divergingPoint = [0.0, 0.0, 0.0]
    divergingPointMISR = -1

    clippingPointID = -1
    clippingPoint = [0.0, 0.0, 0.0]

    cell0PointIds = vtk.vtkIdList()
    cell1PointIds = vtk.vtkIdList()

    centerlines.GetCellPoints(
        0, cell0PointIds)  #this is the cl that goes through the aneurysm
    centerlines.GetCellPoints(1, cell1PointIds)

    for i in range(
            0,
            min(cell0PointIds.GetNumberOfIds(),
                cell1PointIds.GetNumberOfIds())):
        cell0Point = centerlines.GetPoint(cell0PointIds.GetId(i))
        cell1Point = centerlines.GetPoint(cell1PointIds.GetId(i))

        distanceBetweenPoints = math.sqrt(
            vtk.vtkMath.Distance2BetweenPoints(cell0Point, cell1Point))
        if (distanceBetweenPoints > toll):
            divergingPointID = cell1PointIds.GetId(i)
            divergingPoint = centerlines.GetPoint(cell1PointIds.GetId(i))
            divergingPointMISR = centerlines.GetPointData().GetArray(
                radiusArrayName).GetTuple1(cell1PointIds.GetId(i))
            break

    MISphere = vtk.vtkSphere()
    MISphere.SetCenter(divergingPoint)
    MISphere.SetRadius(divergingPointMISR)
    tempPoint = [0.0, 0.0, 0.0]

    for i in range(divergingPointID, 0, -1):
        value = MISphere.EvaluateFunction(centerlines.GetPoint(i))
        if (value >= 0.0):
            tempPoint = centerlines.GetPoint(i)
            break

    locator = vtk.vtkPointLocator()
    locator.SetDataSet(parentCenterlines)
    locator.BuildLocator()

    clippingPointID = locator.FindClosestPoint(tempPoint)
    clippingPoint = parentCenterlines.GetPoint(clippingPointID)

    return clippingPoint, divergingPoint
Exemplo n.º 18
0
def MakeScalars(dims, origin, spacing, scalars):
    # Implicit function used to compute scalars
    sphere = vtk.vtkSphere()
    sphere.SetRadius(3)
    sphere.SetCenter(5, 5, 5)
    scalars.SetNumberOfTuples(dims[0] * dims[1] * dims[2])
    for k in range(0, dims[2]):
        z = origin[2] + spacing[2] * k
        for j in range(0, dims[1]):
            y = origin[1] + spacing[1] * j
            for i in range(0, dims[0]):
                x = origin[0] + spacing[0] * i
                scalars.SetValue(k * dims[0] * dims[1] + j * dims[0] + i,
                                 sphere.EvaluateFunction(x, y, z))
Exemplo n.º 19
0
 def mouseMoveEvent(self, obj, event):
     clickPos = self.GetInteractor().GetEventPosition()
     picker = vtk.vtkPointPicker()
     picker.Pick(clickPos[0], clickPos[1], 0, self.GetDefaultRenderer())
     point = picker.GetPointId()
     if (point != -1):
         altitude = self.grid.GetPointData().GetScalars().GetValue(point)
         self.textActor.SetInput("Altitude : " + str(altitude) + "m")
         altitudeSphere = vtk.vtkSphere()
         altitudeSphere.SetRadius(EARTH_RADIUS + altitude)
         self.cutter.SetCutFunction(altitudeSphere)
         self.renWin.Render()
     self.OnMouseMove()
     return
Exemplo n.º 20
0
def main():
    colors = vtk.vtkNamedColors()

    sphere = vtk.vtkSphere()
    sphere.SetCenter(0, 0, 0)
    sphere.SetRadius(0.5)

    # The sample function generates a distance function from the implicit
    # function. This is then contoured to get a polygonal surface.
    sample = vtk.vtkSampleFunction()
    sample.SetImplicitFunction(sphere)
    sample.SetModelBounds(-.5, .5, -.5, .5, -.5, .5)
    sample.SetSampleDimensions(20, 20, 20)
    sample.ComputeNormalsOff()

    # contour
    surface = vtk.vtkContourFilter()
    surface.SetInputConnection(sample.GetOutputPort())
    surface.SetValue(0, 0.0)

    # mapper
    mapper = vtk.vtkPolyDataMapper()
    mapper.SetInputConnection(surface.GetOutputPort())
    mapper.ScalarVisibilityOff()
    actor = vtk.vtkActor()
    actor.SetMapper(mapper)
    actor.GetProperty().EdgeVisibilityOn()
    actor.GetProperty().SetColor(colors.GetColor3d('AliceBlue'))
    actor.GetProperty().SetEdgeColor(colors.GetColor3d('SteelBlue'))

    # A renderer and render window
    renderer = vtk.vtkRenderer()
    renderer.SetBackground(colors.GetColor3d('Silver'))

    # add the actor
    renderer.AddActor(actor)

    # render window
    renwin = vtk.vtkRenderWindow()
    renwin.AddRenderer(renderer)
    renwin.SetWindowName('ImplicitSphere1')

    # An interactor
    interactor = vtk.vtkRenderWindowInteractor()
    interactor.SetRenderWindow(renwin)

    # Start
    interactor.Initialize()
    renwin.Render()
    interactor.Start()
Exemplo n.º 21
0
def main():
    colors = vtk.vtkNamedColors()

    # Set the background color.
    colors.SetColor("BkgColor", [51, 77, 102, 255])

    sphere = vtk.vtkSphere()

    # Sample the function
    sample = vtk.vtkSampleFunction()
    sample.SetSampleDimensions(50, 50, 50)
    sample.SetImplicitFunction(sphere)
    value = 2.0
    xmin = -value
    xmax = value
    ymin = -value
    ymax = value
    zmin = -value
    zmax = value
    sample.SetModelBounds(xmin, xmax, ymin, ymax, zmin, zmax)

    # Create the 0 isosurface
    contours = vtk.vtkContourFilter()
    contours.SetInputConnection(sample.GetOutputPort())
    contours.GenerateValues(1, 1, 1)

    # Map the contours to graphical primitives
    contourMapper = vtk.vtkPolyDataMapper()
    contourMapper.SetInputConnection(contours.GetOutputPort())
    contourMapper.ScalarVisibilityOff()

    # Create an actor for the contours
    contourActor = vtk.vtkActor()
    contourActor.SetMapper(contourMapper)

    # Visualize
    renderer = vtk.vtkRenderer()
    renderWindow = vtk.vtkRenderWindow()
    renderWindow.AddRenderer(renderer)
    renderWindow.SetWindowName('ImplicitSphere')

    interactor = vtk.vtkRenderWindowInteractor()
    interactor.SetRenderWindow(renderWindow)

    renderer.AddActor(contourActor)
    renderer.SetBackground(colors.GetColor3d("BkgColor"))

    renderWindow.Render()
    interactor.Start()
Exemplo n.º 22
0
def vtk_sphere(center, radius):
    """Returns a vtk sphere object based on the bounds

    Args:
        center (list): Center of the sphere
        radius (float): Radius of the sphere

    Returns:
        sphere (vtkSphere): A vtkSphere
    """
    sphere = vtk.vtkSphere()
    sphere.SetCenter(center)
    sphere.SetRadius(radius)

    return sphere
Exemplo n.º 23
0
def make_blob(n, radius):
    blob_image = vtk.vtkImageData()

    max_r = 50 - 2.0 * radius
    random_sequence = vtk.vtkMinimalStandardRandomSequence()
    random_sequence.SetSeed(5071)
    for i in range(0, n):

        sphere = vtk.vtkSphere()
        sphere.SetRadius(radius)

        x = random_sequence.GetRangeValue(-max_r, max_r)
        random_sequence.Next()
        y = random_sequence.GetRangeValue(-max_r, max_r)
        random_sequence.Next()
        z = random_sequence.GetRangeValue(-max_r, max_r)
        random_sequence.Next()

        sphere.SetCenter(int(x), int(y), int(z))

        sampler = vtk.vtkSampleFunction()
        sampler.SetImplicitFunction(sphere)
        sampler.SetOutputScalarTypeToFloat()
        sampler.SetSampleDimensions(100, 100, 100)
        sampler.SetModelBounds(-50, 50, -50, 50, -50, 50)

        thres = vtk.vtkImageThreshold()
        thres.SetInputConnection(sampler.GetOutputPort())
        thres.ThresholdByLower(radius * radius)
        thres.ReplaceInOn()
        thres.ReplaceOutOn()
        thres.SetInValue(i + 1)
        thres.SetOutValue(0)
        thres.Update()
        if i == 0:
            blob_image.DeepCopy(thres.GetOutput())

        max_value = vtk.vtkImageMathematics()
        max_value.SetInputData(0, blob_image)
        max_value.SetInputData(1, thres.GetOutput())
        max_value.SetOperationToMax()
        max_value.Modified()
        max_value.Update()

        blob_image.DeepCopy(max_value.GetOutput())

    return blob_image
Exemplo n.º 24
0
    def testImage(self):
        r = vtk.vtkRTAnalyticSource()
        r.SetWholeExtent(-5, 5, -5, 5, -5, 5)
        r.Update()

        s = vtk.vtkSphere()
        s.SetRadius(2)
        s.SetCenter(0,0,0)

        c = vtk.vtkTableBasedClipDataSet()
        c.SetInputConnection(r.GetOutputPort())
        c.SetClipFunction(s)
        c.SetInsideOut(1)

        c.Update()

        self.assertEqual(c.GetOutput().GetNumberOfCells(), 64)
Exemplo n.º 25
0
def move_past_sphere(centerline, center, r, start, step=-1, stop=0, X=0.8):
    """Moves a point along the centerline until it as outside MIS"""
    # Create the minimal inscribed sphere
    MISphere = vtk.vtkSphere()
    MISphere.SetCenter(center)
    MISphere.SetRadius(r * X)
    tempPoint = [0.0, 0.0, 0.0]

    # Go the length of one MISR backwards
    for i in range(start, stop, step):
        value = MISphere.EvaluateFunction(centerline.GetPoint(i))
        if (value >= 0.0):
            tempPoint = centerline.GetPoint(i)
            break

    r = centerline.GetPointData().GetArray(radiusArrayName).GetTuple1(i)
    return tempPoint, r
Exemplo n.º 26
0
    def testImage(self):
        r = vtk.vtkRTAnalyticSource()
        r.SetWholeExtent(-5, 5, -5, 5, -5, 5)
        r.Update()

        s = vtk.vtkSphere()
        s.SetRadius(2)
        s.SetCenter(0,0,0)

        c = vtk.vtkTableBasedClipDataSet()
        c.SetInputConnection(r.GetOutputPort())
        c.SetClipFunction(s)
        c.SetInsideOut(1)

        c.Update()

        self.assertEqual(c.GetOutput().GetNumberOfCells(), 64)
Exemplo n.º 27
0
def create_renderer_3(bone, skin):
    '''
    Return the third renderer
    bone: the bone dataset
    skin: the skin dataset
    '''
    # creating the sphere clipping
    radius = 60
    center = [70, 30, 100]
    sphere = vtk.vtkSphere()
    sphere.SetRadius(radius)
    sphere.SetCenter(center)

    # clipping
    clipper = vtk.vtkClipDataSet()
    clipper.SetClipFunction(sphere)
    clipper.SetInputConnection(skin.GetOutputPort())
    skin = clipper

    # creating actors
    bone_actor = create_actor(bone)
    bone_actor.GetProperty().SetColor(0.94, 0.94, 0.94)

    skin_actor = create_actor(skin)
    skin_actor.GetProperty().SetColor(0.8, 0.62, 0.62)

    # creating the sphere actor ----
    # sampling using the sphere implicit function
    sample = vtk.vtkSampleFunction()
    sample.SetImplicitFunction(sphere)
    sample.SetSampleDimensions(50, 50, 50)
    sample.SetModelBounds(center[0] - radius, center[0] + radius,
                          center[1] - radius, center[1] + radius,
                          center[2] - radius, center[2] + radius)
    # contouring. The sphere is described by a 0 iso-value
    sphere_actor = create_iso_actor(sample, 0)
    # design
    sphere_actor.GetProperty().SetColor(0.85, 0.8, 0.1)
    sphere_actor.GetProperty().SetOpacity(0.15)

    # creating renderer
    ren = create_renderer([bone_actor, skin_actor, sphere_actor])
    ren.SetBackground(0.827, 0.824, 1)

    return ren
Exemplo n.º 28
0
def create_sphere_clipping(vtk_algo, radius, coordinates):
    """Create a clipping actor between the vtk_object provided and a sphere at the coordinates and of the radius
    :param vtk_algo: The object to clip with the sphere
    :param radius: The radius of the sphere
    :param coordinates: The coordinates of the sphere
    :returns: An actor representing the object clipped with the sphere
    """
    sphere = vtk.vtkSphere()
    sphere.SetRadius(radius)
    sphere.SetCenter(coordinates)

    clipper = vtk.vtkClipPolyData()
    clipper.SetInputConnection(vtk_algo.GetOutputPort())
    clipper.SetClipFunction(sphere)
    clipper.GenerateClippedOutputOn()
    clipper.SetValue(0.5)

    return create_actor(clipper)
def FindClippingPointOnParentArtery(centerlines,parentCenterlines,toll):
   divergingPointID = -1
   divergingPoint = [0.0,0.0,0.0]
   divergingPointMISR = -1

   clippingPointID = -1
   clippingPoint = [0.0,0.0,0.0]
   
   cell0PointIds = vtk.vtkIdList()
   cell1PointIds = vtk.vtkIdList()

   centerlines.GetCellPoints(0,cell0PointIds) #this is the cl that goes through the aneurysm
   centerlines.GetCellPoints(1,cell1PointIds)
 
   for i in range(0,min(cell0PointIds.GetNumberOfIds(),cell1PointIds.GetNumberOfIds())):
      cell0Point = centerlines.GetPoint(cell0PointIds.GetId(i))
      cell1Point = centerlines.GetPoint(cell1PointIds.GetId(i))

      distanceBetweenPoints = math.sqrt(vtk.vtkMath.Distance2BetweenPoints(cell0Point,cell1Point))
      if (distanceBetweenPoints>toll):
        divergingPointID = cell1PointIds.GetId(i)
        divergingPoint = centerlines.GetPoint(cell1PointIds.GetId(i))
        divergingPointMISR = centerlines.GetPointData().GetArray(radiusArrayName).GetTuple1(cell1PointIds.GetId(i))
        break
  
   MISphere = vtk.vtkSphere()
   MISphere.SetCenter(divergingPoint)
   MISphere.SetRadius(divergingPointMISR)
   tempPoint = [0.0,0.0,0.0]

   for i in range(divergingPointID,0,-1):
      value = MISphere.EvaluateFunction(centerlines.GetPoint(i))
      if (value>=0.0):
         tempPoint = centerlines.GetPoint(i) 
         break
       
   locator = vtk.vtkPointLocator()
   locator.SetDataSet(parentCenterlines)
   locator.BuildLocator()
 
   clippingPointID = locator.FindClosestPoint(tempPoint)
   clippingPoint = parentCenterlines.GetPoint(clippingPointID)

   return clippingPoint,divergingPoint
Exemplo n.º 30
0
    def testRectilinear(self):
        rt = vtk.vtkRTAnalyticSource()
        rt.SetWholeExtent(-5, 5, -5, 5, -5, 5)
        rt.Update()
        i = rt.GetOutput()

        r = vtk.vtkRectilinearGrid()
        dims = i.GetDimensions()
        r.SetDimensions(dims)
        exts = i.GetExtent()
        orgs = i.GetOrigin()

        xs = vtk.vtkFloatArray()
        xs.SetNumberOfTuples(dims[0])
        for d in range(dims[0]):
            xs.SetTuple1(d, orgs[0] + exts[0] + d)
        r.SetXCoordinates(xs)

        ys = vtk.vtkFloatArray()
        ys.SetNumberOfTuples(dims[1])
        for d in range(dims[1]):
            ys.SetTuple1(d, orgs[1] + exts[2] + d)
        r.SetYCoordinates(ys)

        zs = vtk.vtkFloatArray()
        zs.SetNumberOfTuples(dims[2])
        for d in range(dims[2]):
            zs.SetTuple1(d, orgs[2] + exts[4] + d)
        r.SetZCoordinates(zs)

        s = vtk.vtkSphere()
        s.SetRadius(2)
        s.SetCenter(0,0,0)

        c = vtk.vtkTableBasedClipDataSet()
        c.SetInputData(r)
        c.SetClipFunction(s)
        c.SetInsideOut(1)

        c.Update()

        self.assertEqual(c.GetOutput().GetNumberOfCells(), 64)
Exemplo n.º 31
0
    def testRectilinear(self):
        rt = vtk.vtkRTAnalyticSource()
        rt.SetWholeExtent(-5, 5, -5, 5, -5, 5)
        rt.Update()
        i = rt.GetOutput()

        r = vtk.vtkRectilinearGrid()
        dims = i.GetDimensions()
        r.SetDimensions(dims)
        exts = i.GetExtent()
        orgs = i.GetOrigin()

        xs = vtk.vtkFloatArray()
        xs.SetNumberOfTuples(dims[0])
        for d in range(dims[0]):
            xs.SetTuple1(d, orgs[0] + exts[0] + d)
        r.SetXCoordinates(xs)

        ys = vtk.vtkFloatArray()
        ys.SetNumberOfTuples(dims[1])
        for d in range(dims[1]):
            ys.SetTuple1(d, orgs[1] + exts[2] + d)
        r.SetYCoordinates(ys)

        zs = vtk.vtkFloatArray()
        zs.SetNumberOfTuples(dims[2])
        for d in range(dims[2]):
            zs.SetTuple1(d, orgs[2] + exts[4] + d)
        r.SetZCoordinates(zs)

        s = vtk.vtkSphere()
        s.SetRadius(2)
        s.SetCenter(0,0,0)

        c = vtk.vtkTableBasedClipDataSet()
        c.SetInputData(r)
        c.SetClipFunction(s)
        c.SetInsideOut(1)

        c.Update()

        self.assertEqual(c.GetOutput().GetNumberOfCells(), 64)
Exemplo n.º 32
0
def move_past_sphere(centerline,
                     center,
                     r,
                     start,
                     step=-1,
                     stop=0,
                     scale_factor=0.8):
    """Moves a point along the centerline until it as outside the a sphere with radius (r)
    and a center (center).

    Args:
        centerline (vtkPolyData): Centerline to move along.
        center (list): point list of the center of the sphere
        r (float): the radius of a sphere
        start (int): id of the point along the centerline where to start.
        step (int): direction along the centerline.
        stop (int): ID along centerline, for when to stop searching.
        scale_factor (float): Scale the radius with this factor.

    Returns:
        tmp_point (list): The first point on the centerline outside the sphere
        r (float): minimal inscribed sphere radius at the new point.
        i (int): the centerline ID at the new point.
    """
    # Create the minimal inscribed sphere
    misr_sphere = vtk.vtkSphere()
    misr_sphere.SetCenter(center)
    misr_sphere.SetRadius(r * scale_factor)
    tmp_point = [0.0, 0.0, 0.0]

    # Go the length of one MISR backwards
    for i in range(start, stop, step):
        value = misr_sphere.EvaluateFunction(centerline.GetPoint(i))
        if value >= 0.0:
            tmp_point = centerline.GetPoint(i)
            break

    r = centerline.GetPointData().GetArray(radiusArrayName).GetTuple1(i)

    return tmp_point, r, i
Exemplo n.º 33
0
    def _Clip(self, pd):
        # The plane implicit function will be >0 for all the points in the positive side
        # of the plane (i.e. x s.t. n.(x-o)>0, where n is the plane normal and o is the
        # plane origin).
        plane = vtkPlane()
        plane.SetOrigin(self.Iolet.Centre.x, self.Iolet.Centre.y,
                        self.Iolet.Centre.z)
        plane.SetNormal(self.Iolet.Normal.x, self.Iolet.Normal.y,
                        self.Iolet.Normal.z)

        # The sphere implicit function will be >0 for all the points outside
        # the sphere.
        sphere = vtkSphere()
        sphere.SetCenter(self.Iolet.Centre.x, self.Iolet.Centre.y,
                         self.Iolet.Centre.z)
        sphere.SetRadius(self.Iolet.Radius)

        # The VTK_INTERSECTION operator takes the maximum value of all the registered
        # implicit functions. This will result in the function evaluating to >0 for all
        # the points outside the sphere plus those inside the sphere in the positive
        # side of the plane.
        clippingFunction = vtkImplicitBoolean()
        clippingFunction.AddFunction(plane)
        clippingFunction.AddFunction(sphere)
        clippingFunction.SetOperationTypeToIntersection()

        clipper = vtkClipPolyData()
        clipper.SetInputData(pd)
        clipper.SetClipFunction(clippingFunction)

        # Filter to get part closest to seed point
        connectedRegionGetter = vtkPolyDataConnectivityFilter()
        connectedRegionGetter.SetExtractionModeToClosestPointRegion()
        connectedRegionGetter.SetClosestPoint(*self.SeedPoint)
        connectedRegionGetter.SetInputConnection(clipper.GetOutputPort())
        connectedRegionGetter.Update()
        return connectedRegionGetter.GetOutput()
Exemplo n.º 34
0
print("Minor Version: ", rpd.GetFileMinorVersion())
print("File Version: ", rpd.GetFileVersion())

# Compare the strings and make sure a version difference is published.
if not "4.2" in legacyOutStr:
    print("Bad legacy writer output")
    sys.exit(1)

if not "5.1" in outStr:
    print("Bad writer output")
    sys.exit(1)

# Write / read unstructured data - legacy version
# Convert polydata to unstructured grid
print("\nI/O vtkUnstructuredGrid")
sph = vtk.vtkSphere()
sph.SetRadius(10000000)
extract = vtk.vtkExtractGeometry()
extract.SetInputConnection(sphere.GetOutputPort())
extract.SetImplicitFunction(sph)

wug = vtk.vtkUnstructuredGridWriter()
wug.SetFileVersion(42)
wug.WriteToOutputStringOn()
wug.SetInputConnection(extract.GetOutputPort())
wug.Write()

legacyOutStr = wug.GetOutputString()
#print(legacyOutStr)

rug = vtk.vtkUnstructuredGridReader()
Exemplo n.º 35
0
VTK_DATA_ROOT = vtkGetDataRoot()

# create pipeline
#
pl3d = vtk.vtkMultiBlockPLOT3DReader()
pl3d.SetXYZFileName(VTK_DATA_ROOT + "/Data/combxyz.bin")
pl3d.SetQFileName(VTK_DATA_ROOT + "/Data/combq.bin")
pl3d.SetScalarFunctionNumber(100)
pl3d.SetVectorFunctionNumber(202)
pl3d.Update()

output = pl3d.GetOutput().GetBlock(0)

# create a crazy implicit function
center = output.GetCenter()
sphere = vtk.vtkSphere()
sphere.SetCenter(center)
sphere.SetRadius(2.0)

sphere2 = vtk.vtkSphere()
sphere2.SetCenter(center[0] + 4.0, center[1], center[2])
sphere2.SetRadius(4.0)

boolOp = vtk.vtkImplicitBoolean()
boolOp.SetOperationTypeToUnion()
boolOp.AddFunction(sphere)
boolOp.AddFunction(sphere2)

# clip the structured grid to produce a tetrahedral mesh
clip = vtk.vtkClipDataSet()
clip.SetInputData(output)
Exemplo n.º 36
0
# implicit function. In this case the implicit function is formed by
# the boolean combination of two ellipsoids.

import vtk

# Here we create two ellipsoidal implicit functions and boolean them
# together tto form a "cross" shaped implicit function.
quadric = vtk.vtkQuadric()
quadric.SetCoefficients(.5, 1, .2, 0, .1, 0, 0, .2, 0, 0)
sample = vtk.vtkSampleFunction()
sample.SetSampleDimensions(50, 50, 50)
sample.SetImplicitFunction(quadric)
sample.ComputeNormalsOff()
trans = vtk.vtkTransform()
trans.Scale(1, .5, .333)
sphere = vtk.vtkSphere()
sphere.SetRadius(0.25)
sphere.SetTransform(trans)
trans2 = vtk.vtkTransform()
trans2.Scale(.25, .5, 1.0)
sphere2 = vtk.vtkSphere()
sphere2.SetRadius(0.25)
sphere2.SetTransform(trans2)
union = vtk.vtkImplicitBoolean()
union.AddFunction(sphere)
union.AddFunction(sphere2)
union.SetOperationType(0) #union

# Here is where it gets interesting. The implicit function is used to
# extract those cells completely inside the function. They are then
# shrunk to help show what was extracted.
Exemplo n.º 37
0
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)

# create implicit function primitives
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
theCone = vtk.vtkImplicitBoolean()
theCone.SetOperationTypeToIntersection()
theCone.AddFunction(cone)
theCone.AddFunction(vertPlane)
theCone.AddFunction(basePlane)

theCream = vtk.vtkImplicitBoolean()
Exemplo n.º 38
0
def main():
    colors = vtk.vtkNamedColors()

    fileName = get_program_parameters()

    # Read the image.
    readerFactory = vtk.vtkImageReader2Factory()
    reader = readerFactory.CreateImageReader2(fileName)
    reader.SetFileName(fileName)
    reader.Update()

    cast = vtk.vtkImageCast()
    cast.SetInputConnection(reader.GetOutputPort())
    cast.SetOutputScalarTypeToDouble()

    # Get rid of the discrete scalars.
    smooth = vtk.vtkImageGaussianSmooth()
    smooth.SetInputConnection(cast.GetOutputPort())
    smooth.SetStandardDeviations(0.8, 0.8, 0)

    m1 = vtk.vtkSphere()
    m1.SetCenter(310, 130, 0)
    m1.SetRadius(0)

    m2 = vtk.vtkSampleFunction()
    m2.SetImplicitFunction(m1)
    m2.SetModelBounds(0, 264, 0, 264, 0, 1)
    m2.SetSampleDimensions(264, 264, 1)

    m3 = vtk.vtkImageShiftScale()
    m3.SetInputConnection(m2.GetOutputPort())
    m3.SetScale(0.000095)

    div = vtk.vtkImageMathematics()
    div.SetInputConnection(0, smooth.GetOutputPort())
    div.SetInputConnection(1, m3.GetOutputPort())
    div.SetOperationToMultiply()

    # Create the actors.
    colorWindow = 256.0
    colorLevel = 127.5
    originalActor = vtk.vtkImageActor()
    originalActor.GetMapper().SetInputConnection(cast.GetOutputPort())
    originalActor.GetProperty().SetColorWindow(colorWindow)
    originalActor.GetProperty().SetColorLevel(colorLevel)

    filteredActor = vtk.vtkImageActor()
    filteredActor.GetMapper().SetInputConnection(div.GetOutputPort())

    # Define the viewport ranges.
    # (xmin, ymin, xmax, ymax)
    originalViewport = [0.0, 0.0, 0.5, 1.0]
    filteredViewport = [0.5, 0.0, 1.0, 1.0]

    # Setup the renderers.
    originalRenderer = vtk.vtkRenderer()
    originalRenderer.SetViewport(originalViewport)
    originalRenderer.AddActor(originalActor)
    originalRenderer.ResetCamera()
    originalRenderer.SetBackground(colors.GetColor3d("SlateGray"))

    filteredRenderer = vtk.vtkRenderer()
    filteredRenderer.SetViewport(filteredViewport)
    filteredRenderer.AddActor(filteredActor)
    filteredRenderer.ResetCamera()
    filteredRenderer.SetBackground(colors.GetColor3d("LightSlateGray"))

    renderWindow = vtk.vtkRenderWindow()
    renderWindow.SetSize(600, 300)
    renderWindow.AddRenderer(originalRenderer)
    renderWindow.AddRenderer(filteredRenderer)

    renderWindowInteractor = vtk.vtkRenderWindowInteractor()
    style = vtk.vtkInteractorStyleImage()

    renderWindowInteractor.SetInteractorStyle(style)

    renderWindowInteractor.SetRenderWindow(renderWindow)
    renderWindowInteractor.Initialize()

    renderWindowInteractor.Start()
Exemplo n.º 39
0
    def _createImplicit(self, implicitType, implicitName, bounds, primaryInput):
        if implicitType in self._implicitTypes and \
               implicitName not in self._implicitsDict:

            pi = primaryInput
            rwi = self.slice3dVWR.threedFrame.threedRWI
            implicitInfoBounds = None
            
            if implicitType == "Plane":
                implicitWidget = vtk.vtkImplicitPlaneWidget()
                implicitWidget.SetPlaceFactor(1.25)
                if pi != None:
                    implicitWidget.SetInput(pi)
                    implicitWidget.PlaceWidget()
                    b = pi.GetBounds()
                    implicitWidget.SetOrigin(b[0], b[2], b[4])
                    implicitInfoBounds = b
                elif bounds != None:
                    implicitWidget.PlaceWidget(bounds)
                    implicitWidget.SetOrigin(bounds[0], bounds[2], bounds[4])
                    implicitInfoBounds = bounds
                else:
                    # this can never happen
                    pass

                implicitWidget.SetInteractor(rwi)
                implicitWidget.On()

                # create the implicit function
                implicitFunction = vtk.vtkPlane()
                # sync it to the initial widget
                self._syncPlaneFunctionToWidget(implicitWidget)
                # add it to the output
                self.outputImplicitFunction.AddFunction(implicitFunction)

                # now add an observer to the widget
                def observerImplicitPlaneWidget(widget, eventName):
                    # sync it to the initial widget
                    ret = self._syncPlaneFunctionToWidget(widget)
                    # also select the correct grid row
                    if ret != None:
                        name, ii = ret
                        row = self.findGridRowByName(name)
                        if row >= 0:
                            self._grid.SelectRow(row)

                oId = implicitWidget.AddObserver('EndInteractionEvent',
                                                 observerImplicitPlaneWidget)
                    
            elif implicitType == "Sphere":
                implicitWidget = vtk.vtkSphereWidget()
                implicitWidget.SetPlaceFactor(1.25)
                implicitWidget.TranslationOn()
                implicitWidget.ScaleOn()
                #implicitWidget.HandleVisibilityOn()
                
                if pi != None:
                    implicitWidget.SetInput(pi)
                    implicitWidget.PlaceWidget()
                    b = pi.GetBounds()
                    implicitInfoBounds = b
                    #implicitWidget.SetOrigin(b[0], b[2], b[4])
                elif bounds != None:
                    implicitWidget.PlaceWidget(bounds)
                    implicitInfoBounds = bounds
                    #implicitWidget.SetOrigin(bounds[0], bounds[2], bounds[4])
                else:
                    # this can never happen
                    pass

                implicitWidget.SetInteractor(rwi)
                implicitWidget.On()

                # create the implicit function
                implicitFunction = vtk.vtkSphere()
                # sync it to the initial widget
                self._syncSphereFunctionToWidget(implicitWidget)
                # add it to the output
                self.outputImplicitFunction.AddFunction(implicitFunction)

                # now add an observer to the widget
                def observerImplicitSphereWidget(widget, eventName):
                    # sync it to the initial widget
                    ret = self._syncSphereFunctionToWidget(widget)
                    # also select the correct grid row
                    if ret != None:
                        name, ii = ret
                        row = self.findGridRowByName(name)
                        if row >= 0:
                            self._grid.SelectRow(row)

                oId = implicitWidget.AddObserver('EndInteractionEvent',
                                                 observerImplicitSphereWidget)



            if implicitWidget:
                # set the priority so it gets interaction before the
                # ImagePlaneWidget.  3D widgets have default priority 0.5,
                # so we assign our widgets just a tad higher. (voiwidget
                # has 0.6 for example)
                # NB: in a completely weird twist of events, only slices
                # added AFTER this widget will act like they have lower
                # priority.  The initial slice still takes events from us!
                implicitWidget.SetPriority(0.7)
                
                # add to our internal thingy
                ii = implicitInfo()
                ii.name = implicitName
                ii.type = implicitType
                ii.widget = implicitWidget
                ii.bounds = implicitInfoBounds
                ii.oId = oId
                ii.function = implicitFunction
                
                self._implicitsDict[implicitName] = ii

                # now add to the grid
                nrGridRows = self._grid.GetNumberRows()
                self._grid.AppendRows()
                self._grid.SetCellValue(nrGridRows, self._gridNameCol,
                                        implicitName)
                self._grid.SetCellValue(nrGridRows, self._gridTypeCol,
                                       implicitType)

                # set the relevant cells up for Boolean
                for col in [self._gridEnabledCol]:

                    self._grid.SetCellRenderer(nrGridRows, col,
                                               wx.grid.GridCellBoolRenderer())
                    self._grid.SetCellAlignment(nrGridRows, col,
                                                wx.ALIGN_CENTRE,
                                                wx.ALIGN_CENTRE)

                self._setImplicitEnabled(ii.name, True)
Exemplo n.º 40
0
    def getModelROIStencil(self):

        import time

        _t0 = time.time()

        t1 = self.__Transform.GetInverse()
        roi_type = self.getModelROIType()
        roi_orientation = self.getModelROIOrientation()

        # bounds, extent and center
        b = self.getModelROIBounds()

        # abort early if we haven't been fully set up yet
        if b is None:
            return None

        # determine transformed boundary
        _index = [[0, 2, 4], [0, 2, 5], [0, 3, 4], [0, 3, 5], [1, 2, 4], [1, 2, 5], [1, 3, 4], [1, 3, 5]]

        b_t = [1e38, -1e38, 1e38, -1e38, 1e38, -1e38]
        is_identity = True

        # is transform identity?
        is_identity = self.__Transform.GetMatrix().Determinant() == 1.0
        # is_identity = False

        for i in range(8):
            i2 = _index[i]
            pt = [b[i2[0]], b[i2[1]], b[i2[2]]]
            _temp = self.__Transform.TransformPoint(pt[0], pt[1], pt[2])
            b_t[0] = min(_temp[0], b_t[0])
            b_t[1] = max(_temp[0], b_t[1])
            b_t[2] = min(_temp[1], b_t[2])
            b_t[3] = max(_temp[1], b_t[3])
            b_t[4] = min(_temp[2], b_t[4])
            b_t[5] = max(_temp[2], b_t[5])

        e_t = self._BoundsToExtent(b_t)

        # sanity check - check for inversion (caused by negative spacing)
        e_t = list(e_t)
        for i in range(3):
            if e_t[i * 2] > e_t[i * 2 + 1]:
                v = e_t[i * 2]
                e_t[i * 2] = e_t[i * 2 + 1]
                e_t[i * 2 + 1] = v

        # expand stencil extent by one pixel on all sides
        e_t = (e_t[0] - 1, e_t[1] + 1, e_t[2] - 1, e_t[3] + 1, e_t[4] - 1, e_t[5] + 1)

        # make sure we're dealing with ints
        e_t = map(int, e_t)

        if is_identity:
            # fast, but limited to canonical objects
            self._StencilGenerator = vtk.vtkROIStencilSource()
        else:
            # slow, but more generic
            self._StencilGenerator = vtk.vtkImplicitFunctionToImageStencil()

        self._StencilGenerator.SetOutputOrigin(self.getImageOrigin())
        self._StencilGenerator.SetOutputSpacing(self.getImageSpacing())

        # set extent of stencil - taking into account transformation
        self._StencilGenerator.SetOutputWholeExtent(e_t)

        if is_identity:
            # use DG's fast routines
            if roi_type == "box":
                self._StencilGenerator.SetShapeToBox()
            elif roi_type == "cylinder":
                if roi_orientation == "X":
                    self._StencilGenerator.SetShapeToCylinderX()
                elif roi_orientation == "Y":
                    self._StencilGenerator.SetShapeToCylinderY()
                elif roi_orientation == "Z":
                    self._StencilGenerator.SetShapeToCylinderZ()
            elif roi_type == "ellipsoid":
                self._StencilGenerator.SetShapeToEllipsoid()
            self._StencilGenerator.SetBounds(b)
        else:
            # use JG's slow routines
            if roi_type == "box":
                obj = vtk.vtkBox()
                obj.SetTransform(t1)
                obj.SetBounds(b)
            elif roi_type == "cylinder":
                cyl = vtk.vtkCylinder()
                cyl.SetRadius(1.0)

                xc, yc, zc = (b[1] + b[0]) * 0.5, (b[3] + b[2]) * 0.5, (b[5] + b[4]) * 0.5
                diam_a, diam_b, diam_c = (b[1] - b[0]), (b[3] - b[2]), (b[5] - b[4])

                # The cylinder is infinite in extent, so needs to be cropped by using the intersection
                # of three implicit functions -- the cylinder, and two cropping
                # planes
                obj = vtk.vtkImplicitBoolean()
                obj.SetOperationTypeToIntersection()
                obj.AddFunction(cyl)

                clip1 = vtk.vtkPlane()
                clip1.SetNormal(0, 1, 0)
                obj.AddFunction(clip1)

                clip2 = vtk.vtkPlane()
                clip2.SetNormal(0, -1, 0)
                obj.AddFunction(clip2)

                t2 = vtk.vtkTransform()
                t2.Translate(xc, yc, zc)

                if roi_orientation == "X":
                    # cylinder is infinite in extent in the y-axis
                    t2.Scale(1, diam_b / 2.0, diam_c / 2.0)
                    t2.RotateZ(90)
                    r = diam_a / 2.0
                elif roi_orientation == "Y":
                    # cylinder is infinite in extent in the y-axis
                    t2.Scale(diam_a / 2.0, 1, diam_c / 2.0)
                    r = diam_b / 2.0
                elif roi_orientation == "Z":
                    # cylinder is infinite in extent in the y-axis
                    t2.Scale(diam_a / 2.0, diam_b / 2.0, 1)
                    t2.RotateX(90)
                    r = diam_c / 2.0

                clip1.SetOrigin(0, r, 0)
                clip2.SetOrigin(0, -r, 0)

                # combine transforms
                t2.SetInput(self.__Transform)

                obj.SetTransform(t2.GetInverse())

            elif roi_type == "ellipsoid":
                obj = vtk.vtkSphere()
                obj.SetRadius(1.0)

                xc, yc, zc = (b[1] + b[0]) * 0.5, (b[3] + b[2]) * 0.5, (b[5] + b[4]) * 0.5
                diam_a, diam_b, diam_c = (b[1] - b[0]), (b[3] - b[2]), (b[5] - b[4])

                t2 = vtk.vtkTransform()
                t2.Translate(xc, yc, zc)
                t2.Scale(diam_a / 2.0, diam_b / 2.0, diam_c / 2.0)

                # combine transforms
                t2.SetInput(self.__Transform)

                obj.SetTransform(t2.GetInverse())

            self._StencilGenerator.SetInput(obj)

        _t1 = time.time()
        self._StencilGenerator.Update()
        _t2 = time.time()
        return self._StencilGenerator.GetOutput()
Exemplo n.º 41
0
def main():
    colors = vtk.vtkNamedColors()

    # create a sphere
    sphere = vtk.vtkSphere()
    sphere.SetRadius(1)
    sphere.SetCenter(1, 0, 0)

    # create a box
    box = vtk.vtkBox()
    box.SetBounds(-1, 1, -1, 1, -1, 1)

    # combine the two implicit functions
    boolean = vtk.vtkImplicitBoolean()
    boolean.SetOperationTypeToDifference()
    # boolean.SetOperationTypeToUnion()
    # boolean.SetOperationTypeToIntersection()
    boolean.AddFunction(box)
    boolean.AddFunction(sphere)

    # The sample function generates a distance function from the implicit
    # function. This is then contoured to get a polygonal surface.
    sample = vtk.vtkSampleFunction()
    sample.SetImplicitFunction(boolean)
    sample.SetModelBounds(-1, 2, -1, 1, -1, 1)
    sample.SetSampleDimensions(40, 40, 40)
    sample.ComputeNormalsOff()

    # contour
    surface = vtk.vtkContourFilter()
    surface.SetInputConnection(sample.GetOutputPort())
    surface.SetValue(0, 0.0)

    # mapper
    mapper = vtk.vtkPolyDataMapper()
    mapper.SetInputConnection(surface.GetOutputPort())
    mapper.ScalarVisibilityOff()
    actor = vtk.vtkActor()
    actor.SetMapper(mapper)
    actor.GetProperty().EdgeVisibilityOn()
    actor.GetProperty().SetColor(colors.GetColor3d('AliceBlue'))
    actor.GetProperty().SetEdgeColor(colors.GetColor3d('SteelBlue'))

    # A renderer and render window
    renderer = vtk.vtkRenderer()
    renderer.SetBackground(colors.GetColor3d('Silver'))

    # add the actor
    renderer.AddActor(actor)

    # render window
    renwin = vtk.vtkRenderWindow()
    renwin.AddRenderer(renderer)

    # An interactor
    interactor = vtk.vtkRenderWindowInteractor()
    interactor.SetRenderWindow(renwin)

    # Start
    interactor.Initialize()
    renwin.Render()
    # renderer.GetActiveCamera().AddObserver('ModifiedEvent', CameraModifiedCallback)
    renderer.GetActiveCamera().SetPosition(5.0, -4.0, 1.6)
    renderer.GetActiveCamera().SetViewUp(0.1, 0.5, 0.9)
    renderer.GetActiveCamera().SetDistance(6.7)
    renwin.Render()
    interactor.Start()
Exemplo n.º 42
0
#!/usr/bin/env python
import vtk
from vtk.test import Testing
from vtk.util.misc import vtkGetDataRoot
VTK_DATA_ROOT = vtkGetDataRoot()

# This example demonstrates adding two implicit models
# to produce an (unexpected!) result
# first we load in the standard vtk packages into tcl
geomObject1 = vtk.vtkCone()
geomObject2 = vtk.vtkSphere()
geomObject2.SetRadius(0.5)
geomObject2.SetCenter(0.5, 0, 0)
sum = vtk.vtkImplicitSum()
sum.SetNormalizeByWeight(1)
sum.AddFunction(geomObject1, 2)
sum.AddFunction(geomObject2, 1)
sample = vtk.vtkSampleFunction()
sample.SetImplicitFunction(sum)
sample.SetSampleDimensions(60, 60, 60)
sample.ComputeNormalsOn()
surface = vtk.vtkContourFilter()
surface.SetInputConnection(sample.GetOutputPort())
surface.SetValue(0, 0.0)
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(surface.GetOutputPort())
mapper.ScalarVisibilityOff()
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.GetProperty().SetDiffuseColor(0.2, 0.4, 0.6)
actor.GetProperty().SetSpecular(0.4)
Exemplo n.º 43
0
g3Mapper.SetScalarRange(output.GetScalarRange())
g3Actor = vtk.vtkActor()
g3Actor.SetMapper(g3Mapper)
g3Actor.AddPosition(0,0,15)
gf4 = vtk.vtkDataSetSurfaceFilter()
gf4.SetInputConnection(gf2.GetOutputPort())
gf4.UseStripsOn()
g4Mapper = vtk.vtkPolyDataMapper()
g4Mapper.SetInputConnection(gf4.GetOutputPort())
g4Mapper.SetScalarRange(output.GetScalarRange())
g4Actor = vtk.vtkActor()
g4Actor.SetMapper(g4Mapper)
g4Actor.AddPosition(0,15,15)
# create pipeline - unstructured grid
#
s = vtk.vtkSphere()
s.SetCenter(output.GetCenter())
s.SetRadius(100.0)
#everything
eg = vtk.vtkExtractGeometry()
eg.SetInputData(output)
eg.SetImplicitFunction(s)
gf5 = vtk.vtkDataSetSurfaceFilter()
gf5.SetInputConnection(eg.GetOutputPort())
g5Mapper = vtk.vtkPolyDataMapper()
g5Mapper.SetInputConnection(gf5.GetOutputPort())
g5Mapper.SetScalarRange(output.GetScalarRange())
g5Actor = vtk.vtkActor()
g5Actor.SetMapper(g5Mapper)
g5Actor.AddPosition(0,0,30)
gf6 = vtk.vtkDataSetSurfaceFilter()
Exemplo n.º 44
0
    def Execute(self):

        if self.Surface == None:
            self.PrintError('Error: no Surface.')

        self.Clipper = vtk.vtkClipPolyData()
        self.Clipper.SetInput(self.Surface)
        self.Clipper.GenerateClippedOutputOn()
        self.Clipper.SetInsideOut(self.InsideOut)
 
        if self.Interactive:

            if self.WidgetType == "box":
                self.ClipFunction = vtk.vtkPlanes()
            elif self.WidgetType == "sphere":
                self.ClipFunction = vtk.vtkSphere()
       
            self.Clipper.SetClipFunction(self.ClipFunction)

            self.Cutter = vtk.vtkCutter()
            self.Cutter.SetInput(self.Surface)
            self.Cutter.SetCutFunction(self.ClipFunction)

            self.ClippedSurface = vtk.vtkPolyData()
            self.CutLines = vtk.vtkPolyData()

            if not self.vmtkRenderer:
                self.vmtkRenderer = vmtkrenderer.vmtkRenderer()
                self.vmtkRenderer.Initialize()
                self.OwnRenderer = 1

            self.vmtkRenderer.RegisterScript(self) 

            mapper = vtk.vtkPolyDataMapper()
            mapper.SetInput(self.Surface)
            mapper.ScalarVisibilityOff()
            self.Actor = vtk.vtkActor()
            self.Actor.SetMapper(mapper)
            self.vmtkRenderer.Renderer.AddActor(self.Actor)

            if self.WidgetType == "box":
                self.ClipWidget = vtk.vtkBoxWidget()
                self.ClipWidget.GetFaceProperty().SetColor(0.6,0.6,0.2)
                self.ClipWidget.GetFaceProperty().SetOpacity(0.25)
            elif self.WidgetType == "sphere":
                self.ClipWidget = vtk.vtkSphereWidget()
                self.ClipWidget.GetSphereProperty().SetColor(0.6,0.6,0.2)
                self.ClipWidget.GetSphereProperty().SetOpacity(0.25)
                self.ClipWidget.GetSelectedSphereProperty().SetColor(0.6,0.0,0.0)
                self.ClipWidget.GetSelectedSphereProperty().SetOpacity(0.75)
                self.ClipWidget.SetRepresentationToSurface()
                self.ClipWidget.SetPhiResolution(20)
                self.ClipWidget.SetThetaResolution(20)

            self.ClipWidget.SetInteractor(self.vmtkRenderer.RenderWindowInteractor)
            
            self.vmtkRenderer.AddKeyBinding('space','Clip.',self.ClipCallback)
            self.vmtkRenderer.AddKeyBinding('i','Interact.',self.InteractCallback)
            self.Display()

            self.Transform = vtk.vtkTransform()
            self.ClipWidget.GetTransform(self.Transform)

            if self.OwnRenderer:
                self.vmtkRenderer.Deallocate()

        else:

            self.Surface.GetPointData().SetActiveScalars(self.ClipArrayName)

            self.Clipper.GenerateClipScalarsOff()
            self.Clipper.SetValue(self.ClipValue)
            self.Clipper.Update()

            self.Cutter = vtk.vtkContourFilter()
            self.Cutter.SetInput(self.Surface)
            self.Cutter.SetValue(0,self.ClipValue)
            self.Cutter.Update()

            self.Surface = self.Clipper.GetOutput()
            self.ClippedSurface = self.Clipper.GetClippedOutput()

            self.CutLines = self.Cutter.GetOutput()

        if self.CleanOutput == 1:

            cleaner = vtk.vtkCleanPolyData()
            cleaner.SetInput(self.Surface)
            cleaner.Update()
            self.Surface = cleaner.GetOutput()

            cleaner = vtk.vtkCleanPolyData()
            cleaner.SetInput(self.ClippedSurface)
            cleaner.Update()
            self.ClippedSurface = cleaner.GetOutput()

            cleaner = vtk.vtkCleanPolyData()
            cleaner.SetInput(self.CutLines)
            cleaner.Update()
            stripper = vtk.vtkStripper()
            stripper.SetInput(cleaner.GetOutput())
            stripper.Update()
            self.CutLines = stripper.GetOutput()

        if self.Surface.GetSource():
            self.Surface.GetSource().UnRegisterAllOutputs()
Exemplo n.º 45
0
#!/usr/bin/env python
import vtk
from vtk.test import Testing
from vtk.util.misc import vtkGetDataRoot
VTK_DATA_ROOT = vtkGetDataRoot()

# This example demonstrates adding two implicit models
# to produce an (unexpected!) result
# first we load in the standard vtk packages into tcl
geomObject1 = vtk.vtkCone()
geomObject2 = vtk.vtkSphere()
geomObject2.SetRadius(0.5)
geomObject2.SetCenter(0.5,0,0)
sum = vtk.vtkImplicitSum()
sum.SetNormalizeByWeight(1)
sum.AddFunction(geomObject1,2)
sum.AddFunction(geomObject2,1)
sample = vtk.vtkSampleFunction()
sample.SetImplicitFunction(sum)
sample.SetSampleDimensions(60,60,60)
sample.ComputeNormalsOn()
surface = vtk.vtkContourFilter()
surface.SetInputConnection(sample.GetOutputPort())
surface.SetValue(0,0.0)
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(surface.GetOutputPort())
mapper.ScalarVisibilityOff()
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.GetProperty().SetDiffuseColor(0.2,0.4,0.6)
actor.GetProperty().SetSpecular(0.4)
Exemplo n.º 46
0
def SmoothClippedVoronoiDiagram(voronoi,centerlines):
   numberOfPoints = voronoi.GetNumberOfPoints()
   numberOfCenterlinesPoints = centerlines.GetNumberOfPoints()

   maskArray = vtk.vtkIntArray()
   maskArray.SetNumberOfComponents(1)
   maskArray.SetNumberOfTuples(numberOfPoints)
   maskArray.FillComponent(0,0)

   for i in range(numberOfCenterlinesPoints):
     localRadius = centerlines.GetPointData().GetArray(radiusArrayName).GetTuple1(i)

     threshold = localRadius*(1.0 - smoothingFactor) 

     sphere = vtk.vtkSphere()
     sphere.SetRadius(localRadius)
     sphere.SetCenter(centerlines.GetPoint(i))

     localMaskArray = vtk.vtkIntArray()
     localMaskArray.SetNumberOfComponents(1)
     localMaskArray.SetNumberOfTuples(numberOfPoints)
     localMaskArray.FillComponent(0,0)

     for j in range(numberOfPoints):
        value = sphere.EvaluateFunction(voronoi.GetPoint(j))    
        if (value <= 0.0):
           localMaskArray.SetTuple1(j,1) 

     for j in range(numberOfPoints):
       value = localMaskArray.GetTuple1(j)
       if (value==1):
          r = voronoi.GetPointData().GetArray(radiusArrayName).GetTuple1(j) 
          if (r>threshold):
             maskArray.SetTuple1(j,1)

   finalNumberOfMaskedPoints = ComputeNumberOfMaskedPoints(maskArray)
   print('from original number of points ', numberOfPoints,'to',finalNumberOfMaskedPoints)

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

   radiusArray = vtk.vtkDoubleArray()
   radiusArray.SetNumberOfComponents(1)
   radiusArray.SetNumberOfTuples(finalNumberOfMaskedPoints)
   radiusArray.FillComponent(0,0.0)
   radiusArray.SetName(radiusArrayName)

   count = 0
   for i in range(numberOfPoints):
      value = maskArray.GetTuple1(i)
      if (value==1):
         radius = voronoi.GetPointData().GetArray(radiusArrayName).GetTuple1(i)
      
         points.InsertNextPoint(voronoi.GetPoint(i))
         cellArray.InsertNextCell(1)
         cellArray.InsertCellPoint(count) 
         radiusArray.SetTuple1(count,radius)
         count +=1

   smoothedDiagram.SetPoints(points)
   smoothedDiagram.SetVerts(cellArray)
   smoothedDiagram.GetPointData().AddArray(radiusArray)
   return smoothedDiagram
Exemplo n.º 47
0
    def makeModels(self):
        """
        make vtk model
        """

        # Here we create two ellipsoidal implicit functions and boolean them
        # together to form a "cross" shaped implicit function.
        quadric = vtk.vtkQuadric()
        quadric.SetCoefficients(.5, 1, .2, 0, .1, 0, 0, .2, 0, 0)

        sample = vtk.vtkSampleFunction()
        sample.SetSampleDimensions(50, 50, 50)
        sample.SetImplicitFunction(quadric)
        sample.ComputeNormalsOff()

        trans = vtk.vtkTransform()
        trans.Scale(1, .5, .333)
        sphere = vtk.vtkSphere()
        sphere.SetRadius(self.radius)
        sphere.SetTransform(trans)

        trans2 = vtk.vtkTransform()
        trans2.Scale(.25, .5, 1.0)
        sphere2 = vtk.vtkSphere()
        sphere2.SetRadius(self.radius)
        sphere2.SetTransform(trans2)

        self.sphere_geom_1 = sphere
        self.sphere_geom_2 = sphere2

        union = vtk.vtkImplicitBoolean()
        union.AddFunction(sphere)
        union.AddFunction(sphere2)
        union.SetOperationType(0)

        # Here is where it gets interesting. The implicit function is used to
        # extract those cells completely inside the function. They are then
        # shrunk to helpr show what was extracted.
        extract = vtk.vtkExtractGeometry()
        extract.SetInputConnection(sample.GetOutputPort())
        extract.SetImplicitFunction(union)
        shrink = vtk.vtkShrinkFilter()
        shrink.SetInputConnection(extract.GetOutputPort())
        shrink.SetShrinkFactor(self.shrink_factor)
        dataMapper = vtk.vtkDataSetMapper()
        dataMapper.SetInputConnection(shrink.GetOutputPort())

        self.shrink_geom = shrink

        # data actor
        self.data_actor = vtk.vtkActor()
        self.data_actor.SetMapper(dataMapper)

        # The outline gives context to the original data.
        outline = vtk.vtkOutlineFilter()
        outline.SetInputConnection(sample.GetOutputPort())
        outlineMapper = vtk.vtkPolyDataMapper()
        outlineMapper.SetInputConnection(outline.GetOutputPort())

        # outline actor
        self.outline_actor = vtk.vtkActor()
        self.outline_actor.SetMapper(outlineMapper)
        outlineProp = self.outline_actor.GetProperty()
        outlineProp.SetColor(0, 0, 0)
Exemplo n.º 48
0
# Parameters for debugging
NPts = 1000000
math = vtk.vtkMath()
math.RandomSeed(31415)

# create pipeline
#
points = vtk.vtkBoundedPointSource()
points.SetNumberOfPoints(NPts)
points.ProduceRandomScalarsOn()
points.ProduceCellOutputOff()
points.Update()

# Create a sphere implicit function
sphere = vtk.vtkSphere()
sphere.SetCenter(0.0, 0.1, 0.2)
sphere.SetRadius(0.75)

# Extract points within sphere
extract = vtk.vtkFitImplicitFunction()
extract.SetInputConnection(points.GetOutputPort())
extract.SetImplicitFunction(sphere)
extract.SetThreshold(0.005)
extract.GenerateVerticesOn()

# Clip out some of the points with a plane; requires vertices
plane = vtk.vtkPlane()
plane.SetOrigin(sphere.GetCenter())
plane.SetNormal(1, 1, 1)
Exemplo n.º 49
0
ren1 = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren1)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# create implicit function primitives
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
theCone = vtk.vtkImplicitBoolean()
theCone.SetOperationTypeToIntersection()
theCone.AddFunction(cone)
theCone.AddFunction(vertPlane)
theCone.AddFunction(basePlane)
theCream = vtk.vtkImplicitBoolean()
theCream.SetOperationTypeToDifference()
theCream.AddFunction(iceCream)
theCream.AddFunction(bite)
Exemplo n.º 50
0
g3Mapper.SetScalarRange(output.GetScalarRange())
g3Actor = vtk.vtkActor()
g3Actor.SetMapper(g3Mapper)
g3Actor.AddPosition(0,0,15)
gf4 = vtk.vtkDataSetSurfaceFilter()
gf4.SetInputConnection(gf2.GetOutputPort())
gf4.UseStripsOn()
g4Mapper = vtk.vtkPolyDataMapper()
g4Mapper.SetInputConnection(gf4.GetOutputPort())
g4Mapper.SetScalarRange(output.GetScalarRange())
g4Actor = vtk.vtkActor()
g4Actor.SetMapper(g4Mapper)
g4Actor.AddPosition(0,15,15)
# create pipeline - unstructured grid
#
s = vtk.vtkSphere()
s.SetCenter(output.GetCenter())
s.SetRadius(100.0)
#everything
eg = vtk.vtkExtractGeometry()
eg.SetInputData(output)
eg.SetImplicitFunction(s)
gf5 = vtk.vtkDataSetSurfaceFilter()
gf5.SetInputConnection(eg.GetOutputPort())
g5Mapper = vtk.vtkPolyDataMapper()
g5Mapper.SetInputConnection(gf5.GetOutputPort())
g5Mapper.SetScalarRange(output.GetScalarRange())
g5Actor = vtk.vtkActor()
g5Actor.SetMapper(g5Mapper)
g5Actor.AddPosition(0,0,30)
gf6 = vtk.vtkDataSetSurfaceFilter()
Exemplo n.º 51
0
def gen_slice(args):

    verbose = args.verbose
    origin = args.origin
    normal = args.normal
    output_file = args.output_file[0]
    input_file =  args.input_file[0]
    variable =  args.variable[0]
    on_sphere = args.sphere
    sphere_radius = args.sphere_radius
    depth = args.sphere_radius

    xi = []
    yi = []
    zi = []
    vtu_files = []
    path = os.path.dirname(input_file)
    
    if (not on_sphere):
        if (normal == (0,0,1)):
            index_1 = 0
            index_2 = 1
            x_axis = "X"
            y_axis = "Y"
        elif(normal == (0,1,0)):
            index_1 = 0
            index_2 = 2
            x_axis = "X"
            y_axis = "Depth"
        elif(normal == (1,0,0)):
            index_1 = 1
            index_2 = 2
            x_axis = "Y"
            y_axis = "Depth"
        else:
            print "Normal should be one of (1,0,0), (0,1,0), or (0,0,1)"
            sys.exit(-1)
        # check origin
        if (origin == None):
            print "Origin should be a set of three corrdinate, eg. (0,0,-10)"
            sys.exit(-1)
    else:
        import fluidity.spheretools as st
        index_1 = 0
        index_2 = 1
        index_3 = 2
        x_axis = "Longitude"
        y_axis = "Latitude"


    # get vtus from pvtu file. They are in lines such as:
    # <Piece Source="restratA-np64-adapt-C_99/restratA-np64-adapt-C_99_0.vtu" />
    # As PVTU is XML, parse as such and grab the Piece elements
    xml_root = etree.parse(input_file,xml_parser)
    find = etree.XPath("//Piece")
    peices = find(xml_root)
    for p in peices:
        name = p.attrib['Source']
        vtu_files.append(os.path.join(path,name))
      
    if (on_sphere):
        sphere = vtk.vtkSphere()
        sphere.SetCenter(0,0,0)
        sphere.SetRadius(sphere_radius-10)
    else:
        plane = vtk.vtkPlane()
        plane.SetOrigin(origin[0], origin[1], origin[2])
        plane.SetNormal(normal[0],normal[1],normal[2])


    getMagnitude = False
    component = -1
    # Special cases of variables
    if (variable == "VelocityMagnitude"):
        getMagnitude = True
        variable = "Velocity_projection"
    if (variable == "VelocityU"):
        getMagnitude = False
        variable = "ProjectedVelocity"
        component = 0
    if (variable == "VelocityV"):
        getMagnitude = False
        variable = "ProjectedVelocity"
        component = 1   
    if (variable == "BedShearStressMagnitude"):
        getMagnitude = True
        variable = "BedShearStress_projection"
    if (variable == "MaxBedShearStressMagnitude"):
        getMagnitude = True
        variable = "MaxBedShearStress_projection"
    if (variable == "AveBedShearStressMagnitude"):
        getMagnitude = True
        variable = "AveBedShearStress_projection"
    if (variable == "MaxVelocityMagnitude"):
        getMagnitude = True
        variable = "MaxVelocity_projection"
    if (variable == "AveVelocityMagnitude"):
        getMagnitude = True
        variable = "AveVelocity_projection"
    if (variable == "AveVelocityU"):
        getMagnitude = False
        component = 0
        variable = "AveVelocity_projection"
    if (variable == "AveVelocityV"):
        getMagnitude = False
        component = 1
        variable = "AveVelocity_projection"
    if (variable == "MaxVelocityU"):
        getMagnitude = False
        component = 0
        variable = "MaxVelocity_projection"
    if (variable == "MaxVelocityV"):
        getMagnitude = False
        component = 1
        variable = "MaxVelocity_projection"
    if (variable == "AveBedShearStressU"):
        getMagnitude = False
        component = 0
        variable = "AveBedShearStress_projection"
    if (variable == "AveBedShearStressV"):
        getMagnitude = False
        component = 1
        variable = "AveBedShearStress_projection"
    if (variable == "MaxBedShearStressU"):
        getMagnitude = False
        component = 0
        variable = "MaxBedShearStress_projection"
    if (variable == "MaxBedShearStressV"):
        getMagnitude = False
        component = 1
        variable = "MaxBedShearStress_projection"
    
    comp_1 = []
    comp_2 = []
    comp_3 = []
    # the above are for later...numpy.array[[list],[list]] is sllloooowww

    #for each vtu, grab any slice data
    i = 0
    for v in vtu_files:
        if (verbose):
            print v
        # grab the number
        num = i

        # Start by loading some data.
        reader=vtk.vtkXMLUnstructuredGridReader()
        reader.SetFileName(v)
        reader.Update()
        grid=reader.GetOutput()
        grid.GetPointData().SetActiveScalars(variable)

        cut = vtk.vtkCutter()
        if (on_sphere):
            cut.SetCutFunction(sphere)
        else:
            cut.SetCutFunction(plane)
        cut.SetInputConnection(reader.GetOutputPort())
        cut.Update()

        i = i+1
        
        d = cut.GetOutput().GetPointData().GetScalars()
        d.GetNumberOfTuples()
        slice_data = np.array([d.GetTuple(i) for i in range(d.GetNumberOfTuples())])
        c = cut.GetOutput()
        coords = []
        for i in range(0,c.GetNumberOfPoints()):
            coords.append(c.GetPoint(i))
        coords = np.array(coords)

        if (len(slice_data) > 0):
            n_comps = len(slice_data[0])
            if (on_sphere):
                if (n_comps  == 3):


                    # project vectors and coords
                    for i in range(0,len(coords[:,0])):
                        #print coords[i,0],coords[i,1],coords[i,2]
                        #print slice_data[i,0],slice_data[i,1],slice_data[i,2]
                        [[radial, polar, azimuthal],[lat,lon]] = \
                            sp.vector_cartesian_2_spherical_polar(slice_data[i,0],slice_data[i,1],slice_data[i,2],
                                    coords[i,0],coords[i,1],coords[i,2])
                        xi.append(math.degrees(lon))
                        yi.append(math.degrees(lat))
                        slice_data[i,0] = radial
                        slice_data[i,1] = polar
                        slice_data[i,2] = azimuthal
                elif (n_comps == 1):
                    #project points only
                    for i in range(0,len(coords[:,0])):
                        lat,lon = st.cart2polar(coords[i,:])
                        xi.append(math.degrees(lon))
                        yi.append(math.degrees(lat))
                else:
                    print("Unknown number of componenets - not a 3D vector or scalar")
                    sys.exit(-1)
            else:
                xi.extend(coords[:,index_1])
                yi.extend(coords[:,index_2])
            
            if (getMagnitude):
                # How to calculate the magnitude nicely..? Below seems rather brute force.
                mag = []
                mag = slice_data[:,0]
                for j in range(0,len(mag)):
                        mag[j] = mag[j]*mag[j]
                for i in range(1,n_comps):
                    for j in range(0,len(mag)):
                        mag[j] = mag[j] + slice_data[j,i]*slice_data[j,i]
                for j in range(0,len(mag)):
                        mag[j] =math.sqrt(mag[j])
                zi.extend(mag)
            elif (component > -1):
                zi.extend(slice_data[:,component])
            else:
                if (n_comps == 3):
                    comp_1.extend(slice_data[:,0])
                    comp_2.extend(slice_data[:,1])
                    comp_3.extend(slice_data[:,2])
                else:
                    zi.extend(slice_data[:,0])


    # THe data contain > 1 components, but we only want one
    if (component > -1 or getMagnitude) :
        n_comps = 1
        #if (component == 1):
        #    zi = comp_1
        #elif (component == 2):
        #    zi = comp_2
        #elif (component == 3):
        #    zi = comp_3
        #else:
        #    print "Error - you seem to be generating 4D data!"
        #    sys.exit(-1)
    coords = []
    # need to tidy up these arrays - lot's duplicate points from halos, DG, or whatever
    if (n_comps == 3):
        for i in range(len(xi)):
            coords.append([xi[i],yi[i],comp_1[i],comp_2[i],comp_3[i]])
    elif (n_comps == 1):
        for i in range(len(xi)):
            coords.append([xi[i],yi[i],zi[i]])
    else:
        print "Error. I expect 1 or 3 components"
        sys.exit(-1)

    if (verbose):
        print "Removing duplicated points"
    coords_checked = unique(coords)
    
    if (verbose):
        print "Saving file"

    xi = []
    yi = []
    zi = []
    for c in coords_checked:
        xi.append(c[0])
        yi.append(c[1])
        if (n_comps == 3):
            zi.append([c[2], c[3], c[4]])
        else:
            zi.append(c[2])
        i += 1

    # Store data as a pickle
    data = [xi,yi,zi]
    # Add axes labels
    axes_info = [index_1,index_2,x_axis,y_axis]
    data.append(axes_info)
    pickle.dump( data, open( output_file, "wb" ) )
Exemplo n.º 52
0
                          math.Random(.2, 1), 1)
        i += 1


lut = vtk.vtkLookupTable()
MakeColors(lut, 256)
n = 20
radius = 10

# This has been moved outside the loop so that the code can be correctly
# translated to python
blobImage = vtk.vtkImageData()

i = 0
while i < n:
    sphere = vtk.vtkSphere()
    sphere.SetRadius(radius)
    max = 50 - radius
    sphere.SetCenter(int(math.Random(-max, max)), int(math.Random(-max, max)),
                     int(math.Random(-max, max)))

    sampler = vtk.vtkSampleFunction()
    sampler.SetImplicitFunction(sphere)
    sampler.SetOutputScalarTypeToFloat()
    sampler.SetSampleDimensions(51, 51, 51)
    sampler.SetModelBounds(-50, 50, -50, 50, -50, 50)

    thres = vtk.vtkImageThreshold()
    thres.SetInputConnection(sampler.GetOutputPort())
    thres.ThresholdByLower(radius * radius)
    thres.ReplaceInOn()
res = 50

# Create the RenderWindow, Renderers and both Actors
ren0 = vtk.vtkRenderer()
ren1 = vtk.vtkRenderer()
ren2 = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.SetMultiSamples(0)
renWin.AddRenderer(ren0)
renWin.AddRenderer(ren1)
renWin.AddRenderer(ren2)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)

# Create a synthetic source: sample a sphere across a volume
sphere = vtk.vtkSphere()
sphere.SetCenter( 0.0,0.0,0.0)
sphere.SetRadius(0.25)

sample = vtk.vtkSampleFunction()
sample.SetImplicitFunction(sphere)
sample.SetModelBounds(-0.5,0.5, -0.5,0.5, -0.5,0.5)
sample.SetSampleDimensions(res,res,res)
sample.Update()

# Adds random attributes
random = vtk.vtkRandomAttributeGenerator()
random.SetGenerateCellScalars(True)
random.SetInputConnection(sample.GetOutputPort())

# Convert the image data to unstructured grid
Exemplo n.º 54
0
# res = 200

# Create the RenderWindow, Renderers and both Actors
ren0 = vtk.vtkRenderer()
ren1 = vtk.vtkRenderer()
ren2 = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.SetMultiSamples(0)
renWin.AddRenderer(ren0)
renWin.AddRenderer(ren1)
renWin.AddRenderer(ren2)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)

# Create a synthetic source: sample a sphere across a volume
sphere = vtk.vtkSphere()
sphere.SetCenter(0.0, 0.0, 0.0)
sphere.SetRadius(0.25)

sample = vtk.vtkSampleFunction()
sample.SetImplicitFunction(sphere)
sample.SetModelBounds(-0.5, 0.5, -0.5, 0.5, -0.5, 0.5)
sample.SetSampleDimensions(res, res, res)
sample.Update()

# Adds random attributes
random = vtk.vtkRandomAttributeGenerator()
random.SetGenerateCellScalars(True)
random.SetInputConnection(sample.GetOutputPort())

# Convert the image data to unstructured grid
Exemplo n.º 55
0
sTube = positions[0]
sTubeX = sTube[:,0]
sTubeY = sTube[:,1]
sTubeZ = sTube[:,2]

tPairs = []

for i in range(1,np.shape(positions[0])[0]):
    tPairs.append((i-1,i))


spheres = [None]*np.size(sTubeX)
sphereActs = [None]*np.size(sTubeX)
for i in range(len(spheres)):
    spheres[i] = vtk.vtkSphere()
    spheres[i].SetCenter(sTubeX[i], sTubeY[i], sTubeZ[i])
    spheres[i].SetRadius(scalars[0])


cyls = [None]*len(tPairs)
for c in range(len(cyls)):
    icyl = vtk.vtkCylinder()
    p1 = vtk.vtkPlane()
    p1.SetOrigin(sTubeX[tPairs[c][0]],sTubeY[tPairs[c][0]],sTubeZ[tPairs[c][0]])
    p1.SetNormal(sTubeX[tPairs[c][1]] - sTubeX[tPairs[c][0]],sTubeY[tPairs[c][1]] - sTubeY[tPairs[c][0]],sTubeZ[tPairs[c][1]] - sTubeZ[tPairs[c][0]])
    p2 = vtk.vtkPlane()
    p2.SetOrigin(sTubeX[tPairs[c][1]],sTubeY[tPairs[c][1]],sTubeZ[tPairs[c][1]])
    p2.SetNormal(sTubeX[tPairs[c][0]] - sTubeX[tPairs[c][1]],sTubeY[tPairs[c][0]] - sTubeY[tPairs[c][1]],sTubeZ[tPairs[c][0]] - sTubeZ[tPairs[c][1]])
    ccyl = vtk.vtkImplicitBoolean()
    ccyl.SetOperationTypeToIntersection()