Adding more PolyData examples

src/PythonicAPI.md

@@ -121,6 +121,9 @@ This Python script, [SelectExamples](../PythonicAPI/Utilities/SelectExamples), w
 [ConnectivityFilter](/PythonicAPI/Filtering/ConnectivityFilter) | Color any dataset type based on connectivity.
 [Curvatures](/PythonicAPI/PolyData/Curvatures) | Compute Gaussian, and Mean Curvatures.
 [CurvaturesAdjustEdges](/PythonicAPI/PolyData/CurvaturesAdjustEdges) | Get the Gaussian and Mean curvatures of a surface with adjustments for edge effects.
+[ExtractPolyLinesFromPolyData](/Python/PolyData/ExtractPolyLinesFromPolyData) | Extract polylines from polydata.
+[ExtractSelection](/Python/PolyData/ExtractSelection) |Extract selected points.
+[ExtractSelectionCells](/Python/PolyData/ExtractSelectionCells) | Extract cell, select cell.
 [LineOnMesh](/PythonicAPI/DataManipulation/LineOnMesh) | Plot a spline on a terrain-like surface.
 [MeshLabelImageColor](/PythonicAPI/DataManipulation/MeshLabelImageColor) | Mesh a single label from a label image. Then smooth and color the vertices according to the displacement error introduced by the smoothing.
 [SmoothMeshGrid](/PythonicAPI/PolyData/SmoothMeshGrid) | Create a terrain with regularly spaced points and smooth it with ?vtkLoopSubdivisionFilter? and ?vtkButterflySubdivisionFilter?.

src/PythonicAPI/PolyData/ExtractPolyLinesFromPolyData.md

+### Description
+
+This example uses vtkCutter to create contour lines. It processes these lines with vtkStripper to create continuous poly lines. After exiting the example with the "e" key, the lines are printed.

src/PythonicAPI/PolyData/ExtractPolyLinesFromPolyData.py

+#!/usr/bin/env python3
+
+from dataclasses import dataclass
+
+# noinspection PyUnresolvedReferences
+import vtkmodules.vtkInteractionStyle
+# noinspection PyUnresolvedReferences
+import vtkmodules.vtkRenderingOpenGL2
+from vtkmodules.vtkCommonColor import vtkNamedColors
+from vtkmodules.vtkCommonCore import vtkIdList
+from vtkmodules.vtkCommonDataModel import vtkPlane
+from vtkmodules.vtkFiltersCore import (
+    vtkCutter,
+    vtkStripper
+)
+from vtkmodules.vtkFiltersSources import vtkSphereSource
+from vtkmodules.vtkRenderingCore import (
+    vtkActor,
+    vtkPolyDataMapper,
+    vtkRenderWindow,
+    vtkRenderWindowInteractor,
+    vtkRenderer
+)
+
+
+def main():
+    colors = vtkNamedColors()
+    line_color = colors.GetColor3d('peacock')
+    model_color = colors.GetColor3d('silver')
+    background_color = colors.GetColor3d('wheat')
+
+    model_source = vtkSphereSource()
+
+    plane = vtkPlane()
+
+    cutter = vtkCutter(cut_function=plane)
+    cutter.GenerateValues(10, -0.5, 0.5)
+
+    model_mapper = vtkPolyDataMapper()
+    model_source >> model_mapper
+
+    model = vtkActor(mapper=model_mapper)
+    model.property.diffuse_color = model_color
+    model.property.interpolation = Property.Interpolation.VTK_FLAT
+
+    stripper = vtkStripper(join_contiguous_segments=True)
+    stripper.JoinContiguousSegmentsOn()
+
+    lines_mapper = vtkPolyDataMapper()
+    model_source >> cutter >> stripper >> lines_mapper
+
+    lines = vtkActor(mapper=lines_mapper)
+    lines.property.diffuse_color = line_color
+    lines.property.line_width = 3.0
+
+    renderer = vtkRenderer(background=background_color)
+    render_window = vtkRenderWindow(size=(640, 480), window_name='ExtractPolyLinesFromPolyData')
+    render_window.AddRenderer(renderer)
+
+    interactor = vtkRenderWindowInteractor()
+    interactor.render_window = render_window
+
+    # Add the actors to the renderer.
+    renderer.AddActor(model)
+    renderer.AddActor(lines)
+    renderer.active_camera.Azimuth(-45)
+    renderer.active_camera.Elevation(-22.5)
+    renderer.ResetCamera()
+
+    # This starts the event loop and as a side effect causes an
+    # initial render.
+    render_window.Render()
+    interactor.Start()
+
+    # Extract the lines from the polydata.
+    number_of_lines = cutter.GetOutput().GetNumberOfLines()
+
+    print('-----------Lines without using vtkStripper')
+    print(f'There are {number_of_lines} lines in the polydata.')
+
+    number_of_lines = stripper.GetOutput().GetNumberOfLines()
+    points = stripper.GetOutput().GetPoints()
+    cells = stripper.GetOutput().GetLines()
+    cells.InitTraversal()
+
+    print('-----------Lines using vtkStripper')
+    print(f'There are {number_of_lines} lines in the polydata.')
+
+    indices = vtkIdList()
+    line_count = 0
+
+    while cells.GetNextCell(indices):
+        print(f'Line {line_count}:')
+        for i in range(indices.GetNumberOfIds()):
+            point = points.GetPoint(indices.GetId(i))
+            print(f'\t({point[0]:9.6f},{point[1]:9.6f}, {point[2]:9.6f})')
+        line_count += 1
+
+
+@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()

