1. Basic Rendering Pipeline

This section demonstrates the core VTK components required to display a geometry object.

BasicCylinderRenderer.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import vtkmodules.vtkInteractionStyle
import vtkmodules.vtkRenderingOpenGL2
from vtkmodules.vtkCommonColor import vtkNamedColors
from vtkmodules.vtkFiltersSources import vtkCylinderSource
from vtkmodules.vtkRenderingCore import (
    vtkActor,
    vtkPolyDataMapper,
    vtkRenderWindow,
    vtkRenderWindowInteractor,
    vtkRenderer
)


def main():
    colors = vtkNamedColors()
    # Define background RGBA values normalized between 0 and 1
    bkg_rgba = [x / 255.0 for x in [26, 51, 102, 255]]
    colors.SetColor("DeepBlue", *bkg_rgba)

    # Construct a cylinder with 8 circumferential slices
    geo_source = vtkCylinderSource()
    geo_source.SetResolution(8)

    # Map the polygonal data to the rendering pipeline
    mapper = vtkPolyDataMapper()
    mapper.SetInputConnection(geo_source.GetOutputPort())

    # Actor handles material properties and transformations
    actor = vtkActor()
    actor.SetMapper(mapper)
    actor.GetProperty().SetColor(colors.GetColor3d("Tomato"))
    actor.RotateX(30.0)
    actor.RotateY(-45.0)

    # Initialize renderer, window, and interactor
    renderer = vtkRenderer()
    window = vtkRenderWindow()
    window.AddRenderer(renderer)
    interactor = vtkRenderWindowInteractor()
    interactor.SetRenderWindow(window)

    # Configure scene elements
    renderer.AddActor(actor)
    renderer.SetBackground(colors.GetColor3d("DeepBlue"))
    window.SetSize(300, 300)
    window.SetWindowName('Basic Cylinder')

    interactor.Initialize()
    renderer.ResetCamera()
    renderer.GetActiveCamera().Zoom(1.5)
    window.Render()
    interactor.Start()


if __name__ == '__main__':
    main()

2. Vector Mathematics

Utilizing the VTK math library for geometric calculations.

VectorDistanceCalc.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import math
from vtkmodules.vtkCommonCore import vtkMath


def main():
    point_start = (0, 0, 0)
    point_end = (1, 1, 1)

    sq_dist = vtkMath.Distance2BetweenPoints(point_start, point_end)
    actual_dist = math.sqrt(sq_dist)

    print(f'Point A: {point_start}')
    print(f'Point B: {point_end}')
    print(f'Squared Distance: {sq_dist}')
    print(f'Euclidean Distance: {actual_dist}')


if __name__ == '__main__':
    main()

3. Geometric Primitives and Coordinate Systems

Exploring various shapes and coordinate visualization tools.

AxisAndSphere.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import vtkmodules.vtkInteractionStyle
import vtkmodules.vtkRenderingOpenGL2
from vtkmodules.vtkCommonColor import vtkNamedColors
from vtkmodules.vtkCommonTransforms import vtkTransform
from vtkmodules.vtkFiltersSources import vtkSphereSource
from vtkmodules.vtkRenderingAnnotation import vtkAxesActor
from vtkmodules.vtkRenderingCore import (
    vtkActor,
    vtkPolyDataMapper,
    vtkRenderWindow,
    vtkRenderWindowInteractor,
    vtkRenderer
)


def main():
    color_mgr = vtkNamedColors()

    # Generate sphere mesh
    sphere_gen = vtkSphereSource()
    sphere_gen.SetCenter(0.0, 0.0, 0.0)
    sphere_gen.SetRadius(0.5)

    sphere_map = vtkPolyDataMapper()
    sphere_map.SetInputConnection(sphere_gen.GetOutputPort())

    sphere_actor = vtkActor()
    sphere_actor.SetMapper(sphere_map)

    ren = vtkRenderer()
    win = vtkRenderWindow()
    win.SetWindowName('Coordinate Axes Demo')
    win.AddRenderer(ren)

    iren = vtkRenderWindowInteractor()
    iren.SetRenderWindow(win)

    ren.AddActor(sphere_actor)
    ren.SetBackground(color_mgr.GetColor3d('SlateGray'))

    # Apply transformation to axes actors
    transform = vtkTransform()
    transform.Translate(1.0, 0.0, 0.0)

    axes = vtkAxesActor()
    axes.SetUserTransform(transform)

    ren.AddActor(axes)

    cam = ren.GetActiveCamera()
    cam.Azimuth(50)
    cam.Elevation(-30)

    ren.ResetCamera()
    win.Render()
    iren.Start()


