Example #1
0
 def __init__(self, module_manager):
     SimpleVTKClassModuleBase.__init__(
         self, module_manager,
         vtk.vtkHull(), 'Processing.',
         ('vtkPolyData',), ('vtkPolyData',),
         replaceDoc=True,
         inputFunctions=None, outputFunctions=None)
Example #2
0
 def __init__(self, module_manager):
     SimpleVTKClassModuleBase.__init__(self,
                                       module_manager,
                                       vtk.vtkHull(),
                                       'Processing.', ('vtkPolyData', ),
                                       ('vtkPolyData', ),
                                       replaceDoc=True,
                                       inputFunctions=None,
                                       outputFunctions=None)
Example #3
0
 def __init__(self, **kwargs):
     self.hull = vtk.vtkHull()
     self.poly_data = vtk.vtkPolyData()
     self.extractor = vtk.vtkExtractEdges()
     self.extractor.SetInput(self.poly_data)
     self.mapper = vtk.vtkPolyDataMapper()
     self.mapper.SetInputConnection(self.extractor.GetOutputPort())
     self.actor = vtk.vtkActor()
     self.actor.SetMapper(self.mapper)
     self._process_kwargs(**kwargs)
Example #4
0
 def __init__(self, **kwargs):
     self.hull = vtk.vtkHull()
     self.poly_data = vtk.vtkPolyData()
     self.extractor = vtk.vtkExtractEdges()
     self.extractor.SetInput(self.poly_data)
     self.mapper = vtk.vtkPolyDataMapper()
     self.mapper.SetInputConnection(self.extractor.GetOutputPort())
     self.actor = vtk.vtkActor()
     self.actor.SetMapper(self.mapper)
     self._process_kwargs(**kwargs)
Example #5
0
while i < 100:
    radius = 1.0
    theta = mathObj.Random(0,360)
    phi = mathObj.Random(0,180)
    x = expr.expr(globals(), locals(),["radius","*","sin","(","phi",")*","cos","(","theta",")"])
    y = expr.expr(globals(), locals(),["radius","*","sin","(","phi",")*","sin","(","theta",")"])
    z = expr.expr(globals(), locals(),["radius","*","cos","(","phi",")"])
    points.InsertPoint(i,x,y,z)
    normals.InsertTuple3(i,x,y,z)
    i = i + 1

planes = vtk.vtkPlanes()
planes.SetPoints(points)
planes.SetNormals(normals)
ss = vtk.vtkSphereSource()
hull = vtk.vtkHull()
hull.SetPlanes(planes)
pd = vtk.vtkPolyData()
hull.GenerateHull(pd,-20,20,-20,20,-20,20)
# triangulate them
#
mapHull = vtk.vtkPolyDataMapper()
mapHull.SetInputData(pd)
hullActor = vtk.vtkActor()
hullActor.SetMapper(mapHull)
# Create graphics objects
# Create the rendering window, renderer, and interactive renderer
ren1 = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren1)
iren = vtk.vtkRenderWindowInteractor()
Example #6
0
def main():
    colors = vtk.vtkNamedColors()

    planes = list()
    titles = list()

    # Using frustum planes.
    titles.append('Using frustum planes')
    camera = vtk.vtkCamera()
    planesArray = [0] * 24
    camera.GetFrustumPlanes(1, planesArray)
    planes.append(vtk.vtkPlanes())
    planes[0].SetFrustumPlanes(planesArray)

    # Using bounds.
    titles.append('Using bounds')
    sphereSource = vtk.vtkSphereSource()
    sphereSource.Update()
    bounds = [0] * 6
    sphereSource.GetOutput().GetBounds(bounds)
    planes.append(vtk.vtkPlanes())
    planes[1].SetBounds(bounds)

    # At this point we have the planes created by both of the methods above.
    # You can do whatever you want with them.

    # For visualisation we will produce an n-sided convex hull
    # and visualise it.

    # Create a common text property.
    textProperty = vtk.vtkTextProperty()
    textProperty.SetFontSize(16)
    textProperty.SetJustificationToCentered()

    renWin = vtk.vtkRenderWindow()
    renWin.SetSize(600, 600)
    renWin.SetWindowName('Planes')

    iRen = vtk.vtkRenderWindowInteractor()
    iRen.SetRenderWindow(renWin)

    hulls = list()
    pds = list()
    mappers = list()
    actors = list()
    renderers = list()
    textMappers = list()
    textActors = list()
    for i in range(0, len(planes)):
        hulls.append(vtk.vtkHull())
        hulls[i].SetPlanes(planes[i])

        pds.append(vtk.vtkPolyData())

        # To generate the convex hull we supply a vtkPolyData object and a bounding box.
        # We define the bounding box to be where we expect the resulting polyhedron to lie.
        # Make it a generous fit as it is only used to create the initial
        # polygons that are eventually clipped.
        hulls[i].GenerateHull(pds[i], -200, 200, -200, 200, -200, 200)

        mappers.append(vtk.vtkPolyDataMapper())
        mappers[i].SetInputData(pds[i])

        actors.append(vtk.vtkActor())
        actors[i].SetMapper(mappers[i])
        actors[i].GetProperty().SetColor(colors.GetColor3d('Moccasin'))
        actors[i].GetProperty().SetSpecular(0.8)
        actors[i].GetProperty().SetSpecularPower(30)

        renderers.append(vtk.vtkRenderer())
        renderers[i].AddActor(actors[i])

        textMappers.append(vtk.vtkTextMapper())
        textMappers[i].SetInput(titles[i])
        textMappers[i].SetTextProperty(textProperty)

        textActors.append(vtk.vtkActor2D())
        textActors[i].SetMapper(textMappers[i])
        textActors[i].SetPosition(100, 10)
        renderers[i].AddViewProp(textActors[i])

        renWin.AddRenderer(renderers[i])

    # Setup the viewports
    xGridDimensions = 2
    yGridDimensions = 1
    rendererSize = 300
    renWin.SetSize(rendererSize * xGridDimensions,
                   rendererSize * yGridDimensions)
    for row in range(0, yGridDimensions):
        for col in range(0, xGridDimensions):
            index = row * xGridDimensions + col

            # (xmin, ymin, xmax, ymax)
            viewport = [
                float(col) / xGridDimensions,
                float(yGridDimensions - (row + 1)) / yGridDimensions,
                float(col + 1) / xGridDimensions,
                float(yGridDimensions - row) / yGridDimensions
            ]

            if index > (len(actors) - 1):
                # Add a renderer even if there is no actor.
                # This makes the render window background all the same color.
                ren = vtk.vtkRenderer()
                ren.SetBackground(colors.GetColor3d('DarkSlateGray'))
                ren.SetViewport(viewport)
                renWin.AddRenderer(ren)
                continue

            renderers[index].SetViewport(viewport)
            renderers[index].SetBackground(colors.GetColor3d('DarkSlateGray'))
            renderers[index].ResetCamera()
            renderers[index].GetActiveCamera().Azimuth(30)
            renderers[index].GetActiveCamera().Elevation(-30)
            renderers[index].ResetCameraClippingRange()

    iRen.Initialize()
    renWin.Render()
    iRen.Start()