src/PythonicAPI/PolyData/ExtractSelection.md

+### Description
+
+This example creates 50 random points and extracts 10 of them (the points with ids 10-19).
+
+Also demonstrated is how to invert the selection.
+
+The three actors in the render window display from left to right:
+
+- all the points
+- the selected points
+- the points not selected.

src/PythonicAPI/PolyData/ExtractSelection.py

+#!/usr/bin/env python3
+
+# noinspection PyUnresolvedReferences
+import vtkmodules.vtkInteractionStyle
+# noinspection PyUnresolvedReferences
+import vtkmodules.vtkRenderingOpenGL2
+from vtkmodules.vtkCommonColor import vtkNamedColors
+from vtkmodules.vtkCommonCore import vtkIdTypeArray
+from vtkmodules.vtkCommonDataModel import (
+    vtkSelection,
+    vtkSelectionNode,
+    vtkUnstructuredGrid
+)
+from vtkmodules.vtkFiltersExtraction import vtkExtractSelection
+from vtkmodules.vtkFiltersSources import vtkPointSource
+from vtkmodules.vtkRenderingCore import (
+    vtkActor,
+    vtkCamera,
+    vtkDataSetMapper,
+    vtkProperty,
+    vtkRenderWindow,
+    vtkRenderWindowInteractor,
+    vtkRenderer
+)
+
+
+def main(argv):
+    colors = vtkNamedColors()
+
+    point_source = vtkPointSource(number_of_points=50)
+    point_source.update()
+
+    ids = vtkIdTypeArray(number_of_components=1)
+    # Set values.
+    for i in range(10, 20):
+        ids.InsertNextValue(i)
+
+    selection_node = vtkSelectionNode(selection_list=ids, field_type=vtkSelectionNode.POINT,
+                                      content_type=vtkSelectionNode.INDICES)
+
+    selection = vtkSelection()
+    selection.AddNode(selection_node)
+
+    extract_selection = vtkExtractSelection(input_data=(1, selection))
+    point_source.output >> extract_selection
+
+    # In selection.
+    selected = vtkUnstructuredGrid()
+    selected.ShallowCopy(extract_selection.update().output)
+
+    # Get points that are NOT in the selection.
+    selection_node.properties.Set(vtkSelectionNode().INVERSE(), 1)  # invert the selection.
+
+    not_selected = vtkUnstructuredGrid()
+    not_selected.ShallowCopy(extract_selection.update().output)
+
+    print(f'There are {point_source.output.number_of_points} input points.')
+    print(f'There are {selected.number_of_points} points and {selected.number_of_cells} cells in the selection.')
+    print(f'There are {not_selected.number_of_points} points'
+          f' and {not_selected.number_of_cells} cells NOT in the selection.')
+
+    property = vtkProperty()
+    property.color = colors.GetColor3d('MidnightBlue')
+    property.point_size = 5
+
+    input_mapper = vtkDataSetMapper()
+    point_source.output >> input_mapper
+    input_actor = vtkActor(mapper=input_mapper, property=property)
+
+    selected_mapper = vtkDataSetMapper()
+    selected >> selected_mapper
+    selected_actor = vtkActor(mapper=selected_mapper, property=property)
+
+    not_selected_mapper = vtkDataSetMapper()
+    not_selected >> not_selected_mapper
+    not_selected_actor = vtkActor(mapper=not_selected_mapper, property=property)
+
+    # There will be one render window.
+    render_window = vtkRenderWindow()
+    render_window.SetSize(900, 300)
+    render_window.SetWindowName('ExtractSelectedIds')
+
+    # And one interactor.
+    interactor = vtkRenderWindowInteractor()
+    interactor.SetRenderWindow(render_window)
+
+    # Define viewport ranges.
+    # (xmin, ymin, xmax, ymax)
+    left_viewport = (0.0, 0.0, 0.33, 1.0)
+    center_viewport = (0.33, 0.0, 0.66, 1.0)
+    right_viewport = (0.66, 0.0, 1.0, 1.0)
+
+    # Create a camera for all renderers.
+    camera = vtkCamera()
+
+    # Setup the renderers
+    left_renderer = vtkRenderer(background=colors.GetColor3d('BurlyWood'),
+                                viewport=left_viewport, active_camera=camera)
+    render_window.AddRenderer(left_renderer)
+
+    center_renderer = vtkRenderer(background=colors.GetColor3d('orchid_dark'),
+                                  viewport=center_viewport, active_camera=camera)
+    render_window.AddRenderer(center_renderer)
+
+    right_renderer = vtkRenderer(background=colors.GetColor3d('CornflowerBlue'),
+                                 viewport=right_viewport, active_camera=camera)
+    render_window.AddRenderer(right_renderer)
+
+    left_renderer.AddActor(input_actor)
+    center_renderer.AddActor(selected_actor)
+    right_renderer.AddActor(not_selected_actor)
+
+    left_renderer.ResetCamera()
+
+    render_window.Render()
+    interactor.Start()
+
+
+if __name__ == '__main__':
+    import sys
+
+    main(sys.argv)