if __name__ == '__main__':
    main()

RegularPolygonShape.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import vtkmodules.vtkInteractionStyle
import vtkmodules.vtkRenderingOpenGL2
from vtkmodules.vtkCommonColor import vtkNamedColors
from vtkmodules.vtkFiltersSources import vtkRegularPolygonSource
from vtkmodules.vtkRenderingCore import (
    vtkActor,
    vtkPolyDataMapper,
    vtkRenderWindow,
    vtkRenderWindowInteractor,
    vtkRenderer
)


def main():
    color_mgr = vtkNamedColors()

    # Create a circle by disabling inner polygons on a regular polygon source
    poly_src = vtkRegularPolygonSource()
    poly_src.GeneratePolygonOff()
    poly_src.SetNumberOfSides(50)
    poly_src.SetRadius(5.0)
    poly_src.SetCenter(0.0, 0.0, 0.0)

    mapper = vtkPolyDataMapper()
    mapper.SetInputConnection(poly_src.GetOutputPort())

    actor = vtkActor()
    actor.SetMapper(mapper)
    actor.GetProperty().SetColor(color_mgr.GetColor3d('Cornsilk'))

    renderer = vtkRenderer()
    window = vtkRenderWindow()
    window.SetWindowName("Circle Visual")
    window.AddRenderer(renderer)
    
    interactor = vtkRenderWindowInteractor()
    interactor.SetRenderWindow(window)

    renderer.AddActor(actor)
    renderer.SetBackground(color_mgr.GetColor3d('DarkGreen'))

    window.Render()
    interactor.Start()


if __name__ == '__main__':
    main()

MulticoloredLinesPipeline.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import vtkmodules.vtkInteractionStyle
import vtkmodules.vtkRenderingOpenGL2
from vtkmodules.vtkCommonColor import vtkNamedColors
from vtkmodules.vtkCommonCore import (
    vtkPoints,
    vtkUnsignedCharArray
)
from vtkmodules.vtkCommonDataModel import (
    vtkCellArray,
    vtkLine,
    vtkPolyData
)
from vtkmodules.vtkRenderingCore import (
    vtkActor,
    vtkPolyDataMapper,
    vtkRenderWindow,
    vtkRenderWindowInteractor,
    vtkRenderer
)


def main():
    lines_data = vtkPolyData()

    # Define three vertices
    origin_pt = [0.0, 0.0, 0.0]
    pt_a = [1.0, 0.0, 0.0]
    pt_b = [0.0, 1.0, 0.0]

    points_container = vtkPoints()
    points_container.InsertNextPoint(origin_pt)
    points_container.InsertNextPoint(pt_a)
    points_container.InsertNextPoint(pt_b)

    lines_data.SetPoints(points_container)

    # Define line connections using point indices
    line0 = vtkLine()
    line0.GetPointIds().SetId(0, 0)  # Connects to Origin
    line0.GetPointIds().SetId(1, 1)  # Connects to P0

    line1 = vtkLine()
    line1.GetPointIds().SetId(0, 0)  # Connects to Origin
    line1.GetPointIds().SetId(1, 2)  # Connects to P1

    cells = vtkCellArray()
    cells.InsertNextCell(line0)
    cells.InsertNextCell(line1)

    lines_data.SetLines(cells)

    named_colors = vtkNamedColors()
    cell_colors = vtkUnsignedCharArray()
    cell_colors.SetNumberOfComponents(3)
    try:
        cell_colors.InsertNextTupleValue(named_colors.GetColor3ub("Tomato"))
        cell_colors.InsertNextTupleValue(named_colors.GetColor3ub("Mint"))
    except AttributeError:
        cell_colors.InsertNextTypedTuple(named_colors.GetColor3ub("Tomato"))
        cell_colors.InsertNextTypedTuple(named_colors.GetColor3ub("Mint"))

    lines_data.GetCellData().SetScalars(cell_colors)

    pipeline_mapper = vtkPolyDataMapper()
    pipeline_mapper.SetInputData(lines_data)

    line_actor = vtkActor()
    line_actor.SetMapper(pipeline_mapper)
    line_actor.GetProperty().SetLineWidth(4)

    render = vtkRenderer()
    render.AddActor(line_actor)
    render.SetBackground(named_colors.GetColor3d("SlateGray"))

    window = vtkRenderWindow()
    window.SetWindowName("Colored Lines")
    window.AddRenderer(render)

    interact = vtkRenderWindowInteractor()
    interact.SetRenderWindow(window)

    window.Render()
    interact.Start()


