Added ImageMask, ImageOpenClose3D

src/PythonicAPI.md

@@ -609,7 +609,9 @@ See [this tutorial](http://www.vtk.org/Wiki/VTK/Tutorials/3DDataTypes) for a bri
 [ImageCityBlockDistance](/PythonicAPI/Images/ImageCityBlockDistance) | Compute the Manhattan distance from every point to every black point in a binary image.
 [ImageGridSource](/PythonicAPI/Images/ImageGridSource) | Create a image of a grid.
 [ImageHistogram](/PythonicAPI/Images/ImageHistogram) | Compute the histogram of an image.
+[ImageMask](/PythonicAPI/Images/ImageMask) | Mask a region of an image.
 [ImageNonMaximumSuppression](/PythonicAPI/Images/ImageNonMaximumSuppression) | Find peaks in an image using non maximum suppression.
+[ImageOpenClose3D](/PythonicAPI/Images/ImageOpenClose3D) | Open or close (morphologically) an image.
 [MarkKeypoints](/PythonicAPI/Images/MarkKeypoints) | Mark keypoints in an image.
 
 

src/PythonicAPI/Images/ImageMask.md

+### Description
+
+This example creates an all red image. Then it creates a mask of a small rectangle. The red pixels in this rectangle are copied to the output image, while the rest of the output image is black. The black region could be set to a different color using SetMaskedOutputValue.

src/PythonicAPI/Images/ImageMask.py

+#!/usr/bin/env python3
+
+# noinspection PyUnresolvedReferences
+import vtkmodules.vtkInteractionStyle
+# noinspection PyUnresolvedReferences
+import vtkmodules.vtkRenderingOpenGL2
+from vtkmodules.util.execution_model import select_ports
+from vtkmodules.vtkCommonColor import vtkNamedColors
+from vtkmodules.vtkImagingCore import vtkImageMask
+from vtkmodules.vtkImagingSources import vtkImageCanvasSource2D
+from vtkmodules.vtkInteractionStyle import vtkInteractorStyleImage
+from vtkmodules.vtkRenderingCore import (
+    vtkImageActor,
+    vtkRenderer,
+    vtkRenderWindow,
+    vtkRenderWindowInteractor
+)
+
+
+def main():
+    colors = vtkNamedColors()
+
+    # Create an image of a rectangle.
+    source = vtkImageCanvasSource2D(extent=(0, 200, 0, 200, 0, 0), number_of_scalar_components=3)
+    source.SetScalarTypeToUnsignedChar()
+
+    # Create a red image.
+    source.draw_color = (255, 0, 0)
+    source.FillBox(0, 200, 0, 200)
+
+    # Create a rectangular mask.
+    mask_source = vtkImageCanvasSource2D(extent=(0, 200, 0, 200, 0, 0), number_of_scalar_components=1)
+    mask_source.SetScalarTypeToUnsignedChar()
+
+    # Initialize the mask to black.
+    mask_source.draw_color = (0, 0, 0)
+    mask_source.FillBox(0, 200, 0, 200)
+
+    # Create a square.
+    mask_source.draw_color = (255, 255, 255)
+    # Anything non-zero means 'make the output
+    # pixel equal the input pixel'. If the mask is
+    # zero, the output pixel is set to MaskedValue.
+    mask_source.FillBox(100, 120, 100, 120)
+
+    mask_filter = vtkImageMask(masked_output_value=(0, 1, 0))
+    source >> select_ports(0, mask_filter)
+    mask_source >> select_ports(1, mask_filter)
+
+    inverse_mask_filter = vtkImageMask(masked_output_value=(0, 1, 0), not_mask=True)
+    inverse_mask_filter.SetInputConnection(0, source.GetOutputPort())
+    inverse_mask_filter.SetInputConnection(1, mask_source.GetOutputPort())
+
+    # Create the actors.
+    original_actor = vtkImageActor()
+    source >> original_actor.mapper
+
+    mask_actor = vtkImageActor()
+    mask_source >> mask_actor.mapper
+
+    masked_actor = vtkImageActor()
+    mask_filter >> masked_actor.mapper
+
+    inverse_masked_actor = vtkImageActor()
+    inverse_mask_filter >> inverse_masked_actor.mapper
+
+    # Define the viewport ranges.(x_min, y_min, x_max, y_max).
+    original_viewport = (0.0, 0.0, 0.25, 1.0)
+    mask_viewport = (0.25, 0.0, 0.5, 1.0)
+    masked_viewport = (0.5, 0.0, 0.75, 1.0)
+    inverse_masked_viewport = (0.75, 0.0, 1.0, 1.0)
+
+    # Setup the renderers.
+    original_renderer = vtkRenderer(background=colors.GetColor3d('SandyBrown'))
+    original_renderer.viewport = original_viewport
+    original_renderer.AddActor(original_actor)
+    original_renderer.ResetCamera()
+
+    mask_renderer = vtkRenderer(viewport=mask_viewport, background=colors.GetColor3d('Peru'))
+    mask_renderer.AddActor(mask_actor)
+
+    masked_renderer = vtkRenderer(viewport=masked_viewport, background=colors.GetColor3d('SandyBrown'))
+    masked_renderer.AddActor(masked_actor)
+
+    inverse_masked_renderer = vtkRenderer(viewport=inverse_masked_viewport, background=colors.GetColor3d('Peru'))
+    inverse_masked_renderer.AddActor(inverse_masked_actor)
+
+    render_window = vtkRenderWindow(size=(1000, 250), window_name='ImageMask')
+    render_window.AddRenderer(original_renderer)
+    render_window.AddRenderer(mask_renderer)
+    render_window.AddRenderer(masked_renderer)
+    render_window.AddRenderer(inverse_masked_renderer)
+
+    render_window_interactor = vtkRenderWindowInteractor()
+    style = vtkInteractorStyleImage()
+
+    render_window_interactor.interactor_style = style
+
+    render_window_interactor.render_window = render_window
+    render_window.Render()
+    render_window_interactor.Initialize()
+
+    render_window_interactor.Start()
+
+
+if __name__ == '__main__':
+    main()

src/PythonicAPI/Images/ImageOpenClose3D.md

+### Description
+
+This example reads a binary image and performs opening on one value and closing on another (morphological operations).

src/PythonicAPI/Images/ImageOpenClose3D.py

+#!/usr/bin/env python3
+
+from pathlib import Path
+
+# noinspection PyUnresolvedReferences
+import vtkmodules.vtkInteractionStyle
+# noinspection PyUnresolvedReferences
+import vtkmodules.vtkRenderingOpenGL2
+from vtkmodules.vtkCommonColor import vtkNamedColors
+from vtkmodules.vtkIOImage import vtkImageReader2Factory, vtkPNGReader, vtkJPEGReader
+from vtkmodules.vtkImagingCore import vtkImageCast
+from vtkmodules.vtkImagingGeneral import vtkImageCityBlockDistance
+from vtkmodules.vtkImagingMorphological import vtkImageOpenClose3D
+from vtkmodules.vtkInteractionStyle import vtkInteractorStyleImage
+from vtkmodules.vtkRenderingCore import (
+    vtkImageActor,
+    vtkRenderer,
+    vtkRenderWindow,
+    vtkRenderWindowInteractor
+)
+
+
+def get_program_parameters():
+    import argparse
+    description = 'ImageOpenClose3D.'
+    epilogue = '''
+    '''
+    parser = argparse.ArgumentParser(description=description, epilog=epilogue,
+                                     formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument('file_name', help='The image file name to use e.g. Yinyang.png.')
+    args = parser.parse_args()
+    return args.file_name
+
+
+def main():
+    fn = get_program_parameters()
+    fp = Path(fn)
+    file_check = True
+    if not fp.is_file():
+        print(f'Missing image file: {fp}.')
+        file_check = False
+    if not file_check:
+        return
+
+    colors = vtkNamedColors()
+
+    # Read the image.
+    reader: vtkImageReader2Factory = vtkImageReader2Factory().CreateImageReader2(str(fp))
+    reader.file_name = fp
+
+    # Alternatively, use vtkPNGReader.
+    # reader = vtkPNGReader(file_name = fp)
+
+    reader.Update()
+
+    open_close = vtkImageOpenClose3D(open_value = 0,close_value = 255,kernel_size = (5, 5, 3),release_data_flag = False)
+    reader >> open_close
+
+    original_actor = vtkImageActor()
+    reader >> original_actor.mapper
+
+    open_close_actor = vtkImageActor()
+    open_close >> open_close_actor.mapper
+
+    # Define the viewport ranges (x_min, y_min, x_max, y_max).
+    original_viewport = (0.0, 0.0, 0.5, 1.0)
+    open_close_viewport = (0.5, 0.0, 1.0, 1.0)
+
+    # Setup the renderers.
+    original_renderer = vtkRenderer(viewport=original_viewport, background=colors.GetColor3d('Sienna'))
+    original_renderer.AddActor(original_actor)
+
+    open_close_renderer = vtkRenderer(viewport=open_close_viewport, background=colors.GetColor3d('RoyalBlue'))
+    open_close_renderer.AddActor(open_close_actor)
+    open_close_renderer.ResetCamera()
+
+    render_window = vtkRenderWindow(size=(600, 300), window_name='ImageOpenClose3D')
+    render_window.AddRenderer(original_renderer)
+    render_window.AddRenderer(open_close_renderer)
+
+    render_window_interactor = vtkRenderWindowInteractor()
+    style = vtkInteractorStyleImage()
+    render_window_interactor.interactor_style = style
+
+    render_window_interactor.render_window = render_window
+    render_window.Render()
+    render_window_interactor.Initialize()
+
+    render_window_interactor.Start()
+
+
+if __name__ == '__main__':
+    main()