    colors = vtkNamedColors()

    # The text is on a single line and bottom-justified.
    singleLineTextB = vtkTextMapper()
    singleLineTextB.SetInput('Single line (bottom)')
    tprop = singleLineTextB.GetTextProperty()
--
    colors = vtkNamedColors()

    # Create the axes and the associated mapper and actor.
    axes = vtkAxes()
    axes.SetOrigin(0, 0, 0)
    axesMapper = vtkPolyDataMapper()
--
    colors = vtkNamedColors()

    # Create Sphere 1.
    sphere1 = vtkSphereSource()
    sphere1.SetRadius(3)
    sphere1.SetCenter(0, 0, 0)
--
    colors = vtkNamedColors()

    # PART 1 Make some Data.
    # Make a tree.
    root = vtkMultiBlockDataSet()

--
    colors = vtkNamedColors()

    # Create and populate the AMR dataset
    # The dataset should look like
    # Level 0
    #   uniform grid, dimensions 11, 11, 11, AMR box (0, 0, 0) - (9, 9, 9) 
--
    named_colors = vtkNamedColors()

    # Make a 32 x 32 grid.
    size = 32

    # Define z values for the topography.
--
    colors = vtkNamedColors()
    ifn, index = get_program_parameters()

    # Prepare to read the file.
    reader_volume = vtkMetaImageReader()
    reader_volume.SetFileName(ifn)
--
    colors = vtk.vtkNamedColors()

    colors.SetColor("BkgColor", [26, 51, 102, 255])

    parametricObjects = list()
    parametricObjects.append(vtk.vtkParametricBohemianDome())
--
    colors = vtk.vtkNamedColors()

    colors.SetColor("BkgColor", [26, 51, 102, 255])

    parametricObjects = list()
    parametricObjects.append(vtk.vtkParametricBoy())
--
    colors = vtk.vtkNamedColors()

    colors.SetColor("BkgColor", [26, 51, 102, 255])

    # Uncomment one of the following.
    # parametricObject = vtk.vtkParametricBoy()
--
    colors = vtk.vtkNamedColors()

    g = vtk.vtkMutableDirectedGraph()
    latitude = vtk.vtkDoubleArray()
    latitude.SetName('latitude')
    longitude = vtk.vtkDoubleArray()
--
    colors = vtk.vtkNamedColors()

    geoGraticle = vtk.vtkGeoGraticule()
    transformProjection = vtk.vtkGeoTransform()
    destinationProjection = vtk.vtkGeoProjection()
    sourceProjection = vtk.vtkGeoProjection()
--
    colors = vtkNamedColors()

    actor = vtkActor()
    actor.SetMapper(mapper)
    actor.GetProperty().EdgeVisibilityOn()
    actor.GetProperty().LightingOff()
--
    colors = vtkNamedColors()

    renderer = vtkRenderer()
    renderer.AddActor(actor)
    renderer.SetBackground(colors.GetColor3d('DimGray'))

--
    colors = vtkNamedColors()

    # Create 5 points (vtkPolyData)
    pointSource = vtkPointSource()
    pointSource.SetNumberOfPoints(5)
    pointSource.Update()
--
    colors = vtkNamedColors()

    # Set the background color.
    colors.SetColor('BkgColor', [0.3, 0.2, 0.1, 1.0])

    input1 = vtkPolyData()
--
    colors = vtkNamedColors()

    sphereSource1 = vtkSphereSource()
    sphereSource1.Update()

    delaunay1 = vtkDelaunay3D()
--
    colors = vtkNamedColors()

    # Generate a 10 x 10 grid of points
    points = vtkPoints()
    gridSize = 10
    seed = 0
--
    colors = vtkNamedColors()

    # Create a set of heights on a grid.
    # This is often called a "terrain map".
    points = vtkPoints()

--
    colors = vtkNamedColors()

    polydata = vtkPolyData()
    polydata.SetPoints(sphereSource.GetOutput().GetPoints())

    splatter = vtkGaussianSplatter()
--
    colors = vtkNamedColors()

    points = vtkPoints()
    points.InsertNextPoint(0, 0, 0)
    points.InsertNextPoint(1, 1, 0)
    points.InsertNextPoint(2, 2, 0)
--
    colors = vtkNamedColors()

    points = vtkPoints()
    points.InsertNextPoint(0, 0, 0)
    points.InsertNextPoint(1, 1, 1)
    points.InsertNextPoint(2, 2, 2)
--
    colors = vtkNamedColors()
    perlinNoise = vtkPerlinNoise()
    perlinNoise.SetFrequency(2, 1.25, 1.5)
    perlinNoise.SetPhase(0, 0, 0)

    sample = vtkSampleFunction()
--
    colors = vtkNamedColors()

    # Create the polydata geometry
    sphereSource = vtkSphereSource()
    sphereSource.Update()

--
    colors = vtkNamedColors()
    # Create points on an XY grid with random Z coordinate
    points = vtkPoints()
    gridSize = 10
    seed = 0
    randomSequence = vtkMinimalStandardRandomSequence()
--
    colors = vtkNamedColors()
    points = vtkPoints()
    points.InsertNextPoint(0, 0, 0)
    points.InsertNextPoint(1, 1, 1)
    points.InsertNextPoint(2, 2, 2)

--
    colors = vtkNamedColors()
    # Create the RenderWindow, Renderer and both Actors
    renderer = vtkRenderer()
    renderWindow = vtkRenderWindow()
    renderWindow.AddRenderer(renderer)
    renderWindowInteractor = vtkRenderWindowInteractor()
--
    colors = vtkNamedColors()

    arrowSource = vtkArrowSource()
    # arrowSource.SetShaftRadius(0.01)
    # arrowSource.SetTipLength(.9)

--
    colors = vtkNamedColors()

    # create a Sphere
    sphereSource = vtkSphereSource()
    sphereSource.SetCenter(0.0, 0.0, 0.0)
    sphereSource.SetRadius(0.5)
--
    colors = vtkNamedColors()

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

    titles = list()
--
    colors = vtkNamedColors()

    # Create a mapper and actor.
    mapper = vtkDataSetMapper()
    mapper.SetInputConnection(source.GetOutputPort())
    mapper.SetInputConnection(shrink.GetOutputPort())
--
    colors = vtkNamedColors()

    # Create a circle
    polygonSource = vtkRegularPolygonSource()
    # Comment this line to generate a disk instead of a circle.
    polygonSource.GeneratePolygonOff()
--
    namedColors = vtkNamedColors()

    # Create a vtkUnsignedCharArray container and store the colors in it
    colors = vtkUnsignedCharArray()
    colors.SetNumberOfComponents(3)
    try:
--
    colors = vtkNamedColors()

    coneSource = vtkConeSource()
    # coneSource.SetResolution(60)
    # coneSource.SetCenter(-2,0,0)

--
    colors = vtkNamedColors()

    mapper = vtkDataSetMapper()
    mapper.SetInputData(ug)

    actor = vtkActor()
--
    colors = vtkNamedColors()

    # Create a rendering window and renderer.
    ren = vtkRenderer()
    renWin = vtkRenderWindow()
    renWin.SetWindowName('Cube1')
--
If your VTK version is 5.x then remove the line: colors = vtkNamedColors()
 and replace the set background parameters with (1.0, 0.9688, 0.8594)