if __name__ == '__main__':
    main()

ManualDodecahedronConstruction.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import vtkmodules.vtkInteractionStyle
import vtkmodules.vtkRenderingOpenGL2
from vtkmodules.vtkCommonColor import vtkNamedColors
from vtkmodules.vtkCommonDataModel import vtkPolyhedron
from vtkmodules.vtkRenderingCore import (
    vtkActor,
    vtkPolyDataMapper,
    vtkRenderWindow,
    vtkRenderWindowInteractor,
    vtkRenderer
)


def build_dodecahedron():
    polyh = vtkPolyhedron()

    for i in range(20):
        polyh.GetPointIds().InsertNextId(i)

    coords = [
        (1.21412, 0, 1.58931), (0.375185, 1.1547, 1.58931),
        (-0.982247, 0.713644, 1.58931), (-0.982247, -0.713644, 1.58931),
        (0.375185, -1.1547, 1.58931), (1.96449, 0, 0.375185),
        (0.607062, 1.86835, 0.375185), (-1.58931, 1.1547, 0.375185),
        (-1.58931, -1.1547, 0.375185), (0.607062, -1.86835, 0.375185),
        (1.58931, 1.1547, -0.375185), (-0.607062, 1.86835, -0.375185),
        (-1.96449, 0, -0.375185), (-0.607062, -1.86835, -0.375185),
        (1.58931, -1.1547, -0.375185), (0.982247, 0.713644, -1.58931),
        (-0.375185, 1.1547, -1.58931), (-1.21412, 0, -1.58931),
        (-0.375185, -1.1547, -1.58931), (0.982247, -0.713644, -1.58931)
    ]

    for x, y, z in coords:
        polyh.GetPoints().InsertNextPoint(x, y, z)

    face_topology = [
        12, 5, 0, 1, 2, 3, 4, 5, 0, 5, 10, 6, 1,
        5, 1, 6, 11, 7, 2, 5, 2, 7, 12, 8, 3, 5, 3, 8, 13, 9, 4,
        5, 4, 9, 14, 5, 0, 5, 15, 10, 5, 14, 19, 5, 16, 11, 6, 10, 15,
        5, 17, 12, 7, 11, 16, 5, 18, 13, 8, 12, 17, 5, 19, 14, 9, 13, 18,
        5, 19, 18, 17, 16, 15
    ]
    polyh.SetFaces(face_topology)
    polyh.Initialize()

    return polyh


def main():
    colors = vtkNamedColors()
    dodec = build_dodecahedron()

    mapper = vtkPolyDataMapper()
    mapper.SetInputData(dodec.GetPolyData())

    actor = vtkActor()
    actor.SetMapper(mapper)
    actor.GetProperty().SetColor(colors.GetColor3d('PapayaWhip'))

    renderer = vtkRenderer()
    window = vtkRenderWindow()
    window.SetWindowName('Dodecahedron View')
    window.AddRenderer(renderer)
    interactor = vtkRenderWindowInteractor()
    interactor.SetRenderWindow(window)

    renderer.AddActor(actor)
    renderer.SetBackground(colors.GetColor3d('CadetBlue'))
    camera = renderer.GetActiveCamera()
    camera.Azimuth(30)
    camera.Elevation(30)
    renderer.ResetCamera()

    window.Render()
    interactor.Start()


if __name__ == '__main__':
    main()

ExtrudedEllipseGeometry.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import math
import vtkmodules.vtkInteractionStyle
import vtkmodules.vtkRenderingOpenGL2
from vtkmodules.vtkCommonColor import vtkNamedColors
from vtkmodules.vtkCommonCore import (
    vtkMath,
    vtkPoints
)
from vtkmodules.vtkCommonDataModel import (
    vtkCellArray,
    vtkPolyData,
    vtkPolyLine
)
from vtkmodules.vtkFiltersModeling import vtkLinearExtrusionFilter
from vtkmodules.vtkRenderingCore import (
    vtkActor,
    vtkPolyDataMapper,
    vtkProperty,
    vtkRenderWindow,
    vtkRenderWindowInteractor,
    vtkRenderer
)