Example #7
0
ren1 = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.SetMultiSamples(0)
renWin.AddRenderer(ren1)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
byuReader = vtk.vtkBYUReader()
byuReader.SetGeometryFileName("" + str(VTK_DATA_ROOT) + "/Data/teapot.g")
byuMapper = vtk.vtkPolyDataMapper()
byuMapper.SetInputConnection(byuReader.GetOutputPort())
i = 0
while i < 9:
    locals()[get_variable_name("byuActor", i, "")] = vtk.vtkActor()
    locals()[get_variable_name("byuActor", i, "")].SetMapper(byuMapper)
    ren1.AddActor(locals()[get_variable_name("byuActor", i, "")])
    locals()[get_variable_name("hull", i, "")] = vtk.vtkHull()
    locals()[get_variable_name("hull", i, "")].SetInputConnection(byuReader.GetOutputPort())
    locals()[get_variable_name("hullMapper", i, "")] = vtk.vtkPolyDataMapper()
    locals()[get_variable_name("hullMapper", i, "")].SetInputConnection(locals()[get_variable_name("hull", i, "")].GetOutputPort())
    locals()[get_variable_name("hullActor", i, "")] = vtk.vtkActor()
    locals()[get_variable_name("hullActor", i, "")].SetMapper(locals()[get_variable_name("hullMapper", i, "")])
    locals()[get_variable_name("hullActor", i, "")].GetProperty().SetColor(1,0,0)
    locals()[get_variable_name("hullActor", i, "")].GetProperty().SetAmbient(0.2)
    locals()[get_variable_name("hullActor", i, "")].GetProperty().SetDiffuse(0.8)
    locals()[get_variable_name("hullActor", i, "")].GetProperty().SetRepresentationToWireframe()
    ren1.AddActor(locals()[get_variable_name("hullActor", i, "")])
    i = i + 1

byuReader.Update()
diagonal = byuActor0.GetLength()
i = 0
Example #8
0
ren1 = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.SetMultiSamples(0)
renWin.AddRenderer(ren1)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
byuReader = vtk.vtkBYUReader()
byuReader.SetGeometryFileName("" + str(VTK_DATA_ROOT) + "/Data/teapot.g")
byuMapper = vtk.vtkPolyDataMapper()
byuMapper.SetInputConnection(byuReader.GetOutputPort())
i = 0
while i < 9:
    locals()[get_variable_name("byuActor", i, "")] = vtk.vtkActor()
    locals()[get_variable_name("byuActor", i, "")].SetMapper(byuMapper)
    ren1.AddActor(locals()[get_variable_name("byuActor", i, "")])
    locals()[get_variable_name("hull", i, "")] = vtk.vtkHull()
    locals()[get_variable_name("hull", i, "")].SetInputConnection(
        byuReader.GetOutputPort())
    locals()[get_variable_name("hullMapper", i, "")] = vtk.vtkPolyDataMapper()
    locals()[get_variable_name("hullMapper", i, "")].SetInputConnection(
        locals()[get_variable_name("hull", i, "")].GetOutputPort())
    locals()[get_variable_name("hullActor", i, "")] = vtk.vtkActor()
    locals()[get_variable_name("hullActor", i,
                               "")].SetMapper(locals()[get_variable_name(
                                   "hullMapper", i, "")])
    locals()[get_variable_name("hullActor", i,
                               "")].GetProperty().SetColor(1, 0, 0)
    locals()[get_variable_name("hullActor", i,
                               "")].GetProperty().SetAmbient(0.2)
    locals()[get_variable_name("hullActor", i,
                               "")].GetProperty().SetDiffuse(0.8)