"""

# noinspection PyUnresolvedReferences
--
    colors = vtkNamedColors()

    # x = array of 8 3-tuples of float representing the vertices of a cube:
    x = [(0.0, 0.0, 0.0), (1.0, 0.0, 0.0), (1.0, 1.0, 0.0), (0.0, 1.0, 0.0),
         (0.0, 0.0, 1.0), (1.0, 0.0, 1.0), (1.0, 1.0, 1.0), (0.0, 1.0, 1.0)]

--
    colors = vtkNamedColors()
    # Set the background color.
    bkg = map(lambda x: x / 255.0, [26, 51, 102, 255])
    colors.SetColor("BkgColor", *bkg)

    # This creates a polygonal cylinder model with eight circumferential
--
    colors = vtkNamedColors()

    # Create a sphere
    cylinderSource = vtkCylinderSource()
    cylinderSource.SetCenter(0.0, 0.0, 0.0)
    cylinderSource.SetRadius(5.0)
--
    colors = vtkNamedColors()

    diskSource = vtkDiskSource()

    # Create a mapper and actor.
    mapper = vtkPolyDataMapper()
--
    colors = vtkNamedColors()

    dodecahedron = MakeDodecahedron()

    # Visualize
    mapper = vtkPolyDataMapper()
--
    colors = vtkNamedColors()

    # Earth source
    earthSource = vtkEarthSource()
    earthSource.OutlineOn()
    earthSource.Update()
--
    colors = vtkNamedColors()

    angle = 0
    r1 = 50
    r2 = 30
    centerX = 10.0
--
    colors = vtkNamedColors()

    angle = 0
    r1 = 50
    r2 = 30
    centerX = 10.0
--
    colors = vtkNamedColors()

    camera = vtkCamera()
    camera.SetClippingRange(0.1, 0.4)
    planesArray = [0] * 24

--
    colors = vtkNamedColors()

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

    # Create container to hold the 3D object generators (sources)
--
    colors = vtkNamedColors()

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

    # For the hexahedron setup the coordinates of eight points.
--
    colors = vtkNamedColors()

    # Create one sphere for all.
    sphere = vtkSphereSource()
    sphere.SetPhiResolution(21)
    sphere.SetThetaResolution(21)
--
    colors = vtkNamedColors()

    pty = vtkTextProperty()
    pty.BoldOn()
    pty.SetJustificationToCentered()
    pty.SetColor(colors.GetColor3d('Black'))
--
    colors = vtkNamedColors()

    pty = vtkTextProperty()
    pty.BoldOn()
    pty.ShadowOn()
    pty.SetJustificationToCentered()
--
    colors = vtkNamedColors()

    pty = vtkProperty()
    pty.SetAmbientColor(colors.GetColor3d('LightSalmon'))
    pty.SetDiffuseColor(colors.GetColor3d('OrangeRed'))
    pty.SetSpecularColor(colors.GetColor3d('White'))
--
    colors = vtkNamedColors()

    pty = vtkProperty()
    pty.SetAmbientColor(colors.GetColor3d('DarkSalmon'))
    pty.SetDiffuseColor(colors.GetColor3d('Seashell'))
    pty.SetSpecularColor(colors.GetColor3d('White'))
--
    colors = vtkNamedColors()

    pty = vtkProperty()
    pty.SetAmbientColor(colors.GetColor3d('Gold'))
    pty.SetDiffuseColor(colors.GetColor3d('Yellow'))
    pty.SetSpecularColor(colors.GetColor3d('White'))
--
    colors = vtkNamedColors()

    pty = vtkProperty()
    pty.SetAmbientColor(colors.GetColor3d('SteelBlue'))
    pty.SetDiffuseColor(colors.GetColor3d('LightSteelBlue'))
    pty.SetSpecularColor(colors.GetColor3d('White'))
--
    colors = vtkNamedColors()

    # Create one sphere for all.
    sphere = vtkSphereSource()
    sphere.SetPhiResolution(21)
    sphere.SetThetaResolution(21)
--
    colors = vtkNamedColors()

    pty = vtkTextProperty()
    pty.BoldOn()
    pty.SetJustificationToCentered()
    pty.SetColor(colors.GetColor3d('Black'))
--
    colors = vtkNamedColors()

    pty = vtkTextProperty()
    pty.BoldOn()
    pty.ShadowOn()
    pty.SetJustificationToCentered()
--
    colors = vtkNamedColors()

    pty = vtkProperty()
    pty.SetAmbientColor(colors.GetColor3d('LightSalmon'))
    pty.SetDiffuseColor(colors.GetColor3d('OrangeRed'))
    pty.SetSpecularColor(colors.GetColor3d('White'))
--
    colors = vtkNamedColors()

    pty = vtkProperty()
    pty.SetAmbientColor(colors.GetColor3d('DarkSalmon'))
    pty.SetDiffuseColor(colors.GetColor3d('Seashell'))
    pty.SetSpecularColor(colors.GetColor3d('White'))
--
    colors = vtkNamedColors()

    pty = vtkProperty()
    pty.SetAmbientColor(colors.GetColor3d('Gold'))
    pty.SetDiffuseColor(colors.GetColor3d('Yellow'))
    pty.SetSpecularColor(colors.GetColor3d('White'))
--
    colors = vtkNamedColors()

    pty = vtkProperty()
    pty.SetAmbientColor(colors.GetColor3d('SteelBlue'))
    pty.SetDiffuseColor(colors.GetColor3d('LightSteelBlue'))
    pty.SetSpecularColor(colors.GetColor3d('White'))
--
    colors = vtkNamedColors()

    mapper = vtkPolyDataMapper()
    mapper.SetInputConnection(lineSource.GetOutputPort())
    actor = vtkActor()
    actor.SetMapper(mapper)
--
    colors = vtkNamedColors()

    mapper = vtkPolyDataMapper()
    mapper.SetInputData(linesPolyData)

    actor = vtkActor()
--
    colors = vtkNamedColors()

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

    # Create an arrow.
--
    colors = vtkNamedColors()

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

    # Create a cylinder.
--
    colors = vtkNamedColors()

    colors.SetColor('BkgColor', [26, 51, 102, 255])

    surface = vtkParametricKuen()
    source = vtkParametricFunctionSource()
--
    colors = vtkNamedColors()

    # Create one text property for all.
    text_property = vtkTextProperty()
    text_property.SetJustificationToCentered()
    text_property.SetFontSize(int(renderer_size / 12))
--
    colors = vtkNamedColors()

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

    surface = vtkParametricSuperEllipsoid()
--
    colors = vtkNamedColors()

    colors.SetColor('BkgColor', [26, 51, 102, 255])

    surface = vtkParametricSuperToroid()
    source = vtkParametricFunctionSource()
--
    colors = vtkNamedColors()

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

    # Create a plane
--
    colors = vtkNamedColors()

    planes = list()
    titles = list()

    # Using frustum planes.
--
    colors = vtkNamedColors()

    mappers = list()
    actors = list()
    text_mappers = list()
    text_actors = list()
--
    colors = vtkNamedColors()

    # Create the geometry of a point (the coordinate)
    points = vtkPoints()
    p = [1.0, 2.0, 3.0]

--
    colors = vtkNamedColors()

    # Setup four points
    points = vtkPoints()
    points.InsertNextPoint(0.0, 0.0, 0.0)
    points.InsertNextPoint(1.0, 0.0, 0.0)
--
    colors = vtkNamedColors()

    # create polyhedron (cube)
    # The point Ids are: [0, 1, 2, 3, 4, 5, 6, 7]

    points = vtkPoints()
--
    colors = vtkNamedColors()

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

    # vtkPoints represents 3D points. The data model for vtkPoints is an array of
--
    colors = vtkNamedColors()

    # Create five points.
    origin = [0.0, 0.0, 0.0]
    p0 = [1.0, 0.0, 0.0]
    p1 = [0.0, 1.0, 0.0]
--
    colors = vtkNamedColors()

    points = vtkPoints()

    p0 = [1.0, 1.0, 1.0]
    p1 = [-1.0, 1.0, 1.0]
--
    colors = vtkNamedColors()

    # Create four points (must be in counter clockwise order)
    p0 = [0.0, 0.0, 0.0]
    p1 = [1.0, 0.0, 0.0]
    p2 = [1.0, 1.0, 0.0]
--
    namedColors = vtkNamedColors()

    uGrid = MakeQuadraticHexahedron()

    tessellate = vtkTessellatorFilter()
    tessellate.SetInputData(uGrid)
--
    namedColors = vtkNamedColors()

    uGrid = MakeQuadraticHexahedron()

    tessellate = vtkTessellatorFilter()
    tessellate.SetInputData(uGrid)
--
    namedColors = vtkNamedColors()

    uGrid = MakeQuadraticTetra()

    tessellate = vtkTessellatorFilter()
    tessellate.SetInputData(uGrid)
--
    namedColors = vtkNamedColors()

    uGrid = MakeQuadraticTetra()

    tessellate = vtkTessellatorFilter()
    tessellate.SetInputData(uGrid)
--
    colors = vtkNamedColors()

    # Create a pentagon
    polygonSource = vtkRegularPolygonSource()
    polygonSource.SetNumberOfSides(5)
    polygonSource.SetRadius(5)
--
    colors = vtkNamedColors()

    # Create a cube.
    cubeSource = vtkCubeSource()

    shrink = vtkShrinkFilter()
--
    colors = vtkNamedColors()

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

    sourceObjects = list()
--
    colors = vtkNamedColors()

    # Create a sphere
    sphereSource = vtkSphereSource()
    sphereSource.SetCenter(0.0, 0.0, 0.0)
    sphereSource.SetRadius(5.0)
--
    colors = vtkNamedColors()

    bounds = [-10.0, 10.0, 10.0, 20.0, -5.0, 5.0]

    boxSource = vtkTessellatedBoxSource()
    boxSource.SetLevel(3)
--
    colors = vtkNamedColors()

    points = vtkPoints()
    points.InsertNextPoint(0, 0, 0)
    points.InsertNextPoint(1, 0, 0)
    points.InsertNextPoint(1, 1, 0)
--
    colors = vtkNamedColors()

    # Create a rendering window and renderer.
    ren = vtkRenderer()
    renWin = vtkRenderWindow()
    renWin.SetWindowName('TextActor')
--
    colors = vtkNamedColors()

    # Create a triangle
    points = vtkPoints()
    points.InsertNextPoint(1.0, 0.0, 0.0)
    points.InsertNextPoint(0.0, 0.0, 0.0)
--
    colors = vtkNamedColors()

    points = vtkPoints()
    points.InsertNextPoint(0, 0, 0)
    points.InsertNextPoint(0, 1, 0)
    points.InsertNextPoint(1, 0, 0)
--
    colors = vtkNamedColors()

    points = vtkPoints()
    points.InsertNextPoint(0, 0, 0)

    vertex = vtkVertex()
--
    colors = vtkNamedColors()

    graph = vtkMutableDirectedGraph()
    # Create a graph
    v1 = graph.AddVertex()
    v2 = graph.AddVertex()
--
    colors = vtkNamedColors()

    # Create a graph
    graph = vtkMutableDirectedGraph()

    v1 = graph.AddVertex()
--
    colors = vtkNamedColors()

    # Create a graph
    graph = vtkMutableDirectedGraph()

    v1 = graph.AddVertex()
--
    colors = vtkNamedColors()

    g = vtkMutableUndirectedGraph()

    v1 = g.AddVertex()
    v2 = g.AddVertex()
--
    colors = vtkNamedColors()

    g = vtkMutableDirectedGraph()

    # Create 3 vertices
    v1 = g.AddVertex()
--
    colors = vtkNamedColors()
    # Create a graph
    g = vtkMutableUndirectedGraph()

    # Add 4 vertices to the graph
    v1 = g.AddVertex()
--
    colors = vtkNamedColors()

    g = vtkMutableUndirectedGraph()

    # Create 3 vertices
    v1 = g.AddVertex()
--
    colors = vtkNamedColors()

    random_graph_source = vtkRandomGraphSource()
    random_graph_source.SetNumberOfVertices(5)
    random_graph_source.SetNumberOfEdges(4)
    # This ensures repeatable results for testing. Turn this off for real use.
--
    colors = vtkNamedColors()

    g = vtkMutableUndirectedGraph()

    v1 = g.AddVertex()
    v2 = g.AddVertex()
--
    colors = vtkNamedColors()

    # Create the first graph
    g0 = vtkMutableUndirectedGraph()

    v1 = g0.AddVertex()
--
    colors = vtkNamedColors()
    # Create hyper tree grid source

    descriptor = 'RRR .R. .RR ..R ..R .R.|R.......................... ' \
                 '........................... ........................... ' \
                 '.............R............. ....RR.RR........R......... ' \
--
    colors = vtkNamedColors()

    # Create an image
    source1 = vtkImageCanvasSource2D()
    source1.SetScalarTypeToUnsignedChar()
    source1.SetNumberOfScalarComponents(3)
--
    colors = vtkNamedColors()

    # Create an image
    source = vtkImageSinusoidSource()
    source.Update()

--
    colors = vtkNamedColors()

    # Create image 1
    source1 = vtkImageMandelbrotSource()
    source1.SetWholeExtent(0, 255, 0, 255, 0, 0)
    source1.Update()
--
    colors = vtkNamedColors()

    filename = get_program_parameters()

    imageData = vtkImageData()
    imageData.SetDimensions(3, 4, 5)
--
    colors = vtkNamedColors()

    fileName = get_program_parameters()

    # Read the image.
    readerFactory = vtkImageReader2Factory()
--
    # colors = vtkNamedColors()

    fileName = get_program_parameters()

    # Read the image.
    readerFactory = vtkImageReader2Factory()
--
    colors = vtkNamedColors()

    fileName = get_program_parameters()

    # Read the image.
    readerFactory = vtkImageReader2Factory()
--
    # colors = vtkNamedColors()

    fileName = get_program_parameters()

    # Read the image.
    readerFactory = vtkImageReader2Factory()
--
    colors = vtkNamedColors()

    fileName = get_program_parameters()

    # Read the image.
    readerFactory = vtkImageReader2Factory()
--
    colors = vtkNamedColors()

    file_name = get_program_parameters()

    # Read the image.
    reader_factory = vtkImageReader2Factory()
--
    # colors = vtkNamedColors()

    fileName = get_program_parameters()

    # Read the image.
    readerFactory = vtkImageReader2Factory()
--
    # colors = vtkNamedColors()

    fileName = get_program_parameters()

    # Read the image.
    readerFactory = vtkImageReader2Factory()
--
    colors = vtkNamedColors()

    fileName = get_program_parameters()

    # Read the image.
    readerFactory = vtkImageReader2Factory()
--
    colors = vtkNamedColors()

    fileName = get_program_parameters()

    # Read the image.
    readerFactory = vtkImageReader2Factory()
--
    colors = vtkNamedColors()
    points = vtkPoints()
    points.InsertNextPoint(10, 10, 0)
    points.InsertNextPoint(100, 100, 0)
    points.InsertNextPoint(200, 200, 0)

--
    colors = vtkNamedColors()

    #  Verify input arguments
    fn = get_program_parameters()
    if fn:
        # Read the image
--
    colors = vtkNamedColors()

    # Create a float image
    source = vtkImageMandelbrotSource()
    source.Update()

--
    colors = vtkNamedColors()

    # Set the background color.
    colors.SetColor('BkgColor', [60, 93, 144, 255])

    # Read in an image and compute a luminance value. The image is extracted
--
    colors = vtkNamedColors()

    # create a sphere
    sphere = vtkSphere()
    sphere.SetRadius(1)
    sphere.SetCenter(1, 0, 0)
--
    colors = vtkNamedColors()

    # create an ellipsoid using a implicit quadric
    quadric = vtkQuadric()
    quadric.SetCoefficients(0.5, 1, 0.2, 0, 0.1, 0, 0, 0.2, 0, 0)

--
    colors = vtkNamedColors()

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

--
    colors = vtkNamedColors()

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

    sphere = vtkSphere()
--
    colors = vtkNamedColors()

    implicitFunction = vtkSuperquadric()
    implicitFunction.SetPhiRoundness(2.5)
    implicitFunction.SetThetaRoundness(.5)

--
    colors = vtkNamedColors()

    # Generate an image data set with multiple attribute arrays to probe and view
    rt = vtkRTAnalyticSource()
    rt.SetWholeExtent(-3, 3, -3, 3, -3, 3)
    grad = vtkImageGradient()
--
    colors = vtkNamedColors()

    # Generate an example image data set with multiple attribute arrays to probe
    # and view.
    # This is where you would put your reader instead of this rt->elev pipeline...
    rt = vtkRTAnalyticSource()
--
    colors = vtkNamedColors()

    source = vtkRandomGraphSource()
    source.DirectedOff()
    source.SetNumberOfVertices(100)
    source.SetEdgeProbability(0)  # Basically generates a tree
--
    colors = vtkNamedColors()

    # Create the Renderer, RenderWindow and RenderWindowInteractor.
    ren = vtkRenderer()
    renWin = vtkRenderWindow()
    renWin.AddRenderer(ren)
--
    colors = vtkNamedColors()

    # create a rendering window and renderer
    ren = vtkRenderer()
    renWin = vtkRenderWindow()
    renWin.AddRenderer(ren)
--
    colors = vtkNamedColors()

    # create a rendering window and renderer
    ren = vtkRenderer()
    renWin = vtkRenderWindow()
    renWin.AddRenderer(ren)
--
    colors = vtkNamedColors()

    source = vtkSphereSource()
    source.SetCenter(0, 0, 0)
    source.SetRadius(1)
    source.Update()
--
    colors = vtkNamedColors()

    source = vtkSphereSource()
    source.SetCenter(0, 0, 0)
    source.SetRadius(1)
    source.Update()
--
    colors = vtkNamedColors()

    renderer = vtkRenderer()
    renWin = vtkRenderWindow()
    iren = vtkRenderWindowInteractor()

--
    colors = vtkNamedColors()
    colors.SetColor("ParaViewBkg", [82, 87, 110, 255])

    lut = get_diverging_lut('cool_warm')
    # lut = get_diverging_lut1('DarkRed', 'Gainsboro', 'Green')

--
    colors = vtkNamedColors()
    # Colour transfer function.
    ctf = vtkColorTransferFunction()
    ctf.SetColorSpaceToDiverging()
    p1 = [0.0] + list(colors.GetColor3d(start))
    p2 = [0.5] + list(colors.GetColor3d(mid))
--
    colors = vtkNamedColors()
    colors.SetColor("ParaViewBkg", [82, 87, 110, 255])

    lut = get_diverging_lut('cool_warm')
    # lut = get_diverging_lut1('DarkRed', 'Gainsboro', 'Green')

--
    colors = vtkNamedColors()
    # Colour transfer function.
    ctf = vtkColorTransferFunction()
    ctf.SetColorSpaceToDiverging()
    p1 = [0.0] + list(colors.GetColor3d(start))
    p2 = [0.5] + list(colors.GetColor3d(mid))
--
    colors = vtkNamedColors()

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

    # create a rendering window and renderer
--
    colors = vtkNamedColors()

    input_filename = get_program_parameters()

    # Read the DICOM file
    reader = vtkDICOMImageReader()
--
    colors = vtkNamedColors()
    reader = vtkDICOMImageReader()
    folder = get_program_parameters()
    # Read DICOM files in the specified directory
    reader.SetDirectoryName(folder)
    reader.Update()
--
    colors = vtkNamedColors()

    # Input file and variable
    filename, nodal_var = get_program_parameters()

    # Read Exodus Data
--
    colors = vtkNamedColors()

    file_name = get_program_parameters()

    # Read the source file.
    reader = vtkXMLImageDataReader()
--
    colors = vtkNamedColors()

    filename = get_program_parameters()

    # Create the reader for the data.
    print('Loading ', filename)
--
    colors = vtkNamedColors()

    reader = vtkMultiBlockPLOT3DReader()
    reader.SetXYZFileName(xyzFile)
    reader.SetQFileName(qFile)
    reader.SetScalarFunctionNumber(100)
--
    colors = vtkNamedColors()

    filename = get_program_parameters()

    # Read all the data from the file
    reader = vtkXMLPolyDataReader()
--
    colors = vtkNamedColors()

    # vtkSLCReader to read.
    reader = vtkSLCReader()
    reader.SetFileName(InputFilename)
    reader.Update()
--
    colors = vtkNamedColors()

    filename = get_program_parameters()

    reader = vtkSTLReader()
    reader.SetFileName(filename)
--
    colors = vtk.vtkNamedColors()

    file_name = get_program_parameters()

    # Read the source file.
    reader = vtk.vtkXMLUnstructuredGridReader()
--
    colors = vtkNamedColors()

    filename = get_program_parameters()

    reader = vtkXMLPolyDataReader()
    reader.SetFileName(filename)
--
    colors = vtkNamedColors()

    # Read the dataset.
    reader = vtkHDFReader()
    reader.SetFileName(fn)
    reader.Update()
--
    colors = vtkNamedColors()

    filename = get_program_parameters()

    sphereSource = vtkSphereSource()
    sphereSource.Update()
--
    colors = vtkNamedColors()

    filename = get_program_parameters()

    sphereSource = vtkSphereSource()
    sphereSource.Update()
--
    colors = vtkNamedColors()

    file_name, start_label, end_label = get_program_parameters()
    if start_label > end_label:
        end_label, start_label = start_label, end_label

--
    colors = vtkNamedColors()

    file_name = get_program_parameters()

    colors.SetColor('SkinColor', [240, 184, 160, 255])
    colors.SetColor('BackfaceColor', [255, 229, 200, 255])
--
    colors = vtkNamedColors()

    file_name = get_program_parameters()

    colors.SetColor('SkinColor', [240, 184, 160, 255])
    colors.SetColor('BackfaceColor', [255, 229, 200, 255])
--
    colors = vtkNamedColors()

    file_name = get_program_parameters()

    colors.SetColor('SkinColor', [240, 184, 160, 255])
    colors.SetColor('BkgColor', [51, 77, 102, 255])
--
    colors = vtkNamedColors()

    file_name = get_program_parameters()

    colors.SetColor('BkgColor', [51, 77, 102, 255])

--
    colors = vtkNamedColors()

    file_name = get_program_parameters()

    colors.SetColor('SkinColor', [240, 184, 160, 255])
    colors.SetColor('BackfaceColor', [255, 229, 200, 255])
--
    colors = vtkNamedColors()
    diskSource = vtkDiskSource()
    diskSource.Update()

    featureEdges = vtkFeatureEdges()
    featureEdges.SetInputConnection(diskSource.GetOutputPort())
--
    colors = vtkNamedColors()
    backgroundColor = colors.GetColor3d('steel_blue')
    boundaryColor = colors.GetColor3d('Banana')
    clipColor = colors.GetColor3d('Tomato')

    if filePath and os.path.isfile(filePath):
--
    colors = vtkNamedColors()

    # Create polydata to slice the grid with. In this case, use a cone. This could
    # be any polydata including a stl file.
    cone = vtkConeSource()
    cone.SetResolution(20)
--
    colors = vtkNamedColors()

    # Create polydata to slice the grid with. In this case, use a cone. This
    # could
    # be any polydata including a stl file.
    cone = vtkConeSource()
--
    named_colors = vtkNamedColors()

    # Create a grid points
    points = vtkPoints()
    GridSize = 20;
    xx = 0.0
--
    colors = vtkNamedColors()
    backFaceColor = colors.GetColor3d('Gold')
    inputActorColor = colors.GetColor3d('NavajoWhite')
    decimatedActorColor = colors.GetColor3d('NavajoWhite')
    # colors.SetColor('leftBkg', [0.6, 0.5, 0.4, 1.0])
    # colors.SetColor('rightBkg', [0.4, 0.5, 0.6, 1.0])
--
    colors = vtkNamedColors()

    # Set the background color.
    # colors.SetColor('bkg', [0.2, 0.3, 0.4, 1.0])

    # Create a sphere to deform
--
    colors = vtkNamedColors()

    points_reader = vtkDelimitedTextReader()
    points_reader.SetFileName(points_fn)
    points_reader.DetectNumericColumnsOn()
    points_reader.SetFieldDelimiterCharacters('\t')
--
    colors = vtkNamedColors()

    # Create a property to be used for the back faces. Turn off all
    # shading by specifying 0 weights for specular and diffuse. Max the
    # ambient.
    back_faces = vtkProperty()
--
    colors = vtkNamedColors()

    # Create the RenderWindow, Renderer and Interactor.
    #
    renderer = vtkRenderer()
    renWin = vtkRenderWindow()
--
    colors = vtkNamedColors()

    # To see the line
    lineMapper = vtkPolyDataMapper()
    lineMapper.SetInputData(polydata)

--
    colors = vtkNamedColors()

    reader = vtkPNGReader()
    if not reader.CanReadFile(file_name):
        print('Error: Could not read', file_name)
        return
--
    colors = vtkNamedColors()

    # Generate some "random" points.
    points = vtkPoints()
    randomSequence = vtkMinimalStandardRandomSequence()
    randomSequence.SetSeed(1)
--
    colors = vtkNamedColors()
    ren.SetBackground(colors.GetColor3d('Burlywood'))

    ren_win.Render()

    iren.Start()
--
    colors = vtkNamedColors()

    colors.SetColor('SkinColor', [240, 184, 160, 255])
    colors.SetColor('BackfaceColor', [255, 229, 200, 255])
    colors.SetColor('BkgColor', [51, 77, 102, 255])

--
    colors = vtkNamedColors()

    reader = vtkDataObjectReader()
    reader.SetFileName(ifn)

    size = 3187  # maximum number possible
--
    colors = vtkNamedColors()

    colors.SetColor('PopColor', [230, 230, 230, 255])

    fileName = get_program_parameters()

--
    colors = vtkNamedColors()

    dicom_dir, iso_value = get_program_parameters()
    if iso_value is None and dicom_dir is not None:
        print('An ISO value is needed.')
        return ()
--
    colors = vtkNamedColors()
    ren.SetBackground(colors.GetColor3d('Burlywood'))

    ren_win.Render()

    iren.Start()
--
    colors = vtkNamedColors()

    # Create the RenderWindow, Renderer and Interactor.
    #
    renderer = vtkRenderer()
    renWin = vtkRenderWindow()
--
        colors = vtkNamedColors()

        # Get the location of the click (in window coordinates)
        pos = self.GetInteractor().GetEventPosition()

        picker = vtkCellPicker()
--
    colors = vtkNamedColors()

    plane_source = vtkPlaneSource()
    plane_source.Update()

    triangle_filter = vtkTriangleFilter()
--
colors = vtkNamedColors()
NUMBER_OF_SPHERES = 10


class MouseInteractorHighLightActor(vtkInteractorStyleTrackballCamera):

--
    colors = vtkNamedColors()

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

--
    colors = vtkNamedColors()

    renwin = vtkRenderWindow()
    renwin.SetWindowName('MultiplePlots')
    iren = vtkRenderWindowInteractor()
    iren.SetRenderWindow(renwin)
--
    colors = vtkNamedColors()

    view = vtkContextView()
    view.GetRenderer().SetBackground(colors.GetColor3d('SlateGray'))
    view.GetRenderWindow().SetSize(400, 300)

--
    colors = vtkNamedColors()

    numTuples = 12

    bitter = vtkFloatArray()
    bitter.SetNumberOfTuples(numTuples)
--
    colors = vtkNamedColors()

    chart = vtkChartXYZ()
    chart.SetGeometry(vtkRectf(10.0, 10.0, 630, 470))

    plot = vtkPlotSurface()
--
    colors = vtkNamedColors()

    src_fn, tgt_fn = get_program_parameters()
    print('Loading source:', src_fn)
    source_polydata = read_poly_data(src_fn)
    # Save the source polydata in case the alignment process does not improve
--
    colors = vtkNamedColors()

    operation, fn1, fn2 = get_program_parameters()
    if fn1 and fn2:
        poly1 = ReadPolyData(fn1)
        tri1 = vtkTriangleFilter()
--
    colors = vtkNamedColors()
    outsideColor = colors.GetColor3d('Crimson')
    insideColor = colors.GetColor3d('Banana')
    borderColor = colors.GetColor3d('Mint')
    surfaceColor = colors.GetColor3d('Peacock')
    backgroundColor = colors.GetColor3d('Silver')
--
    colors = vtkNamedColors()

    filename = get_program_parameters()

    # setup points and vertices
    Points = vtkPoints()
--
    colors = vtkNamedColors()
    colors.SetColor("ParaViewBkg", [82, 87, 110, 255])

    window_width = 1024
    window_height = 512

--
    colors = vtkNamedColors()
    # Colour transfer function.
    ctf = vtkColorTransferFunction()
    ctf.SetColorSpaceToDiverging()
    p1 = [0.0] + list(colors.GetColor3d('MidnightBlue'))
    p2 = [0.5] + list(colors.GetColor3d('Gainsboro'))
--
    colors = vtkNamedColors()

    # We are going to handle two different sources.
    # The first source is a superquadric source.
    torus = vtkSuperquadricSource()
    torus.SetCenter(0.0, 0.0, 0.0)
--
    colors = vtkNamedColors()
    # Colour transfer function.
    ctf = vtkColorTransferFunction()
    ctf.SetColorSpaceToDiverging()
    p1 = [0.0] + list(colors.GetColor3d('MidnightBlue'))
    p2 = [0.5] + list(colors.GetColor3d('Gainsboro'))
--
    colors = vtkNamedColors()

    # Create a mapper and actor.
    mapper = vtkPolyDataMapper()
    mapper.SetInputData(source)
    mapper.SetScalarModeToUsePointFieldData()
--
    colors = vtkNamedColors()
    lineColor = colors.GetColor3d('peacock')
    modelColor = colors.GetColor3d('silver')
    backgroundColor = colors.GetColor3d('wheat')

    modelSource = vtkSphereSource()
--
    colors = vtkNamedColors()

    point_source = vtkPointSource()

    point_source.SetNumberOfPoints(50)
    point_source.Update()
--
    colors = vtkNamedColors()

    # colors.SetColor('leftBkg', [0.6, 0.5, 0.4, 1.0])
    # colors.SetColor('centreBkg', [0.3, 0.1, 0.4, 1.0])
    # colors.SetColor('rightBkg', [0.4, 0.5, 0.6, 1.0])

--
    colors = vtkNamedColors()

    # Create a cube
    cube = vtkSphereSource()
    cube.SetRadius(50)
    cube.SetThetaResolution(100)
--
    colors = vtkNamedColors()

    sphereSource = vtkSphereSource()
    sphereSource.SetCenter(0.0, 0.0, 0.0)
    sphereSource.SetRadius(1.0)
    sphereSource.Update()
--
    colors = vtkNamedColors()

    # create a rendering window and renderer
    ren = vtkRenderer()
    renWin = vtkRenderWindow()
    renWin.SetWindowName('Outline')
--
    colors = vtkNamedColors()

    # create a rendering window and renderer
    ren = vtkRenderer()
    renWin = vtkRenderWindow()
    renWin.AddRenderer(ren)
--
    colors = vtkNamedColors()

    # Create a rendering window and renderer
    ren = vtkRenderer()
    renWin = vtkRenderWindow()
    renWin.AddRenderer(ren)
--
    colors = vtkNamedColors()

    # Create a rendering window and renderer
    ren = vtkRenderer()
    renWin = vtkRenderWindow()
    renWin.AddRenderer(ren)
--
    nc = vtkNamedColors()

    # Make a 32 x 32 grid
    size = 32

    rn = vtkMinimalStandardRandomSequence()
--
    colors = vtkNamedColors()

    filename = get_program_parameters()

    # setup points and vertices
    Points = vtkPoints()
--
    colors = vtkNamedColors()

    filename = get_program_parameters()

    # setup points and vertices
    Points = vtkPoints()
--
    colors = vtkNamedColors()

    # Create a line
    lineSource = vtkLineSource()
    lineSource.SetPoint1(1.0, 0.0, 0.0)
    lineSource.SetPoint2(.0, 1.0, 0.0)
--
    colors = vtkNamedColors()

    points = vtkPoints()
    points.InsertNextPoint(0.0, 0.0, 0.0)
    points.InsertNextPoint(1.0, 0.0, 0.0)
    points.InsertNextPoint(2.0, 0.0, 0.0)
--
    colors = vtkNamedColors()

    # Create a grid
    grid = vtkRectilinearGrid()
    grid.SetDimensions(2, 3, 1)

--
    colors = vtkNamedColors()

    x = [-1.22396, -1.17188, -1.11979, -1.06771, -1.01562, -0.963542, -0.911458, -0.859375, -0.807292, -0.755208,
         -0.703125, -0.651042, -0.598958, -0.546875, -0.494792, -0.442708, -0.390625, -0.338542, -0.286458, -0.234375,
         -0.182292, -0.130209, -0.078125, -0.026042, 0.0260415, 0.078125, 0.130208, 0.182291, 0.234375, 0.286458,
         0.338542, 0.390625, 0.442708, 0.494792, 0.546875, 0.598958, 0.651042, 0.703125, 0.755208, 0.807292, 0.859375,
--
    colors = vtkNamedColors()

    # Create a grid    
    grid = vtkRectilinearGrid()

    grid.SetDimensions(2, 3, 2)
--
    colors = vtkNamedColors()

    # Set the background color.
    colors.SetColor('bkg', [26, 51, 102, 255])

    # The following lines create a sphere represented by polygons.
--
    colors = vtkNamedColors()

    # Set the background color.
    colors.SetColor('Bkg', [26, 51, 102, 255])

    # Create the rendering objects.
--
    colors = vtkNamedColors()
    renderer = vtkRenderer()
    renWin = vtkRenderWindow()
    renWin.AddRenderer(renderer)
    iren = vtkRenderWindowInteractor()
    iren.SetRenderWindow(renWin)
--
    colors = vtkNamedColors()

    #
    # Next we create an instance of vtkConeSource and set some of its
    # properties. The instance of vtkConeSource 'cone' is part of a visualization
    # pipeline (it is a source process object); it produces data (output type is
--
    colors = vtkNamedColors()

    #
    # Next we create an instance of vtkConeSource and set some of its
    # properties. The instance of vtkConeSource 'cone' is part of a visualization
    # pipeline (it is a source process object); it produces data (output type is
--
    colors = vtkNamedColors()

    # Set the background color.
    colors.SetColor('bkg', [26, 51, 102, 255])

    # The following lines create a sphere represented by polygons.
--
    colors = vtkNamedColors()

    fileName = get_program_parameters()

    # Create the renderers.
    renderers = OrderedDict()
--
    colors = vtkNamedColors()
    sphere = vtkSphereSource()
    mapper = vtkPolyDataMapper()
    mapper.SetInputConnection(sphere.GetOutputPort())
    actor = vtkActor()
    actor.SetMapper(mapper)
--
    colors = vtkNamedColors()
    cylinder = vtkCylinderSource()
    mapper = vtkPolyDataMapper()
    mapper.SetInputConnection(cylinder.GetOutputPort())
    actor = vtkActor()
    actor.SetMapper(mapper)
--
    colors = vtkNamedColors()
    reader = vtkOBJReader()
    reader.SetFileName(fileName)
    mapper = vtkPolyDataMapper()
    mapper.SetInputConnection(reader.GetOutputPort())
    actor = vtkActor()
--
    colors = vtkNamedColors()

    mapper = vtkPolyDataMapper()
    mapper.SetInputData(pd)

    actor = vtkActor()
--
    colors = vtkNamedColors()

    # Points start at upper right and proceed anti-clockwise.
    points = vtkPoints()
    points.SetNumberOfPoints(4)
    points.InsertPoint(0, 1, 1, 0)
--
    colors = vtkNamedColors()

    # Make the slab and axes actors.
    cube_source = vtkCubeSource()
    cube_source.SetXLength(4.0)
    cube_source.SetYLength(9.0)
--
    colors = vtkNamedColors()

    renderer = vtkRenderer()

    renWin = vtkRenderWindow()
    renWin.AddRenderer(renderer)
--
    colors = vtkNamedColors()

    # Set the colors.
    colors.SetColor('CubeColor', [250, 128, 114, 255])
    colors.SetColor('BkgColor', [230, 230, 230, 255])

--
    colors = vtkNamedColors()

    colors.SetColor('A1Diff', [255, 204, 77, 255])
    colors.SetColor('A2Amb', [51, 51, 255, 255])
    colors.SetColor('A2Diff', [51, 255, 204, 255])
    colors.SetColor('A3Amb', [128, 166, 255, 255])
--
    colors = vtkNamedColors()

    iren = vtkRenderWindowInteractor()
    renWin = vtkRenderWindow()
    renWin.SetMultiSamples(0)

--
    colors = vtkNamedColors()
    colors.SetColor('Brass', [184, 115, 51, 255])

    ren = vtkOpenGLRenderer()
    ren.SetBackground(colors.GetColor3d('Black'))

--
    colors = vtkNamedColors()

    ren = vtkOpenGLRenderer()
    ren.SetBackground(colors.GetColor3d('Black'))
    ren.AutomaticLightCreationOff()

--
    colors = vtkNamedColors()

    ren = vtkOpenGLRenderer()
    ren.SetBackground(colors.GetColor3d('Black'))

    ren_win = vtkRenderWindow()
--
    colors = vtkNamedColors()

    ren = vtkOpenGLRenderer()
    ren.SetBackground(colors.GetColor3d('Black'))

    ren_win = vtkRenderWindow()
--
    colors = vtkNamedColors()

    ren = vtkOpenGLRenderer()
    ren.SetBackground(colors.GetColor3d('Black'))
    ren.AutomaticLightCreationOff()

--
    colors = vtkNamedColors()
    colors.SetColor('Brass', [184, 115, 51, 255])
    colors.SetColor('DarkTeal', [0, 128, 77, 255])

    ren = vtkOpenGLRenderer()
    ren.SetBackground(colors.GetColor3d('Black'))
--
    colors = vtkNamedColors()
    colors.SetColor('Brass', [184, 115, 51, 255])

    ren = vtkOpenGLRenderer()
    ren.SetBackground(colors.GetColor3d('Black'))

--
    colors = vtkNamedColors()

    # Default background color.
    colors.SetColor('BkgColor', [26, 51, 102, 255])

    # Default background color.
--
    colors = vtkNamedColors()

    slider = vtkSliderRepresentation2D()

    slider.SetMinimumValue(properties.minimum_value)
    slider.SetMaximumValue(properties.maximum_value)
--
    colors = vtkNamedColors()

    # Default background color.
    colors.SetColor('BkgColor', [26, 51, 102, 255])

    fn, surface_name, use_cubemap, use_tonemapping = get_program_parameters()
--
    colors = vtkNamedColors()

    slider = vtkSliderRepresentation2D()

    slider.SetMinimumValue(properties.minimum_value)
    slider.SetMaximumValue(properties.maximum_value)
--
    colors = vtkNamedColors()

    # Default background color.
    colors.SetColor('BkgColor', [26, 51, 102, 255])
    colors.SetColor('VTKBlue', [6, 79, 141, 255])
    # Let's make a complementary colour to VTKBlue.
--
    colors = vtkNamedColors()

    slider = vtkSliderRepresentation2D()

    slider.SetMinimumValue(properties.minimum_value)
    slider.SetMaximumValue(properties.maximum_value)
--
    colors = vtkNamedColors()

    pl3d = vtkMultiBlockPLOT3DReader()
    pl3d.SetXYZFileName(xyzFn)
    pl3d.SetQFileName(qFn)
    pl3d.SetScalarFunctionNumber(100)
--
    colors = vtkNamedColors()
    # Set the background color.
    colors.SetColor('BkgColor', [26, 51, 102, 255])
    # colors.SetColor('BkgColor', [60, 93, 144, 255])

    ren1 = vtkRenderer()
--
    colors = vtkNamedColors()
    colors.SetColor('HighNoonSun', [255, 255, 251, 255])  # Color temp. 5400°K
    colors.SetColor('100W Tungsten', [255, 214, 170, 255])  # Color temp. 2850°K

    renderer = vtkRenderer()
    renderer.SetBackground(colors.GetColor3d('Silver'))
--
    colors = vtkNamedColors()

    # Set the background color.
    colors.SetColor('bkg', [26, 51, 102, 255])

    # The following lines create a sphere represented by polygons.
--
    colors = vtkNamedColors()

    lines = vtkLineSource()
    # Create two points, P0 and P1
    p0 = [1.0, 0.0, 0.0]
    p1 = [5.0, 0.0, 0.0]
--
    colors = vtkNamedColors()

    fileName = get_program_parameters()

    renderer1 = vtkRenderer()
    renderer1.SetViewport(0.0, 0.0, 0.5, 1.0)
--
    colors = vtkNamedColors()
    renderer = vtkRenderer()
    renWin = vtkRenderWindow()
    renWin.AddRenderer(renderer)
    iren = vtkRenderWindowInteractor()
    iren.SetRenderWindow(renWin)
--
    colors = vtkNamedColors()

    cubeSource = vtkCubeSource()
    cubeSource.SetXLength(4.0)
    cubeSource.SetYLength(9.0)
    cubeSource.SetZLength(1.0)
--
    colors = vtkNamedColors()
    # Set the background color.
    colors.SetColor('BkgColor1', [60, 93, 144, 255])
    colors.SetColor('BkgColor2', [26, 51, 102, 255])

    ren = vtkRenderer()
--
    colors = vtkNamedColors()

    points = vtkPoints()

    grid_size = 8
    counter = 0
--
    colors = vtkNamedColors()

    rMin = 0.5
    rMax = 1.0
    dims = [13, 11, 11]

--
    colors = vtkNamedColors()

    renderer = vtkRenderer()
    renWin = vtkRenderWindow()
    renWin.AddRenderer(renderer)
    iren = vtkRenderWindowInteractor()
--
    colors = vtkNamedColors()

    # Setup the render window, renderer, and interactor.
    renderer = vtkRenderer()
    renderWindow = vtkRenderWindow()
    renderWindow.AddRenderer(renderer)
--
    colors = vtkNamedColors()

    renWin = vtkRenderWindow()

    iren = vtkRenderWindowInteractor()
    iren.SetRenderWindow(renWin)
--
    colors = vtkNamedColors()

    fileName = get_program_parameters()

    # hidden sphere
    sphere1 = vtkSphereSource()
--
    colors = vtkNamedColors()

    # Load in the texture map. A texture is any unsigned char image. If it
    # is not of this type, you will have to map it through a lookup table
    # or by using vtkImageShiftScale.
    #
--
    colors = vtkNamedColors()

    # Read the data.
    pl3d = vtkMultiBlockPLOT3DReader()
    pl3d.SetXYZFileName(dataFn1)
    pl3d.SetQFileName(dataFn2)
--
    colors = vtkNamedColors()

    #
    # Now we create an instance of vtkConeSource and set some of its
    # properties. The instance of vtkConeSource "cone" is part of a
    # visualization pipeline (it is a source process object) it produces data
--
    colors = vtkNamedColors()

    #
    # The pipeline creation is documented in Tutorial_Step1.
    #
    cone = vtkConeSource()
--
    colors = vtkNamedColors()

    #
    # Next we create an instance of vtkConeSource and set some of its
    # properties. The instance of vtkConeSource 'cone' is part of a
    # visualization pipeline (it is a source process object) it produces data
--
    colors = vtkNamedColors()

    #
    # Next we create an instance of vtkConeSource and set some of its
    # properties. The instance of vtkConeSource "cone" is part of a
    # visualization pipeline (it is a source process object) it produces data
--
    colors = vtkNamedColors()

    #
    # Next we create an instance of vtkConeSource and set some of its
    # properties. The instance of vtkConeSource 'cone' is part of a
    # visualization pipeline (it is a source process object) it produces data
--
    colors = vtkNamedColors()

    #
    # Next we create an instance of vtkConeSource and set some of its
    # properties. The instance of vtkConeSource 'cone' is part of a
    # visualization pipeline (it is a source process object) it produces data
--
    colors = vtkNamedColors()
    renderer = vtkRenderer()
    renderer.SetBackground(colors.GetColor3d('Wheat'))
    renderer.UseHiddenLineRemovalOn()

    renderWindow = vtkRenderWindow()
--
    colors = vtkNamedColors()
    renderer = vtkRenderer()
    renderer.SetBackground(colors.GetColor3d('Wheat'))
    renderer.UseHiddenLineRemovalOn()

    renderWindow = vtkRenderWindow()
--
    colors = vtkNamedColors()

    x = [[0, 0, 0], [1, 0, 0], [2, 0, 0], [0, 1, 0], [1, 1, 0], [2, 1, 0], [0, 0, 1], [1, 0, 1], [2, 0, 1], [0, 1, 1],
         [1, 1, 1], [2, 1, 1], [0, 1, 2], [1, 1, 2], [2, 1, 2], [0, 1, 3], [1, 1, 3], [2, 1, 3], [0, 1, 4], [1, 1, 4],
         [2, 1, 4], [0, 1, 5], [1, 1, 5], [2, 1, 5], [0, 1, 6], [1, 1, 6], [2, 1, 6]]
    # Here we have kept consistency with the Cxx example of the same name.
--
    colors = vtkNamedColors()

    # Create a sphere
    sphereSource = vtkSphereSource()
    sphereSource.SetCenter(0.0, 0.0, 0.0)
    sphereSource.SetRadius(2)
--
    colors = vtkNamedColors()
    colors.SetColor('ParaViewBkg', 82, 87, 110, 255)

    ren = vtkRenderer()
    ren.SetBackground(colors.GetColor3d('ParaViewBkg'))
    ren_win = vtkRenderWindow()
--
    colors = vtkNamedColors()
    colors.SetColor('ParaViewBkg', 82, 87, 110, 255)

    sphere = vtkSphereSource()
    sphere.SetThetaResolution(64)
    sphere.SetPhiResolution(32)
--
    colors = vtkNamedColors()
    colors.SetColor('ParaViewBkg', 82, 87, 110, 255)

    ren_win = vtkRenderWindow()
    ren_win.SetSize(640 * 2, 480 * 2)
    ren_win.SetWindowName('RescaleReverseLUT')
--
    colors = vtkNamedColors()

    cone = vtkConeSource()
    cone.SetHeight(3.0)
    cone.SetRadius(1.0)
    cone.SetResolution(10)
--
    colors = vtkNamedColors()

    polyData = ReadPolyData(pd_fn)
    mapper = vtkPolyDataMapper()
    mapper.SetInputData(polyData)

--
    colors = vtkNamedColors()

    polyData = ReadPolyData(pd_fn)
    mapper = vtkPolyDataMapper()
    mapper.SetInputData(polyData)

--
    colors = vtkNamedColors()

    # create a rendering window and renderer
    ren = vtkRenderer()
    renWin = vtkRenderWindow()
    renWin.AddRenderer(ren)
--
    colors = vtkNamedColors()

    # We store background colors in a vector. Then we extract the red, green and
    # blue components later when coloring the reneder background.
    rendererColors = list()
    colorSeries = vtkColorSeries()
--
    colors = vtkNamedColors()

    # We begin by creating the data we want to render.
    # For this tutorial, we create a 3D-image containing three overlaping cubes.
    # This data can of course easily be replaced by data from a medical CT-scan or anything else three dimensional.
    # The only limit is that the data must be reduced to unsigned 8 bit or 16 bit integers.
--
    colors = vtkNamedColors()
    colors.SetColor('ParaViewBkg', 82, 87, 110, 255)

    sphere = vtkSphereSource()
    sphere.SetThetaResolution(64)
    sphere.SetPhiResolution(32)
--
    colors = vtkNamedColors()

    fileName = get_program_parameters()

    # Create a rendering window, renderer and interactor.
    ren = vtkRenderer()
--
    colors = vtkNamedColors()

    aren = vtkRenderer()
    renWin = vtkRenderWindow()
    renWin.AddRenderer(aren)
    iren = vtkRenderWindowInteractor()
--
    colors = vtkNamedColors()

    ren1 = vtkRenderer()

    renWin = vtkRenderWindow()
    renWin.AddRenderer(ren1)
--
    colors = vtkNamedColors()

    ren1 = vtkRenderer()

    renWin = vtkRenderWindow()
    renWin.AddRenderer(ren1)
--
    colors = vtkNamedColors()

    # Demonstrate the use of clipping on polygonal data
    #

    # create pipeline
--
    colors = vtkNamedColors()

    # Create the RenderWindow, Renderer and Interactor.
    #

    ren1 = vtkRenderer()
--
    colors = vtkNamedColors()

    aren = vtkRenderer()

    renWin = vtkRenderWindow()
    renWin.AddRenderer(aren)
--
    colors = vtkNamedColors()

    fileName = get_program_parameters()

    # Now create the RenderWindow, Renderer and Interactor.
    #
--
    colors = vtkNamedColors()

    ren1 = vtkRenderer()

    renWin = vtkRenderWindow()
    renWin.AddRenderer(ren1)
--
    colors = vtkNamedColors()

    # Create a cube
    cube = vtkCubeSource()
    cube.SetXLength(40)
    cube.SetYLength(30)
--
    colors = vtkNamedColors()

    fileName, numberOfCuts = get_program_parameters()
    reader = vtkXMLPolyDataReader()
    reader.SetFileName(fileName)
    reader.Update()
--
    colors = vtkNamedColors()

    reader = vtkXMLPolyDataReader()
    reader.SetFileName(inputFilename)
    reader.Update()

--
    colors = vtkNamedColors()

    # Setup the coordinates of eight points
    # (the two faces must be in counter clockwise order as viewed from the
    # outside)
    pointCoords = [
--
    colors = vtkNamedColors()

    fileName1, fileName2 = get_program_parameters()

    # This example shows how to use decimation to reduce a polygonal mesh. We also
    # use mesh smoothing and generate surface normals to give a pleasing result.
--
    colors = vtkNamedColors()

    fileName = get_program_parameters()

    # This example shows how to use decimation to reduce a polygonal mesh. We also
    # use mesh smoothing and generate surface normals to give a pleasing result.
--
    colors = vtkNamedColors()

    # Read a vtk file
    #
    plate = vtkPolyDataReader()
    plate.SetFileName(file_name)
--
    colors = vtkNamedColors()

    # Create the RenderWindow, Renderer and Interactor.
    #
    ren = vtkRenderer()
    renWin = vtkRenderWindow()
--
    colors = vtkNamedColors()

    ren1 = vtkRenderer()

    renWin = vtkRenderWindow()
    renWin.AddRenderer(ren1)
--
    colors = vtkNamedColors()

    # Create the RenderWindow, Renderer and Interactor.
    ren1 = vtkRenderer()
    renWin = vtkRenderWindow()
    renWin.AddRenderer(ren1)
--
    colors = vtkNamedColors()

    # Create the RenderWindow, Renderer and Interactor.
    ren = vtkRenderer()
    ren_win = vtkRenderWindow()
    ren_win.AddRenderer(ren)
--
    colors = vtkNamedColors()

    # Create the RenderWindow, Renderer and Interactor.
    #

    ren1 = vtkRenderer()
--
    colors = vtkNamedColors()

    # Create lines which serve as the 'seed' geometry. The lines spell the
    # word 'hello'.
    #
    reader = vtkPolyDataReader()
--
    colors = vtkNamedColors()

    # Create the RenderWindow, Renderer and Interactor.
    #
    ren1 = vtkRenderer()
    renWin = vtkRenderWindow()
--
    colors = vtkNamedColors()

    # Create implicit function primitives. These have been carefully placed to
    # give the effect that we want. We are going to use various combinations of
    # these functions to create the shape we want for example, we use planes
    # intersected with a cone (which is infinite in extent) to get a finite
--
    colors = vtkNamedColors()

    # Read the CT data of the human head.
    reader = vtkMetaImageReader()
    reader.SetFileName(fileName)
    reader.Update()
--
    colors = vtkNamedColors()

    # Create the RenderWindow, Renderer and Interactor.
    ren1 = vtkRenderer()
    renWin = vtkRenderWindow()
    renWin.AddRenderer(ren1)
--
    colors = vtkNamedColors()

    xyxFile, qFile = get_program_parameters()

    # Read the data.
    #
--
    colors = vtkNamedColors()

    xyxFile, qFile = get_program_parameters()

    # Read the data.
    #
--
    colors = vtkNamedColors()

    xyxFile, qFile = get_program_parameters()

    # Read the data.
    #
--
    color = vtkNamedColors()

    # Rotate the final figure 0, 90, 180, 270 degrees.
    rotation = abs(int(rotation))
    if rotation > 3:
        rotation = 0
--
    colors = vtkNamedColors()

    textureFile, motorFile = get_program_parameters()

    # Create the Renderer, RenderWindow and RenderWindowInteractor.
    ren = vtkRenderer()
--
    colors = 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 = 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 = vtkNamedColors()

    # Create the pipeline.
    reader = vtkMCubesReader()
    reader.SetFileName(fileName)
    if not noConnectivity:
--
    colors = vtkNamedColors()

    fileName = get_program_parameters()

    # Create the pipeline.
    reader = vtkMCubesReader()
--
    colors = vtkNamedColors()

    # Set the colors.
    colors.SetColor('PlateColor', [255, 160, 140, 255])
    colors.SetColor('BkgColor', [65, 99, 149, 255])

--
    colors = vtkNamedColors()

    fileName1, fileName2 = get_program_parameters()

    # Create the pipeline.
    #
--
    colors = vtkNamedColors()

    aren = vtkRenderer()
    renWin = vtkRenderWindow()
    renWin.AddRenderer(aren)
    iren = vtkRenderWindowInteractor()
--
    colors = vtkNamedColors()

    fran = vtkPolyDataReader()
    fran.SetFileName(fileName)

    normals = vtkPolyDataNormals()
--
    colors = vtkNamedColors()

    fileName = get_program_parameters()

    # Create the RenderWindow, Renderer and Interactor.
    #
--
    colors = vtkNamedColors()

    fileNames, useRibbons = get_program_parameters()
    useTubes = not useRibbons

    # Set up the stocks
--
    colors = vtkNamedColors()

    fileName1, fileName2, numOfStreamLines, illustration = get_program_parameters()
    if illustration:
        numOfStreamLines = 25

--
    colors = vtkNamedColors()

    # Create the RenderWindow, Renderer and interactive renderer.
    #
    ren = vtkRenderer()
    renWin = vtkRenderWindow()
--
    colors = vtkNamedColors()

    # Create the RenderWindow, Renderer and interactive renderer.
    #
    ren = vtkRenderer()
    renWin = vtkRenderWindow()
--
    colors = vtkNamedColors()

    # Set the background color.
    colors.SetColor('BkgColor', [65, 99, 149, 255])

    # Read a vtk file
--
    colors = vtkNamedColors()

    fileName1, fileName2 = get_program_parameters()

    # Here we read data from a annular combustor. A combustor burns fuel and air
    # in a gas turbine (e.g., a jet engine) and the hot gas eventually makes its
--
    colors = vtkNamedColors()

    # Here we read the file keeping only the alpha characters
    #  and calculate the frequency of each letter.
    with open(fileName) as f:
        freq = Counter()
--
    colors = vtkNamedColors()

    # Set up the renderer, window, and interactor.
    #
    ren = vtkRenderer()
    ren.SetBackground(colors.GetColor3d('Wheat'))
--
    nc = vtkNamedColors()

    lut = vtkLookupTable()
    lut.SetNumberOfTableValues(tableSize)
    lut.Build()

--
    nc = vtkNamedColors()

    # Provide some geometry
    resolution = 3

    plane11 = vtkPlaneSource()
--
    colors = vtkNamedColors()

    # For testing
    rng = vtkMinimalStandardRandomSequence()
    # rng.SetSeed(8775070)
    rng.SetSeed(5127)
--
    colors = vtkNamedColors()

    fileName1, fileName2, fileName3 = get_program_parameters()
    aRenderer = vtkRenderer()
    aRenderWindow = vtkRenderWindow()
    aRenderWindow.AddRenderer(aRenderer)
--
    colors = vtkNamedColors()

    thickness = list()
    displacement = list()
    for i in range(0, 10):
        thickness.append('thickness' + str(i))
--
    colors = vtkNamedColors()

    # Set the colors.
    colors.SetColor('AzimuthArrowColor', [255, 77, 77, 255])
    colors.SetColor('ElevationArrowColor', [77, 255, 77, 255])
    colors.SetColor('RollArrowColor', [255, 255, 77, 255])
--
    colors = vtkNamedColors()

    # Set the colors.
    colors.SetColor("AzimuthArrowColor", [255, 77, 77, 255])
    colors.SetColor("ElevationArrowColor", [77, 255, 77, 255])
    colors.SetColor("RollArrowColor", [255, 255, 77, 255])
--
    colors = vtkNamedColors()

    # Create a sphere
    sphereSource = vtkSphereSource()
    sphereSource.SetCenter(0.0, 0.0, 0.0)
    sphereSource.SetRadius(10)
--
    colors = vtkNamedColors()

    # Generate an image data set with multiple attribute arrays to probe and view
    # We will glyph these points with cones and scale/orient/color them with the
    # various attributes

--
    colors = vtkNamedColors()

    sphere0 = vtkSphereSource()
    sphere0.SetRadius(0.29)
    sphere0.SetPhiResolution(31)
    sphere0.SetThetaResolution(31)
--
    colors = vtkNamedColors()

    # create a rendering window and renderer
    ren = vtkRenderer()
    renWin = vtkRenderWindow()
    renWin.AddRenderer(ren)
--
    colors = vtkNamedColors()

    ren = vtkRenderer()
    renWin = vtkRenderWindow()
    renWin.AddRenderer(ren)
    renWin.SetSize(640, 480)
--
        self.nc = vtkNamedColors()
        self.htmlRGBA = HTMLToFromRGBAColor()

    @staticmethod
    def MakeHTMLStyle():
        s = '  <style>\n'
--
    colors = vtkNamedColors()

    reader = vtkStructuredPointsReader()
    reader.SetFileName(fileName)

    hhog = vtkHedgeHog()
--
    nc = vtkNamedColors()
    myColors = vtkColorSeries()
    myColors.SetColorSchemeByName('VTKBlueColors')

    myColors.AddColor(nc.GetColor3ub('alice_blue'))
    myColors.AddColor(nc.GetColor3ub('blue'))
--
    nc = vtkNamedColors()
    myColors = vtkColorSeries()
    myColors.SetColorSchemeByName('VTKBrownColors')

    myColors.AddColor(nc.GetColor3ub('beige'))
    myColors.AddColor(nc.GetColor3ub('brown'))
--
    nc = vtkNamedColors()
    myColors = vtkColorSeries()
    myColors.SetColorSchemeByName('VTKRedColors')

    myColors.AddColor(nc.GetColor3ub('alizarin_crimson'))
    myColors.AddColor(nc.GetColor3ub('brick'))
--
    nc = vtkNamedColors()
    myColors = vtkColorSeries()
    myColors.SetColorSchemeByName('VTKOrangeColors')

    myColors.AddColor(nc.GetColor3ub('cadmium_orange'))
    myColors.AddColor(nc.GetColor3ub('cadmium_red_light'))
--
    nc = vtkNamedColors()
    myColors = vtkColorSeries()
    myColors.SetColorSchemeByName('VTKWhiteColors')

    myColors.AddColor(nc.GetColor3ub('antique_white'))
    myColors.AddColor(nc.GetColor3ub('azure'))
--
    nc = vtkNamedColors()
    myColors = vtkColorSeries()
    myColors.SetColorSchemeByName('VTKGreyColors')

    myColors.AddColor(nc.GetColor3ub('cold_grey'))
    myColors.AddColor(nc.GetColor3ub('dim_grey'))
--
    nc = vtkNamedColors()
    myColors = vtkColorSeries()
    myColors.SetColorSchemeByName('VTKMagentaColors')

    myColors.AddColor(nc.GetColor3ub('blue_violet'))
    myColors.AddColor(nc.GetColor3ub('cobalt_violet_deep'))
--
    nc = vtkNamedColors()
    myColors = vtkColorSeries()
    myColors.SetColorSchemeByName('VTKCyanColors')

    myColors.AddColor(nc.GetColor3ub('aquamarine'))
    myColors.AddColor(nc.GetColor3ub('aquamarine_medium'))
--
    nc = vtkNamedColors()
    myColors = vtkColorSeries()
    myColors.SetColorSchemeByName('VTKYellowColors')

    myColors.AddColor(nc.GetColor3ub('aureoline_yellow'))
    myColors.AddColor(nc.GetColor3ub('banana'))
--
    nc = vtkNamedColors()
    myColors = vtkColorSeries()
    myColors.SetColorSchemeByName('VTKGreenColors')

    myColors.AddColor(nc.GetColor3ub('chartreuse'))
    myColors.AddColor(nc.GetColor3ub('chrome_oxide_green'))
--
    colors = vtkNamedColors()

    # Provide some geometry.
    xResolution = 6
    yResolution = 6
    aPlane = vtkPlaneSource()
--
    colors = vtkNamedColors()

    backgroundColor = colors.GetColor3d("DarkSlateGray")
    actorColor = colors.GetColor3d("Tomato")
    axis1Color = colors.GetColor3d("Salmon")
    axis2Color = colors.GetColor3d("PaleGreen")
--
    colors = vtkNamedColors()

    # Set the background color.
    colors.SetColor('BkgColor', [179, 204, 255, 255])
    colors.SetColor("ParaViewBkg", [82, 87, 110, 255])

--
    colors = vtkNamedColors()

    sphereSource = vtkSphereSource()
    sphereSource.SetCenter(0.0, 0.0, 0.0)
    sphereSource.SetRadius(1.0)
    sphereSource.Update()
--
    colors = vtkNamedColors()

    # sample the quadric function
    sample = vtkSampleFunction()
    sample.SetSampleDimensions(50, 50, 50)
    sample.SetImplicitFunction(quadric)
--
    colors = vtkNamedColors()

    # Set the background color.
    colors.SetColor('BkgColor', [179, 204, 255, 255])
    colors.SetColor("ParaViewBkg", [82, 87, 110, 255])

--
    colors = vtkNamedColors()

    path = Path(data_folder)
    if path.is_dir():
        s = ''
        file_name = path.joinpath('frogtissue').with_suffix('.mhd')
--
    colors = vtkNamedColors()
    colors.SetColor("ParaViewBkg", [82, 87, 110, 255])

    # Setup render window, renderer, and interactor.
    ren = vtkRenderer()
    ren_win = vtkRenderWindow()
--
    nc = vtkNamedColors()

    for k in indices.keys():
        lut.SetTableValue(indices[k], nc.GetColor4d(colors[k]))

    return lut
--
    colors = vtkNamedColors()
    colors.SetColor("ParaViewBkg", [82, 87, 110, 255])

    # Setup render window, renderers, and interactor.
    ren = vtkRenderer()
    ren_win = vtkRenderWindow()
--
    nc = vtkNamedColors()

    for k in indices.keys():
        lut.SetTableValue(indices[k], nc.GetColor4d(colors[k]))

    return lut
--
    colors = vtkNamedColors()
    # Set the colors of the slider components.
    # Change the color of the bar.
    slider.GetTubeProperty().SetColor(colors.GetColor3d(properties.bar_color))
    # Change the color of the ends of the bar.
    slider.GetCapProperty().SetColor(colors.GetColor3d(properties.bar_ends_color))
--
    colors = vtkNamedColors()

    path = Path(data_folder)
    if path.is_dir():
        s = ''
        fn_1 = path.joinpath('frog').with_suffix('.mhd')
--
    colors = vtkNamedColors()

    # The Wavelet Source is nice for generating a test vtkImageData set
    rt = vtkRTAnalyticSource()
    rt.SetWholeExtent(-2, 2, -2, 2, 0, 0)

--
    colors = vtkNamedColors()

    # Create the renderer and render window interactor.
    ren = vtkRenderer()
    renWin.AddRenderer(ren)
    renWin.SetSize(1200, 750)
--
    colors = vtkNamedColors()

    sphere = vtkSphereSource()
    sphere.SetCenter(0, 0, 0)
    sphere.SetRadius(5.0)

--
    colors = vtkNamedColors()

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

    # Read a vtk file
--
    colors = vtkNamedColors()
    if color_scheme == 1:
        # A lookup table of 256 colours ranging from
        #  deep blue (water) to yellow-white (mountain top)
        #  is used to color map this figure.
        lut = vtkLookupTable()
--
    colors = vtkNamedColors()

    sample_resolution = get_program_parameters()

    # Create a sampled sphere
    implicit_sphere = vtkSphere()
--
    colors = vtkNamedColors()

    # Set the furniture colors.
    colors.SetColor('Furniture', [204, 204, 153, 255])

    scalarRange = [0.0, 0.0]
--
    colors = vtkNamedColors()

    # Initially, set up the points to be an equilateral triangle. Note that the
    # first point is the same as the last point to make this a closed curve when
    # I create the vtkPolyLine.
    points = vtkPoints()
--
    colors = vtkNamedColors()

    renderer = vtkRenderer()
    renderer.GetCullers().RemoveAllItems()

    renWin = vtkRenderWindow()
--
    colors = vtkNamedColors()

    Pr = 10.0  # The Lorenz parameters
    b = 2.667
    r = 28.0
    # x = 0.0
--
    colors = vtkNamedColors()
    # Have some fun with colors
    ren_bkg = ['AliceBlue', 'GhostWhite', 'WhiteSmoke', 'Seashell']
    actor_color = ['Bisque', 'RosyBrown', 'Goldenrod', 'Chocolate']

    # Window sizes and spacing.
--
    colors = vtkNamedColors()

    # One render window, multiple viewports.
    rw = vtkRenderWindow()
    iren = vtkRenderWindowInteractor()
    iren.SetRenderWindow(rw)
--
        self.nc = vtkNamedColors()
        self.htmlRGBA = HTMLToFromRGBAColor()

    @staticmethod
    def MakeHTMLStyle():
        s = '  <style>\n'
--
        s += '<title>vtkNamedColors</title>\n'
        s += HTMLTableMaker.MakeHTMLStyle()
        s += '</head>\n'
        return s

    @staticmethod
--
        res += '<h1>Colors available in vtkNamedColors</h1>\n'
        res += '<table>\n'
        res += '<tr>\n'
        res += '<th colspan="3">Web Color Names</th>\n'
        res += '</tr>\n'
        res += '<tr>\n'
--
        res += '<h1>Colors available in vtkNamedColors</h1>\n'
        res += 'The web colors take precedence over colors of the same'
        res += ' name in VTK Color Names.\n'
        res += '<table>\n'
        res += '<tr>\n'
        res += '<th colspan="3">VTK Color Names</th>\n'
--
        res += '<h1>Synonyms in vtkNamedColors</h1>\n'
        res += '<table>\n'
        res += '<tr>\n'
        res += '<th colspan="2">Synonyms</th>\n'
        res += '</tr>\n'
        res += '<tr>\n'
--
        res += '<h1>Colors available in vtkNamedColors</h1>\n'
        res += 'The class vtkNamedColors provides color names and their'
        res += ' values for the convenience of the user.\n'
        res += '<br>The following tables show the available colors along with'
        res += ' their red, green and blue values.\n'
        res += self.MakeHTMLIndex()
        res += '<table>\n'
--
    nc = vtkNamedColors()
    # We can print out the variables.
    # The color name and RGBA values are displayed.
    print(nc)

    # Here we just print out the colors and any
--
    colors = vtkNamedColors()

    fileName = get_program_parameters()

    polyData = ReadPolyData(fileName)

--
    colors = vtkNamedColors()

    sphereSource = vtkSphereSource()
    sphereSource.Update()

    input_data = vtkPolyData()
--
nc = vtkNamedColors()


def GetProgramParameters():
    import argparse
    description = 'Demonstrates point data subdivision with the glyphing of normals on the surface.'
--
    colors = vtkNamedColors()

    # create a rendering window and renderer
    ren = vtkRenderer()
    renWin = vtkRenderWindow()
    renWin.AddRenderer(ren)
--
    colors = vtkNamedColors()

    # Create points.
    points = vtkPoints()
    points.InsertNextPoint(0, 0, 0)
    points.InsertNextPoint(5, 0, 0)
--
    colors = vtkNamedColors()

    # Create the rendering stuff
    ren1 = vtkRenderer()
    renWin = vtkRenderWindow()
    renWin.SetMultiSamples(0)
--
    colors = vtkNamedColors()

    renderer = vtkRenderer()

    renderWindow = vtkRenderWindow()
    renderWindow.AddRenderer(renderer)
--
    colors = vtkNamedColors()
    box_color = colors.GetColor3d('Tomato')
    rectangle_color = colors.GetColor3d('Beige')
    cone_color = colors.GetColor3d('Peacock')
    sphere_color = colors.GetColor3d('Banana')

--
    colors = vtkNamedColors()

    jpegfile = get_program_parameters()

    # Create a render window
    ren = vtkRenderer()
--
    colors = vtkNamedColors()

    # colors.SetColor('bkg', [0.1, 0.2, 0.4, 1.0])

    xyz_file, q_file = get_program_parameters()

--
    colors = vtkNamedColors()

    textSource = vtkTextSource()
    textSource.SetText("Hello")
    textSource.SetForegroundColor(colors.GetColor3d('DarkSlateGray'))
    textSource.SetBackgroundColor(colors.GetColor3d('NavajoWhite'))
--
    colors = vtkNamedColors()

    textSource = vtkVectorText()
    textSource.SetText('Hello')
    textSource.Update()

--
    colors = vtkNamedColors()

    sphereSource = vtkSphereSource()
    sphereSource.SetCenter(0.0, 0.0, 0.0)
    sphereSource.SetRadius(5)

--
    colors = vtkNamedColors()

    # Create pipeline. Read structured grid data.
    #
    pl3d = vtkMultiBlockPLOT3DReader()
    pl3d.SetXYZFileName(xyzFile)
--
    colors = vtkNamedColors()

    # This is a simple volume rendering example that
    # uses a vtkFixedPointVolumeRayCastMapper

    # Create the standard renderer, render window
--
    colors = vtkNamedColors()

    # Sphere.
    sphere_source = vtkSphereSource()
    sphere_source.SetCenter(-4.0, 0.0, 0.0)
    sphere_source.SetRadius(4.0)
--
    colors = vtkNamedColors()

    # Create a Cone
    cone = vtkConeSource()
    cone.SetResolution(20)
    coneMapper = vtkPolyDataMapper()
--
    colors = vtkNamedColors()

    path = get_program_parameters()
    if not Path(path).is_file():
        print('Unable to find the file:', path)
        return
--
    colors = vtkNamedColors()

    actor = vtkAnnotatedCubeActor()
    actor.GetCubeProperty().SetColor(colors.GetColor3d('PeachPuff'))

    # a renderer and render window
--
    colors = vtkNamedColors()

    # colors.SetColor('bkg', [0.1, 0.2, 0.4, 1.0])

    # Create the RenderWindow, Renderer and both Actors

--
    colors = vtkNamedColors()
    sphere_source = vtkSphereSource()
    sphere_source.SetRadius(10.0)

    fp = None
    if fn:
--
    colors = vtkNamedColors()

    file_name = get_program_parameters()

    # Read the polydata for the icon
    reader = vtkXMLPolyDataReader()
--
    colors = vtkNamedColors()

    # colors.SetColor('bkg', [0.2, 0.3, 0.7, 1.0])

    # create a rendering window and renderer
    ren = vtkRenderer()
--
    colors = vtkNamedColors()

    # colors.SetColor('bkg', [0.1, 0.2, 0.4, 1.0])

    # The source file
    file_name = get_program_parameters()
--
    colors = vtkNamedColors()

    # colors.SetColor('bkg', [0.1, 0.2, 0.4, 1.0])

    # A renderer and render window
    renderer = vtkRenderer()
--
    colors = vtkNamedColors()
    colors.SetColor('ParaViewBkg', [82, 87, 110, 255])

    has_cow = False
    if vtk_version_ok(9, 0, 20210718):
        cam_orient_manipulator = vtkCameraOrientationWidget()
--
    colors = vtkNamedColors()

    # colors.SetColor('bkg', [0.1, 0.2, 0.4, 1.0])

    source = vtkSphereSource()