def main():
    col_mgr = vtkNamedColors()

    angle = 0.0
    r_major = 50
    r_minor = 30
    center_x = 10.0
    center_y = 5.0

    pts = vtkPoints()
    idx = 0
    while angle <= 2.0 * vtkMath.Pi() + (vtkMath.Pi() / 60.0):
        x_val = r_major * math.cos(angle) + center_x
        y_val = r_minor * math.sin(angle) + center_y
        pts.InsertNextPoint(x_val, y_val, 0.0)
        angle += vtkMath.Pi() / 60.0
        idx += 1

    path_line = vtkPolyLine()
    path_line.GetPointIds().SetNumberOfIds(idx)
    for i in range(idx):
        path_line.GetPointIds().SetId(i, i)

    cells = vtkCellArray()
    cells.InsertNextCell(path_line)

    pd = vtkPolyData()
    pd.SetPoints(pts)
    pd.SetLines(cells)

    extrude_filter = vtkLinearExtrusionFilter()
    extrude_filter.SetInputData(pd)
    extrude_filter.SetExtrusionTypeToNormalExtrusion()
    extrude_filter.SetVector(0, 0, 100.0)
    extrude_filter.Update()

    line_mapper = vtkPolyDataMapper()
    line_mapper.SetInputData(pd)

    line_actor = vtkActor()
    line_actor.SetMapper(line_mapper)
    line_actor.GetProperty().SetColor(col_mgr.GetColor3d("Peacock"))

    shape_mapper = vtkPolyDataMapper()
    shape_mapper.SetInputConnection(extrude_filter.GetOutputPort())

    back_face_prop = vtkProperty()
    back_face_prop.SetColor(col_mgr.GetColor3d("Tomato"))

    front_actor = vtkActor()
    front_actor.SetMapper(shape_mapper)
    front_actor.GetProperty().SetColor(col_mgr.GetColor3d("Banana"))
    front_actor.SetBackfaceProperty(back_face_prop)

    ren = vtkRenderer()
    ren.SetBackground(col_mgr.GetColor3d("SlateGray"))
    ren.AddActor(front_actor)
    ren.AddActor(line_actor)

    win = vtkRenderWindow()
    win.SetWindowName("Elliptical Cylinder")
    win.AddRenderer(ren)
    win.SetSize(600, 600)

    iren = vtkRenderWindowInteractor()
    iren.SetRenderWindow(win)

    cam = ren.GetActiveCamera()
    cam.SetPosition(0, 1, 0)
    cam.SetFocalPoint(0, 0, 0)
    cam.SetViewUp(0, 0, 1)
    ren.ResetCamera()

    win.Render()
    iren.Start()


if __name__ == '__main__':
    main()

ParametricCylinderWithVectors.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import math
import argparse
import vtkmodules.vtkInteractionStyle
import vtkmodules.vtkRenderingOpenGL2
from vtkmodules.vtkCommonColor import vtkNamedColors
from vtkmodules.vtkCommonCore import (
    vtkMath,
    vtkMinimalStandardRandomSequence,
    vtkPoints
)
from vtkmodules.vtkCommonDataModel import (
    vtkCellArray,
    vtkPolyData,
    vtkPolyLine
)
from vtkmodules.vtkCommonMath import vtkMatrix4x4
from vtkmodules.vtkCommonTransforms import vtkTransform
from vtkmodules.vtkFiltersCore import vtkTubeFilter
from vtkmodules.vtkFiltersGeneral import vtkTransformPolyDataFilter
from vtkmodules.vtkFiltersModeling import vtkLinearExtrusionFilter
from vtkmodules.vtkFiltersSources import vtkArrowSource
from vtkmodules.vtkRenderingCore import (
    vtkActor,
    vtkPolyDataMapper,
    vtkRenderWindow,
    vtkRenderWindowInteractor,
    vtkRenderer
)