src/PythonicAPI/PolyData/ExtractSelectionCells.py

+#!/usr/bin/env python
+
+"""
+converted from:
+ - http://www.org/Wiki/VTK/Examples/Cxx/PolyData/ExtractSelectionCells
+"""
+
+# noinspection PyUnresolvedReferences
+import vtkmodules.vtkInteractionStyle
+# noinspection PyUnresolvedReferences
+import vtkmodules.vtkRenderingOpenGL2
+from vtkmodules.vtkCommonColor import vtkNamedColors
+from vtkmodules.vtkCommonCore import vtkIdTypeArray
+from vtkmodules.vtkCommonDataModel import (
+    vtkSelection,
+    vtkSelectionNode,
+    vtkUnstructuredGrid
+)
+from vtkmodules.vtkFiltersExtraction import vtkExtractSelection
+from vtkmodules.vtkFiltersSources import vtkSphereSource
+from vtkmodules.vtkRenderingCore import (
+    vtkActor,
+    vtkCamera,
+    vtkDataSetMapper,
+    vtkProperty,
+    vtkRenderWindow,
+    vtkRenderWindowInteractor,
+    vtkRenderer
+)
+
+
+def main():
+    colors = vtkNamedColors()
+
+    # colors.SetColor('leftBkg', *(0.6, 0.5, 0.4, 1.0))
+    # colors.SetColor('centreBkg', *(0.3, 0.1, 0.4, 1.0))
+    # colors.SetColor('rightBkg', *(0.4, 0.5, 0.6, 1.0))
+
+    sphere_source = vtkSphereSource()
+    sphere_source.update()
+
+    ids = vtkIdTypeArray(number_of_components=1)
+    # Specify that we want to extract cells 10 through 19.
+    i = 10
+    while i < 20:
+        ids.InsertNextValue(i)
+        i += 1
+
+    selection_node = vtkSelectionNode(selection_list=ids, field_type=vtkSelectionNode.CELL,
+                                      content_type=vtkSelectionNode.INDICES)
+
+    selection = vtkSelection()
+    selection.AddNode(selection_node)
+
+    extract_selection = vtkExtractSelection(input_data=(1, selection))
+    sphere_source.output >> extract_selection
+
+    # In selection.
+    selected = vtkUnstructuredGrid()
+    selected.ShallowCopy(extract_selection.update().output)
+
+    # Get points that are NOT in the selection.
+    selection_node.properties.Set(vtkSelectionNode().INVERSE(), 1)  # invert the selection.
+    # extract_selection.update()
+
+    not_selected = vtkUnstructuredGrid()
+    not_selected.ShallowCopy(extract_selection.update().output)
+
+    print(f'There are {sphere_source.output.number_of_points}'
+          f' points and {sphere_source.output.number_of_cells} input cells.')
+    print(f'There are {selected.number_of_points} points and {selected.number_of_cells} cells in the selection.')
+    print(f'There are {not_selected.number_of_points} points'
+          f' and {not_selected.number_of_cells} cells NOT in the selection.')
+
+    property = vtkProperty()
+    property.color = colors.GetColor3d('MistyRose')
+    backfaces = vtkProperty()
+    backfaces.color = colors.GetColor3d('Gold')
+
+    input_mapper = vtkDataSetMapper()
+    sphere_source.output >> input_mapper
+    input_actor = vtkActor(mapper=input_mapper, property=property, backface_property=backfaces)
+
+    selected_mapper = vtkDataSetMapper()
+    selected >> selected_mapper
+    selected_actor = vtkActor(mapper=selected_mapper, property=property, backface_property=backfaces)
+
+    not_selected_mapper = vtkDataSetMapper()
+    not_selected >> not_selected_mapper
+    not_selected_actor = vtkActor(mapper=not_selected_mapper, property=property, backface_property=backfaces)
+
+    # There will be one render window
+    render_window = vtkRenderWindow()
+    render_window.SetSize(900, 300)
+    render_window.SetWindowName('ExtractSelectionCells')
+
+    # And one interactor
+    interactor = vtkRenderWindowInteractor()
+    interactor.SetRenderWindow(render_window)
+
+    # Define viewport ranges.
+    # (xmin, ymin, xmax, ymax)
+    left_viewport = (0.0, 0.0, 0.33, 1.0)
+    center_viewport = (0.33, 0.0, 0.66, 1.0)
+    right_viewport = (0.66, 0.0, 1.0, 1.0)
+
+    # Create a camera for all renderers
+    camera = vtkCamera()
+
+    # Setup the renderers.
+    left_renderer = vtkRenderer(background=colors.GetColor3d('BurlyWood'),
+                                viewport=left_viewport, active_camera=camera)
+    render_window.AddRenderer(left_renderer)
+
+    center_renderer = vtkRenderer(background=colors.GetColor3d('orchid_dark'),
+                                  viewport=center_viewport, active_camera=camera)
+    render_window.AddRenderer(center_renderer)
+
+    right_renderer = vtkRenderer(background=colors.GetColor3d('CornflowerBlue'),
+                                 viewport=right_viewport, active_camera=camera)
+    render_window.AddRenderer(right_renderer)
+
+    left_renderer.AddActor(input_actor)
+    center_renderer.AddActor(selected_actor)
+    right_renderer.AddActor(not_selected_actor)
+
+    left_renderer.ResetCamera()
+
+    render_window.Render()
+    interactor.Start()
+
+
+if __name__ == '__main__':
+    main()

src/PythonicAPI/Utilities/VTKDataClasses.py

@@ -173,6 +173,22 @@ class Mapper:
         VTK_SCALAR_MODE_USE_FIELD_DATA: int = 5
 
 
+@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
+
+
 @dataclass(frozen=True)
 class SpiderPlotActor:
     @dataclass(frozen=True)