Adding C++ and Python versions of ImageWarp.

src/Cxx.md

@@ -1091,6 +1091,7 @@ See [this tutorial](http://www.vtk.org/Wiki/VTK/Tutorials/3DDataTypes) for a bri
 [ImageSobel2D](/Cxx/Images/ImageSobel2D)| vtkImageSobel2D |Sobel edge detection 2D.
 [ImageValueRange](/Cxx/Images/ImageValueRange)| vtkImageData | Get the range of image pixel values (min/max).
 [ImageVariance3D](/Cxx/Images/ImageVariance3D)| vtkImageVariance3D | Construct a new image consisting of the variance of the input image at each pixel.
+[ImageWarp](/Cxx/Images/ImageWarp)| vtkBMPReader vtkImageLuminance vtkWarpScalar vtkMergeFilter | Combine the imaging and visualization pipelines to deform an image in the z-direction. The vtkMergeFilter is used to combine the warped surface with the original color data.
 [RGBToHSI](/Cxx/Images/RGBToHSI)| vtkImageRGBToHSI |Convert RGB to HSI.
 [RGBToHSV](/Cxx/Images/RGBToHSV)| vtkImageRGBToHSV |Convert RGB to HSV.
 [RGBToYIQ](/Cxx/Images/RGBToYIQ)| vtkImageRGBToYIQ |Convert RGB to YIQ.

src/Cxx/Images/CMakeLists.txt

@@ -62,6 +62,7 @@ set(NEEDS_ARGS
   ImageSeparableConvolution
   ImageToPolyDataFilter
   ImageToStructuredPoints
+  ImageWarp
   Transparency
   InteractWithImage
   PickPixel
@@ -159,10 +160,13 @@ add_test(${KIT}-ImageRotate ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${KIT}CxxTests
 
 add_test(${KIT}-ImageSeparableConvolution ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${KIT}CxxTests
   TestImageSeparableConvolution ${DATA}/Yinyang.png -E 25)
-  
+
 add_test(${KIT}-ImageToStructuredPoints ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${KIT}CxxTests
   TestImageToStructuredPoints -E 25)
 
+add_test(${KIT}-ImageWarp ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${KIT}CxxTests
+  TestImageWarp ${DATA}/masonry.bmp)
+
 add_test(${KIT}-Transparency ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${KIT}CxxTests
   TestTransparency  ${DATA}/Ox.jpg)
 

src/Cxx/Images/ImageWarp.cxx

+/*
+ * This example shows how to combine data from both the imaging
+ *  and graphics pipelines. The vtkMergeData filter is used to
+ *  merge the data from each together.
+*/
+#include <vtkActor.h>
+#include <vtkBMPReader.h>
+#include <vtkCamera.h>
+#include <vtkDataSetMapper.h>
+#include <vtkImageDataGeometryFilter.h>
+#include <vtkImageLuminance.h>
+#include <vtkMergeFilter.h>
+#include <vtkNamedColors.h>
+#include <vtkRenderWindow.h>
+#include <vtkRenderWindowInteractor.h>
+#include <vtkRenderer.h>
+#include <vtkSmartPointer.h>
+#include <vtkWarpScalar.h>
+
+#include <algorithm>
+#include <array>
+#include <iomanip>
+#include <iostream>
+#include <string>
+
+int main(int argc, char* argv[])
+{
+
+  if (argc < 2)
+  {
+    std::cout << "Usage: " << argv[0] << " fileName" << std::endl;
+    std::cout << "where: fileName is the masonry.bmp file." << std::endl;
+    return EXIT_FAILURE;
+  }
+
+  std::string fileName = argv[1];
+
+  vtkSmartPointer<vtkNamedColors> colors =
+    vtkSmartPointer<vtkNamedColors>::New();
+
+  // Set the background color. Match those in VTKTextbook.pdf.
+  auto SetColor = [&colors](std::array<double, 3>& v,
+                            std::string const& colorName) {
+    auto const scaleFactor = 256.0;
+    std::transform(std::begin(v), std::end(v), std::begin(v),
+                   [=](double const& n) { return n / scaleFactor; });
+    colors->SetColor(colorName, v.data());
+    return;
+  };
+  std::array<double, 3> bkg{{60, 93, 144}};
+  SetColor(bkg, "BkgColor");
+
+  // Read in an image and compute a luminance value-> The image is extracted
+  // as a set of polygons (vtkImageDataGeometryFilter). We then will
+  // warp the plane using the scalar (luminance) values.
+  //
+  vtkSmartPointer<vtkBMPReader> reader = vtkSmartPointer<vtkBMPReader>::New();
+  reader->SetFileName(fileName.c_str());
+  // Convert the image to a grey scale.
+  vtkSmartPointer<vtkImageLuminance> luminance =
+    vtkSmartPointer<vtkImageLuminance>::New();
+  luminance->SetInputConnection(reader->GetOutputPort());
+  // Pass the data to the pipeline as polygons.
+  vtkSmartPointer<vtkImageDataGeometryFilter> geometry =
+    vtkSmartPointer<vtkImageDataGeometryFilter>::New();
+  geometry->SetInputConnection(luminance->GetOutputPort());
+  // Warp the data in a direction perpendicular to the image plane.
+  vtkSmartPointer<vtkWarpScalar> warp = vtkSmartPointer<vtkWarpScalar>::New();
+  warp->SetInputConnection(geometry->GetOutputPort());
+  warp->SetScaleFactor(-0.1);
+
+  // Use vtkMergeFilter to combine the original image with the warped geometry.
+  vtkSmartPointer<vtkMergeFilter> merge =
+    vtkSmartPointer<vtkMergeFilter>::New();
+  merge->SetGeometryConnection(warp->GetOutputPort());
+  merge->SetScalarsConnection(reader->GetOutputPort());
+  vtkSmartPointer<vtkDataSetMapper> mapper =
+    vtkSmartPointer<vtkDataSetMapper>::New();
+  mapper->SetInputConnection(merge->GetOutputPort());
+  mapper->SetScalarRange(0, 255);
+  vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
+  actor->SetMapper(mapper);
+
+  // Create the rendering window, renderer, and interactive renderer.
+  //
+  vtkSmartPointer<vtkRenderer> ren = vtkSmartPointer<vtkRenderer>::New();
+  vtkSmartPointer<vtkRenderWindow> renWin =
+    vtkSmartPointer<vtkRenderWindow>::New();
+  renWin->AddRenderer(ren);
+
+  vtkSmartPointer<vtkRenderWindowInteractor> iren =
+    vtkSmartPointer<vtkRenderWindowInteractor>::New();
+  iren->SetRenderWindow(renWin);
+
+  // Add the actors to the renderer, set the background and size.
+  ren->AddActor(actor);
+  ren->ResetCamera();
+  ren->SetBackground(colors->GetColor3d("BkgColor").GetData());
+  // ren->GetActiveCamera()->Azimuth(20);
+  // ren->GetActiveCamera()->Elevation(30);
+  // ren->ResetCameraClippingRange();
+  // ren->GetActiveCamera()->Zoom(1.3);
+  ren->GetActiveCamera()->SetPosition(-100, -130, 325);
+  ren->GetActiveCamera()->SetFocalPoint(105, 114, -29);
+  ren->GetActiveCamera()->SetViewUp(0.51, 0.54, 0.67);
+  ren->ResetCameraClippingRange();
+
+  renWin->SetSize(512, 512);
+
+  // Render the image.
+  renWin->Render();
+  iren->Start();
+
+  return EXIT_SUCCESS;
+}

src/Python.md

@@ -233,6 +233,13 @@ This section includes examples of manipulating meshes.
 |--------------|----------------------|-------------|-------|
 [BackgroundImage](/Python/BackgroundImage) | vtkJPEGReader vtkImageCanvasSource2D vtkImageActor vtkSuperquadricSource | Display an image as the "background" of a scene, and render a superquadric in front of it.
 
+## Image Processing
+
+| Example Name | Classes Demonstrated | Description | Image |
+|--------------|----------------------|-------------|-------|
+[ImageWarp](/Python/Images/ImageWarp)| vtkBMPReader vtkImageLuminance vtkWarpScalar vtkMergeFilter | Combine the imaging and visualization pipelines to deform an image in the z-direction. The vtkMergeFilter is used to combine the warped surface with the original color data.
+
+
 ## Working with vtkImageData
 
 | Example Name | Classes Demonstrated | Description | Image |

src/Python/Images/ImageWarp.py

+##!/usr/bin/env python
+
+import vtk
+
+
+def main():
+    fileName = get_program_parameters()
+
+    colors = vtk.vtkNamedColors()
+    # Set the background color. Match those in VTKTextbook.pdf.
+    bkg = map(lambda x: x / 256.0, [60, 93, 144])
+    colors.SetColor("BkgColor", *bkg)
+
+    # Read in an image and compute a luminance value. The image is extracted
+    # as a set of polygons (vtkImageDataGeometryFilter). We then will
+    # warp the plane using the scalar (luminance) values.
+    #
+    reader = vtk.vtkBMPReader()
+    reader.SetFileName(fileName)
+    # Convert the image to a grey scale.
+    luminance = vtk.vtkImageLuminance()
+    luminance.SetInputConnection(reader.GetOutputPort())
+    # Pass the data to the pipeline as polygons.
+    geometry = vtk.vtkImageDataGeometryFilter()
+    geometry.SetInputConnection(luminance.GetOutputPort())
+    # Warp the data in a direction perpendicular to the image plane.
+    warp = vtk.vtkWarpScalar()
+    warp.SetInputConnection(geometry.GetOutputPort())
+    warp.SetScaleFactor(-0.1)
+
+    # Use vtkMergeFilter to combine the original image with the warped geometry.
+    merge = vtk.vtkMergeFilter()
+    merge.SetGeometryConnection(warp.GetOutputPort())
+    merge.SetScalarsConnection(reader.GetOutputPort())
+    mapper = vtk.vtkDataSetMapper()
+    mapper.SetInputConnection(merge.GetOutputPort())
+    mapper.SetScalarRange(0, 255)
+    actor = vtk.vtkActor()
+    actor.SetMapper(mapper)
+
+    # Create the rendering window, renderer, and interactive renderer.
+    ren = vtk.vtkRenderer()
+    renWin = vtk.vtkRenderWindow()
+    renWin.AddRenderer(ren)
+    iren = vtk.vtkRenderWindowInteractor()
+    iren.SetRenderWindow(renWin)
+
+    # Add the actors to the renderer, set the background and size.
+    ren.AddActor(actor)
+    ren.ResetCamera()
+    ren.SetBackground(colors.GetColor3d("BkgColor"))
+    # ren.GetActiveCamera().Azimuth(20)
+    # ren.GetActiveCamera().Elevation(30)
+    # ren.ResetCameraClippingRange()
+    # ren.GetActiveCamera().Zoom(1.3)
+    ren.GetActiveCamera().SetPosition(-100, -130, 325)
+    ren.GetActiveCamera().SetFocalPoint(105, 114, -29)
+    ren.GetActiveCamera().SetViewUp(0.51, 0.54, 0.67)
+    ren.ResetCameraClippingRange()
+
+    renWin.SetSize(512, 512)
+
+    # Render the image.
+    iren.Initialize()
+    renWin.Render()
+    iren.Start()
+
+
+def get_program_parameters():
+    import argparse
+    description = 'ImageWarp.'
+    epilogue = '''
+This example shows how to combine data from both the imaging
+ and graphics pipelines. The vtkMergeData filter is used to
+ merge the data from each together.
+
+   '''
+    parser = argparse.ArgumentParser(description=description, epilog=epilogue,
+                                     formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument('filePrefix', help='Path to the masonry.bmp file.')
+    args = parser.parse_args()
+    return args.filePrefix
+
+
+if __name__ == '__main__':
+    main()