Added ThinPlateSplineTransform, ImageGridSource, ImageHistogram

src/PythonicAPI.md

@@ -225,6 +225,7 @@ This Python script, [SelectExamples](../PythonicAPI/Utilities/SelectExamples), w
 [Silhouette](/PythonicAPI/PolyData/Silhouette) |
 [SmoothMeshGrid](/PythonicAPI/PolyData/SmoothMeshGrid) | Create a terrain with regularly spaced points and smooth it with ?vtkLoopSubdivisionFilter? and ?vtkButterflySubdivisionFilter?.
 [Spring](/PythonicAPI/Modelling/Spring) | Rotation in combination with linear displacement and radius variation.
+[ThinPlateSplineTransform](/PythonicAPI/PolyData/ThinPlateSplineTransform) |
 [VertexConnectivity](/PythonicAPI/PolyData/VertexConnectivity) | Get a list of vertices attached (through an edge) to a vertex.
 [WarpTo](/PythonicAPI/Filtering/WarpTo) | Deform geometry by warping towards a point.
 [WarpVector](/PythonicAPI/PolyData/WarpVector) | This example warps/deflects a line.
@@ -602,6 +603,8 @@ See [this tutorial](http://www.vtk.org/Wiki/VTK/Tutorials/3DDataTypes) for a bri
 [DotProduct](/PythonicAPI/Images/DotProduct) | Compute the pixel-wise dot product of two vector images.
 [ExtractComponents](/PythonicAPI/Images/ExtractComponents) | Extract components of an image. This can be used to get, for example, the red channel of an image.
 [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.
 [ImageNonMaximumSuppression](/PythonicAPI/Images/ImageNonMaximumSuppression) | Find peaks in an image using non maximum suppression.
 [MarkKeypoints](/PythonicAPI/Images/MarkKeypoints) | Mark keypoints in an image.
 

src/PythonicAPI/Images/ImageGridSource.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 vtkImageCast
+from vtkmodules.vtkImagingGeneral import (
+    vtkImageGradient,
+    vtkImageGradientMagnitude
+)
+from vtkmodules.vtkImagingMorphological import vtkImageNonMaximumSuppression
+from vtkmodules.vtkImagingSources import vtkImageSinusoidSource, vtkImageGridSource
+from vtkmodules.vtkInteractionStyle import vtkInteractorStyleImage
+from vtkmodules.vtkRenderingCore import (
+    vtkImageActor,
+    vtkRenderer,
+    vtkRenderWindow,
+    vtkRenderWindowInteractor
+)
+
+
+def main():
+    colors = vtkNamedColors()
+
+    # Create an image.
+    source = vtkImageGridSource(fill_value=122)
+
+    cast_filter = vtkImageCast()
+
+    cast_filter.SetOutputScalarTypeToUnsignedChar()
+
+    # Create an actor.
+    actor = vtkImageActor()
+    source >> cast_filter >> actor.mapper
+
+    # Setup renderer.
+    renderer = vtkRenderer(background=colors.GetColor3d('CornflowerBlue'))
+    renderer.AddActor(actor)
+
+    # Setup render window.
+    render_window = vtkRenderWindow(window_name='ImageGridSource')
+    render_window.AddRenderer(renderer)
+
+    # Setup render window interactor.
+    render_window_interactor = vtkRenderWindowInteractor()
+    style = vtkInteractorStyleImage()
+    render_window_interactor.interactor_style = style
+
+    # Render and start interaction.
+    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/ImageHistogram.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
+from vtkmodules.vtkImagingStatistics import vtkImageHistogram
+from vtkmodules.vtkRenderingCore import (
+    vtkImageSlice,
+    vtkImageSliceMapper,
+    vtkInteractorStyle,
+    vtkRenderer,
+    vtkRenderWindow,
+    vtkRenderWindowInteractor
+)
+
+
+def get_program_parameters():
+    import argparse
+    description = 'ImageHistogram.'
+    epilogue = '''
+    '''
+    parser = argparse.ArgumentParser(description=description, epilog=epilogue,
+                                     formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument('filename', help='The file to use e.g. Pileated.jpg.')
+    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
+    reader.update()
+
+    iren = vtkRenderWindowInteractor()
+    style = vtkInteractorStyle()
+    ren_win = vtkRenderWindow(size=(640, 480), window_name='ImageHistogram')
+    iren.render_window = ren_win
+    iren.interactor_style = style
+
+    histogram = vtkImageHistogram(generate_histogram_image=True, histogram_image_size=(256, 256),
+                                  automatic_binning=True)
+    reader >> histogram
+    histogram.SetInputConnection(reader.GetOutputPort())
+    histogram.SetHistogramImageScaleToSqrt()
+    histogram.update()
+
+    nbins = histogram.number_of_bins
+    bin_range = list()
+    bin_range.append(histogram.bin_origin)
+    bin_range.append(bin_range[0] + (nbins - 1) * histogram.bin_spacing)
+
+    for i in range(0, len(bin_range)):
+        viewport = [0.5 * (i and 1), 0.0, 0.5 + 0.5 * (i and 1), 1.0]
+        renderer = vtkRenderer(viewport=viewport)
+        camera = renderer.active_camera
+        ren_win.AddRenderer(renderer)
+
+        image_mapper = vtkImageSliceMapper()
+        # Compute the y range.
+        if i == 0:
+            reader >> image_mapper
+            extent = reader.output.extent
+        else:
+            histogram >> image_mapper
+            image_mapper.BorderOn()
+            extent = histogram.output.extent
+        dy = extent[3] - extent[2] + 1
+
+        bounds = image_mapper.bounds
+        point = list()
+        for j in range(0, 6, 2):
+            point.append(0.5 * (bounds[j] + bounds[j + 1]))
+
+        camera.focal_point = point
+        point[image_mapper.GetOrientation()] += 1000
+        camera.position = point
+        camera.view_up = (0.0, 1.0, 0.0)
+        camera.ParallelProjectionOn()
+        # Set scale so that vertical dimension fills the window.
+        camera.SetParallelScale(0.5 * dy)
+
+        image = vtkImageSlice()
+        image.mapper = image_mapper
+
+        renderer.AddViewProp(image)
+
+        if i == 0:
+            image.property.SetColorWindow(bin_range[1] - bin_range[0])
+            image.property.SetColorLevel(0.5 * (bin_range[0] + bin_range[1]))
+        else:
+            image.property.SetInterpolationTypeToNearest()
+            image.property.SetColorWindow(255.0)
+            image.property.SetColorLevel(127.5)
+
+    iren.Initialize()
+    ren_win.Render()
+    iren.Start()
+
+
+if __name__ == '__main__':
+    main()

src/PythonicAPI/PolyData/ThinPlateSplineTransform.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.vtkCommonCore import (
+    vtkLookupTable,
+    vtkPoints
+)
+from vtkmodules.vtkCommonTransforms import vtkThinPlateSplineTransform
+from vtkmodules.vtkIOImage import vtkBMPReader
+from vtkmodules.vtkImagingCore import (
+    vtkImageBlend,
+    vtkImageMapToColors,
+    vtkImageReslice
+)
+from vtkmodules.vtkImagingSources import vtkImageGridSource
+from vtkmodules.vtkInteractionStyle import vtkInteractorStyleTerrain
+from vtkmodules.vtkRenderingCore import (
+    vtkActor2D,
+    vtkImageMapper,
+    vtkRenderer,
+    vtkRenderWindow,
+    vtkRenderWindowInteractor
+)
+
+
+def get_program_parameters():
+    import argparse
+    description = 'Warp an image with a thin plate spline.'
+    epilogue = '''
+    '''
+    parser = argparse.ArgumentParser(description=description, epilog=epilogue,
+                                     formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument('filename', help=' Filename.bmp e.g. masonry.bmp.')
+    args = parser.parse_args()
+    return args.filename
+
+
+def main():
+    colors = vtkNamedColors()
+
+    file_name = get_program_parameters()
+
+    fp = Path(file_name)
+    if not fp.is_file():
+        print(f'{fp} not found.')
+        return
+
+    # First, create an image to warp.
+    image_grid = vtkImageGridSource(grid_spacing=(16, 16, 0), grid_origin=(0, 0, 0), data_extent=(0, 255, 0, 255, 0, 0))
+    image_grid.SetDataScalarTypeToUnsignedChar()
+
+    table = vtkLookupTable(table_range=(0, 1), alpha_range=(0.0, 1.0), hue_range=(0.15, 0.15), saturation_range=(1, 1),
+                           value_range=(0, 1))
+    table.Build()
+
+    alpha = vtkImageMapToColors(lookup_table=table)
+    image_grid >> alpha
+
+    reader = vtkBMPReader(file_name=fp)
+    reader.update()
+    data_extent = reader.GetDataExtent()
+    # Use data_extent[1] and data_extent[3] to set the render window size.
+
+    blend = vtkImageBlend()
+    reader >> blend
+    alpha >> blend
+
+    # Next, create a ThinPlateSpline transform.
+
+    p1 = vtkPoints(number_of_points=8)
+    p1.SetPoint(0, 0, 0, 0)
+    p1.SetPoint(1, 0, 255, 0)
+    p1.SetPoint(2, 255, 0, 0)
+    p1.SetPoint(3, 255, 255, 0)
+    p1.SetPoint(4, 96, 96, 0)
+    p1.SetPoint(5, 96, 159, 0)
+    p1.SetPoint(6, 159, 159, 0)
+    p1.SetPoint(7, 159, 96, 0)
+
+    p2 = vtkPoints(number_of_points=8)
+    p2.SetPoint(0, 0, 0, 0)
+    p2.SetPoint(1, 0, 255, 0)
+    p2.SetPoint(2, 255, 0, 0)
+    p2.SetPoint(3, 255, 255, 0)
+    p2.SetPoint(4, 96, 159, 0)
+    p2.SetPoint(5, 159, 159, 0)
+    p2.SetPoint(6, 159, 96, 0)
+    p2.SetPoint(7, 96, 96, 0)
+
+    transform = vtkThinPlateSplineTransform(source_landmarks=p2, target_landmarks=p1)
+    transform.SetBasisToR2LogR()
+    # You must invert the transform before passing it to vtkImageReslice.
+    transform.Inverse()
+
+    reslice = vtkImageReslice(reslice_transform=transform)
+
+    reslice.SetInterpolationModeToLinear()
+    mapper = vtkImageMapper(color_window=255.0, color_level=127.5, z_slice=0)
+    blend >> reslice >> mapper
+    act = vtkActor2D(mapper=mapper)
+
+    renderer = vtkRenderer(background=colors.GetColor3d('SlateGray'))
+    renderer.AddActor(act)
+
+    # No background is visible because the window size matches the data extent.
+    window = vtkRenderWindow(size=(data_extent[1], data_extent[3]), window_name='ThinPlateSplineTransform')
+
+    window.AddRenderer(renderer)
+    interactor = vtkRenderWindowInteractor()
+    interactor.render_window = window
+    style = vtkInteractorStyleTerrain()
+    interactor.interactor_style = style
+    window.Render()
+    interactor.Initialize()
+    interactor.Start()
+
+
+if __name__ == '__main__':
+    main()