diff --git a/src/Cxx/ImageData/VoxelsOnBoundary.md b/src/Cxx/ImageData/VoxelsOnBoundary.md
index bc785205a4fcbef386517be52c2ef497f47a081e..8ac290acdf193f3e93d53589f256fd8c06ea6bd4 100644
--- a/src/Cxx/ImageData/VoxelsOnBoundary.md
+++ b/src/Cxx/ImageData/VoxelsOnBoundary.md
@@ -2,13 +2,7 @@
This example uses vtkMultiThreshold to extract voxels that are inside an isosurface and on the boundary of the isosurface. The result is a vtkUnstructuredGrid for each set of voxels. Before processing, vtkImageShrink3D reduces the resolution by a factor of 4.
-Compare these results with
-
-!!! example "usage"
- VoxelsOnBoundary FullHead.mhd
-
-!!! info
- Compare these results with [MedicalDemo1](../../Medical/MedicalDemo1) that extracts the surface using vtkMarchingCubes to extract an interpolated isosurface.
+Compare these results with [MedicalDemo1](../../Medical/MedicalDemo1) that extracts the surface using vtkFlyingEdges3D or vtkMarchingCubes to extract an interpolated isosurface.
!!! info
The example uses `src/Testing/Data/FullHead.mhd` which references `src/Testing/Data/FullHead.raw.gz`.
diff --git a/src/PythonicAPI.md b/src/PythonicAPI.md
index 5c432381b8021eb5cbf23db07fef3b212c496386..ea4b939af97ca09edc004b7bff6b2f2390abb371 100644
--- a/src/PythonicAPI.md
+++ b/src/PythonicAPI.md
@@ -555,6 +555,7 @@ See [this tutorial](http://www.vtk.org/Wiki/VTK/Tutorials/3DDataTypes) for a bri
[StreamlinesWithLineWidget](/PythonicAPI/VisualizationAlgorithms/StreamlinesWithLineWidget) | Using the vtkLineWidget to produce streamlines in the combustor dataset. The StartInteractionEvent turns the visibility of the streamlines on; the InteractionEvent causes the streamlines to regenerate themselves.
[TensorEllipsoids](/PythonicAPI/VisualizationAlgorithms/TensorEllipsoids) | Display the scaled and oriented principal axes as tensor ellipsoids representing the stress tensor.
[TransformActorCollection](/PythonicAPI/Visualization/TransformActorCollection) | Transform an actor collection.
+[VoxelsOnBoundary](/PythonicAPI/ImageData/VoxelsOnBoundary) | Extract voxels on the border of an isosurface.
[WarpCombustor](/PythonicAPI/VisualizationAlgorithms/WarpCombustor) | Carpet plots of combustor flow energy in a structured grid. Colors and plane displacement represent energy values.
## Working with ?vtkImageData?
@@ -613,7 +614,10 @@ See [this tutorial](http://www.vtk.org/Wiki/VTK/Tutorials/3DDataTypes) for a bri
[GaussianSmooth](/PythonicAPI/ImageProcessing/GaussianSmooth) | Low-pass filters can be implemented as convolution with a Gaussian kernel.
[HybridMedianComparison](/PythonicAPI/ImageProcessing/HybridMedianComparison) | Comparison of median and hybrid-median filters. The hybrid filter preserves corners and thin lines, better than the median filter.
[IdealHighPass](/PythonicAPI/ImageProcessing/IdealHighPass) | This figure shows two high-pass filters in the frequency domain. The Butterworth high-pass filter has a gradual attenuation that avoids ringing produced by the ideal high-pass filter with an abrupt transition.
-[ImageContinuousDilate3D](/Cxx/PythonicAPI/ImageContinuousDilate3D) | Dilate an image.
+[ImageContinuousDilate3D](/PythonicAPI/Images/ImageContinuousDilate3D) | Dilate an image.
+[ImageContinuousErode3D](/PythonicAPI/Images/ImageContinuousErode3D) | Erode an image.
+[ImageConvolve](/PythonicAPI/Images/ImageConvolve) | Convolve an image with a kernel.
+[ImageCorrelation](/PythonicAPI/Images/ImageCorrelation) | Correlate two images.
[ImageGradient](/PythonicAPI/VisualizationAlgorithms/ImageGradient) | Create an imaging pipeline to visualize gradient information.
[IsoSubsample](/PythonicAPI/ImageProcessing/IsoSubsample) | This figure demonstrates aliasing that occurs when a high-frequency signal is subsampled. High frequencies appear as low frequency artifacts. The left image is an isosurface of a skull after subsampling. The right image used a low-pass filter before subsampling to reduce aliasing.
[MorphologyComparison](/PythonicAPI/ImageProcessing/MorphologyComparison) | This figure demonstrates various binary filters that can alter the shape of segmented regions.
diff --git a/src/PythonicAPI/ImageData/VoxelsOnBoundary.md b/src/PythonicAPI/ImageData/VoxelsOnBoundary.md
new file mode 100644
index 0000000000000000000000000000000000000000..8ac290acdf193f3e93d53589f256fd8c06ea6bd4
--- /dev/null
+++ b/src/PythonicAPI/ImageData/VoxelsOnBoundary.md
@@ -0,0 +1,8 @@
+### Description
+
+This example uses vtkMultiThreshold to extract voxels that are inside an isosurface and on the boundary of the isosurface. The result is a vtkUnstructuredGrid for each set of voxels. Before processing, vtkImageShrink3D reduces the resolution by a factor of 4.
+
+Compare these results with [MedicalDemo1](../../Medical/MedicalDemo1) that extracts the surface using vtkFlyingEdges3D or vtkMarchingCubes to extract an interpolated isosurface.
+
+!!! info
+ The example uses `src/Testing/Data/FullHead.mhd` which references `src/Testing/Data/FullHead.raw.gz`.
diff --git a/src/PythonicAPI/ImageData/VoxelsOnBoundary.py b/src/PythonicAPI/ImageData/VoxelsOnBoundary.py
new file mode 100644
index 0000000000000000000000000000000000000000..b104e5f15c85039c5a44e919defdf7f7e25a7b81
--- /dev/null
+++ b/src/PythonicAPI/ImageData/VoxelsOnBoundary.py
@@ -0,0 +1,136 @@
+# !/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.vtkCommonDataModel import (
+ vtkPlane, vtkDataObject
+)
+from vtkmodules.vtkFiltersGeneral import vtkImageDataToPointSet, vtkMultiThreshold
+from vtkmodules.vtkIOImage import vtkImageReader2Factory
+from vtkmodules.vtkImagingCore import vtkImageShrink3D
+from vtkmodules.vtkRenderingCore import (
+ vtkActor,
+ vtkDataSetMapper,
+ vtkRenderer,
+ vtkRenderWindow,
+ vtkRenderWindowInteractor,
+)
+
+
+def get_program_parameters():
+ import argparse
+ description = 'VoxelsOnBoundsry.'
+ epilogue = '''
+ '''
+ parser = argparse.ArgumentParser(description=description, epilog=epilogue,
+ formatter_class=argparse.RawDescriptionHelpFormatter)
+ parser.add_argument('filename', help='The file to use e.g. FullHead.mhd.')
+ args = parser.parse_args()
+ return args.filename
+
+
+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
+ # Can use this instead.
+ # reader = vtkMetaImageReader(file_name=fp)
+ reader.update()
+
+ shrink = vtkImageShrink3D(shrink_factors=(4, 4, 4))
+ reader >> shrink
+ shrink.update()
+
+ # Create a PointSet from the ImageData.
+ image_data_to_point_set = vtkImageDataToPointSet()
+ reader >> image_data_to_point_set
+ shrink >> image_data_to_point_set
+
+ # Extract voxels on the border between the inside and outside.
+ threshold = vtkMultiThreshold(input_data=image_data_to_point_set.update().output)
+ # Inside points have one or more points above the isosurface.
+ inside_id = threshold.AddIntervalSet(501, 20000, vtkMultiThreshold.CLOSED, vtkMultiThreshold.CLOSED,
+ vtkDataObject.FIELD_ASSOCIATION_POINTS, 'ImageScalars', 0, 0)
+ # Border points have points that straddle the boundary
+ border_id = threshold.AddIntervalSet(499.9999, 501.0000, vtkMultiThreshold.OPEN, vtkMultiThreshold.OPEN,
+ vtkDataObject.FIELD_ASSOCIATION_POINTS, 'ImageScalars', 0, 0)
+
+ # Select the intervals to be output
+ threshold.OutputSet(inside_id)
+ threshold.OutputSet(border_id)
+ threshold.Update()
+
+ # Visualize
+ colors = vtkNamedColors()
+ # outsideColor = colors.GetColor3d('Crimson')
+ inside_color = colors.GetColor3d('Banana')
+ border_color = colors.GetColor3d('Mint')
+ # surfaceColor = colors.GetColor3d('Peacock')
+ background_color = colors.GetColor3d('Silver')
+
+ input_data_inside = threshold.output.GetBlock(inside_id).GetBlock(0)
+ input_data_border = threshold.output.GetBlock(border_id).GetBlock(0)
+
+ normal = (1.0, -1.0, -1.0)
+ origin = input_data_inside.GetCenter()
+ plane = vtkPlane(origin=origin, normal=normal)
+
+ # Inside
+ inside_mapper = vtkDataSetMapper(input_data=input_data_inside, scalar_visibility=False)
+
+ inside_actor = vtkActor(mapper=inside_mapper)
+ inside_actor.property.diffuse_color = inside_color
+ inside_actor.property.specular = 0.6
+ inside_actor.property.specular_power = 30
+ inside_actor.property.edge_visibility = True
+
+ # Border
+ border_mapper = vtkDataSetMapper(input_data=input_data_border, scalar_visibility=False)
+
+ border_actor = vtkActor(mapper=border_mapper)
+ border_actor.property.diffuse_color = border_color
+ border_actor.property.specular = 0.6
+ border_actor.property.specular_power = 30
+ border_actor.property.edge_visibility = True
+
+ renderer = vtkRenderer(use_hidden_line_removal=True, background=background_color)
+ render_window = vtkRenderWindow(size=(640, 480), window_name='CellsOnBoundary')
+ render_window.AddRenderer(renderer)
+
+ render_window_interactor = vtkRenderWindowInteractor()
+ render_window_interactor.render_window = render_window
+ renderer.AddActor(inside_actor)
+ renderer.AddActor(border_actor)
+
+ render_window.Render()
+
+ # Set up a good view.
+ renderer.active_camera.view_up = (0, 0, -1)
+ renderer.active_camera.position = (0, -1, 0)
+ renderer.active_camera.focal_point = (0, 0, 0)
+ renderer.active_camera.Azimuth(30.0)
+ renderer.active_camera.Elevation(30.0)
+ renderer.ResetCamera()
+ renderer.active_camera.Dolly(1.5)
+
+ render_window_interactor.Start()
+
+
+if __name__ == '__main__':
+ main()
diff --git a/src/PythonicAPI/Images/ImageContinuousDilate3D.py b/src/PythonicAPI/Images/ImageContinuousDilate3D.py
index e7be1d12050a9f5f2e94c2588c5b1b3e28662881..c064ac8cb38f54dbcefb2704a49bef3aab6a5ff4 100644
--- a/src/PythonicAPI/Images/ImageContinuousDilate3D.py
+++ b/src/PythonicAPI/Images/ImageContinuousDilate3D.py
@@ -52,7 +52,7 @@ def main():
draw_color1 = colors.GetColor3ub('Black')
draw_color2 = colors.GetColor3ub('White')
- # Create an image
+ # Create an image.
source = vtkImageCanvasSource2D(extent=(0, 200, 0, 200, 0, 0))
source.SetScalarTypeToUnsignedChar()
source.draw_color = tuple(draw_color1)
diff --git a/src/PythonicAPI/Images/ImageContinuousErode3D.py b/src/PythonicAPI/Images/ImageContinuousErode3D.py
new file mode 100644
index 0000000000000000000000000000000000000000..3d914bccae043aa97432ac79b5052e137d26e121
--- /dev/null
+++ b/src/PythonicAPI/Images/ImageContinuousErode3D.py
@@ -0,0 +1,106 @@
+#!/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.vtkCommonDataModel import vtkImageData
+from vtkmodules.vtkIOImage import vtkPNGReader
+from vtkmodules.vtkImagingMorphological import vtkImageContinuousErode3D
+from vtkmodules.vtkImagingSources import vtkImageCanvasSource2D
+from vtkmodules.vtkRenderingCore import (
+ vtkActor,
+ vtkDataSetMapper,
+ vtkRenderer,
+ vtkRenderWindow,
+ vtkRenderWindowInteractor
+)
+
+
+def get_program_parameters():
+ import argparse
+ description = 'ImageContinuousErode3D.'
+ epilogue = '''
+ '''
+ parser = argparse.ArgumentParser(description=description, epilog=epilogue,
+ formatter_class=argparse.RawDescriptionHelpFormatter)
+ parser.add_argument('file_name', nargs='?', default=None, help='The image file name to use e.g. Gourds.png.')
+ args = parser.parse_args()
+ return args.file_name
+
+
+def main():
+ fn = get_program_parameters()
+ fp = None
+ if fn:
+ 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()
+
+ image = vtkImageData()
+
+ if not fp:
+ draw_color1 = colors.GetColor3ub('Black')
+ draw_color2 = colors.GetColor3ub('White')
+
+ # Create an image.
+ source = vtkImageCanvasSource2D(extent=(0, 200, 0, 200, 0, 0))
+ source.SetScalarTypeToUnsignedChar()
+ source.draw_color = tuple(draw_color1)
+ source.FillBox(0, 200, 0, 200)
+ source.draw_color = tuple(draw_color2)
+ source.FillBox(100, 150, 100, 150)
+ source.update()
+ image.ShallowCopy(source.output)
+ else:
+ reader = vtkPNGReader(file_name=fp)
+ reader.update()
+ image.ShallowCopy(reader.output)
+
+ erode_filter = vtkImageContinuousErode3D(input_data=image, kernel_size=(10, 10, 1))
+
+ original_mapper = vtkDataSetMapper(input_data=image)
+
+ original_actor = vtkActor(mapper=original_mapper)
+
+ eroded_mapper = vtkDataSetMapper()
+ erode_filter >> eroded_mapper
+
+ eroded_actor = vtkActor(mapper=eroded_mapper)
+
+ # Visualize
+ left_viewport = (0.0, 0.0, 0.5, 1.0)
+ right_viewport = (0.5, 0.0, 1.0, 1.0)
+
+ render_window = vtkRenderWindow(size=(600, 300), window_name='ImageContinuousErode3D')
+
+ interactor = vtkRenderWindowInteractor()
+ interactor.render_window = render_window
+
+ left_renderer = vtkRenderer(viewport=left_viewport, background=colors.GetColor3d('Sienna'))
+ render_window.AddRenderer(left_renderer)
+
+ right_renderer = vtkRenderer(viewport=right_viewport, background=colors.GetColor3d('RoyalBlue'))
+ render_window.AddRenderer(right_renderer)
+
+ left_renderer.AddActor(original_actor)
+ right_renderer.AddActor(eroded_actor)
+
+ left_renderer.ResetCamera()
+ right_renderer.active_camera = left_renderer.active_camera
+
+ render_window.Render()
+ interactor.Start()
+
+
+if __name__ == '__main__':
+ main()
diff --git a/src/PythonicAPI/Images/ImageConvolve.py b/src/PythonicAPI/Images/ImageConvolve.py
new file mode 100644
index 0000000000000000000000000000000000000000..745f14ba2f9694e8197e4d86d82ffc9d90e3d6e0
--- /dev/null
+++ b/src/PythonicAPI/Images/ImageConvolve.py
@@ -0,0 +1,72 @@
+#!/usr/bin/env python3
+
+# noinspection PyUnresolvedReferences
+import vtkmodules.vtkInteractionStyle
+# noinspection PyUnresolvedReferences
+import vtkmodules.vtkRenderingOpenGL2
+from vtkmodules.vtkCommonColor import vtkNamedColors
+from vtkmodules.vtkImagingCore import vtkImageCast
+from vtkmodules.vtkImagingGeneral import vtkImageConvolve
+from vtkmodules.vtkImagingSources import vtkImageMandelbrotSource
+from vtkmodules.vtkInteractionStyle import vtkInteractorStyleImage
+from vtkmodules.vtkRenderingCore import (
+ vtkRenderer,
+ vtkRenderWindow,
+ vtkRenderWindowInteractor, vtkImageActor
+)
+
+
+def main():
+ colors = vtkNamedColors()
+
+ # Create an image.
+ source = vtkImageMandelbrotSource()
+
+ original_cast_filter = vtkImageCast()
+ original_cast_filter.SetOutputScalarTypeToUnsignedChar()
+
+ kernel = [1] * 9
+ convolve_filter = vtkImageConvolve(kernel3x3=kernel)
+ convolve_filter.SetKernel3x3(kernel)
+
+ convolved_cast_filter = vtkImageCast()
+ convolved_cast_filter.SetOutputScalarTypeToUnsignedChar()
+
+ # Create an actor
+ original_actor = vtkImageActor()
+ source >> original_cast_filter >> original_actor.mapper
+
+ convolved_actor = vtkImageActor()
+ source >> convolve_filter >> convolved_cast_filter >> convolved_actor.mapper
+
+ # Define viewport ranges (x_min, y_min, x_max, y_max).
+ left_viewport = (0.0, 0.0, 0.5, 1.0)
+ right_viewport = (0.5, 0.0, 1.0, 1.0)
+
+ # Setup renderer
+ original_renderer = vtkRenderer(viewport=left_viewport, background=colors.GetColor3d('Sienna'))
+ original_renderer.AddActor(original_actor)
+
+ convolved_renderer = vtkRenderer(viewport=right_viewport, background=colors.GetColor3d('RoyalBlue'))
+ convolved_renderer.AddActor(convolved_actor)
+
+ # Setup the render window.
+ render_window = vtkRenderWindow(size=(600, 300), window_name='ImageConvolve')
+ render_window.AddRenderer(original_renderer)
+ render_window.AddRenderer(convolved_renderer)
+
+ # Setup the render window interactor.
+ render_window_interactor = vtkRenderWindowInteractor()
+ style = vtkInteractorStyleImage()
+ render_window_interactor.interactor_style = style
+
+ # Render and start the interaction.
+ render_window_interactor.render_window = render_window
+ render_window.Render()
+ render_window_interactor.Initialize()
+
+ render_window_interactor.Start()
+
+
+if __name__ == '__main__':
+ main()
diff --git a/src/PythonicAPI/Images/ImageCorrelation.py b/src/PythonicAPI/Images/ImageCorrelation.py
new file mode 100644
index 0000000000000000000000000000000000000000..6ef849986545e1d87005e84203ad2767235bac4d
--- /dev/null
+++ b/src/PythonicAPI/Images/ImageCorrelation.py
@@ -0,0 +1,112 @@
+#!/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 vtkImageCast, vtkImageShiftScale
+from vtkmodules.vtkImagingGeneral import vtkImageCorrelation
+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.
+ draw_color1 = colors.GetColor3ub('Black')
+ draw_color2 = colors.GetColor3ub('Wheat')
+
+ image_source = vtkImageCanvasSource2D(extent=(0, 300, 0, 300, 0, 0), number_of_scalar_components=3)
+ image_source.SetScalarTypeToUnsignedChar()
+ image_source.draw_color = tuple(draw_color1)
+ image_source.FillBox(0, 300, 0, 300)
+ image_source.draw_color = tuple(draw_color2)
+ image_source.FillTriangle(10, 100, 190, 150, 40, 250)
+ image_source.update()
+
+ # Create an actor.
+ original_actor = vtkImageActor()
+ image_source >> original_actor.mapper
+
+ # Create a kernel.
+ kernel_source = vtkImageCanvasSource2D(extent=(0, 30, 0, 30, 0, 0), number_of_scalar_components=3)
+ kernel_source.SetScalarTypeToUnsignedChar()
+ kernel_source.draw_color = tuple(draw_color1)
+ kernel_source.FillBox(0, 30, 0, 30)
+ kernel_source.draw_color = tuple(draw_color2)
+ kernel_source.FillTriangle(10, 1, 25, 10, 1, 5)
+ kernel_source.Update()
+
+ # Create an actor.
+ kernel_actor = vtkImageActor()
+ kernel_source >> kernel_actor.mapper
+
+ # Compute the correlation.
+ correlation_filter = vtkImageCorrelation()
+ image_source >> select_ports(0, correlation_filter)
+ kernel_source >> select_ports(1, correlation_filter)
+ correlation_filter.update()
+
+ # At this point, corr pixels are doubles so, get the scalar range.
+ corr = correlation_filter.output
+ corr_range = corr.point_data.scalars.range
+ scale = 255 / corr_range[1]
+
+ # Rescale the correlation filter output. Note that it implies that
+ # minimum correlation is always zero.
+ image_scale = vtkImageShiftScale(scale=scale)
+ image_scale.SetInputConnection(correlation_filter.GetOutputPort())
+ image_scale.SetOutputScalarTypeToUnsignedChar()
+
+ correlation_cast_filter = vtkImageCast()
+ correlation_cast_filter.SetOutputScalarTypeToUnsignedChar()
+
+ # Create an actor.
+ correlation_actor = vtkImageActor()
+ correlation_filter >> image_scale >> correlation_cast_filter >> correlation_actor.mapper
+
+ # Define viewport ranges (x_min, y_min, x_max, y_max).
+ original_viewport = (0.0, 0.0, 0.33, 1.0)
+ kernel_viewport = (0.33, 0.0, 0.66, 1.0)
+ correlation_viewport = (0.66, 0.0, 1.0, 1.0)
+
+ # Setup the renderers.
+ original_renderer = vtkRenderer(viewport=original_viewport, background=colors.GetColor3d('Mint'))
+ original_renderer.AddActor(original_actor)
+
+ kernel_renderer = vtkRenderer(viewport=kernel_viewport, background=colors.GetColor3d('Mint'))
+ kernel_renderer.AddActor(kernel_actor)
+
+ correlation_renderer = vtkRenderer(viewport=correlation_viewport, background=colors.GetColor3d('Peacock'))
+ correlation_renderer.AddActor(correlation_actor)
+
+ # Set up the render window.
+ render_window = vtkRenderWindow(size=(900, 300), window_name='ImageCorrelation')
+ render_window.AddRenderer(original_renderer)
+ render_window.AddRenderer(kernel_renderer)
+ render_window.AddRenderer(correlation_renderer)
+
+ # Set up the render window interactor.
+ render_window_interactor = vtkRenderWindowInteractor()
+ style = vtkInteractorStyleImage()
+ render_window_interactor.interactor_style = style
+
+ # Render and start the interaction.
+ render_window_interactor.render_window = render_window
+ render_window.Render()
+ render_window_interactor.Initialize()
+
+ render_window_interactor.Start()
+
+
+if __name__ == '__main__':
+ main()
diff --git a/src/Testing/Baseline/PythonicAPI/ImageData/TestVoxelsOnBoundary.png b/src/Testing/Baseline/PythonicAPI/ImageData/TestVoxelsOnBoundary.png
new file mode 100644
index 0000000000000000000000000000000000000000..4b4e8658a1e7b11c363ec0b61eeca400353d3343
--- /dev/null
+++ b/src/Testing/Baseline/PythonicAPI/ImageData/TestVoxelsOnBoundary.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f22daad092c6e5aaa43cc606e6b4de851496967efbcf476184601684883d5fe3
+size 45926
diff --git a/src/Testing/Baseline/PythonicAPI/Images/TestImageContinuousErode3D.png b/src/Testing/Baseline/PythonicAPI/Images/TestImageContinuousErode3D.png
new file mode 100644
index 0000000000000000000000000000000000000000..a2bd30f3b663d7eb8b5ddade6866a0a8c6a84121
--- /dev/null
+++ b/src/Testing/Baseline/PythonicAPI/Images/TestImageContinuousErode3D.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:47943f2b677cb3d71ee06aef6da97f20c4d9c9c8e88b8571d29c64a3e53179ff
+size 160403
diff --git a/src/Testing/Baseline/PythonicAPI/Images/TestImageConvolve.png b/src/Testing/Baseline/PythonicAPI/Images/TestImageConvolve.png
new file mode 100644
index 0000000000000000000000000000000000000000..99dfb404d02602acf36565bdda844672255159ce
--- /dev/null
+++ b/src/Testing/Baseline/PythonicAPI/Images/TestImageConvolve.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:259c10132177604b36dfce7a94a83622f5b47607648280b79ded2343b0bcd535
+size 42764
diff --git a/src/Testing/Baseline/PythonicAPI/Images/TestImageCorrelation.png b/src/Testing/Baseline/PythonicAPI/Images/TestImageCorrelation.png
new file mode 100644
index 0000000000000000000000000000000000000000..585318ee366a3205e9da929ad35eb84da4b1850f
--- /dev/null
+++ b/src/Testing/Baseline/PythonicAPI/Images/TestImageCorrelation.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f0f3daf52941bde667b37cad5bc100367595fde7fbd0e6a7d5c7839878ce4ed5
+size 13647