Added ImageStack, ImageTracerWidgetInsideContour, ImageTracerWidgetNonPlanar

src/PythonicAPI.md

@@ -618,6 +618,7 @@ See [this tutorial](http://www.vtk.org/Wiki/VTK/Tutorials/3DDataTypes) for a bri
 [ImageRange3D](/PythonicAPI/Images/ImageRange3D) | Replace every pixel with the range of its neighbors according to a kernel.
 [ImageSeparableConvolution](/PythonicAPI/Images/ImageSeparableConvolution) | Convolve a separable kernel with an image.
 [ImageSlice](/PythonicAPI/Images/ImageSlice) | Visualize and interact with an image. This is even more powerful than vtkImageSliceMapper. It can also do oblique slices.
+[ImageStack](/PythonicAPI/Images/ImageStack) | Display layers of images.
 [ImageToPolyDataFilter](/PythonicAPI/Images/ImageToPolyDataFilter) | Convert a vtkImageData to a vtkPolyData.
 [MarkKeypoints](/PythonicAPI/Images/MarkKeypoints) | Mark keypoints in an image.
 
@@ -674,6 +675,8 @@ See [this tutorial](http://www.vtk.org/Wiki/VTK/Tutorials/3DDataTypes) for a bri
 [DistanceWidget](/PythonicAPI/Widgets/DistanceWidget) |
 [HoverWidget](/PythonicAPI/Widgets/HoverWidget) | How to detect a hover.
 [ImagePlaneWidget](/PythonicAPI/Widgets/ImagePlaneWidget) |
+[ImageTracerWidgetInsideContour](/PythonicAPI/Widgets/ImageTracerWidgetInsideContour) | Highlight pixels inside a non-regular region scribbled on an image.
+[ImageTracerWidgetNonPlanar](/PythonicAPI/Widgets/ImageTracerWidgetNonPlanar) | Draw on a non-planar surface.
 [ImplicitConeWidget](/PythonicAPI/Widgets/ImplicitConeWidget) | An interactive implicit cone widget.
 [ImplicitPlaneWidget2](/PythonicAPI/Widgets/ImplicitPlaneWidget2) | Clip polydata with an implicit plane.
 [PolygonalSurfacePointPlacer](/PythonicAPI/PolyData/PolygonalSurfacePointPlacer) | Used in conjunction with vtkContourWidget to draw curves on a surface.

src/PythonicAPI/Images/ImageStack.py

+#!/usr/bin/env python3
+
+# noinspection PyUnresolvedReferences
+import vtkmodules.vtkInteractionStyle
+# noinspection PyUnresolvedReferences
+import vtkmodules.vtkRenderingOpenGL2
+from vtkmodules.vtkCommonColor import vtkNamedColors
+from vtkmodules.vtkCommonCore import VTK_UNSIGNED_CHAR
+from vtkmodules.vtkCommonDataModel import vtkImageData
+from vtkmodules.vtkInteractionStyle import vtkInteractorStyleImage
+from vtkmodules.vtkRenderingCore import (
+    vtkImageSlice,
+    vtkImageSliceMapper,
+    vtkRenderer,
+    vtkRenderWindow,
+    vtkRenderWindowInteractor
+)
+from vtkmodules.vtkRenderingImage import vtkImageStack
+
+
+def main():
+    colors = vtkNamedColors()
+
+    # Image 1
+    image1 = create_color_image(1, 0)
+
+    image_slice_mapper1 = vtkImageSliceMapper()
+    image_slice_mapper1.SetInputData(image1)
+
+    image_slice1 = vtkImageSlice()
+    image_slice1.SetMapper(image_slice_mapper1)
+    image_slice1.property.opacity = 0.5
+
+    # Image 2
+    image2 = create_color_image(4, 1)
+
+    image_slice_mapper2 = vtkImageSliceMapper()
+    image_slice_mapper2.SetInputData(image2)
+
+    image_slice2 = vtkImageSlice()
+    image_slice2.SetMapper(image_slice_mapper2)
+    image_slice2.property.opacity = 0.5
+
+    # Stack.
+    image_stack = vtkImageStack()
+    image_stack.AddImage(image_slice1)
+    image_stack.AddImage(image_slice2)
+    # image_stack.active_layer = 1
+
+    # Setup renderers.
+    renderer = vtkRenderer(background=colors.GetColor3d('SteelBlue'))
+    renderer.AddViewProp(image_stack)
+
+    # Setup render window.
+    render_window = vtkRenderWindow(window_name='ImageStack')
+    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()
+
+
+def create_color_image(corner, channel):
+    image = vtkImageData(dimensions=(10, 10, 1))
+    image.AllocateScalars(VTK_UNSIGNED_CHAR, 3)
+
+    for x in range(0, 10):
+        for y in range(0, 10):
+            for i in range(0, 3):
+                image.SetScalarComponentFromFloat(x, y, 0, i, 0)
+    for x in range(corner, corner + 3):
+        for y in range(corner, corner + 3):
+            for i in range(0, 3):
+                if i == channel:
+                    image.SetScalarComponentFromFloat(x, y, 0, i, 255)
+                else:
+                    image.SetScalarComponentFromFloat(x, y, 0, i, 0)
+
+    return image
+
+
+if __name__ == '__main__':
+    main()

src/PythonicAPI/Widgets/ImageTracerWidgetInsideContour.py

+#!/usr/bin/env python3
+
+# noinspection PyUnresolvedReferences
+import vtkmodules.vtkInteractionStyle
+# noinspection PyUnresolvedReferences
+import vtkmodules.vtkRenderingOpenGL2
+from vtkmodules.vtkCommonColor import vtkNamedColors
+from vtkmodules.vtkCommonCore import vtkCallbackCommand
+from vtkmodules.vtkCommonDataModel import vtkPolyData
+from vtkmodules.vtkImagingSources import vtkImageCanvasSource2D
+from vtkmodules.vtkImagingStatistics import vtkImageAccumulate
+from vtkmodules.vtkImagingStencil import (
+    vtkImageStencilToImage,
+    vtkPolyDataToImageStencil,
+)
+from vtkmodules.vtkInteractionStyle import vtkInteractorStyleImage
+from vtkmodules.vtkInteractionWidgets import vtkImageTracerWidget
+from vtkmodules.vtkRenderingCore import (
+    vtkImageActor,
+    vtkRenderer,
+    vtkRenderWindow,
+    vtkRenderWindowInteractor
+)
+
+
+def main():
+    colors = vtkNamedColors()
+
+    image = create_image1()
+
+    actor = vtkImageActor()
+    actor.mapper.input_data = image
+
+    renderer = vtkRenderer(background=colors.GetColor3d('DarkSlateGray'))
+    renderer.AddActor(actor)
+
+    render_window = vtkRenderWindow(window_name='ImageTracerWidgetInsideContour')
+    render_window.AddRenderer(renderer)
+
+    interactor = vtkRenderWindowInteractor()
+    interactor.render_window = render_window
+    style = vtkInteractorStyleImage()
+    interactor.interactor_style = style
+
+    tracer = vtkImageTracerWidget()
+    tracer.line_property.line_width = 5
+    tracer.interactor = interactor
+    tracer.view_prop = actor
+    tracer.auto_close = True
+    render_window.Render()
+
+    # The observer must be added BEFORE the On() call.
+    callback = AffineCallback(image, tracer)
+    tracer.AddObserver(vtkCallbackCommand.EndInteractionEvent, callback)
+
+    tracer.On()
+    interactor.Start()
+
+
+class AffineCallback(vtkCallbackCommand):
+    def __init__(self, image, tracer_widget):
+        super().__init__()
+
+        self.image = image
+        self.tracer_widget = tracer_widget
+
+    def __call__(self, caller, ev):
+        self.Execute(self, id, ev)
+
+    def Execute(self, caller, identifier, event):
+        path = vtkPolyData()
+
+        if not self.tracer_widget.IsClosed():
+            print(f'Path not closed!')
+            return
+
+        self.tracer_widget.GetPath(path)
+        print(f'There are {path.number_of_points} points in the path.')
+
+        poly_data_to_image_stencil = vtkPolyDataToImageStencil(tolerance=0, input_data=path,
+                                                               output_origin=self.image.origin,
+                                                               output_spacing=self.image.spacing,
+                                                               output_whole_extent=self.image.extent)
+        poly_data_to_image_stencil.update()
+
+        image_stencil_to_image = vtkImageStencilToImage(inside_value=255)
+        poly_data_to_image_stencil >> image_stencil_to_image
+        image_stencil_to_image.update()
+
+        image_accumulate = vtkImageAccumulate(input_data=self.image,
+                                              stencil_data=poly_data_to_image_stencil.output)
+        image_accumulate.update()
+        print(f'Voxel count: {image_accumulate.voxel_count}')
+
+
+def create_image1():
+    colors = vtkNamedColors()
+
+    draw_color1 = colors.GetColor3ub('DarkGray')
+
+    canvas_source = vtkImageCanvasSource2D(extent=(0, 20, 0, 50, 0, 0), number_of_scalar_components=1)
+    canvas_source.SetScalarTypeToUnsignedChar()
+    canvas_source.draw_color = tuple(draw_color1)
+    canvas_source.FillBox(0, 20, 0, 50)
+
+    # image = vtkImageData()
+    image = canvas_source.update().output
+    return image
+
+
+if __name__ == '__main__':
+    main()

src/PythonicAPI/Widgets/ImageTracerWidgetNonPlanar.py

+#!/usr/bin/env python3
+
+# noinspection PyUnresolvedReferences
+import vtkmodules.vtkInteractionStyle
+# noinspection PyUnresolvedReferences
+import vtkmodules.vtkRenderingOpenGL2
+from vtkmodules.vtkCommonColor import vtkNamedColors
+from vtkmodules.vtkFiltersSources import vtkSphereSource
+from vtkmodules.vtkInteractionStyle import vtkInteractorStyleTrackballCamera
+from vtkmodules.vtkInteractionWidgets import vtkImageTracerWidget
+from vtkmodules.vtkRenderingCore import (
+    vtkActor,
+    vtkPolyDataMapper,
+    vtkRenderer,
+    vtkRenderWindow,
+    vtkRenderWindowInteractor
+)
+
+
+def main():
+    colors = vtkNamedColors()
+
+    sphere_source = vtkSphereSource()
+
+    # Create a mapper and actor.
+    mapper = vtkPolyDataMapper()
+    sphere_source >> mapper
+    actor = vtkActor(mapper=mapper)
+    actor.property.color = colors.GetColor3d('MistyRose')
+
+    # A renderer and render window.
+    renderer = vtkRenderer(background=colors.GetColor3d('SlateGray'))
+    render_window = vtkRenderWindow(window_name='ImageTracerWidgetNonPlanar')
+    render_window.AddRenderer(renderer)
+
+    renderer.AddActor(actor)
+
+    # An interactor.
+    render_window_interactor = vtkRenderWindowInteractor()
+    render_window_interactor.render_window = render_window
+    style = vtkInteractorStyleTrackballCamera()
+    render_window_interactor.interactor_style = style
+
+    tracer_widget = vtkImageTracerWidget()
+    tracer_widget.interactor = render_window_interactor
+    tracer_widget.SetViewProp(actor)
+
+    render_window.Render()
+
+    render_window_interactor.Initialize()
+    render_window.Render()
+    tracer_widget.On()
+
+    # Begin the mouse interaction.
+    render_window_interactor.Start()
+
+
+if __name__ == '__main__':
+    main()