def get_args():
    parser = argparse.ArgumentParser(description='Extruded Ellipse Demo.')
    parser.add_argument('-nx', nargs='?', const=0.0, default=0.0, type=float)
    parser.add_argument('-ny', nargs='?', const=0.0, default=0.0, type=float)
    parser.add_argument('-nz', nargs='?', const=100.0, default=100.0, type=float)
    return parser.parse_args()


def main():
    args = get_args()
    nx, ny, nz = args.nx, args.ny, args.nz
    colors = vtkNamedColors()

    angle = 0.0
    r1, r2 = 50.0, 30.0
    cx, cy = 10.0, 5.0

    points = vtkPoints()
    count = 0
    while angle <= 2.0 * vtkMath.Pi() + (vtkMath.Pi() / 60.0):
        points.InsertNextPoint(r1 * math.cos(angle) + cx,
                               r2 * math.sin(angle) + cy,
                               0.0)
        angle += vtkMath.Pi() / 60.0
        count += 1

    line = vtkPolyLine()
    line.GetPointIds().SetNumberOfIds(count)
    for i in range(count):
        line.GetPointIds().SetId(i, i)

    cells = vtkCellArray()
    cells.InsertNextCell(line)

    polyData = vtkPolyData()
    polyData.SetPoints(points)
    polyData.SetLines(cells)

    ext = vtkLinearExtrusionFilter()
    ext.SetInputData(polyData)
    ext.SetExtrusionTypeToNormalExtrusion()
    ext.SetVector(nx, ny, nz)
    ext.Update()

    start_vec = [cx, cy, 0.0]
    end_vec = [start_vec[i] + ext.GetVector()[i] for i in range(3)]

    norm_x = [0.0] * 3
    norm_y = [0.0] * 3
    norm_z = [0.0] * 3

    vtkMath.Subtract(end_vec, start_vec, norm_x)
    length = vtkMath.Norm(norm_x)
    vtkMath.Normalize(norm_x)

    rng = vtkMinimalStandardRandomSequence()
    rng.SetSeed(8775070)
    max_r = 10.0
    arbitrary = [rng.GetRangeValue(-max_r, max_r) for _ in range(3)]
    vtkMath.Cross(norm_x, arbitrary, norm_z)
    vtkMath.Normalize(norm_z)
    vtkMath.Cross(norm_z, norm_x, norm_y)

    mat = vtkMatrix4x4()
    mat.Identity()
    for i in range(3):
        mat.SetElement(i, 0, norm_x[i])
        mat.SetElement(i, 1, norm_y[i])
        mat.SetElement(i, 2, norm_z[i])

    tr = vtkTransform()
    tr.Translate(start_vec)
    tr.Concatenate(mat)
    tr.Scale(length, length, length)

    arrow_src = vtkArrowSource()
    arrow_src.SetTipResolution(31)
    arrow_src.SetShaftResolution(21)

    t_pf = vtkTransformPolyDataFilter()
    t_pf.SetTransform(tr)
    t_pf.SetInputConnection(arrow_src.GetOutputPort())

    arrow_map = vtkPolyDataMapper()
    arrow_map.SetInputConnection(t_pf.GetOutputPort())

    arrow_act = vtkActor()
    arrow_act.SetMapper(arrow_map)
    arrow_act.GetProperty().SetColor(colors.GetColor3d("Tomato"))

    tube = vtkTubeFilter()
    tube.SetInputData(polyData)
    tube.SetRadius(2.0)
    tube.SetNumberOfSides(21)

    edge_map = vtkPolyDataMapper()
    edge_map.SetInputConnection(tube.GetOutputPort())

    edge_act = vtkActor()
    edge_act.SetMapper(edge_map)
    edge_act.GetProperty().SetColor(colors.GetColor3d("Peacock"))

    obj_map = vtkPolyDataMapper()
    obj_map.SetInputConnection(ext.GetOutputPort())

    main_obj = vtkActor()
    main_obj.SetMapper(obj_map)
    main_obj.GetProperty().SetColor(colors.GetColor3d("Banana"))
    main_obj.GetProperty().SetOpacity(.7)

    ren = vtkRenderer()
    ren.SetBackground(colors.GetColor3d("SlateGray"))
    ren.AddActor(main_obj)
    ren.AddActor(edge_act)
    ren.AddActor(arrow_act)

    win = vtkRenderWindow()
    win.SetWindowName("Parametric Cylinder")
    win.AddRenderer(ren)
    win.SetSize(600, 600)

    iren = vtkRenderWindowInteractor()
    iren.SetRenderWindow(win)

    camera = vtkCamera()
    camera.SetPosition(0, 1, 0)
    camera.SetFocalPoint(0, 0, 0)
    camera.SetViewUp(0, 0, 1)
    ren.SetActiveCamera(camera)
    ren.ResetCamera()

    win.Render()
    iren.Start()


