Skip to content


# OfficeTube

VTKEx/Python/VisualizationAlgorithms/OfficeTube

Other languages

See (Cxx)

Question

If you have a simple question about this example contact us at VTKExProject If your question is more complex and may require extended discussion, please use the VTK Discourse Forum

### Code

OfficeTube.py

    #!/usr/bin/env python

    import vtk
    from vtk.vtkCommonDataModel import vtkDataObject

    def main():
        fileName = get_program_parameters()

        colors = vtk.vtkNamedColors()
        # Set the furniture colors, matching those in the VTKTextBook.
        tableTopColor = [0.59, 0.427, 0.392]
        filingCabinetColor = [0.8, 0.8, 0.6]
        bookShelfColor = [0.8, 0.8, 0.6]
        windowColor = [0.3, 0.3, 0.5]
        colors.SetColor("TableTop", *tableTopColor)
        colors.SetColor("FilingCabinet", *filingCabinetColor)
        colors.SetColor("BookShelf", *bookShelfColor)
        colors.SetColor("WindowColor", *windowColor)

        # We read a data file that represents a CFD analysis of airflow in an office
        # (with ventilation and a burning cigarette). We force an update so that we
        # can query the output for its length, i.e., the length of the diagonal
        # of the bounding box. This is useful for normalizing the data.
        reader = vtk.vtkDataSetReader()
        reader.SetFileName(fileName)
        reader.Update()

        # Now we will generate a single streamline in the data. We select the
        # integration order to use (RungeKutta order 4) and associate it with
        # the streamer. The start position is the position in world space where
        # we want to begin streamline integration; and we integrate in both
        # directions. The step length is the length of the line segments that
        # make up the streamline (i.e., related to display). The
        # IntegrationStepLength specifies the integration step length as a
        # fraction of the cell size that the streamline is in.
        integ = vtk.vtkRungeKutta4()

        streamer = vtk.vtkStreamTracer()
        streamer.SetInputConnection(reader.GetOutputPort())
        streamer.SetStartPosition(0.1, 2.1, 0.5)
        streamer.SetMaximumPropagation(500)
        streamer.SetInitialIntegrationStep(0.05)
        streamer.SetIntegrationDirectionToBoth()
        streamer.SetIntegrator(integ)

        # The tube is wrapped around the generated streamline. By varying the radius
        # by the inverse of vector magnitude, we are creating a tube whose radius is
        # proportional to mass flux (in incompressible flow).
        streamTube = vtk.vtkTubeFilter()
        streamTube.SetInputConnection(streamer.GetOutputPort())
        streamTube.SetInputArrayToProcess(1, 0, 0, vtkDataObject.FIELD_ASSOCIATION_POINTS, "vectors")
        streamTube.SetRadius(0.02)
        streamTube.SetNumberOfSides(12)
        streamTube.SetVaryRadiusToVaryRadiusByVector()

        mapStreamTube = vtk.vtkPolyDataMapper()
        mapStreamTube.SetInputConnection(streamTube.GetOutputPort())
        mapStreamTube.SetScalarRange(reader.GetOutput().GetPointData().GetScalars().GetRange())

        streamTubeActor = vtk.vtkActor()
        streamTubeActor.SetMapper(mapStreamTube)
        streamTubeActor.GetProperty().BackfaceCullingOn()

        # Create the scene.
        # We generate a whole bunch of planes which correspond to
        # the geometry in the analysis; tables, bookshelves and so on.
        table1 = vtk.vtkStructuredGridGeometryFilter()
        table1.SetInputData(reader.GetStructuredGridOutput())
        table1.SetExtent(11, 15, 7, 9, 8, 8)
        mapTable1 = vtk.vtkPolyDataMapper()
        mapTable1.SetInputConnection(table1.GetOutputPort())
        mapTable1.ScalarVisibilityOff()
        table1Actor = vtk.vtkActor()
        table1Actor.SetMapper(mapTable1)
        table1Actor.GetProperty().SetColor(colors.GetColor3d("TableTop"))

        table2 = vtk.vtkStructuredGridGeometryFilter()
        table2.SetInputData(reader.GetStructuredGridOutput())
        table2.SetExtent(11, 15, 10, 12, 8, 8)
        mapTable2 = vtk.vtkPolyDataMapper()
        mapTable2.SetInputConnection(table2.GetOutputPort())
        mapTable2.ScalarVisibilityOff()
        table2Actor = vtk.vtkActor()
        table2Actor.SetMapper(mapTable2)
        table2Actor.GetProperty().SetColor(colors.GetColor3d("TableTop"))

        FilingCabinet1 = vtk.vtkStructuredGridGeometryFilter()
        FilingCabinet1.SetInputData(reader.GetStructuredGridOutput())
        FilingCabinet1.SetExtent(15, 15, 7, 9, 0, 8)
        mapFilingCabinet1 = vtk.vtkPolyDataMapper()
        mapFilingCabinet1.SetInputConnection(FilingCabinet1.GetOutputPort())
        mapFilingCabinet1.ScalarVisibilityOff()
        FilingCabinet1Actor = vtk.vtkActor()
        FilingCabinet1Actor.SetMapper(mapFilingCabinet1)
        FilingCabinet1Actor.GetProperty().SetColor(colors.GetColor3d("FilingCabinet"))

        FilingCabinet2 = vtk.vtkStructuredGridGeometryFilter()
        FilingCabinet2.SetInputData(reader.GetStructuredGridOutput())
        FilingCabinet2.SetExtent(15, 15, 10, 12, 0, 8)
        mapFilingCabinet2 = vtk.vtkPolyDataMapper()
        mapFilingCabinet2.SetInputConnection(FilingCabinet2.GetOutputPort())
        mapFilingCabinet2.ScalarVisibilityOff()
        FilingCabinet2Actor = vtk.vtkActor()
        FilingCabinet2Actor.SetMapper(mapFilingCabinet2)
        FilingCabinet2Actor.GetProperty().SetColor(colors.GetColor3d("FilingCabinet"))

        bookshelf1Top = vtk.vtkStructuredGridGeometryFilter()
        bookshelf1Top.SetInputData(reader.GetStructuredGridOutput())
        bookshelf1Top.SetExtent(13, 13, 0, 4, 0, 11)
        mapBookshelf1Top = vtk.vtkPolyDataMapper()
        mapBookshelf1Top.SetInputConnection(bookshelf1Top.GetOutputPort())
        mapBookshelf1Top.ScalarVisibilityOff()
        bookshelf1TopActor = vtk.vtkActor()
        bookshelf1TopActor.SetMapper(mapBookshelf1Top)
        bookshelf1TopActor.GetProperty().SetColor(colors.GetColor3d("BookShelf"))

        bookshelf1Bottom = vtk.vtkStructuredGridGeometryFilter()
        bookshelf1Bottom.SetInputData(reader.GetStructuredGridOutput())
        bookshelf1Bottom.SetExtent(20, 20, 0, 4, 0, 11)
        mapBookshelf1Bottom = vtk.vtkPolyDataMapper()
        mapBookshelf1Bottom.SetInputConnection(bookshelf1Bottom.GetOutputPort())
        mapBookshelf1Bottom.ScalarVisibilityOff()
        bookshelf1BottomActor = vtk.vtkActor()
        bookshelf1BottomActor.SetMapper(mapBookshelf1Bottom)
        bookshelf1BottomActor.GetProperty().SetColor(colors.GetColor3d("BookShelf"))

        bookshelf1Front = vtk.vtkStructuredGridGeometryFilter()
        bookshelf1Front.SetInputData(reader.GetStructuredGridOutput())
        bookshelf1Front.SetExtent(13, 20, 0, 0, 0, 11)
        mapBookshelf1Front = vtk.vtkPolyDataMapper()
        mapBookshelf1Front.SetInputConnection(bookshelf1Front.GetOutputPort())
        mapBookshelf1Front.ScalarVisibilityOff()
        bookshelf1FrontActor = vtk.vtkActor()
        bookshelf1FrontActor.SetMapper(mapBookshelf1Front)
        bookshelf1FrontActor.GetProperty().SetColor(colors.GetColor3d("BookShelf"))

        bookshelf1Back = vtk.vtkStructuredGridGeometryFilter()
        bookshelf1Back.SetInputData(reader.GetStructuredGridOutput())
        bookshelf1Back.SetExtent(13, 20, 4, 4, 0, 11)
        mapBookshelf1Back = vtk.vtkPolyDataMapper()
        mapBookshelf1Back.SetInputConnection(bookshelf1Back.GetOutputPort())
        mapBookshelf1Back.ScalarVisibilityOff()
        bookshelf1BackActor = vtk.vtkActor()
        bookshelf1BackActor.SetMapper(mapBookshelf1Back)
        bookshelf1BackActor.GetProperty().SetColor(colors.GetColor3d("BookShelf"))

        bookshelf1LHS = vtk.vtkStructuredGridGeometryFilter()
        bookshelf1LHS.SetInputData(reader.GetStructuredGridOutput())
        bookshelf1LHS.SetExtent(13, 20, 0, 4, 0, 0)
        mapBookshelf1LHS = vtk.vtkPolyDataMapper()
        mapBookshelf1LHS.SetInputConnection(bookshelf1LHS.GetOutputPort())
        mapBookshelf1LHS.ScalarVisibilityOff()
        bookshelf1LHSActor = vtk.vtkActor()
        bookshelf1LHSActor.SetMapper(mapBookshelf1LHS)
        bookshelf1LHSActor.GetProperty().SetColor(colors.GetColor3d("BookShelf"))

        bookshelf1RHS = vtk.vtkStructuredGridGeometryFilter()
        bookshelf1RHS.SetInputData(reader.GetStructuredGridOutput())
        bookshelf1RHS.SetExtent(13, 20, 0, 4, 11, 11)
        mapBookshelf1RHS = vtk.vtkPolyDataMapper()
        mapBookshelf1RHS.SetInputConnection(bookshelf1RHS.GetOutputPort())
        mapBookshelf1RHS.ScalarVisibilityOff()
        bookshelf1RHSActor = vtk.vtkActor()
        bookshelf1RHSActor.SetMapper(mapBookshelf1RHS)
        bookshelf1RHSActor.GetProperty().SetColor(colors.GetColor3d("BookShelf"))

        bookshelf2Top = vtk.vtkStructuredGridGeometryFilter()
        bookshelf2Top.SetInputData(reader.GetStructuredGridOutput())
        bookshelf2Top.SetExtent(13, 13, 15, 19, 0, 11)
        mapBookshelf2Top = vtk.vtkPolyDataMapper()
        mapBookshelf2Top.SetInputConnection(bookshelf2Top.GetOutputPort())
        mapBookshelf2Top.ScalarVisibilityOff()
        bookshelf2TopActor = vtk.vtkActor()
        bookshelf2TopActor.SetMapper(mapBookshelf2Top)
        bookshelf2TopActor.GetProperty().SetColor(colors.GetColor3d("BookShelf"))

        bookshelf2Bottom = vtk.vtkStructuredGridGeometryFilter()
        bookshelf2Bottom.SetInputData(reader.GetStructuredGridOutput())
        bookshelf2Bottom.SetExtent(20, 20, 15, 19, 0, 11)
        mapBookshelf2Bottom = vtk.vtkPolyDataMapper()
        mapBookshelf2Bottom.SetInputConnection(bookshelf2Bottom.GetOutputPort())
        mapBookshelf2Bottom.ScalarVisibilityOff()
        bookshelf2BottomActor = vtk.vtkActor()
        bookshelf2BottomActor.SetMapper(mapBookshelf2Bottom)
        bookshelf2BottomActor.GetProperty().SetColor(colors.GetColor3d("BookShelf"))

        bookshelf2Front = vtk.vtkStructuredGridGeometryFilter()
        bookshelf2Front.SetInputData(reader.GetStructuredGridOutput())
        bookshelf2Front.SetExtent(13, 20, 15, 15, 0, 11)
        mapBookshelf2Front = vtk.vtkPolyDataMapper()
        mapBookshelf2Front.SetInputConnection(bookshelf2Front.GetOutputPort())
        mapBookshelf2Front.ScalarVisibilityOff()
        bookshelf2FrontActor = vtk.vtkActor()
        bookshelf2FrontActor.SetMapper(mapBookshelf2Front)
        bookshelf2FrontActor.GetProperty().SetColor(colors.GetColor3d("BookShelf"))

        bookshelf2Back = vtk.vtkStructuredGridGeometryFilter()
        bookshelf2Back.SetInputData(reader.GetStructuredGridOutput())
        bookshelf2Back.SetExtent(13, 20, 19, 19, 0, 11)
        mapBookshelf2Back = vtk.vtkPolyDataMapper()
        mapBookshelf2Back.SetInputConnection(bookshelf2Back.GetOutputPort())
        mapBookshelf2Back.ScalarVisibilityOff()
        bookshelf2BackActor = vtk.vtkActor()
        bookshelf2BackActor.SetMapper(mapBookshelf2Back)
        bookshelf2BackActor.GetProperty().SetColor(colors.GetColor3d("BookShelf"))

        bookshelf2LHS = vtk.vtkStructuredGridGeometryFilter()
        bookshelf2LHS.SetInputData(reader.GetStructuredGridOutput())
        bookshelf2LHS.SetExtent(13, 20, 15, 19, 0, 0)
        mapBookshelf2LHS = vtk.vtkPolyDataMapper()
        mapBookshelf2LHS.SetInputConnection(bookshelf2LHS.GetOutputPort())
        mapBookshelf2LHS.ScalarVisibilityOff()
        bookshelf2LHSActor = vtk.vtkActor()
        bookshelf2LHSActor.SetMapper(mapBookshelf2LHS)
        bookshelf2LHSActor.GetProperty().SetColor(colors.GetColor3d("BookShelf"))

        bookshelf2RHS = vtk.vtkStructuredGridGeometryFilter()
        bookshelf2RHS.SetInputData(reader.GetStructuredGridOutput())
        bookshelf2RHS.SetExtent(13, 20, 15, 19, 11, 11)
        mapBookshelf2RHS = vtk.vtkPolyDataMapper()
        mapBookshelf2RHS.SetInputConnection(bookshelf2RHS.GetOutputPort())
        mapBookshelf2RHS.ScalarVisibilityOff()
        bookshelf2RHSActor = vtk.vtkActor()
        bookshelf2RHSActor.SetMapper(mapBookshelf2RHS)
        bookshelf2RHSActor.GetProperty().SetColor(colors.GetColor3d("BookShelf"))

        window = vtk.vtkStructuredGridGeometryFilter()
        window.SetInputData(reader.GetStructuredGridOutput())
        window.SetExtent(20, 20, 6, 13, 10, 13)
        mapWindow = vtk.vtkPolyDataMapper()
        mapWindow.SetInputConnection(window.GetOutputPort())
        mapWindow.ScalarVisibilityOff()
        windowActor = vtk.vtkActor()
        windowActor.SetMapper(mapWindow)
        windowActor.GetProperty().SetColor(colors.GetColor3d("WindowColor"))

        outlet = vtk.vtkStructuredGridGeometryFilter()
        outlet.SetInputData(reader.GetStructuredGridOutput())
        outlet.SetExtent(0, 0, 9, 10, 14, 16)
        mapOutlet = vtk.vtkPolyDataMapper()
        mapOutlet.SetInputConnection(outlet.GetOutputPort())
        mapOutlet.ScalarVisibilityOff()
        outletActor = vtk.vtkActor()
        outletActor.SetMapper(mapOutlet)
        outletActor.GetProperty().SetColor(colors.GetColor3d("lamp_black"))

        inlet = vtk.vtkStructuredGridGeometryFilter()
        inlet.SetInputData(reader.GetStructuredGridOutput())
        inlet.SetExtent(0, 0, 9, 10, 0, 6)
        mapInlet = vtk.vtkPolyDataMapper()
        mapInlet.SetInputConnection(inlet.GetOutputPort())
        mapInlet.ScalarVisibilityOff()
        inletActor = vtk.vtkActor()
        inletActor.SetMapper(mapInlet)
        inletActor.GetProperty().SetColor(colors.GetColor3d("lamp_black"))

        outline = vtk.vtkStructuredGridOutlineFilter()
        outline.SetInputData(reader.GetStructuredGridOutput())
        mapOutline = vtk.vtkPolyDataMapper()
        mapOutline.SetInputConnection(outline.GetOutputPort())
        outlineActor = vtk.vtkActor()
        outlineActor.SetMapper(mapOutline)
        outlineActor.GetProperty().SetColor(colors.GetColor3d("Black"))

        # Create the rendering window, renderer, and interactive renderer.
        ren = vtk.vtkRenderer()
        renWin = vtk.vtkRenderWindow()
        renWin.AddRenderer(ren)
        iren = vtk.vtkRenderWindowInteractor()
        iren.SetRenderWindow(renWin)

        # Add the remaining actors to the renderer, set the background and size.
        ren.AddActor(table1Actor)
        ren.AddActor(table2Actor)
        ren.AddActor(FilingCabinet1Actor)
        ren.AddActor(FilingCabinet2Actor)
        ren.AddActor(bookshelf1TopActor)
        ren.AddActor(bookshelf1BottomActor)
        ren.AddActor(bookshelf1FrontActor)
        ren.AddActor(bookshelf1BackActor)
        ren.AddActor(bookshelf1LHSActor)
        ren.AddActor(bookshelf1RHSActor)
        ren.AddActor(bookshelf2TopActor)
        ren.AddActor(bookshelf2BottomActor)
        ren.AddActor(bookshelf2FrontActor)
        ren.AddActor(bookshelf2BackActor)
        ren.AddActor(bookshelf2LHSActor)
        ren.AddActor(bookshelf2RHSActor)
        ren.AddActor(windowActor)
        ren.AddActor(outletActor)
        ren.AddActor(inletActor)
        ren.AddActor(outlineActor)
        ren.AddActor(streamTubeActor)

        ren.SetBackground(colors.GetColor3d("SlateGray"))

        aCamera = vtk.vtkCamera()
        aCamera.SetClippingRange(0.726079, 36.3039)
        aCamera.SetFocalPoint(2.43584, 2.15046, 1.11104)
        aCamera.SetPosition(-4.76183, -10.4426, 3.17203)
        aCamera.ComputeViewPlaneNormal()
        aCamera.SetViewUp(0.0511273, 0.132773, 0.989827)
        aCamera.SetViewAngle(18.604)
        aCamera.Zoom(1.2)

        ren.SetActiveCamera(aCamera)

        renWin.SetSize(640, 400)
        iren.Initialize()
        iren.Start()

    def get_program_parameters():
        import argparse
        description = 'The stream polygon. Sweeping a polygon to form a tube..'
        epilogue = '''
       '''
        parser = argparse.ArgumentParser(description=description, epilog=epilogue,
                                         formatter_class=argparse.RawDescriptionHelpFormatter)
        parser.add_argument('fileName', help='office.binary.vtk.')
        args = parser.parse_args()
        return args.fileName

    if __name__ == '__main__':
        main()