diff --git a/src/Cxx.md b/src/Cxx.md
index 1060e603a6318b4866869c81512efee03326755b..b85838e65a6e3b225e393da8193ed97bb14fc0a1 100644
--- a/src/Cxx.md
+++ b/src/Cxx.md
@@ -191,7 +191,7 @@ If you are new to VTK then these [tutorials](#tutorial) will help to get you sta
 | -------------- | ------------- | ------- |
 [Cell3DDemonstration](/Cxx/GeometricObjects/Cell3DDemonstration) | Demonstrate the use of vtkCell3D to construct geometric objects. Sample objects are generated from the classes derived from vtkCell3D and displayed.
 [CellTypeSource](/Cxx/GeometricObjects/CellTypeSource) | Generate tessellated cells.
-[ConvexPointSet](/Cxx/GeometricObjects/ConvexPointSet) | Generate a ConvexPointSetCell.
+[ConvexPointSet](/Cxx/GeometricObjects/ConvexPointSet) | Generate a ConvexPointSet cell.
 [Hexahedron](/Cxx/GeometricObjects/Hexahedron) |
 [LinearCellDemo](/Cxx/GeometricObjects/LinearCellDemo) | Linear cell types found in VTK. Numbers define ordering of the defining points.
 [LongLine](/Cxx/GeometricObjects/LongLine) | Manually create a polyline.
@@ -1091,7 +1091,7 @@ See [this tutorial](http://www.vtk.org/Wiki/VTK/Tutorials/3DDataTypes) for a bri
 [PineRootConnectivityA](/Cxx/VisualizationAlgorithms/PineRootConnectivityA) | The isosurface, with no connectivity filter applied.
 [PineRootDecimation](/Cxx/VisualizationAlgorithms/PineRootDecimation) | Applying the decimation and connectivity filters to remove noisy isosurfaces and reduce data size.
 [PlateVibration](/Cxx/VisualizationAlgorithms/PlateVibration) | Demonstrates the motion of a vibrating beam.
-[PointDataSubdivision](/Cxx/Visualization/PointDataSubdivision) | Demonstrates the effect of applying these filters on various sources.
+[PointDataSubdivision](/Cxx/Visualization/PointDataSubdivision) | Demonstrates the use of the vtkLinearSubdivisionFilter and vtkButterflySubdivisionFilter.
 [PointSize](/Cxx/Visualization/PointSize) |
 [ProbeCombustor](/Cxx/VisualizationAlgorithms/ProbeCombustor) | Probing data in a combustor.  Probes are regular arrays of 50 by 50 points that are then passed through a contouring filter.
 [ProgrammableGlyphFilter](/Cxx/Visualization/ProgrammableGlyphFilter) | Generate a custom glyph at each point.
diff --git a/src/Python.md b/src/Python.md
index 9f341e7fe960e5a70efc33a54e19f898f51c4cea..69240d2599b27146dac41784f33c3e8272a078b3 100644
--- a/src/Python.md
+++ b/src/Python.md
@@ -120,7 +120,7 @@ If you are new to VTK then these [tutorials](#tutorial) will help to get you sta
 | -------------- | ------------- | ------- |
 [Cell3DDemonstration](/Python/GeometricObjects/Cell3DDemonstration) | Sample objects are generated from the classes derived from vtkCell3D and displayed.
 [CellTypeSource](/Python/GeometricObjects/CellTypeSource) | Generate tessellated cells.
-[ConvexPointSet](/Python/GeometricObjects/ConvexPointSet) | Generate a ConvexPointSetCell.
+[ConvexPointSet](/Python/GeometricObjects/ConvexPointSet) | Generate a ConvexPointSet cell.
 [Hexahedron](/Python/GeometricObjects/Hexahedron) |
 [LinearCellDemo](/Python/GeometricObjects/LinearCellDemo) | Linear cell types found in VTK. Numbers define ordering of the defining points.
 [LongLine](/Python/GeometricObjects/LongLine) | Manually create a polyline.
@@ -590,7 +590,7 @@ See [this tutorial](http://www.vtk.org/Wiki/VTK/Tutorials/3DDataTypes) for a bri
 [PineRootConnectivityA](/Python/VisualizationAlgorithms/PineRootConnectivityA) | The isosurface, with no connectivity filter applied.
 [PineRootDecimation](/Python/VisualizationAlgorithms/PineRootDecimation) | Applying the decimation and connectivity filters to remove noisy isosurfaces and reduce data size.
 [PlateVibration](/Python/VisualizationAlgorithms/PlateVibration) | Demonstrates the motion of a vibrating beam.
-[PointDataSubdivision](/Python/Visualization/PointDataSubdivision) | Vary the shapes of glyphed points using a programmable glyph filter
+[PointDataSubdivision](/Python/Visualization/PointDataSubdivision) | Demonstrates the use of the vtkLinearSubdivisionFilter and vtkButterflySubdivisionFilter.
 [PointSize](/Python/Visualization/PointSize) |
 [ProbeCombustor](/Python/VisualizationAlgorithms/ProbeCombustor) | Probing data in a combustor.  Probes are regular arrays of 50 by 50 points that are then passed through a contouring filter.
 [ProgrammableGlyphFilter](/Python/Visualization/ProgrammableGlyphFilter) | Generate a custom glyph at each point.
diff --git a/src/PythonicAPI.md b/src/PythonicAPI.md
index 6cd7730faf5eb4d6207cd8dc720159e552acc01a..033e8ce242c7383125d80e57ac37d60e6bb9cc90 100644
--- a/src/PythonicAPI.md
+++ b/src/PythonicAPI.md
@@ -103,6 +103,7 @@ This Python script, [SelectExamples](../PythonicAPI/Utilities/SelectExamples), w
 | Example Name | Description | Image |
 | -------------- | ------------- | ------- |
 [CellTypeSource](/PythonicAPI/GeometricObjects/CellTypeSource) | Generate tessellated cells.
+[ConvexPointSet](/PythonicAPI/GeometricObjects/ConvexPointSet) | Generate a ConvexPointSet cell.
 
 ### Sources
 
@@ -128,7 +129,9 @@ This Python script, [SelectExamples](../PythonicAPI/Utilities/SelectExamples), w
 | Example Name | Description | Image |
 | -------------- | ------------- | ------- |
 [BooleanOperationImplicitFunctions](/PythonicAPI/ImplicitFunctions/BooleanOperationImplicitFunctions) | Demonstrate booleans of two different implicit functions
+[ContourTriangulator](/PythonicAPI/Modelling/ContourTriangulator) | Create a contour from a structured point set (image) and triangulate it.
 [DiscreteFlyingEdges3D](/PythonicAPI/Modelling/DiscreteFlyingEdges3D) | Generate surfaces from labeled data.
+[IceCream](/PythonicAPI/VisualizationAlgorithms/IceCream) | How to use boolean combinations of implicit functions to create a model of an ice cream cone.
 [ImplicitQuadric](/PythonicAPI/ImplicitFunctions/ImplicitQuadric) | Create an ellipsoid using an implicit quadric
 [ImplicitSphere](/PythonicAPI/ImplicitFunctions/ImplicitSphere) | Demonstrate sampling of a sphere implicit function
 [ImplicitSphere1](/PythonicAPI/ImplicitFunctions/ImplicitSphere1) | Demonstrate sampling of a sphere implicit function
@@ -155,6 +158,7 @@ This Python script, [SelectExamples](../PythonicAPI/Utilities/SelectExamples), w
 
 | Example Name | Description | Image |
 | -------------- | ------------- | ------- |
+[CompositePolyDataMapper](/PythonicAPI/CompositeData/CompositePolyDataMapper) |
 [OverlappingAMR](/PythonicAPI/CompositeData/OverlappingAMR) | Demonstrates how to create and populate  VTK's Overlapping AMR Grid type with data.
 
 ### Data Type Conversions
@@ -255,6 +259,7 @@ This section includes ?vtkUnstructuredGrid?.
 | Example Name | Description | Image |
 | -------------- | ------------- | ------- |
 [SideBySideGraphs](/PythonicAPI/Graphs/SideBySideGraphs) | Display two graphs side by side.
+[LabelVerticesAndEdges](/PythonicAPI/Graphs/LabelVerticesAndEdges) | Label vertices and edges.
 
 ### Graph Conversions
 
@@ -315,7 +320,9 @@ See [this tutorial](http://www.vtk.org/Wiki/VTK/Tutorials/3DDataTypes) for a bri
 [AssignCellColorsFromLUT](/PythonicAPI/Visualization/AssignCellColorsFromLUT) | Demonstrates how to assign colors to cells in a vtkPolyData structure using lookup tables.
 [BillboardTextActor3D](/PythonicAPI/Visualization/BillboardTextActor3D) | Label points with billboards.
 [ColoredAnnotatedCube](/PythonicAPI/Visualization/ColoredAnnotatedCube) | How to color the individual faces of an annotated cube.
-[CurvaturesNormalsElevations](/PythonicAPI/Visualization/CurvaturesNormalsElevations) | Gaussian and Mean curvatures of a surface with arrows colored by elevation to display the normals.
+[CollisionDetection](/PythonicAPI/Visualization/CollisionDetection) | Collison between two spheres.
+[CubeAxesActor](/PythonicAPI/Visualization/CubeAxesActor) | Display three orthogonal axes with [CurvaturesNormalsElevations](/PythonicAPI/Visualization/CurvaturesNormalsElevations) | Gaussian and Mean curvatures of a surface with arrows colored by elevation to display the normals.
+[PointDataSubdivision](/PythonicAPI/Visualization/PointDataSubdivision) | Demonstrates the use of the vtkLinearSubdivisionFilter and vtkButterflySubdivisionFilter.
 [QuadricVisualization](/PythonicAPI/Visualization/QuadricVisualization) | Visualizing a quadric function.
 [WarpCombustor](/PythonicAPI/VisualizationAlgorithms/WarpCombustor) | Carpet plots of combustor flow energy in a structured grid. Colors and plane displacement represent energy values.
 
@@ -361,6 +368,8 @@ See [this tutorial](http://www.vtk.org/Wiki/VTK/Tutorials/3DDataTypes) for a bri
 | Example Name | Description | Image |
 | -------------- | ------------- | ------- |
 [BalloonWidget](/PythonicAPI/Widgets/BalloonWidget) | Uses a vtkBalloonWidget to draw labels when the mouse stays above an actor.
+[CompassWidget](/PythonicAPI/Widgets/CompassWidget) | Draws an interactive compass.
+[ContourWidget](/PythonicAPI/Widgets/ContourWidget) | Draw a contour (line) which can be deformed by the user.
 
 ## Plotting
 
@@ -369,6 +378,7 @@ See [this tutorial](http://www.vtk.org/Wiki/VTK/Tutorials/3DDataTypes) for a bri
 [MultiplePlots](/PythonicAPI/Plotting/MultiplePlots) | Display multiple plots by using viewports in a single render window.
 [ScatterPlot](/PythonicAPI/Plotting/ScatterPlot) | Scatter plot.
 [SpiderPlot](/PythonicAPI/Plotting/SpiderPlot) | Spider plot.
+[SurfacePlot](/PythonicAPI/Plotting/SurfacePlot) | Surface plot.
 
 ## Animation
 
diff --git a/src/PythonicAPI/CompositeData/CompositePolyDataMapper.py b/src/PythonicAPI/CompositeData/CompositePolyDataMapper.py
new file mode 100755
index 0000000000000000000000000000000000000000..72d76a08cb20d868eb23cb715c2da05e82e3e1e3
--- /dev/null
+++ b/src/PythonicAPI/CompositeData/CompositePolyDataMapper.py
@@ -0,0 +1,75 @@
+#!/usr/bin/env python3
+
+# noinspection PyUnresolvedReferences
+import vtkmodules.vtkInteractionStyle
+# noinspection PyUnresolvedReferences
+import vtkmodules.vtkRenderingOpenGL2
+from vtkmodules.vtkCommonColor import vtkNamedColors
+from vtkmodules.vtkCommonDataModel import vtkMultiBlockDataSet
+from vtkmodules.vtkFiltersSources import vtkSphereSource
+from vtkmodules.vtkRenderingCore import (
+    vtkActor,
+    vtkCompositeDataDisplayAttributes,
+    vtkCompositePolyDataMapper,
+    vtkRenderWindow,
+    vtkRenderWindowInteractor,
+    vtkRenderer
+)
+
+
+def main():
+    colors = vtkNamedColors()
+
+    # Create Sphere 1.
+    sphere1 = vtkSphereSource(radius=3, center=(0, 0, 0))
+    sphere1.update()
+
+    # Create Sphere 2.
+    sphere2 = vtkSphereSource(radius=2, center=(2, 0, 0))
+    sphere2.update()
+
+    # Leave block 1 as NULL.  NULL blocks are valid and should be handled by
+    # algorithms that process multiblock datasets.  Especially when
+    # running in parallel where the blocks are owned by other processes.
+    mbds = vtkMultiBlockDataSet(number_of_blocks=3)
+    mbds.SetBlock(0, sphere1.output)
+    mbds.SetBlock(2, sphere2.output)
+
+    # You can use the vtkCompositeDataDisplayAttributes to set the color,
+    # opacity and visibiliy of individual blocks of the multiblock dataset.
+    # Attributes are mapped by block pointers (vtkDataObject*), so these can
+    # be queried by their flat index through a convenience function in the
+    # attribute class (vtkCompositeDataDisplayAttributes::DataObjectFromIndex).
+    # Alternatively, one can set attributes directly through the mapper using
+    # flat indices.
+    cdsa = vtkCompositeDataDisplayAttributes()
+    mapper = vtkCompositePolyDataMapper(composite_data_display_attributes=cdsa)
+    mbds >> mapper
+
+    # This sets the block at flat index 3 red
+    # Note that the index is the flat index in the tree, so the whole multiblock
+    # is index 0 and the blocks are flat indexes 1, 2 and 3.  This affects
+    # the block returned by mbds.GetBlock(2).
+    mapper.SetBlockColor(3, colors.GetColor3d('Red'))
+    # Color the spheres.
+    mapper.SetBlockColor(1, colors.GetColor3d('LavenderBlush'))
+    mapper.SetBlockColor(2, colors.GetColor3d('Lavender'))
+
+    actor = vtkActor()
+    actor.SetMapper(mapper)
+
+    # Create the Renderer, RenderWindow, and RenderWindowInteractor.
+    renderer = vtkRenderer(background=colors.GetColor3d('SteelBlue'))
+    render_window = vtkRenderWindow(window_name='CompositePolyDataMapper')
+    render_window.AddRenderer(renderer)
+    render_window_interactor = vtkRenderWindowInteractor()
+    render_window_interactor.render_window = render_window
+
+    # Enable user interface interactor.
+    renderer.AddActor(actor)
+    render_window.Render()
+    render_window_interactor.Start()
+
+
+if __name__ == '__main__':
+    main()
diff --git a/src/PythonicAPI/GeometricObjects/ConvexPointSet.md b/src/PythonicAPI/GeometricObjects/ConvexPointSet.md
new file mode 100644
index 0000000000000000000000000000000000000000..0835cd205eb01115be0991e73bf102187c92367a
--- /dev/null
+++ b/src/PythonicAPI/GeometricObjects/ConvexPointSet.md
@@ -0,0 +1,7 @@
+### Description
+
+vtkConvexPointSet object represents a 3D cell defined by a convex set of points. An example of such a cell is an
+octant (from an octree).
+
+vtkConvexPointSet uses the ordered triangulations approach (vtkOrderedTriangulator) to create triangulations guaranteed
+to be compatible across shared faces.
diff --git a/src/PythonicAPI/GeometricObjects/ConvexPointSet.py b/src/PythonicAPI/GeometricObjects/ConvexPointSet.py
new file mode 100755
index 0000000000000000000000000000000000000000..f60c6e41985ade76ac2243176656336dbb4a393e
--- /dev/null
+++ b/src/PythonicAPI/GeometricObjects/ConvexPointSet.py
@@ -0,0 +1,92 @@
+# !/usr/bin/env python3
+
+# noinspection PyUnresolvedReferences
+import vtkmodules.vtkInteractionStyle
+# noinspection PyUnresolvedReferences
+import vtkmodules.vtkRenderingOpenGL2
+from vtkmodules.vtkCommonColor import vtkNamedColors
+from vtkmodules.vtkCommonCore import vtkPoints
+from vtkmodules.vtkCommonDataModel import (
+    vtkConvexPointSet,
+    vtkPolyData,
+    vtkUnstructuredGrid
+)
+from vtkmodules.vtkFiltersSources import vtkSphereSource
+from vtkmodules.vtkRenderingCore import (
+    vtkActor,
+    vtkDataSetMapper,
+    vtkGlyph3DMapper,
+    vtkRenderWindow,
+    vtkRenderWindowInteractor,
+    vtkRenderer
+)
+
+
+def main():
+    cps = vtkConvexPointSet()
+    points = vtkPoints()
+    points.InsertNextPoint(0, 0, 0)
+    points.InsertNextPoint(1, 0, 0)
+    points.InsertNextPoint(1, 1, 0)
+    points.InsertNextPoint(0, 1, 0)
+    points.InsertNextPoint(0, 0, 1)
+    points.InsertNextPoint(1, 0, 1)
+    points.InsertNextPoint(1, 1, 1)
+    points.InsertNextPoint(0, 1, 1)
+    points.InsertNextPoint(0.5, 0, 0)
+    points.InsertNextPoint(1, 0.5, 0)
+    points.InsertNextPoint(0.5, 1, 0)
+    points.InsertNextPoint(0, 0.5, 0)
+    points.InsertNextPoint(0.5, 0.5, 0)
+
+    for i in range(0, 13):
+        cps.GetPointIds().InsertId(i, i)
+
+    ug = vtkUnstructuredGrid(points=points)
+    ug.Allocate(1, 1)
+    ug.InsertNextCell(cps.GetCellType(), cps.GetPointIds())
+
+    colors = vtkNamedColors()
+
+    mapper = vtkDataSetMapper()
+    ug >> mapper
+
+    actor = vtkActor(mapper=mapper)
+    actor.property.color = colors.GetColor3d("Tomato")
+    actor.property.line_width = 3
+    actor.property.edge_visibility = True
+
+    # Glyph the points
+    sphere = vtkSphereSource(radius=0.03, phi_resolution=21, theta_resolution=21)
+
+    # Create a polydata to store everything in
+    poly_data = vtkPolyData(points=points)
+
+    point_mapper = vtkGlyph3DMapper(input_data=poly_data, source_data=sphere.update().output)
+
+    point_actor = vtkActor(mapper=point_mapper)
+    point_actor.property.color = colors.GetColor3d('Peacock')
+
+    # Create a renderer, render window, and interactor.
+    renderer = vtkRenderer(background=colors.GetColor3d('Silver'))
+    render_window = vtkRenderWindow(size=(640, 480), window_name='ConvexPointSet')
+    render_window.AddRenderer(renderer)
+    render_window_interactor = vtkRenderWindowInteractor()
+    render_window_interactor.render_window = render_window
+
+    # Add the actors to the scene
+    renderer.AddActor(actor)
+    renderer.AddActor(point_actor)
+
+    renderer.ResetCamera()
+    renderer.active_camera.Azimuth(210)
+    renderer.active_camera.Elevation(30)
+    renderer.ResetCameraClippingRange()
+
+    # Render and interact
+    render_window.Render()
+    render_window_interactor.Start()
+
+
+if __name__ == '__main__':
+    main()
diff --git a/src/PythonicAPI/Graphs/LabelVerticesAndEdges.md b/src/PythonicAPI/Graphs/LabelVerticesAndEdges.md
new file mode 100644
index 0000000000000000000000000000000000000000..2c69f422e210040194910139ff45e49f1af41e40
--- /dev/null
+++ b/src/PythonicAPI/Graphs/LabelVerticesAndEdges.md
@@ -0,0 +1,3 @@
+### Description
+
+This example sets and displays labels of vertices and edges of a graph.
diff --git a/src/PythonicAPI/Graphs/LabelVerticesAndEdges.py b/src/PythonicAPI/Graphs/LabelVerticesAndEdges.py
new file mode 100755
index 0000000000000000000000000000000000000000..766aba0604fab530ab1c2fbbcad9438755edbf91
--- /dev/null
+++ b/src/PythonicAPI/Graphs/LabelVerticesAndEdges.py
@@ -0,0 +1,67 @@
+#!/usr/bin/env python3
+
+# noinspection PyUnresolvedReferences
+import vtkmodules.vtkInteractionStyle
+# noinspection PyUnresolvedReferences
+import vtkmodules.vtkRenderingOpenGL2
+from vtkmodules.vtkCommonColor import vtkNamedColors
+from vtkmodules.vtkCommonCore import (
+    vtkDoubleArray,
+    vtkIntArray
+)
+from vtkmodules.vtkCommonDataModel import vtkMutableUndirectedGraph
+from vtkmodules.vtkInfovisLayout import vtkCircularLayoutStrategy
+from vtkmodules.vtkViewsInfovis import vtkGraphLayoutView
+
+
+def main():
+    colors = vtkNamedColors()
+
+    g = vtkMutableUndirectedGraph()
+
+    # Create 3 vertices.
+    v1 = g.AddVertex()
+    v2 = g.AddVertex()
+    v3 = g.AddVertex()
+
+    # Create a fully connected graph.
+    g.AddEdge(v1, v2)
+    g.AddEdge(v2, v3)
+    g.AddEdge(v1, v3)
+
+    # Create the edge weight array.
+    weights = vtkDoubleArray(number_of_components=1, name='Weights')
+
+    # Set the edge weights
+    weights.InsertNextValue(1.0)
+    weights.InsertNextValue(1.0)
+    weights.InsertNextValue(2.0)
+
+    # Create an array for the vertex labels.
+    vertex_ids = vtkIntArray(number_of_components=1, name='VertexIDs')
+
+    # Set the vertex labels.
+    vertex_ids.InsertNextValue(0)
+    vertex_ids.InsertNextValue(1)
+    vertex_ids.InsertNextValue(2)
+
+    # Add the edge weight array to the graph.
+    g.GetEdgeData().AddArray(weights)
+    g.GetVertexData().AddArray(vertex_ids)
+
+    circular_layout_strategy = vtkCircularLayoutStrategy()
+
+    graph_layout_view = vtkGraphLayoutView(layout_strategy=circular_layout_strategy,
+                                           vertex_label_visibility=True, edge_label_visibility=True,
+                                           edge_label_array_name='Weights', vertex_label_array_name='VertexIDs')
+    graph_layout_view.AddRepresentationFromInput(g)
+    graph_layout_view.GetRepresentation().vertex_label_text_property.color = colors.GetColor3d('Yellow')
+    graph_layout_view.GetRepresentation().edge_label_text_property.color = colors.GetColor3d('Lime')
+    graph_layout_view.ResetCamera()
+    graph_layout_view.Render()
+    graph_layout_view.render_window.window_name = 'LabelVerticesAndEdges'
+    graph_layout_view.interactor.Start()
+
+
+if __name__ == '__main__':
+    main()
diff --git a/src/PythonicAPI/ImplicitFunctions/BooleanOperationImplicitFunctions.py b/src/PythonicAPI/ImplicitFunctions/BooleanOperationImplicitFunctions.py
index 860c55533b6d1199bb19fe49322da45dd463d8aa..52bd481a5187aa422b355ad54049fee77833a4c6 100755
--- a/src/PythonicAPI/ImplicitFunctions/BooleanOperationImplicitFunctions.py
+++ b/src/PythonicAPI/ImplicitFunctions/BooleanOperationImplicitFunctions.py
@@ -32,7 +32,7 @@ def main():
 
     # Combine the two implicit functions.
     # You can also experiment with operation types of VTK_UNION or VTK_INTERSECTION.
-    boolean = vtkImplicitBoolean(operation_type=vtkImplicitBoolean().VTK_DIFFERENCE)
+    boolean = vtkImplicitBoolean(operation_type=vtkImplicitBoolean.VTK_DIFFERENCE)
     boolean.AddFunction(box)
     boolean.AddFunction(sphere)
 
diff --git a/src/PythonicAPI/Modelling/ContourTriangulator.py b/src/PythonicAPI/Modelling/ContourTriangulator.py
new file mode 100755
index 0000000000000000000000000000000000000000..b8de830483df1f700576f2431ac9ca7223ed8bfb
--- /dev/null
+++ b/src/PythonicAPI/Modelling/ContourTriangulator.py
@@ -0,0 +1,85 @@
+#!/usr/bin/env python3
+
+
+# noinspection PyUnresolvedReferences
+import vtkmodules.vtkInteractionStyle
+# noinspection PyUnresolvedReferences
+import vtkmodules.vtkRenderingOpenGL2
+from vtkmodules.vtkCommonColor import vtkNamedColors
+from vtkmodules.vtkFiltersCore import vtkMarchingSquares
+from vtkmodules.vtkFiltersGeneral import vtkContourTriangulator
+from vtkmodules.vtkIOImage import vtkPNGReader
+from vtkmodules.vtkRenderingCore import (
+    vtkActor,
+    vtkDataSetMapper,
+    vtkRenderWindow,
+    vtkRenderWindowInteractor,
+    vtkRenderer
+)
+
+
+def get_program_parameters():
+    import argparse
+    description = 'Create a contour from a structured point set (image) and triangulate it.'
+    epilogue = '''
+    Try with different iso values e.g. -i1000.
+    '''
+    parser = argparse.ArgumentParser(description=description, epilog=epilogue)
+    parser.add_argument('file_name', help='The path to the image file to use e.g fullhead15.png.')
+    parser.add_argument('-i', '--iso_value', help='The contour value for generating the isoline.', default=500,
+                        type=int)
+    args = parser.parse_args()
+    return args.file_name, args.iso_value
+
+
+def main():
+    file_name, iso_value = get_program_parameters()
+
+    colors = vtkNamedColors()
+
+    reader = vtkPNGReader(file_name=file_name)
+    if not reader.CanReadFile(file_name):
+        print('Error: Could not read', file_name)
+        return
+
+    iso = vtkMarchingSquares(value=(0, iso_value))
+    reader >> iso
+
+    iso_mapper = vtkDataSetMapper(scalar_visibility=False)
+    iso >> iso_mapper
+
+    iso_actor = vtkActor(mapper=iso_mapper)
+    iso_actor.property.color = colors.GetColor3d('MediumOrchid')
+
+    poly = vtkContourTriangulator()
+
+    poly_mapper = vtkDataSetMapper(scalar_visibility=False)
+    poly_mapper.SetInputConnection(poly.GetOutputPort())
+    iso >> poly >> poly_mapper
+
+    poly_actor = vtkActor(mapper=poly_mapper)
+    poly_actor.property.color = colors.GetColor3d('Gray')
+
+    # Standard rendering classes.
+    renderer = vtkRenderer(background=colors.GetColor3d('DarkSlateGray'))
+    ren_win = vtkRenderWindow(size=(300, 300), window_name='ContourTriangulator',
+                              multi_samples=0)
+    ren_win.AddRenderer(renderer)
+
+    iren = vtkRenderWindowInteractor()
+    iren.render_window = ren_win
+
+    renderer.AddActor(poly_actor)
+    renderer.AddActor(iso_actor)
+
+    camera = renderer.active_camera
+    renderer.ResetCamera()
+    camera.Azimuth(180)
+
+    ren_win.Render()
+    iren.Initialize()
+    iren.Start()
+
+
+if __name__ == '__main__':
+    main()
diff --git a/src/PythonicAPI/Modelling/DiscreteFlyingEdges3D.py b/src/PythonicAPI/Modelling/DiscreteFlyingEdges3D.py
index a828fd899960cdc738386735bb0212105f12d6dd..a9758790c51b3b4ae3164a478710a0d3f4c19147 100755
--- a/src/PythonicAPI/Modelling/DiscreteFlyingEdges3D.py
+++ b/src/PythonicAPI/Modelling/DiscreteFlyingEdges3D.py
@@ -54,7 +54,7 @@ def main():
     ren_win = vtkRenderWindow(window_name='DiscreteMarchingCubes')
     ren_win.AddRenderer(ren)
     iren = vtkRenderWindowInteractor()
-    iren.SetRenderWindow(ren_win)
+    iren.render_window = ren_win
 
     n = 20
     radius = 8
diff --git a/src/PythonicAPI/Modelling/SmoothDiscreteFlyingEdges3D.py b/src/PythonicAPI/Modelling/SmoothDiscreteFlyingEdges3D.py
index 5556a4cc6c86f980affbbba6502e44c6cc04ae33..66f4daa2c4d95f7c3f465ea63da9497762077a70 100755
--- a/src/PythonicAPI/Modelling/SmoothDiscreteFlyingEdges3D.py
+++ b/src/PythonicAPI/Modelling/SmoothDiscreteFlyingEdges3D.py
@@ -57,7 +57,7 @@ def main():
     ren_win.AddRenderer(ren)
 
     iren = vtkRenderWindowInteractor()
-    iren.SetRenderWindow(ren_win)
+    iren.render_window = ren_win
 
     n = 20
     radius = 8
diff --git a/src/PythonicAPI/Plotting/SurfacePlot.py b/src/PythonicAPI/Plotting/SurfacePlot.py
new file mode 100755
index 0000000000000000000000000000000000000000..03de7d32803b8774d7b72fbf2da0558b6a286b0c
--- /dev/null
+++ b/src/PythonicAPI/Plotting/SurfacePlot.py
@@ -0,0 +1,88 @@
+#!/usr/bin/env python3
+
+from math import sin, sqrt
+
+# noinspection PyUnresolvedReferences
+import vtkmodules.vtkInteractionStyle
+# noinspection PyUnresolvedReferences
+import vtkmodules.vtkRenderingContextOpenGL2
+# noinspection PyUnresolvedReferences
+import vtkmodules.vtkRenderingOpenGL2
+from vtkmodules.vtkChartsCore import (
+    vtkChartXYZ,
+    vtkPlotSurface
+)
+from vtkmodules.vtkCommonColor import vtkNamedColors
+from vtkmodules.vtkCommonCore import vtkFloatArray
+from vtkmodules.vtkCommonDataModel import (
+    vtkRectf,
+    vtkTable,
+    vtkVector2i
+)
+from vtkmodules.vtkRenderingContext2D import vtkContextMouseEvent
+from vtkmodules.vtkViewsContext2D import vtkContextView
+
+
+def main():
+    colors = vtkNamedColors()
+
+    geometry = vtkRectf(10.0, 10.0, 630, 470)
+    chart = vtkChartXYZ(geometry=geometry)
+    # chart.SetGeometry(vtkRectf(10.0, 10.0, 630, 470))
+
+    view = vtkContextView()
+    view.renderer.background = colors.GetColor3d("Silver")
+    view.render_window.size = (640, 480)
+    view.scene.AddItem(chart)
+
+    # Create a surface
+    table = vtkTable()
+    num_points = 70
+    inc = 9.424778 / (num_points - 1)
+    for i in range(num_points):
+        arr = vtkFloatArray()
+        table.AddColumn(arr)
+
+    table.SetNumberOfRows(num_points)
+    for i in range(num_points):
+        x = i * inc
+        for j in range(num_points):
+            y = j * inc
+            table.SetValue(i, j, sin(sqrt(x * x + y * y)))
+
+    # Set up the surface plot we wish to visualize and add it to the chart
+    plot = vtkPlotSurface(x_range=(0, 9.424778), y_range=(0, 9.424778))
+    plot.SetInputData(table)
+    plot.GetPen().SetColorF(colors.GetColor3d("Tomato"))
+    chart.AddPlot(plot)
+
+    view.render_window.multi_samples = 0
+    view.interactor.Initialize()
+    view.render_window.window_name = 'SurfacePlot'
+    view.render_window.Render()
+
+    # Rotate
+    mouse_event = vtkContextMouseEvent()
+    mouse_event.interactor = view.interactor
+
+    pos = vtkVector2i()
+    last_pos = vtkVector2i()
+
+    mouse_event.button = vtkContextMouseEvent.LEFT_BUTTON
+    last_pos.Set(100, 50)
+    mouse_event.SetLastScreenPos(last_pos)
+    pos.Set(150, 100)
+    mouse_event.SetScreenPos(pos)
+
+    s_p = [float(x) for x in pos]
+    l_sp = [float(x) for x in last_pos]
+    screen_pos = mouse_event.screen_pos
+    last_screen_pos = mouse_event.last_screen_pos
+
+    chart.MouseMoveEvent(mouse_event)
+
+    view.GetInteractor().Start()
+
+
+if __name__ == '__main__':
+    main()
diff --git a/src/PythonicAPI/PolyData/SmoothMeshGrid.py b/src/PythonicAPI/PolyData/SmoothMeshGrid.py
index 8681b096b23af0ae6e6d62b166eee0f2a15601af..01d4fc0c5b0ab7ea37146b84bc9bb0fd15f7e94e 100755
--- a/src/PythonicAPI/PolyData/SmoothMeshGrid.py
+++ b/src/PythonicAPI/PolyData/SmoothMeshGrid.py
@@ -138,7 +138,7 @@ def main():
 
     render_window = vtkRenderWindow(size=(900, 300))
     render_window_interactor = vtkRenderWindowInteractor()
-    render_window_interactor.SetRenderWindow(render_window)
+    render_window_interactor.render_window = render_window
 
     text = {0: 'Initial Terrain', 1: 'Loop Subdivision', 2: 'Butterfly Subdivision'}
 
@@ -151,7 +151,8 @@ def main():
     # Build the renderers and add them to the render window.
     renderers = list()
     for k in text.keys():
-        renderers.append(vtkRenderer(background=nc.GetColor3d('Cornsilk')))
+        renderers.append(vtkRenderer(background=nc.GetColor3d('Cornsilk'),
+                                     viewport=viewports[k]))
 
         # Add the actors.
         if k == 0:
@@ -167,7 +168,6 @@ def main():
         else:
             renderers[k].SetActiveCamera(camera)
 
-        renderers[k].SetViewport(*viewports[k])
         renderers[k].ResetCamera()
         camera.Zoom(1.2)
 
diff --git a/src/PythonicAPI/Snippets/VTKDataClasses.md b/src/PythonicAPI/Snippets/VTKDataClasses.md
index 19c02aaf22b754ac1aa201cb88285d020cadb7c7..183946af975370cf4a1ef1bbf819cbae9cd54b32 100644
--- a/src/PythonicAPI/Snippets/VTKDataClasses.md
+++ b/src/PythonicAPI/Snippets/VTKDataClasses.md
@@ -102,7 +102,6 @@ class ColorTransferFunction:
         VTK_CTF_LINEAR: int = 0
         VTK_CTF_LOG10: int = 1
 
-
 ```
 
 ### ConnectivityFilter
@@ -119,7 +118,6 @@ class ConnectivityFilter:
         VTK_EXTRACT_ALL_REGIONS: int = 5
         VTK_EXTRACT_CLOSEST_POINT_REGION: int = 6
 
-
 ```
 
 ### Coordinate
@@ -138,7 +136,6 @@ class Coordinate:
         VTK_WORLD: int = 6
         VTK_USERDEFINED: int = 7
 
-
 ```
 
 ### Curvatures
@@ -153,7 +150,6 @@ class Curvatures:
         VTK_CURVATURE_MAXIMUM: int = 2
         VTK_CURVATURE_MINIMUM: int = 3
 
-
 ```
 
 ### Glyph3D
@@ -187,7 +183,6 @@ class Glyph3D:
         VTK_VECTOR_ROTATION_OFF: int = 2
         VTK_FOLLOW_CAMERA_DIRECTION: int = 3
 
-
 ```
 
 ### ImageCanvasSource2D
@@ -208,7 +203,6 @@ class ImageCanvasSource2D:
         VTK_FLOAT: int = 10
         VTK_DOUBLE: int = 11
 
-
 ```
 
 ### ImageCast
@@ -277,7 +271,6 @@ class ImageMathematics:
         VTK_COMPLEX_MULTIPLY: int = 19
         VTK_REPLACECBYK: int = 20
 
-
 ```
 
 ### LandmarkTransform
@@ -291,7 +284,6 @@ class LandmarkTransform:
         VTK_LANDMARK_SIMILARITY: int = 7
         VTK_LANDMARK_AFFINE: int = 12
 
-
 ```
 
 ### LookupTable
@@ -304,7 +296,6 @@ class LookupTable:
         VTK_SCALE_LINEAR: int = 0
         VTK_SCALE_LOG10: int = 1
 
-
 ```
 
 ### Mapper
@@ -333,7 +324,6 @@ class Mapper:
         VTK_SCALAR_MODE_USE_CELL_FIELD_DATA: int = 4
         VTK_SCALAR_MODE_USE_FIELD_DATA: int = 5
 
-
 ```
 
 ### Property
@@ -354,7 +344,6 @@ class Property:
         VTK_WIREFRAME: int = 1
         VTK_SURFACE: int = 2
 
-
 ```
 
 ### SpiderPlotActor
@@ -367,7 +356,6 @@ class SpiderPlotActor:
         VTK_IV_COLUMN: int = 0
         VTK_IV_ROW: int = 1
 
-
 ```
 
 ### TextProperty
@@ -387,7 +375,6 @@ class TextProperty:
         VTK_TEXT_CENTERED: int = 1
         VTK_TEXT_TOP: int = 2
 
-
 ```
 
 ### Texture
@@ -407,7 +394,6 @@ class Texture:
         VTK_COLOR_MODE_MAP_SCALARS: int = 1
         VTK_COLOR_MODE_DIRECT_SCALARS: int = 2
 
-
 ```
 
 ### VolumeProperty
@@ -434,4 +420,4 @@ class WindowToImageFilter:
         VTK_RGBA: int = 4
         VTK_ZBUFFER: int = 5
 
-```
\ No newline at end of file
+```
diff --git a/src/PythonicAPI/Visualization/CollisionDetection.md b/src/PythonicAPI/Visualization/CollisionDetection.md
new file mode 100644
index 0000000000000000000000000000000000000000..2defa2a82ecd5a568ccddae83bcc256d9266a644
--- /dev/null
+++ b/src/PythonicAPI/Visualization/CollisionDetection.md
@@ -0,0 +1,13 @@
+### Description
+
+This examples uses vtkCollisionDetectionFilter to find the intersection between a fixed (solid white) and moving (red wireframe) sphere. The animation places the moving sphere some distance from the fixed sphere and moves the moving sphere until it contacts the fixed sphere.
+
+Three collision modes are available and can be set as the first argument on the command line.
+
+1. All contacts (0) finds all the contacting cell pairs with two points per collision.
+2. First contact (1) quickly find the first contact point.
+3. Half contacts (2) finds all the contacting cell pairs with one points per collision.
+
+The animation pauses between each frame. The total animation should be 3 seconds.
+
+Three videos on the [VTK Examples Project](https://www.youtube.com/watch?v=baumvJCFmSY&list=PLim3Sl9kwFYJASyM9cKFvQ-Sw343CSic-&index=3) youtube playlist show each of the collision modes.
diff --git a/src/PythonicAPI/Visualization/CollisionDetection.py b/src/PythonicAPI/Visualization/CollisionDetection.py
new file mode 100755
index 0000000000000000000000000000000000000000..fe6b1756b3100b1d12230cddb98ad7df897203bb
--- /dev/null
+++ b/src/PythonicAPI/Visualization/CollisionDetection.py
@@ -0,0 +1,288 @@
+#!/usr/bin/env python3
+
+import time
+from dataclasses import dataclass
+
+# noinspection PyUnresolvedReferences
+import vtkmodules.vtkInteractionStyle
+# noinspection PyUnresolvedReferences
+import vtkmodules.vtkRenderingFreeType
+# noinspection PyUnresolvedReferences
+import vtkmodules.vtkRenderingOpenGL2
+from vtkmodules.vtkCommonColor import vtkNamedColors
+from vtkmodules.vtkCommonMath import vtkMatrix4x4
+from vtkmodules.vtkCommonTransforms import vtkTransform
+from vtkmodules.vtkFiltersModeling import vtkCollisionDetectionFilter
+from vtkmodules.vtkFiltersSources import vtkSphereSource
+from vtkmodules.vtkInteractionWidgets import (
+    vtkTextRepresentation,
+    vtkTextWidget
+)
+from vtkmodules.vtkRenderingCore import (
+    vtkActor,
+    vtkPolyDataMapper,
+    vtkRenderWindow,
+    vtkRenderWindowInteractor,
+    vtkRenderer,
+    vtkTextActor,
+    vtkTextProperty
+)
+
+
+def get_program_parameters():
+    import argparse
+    description = 'Collision detection.'
+    epilogue = '''
+This examples uses vtkCollisionDetectionFilter to find the intersection between a
+ fixed (solid white) and moving (red wireframe) sphere.
+The animation places the moving sphere some distance from the fixed sphere and
+ moves the moving sphere until it contacts the fixed sphere.
+
+Three collision modes are available and can be set as the first argument on the command line.
+
+1. All contacts (0) finds all the contacting cell pairs with two points per collision.
+2. First contact (1) quickly find the first contact point.
+3. Half contacts (2) finds all the contacting cell pairs with one points per collision.
+
+    '''
+    parser = argparse.ArgumentParser(description=description, epilog=epilogue,
+                                     formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument('contactMode', nargs='?', default=0, type=int, help='Contact mode 0 (default), 1, or 2.')
+    args = parser.parse_args()
+    return args.contactMode
+
+
+def main():
+    contact_mode = get_program_parameters()
+
+    # Define colors
+    colors = vtkNamedColors()
+
+    sphere0 = vtkSphereSource(radius=0.29, center=(0.0, 0, 0), phi_resolution=31, theta_resolution=31)
+
+    sphere1 = vtkSphereSource(radius=0.3, center=(0.0, 0, 0), phi_resolution=30, theta_resolution=30)
+
+    matrix1 = vtkMatrix4x4()
+    transform0 = vtkTransform()
+
+    collide = vtkCollisionDetectionFilter(transform=(0, transform0), matrix=(1, matrix1),
+                                          box_tolerance=0.0, cell_tolerance=0.0, number_of_cells_per_node=2)
+    collide.input_connection = (0, sphere0.GetOutputPort())
+    collide.input_connection = (1, sphere1.GetOutputPort())
+    if contact_mode == 0:
+        collide.collision_mode = vtkCollisionDetectionFilter.VTK_ALL_CONTACTS
+    elif contact_mode == 1:
+        collide.collision_mode = vtkCollisionDetectionFilter.VTK_FIRST_CONTACT
+    else:
+        collide.collision_mode = vtkCollisionDetectionFilter.VTK_HALF_CONTACTS
+
+    collide.GenerateScalarsOn()
+
+    # Visualize
+    mapper1 = vtkPolyDataMapper(scalar_visibility=False)
+    mapper1.input_connection = collide.GetOutputPort(0)
+    actor1 = vtkActor(mapper=mapper1, user_transform=transform0)
+    actor1.property.backface_culling = True
+    actor1.property.diffuse_color = colors.GetColor3d("Tomato")
+    actor1.property.representation = Property.Representation.VTK_WIREFRAME
+
+    mapper2 = vtkPolyDataMapper()
+    mapper2.input_connection = collide.GetOutputPort(1)
+    actor2 = vtkActor(mapper=mapper2, user_matrix=matrix1)
+    actor2.property.backface_culling = True
+
+    mapper3 = vtkPolyDataMapper(
+        resolve_coincident_topology=Mapper.ResolveCoincidentTopology.VTK_RESOLVE_POLYGON_OFFSET)
+    mapper3.input_connection = collide.GetContactsOutputPort()
+    actor3 = vtkActor(mapper=mapper3)
+    actor3.property.color = colors.GetColor3d("Black")
+    actor3.property.line_width = 3.0
+
+    renderer = vtkRenderer(background=colors.GetColor3d('Gray'))
+    renderer.UseHiddenLineRemovalOn()
+    renderer.AddActor(actor1)
+    renderer.AddActor(actor2)
+    renderer.AddActor(actor3)
+
+    render_window = vtkRenderWindow(size=(640, 480), window_name='CollisionDetection')
+    render_window.AddRenderer(renderer)
+
+    interactor = vtkRenderWindowInteractor()
+    interactor.SetRenderWindow(render_window)
+
+    # Move the first object
+    num_steps = 100
+    dx = 1.0 / float(num_steps) * 2.0
+    transform0.Translate(-num_steps * dx - .3, 0.0, 0.0)
+    render_window.Render()
+    renderer.GetActiveCamera().Azimuth(-60)
+    renderer.GetActiveCamera().Elevation(45)
+    renderer.GetActiveCamera().Dolly(1.2)
+
+    render_window.Render()
+
+    for i in range(0, num_steps):
+        transform0.Translate(dx, 0.0, 0.0)
+        renderer.ResetCameraClippingRange()
+        render_window.Render()
+        if collide.number_of_contacts > 0:
+            text_property = vtkTextProperty(color=colors.GetColor3d('White'), bold=True, italic=False, shadow=True,
+                                            font_size=16, justification=TextProperty.Justification.VTK_TEXT_CENTERED)
+
+            s = f'{collide.GetCollisionModeAsString()}, the number of contact cells is {collide.GetNumberOfContacts():d}'
+
+            text_positions = get_text_positions([s],
+                                                justification=TextProperty.Justification.VTK_TEXT_CENTERED,
+                                                width=0.5, height=0.1)
+            text_actor = vtkTextActor(input=s,
+                                      text_scale_mode=vtkTextActor.TEXT_SCALE_MODE_NONE,
+                                      text_property=text_property)
+
+            # Create the text representation. Used for positioning the text actor.
+            text_representation = vtkTextRepresentation(enforce_normalized_viewport_bounds=True)
+            text_representation.GetPositionCoordinate().value = text_positions[s]['p']
+            text_representation.GetPosition2Coordinate().value = text_positions[s]['p2']
+
+            # Create the text widget, setting the default renderer and interactor.
+            text_widget = vtkTextWidget(representation=text_representation, text_actor=text_actor,
+                                        default_renderer=renderer,
+                                        interactor=interactor, selectable=False)
+            text_widget.On()
+            break
+        # The total animation time is 3 seconds
+        time.sleep(3.0 / num_steps)
+
+    renderer.ResetCamera()
+    render_window.Render()
+    interactor.Start()
+    # In Field Data there will be an array named "ContactCells".
+    # This array indexes contacting cells (e.g.) index 10 of array 0
+    #  points to a cell (triangle) which contacts/intersects a cell
+    #  at index 10 of array 1.
+    # You can directly obtain these, see GetContactCells(int i)
+    #  in the documentation.
+    # print(collide.GetOutput(0))
+    # print(collide.GetOutput(1))
+
+
+def get_text_positions(names, justification=0, vertical_justification=0, width=0.96, height=0.1):
+    """
+    Get viewport positioning information for a list of names.
+
+    :param names: The list of names.
+    :param justification: Horizontal justification of the text, default is left.
+    :param vertical_justification: Vertical justification of the text, default is bottom.
+    :param width: Width of the bounding_box of the text in screen coordinates.
+    :param height: Height of the bounding_box of the text in screen coordinates.
+    :return: A list of positioning information.
+    """
+    # The gap between the left or right edge of the screen and the text.
+    dx = 0.02
+    width = abs(width)
+    if width > 0.96:
+        width = 0.96
+
+    y0 = 0.01
+    height = abs(height)
+    if height > 0.9:
+        height = 0.9
+    dy = height
+    if vertical_justification == TextProperty.VerticalJustification.VTK_TEXT_TOP:
+        y0 = 1.0 - (dy + y0)
+        dy = height
+    if vertical_justification == TextProperty.VerticalJustification.VTK_TEXT_CENTERED:
+        y0 = 0.5 - (dy / 2.0 + y0)
+        dy = height
+
+    name_len_min = 0
+    name_len_max = 0
+    first = True
+    for k in names:
+        sz = len(k)
+        if first:
+            name_len_min = name_len_max = sz
+            first = False
+        else:
+            name_len_min = min(name_len_min, sz)
+            name_len_max = max(name_len_max, sz)
+    text_positions = dict()
+    for k in names:
+        sz = len(k)
+        delta_sz = width * sz / name_len_max
+        if delta_sz > width:
+            delta_sz = width
+
+        if justification == TextProperty.Justification.VTK_TEXT_CENTERED:
+            x0 = 0.5 - delta_sz / 2.0
+        elif justification == TextProperty.Justification.VTK_TEXT_RIGHT:
+            x0 = 1.0 - dx - delta_sz
+        else:
+            # Default is left justification.
+            x0 = dx
+
+        # For debugging!
+        # print(
+        #     f'{k:16s}: (x0, y0) = ({x0:3.2f}, {y0:3.2f}), (x1, y1) = ({x0 + delta_sz:3.2f}, {y0 + dy:3.2f})'
+        #     f', width={delta_sz:3.2f}, height={dy:3.2f}')
+        text_positions[k] = {'p': [x0, y0, 0], 'p2': [delta_sz, dy, 0]}
+
+    return text_positions
+
+
+@dataclass(frozen=True)
+class Mapper:
+    @dataclass(frozen=True)
+    class ColorMode:
+        VTK_COLOR_MODE_DEFAULT: int = 0
+        VTK_COLOR_MODE_MAP_SCALARS: int = 1
+        VTK_COLOR_MODE_DIRECT_SCALARS: int = 2
+
+    @dataclass(frozen=True)
+    class ResolveCoincidentTopology:
+        VTK_RESOLVE_OFF: int = 0
+        VTK_RESOLVE_POLYGON_OFFSET: int = 1
+        VTK_RESOLVE_SHIFT_ZBUFFER: int = 2
+
+    @dataclass(frozen=True)
+    class ScalarMode:
+        VTK_SCALAR_MODE_DEFAULT: int = 0
+        VTK_SCALAR_MODE_USE_POINT_DATA: int = 1
+        VTK_SCALAR_MODE_USE_CELL_DATA: int = 2
+        VTK_SCALAR_MODE_USE_POINT_FIELD_DATA: int = 3
+        VTK_SCALAR_MODE_USE_CELL_FIELD_DATA: int = 4
+        VTK_SCALAR_MODE_USE_FIELD_DATA: int = 5
+
+
+@dataclass(frozen=True)
+class TextProperty:
+    @dataclass(frozen=True)
+    class Justification:
+        VTK_TEXT_LEFT: int = 0
+        VTK_TEXT_CENTERED: int = 1
+        VTK_TEXT_RIGHT: int = 2
+
+    @dataclass(frozen=True)
+    class VerticalJustification:
+        VTK_TEXT_BOTTOM: int = 0
+        VTK_TEXT_CENTERED: int = 1
+        VTK_TEXT_TOP: int = 2
+
+
+@dataclass(frozen=True)
+class Property:
+    @dataclass(frozen=True)
+    class Interpolation:
+        VTK_FLAT: int = 0
+        VTK_GOURAUD: int = 1
+        VTK_PHONG: int = 2
+        VTK_PBR: int = 3
+
+    @dataclass(frozen=True)
+    class Representation:
+        VTK_POINTS: int = 0
+        VTK_WIREFRAME: int = 1
+        VTK_SURFACE: int = 2
+
+
+if __name__ == '__main__':
+    main()
diff --git a/src/PythonicAPI/Visualization/ColoredAnnotatedCube.py b/src/PythonicAPI/Visualization/ColoredAnnotatedCube.py
index b5c9cbca6e1610093f2cc522212679e5c800565d..b80090976207eabe92cb3b72b9a1ea89c686d304 100644
--- a/src/PythonicAPI/Visualization/ColoredAnnotatedCube.py
+++ b/src/PythonicAPI/Visualization/ColoredAnnotatedCube.py
@@ -196,8 +196,8 @@ def make_axes_actor(scale, total_length, xyz_labels):
 
     # Set the font properties.
     tprop = axes.x_axis_caption_actor2d.caption_text_property
-    tprop.ItalicOn()
-    tprop.ShadowOn()
+    tprop.italic = True
+    tprop.shadow = True
     tprop.SetFontFamilyToTimes()
 
     # Use the same text properties on the other two axes.
diff --git a/src/PythonicAPI/Visualization/CubeAxesActor.py b/src/PythonicAPI/Visualization/CubeAxesActor.py
new file mode 100755
index 0000000000000000000000000000000000000000..c0d449558d70fea250bcf9bcb0dfe78a3ed50277
--- /dev/null
+++ b/src/PythonicAPI/Visualization/CubeAxesActor.py
@@ -0,0 +1,86 @@
+#!/usr/bin/env python
+
+# noinspection PyUnresolvedReferences
+import vtkmodules.vtkInteractionStyle
+# noinspection PyUnresolvedReferences
+import vtkmodules.vtkRenderingOpenGL2
+from vtkmodules.vtkCommonColor import vtkNamedColors
+from vtkmodules.vtkFiltersSources import vtkSuperquadricSource
+from vtkmodules.vtkRenderingAnnotation import vtkCubeAxesActor
+from vtkmodules.vtkRenderingCore import (
+    vtkActor,
+    vtkPolyDataMapper,
+    vtkRenderWindow,
+    vtkRenderWindowInteractor,
+    vtkRenderer
+)
+
+
+def main():
+    colors = vtkNamedColors()
+
+    background_color = colors.GetColor3d('DarkSlateGray')
+    actor_color = colors.GetColor3d('Tomato')
+    axis1_color = colors.GetColor3d('Salmon')
+    axis2_color = colors.GetColor3d('PaleGreen')
+    axis3_color = colors.GetColor3d('LightSkyBlue')
+
+    # Create a superquadric
+    superquadric_source = vtkSuperquadricSource(phi_roundness=3.1, theta_roundness=1.0)
+    superquadric_source.update()  # Needed to get the bounds later.
+
+    renderer = vtkRenderer(background=background_color)
+
+    mapper = vtkPolyDataMapper()
+    superquadric_source >> mapper
+
+    superquadric_actor = vtkActor(mapper=mapper)
+    superquadric_actor.property.diffuse_color = actor_color
+    superquadric_actor.property.diffuse = 0.7
+    superquadric_actor.property.specular = 0.7
+    superquadric_actor.property.specular_power = 50.0
+
+    cube_axes_actor = vtkCubeAxesActor(bounds=superquadric_source.output.bounds, camera=renderer.active_camera)
+    cube_axes_actor.use_text_actor_3D = True
+    cube_axes_actor.GetTitleTextProperty(0).color = axis1_color
+    cube_axes_actor.GetTitleTextProperty(0).font_size = 48
+    cube_axes_actor.GetLabelTextProperty(0).color = axis1_color
+
+    cube_axes_actor.GetTitleTextProperty(1).color = axis2_color
+    cube_axes_actor.GetLabelTextProperty(1).color = axis2_color
+
+    cube_axes_actor.GetTitleTextProperty(2).color = axis3_color
+    cube_axes_actor.GetLabelTextProperty(2).color = axis3_color
+
+    cube_axes_actor.draw_x_gridlines = True
+    cube_axes_actor.draw_y_gridlines = True
+    cube_axes_actor.draw_z_gridlines = True
+    cube_axes_actor.grid_line_location = vtkCubeAxesActor.VTK_GRID_LINES_FURTHEST
+
+    cube_axes_actor.x_axis_minor_tick_visibility = False
+    cube_axes_actor.y_axis_minor_tick_visibility = False
+    cube_axes_actor.z_axis_minor_tick_visibility = False
+
+    cube_axes_actor.fly_mode = vtkCubeAxesActor.VTK_FLY_STATIC_EDGES
+
+    renderer.AddActor(cube_axes_actor)
+    renderer.AddActor(superquadric_actor)
+    renderer.GetActiveCamera().Azimuth(30)
+    renderer.GetActiveCamera().Elevation(30)
+
+    renderer.ResetCamera()
+
+    render_window = vtkRenderWindow(size=(640, 480), window_name='CubeAxesActor')
+
+    render_window.AddRenderer(renderer)
+
+    render_window_interactor = vtkRenderWindowInteractor()
+    render_window_interactor.render_window = render_window
+
+    renderer.active_camera.Zoom(0.8)
+    render_window.Render()
+    render_window_interactor.Start()
+
+
+if __name__ == '__main__':
+    main()
diff --git a/src/PythonicAPI/Visualization/CurvaturesNormalsElevations.py b/src/PythonicAPI/Visualization/CurvaturesNormalsElevations.py
index 9fc4092b05c098588c4244d59c28a23438f2005c..7d901472c48b35a97261951c8578a6c2527428a9 100755
--- a/src/PythonicAPI/Visualization/CurvaturesNormalsElevations.py
+++ b/src/PythonicAPI/Visualization/CurvaturesNormalsElevations.py
@@ -146,7 +146,7 @@ def main(argv):
     iren = vtkRenderWindowInteractor()
     iren.SetRenderWindow(ren_win)
     style = vtkInteractorStyleTrackballCamera()
-    iren.SetInteractorStyle(style)
+    iren.interactor_style = style
 
     renderers = list()
     contour_widgets = dict()
diff --git a/src/PythonicAPI/Visualization/PointDataSubdivision.md b/src/PythonicAPI/Visualization/PointDataSubdivision.md
new file mode 100644
index 0000000000000000000000000000000000000000..5954ebd7b8d04c89f5b6ab1fddc510f98759c6fa
--- /dev/null
+++ b/src/PythonicAPI/Visualization/PointDataSubdivision.md
@@ -0,0 +1,22 @@
+### Description
+
+#### Introduction
+
+This example demonstrates the use of the vtkLinearSubdivisionFilter and vtkButterflySubdivisionFilter.
+
+In order to see the effects of these filters a triptych is created that demonstrates the effect of applying the filter.
+
+The user can select from a list of sources to render, specify whether normals are displayed, what type of shading to use and the number of normals to glyph.
+
+A representative set of sources to render are provided in the class called **Sources**. The user is encouraged to experiment with different sources to see the effect of the filters.
+
+#### Adding more sources.
+If you add more sources, you may need to provide one or all of these filters:
+
+- A vtkTriangleFilter
+- A vtkPolyDataNormals filter
+- A vtkElevationFilter.
+- A vtkCleanPolyData filter.
+- For parametric sources, you may need to apply one of both of **JoinUOff()** or **JoinVOff()**.
+
+The representative sources provided in the class **Sources** should provide good templates.
diff --git a/src/PythonicAPI/Visualization/PointDataSubdivision.py b/src/PythonicAPI/Visualization/PointDataSubdivision.py
new file mode 100755
index 0000000000000000000000000000000000000000..acf592e3a8b5fdf1790acac0bfa39f8a16335aa2
--- /dev/null
+++ b/src/PythonicAPI/Visualization/PointDataSubdivision.py
@@ -0,0 +1,663 @@
+#!/usr/bin/env python3
+
+from dataclasses import dataclass
+
+# noinspection PyUnresolvedReferences
+import vtkmodules.vtkInteractionStyle
+# noinspection PyUnresolvedReferences
+import vtkmodules.vtkRenderingOpenGL2
+from vtkmodules.vtkCommonColor import (
+    vtkColorSeries,
+    vtkNamedColors
+)
+from vtkmodules.vtkCommonComputationalGeometry import (
+    vtkParametricBoy,
+    vtkParametricEllipsoid,
+    vtkParametricMobius,
+    vtkParametricRandomHills,
+    vtkParametricTorus
+)
+from vtkmodules.vtkCommonDataModel import vtkColor3ub
+from vtkmodules.vtkFiltersCore import (
+    vtkCleanPolyData,
+    vtkElevationFilter,
+    vtkGlyph3D,
+    vtkMaskPoints,
+    vtkPolyDataNormals,
+    vtkTriangleFilter
+)
+from vtkmodules.vtkFiltersHybrid import vtkRenderLargeImage
+from vtkmodules.vtkFiltersModeling import (
+    vtkButterflySubdivisionFilter,
+    vtkLinearSubdivisionFilter
+)
+from vtkmodules.vtkFiltersSources import (
+    vtkArrowSource,
+    vtkConeSource,
+    vtkParametricFunctionSource,
+    vtkSphereSource,
+    vtkSuperquadricSource
+)
+from vtkmodules.vtkIOImage import vtkPNGWriter
+from vtkmodules.vtkInteractionStyle import vtkInteractorStyleTrackballCamera
+from vtkmodules.vtkInteractionWidgets import (
+    vtkOrientationMarkerWidget,
+    vtkTextRepresentation,
+    vtkTextWidget
+)
+from vtkmodules.vtkRenderingAnnotation import vtkAxesActor
+from vtkmodules.vtkRenderingCore import (
+    vtkActor,
+    vtkColorTransferFunction,
+    vtkDataSetMapper,
+    vtkPolyDataMapper,
+    vtkRenderWindow,
+    vtkRenderWindowInteractor,
+    vtkRenderer,
+    vtkTextActor,
+    vtkTextProperty
+)
+
+nc = vtkNamedColors()
+
+
+def get_program_parameters():
+    import argparse
+    description = 'Demonstrates point data subdivision with the glyphing of normals on the surface.'
+    epilogue = '''
+        This program takes a surface and displays three surfaces.
+
+        The first surface is the original surface and the second and third surfaces have
+         had linear and butterfly interpolation applied respectively.
+        The user can control the object to use, normals generation, type of shading
+         and number of points to use for the normals.
+    '''
+    parser = argparse.ArgumentParser(description=description, epilog=epilogue)
+    parser.add_argument('sourceToUse', help='The surface to use.', nargs='?', default='Boy')
+    parser.add_argument('-g', '--glyphPoints', help='Number of points to be used for glyphing.', nargs='?', default=50,
+                        type=int)
+    parser.add_argument('--no-normals', help='Do not display normals.', dest='displayNormals', action='store_false')
+    parser.add_argument('--no-gouraud', help='Use flat interpolation. Gouraud interpolation is used by default.',
+                        dest='gouraudInterpolation', action='store_false')
+    parser.set_defaults(displayNormals=True)
+    parser.set_defaults(gouraudInterpolation=True)
+    args = parser.parse_args()
+    return args.sourceToUse, args.displayNormals, args.gouraudInterpolation, args.glyphPoints
+
+
+class Sources:
+    """
+    This class acts as a storage vehicle for the various sources.
+
+    If you add more sources, you may need to provide one or all of these filters:
+     - A Triangle filter
+     - A Normal filter
+     - An elevation filter.
+     - A CleanPolyData filter.
+     - For parametric sources, we may need to apply one of both of JoinUOff() or JoinVOff().
+
+    Use the representative sources provided here as templates.
+    """
+
+    def __init__(self):
+        # If you add more sources update this dictionary.
+        self.sources = {'parametric torus': self.parametric_torus_source(),
+                        'parametric ellipsoid': self.ellipsoid_source(),
+                        'boy': self.boy_source(), 'sphere': self.sphere_source(), 'mobius': self.mobius_source(),
+                        'cone': self.cone_source(), 'random hills': self.parametric_random_hills(),
+                        'superquadric': self.superquadric_source()}
+
+    @staticmethod
+    def parametric_torus_source():
+        torus = vtkParametricTorus(join_u=False, join_v=False)
+        source = vtkParametricFunctionSource(parametric_function=torus)
+        source.SetScalarModeToZ()
+        return source
+
+    @staticmethod
+    def ellipsoid_source():
+        ellipsoid = vtkParametricEllipsoid(x_radius=0.5, y_radius=1.0, z_radius=2.0,
+                                           join_u=False, join_v=False)
+        source = vtkParametricFunctionSource(parametric_function=ellipsoid)  #
+        source.SetScalarModeToZ()
+        return source
+
+    @staticmethod
+    def boy_source():
+        boy = vtkParametricBoy(join_u=False, join_v=False)
+        source = vtkParametricFunctionSource(parametric_function=boy)
+        source.SetScalarModeToZ()
+        return source
+
+    @staticmethod
+    def mobius_source():
+        mobius = vtkParametricMobius(radius=2.0, minimum_v=-0.5, maximum_v=0.5,
+                                     join_u=False, join_v=False)
+        source = vtkParametricFunctionSource(parametric_function=mobius)
+        source.SetScalarModeToX()
+        return source
+
+    @staticmethod
+    def parametric_random_hills():
+        random_hills = vtkParametricRandomHills(random_seed=1, number_of_hills=30)
+        source = vtkParametricFunctionSource(parametric_function=random_hills,
+                                             u_resolution=10, v_resolution=10)
+        source.SetScalarModeToZ()
+        return source
+
+    @staticmethod
+    def sphere_source():
+        sphere = vtkSphereSource(phi_resolution=11, theta_resolution=11)
+        sphere_bounds = sphere.update().output.bounds
+
+        elev = vtkElevationFilter(low_point=(0, sphere_bounds[2], 0), high_point=(0, sphere_bounds[3], 0))
+        elev.SetInputConnection(sphere.GetOutputPort())
+        return sphere >> elev
+
+    @staticmethod
+    def superquadric_source():
+        """
+        Make a torus as the source.
+        """
+        source = vtkSuperquadricSource(center=(0.0, 0.0, 0.0), scale=(1.0, 1.0, 1.0),
+                                       phi_resolution=64, theta_resolution=64, theta_roundness=1.0,
+                                       size=10, toroidal=True)
+
+        # The quadric is made of strips, so pass it through a triangle filter as
+        # the curvature filter only operates on polys
+        tri = vtkTriangleFilter()
+
+        # The quadric has nasty discontinuities from the way the edges are generated
+        # so let's pass it though a CleanPolyDataFilter and merge any points which
+        # are coincident, or very close
+        cleaner = vtkCleanPolyData(tolerance=0.005)
+        source >> tri >> cleaner
+        cleaner_bounds = cleaner.update().output.bounds
+
+        elev = vtkElevationFilter(low_point=(0, cleaner_bounds[2], 0),
+                                  high_point=(0, cleaner_bounds[3], 0))
+        return cleaner >> elev
+
+    @staticmethod
+    def cone_source():
+        cone = vtkConeSource()
+        cone.SetResolution(6)
+        cone.CappingOn()
+        cone.Update()
+        coneBounds = cone.GetOutput().GetBounds()
+
+        coneNormals = vtkPolyDataNormals()
+        coneNormals.SetInputConnection(cone.GetOutputPort())
+
+        elev = vtkElevationFilter()
+        elev.SetInputConnection(coneNormals.GetOutputPort())
+        elev.SetLowPoint(coneBounds[0], 0, 0)
+        elev.SetHighPoint(coneBounds[1], 0, 0)
+
+        # vtkButterflySubdivisionFilter and vtkLinearSubdivisionFilter operate on triangles.
+        tf = vtkTriangleFilter()
+        tf.SetInputConnection(elev.GetOutputPort())
+        tf.Update()
+        return tf
+
+
+def make_lut(scalarRange):
+    """
+    Make a lookup table using a predefined color series.
+
+    :param scalarRange: The range of the scalars to be coloured.
+    :return:  A lookup table.
+    """
+    color_series = vtkColorSeries()
+    # Select a color scheme.
+    # for i in range(0,62):
+    #     color_series.SetColorScheme(i)
+    #     s = f'Colour scheme {color_series.GetColorScheme():2d}: {color_series.GetColorSchemeName():s}'
+    #     print(s)
+
+    # Colour scheme 61: Brewer Qualitative Set3
+    color_series.color_scheme = 61
+    # We use this colour series to create the transfer function.
+    lut = vtkColorTransferFunction()
+    lut.SetColorSpaceToHSV()
+    num_colors = color_series.GetNumberOfColors()
+    for i in range(0, num_colors):
+        color = vtkColor3ub(color_series.GetColor(i))
+        c = list()
+        for j in range(0, 3):
+            c.append(color[j] / 255.0)
+        t = scalarRange[0] + (scalarRange[1] - scalarRange[0]) / (num_colors - 1) * i
+        lut.AddRGBPoint(t, *c)
+    return lut
+
+
+def glyph_actor(source, glyph_points, scalar_range, scale_factor, lut):
+    """
+    Create the actor for glyphing the normals.
+
+    :param: source: the surface.
+    :param: glyph_points: The number of points used by the mask filter.
+    :param: scalar_range: The range in terms of scalar minimum and maximum.
+    :param: scale_factor: The scaling factor for the glyph.
+    :param: lut: The lookup table to use.
+
+    :return: The glyph actor.
+    """
+    arrow_source = vtkArrowSource()
+    # Subsample the dataset.
+    mask_pts = vtkMaskPoints(random_mode=True,
+                             on_ratio=source.update().output.number_of_points // glyph_points)
+    source >> mask_pts
+
+    arrow_glyph = vtkGlyph3D(source_connection=arrow_source.output_port,
+                             scale_factor=scale_factor,
+                             vector_mode=Glyph3D.VectorMode.VTK_USE_NORMAL,
+                             color_mode=Glyph3D.ColorMode.VTK_COLOR_BY_SCALAR,
+                             scale_mode=Glyph3D.ScaleMode.VTK_SCALE_BY_VECTOR,
+                             orient=True)
+
+    # Colour by scalars.
+    arrow_glyph_mapper = vtkDataSetMapper(scalar_range=scalar_range,
+                                          scalar_visibility=True, lookup_table=lut)
+    arrow_glyph_mapper.SetColorModeToMapScalars()
+    mask_pts >> arrow_glyph >> arrow_glyph_mapper
+
+    glyph_actor = vtkActor(mapper=arrow_glyph_mapper)
+    return glyph_actor
+
+
+def make_surface_actor(surface, scalar_range, lut):
+    """
+    Create the actor for a surface.
+
+    :param: surface: The surface.
+    :param: scalarRange: The range in terms of scalar minimum and maximum.
+    :param: lut: The lookup table to use.
+
+    :return: The actor for the surface.
+    """
+    mapper = vtkPolyDataMapper(lookup_table=lut, scalar_range=scalar_range)
+    surface >> mapper
+    mapper.SetColorModeToMapScalars()
+    mapper.ScalarVisibilityOn()
+    actor = vtkActor()
+    actor.SetMapper(mapper)
+    return actor
+
+
+def make_axes_actor():
+    """
+    Make an axis actor.
+
+    :return: The axis actor.
+    """
+    axes = vtkAxesActor(shaft_type=vtkAxesActor.CYLINDER_SHAFT, tip_type=vtkAxesActor.CONE_TIP,
+                        x_axis_label_text='X', y_axis_label_text='Y', z_axis_label_text='Z',
+                        total_length=(1.0, 1.0, 1.0))
+    axes.cylinder_radius = 1.0 * axes.cylinder_radius
+    axes.cone_radius = 1.75 * axes.cone_radius
+    axes.sphere_radius = 1.0 * axes.sphere_radius
+
+    # Set the font properties.
+    tprop = axes.x_axis_caption_actor2d.caption_text_property
+    tprop.ItalicOn()
+    tprop.ShadowOn()
+    tprop.SetFontFamilyToTimes()
+
+    # Use the same text properties on the other two axes.
+    axes.y_axis_caption_actor2d.caption_text_property.ShallowCopy(tprop)
+    axes.z_axis_caption_actor2d.caption_text_property.ShallowCopy(tprop)
+
+    # Now color the labels.
+    colors = vtkNamedColors()
+    axes.x_axis_caption_actor2d.caption_text_property.color = colors.GetColor3d('FireBrick')
+    axes.y_axis_caption_actor2d.caption_text_property.color = colors.GetColor3d('DarkGreen')
+    axes.z_axis_caption_actor2d.caption_text_property.color = colors.GetColor3d('DarkBlue')
+
+    return axes
+
+
+def make_orientation_marker(renderer, iren):
+    """
+    Create an orientation marker for a given renderer.
+
+    :param renderer: The renderer.
+    :param iren: The interactor.
+
+    :return: The orientation marker.
+    """
+    om = vtkOrientationMarkerWidget()
+    om.SetOrientationMarker(make_axes_actor())
+    # Position lower left in the viewport.
+    om.SetViewport(0, 0, 0.2, 0.2)
+    om.SetInteractor(iren)
+    om.SetDefaultRenderer(renderer)
+    om.EnabledOn()
+    om.InteractiveOn()
+    renderer.ResetCamera()
+    return om
+
+
+def get_text_positions(names, justification=0, vertical_justification=0, width=0.96, height=0.1):
+    """
+    Get viewport positioning information for a list of names.
+
+    :param names: The list of names.
+    :param justification: Horizontal justification of the text, default is left.
+    :param vertical_justification: Vertical justification of the text, default is bottom.
+    :param width: Width of the bounding_box of the text in screen coordinates.
+    :param height: Height of the bounding_box of the text in screen coordinates.
+    :return: A list of positioning information.
+    """
+    # The gap between the left or right edge of the screen and the text.
+    dx = 0.02
+    width = abs(width)
+    if width > 0.96:
+        width = 0.96
+
+    y0 = 0.01
+    height = abs(height)
+    if height > 0.9:
+        height = 0.9
+    dy = height
+    if vertical_justification == TextProperty.VerticalJustification.VTK_TEXT_TOP:
+        y0 = 1.0 - (dy + y0)
+        dy = height
+    if vertical_justification == TextProperty.VerticalJustification.VTK_TEXT_CENTERED:
+        y0 = 0.5 - (dy / 2.0 + y0)
+        dy = height
+
+    name_len_min = 0
+    name_len_max = 0
+    first = True
+    for k in names:
+        sz = len(k)
+        if first:
+            name_len_min = name_len_max = sz
+            first = False
+        else:
+            name_len_min = min(name_len_min, sz)
+            name_len_max = max(name_len_max, sz)
+    text_positions = dict()
+    for k in names:
+        sz = len(k)
+        delta_sz = width * sz / name_len_max
+        if delta_sz > width:
+            delta_sz = width
+
+        if justification == TextProperty.Justification.VTK_TEXT_CENTERED:
+            x0 = 0.5 - delta_sz / 2.0
+        elif justification == TextProperty.Justification.VTK_TEXT_RIGHT:
+            x0 = 1.0 - dx - delta_sz
+        else:
+            # Default is left justification.
+            x0 = dx
+
+        # For debugging!
+        # print(
+        #     f'{k:16s}: (x0, y0) = ({x0:3.2f}, {y0:3.2f}), (x1, y1) = ({x0 + delta_sz:3.2f}, {y0 + dy:3.2f})'
+        #     f', width={delta_sz:3.2f}, height={dy:3.2f}')
+        text_positions[k] = {'p': [x0, y0, 0], 'p2': [delta_sz, dy, 0]}
+
+    return text_positions
+
+
+def write_png(ren, fn, magnification=1):
+    """
+    Save the image as a PNG
+    :param: ren - the renderer.
+    :param: fn - the file name.
+    :param: magnification - the magnification, usually 1.
+    """
+    ren_lge_im = vtkRenderLargeImage(input=ren, magnification=magnification)
+    # ren_lge_im.SetInput(ren)
+    # ren_lge_im.SetMagnification(magnification)
+    img_writer = vtkPNGWriter(file_name=fn)
+    # img_writer.SetInputConnection(ren_lge_im.GetOutputPort())
+    ren_lge_im >> img_writer
+    # img_writer.SetFileName(fn)
+    img_writer.Write()
+
+
+def main():
+    def flat_interpolation():
+        for actor in actors:
+            actor.property.SetInterpolationToFlat()
+        ren_win.Render()
+
+    def gouraud_interpolation():
+        for actor in actors:
+            actor.property.SetInterpolationToGouraud()
+        ren_win.Render()
+
+    source_to_use, display_normals, use_gouraud_interpolation, glyph_points = get_program_parameters()
+
+    available_sources = ['boy', 'cone', 'parametric ellipsoid', 'mobius',
+                         'random hills', 'parametric torus', 'sphere', 'superquadric']
+    source_names = [available_sources[i].title() for i in range(0, len(available_sources))]
+    source_name = ' '.join(source_to_use.lower().replace('_', ' ').split())
+    if source_name.lower() not in available_sources:
+        print('Nonexistent surface:', source_name)
+        print('Available sources are:')
+        asl = sorted(available_sources)
+        asl = [asl[i].title() for i in range(0, len(asl))]
+        asl = [asl[i:i + 5] for i in range(0, len(asl), 5)]
+        for i in range(0, len(asl)):
+            s = ', '.join(asl[i])
+            if i < len(asl) - 1:
+                s += ','
+            print(f'   {s}')
+        print('If a name has spaces in it, delineate the name with quotes e.g. "random hills"')
+        return
+
+    src = Sources().sources[source_name]
+
+    # The size of the render window.
+    ren_win_x_size = 1200
+    ren_win_y_size = ren_win_x_size // 3
+    min_ren_win_dim = min(ren_win_x_size, ren_win_y_size)
+
+    src_pd = src.update().output
+    # [xMin, xMax, yMin, yMax, zMin, zMax]
+    bounds = src_pd.bounds
+    # Use this to scale the normal glyph.
+    scale_factor = min(map(lambda x, y: x - y, bounds[1::2], bounds[::2])) * 0.2
+    src_pd.point_data.GetScalars().SetName("Elevation")
+    scalar_range = src_pd.scalar_range
+
+    text = {0: 'Original', 1: 'Linear Subdivision', 2: 'Butterfly Subdivision'}
+
+    # Define viewport ranges [x_min, y_min, x_max, y_max]
+    viewports = {0: [0.0, 0.0, 1.0 / 3.0, 1.0],
+                 1: [1.0 / 3.0, 0.0, 2.0 / 3.0, 1.0],
+                 2: [2.0 / 3.0, 0.0, 1.0, 1.0]
+                 }
+
+    butterfly = vtkButterflySubdivisionFilter(number_of_subdivisions=3)
+    src >> butterfly
+
+    linear = vtkLinearSubdivisionFilter(number_of_subdivisions=3)
+    src >> linear
+
+    lut = make_lut(scalar_range)
+
+    # Make the actors.
+    actors = list()
+    actors.append(make_surface_actor(src, scalar_range, lut))
+    actors.append(make_surface_actor(linear, scalar_range, lut))
+    actors.append(make_surface_actor(butterfly, scalar_range, lut))
+
+    # Let's visualise the normals.
+    glyph_actors = list()
+    if display_normals:
+        glyph_actors.append(glyph_actor(src, glyph_points, scalar_range, scale_factor, lut))
+        glyph_actors.append(glyph_actor(linear, glyph_points, scalar_range, scale_factor, lut))
+        glyph_actors.append(glyph_actor(butterfly, glyph_points, scalar_range, scale_factor, lut))
+
+    ren_win = vtkRenderWindow(size=(ren_win_x_size, ren_win_y_size), window_name='PointDataSubdivision')
+    iren = vtkRenderWindowInteractor()
+    iren.render_window = ren_win
+
+    style = vtkInteractorStyleTrackballCamera()
+    iren.interactor_style = style
+
+    # Position the source name according to its length.
+    title = source_name.title()
+    title_positions = get_text_positions(source_names,
+                                         justification=TextProperty.Justification.VTK_TEXT_LEFT,
+                                         vertical_justification=TextProperty.VerticalJustification.VTK_TEXT_TOP,
+                                         width=0.65)
+
+    title_property = vtkTextProperty(color=nc.GetColor3d('Gold'), bold=True, italic=True, shadow=True,
+                                     font_size=16,
+                                     justification=TextProperty.Justification.VTK_TEXT_LEFT)
+    title_actor = vtkTextActor(input=title, text_scale_mode=vtkTextActor.TEXT_SCALE_MODE_NONE,
+                               text_property=title_property)
+    # Create the text representation. Used for positioning the text actor.
+    title_representation = vtkTextRepresentation(enforce_normalized_viewport_bounds=True)
+    title_representation.GetPositionCoordinate().value = title_positions[title]['p']
+    title_representation.GetPosition2Coordinate().value = title_positions[title]['p2']
+
+    text_property = vtkTextProperty(color=nc.GetColor3d('Gold'), bold=True, italic=False, shadow=False,
+                                    font_size=12, font_family_as_string='Courier',
+                                    justification=TextProperty.Justification.VTK_TEXT_CENTERED,
+                                    vertical_justification=TextProperty.VerticalJustification.VTK_TEXT_CENTERED)
+
+    text_positions = get_text_positions(list(text.values()), justification=TextProperty.Justification.VTK_TEXT_CENTERED,
+                                        vertical_justification=TextProperty.VerticalJustification.VTK_TEXT_BOTTOM,
+                                        width=0.6
+                                        )
+
+    # Build the renderers, orientation markers and text widgets
+    # adding them to the render window.
+    # Create the TextActors.
+    text_actors = list()
+    text_representations = list()
+    text_widgets = list()
+    om = list()
+    camera = None
+    for k in text.keys():
+        renderer = vtkRenderer(background=nc.GetColor3d('SlateGray'), viewport=viewports[k])
+
+        # Add the actors.
+        renderer.AddActor(actors[k])
+        if display_normals:
+            renderer.AddActor(glyph_actors[k])
+
+        if k == 0:
+            camera = renderer.active_camera
+        else:
+            renderer.active_camera = camera
+
+        renderer.ResetCamera()
+
+        ren_win.AddRenderer(renderer)
+
+        # Text actors.
+        label = text[k]
+        text_actors.append(
+            vtkTextActor(input=label, text_scale_mode=vtkTextActor.TEXT_SCALE_MODE_NONE, text_property=text_property))
+
+        # Create the text representation. Used for positioning the text actor.
+        text_representations.append(vtkTextRepresentation(enforce_normalized_viewport_bounds=True))
+        text_representations[k].GetPositionCoordinate().value = text_positions[label]['p']
+        text_representations[k].GetPosition2Coordinate().value = text_positions[label]['p2']
+
+        # Create the TextWidget for the subdivision names.
+        text_widgets.append(
+            vtkTextWidget(representation=text_representations[k], text_actor=text_actors[k],
+                          default_renderer=renderer, interactor=iren, selectable=False))
+
+        if k == 0:
+            # The title.
+            title_widget = vtkTextWidget(representation=title_representation, text_actor=title_actor,
+                                         default_renderer=renderer, interactor=iren, selectable=False)
+            title_widget.On()
+
+        # Orientation marker.
+        om.append(make_orientation_marker(renderer, iren))
+
+    if use_gouraud_interpolation:
+        gouraud_interpolation()
+    else:
+        flat_interpolation()
+
+    ren_win.Render()
+    for k in text.keys():
+        text_widgets[k].On()
+
+    iren.Initialize()
+    # write_png(iren.GetRenderWindow().GetRenderers().GetFirstRenderer(), 'TestPointDataSubdivision.png')
+    iren.Start()
+
+
+@dataclass(frozen=True)
+class Glyph3D:
+    @dataclass(frozen=True)
+    class ColorMode:
+        VTK_COLOR_BY_SCALE: int = 0
+        VTK_COLOR_BY_SCALAR: int = 1
+        VTK_COLOR_BY_VECTOR: int = 2
+
+    @dataclass(frozen=True)
+    class IndexMode:
+        VTK_INDEXING_OFF: int = 0
+        VTK_INDEXING_BY_SCALAR: int = 1
+        VTK_INDEXING_BY_VECTOR: int = 2
+
+    @dataclass(frozen=True)
+    class ScaleMode:
+        VTK_SCALE_BY_SCALAR: int = 0
+        VTK_SCALE_BY_VECTOR: int = 1
+        VTK_SCALE_BY_VECTORCOMPONENTS: int = 2
+        VTK_DATA_SCALING_OFF: int = 3
+
+    @dataclass(frozen=True)
+    class VectorMode:
+        VTK_USE_VECTOR: int = 0
+        VTK_USE_NORMAL: int = 1
+        VTK_VECTOR_ROTATION_OFF: int = 2
+        VTK_FOLLOW_CAMERA_DIRECTION: int = 3
+
+
+@dataclass(frozen=True)
+class Mapper:
+    @dataclass(frozen=True)
+    class ColorMode:
+        VTK_COLOR_MODE_DEFAULT: int = 0
+        VTK_COLOR_MODE_MAP_SCALARS: int = 1
+        VTK_COLOR_MODE_DIRECT_SCALARS: int = 2
+
+    @dataclass(frozen=True)
+    class ResolveCoincidentTopology:
+        VTK_RESOLVE_OFF: int = 0
+        VTK_RESOLVE_POLYGON_OFFSET: int = 1
+        VTK_RESOLVE_SHIFT_ZBUFFER: int = 2
+
+    @dataclass(frozen=True)
+    class ScalarMode:
+        VTK_SCALAR_MODE_DEFAULT: int = 0
+        VTK_SCALAR_MODE_USE_POINT_DATA: int = 1
+        VTK_SCALAR_MODE_USE_CELL_DATA: int = 2
+        VTK_SCALAR_MODE_USE_POINT_FIELD_DATA: int = 3
+        VTK_SCALAR_MODE_USE_CELL_FIELD_DATA: int = 4
+        VTK_SCALAR_MODE_USE_FIELD_DATA: int = 5
+
+
+@dataclass(frozen=True)
+class TextProperty:
+    @dataclass(frozen=True)
+    class Justification:
+        VTK_TEXT_LEFT: int = 0
+        VTK_TEXT_CENTERED: int = 1
+        VTK_TEXT_RIGHT: int = 2
+
+    @dataclass(frozen=True)
+    class VerticalJustification:
+        VTK_TEXT_BOTTOM: int = 0
+        VTK_TEXT_CENTERED: int = 1
+        VTK_TEXT_TOP: int = 2
+
+
+if __name__ == '__main__':
+    main()
diff --git a/src/PythonicAPI/VisualizationAlgorithms/IceCream.md b/src/PythonicAPI/VisualizationAlgorithms/IceCream.md
new file mode 100644
index 0000000000000000000000000000000000000000..fd16e35f8a29c4fd0c6c13213c7ba75f1d9a5036
--- /dev/null
+++ b/src/PythonicAPI/VisualizationAlgorithms/IceCream.md
@@ -0,0 +1,5 @@
+### Description
+This example demonstrates how to use boolean combinations of implicit functions to create a model of an ice cream cone.
+
+!!! info
+    See [Figure 6-23c](../../../VTKBook/06Chapter6/#Figure%206-23c) in [Chapter 6](../../../VTKBook/06Chapter6) the [VTK Textbook](../../../VTKBook/01Chapter1).
diff --git a/src/PythonicAPI/VisualizationAlgorithms/IceCream.py b/src/PythonicAPI/VisualizationAlgorithms/IceCream.py
new file mode 100755
index 0000000000000000000000000000000000000000..ddc1995cd73a68dbebd024a5f2c6a7a44cf37241
--- /dev/null
+++ b/src/PythonicAPI/VisualizationAlgorithms/IceCream.py
@@ -0,0 +1,118 @@
+#!/usr/bin/env python3
+
+
+"""
+This example demonstrates how to use boolean combinations of implicit
+ functions to create a model of an ice cream cone.
+
+"""
+# noinspection PyUnresolvedReferences
+import vtkmodules.vtkInteractionStyle
+# noinspection PyUnresolvedReferences
+import vtkmodules.vtkRenderingOpenGL2
+from vtkmodules.vtkCommonColor import vtkNamedColors
+from vtkmodules.vtkCommonDataModel import (
+    vtkCone,
+    vtkImplicitBoolean,
+    vtkPlane,
+    vtkSphere
+)
+from vtkmodules.vtkFiltersCore import vtkContourFilter
+from vtkmodules.vtkImagingHybrid import vtkSampleFunction
+from vtkmodules.vtkRenderingCore import (
+    vtkActor,
+    vtkPolyDataMapper,
+    vtkRenderWindow,
+    vtkRenderWindowInteractor,
+    vtkRenderer
+)
+
+
+def main():
+    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
+    # cone.
+    #
+    cone = vtkCone(angle=20)
+    vert_plane = vtkPlane(origin=(0.1, 0, 0), normal=(-1, 0, 0))
+    base_plane = vtkPlane(origin=(1.2, 0, 0), normal=(1, 0, 0))
+    ice_cream = vtkSphere(center=(1.333, 0, 0), radius=0.5)
+    bite = vtkSphere(center=(1.5, 0, 0.5), radius=0.25)
+
+    # Combine primitives to build ice-cream cone. Clip the cone with planes.
+    the_cone = vtkImplicitBoolean(operation_type=vtkImplicitBoolean.VTK_INTERSECTION)
+    the_cone.AddFunction(cone)
+    the_cone.AddFunction(vert_plane)
+    the_cone.AddFunction(base_plane)
+
+    # Take a bite out of the ice cream.
+    the_cream = vtkImplicitBoolean(operation_type=vtkImplicitBoolean.VTK_DIFFERENCE)
+    the_cream.AddFunction(ice_cream)
+    the_cream.AddFunction(bite)
+
+    # The sample function generates a distance function from the
+    # implicit function (which in this case is the cone). This is
+    # then contoured to get a polygonal surface.
+    #
+    the_cone_sample = vtkSampleFunction(implicit_function=the_cone,
+                                        model_bounds=(-1, 1.5, -1.25, 1.25, -1.25, 1.25),
+                                        sample_dimensions=(128, 128, 128),
+                                        compute_normals=False)
+
+    the_cone_surface = vtkContourFilter(value=(0, 0.0))
+
+    cone_mapper = vtkPolyDataMapper(scalar_visibility=False)
+    the_cone_sample >> the_cone_surface >> cone_mapper
+
+    cone_actor = vtkActor(mapper=cone_mapper)
+    cone_actor.property.color = colors.GetColor3d('Chocolate')
+
+    # The same here for the ice cream.
+    #
+    the_cream_sample = vtkSampleFunction(implicit_function=the_cream,
+                                         model_bounds=(0, 2.5, -1.25, 1.25, -1.25, 1.25),
+                                         sample_dimensions=(128, 128, 128),
+                                         compute_normals=False)
+
+    the_cream_surface = vtkContourFilter(value=(0, 0.0))
+
+    cream_mapper = vtkPolyDataMapper(scalar_visibility=False)
+    the_cream_sample >> the_cream_surface >> cream_mapper
+
+    cream_actor = vtkActor(mapper=cream_mapper)
+    cream_actor.property.diffuse_color = colors.GetColor3d('Mint')
+    cream_actor.property.specular = 0.6
+    cream_actor.property.specular_power = 50
+
+    # Create the usual rendering stuff.
+    #
+    ren = vtkRenderer(background=colors.GetColor3d('SlateGray'))
+    ren_win = vtkRenderWindow(size=(640, 480), window_name='IceCream')
+    ren_win.AddRenderer(ren)
+
+    iren = vtkRenderWindowInteractor()
+    iren.render_window = ren_win
+
+    # Add the actors to the renderer, set the background and size.
+    #
+    ren.AddActor(cone_actor)
+    ren.AddActor(cream_actor)
+
+    ren.ResetCamera()
+    ren.active_camera.Roll(90)
+    ren.active_camera.Dolly(1.25)
+    ren.ResetCameraClippingRange()
+    iren.Initialize()
+
+    # Render the image.
+    #
+    ren_win.Render()
+    iren.Start()
+
+
+if __name__ == '__main__':
+    main()
diff --git a/src/PythonicAPI/Widgets/CompassWidget.md b/src/PythonicAPI/Widgets/CompassWidget.md
new file mode 100644
index 0000000000000000000000000000000000000000..55b97d1053963ccb66aca7dd2d3a8dad737c5e0d
--- /dev/null
+++ b/src/PythonicAPI/Widgets/CompassWidget.md
@@ -0,0 +1,5 @@
+### Description
+
+This example creates a compass widget in the top right corner of the window. The widget can be used to modify the camera position via its distance and tilt sliders and its heading compass wheel.
+
+Note for this example to work correctly VTK with version >= 9.2.20220831 is required.
diff --git a/src/PythonicAPI/Widgets/CompassWidget.py b/src/PythonicAPI/Widgets/CompassWidget.py
new file mode 100755
index 0000000000000000000000000000000000000000..298f636e50a8fb7c4890668ce381d5c385782c7b
--- /dev/null
+++ b/src/PythonicAPI/Widgets/CompassWidget.py
@@ -0,0 +1,93 @@
+#!/usr/bin/env python3
+
+import math
+
+# noinspection PyUnresolvedReferences
+import vtkmodules.vtkInteractionStyle
+# noinspection PyUnresolvedReferences
+import vtkmodules.vtkRenderingOpenGL2
+from vtkmodules.vtkCommonColor import vtkNamedColors
+from vtkmodules.vtkCommonCore import (
+    vtkCommand,
+    vtkMath
+)
+from vtkmodules.vtkInteractionWidgets import (
+    vtkCompassRepresentation,
+    vtkCompassWidget
+)
+from vtkmodules.vtkRenderingAnnotation import vtkAnnotatedCubeActor
+from vtkmodules.vtkRenderingCore import (
+    vtkRenderWindow,
+    vtkRenderWindowInteractor,
+    vtkRenderer
+)
+
+
+def compass_widget_value_changed_callback(widget, event):
+    """
+    Callback to set the camera position according to the position parameters given by the vtkCompassWidget.
+    """
+    try:
+        camera = widget.GetCurrentRenderer().GetActiveCamera()
+    except AttributeError:
+        return
+
+    # calculate new camera position from compass widget parameters
+    distance = widget.distance
+    tilt = vtkMath.RadiansFromDegrees(widget.tilt)
+    heading = vtkMath.RadiansFromDegrees(widget.heading)
+
+    x = distance * math.cos(heading) * math.cos(tilt)
+    y = distance * math.sin(heading) * math.cos(tilt)
+    z = distance * math.sin(tilt)
+
+    camera.position = (x, y, z)
+    camera.focal_point = (0, 0, 0)
+    camera.view_up = (0, 0, 1)
+    camera.clipping_range = (0.1, distance + 1)
+
+    widget.current_renderer.Render()
+
+
+def main():
+    colors = vtkNamedColors()
+
+    actor = vtkAnnotatedCubeActor()
+    actor.cube_property.color = colors.GetColor3d('PeachPuff')
+
+    renderer = vtkRenderer()
+    render_window = vtkRenderWindow()
+    render_window.AddRenderer(renderer)
+
+    render_window_interactor = vtkRenderWindowInteractor()
+    render_window_interactor.render_window = render_window
+
+    # Create the widget and its representation.
+    compass_representation = vtkCompassRepresentation(minimum_distance=2, maximum_distance=10)
+
+    compass_widget = vtkCompassWidget(interactor=render_window_interactor, representation=compass_representation,
+                                      distance=5, tilt_speed=45, distance_speed=2,
+                                      default_renderer=renderer)
+
+    # Add a callback to update the camera position on vtkCommand::WidgetValueChangedEvent.
+    compass_widget.AddObserver(vtkCommand.WidgetValueChangedEvent, compass_widget_value_changed_callback)
+
+    renderer.AddActor(actor)
+    renderer.SetBackground(colors.GetColor3d('MidnightBlue'))
+
+    render_window.SetSize(640, 480)
+    render_window.SetWindowName('CompassWidget')
+
+    render_window.Render()
+    compass_widget.EnabledOn()
+
+    # No interactor style - camera is moved by widget callback.
+    render_window_interactor.interactor_style = None
+    # Set camera to the initial position.
+    compass_widget.InvokeEvent(vtkCommand.WidgetValueChangedEvent)
+
+    render_window_interactor.Start()
+
+
+if __name__ == '__main__':
+    main()
diff --git a/src/PythonicAPI/Widgets/ContourWidget.md b/src/PythonicAPI/Widgets/ContourWidget.md
new file mode 100644
index 0000000000000000000000000000000000000000..568b1f49e6f00da1bbab9f24f5d11bb674bcc55e
--- /dev/null
+++ b/src/PythonicAPI/Widgets/ContourWidget.md
@@ -0,0 +1,3 @@
+### Description
+
+This example generates a set of points which lie on a circle, and the contour through these points. This contour can be interactively warped/modified by dragging the control points.
diff --git a/src/PythonicAPI/Widgets/ContourWidget.py b/src/PythonicAPI/Widgets/ContourWidget.py
new file mode 100755
index 0000000000000000000000000000000000000000..141c6b4c492acff2195a42494f4121380f18fd0f
--- /dev/null
+++ b/src/PythonicAPI/Widgets/ContourWidget.py
@@ -0,0 +1,77 @@
+#!/usr/bin/python3
+
+import math
+
+# noinspection PyUnresolvedReferences
+import vtkmodules.vtkInteractionStyle
+# noinspection PyUnresolvedReferences
+import vtkmodules.vtkRenderingOpenGL2
+from vtkmodules.vtkCommonColor import vtkNamedColors
+from vtkmodules.vtkCommonCore import (
+    vtkPoints
+)
+from vtkmodules.vtkCommonDataModel import (
+    vtkCellArray,
+    vtkPolyData
+)
+from vtkmodules.vtkInteractionWidgets import (
+    vtkContourWidget,
+    vtkOrientedGlyphContourRepresentation
+)
+from vtkmodules.vtkRenderingCore import (
+    vtkRenderWindow,
+    vtkRenderWindowInteractor,
+    vtkRenderer
+)
+
+
+def main():
+    colors = vtkNamedColors()
+
+    # colors.SetColor('bkg', [0.1, 0.2, 0.4, 1.0])
+
+    # Create the RenderWindow, Renderer and both Actors
+    renderer = vtkRenderer(background=colors.GetColor3d('MidnightBlue'))
+    render_window = vtkRenderWindow(size=(600, 600), window_name='ContourWidget')
+    render_window.AddRenderer(renderer)
+
+    interactor = vtkRenderWindowInteractor()
+    interactor.render_window = render_window
+
+    # Override the default representation for the contour widget to customize its look.
+    contour_rep = vtkOrientedGlyphContourRepresentation()
+    contour_rep.lines_property.color = colors.GetColor3d('Red')
+
+    contour_widget = vtkContourWidget(interactor=interactor, representation=contour_rep)
+    contour_widget.On()
+
+    # Generate a set of points arranged in a circle.
+    points = vtkPoints()
+
+    num_pts = 21
+    for i in range(0, num_pts):
+        angle = 2.0 * math.pi * i / 20.0
+        points.InsertPoint(i, 0.1 * math.cos(angle),
+                           0.1 * math.sin(angle), 0.0)
+        # lines.InsertNextCell(i)
+    vertex_indices = list(range(0, num_pts))
+    # Set the last vertex to 0; this means the last line segment will join the
+    # 19th point (vertices[19]) with the first one (vertices[0]), thus closing
+    # the circle.
+    vertex_indices.append(0)
+    lines = vtkCellArray()
+    lines.InsertNextCell(num_pts + 1, vertex_indices)
+
+    pd = vtkPolyData(points=points, lines=lines)
+
+    contour_widget.Initialize(pd, 1)
+    contour_widget.Render()
+    renderer.ResetCamera()
+    render_window.Render()
+
+    interactor.Initialize()
+    interactor.Start()
+
+
+if __name__ == '__main__':
+    main()
diff --git a/src/Testing/Baseline/Cxx/CompositeData/TestCompositePolyDataMapper.png b/src/Testing/Baseline/Cxx/CompositeData/TestCompositePolyDataMapper.png
index c85f5f98b2296b970f19e86e73cd4d21c7b66e01..e4d33c6a13337c598b1e309d8d4efb27e6a199c0 100644
--- a/src/Testing/Baseline/Cxx/CompositeData/TestCompositePolyDataMapper.png
+++ b/src/Testing/Baseline/Cxx/CompositeData/TestCompositePolyDataMapper.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:b20f275d496ce2abdc3e8582ec6c353ce8b722adc9354da7707d449b4be30d8a
-size 17676
+oid sha256:c1b0391439dc0846b326f0a5f646d8b476d44b745bd6328faca86ad627ee4b51
+size 16751
diff --git a/src/Testing/Baseline/Python/CompositeData/TestCompositePolyDataMapper.png b/src/Testing/Baseline/Python/CompositeData/TestCompositePolyDataMapper.png
index c85f5f98b2296b970f19e86e73cd4d21c7b66e01..e4d33c6a13337c598b1e309d8d4efb27e6a199c0 100644
--- a/src/Testing/Baseline/Python/CompositeData/TestCompositePolyDataMapper.png
+++ b/src/Testing/Baseline/Python/CompositeData/TestCompositePolyDataMapper.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:b20f275d496ce2abdc3e8582ec6c353ce8b722adc9354da7707d449b4be30d8a
-size 17676
+oid sha256:c1b0391439dc0846b326f0a5f646d8b476d44b745bd6328faca86ad627ee4b51
+size 16751
diff --git a/src/Testing/Baseline/PythonicAPI/CompositeData/TestCompositePolyDataMapper.png b/src/Testing/Baseline/PythonicAPI/CompositeData/TestCompositePolyDataMapper.png
new file mode 100644
index 0000000000000000000000000000000000000000..e4d33c6a13337c598b1e309d8d4efb27e6a199c0
--- /dev/null
+++ b/src/Testing/Baseline/PythonicAPI/CompositeData/TestCompositePolyDataMapper.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c1b0391439dc0846b326f0a5f646d8b476d44b745bd6328faca86ad627ee4b51
+size 16751
diff --git a/src/Testing/Baseline/PythonicAPI/GeometricObjects/TestConvexPointSet.png b/src/Testing/Baseline/PythonicAPI/GeometricObjects/TestConvexPointSet.png
new file mode 100644
index 0000000000000000000000000000000000000000..88ff92816e17c84d333f32c7c72735dcc55d0d52
--- /dev/null
+++ b/src/Testing/Baseline/PythonicAPI/GeometricObjects/TestConvexPointSet.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5ec122aa87d299478acc947ebe215c2a598876a370655eefb248b0fdab96bd55
+size 18590
diff --git a/src/Testing/Baseline/PythonicAPI/GeometricObjects/TestCubeAxesActor.png b/src/Testing/Baseline/PythonicAPI/GeometricObjects/TestCubeAxesActor.png
new file mode 100644
index 0000000000000000000000000000000000000000..67bd3b8c77cbff96953a6c65baa42e7d6e0c79ce
--- /dev/null
+++ b/src/Testing/Baseline/PythonicAPI/GeometricObjects/TestCubeAxesActor.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ec1cb9c733cd012bafd8615b22ce27bf88710ce3ae9ece6886f0a2b534e66da5
+size 79431
diff --git a/src/Testing/Baseline/PythonicAPI/Graphs/TestLabelVerticesAndEdges.png b/src/Testing/Baseline/PythonicAPI/Graphs/TestLabelVerticesAndEdges.png
new file mode 100644
index 0000000000000000000000000000000000000000..9d287db24d10c6d4cb6f4153d88fc076208df2e4
--- /dev/null
+++ b/src/Testing/Baseline/PythonicAPI/Graphs/TestLabelVerticesAndEdges.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5c5c83f282a3868d8010f2aeb05b9c80b0beb4b2aad9c7a06f46e77e7daf9d5e
+size 29546
diff --git a/src/Testing/Baseline/PythonicAPI/Modelling/TestContourTriangulator.png b/src/Testing/Baseline/PythonicAPI/Modelling/TestContourTriangulator.png
new file mode 100644
index 0000000000000000000000000000000000000000..4c5ec8c369afac9f3802947b8ddaf4b3b84b4f91
--- /dev/null
+++ b/src/Testing/Baseline/PythonicAPI/Modelling/TestContourTriangulator.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ddcaa40a72049a4fa9153e9c23aba5ac8931e224c8e8f0cad665ebdeae961369
+size 2947
diff --git a/src/Testing/Baseline/PythonicAPI/Plotting/TestSurfacePlot.png b/src/Testing/Baseline/PythonicAPI/Plotting/TestSurfacePlot.png
new file mode 100644
index 0000000000000000000000000000000000000000..91eb9089f50aaee708f9aae6488728ebcb4b5208
--- /dev/null
+++ b/src/Testing/Baseline/PythonicAPI/Plotting/TestSurfacePlot.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:758767fac6f3ff507e01c8aaa2ea1bdd6458cd938698162ec6d904c18d7a780c
+size 83716
diff --git a/src/Testing/Baseline/PythonicAPI/Visualization/TestCollisionDetection.png b/src/Testing/Baseline/PythonicAPI/Visualization/TestCollisionDetection.png
new file mode 100644
index 0000000000000000000000000000000000000000..7bf7f41ddca5ac5507c5ffe8d2d19362539c7dff
--- /dev/null
+++ b/src/Testing/Baseline/PythonicAPI/Visualization/TestCollisionDetection.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b5152a6653792b1f6085ee5a047970fcd6cd378ccfe7e29010f80c2d94c818eb
+size 80237
diff --git a/src/Testing/Baseline/PythonicAPI/Visualization/TestIceCream.png b/src/Testing/Baseline/PythonicAPI/Visualization/TestIceCream.png
new file mode 100644
index 0000000000000000000000000000000000000000..169942987fce0004735175f82c32fbc0ff4ac049
--- /dev/null
+++ b/src/Testing/Baseline/PythonicAPI/Visualization/TestIceCream.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:043afa82b75629a3d3d3431cfe54fbaad19674bff875bfbf6e29e978f52a3af9
+size 62189
diff --git a/src/Testing/Baseline/PythonicAPI/Visualization/TestPointDataSubdivision.png b/src/Testing/Baseline/PythonicAPI/Visualization/TestPointDataSubdivision.png
new file mode 100644
index 0000000000000000000000000000000000000000..a2fc8c341a68815575b731e187ec1237c25ff3de
--- /dev/null
+++ b/src/Testing/Baseline/PythonicAPI/Visualization/TestPointDataSubdivision.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:195185ab5e004e6a170c7d53e337ce779a5b4e82ee0281c6bee493417a1c30ce
+size 135355
diff --git a/src/Testing/Baseline/PythonicAPI/Widgets/TestCompassWidget.png b/src/Testing/Baseline/PythonicAPI/Widgets/TestCompassWidget.png
new file mode 100644
index 0000000000000000000000000000000000000000..ad88e04040e3355a19f8af003dd4a1c04c064a55
--- /dev/null
+++ b/src/Testing/Baseline/PythonicAPI/Widgets/TestCompassWidget.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7b94c7934cda526fb6ab87392e7a0247503186e1a2fb544e771be8865771f56d
+size 11600
diff --git a/src/Testing/Baseline/PythonicAPI/Widgets/TestContourWidget.png b/src/Testing/Baseline/PythonicAPI/Widgets/TestContourWidget.png
new file mode 100644
index 0000000000000000000000000000000000000000..8bc64c1b80510ef799197a2467444df0803accb7
--- /dev/null
+++ b/src/Testing/Baseline/PythonicAPI/Widgets/TestContourWidget.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f132f80656f903b1766f3b29b3d0613a82e34041a5b14982f2084c42c961978b
+size 8071