if __name__ == '__main__':
    main()

4. Grid Layout Display Management

Organiznig multiple viewports within a single render window.

MultiObjectGridDemo.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import vtkmodules.vtkInteractionStyle
import vtkmodules.vtkRenderingFreeType
import vtkmodules.vtkRenderingOpenGL2
from vtkmodules.vtkCommonColor import vtkNamedColors
from vtkmodules.vtkFiltersSources import (
    vtkArrowSource,
    vtkConeSource,
    vtkCubeSource,
    vtkCylinderSource,
    vtkDiskSource,
    vtkLineSource,
    vtkRegularPolygonSource,
    vtkSphereSource
)
from vtkmodules.vtkRenderingCore import (
    vtkActor,
    vtkActor2D,
    vtkPolyDataMapper,
    vtkRenderWindow,
    vtkRenderWindowInteractor,
    vtkRenderer,
    vtkTextMapper,
    vtkTextProperty
)


def main():
    colors = vtkNamedColors()
    colors.SetColor("BkgColor", [51, 77, 102, 255])

    sources_list = []
    sources_list.append(vtkArrowSource())
    sources_list.append(vtkConeSource())
    sources_list.append(vtkCubeSource())
    sources_list.append(vtkCylinderSource())
    sources_list.append(vtkDiskSource())
    sources_list.append(vtkLineSource())
    sources_list.append(vtkRegularPolygonSource())
    sources_list.append(vtkSphereSource())

    mappers_list = []
    actors_list = []
    text_mappers_list = []
    text_actors_list = []

    txt_prop = vtkTextProperty()
    txt_prop.SetFontSize(16)
    txt_prop.SetJustificationToCentered()
    txt_prop.SetColor(colors.GetColor3d('LightGoldenrodYellow'))

    for src_idx in range(len(sources_list)):
        sources_list[src_idx].Update()

        tmp_map = vtkPolyDataMapper()
        tmp_map.SetInputConnection(sources_list[src_idx].GetOutputPort())
        mappers_list.append(tmp_map)

        tmp_act = vtkActor()
        tmp_act.SetMapper(tmp_map)
        tmp_act.GetProperty().SetColor(colors.GetColor3d('PeachPuff'))
        actors_list.append(tmp_act)

        txt_map = vtkTextMapper()
        txt_map.SetInput(sources_list[src_idx].GetClassName())
        txt_map.SetTextProperty(txt_prop)
        text_mappers_list.append(txt_map)

        txt_act = vtkActor2D()
        txt_act.SetMapper(txt_map)
        txt_act.SetPosition(120, 16)
        text_actors_list.append(txt_act)

    grid_c = 3
    grid_r = 3
    unit_size = 300

    window = vtkRenderWindow()
    window.SetWindowName('Geometry Grid')
    window.SetSize(unit_size * grid_c, unit_size * grid_r)

    for row in range(grid_r):
        for col in range(grid_c):
            idx = row * grid_c + col
            ren = vtkRenderer()
            ren.SetBackground(colors.GetColor3d('BkgColor'))

            vp_x = float(col) / grid_c
            vp_y = float(grid_r - row - 1) / grid_r
            vp_w = float(col + 1) / grid_c
            vp_h = float(grid_r - row) / grid_r
            ren.SetViewport(vp_x, vp_y, vp_w, vp_h)

            if idx < len(actors_list):
                ren.AddActor(actors_list[idx])
                ren.AddActor(text_actors_list[idx])
                ren.ResetCameraClippingRange()

            window.AddRenderer(ren)

    interactor = vtkRenderWindowInteractor()
    interactor.SetRenderWindow(window)

    window.Render()
    interactor.Start()


if __name__ == '__main__':
    main()

BoundingPlanesAnalysis.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import vtkmodules.vtkInteractionStyle
import vtkmodules.vtkRenderingFreeType
import vtkmodules.vtkRenderingOpenGL2
from vtkmodules.vtkCommonColor import vtkNamedColors
from vtkmodules.vtkCommonDataModel import (
    vtkPlanes,
    vtkPolyData
)
from vtkmodules.vtkFiltersCore import vtkHull
from vtkmodules.vtkFiltersSources import vtkSphereSource
from vtkmodules.vtkRenderingCore import (
    vtkActor,
    vtkActor2D,
    vtkPolyDataMapper,
    vtkRenderWindow,
    vtkRenderWindowInteractor,
    vtkRenderer,
    vtkTextMapper,
    vtkTextProperty
)


def main():
    colors = vtkNamedColors()
    labels = []
    plane_sets = []

    # Method 1: Camera Frustum Extraction
    labels.append('Frustum Based')
    cam = vtkCamera()
    planes_array = [0] * 24
    cam.GetFrustumPlanes(1, planes_array)
    p_set = vtkPlanes()
    p_set.SetFrustumPlanes(planes_array)
    plane_sets.append(p_set)

    # Method 2: Axis Aligned Bounds
    labels.append('Bounds Based')
    sph_src = vtkSphereSource()
    sph_src.Update()
    bounds_vals = [0] * 6
    sph_src.GetOutput().GetBounds(bounds_vals)
    p_set2 = vtkPlanes()
    p_set2.SetBounds(bounds_vals)
    plane_sets.append(p_set2)

    txt_style = vtkTextProperty()
    txt_style.SetFontSize(16)
    txt_style.SetJustificationToCentered()

    rw = vtkRenderWindow()
    rw.SetSize(600, 600)
    rw.SetWindowName('Plane Analysis')
    interact = vtkRenderWindowInteractor()
    interact.SetRenderWindow(rw)

    hulls = []
    polys = []
    maps = []
    acts = []
    renws = []
    txt_maps = []
    txt_acts = []

    for i in range(len(plane_sets)):
        hull = vtkHull()
        hull.SetPlanes(plane_sets[i])
        hulls.append(hull)

        out_pd = vtkPolyData()
        hull.GenerateHull(out_pd, -200, 200, -200, 200, -200, 200)
        polys.append(out_pd)

        map_inst = vtkPolyDataMapper()
        map_inst.SetInputData(polys[i])
        maps.append(map_inst)

        act = vtkActor()
        act.SetMapper(maps[i])
        act.GetProperty().SetColor(colors.GetColor3d('Moccasin'))
        act.GetProperty().SetSpecular(0.8)
        act.GetProperty().SetSpecularPower(30)
        acts.append(act)

        rens = vtkRenderer()
        rens.AddActor(acts[i])
        renws.append(rens)

        txt_m = vtkTextMapper()
        txt_m.SetInput(labels[i])
        txt_m.SetTextProperty(txt_style)
        txt_maps.append(txt_m)

        txt_a = vtkActor2D()
        txt_a.SetMapper(txt_m)
        txt_a.SetPosition(100, 10)
        txt_a.GetPosition()
        renws[i].AddViewProp(txt_a)

        rw.AddRenderer(rens)

    dim_x = 2
    dim_y = 1
    size = 300
    rw.SetSize(size * dim_x, size * dim_y)

    for r in range(dim_y):
        for c in range(dim_x):
            idx = r * dim_x + c
            vp = [
                float(c) / dim_x,
                float(dim_y - (r + 1)) / dim_y,
                float(c + 1) / dim_x,
                float(dim_y - r) / dim_y
            ]

            if idx >= len(acts):
                blank = vtkRenderer()
                blank.SetBackground(colors.GetColor3d('DarkSlateGray'))
                blank.SetViewport(*vp)
                rw.AddRenderer(blank)
                continue

            renws[idx].SetViewport(*vp)
            renws[idx].SetBackground(colors.GetColor3d('DarkSlateGray'))
            renws[idx].ResetCamera()
            renws[idx].GetActiveCamera().Azimuth(30)
            renws[idx].GetActiveCamera().Elevation(-30)
            renws[idx].ResetCameraClippingRange()

    interact.Initialize()
    rw.Render()
    interact.Start()


if __name__ == '__main__':
    main()

StandardSourceCatalog.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import vtkmodules.vtkInteractionStyle
import vtkmodules.vtkRenderingFreeType
import vtkmodules.vtkRenderingOpenGL2
from vtkmodules.vtkCommonColor import vtkNamedColors
from vtkmodules.vtkFiltersSources import (
    vtkConeSource,
    vtkCubeSource,
    vtkCylinderSource,
    vtkDiskSource,
    vtkLineSource,
    vtkPlaneSource,
    vtkPointSource,
    vtkSphereSource,
    vtkTextSource
)
from vtkmodules.vtkRenderingCore import (
    vtkActor,
    vtkActor2D,
    vtkPolyDataMapper,
    vtkProperty,
    vtkRenderWindow,
    vtkRenderWindowInteractor,
    vtkRenderer,
    vtkTextMapper,
    vtkTextProperty
)


def main():
    colors = vtkNamedColors()
    colors.SetColor('BkgColor', [51, 77, 102, 255])

    source_pool = list()

    src_sphere = vtkSphereSource()
    src_sphere.SetPhiResolution(21)
    src_sphere.SetThetaResolution(21)
    source_pool.append(src_sphere)

    src_cone = vtkConeSource()
    src_cone.SetResolution(51)
    source_pool.append(src_cone)

    src_cyl = vtkCylinderSource()
    src_cyl.SetResolution(51)
    source_pool.append(src_cyl)

    source_pool.append(vtkCubeSource())
    source_pool.append(vtkPlaneSource())
    source_pool.append(vtkTextSource())
    source_pool[-1].SetText('Hello')
    source_pool[-1].BackingOff()

    src_pts = vtkPointSource()
    src_pts.SetNumberOfPoints(500)
    source_pool.append(src_pts)

    src_disk = vtkDiskSource()
    src_disk.SetCircumferentialResolution(51)
    source_pool.append(src_disk)

    source_pool.append(vtkLineSource())

    renders = []
    mappings = []
    actors_obj = []
    txt_maps = []
    txt_actors = []

    style_text = vtkTextProperty()
    style_text.SetFontSize(16)
    style_text.SetJustificationToCentered()
    style_text.SetColor(colors.GetColor3d('LightGoldenrodYellow'))

    back_prop = vtkProperty()
    back_prop.SetColor(colors.GetColor3d('Tomato'))

    for idx in range(len(source_pool)):
        tmp_map = vtkPolyDataMapper()
        tmp_map.SetInputConnection(source_pool[idx].GetOutputPort())
        mappings.append(tmp_map)

        obj_act = vtkActor()
        obj_act.SetMapper(tmp_map)
        obj_act.GetProperty().SetColor(colors.GetColor3d('PeachPuff'))
        obj_act.SetBackfaceProperty(back_prop)
        actors_obj.append(obj_act)

        txt_m = vtkTextMapper()
        txt_m.SetInput(source_pool[idx].GetClassName())
        txt_m.SetTextProperty(style_text)
        txt_maps.append(txt_m)

        txt_act = vtkActor2D()
        txt_act.SetMapper(txt_m)
        txt_act.SetPosition(120, 16)
        txt_actors.append(txt_act)

        new_ren = vtkRenderer()
        renders.append(new_ren)

    limit = int(len(source_pool))
    dims_sq = 3 * 3
    for k in range(limit, dims_sq):
        renders.append(vtkRenderer())

    rw = vtkRenderWindow()
    rw.SetWindowName('Sources Catalog')
    size = 300
    rw.SetSize(size * 3, size * 3)

    for r in range(3):
        for c in range(3):
            idx = r * 3 + c
            x_min = float(c) / 3
            y_min = float(3 - r - 1) / 3
            x_max = float(c + 1) / 3
            y_max = float(3 - r) / 3
            rw.AddRenderer(renders[idx])
            renders[idx].SetViewport(x_min, y_min, x_max, y_max)

            if idx >= len(source_pool):
                continue

            renders[idx].AddActor(actors_obj[idx])
            renders[idx].AddActor(txt_actors[idx])
            renders[idx].SetBackground(colors.GetColor3d('BkgColor'))
            renders[idx].ResetCamera()
            renders[idx].GetActiveCamera().Azimuth(30)
            renders[idx].GetActiveCamera().Elevation(30)
            renders[idx].GetActiveCamera().Zoom(0.8)
            renders[idx].ResetCameraClippingRange()

    interactor = vtkRenderWindowInteractor()
    interactor.SetRenderWindow(rw)

    rw.Render()
    interactor.Start()


if __name__ == '__main__':
    main()