diff --git a/src/Cxx/ImageProcessing/Pad.cxx b/src/Cxx/ImageProcessing/Pad.cxx
index f0622e08461ae75d4496a143fa652235b3fe54e5..4caf8ad260b6e5a576d132774c99f50361690476 100644
--- a/src/Cxx/ImageProcessing/Pad.cxx
+++ b/src/Cxx/ImageProcessing/Pad.cxx
@@ -1,27 +1,29 @@
 #include <vtkCamera.h>
 #include <vtkImageActor.h>
 #include <vtkImageConstantPad.h>
-#include <vtkImageMapper3D.h>
 #include <vtkImageMapToWindowLevelColors.h>
+#include <vtkImageMapper3D.h>
 #include <vtkImageMirrorPad.h>
 #include <vtkImageProperty.h>
 #include <vtkImageReader2.h>
 #include <vtkImageReader2Factory.h>
 #include <vtkInteractorStyleImage.h>
 #include <vtkNamedColors.h>
-#include <vtkRenderer.h>
+#include <vtkNew.h>
 #include <vtkRenderWindow.h>
 #include <vtkRenderWindowInteractor.h>
+#include <vtkRenderer.h>
 #include <vtkSmartPointer.h>
-#include <vtkNew.h>
 
- int main (int argc, char *argv[])
+int main(int argc, char* argv[])
 {
+  vtkNew<vtkNamedColors> colors;
+
   // Verify input arguments
-  if ( argc < 2 )
+  if (argc < 2)
   {
-    std::cout << "Usage: " << argv[0]
-              << " Filename e.g. FullHead.mhd" << std::endl;
+    std::cout << "Usage: " << argv[0] << " Filename e.g. FullHead.mhd"
+              << std::endl;
     return EXIT_FAILURE;
   }
 
@@ -43,7 +45,6 @@
   mirrorPad->SetOutputWholeExtent(constantPad->GetOutputWholeExtent());
 
   // Create actors
-  vtkNew<vtkNamedColors> colors;
 
   vtkNew<vtkImageMapToWindowLevelColors> constantPadColor;
   constantPadColor->SetWindow(2000);
diff --git a/src/Cxx/Images/Actor2D.cxx b/src/Cxx/Images/Actor2D.cxx
index 5ff9f4edc9bb0356dbd1158b70f3ac577b598e7b..3735b52a187e2fb774bcba7b727faf28f9b1e2e1 100644
--- a/src/Cxx/Images/Actor2D.cxx
+++ b/src/Cxx/Images/Actor2D.cxx
@@ -1,60 +1,58 @@
-#include <vtkSmartPointer.h>
+#include <vtkActor2D.h>
 #include <vtkCubeSource.h>
-#include <vtkPolyData.h>
+#include <vtkNamedColors.h>
+#include <vtkNew.h>
 #include <vtkPoints.h>
-#include <vtkVertexGlyphFilter.h>
-#include <vtkRenderWindow.h>
-#include <vtkRenderer.h>
-#include <vtkRenderWindowInteractor.h>
-#include <vtkActor2D.h>
+#include <vtkPolyData.h>
 #include <vtkPolyDataMapper2D.h>
 #include <vtkProperty2D.h>
+#include <vtkRenderWindow.h>
+#include <vtkRenderWindowInteractor.h>
+#include <vtkRenderer.h>
+#include <vtkVertexGlyphFilter.h>
 
-int main(int, char *[])
+int main(int, char*[])
 {
-  vtkSmartPointer<vtkPoints> points = 
-    vtkSmartPointer<vtkPoints>::New();
-  points->InsertNextPoint(10,10,0);
-  points->InsertNextPoint(100,100,0);
-  points->InsertNextPoint(200,200,0);
-
-  vtkSmartPointer<vtkPolyData> polydata =
-    vtkSmartPointer<vtkPolyData>::New();
+  vtkNew<vtkNamedColors> colors;
+
+  vtkNew<vtkPoints> points;
+  points->InsertNextPoint(10, 10, 0);
+  points->InsertNextPoint(100, 100, 0);
+  points->InsertNextPoint(200, 200, 0);
+
+  vtkNew<vtkPolyData> polydata;
   polydata->SetPoints(points);
 
-  vtkSmartPointer<vtkVertexGlyphFilter> glyphFilter =
-    vtkSmartPointer<vtkVertexGlyphFilter>::New();
+  vtkNew<vtkVertexGlyphFilter> glyphFilter;
   glyphFilter->SetInputData(polydata);
   glyphFilter->Update();
 
-  vtkSmartPointer<vtkPolyDataMapper2D> mapper =
-    vtkSmartPointer<vtkPolyDataMapper2D>::New();
+  vtkNew<vtkPolyDataMapper2D> mapper;
   mapper->SetInputConnection(glyphFilter->GetOutputPort());
   mapper->Update();
 
-  vtkSmartPointer<vtkActor2D> actor = 
-    vtkSmartPointer<vtkActor2D>::New();
+  vtkNew<vtkActor2D> actor;
   actor->SetMapper(mapper);
- 
+  actor->GetProperty()->SetColor(colors->GetColor3d("Gold").GetData());
+  actor->GetProperty()->SetPointSize(8);
+
   // Create a renderer, render window, and interactor
-  vtkSmartPointer<vtkRenderer> renderer = 
-    vtkSmartPointer<vtkRenderer>::New();
-  vtkSmartPointer<vtkRenderWindow> renderWindow = 
-    vtkSmartPointer<vtkRenderWindow>::New();
+  vtkNew<vtkRenderer> renderer;
+  vtkNew<vtkRenderWindow> renderWindow;
   renderWindow->AddRenderer(renderer);
-  vtkSmartPointer<vtkRenderWindowInteractor> renderWindowInteractor = 
-    vtkSmartPointer<vtkRenderWindowInteractor>::New();
+  vtkNew<vtkRenderWindowInteractor> renderWindowInteractor;
   renderWindowInteractor->SetRenderWindow(renderWindow);
- 
+
   // Add the actor to the scene
   renderer->AddActor(actor);
-  renderWindow->SetSize(300,300);
-  actor->GetProperty()->SetColor(0,1,0);
-  actor->GetProperty()->SetPointSize(3);
-  
+  renderer->SetBackground(colors->GetColor3d("DarkSlateGray").GetData());
+
+  renderWindow->SetSize(300, 300);
+  renderWindow->SetWindowName("Actor2D");
+
   // Render and interact
   renderWindow->Render();
   renderWindowInteractor->Start();
-  
+
   return EXIT_SUCCESS;
 }
diff --git a/src/Cxx/Images/BackgroundImage.cxx b/src/Cxx/Images/BackgroundImage.cxx
index 3fc8ef5640c89bb4c937eca2dba19126e0ff58c1..f0b53a0a45059053c7d1bc9e0ffdb5db6ee2b2f5 100644
--- a/src/Cxx/Images/BackgroundImage.cxx
+++ b/src/Cxx/Images/BackgroundImage.cxx
@@ -6,8 +6,10 @@
 #include <vtkImageReader2.h>
 #include <vtkImageReader2Factory.h>
 #include <vtkNamedColors.h>
+#include <vtkNew.h>
 #include <vtkPolyData.h>
 #include <vtkPolyDataMapper.h>
+#include <vtkProperty.h>
 #include <vtkRenderWindow.h>
 #include <vtkRenderWindowInteractor.h>
 #include <vtkRenderer.h>
@@ -16,74 +18,76 @@
 
 #include <array>
 
-int main(int argc, char *argv[]) {
-
+int main(int argc, char* argv[])
+{
   vtkNew<vtkNamedColors> colors;
 
-  std::array<unsigned char, 4> lgtCyan = {{100, 255, 255, 255}};
-  std::array<unsigned char, 4> lgtMagenta = {{255, 100, 255, 255}};
-  colors->SetColor("light_cyan", lgtCyan.data());
-  colors->SetColor("light_magenta", lgtMagenta.data());
-
   vtkSmartPointer<vtkImageData> imageData;
 
   // Verify input arguments
-  if (argc > 1) {
+  if (argc > 1)
+  {
     // Read the image
-    vtkSmartPointer<vtkImageReader2Factory> readerFactory =
-        vtkSmartPointer<vtkImageReader2Factory>::New();
+    vtkNew<vtkImageReader2Factory> readerFactory;
     vtkSmartPointer<vtkImageReader2> imageReader;
-    imageReader.TakeReference(
-      readerFactory->CreateImageReader2(argv[1]));
+    imageReader.TakeReference(readerFactory->CreateImageReader2(argv[1]));
     imageReader->SetFileName(argv[1]);
     imageReader->Update();
     imageData = imageReader->GetOutput();
   }
   else
   {
-    vtkSmartPointer<vtkImageCanvasSource2D> canvasSource =
-        vtkSmartPointer<vtkImageCanvasSource2D>::New();
+
+    std::array<double, 4> drawColor1{0, 0, 0, 0};
+    std::array<double, 4> drawColor2{0, 0, 0, 0};
+    std::array<double, 4> drawColor3{0, 0, 0, 0};
+    auto color1 = colors->GetColor4ub("warm_grey").GetData();
+    auto color2 = colors->GetColor4ub("DarkCyan").GetData();
+    auto color3 = colors->GetColor4ub("LightCoral").GetData();
+    for (auto i = 0; i < 4; ++i)
+    {
+      drawColor1[i] = color1[i];
+      drawColor2[i] = color2[i];
+      drawColor3[i] = color3[i];
+    }
+
+    vtkNew<vtkImageCanvasSource2D> canvasSource;
     canvasSource->SetExtent(0, 100, 0, 100, 0, 0);
     canvasSource->SetScalarTypeToUnsignedChar();
     canvasSource->SetNumberOfScalarComponents(3);
-    canvasSource->SetDrawColor(128,  128,  105);
+    canvasSource->SetDrawColor(drawColor1.data());
     canvasSource->FillBox(0, 100, 0, 100);
-    canvasSource->SetDrawColor(100, 255, 255);
+    canvasSource->SetDrawColor(drawColor2.data());
     canvasSource->FillTriangle(10, 10, 25, 10, 25, 25);
-    canvasSource->SetDrawColor(255, 100, 255);
+    canvasSource->SetDrawColor(drawColor3.data());
     canvasSource->FillTube(75, 75, 0, 75, 5.0);
     canvasSource->Update();
     imageData = canvasSource->GetOutput();
   }
   // Create an image actor to display the image
-  vtkSmartPointer<vtkImageActor> imageActor =
-      vtkSmartPointer<vtkImageActor>::New();
+  vtkNew<vtkImageActor> imageActor;
   imageActor->SetInputData(imageData);
 
   // Create a renderer to display the image in the background
-  vtkSmartPointer<vtkRenderer> backgroundRenderer =
-      vtkSmartPointer<vtkRenderer>::New();
+  vtkNew<vtkRenderer> backgroundRenderer;
 
   // Create a superquadric
-  vtkSmartPointer<vtkSuperquadricSource> superquadricSource =
-      vtkSmartPointer<vtkSuperquadricSource>::New();
+  vtkNew<vtkSuperquadricSource> superquadricSource;
   superquadricSource->SetPhiRoundness(1.1);
   superquadricSource->SetThetaRoundness(.2);
 
   // Create a mapper and actor
-  vtkSmartPointer<vtkPolyDataMapper> superquadricMapper =
-      vtkSmartPointer<vtkPolyDataMapper>::New();
+  vtkNew<vtkPolyDataMapper> superquadricMapper;
   superquadricMapper->SetInputConnection(superquadricSource->GetOutputPort());
 
-  vtkSmartPointer<vtkActor> superquadricActor =
-      vtkSmartPointer<vtkActor>::New();
+  vtkNew<vtkActor> superquadricActor;
   superquadricActor->SetMapper(superquadricMapper);
+  superquadricActor->GetProperty()->SetColor(
+      colors->GetColor3d("NavajoWhite").GetData());
 
-  vtkSmartPointer<vtkRenderer> sceneRenderer =
-      vtkSmartPointer<vtkRenderer>::New();
+  vtkNew<vtkRenderer> sceneRenderer;
 
-  vtkSmartPointer<vtkRenderWindow> renderWindow =
-      vtkSmartPointer<vtkRenderWindow>::New();
+  vtkNew<vtkRenderWindow> renderWindow;
 
   // Set up the render window and renderers such that there is
   // a background layer and a foreground layer
@@ -93,9 +97,9 @@ int main(int argc, char *argv[]) {
   renderWindow->SetNumberOfLayers(2);
   renderWindow->AddRenderer(backgroundRenderer);
   renderWindow->AddRenderer(sceneRenderer);
+  renderWindow->SetWindowName("BackgroundImage");
 
-  vtkSmartPointer<vtkRenderWindowInteractor> renderWindowInteractor =
-      vtkSmartPointer<vtkRenderWindowInteractor>::New();
+  vtkNew<vtkRenderWindowInteractor> renderWindowInteractor;
   renderWindowInteractor->SetRenderWindow(renderWindow);
 
   // Add actors to the renderers
@@ -113,7 +117,7 @@ int main(int argc, char *argv[]) {
   imageData->GetSpacing(spacing);
   imageData->GetExtent(extent);
 
-  vtkCamera *camera = backgroundRenderer->GetActiveCamera();
+  vtkCamera* camera = backgroundRenderer->GetActiveCamera();
   camera->ParallelProjectionOn();
 
   double xc = origin[0] + 0.5 * (extent[0] + extent[1]) * spacing[0];
diff --git a/src/Cxx/Images/BackgroundImage.md b/src/Cxx/Images/BackgroundImage.md
index ce493c928b9a5e999b6c99a65fac5815a29bcde7..e939d00b8e73c38cafeaa2d25696f34d46b801a7 100644
--- a/src/Cxx/Images/BackgroundImage.md
+++ b/src/Cxx/Images/BackgroundImage.md
@@ -1,4 +1,5 @@
 ### Description
+
 This example displays an image as the "background" of a scene, and renders a superquadric in front of it.
 
 The example accepts a jpeg file on the command line to use as a background image. If there is no file, it generates a simple background.
diff --git a/src/Cxx/Images/BorderPixelSize.cxx b/src/Cxx/Images/BorderPixelSize.cxx
index deae62ecd39ff8b39337df2112bd8d41a546ab8c..8102a08782db88ba9e82d228d056a188f3af0ad6 100644
--- a/src/Cxx/Images/BorderPixelSize.cxx
+++ b/src/Cxx/Images/BorderPixelSize.cxx
@@ -1,41 +1,47 @@
 #include <vtkImageData.h>
-#include <vtkSmartPointer.h>
+#include <vtkImageMapper.h>
+#include <vtkImageProperty.h>
+#include <vtkImageSlice.h>
+#include <vtkImageSliceMapper.h>
+#include <vtkInteractorStyleImage.h>
+#include <vtkNamedColors.h>
+#include <vtkNew.h>
 #include <vtkRenderWindow.h>
 #include <vtkRenderWindowInteractor.h>
-#include <vtkInteractorStyleImage.h>
 #include <vtkRenderer.h>
-#include <vtkImageMapper.h>
-#include <vtkImageSliceMapper.h>
-#include <vtkImageSlice.h>
-#include <vtkImageProperty.h>
 
-static void CreateRandomImage(vtkImageData* image, const unsigned int dimension);
+namespace {
+void CreateRandomImage(vtkImageData* image, const unsigned int dimension);
+}
 
-int main(int, char *[])
+int main(int, char*[])
 {
+  vtkNew<vtkNamedColors> colors;
+
   // Big image
-  vtkSmartPointer<vtkImageData> image = vtkSmartPointer<vtkImageData>::New();
+  vtkNew<vtkImageData> image;
   CreateRandomImage(image, 50);
 
-  vtkSmartPointer<vtkImageSliceMapper> imageSliceMapper = vtkSmartPointer<vtkImageSliceMapper>::New();
+  vtkNew<vtkImageSliceMapper> imageSliceMapper;
   imageSliceMapper->SetInputData(image);
-  imageSliceMapper->BorderOn(); // This line tells the mapper to draw the full border pixels.
-  vtkSmartPointer<vtkImageSlice> imageSlice = vtkSmartPointer<vtkImageSlice>::New();
+  imageSliceMapper->BorderOn(); // This line tells the mapper to draw the full
+                                // border pixels.
+  vtkNew<vtkImageSlice> imageSlice;
   imageSlice->SetMapper(imageSliceMapper);
   imageSlice->GetProperty()->SetInterpolationTypeToNearest();
 
-  vtkSmartPointer<vtkRenderer> renderer = vtkSmartPointer<vtkRenderer>::New();
+  vtkNew<vtkRenderer> renderer;
   renderer->AddViewProp(imageSlice);
+  renderer->SetBackground(colors->GetColor3d("DarkSlateGray").GetData());
   renderer->ResetCamera();
 
-  vtkSmartPointer<vtkRenderWindow> renderWindow = vtkSmartPointer<vtkRenderWindow>::New();
+  vtkNew<vtkRenderWindow> renderWindow;
   renderWindow->AddRenderer(renderer);
+  renderWindow->SetWindowName("BorderPixelSize");
 
-  vtkSmartPointer<vtkRenderWindowInteractor> renderWindowInteractor =
-    vtkSmartPointer<vtkRenderWindowInteractor>::New();
+  vtkNew<vtkRenderWindowInteractor> renderWindowInteractor;
 
-  vtkSmartPointer<vtkInteractorStyleImage> style =
-    vtkSmartPointer<vtkInteractorStyleImage>::New();
+  vtkNew<vtkInteractorStyleImage> style;
 
   renderWindowInteractor->SetInteractorStyle(style);
 
@@ -48,22 +54,25 @@ int main(int, char *[])
   return EXIT_SUCCESS;
 }
 
+namespace {
+
 void CreateRandomImage(vtkImageData* image, const unsigned int dimension)
 {
   image->SetDimensions(dimension, dimension, 1);
-  image->SetOrigin(.5,.5,0);
-  image->AllocateScalars(VTK_UNSIGNED_CHAR,3);
+  image->SetOrigin(.5, .5, 0);
+  image->AllocateScalars(VTK_UNSIGNED_CHAR, 3);
 
-  for(unsigned int x = 0; x < dimension; x++)
+  for (unsigned int x = 0; x < dimension; x++)
   {
-    for(unsigned int y = 0; y < dimension; y++)
+    for (unsigned int y = 0; y < dimension; y++)
     {
-      unsigned char* pixel = static_cast<unsigned char*>(image->GetScalarPointer(x,y,0));
+      unsigned char* pixel =
+          static_cast<unsigned char*>(image->GetScalarPointer(x, y, 0));
       pixel[0] = rand() % 255;
       pixel[1] = rand() % 255;
       pixel[2] = rand() % 255;
     }
   }
-
   image->Modified();
 }
+} // namespace
diff --git a/src/Cxx/Images/CannyEdgeDetector.cxx b/src/Cxx/Images/CannyEdgeDetector.cxx
index 17a122dbe6e6728d196ba0c655e65c31a9faddf8..316e621ce5f5d248976d546b27ca3246260d8db3 100644
--- a/src/Cxx/Images/CannyEdgeDetector.cxx
+++ b/src/Cxx/Images/CannyEdgeDetector.cxx
@@ -1,164 +1,148 @@
-#include <vtkRenderer.h>
+#include <vtkCamera.h>
+#include <vtkGeometryFilter.h>
 #include <vtkImageActor.h>
-#include <vtkStructuredPoints.h>
-#include <vtkSmartPointer.h>
-#include <vtkRenderWindow.h>
-#include <vtkRenderWindowInteractor.h>
-#include <vtkPNGReader.h>
-#include <vtkImageLuminance.h>
-#include <vtkProperty.h>
-#include <vtkImageGaussianSmooth.h>
 #include <vtkImageCast.h>
+#include <vtkImageConstantPad.h>
+#include <vtkImageGaussianSmooth.h>
 #include <vtkImageGradient.h>
+#include <vtkImageLuminance.h>
 #include <vtkImageMagnitude.h>
 #include <vtkImageNonMaximumSuppression.h>
-#include <vtkImageConstantPad.h>
 #include <vtkImageToStructuredPoints.h>
 #include <vtkLinkEdgels.h>
-#include <vtkThreshold.h>
-#include <vtkGeometryFilter.h>
-#include <vtkSubPixelPositionEdgels.h>
-#include <vtkStripper.h>
+#include <vtkNamedColors.h>
+#include <vtkNew.h>
+#include <vtkPNGReader.h>
 #include <vtkPolyDataMapper.h>
-#include <vtkCamera.h>
+#include <vtkProperty.h>
+#include <vtkRenderWindow.h>
+#include <vtkRenderWindowInteractor.h>
+#include <vtkRenderer.h>
+#include <vtkStripper.h>
+#include <vtkStructuredPoints.h>
+#include <vtkSubPixelPositionEdgels.h>
+#include <vtkThreshold.h>
 
 int main(int argc, char* argv[])
 {
-  if(argc != 2)
+  vtkNew<vtkNamedColors> colors;
+
+  if (argc != 2)
   {
-    std::cerr << "Required args: filename.png" << std::endl;
+    std::cerr << "Required args: filename.png e.g. Gourds.png" << std::endl;
     return EXIT_FAILURE;
   }
 
   std::string filename = argv[1];
 
-
-
-    // Define viewport ranges
+  // Define viewport ranges
   // (xmin, ymin, xmax, ymax)
   double originalViewport[4] = {0.0, 0.0, 0.5, 1.0};
   double edgeViewport[4] = {0.5, 0.0, 1.0, 1.0};
 
-  vtkSmartPointer<vtkRenderer> originalRenderer =
-    vtkSmartPointer<vtkRenderer>::New();
+  vtkNew<vtkRenderer> originalRenderer;
   originalRenderer->SetViewport(originalViewport);
-  vtkSmartPointer<vtkRenderer> edgeRenderer =
-    vtkSmartPointer<vtkRenderer>::New();
+  originalRenderer->SetBackground(colors->GetColor3d("SlateGray").GetData());
+  vtkNew<vtkRenderer> edgeRenderer;
   edgeRenderer->SetViewport(edgeViewport);
+  edgeRenderer->SetBackground(colors->GetColor3d("LightSlateGray").GetData());
 
-  vtkSmartPointer<vtkRenderWindow> renderWindow =
-    vtkSmartPointer<vtkRenderWindow>::New();
-  renderWindow->SetSize(600,300);
+  vtkNew<vtkRenderWindow> renderWindow;
+  renderWindow->SetSize(600, 300);
   renderWindow->SetMultiSamples(0);
   renderWindow->AddRenderer(originalRenderer);
   renderWindow->AddRenderer(edgeRenderer);
+  renderWindow->SetWindowName("CannyEdgeDetector");
 
-  vtkSmartPointer<vtkRenderWindowInteractor> interactor =
-    vtkSmartPointer<vtkRenderWindowInteractor>::New();
+  vtkNew<vtkRenderWindowInteractor> interactor;
   interactor->SetRenderWindow(renderWindow);
 
-  vtkSmartPointer<vtkPNGReader> imageIn =
-    vtkSmartPointer<vtkPNGReader>::New();
+  vtkNew<vtkPNGReader> imageIn;
   imageIn->SetFileName(filename.c_str());
   imageIn->Update();
 
-  vtkSmartPointer<vtkImageActor> imageActor =
-    vtkSmartPointer<vtkImageActor>::New();
+  vtkNew<vtkImageActor> imageActor;
   imageActor->SetInputData(imageIn->GetOutput());
 
   originalRenderer->AddActor(imageActor);
 
-  vtkSmartPointer<vtkImageLuminance> il =
-    vtkSmartPointer<vtkImageLuminance>::New();
+  vtkNew<vtkImageLuminance> il;
   il->SetInputConnection(imageIn->GetOutputPort());
 
-  vtkSmartPointer<vtkImageCast> ic =
-    vtkSmartPointer<vtkImageCast>::New();
+  vtkNew<vtkImageCast> ic;
   ic->SetOutputScalarTypeToFloat();
   ic->SetInputConnection(il->GetOutputPort());
 
   // Smooth the image
-  vtkSmartPointer<vtkImageGaussianSmooth> gs =
-    vtkSmartPointer<vtkImageGaussianSmooth>::New();
+  vtkNew<vtkImageGaussianSmooth> gs;
   gs->SetInputConnection(ic->GetOutputPort());
   gs->SetDimensionality(2);
   gs->SetRadiusFactors(1, 1, 0);
 
   // Gradient the image
-  vtkSmartPointer<vtkImageGradient> imgGradient =
-    vtkSmartPointer<vtkImageGradient>::New();
+  vtkNew<vtkImageGradient> imgGradient;
   imgGradient->SetInputConnection(gs->GetOutputPort());
   imgGradient->SetDimensionality(2);
 
-  vtkSmartPointer<vtkImageMagnitude> imgMagnitude =
-    vtkSmartPointer<vtkImageMagnitude>::New();
+  vtkNew<vtkImageMagnitude> imgMagnitude;
   imgMagnitude->SetInputConnection(imgGradient->GetOutputPort());
 
   // Non maximum suppression
-  vtkSmartPointer<vtkImageNonMaximumSuppression> nonMax =
-    vtkSmartPointer<vtkImageNonMaximumSuppression>::New();
+  vtkNew<vtkImageNonMaximumSuppression> nonMax;
   imgMagnitude->Update();
   nonMax->SetMagnitudeInputData(imgMagnitude->GetOutput());
   imgGradient->Update();
   nonMax->SetVectorInputData(imgGradient->GetOutput());
   nonMax->SetDimensionality(2);
 
-  vtkSmartPointer<vtkImageConstantPad> pad =
-    vtkSmartPointer<vtkImageConstantPad>::New();
+  vtkNew<vtkImageConstantPad> pad;
   pad->SetInputConnection(imgGradient->GetOutputPort());
   pad->SetOutputNumberOfScalarComponents(3);
   pad->SetConstant(0);
 
-  vtkSmartPointer<vtkImageToStructuredPoints> i2sp1 =
-    vtkSmartPointer<vtkImageToStructuredPoints>::New();
+  vtkNew<vtkImageToStructuredPoints> i2sp1;
   i2sp1->SetInputConnection(nonMax->GetOutputPort());
   pad->Update();
   i2sp1->SetVectorInputData(pad->GetOutput());
 
   // Link edgles
-  vtkSmartPointer<vtkLinkEdgels> imgLink =
-    vtkSmartPointer<vtkLinkEdgels>::New();
+  vtkNew<vtkLinkEdgels> imgLink;
   imgLink->SetInputConnection(i2sp1->GetOutputPort());
   imgLink->SetGradientThreshold(2);
 
   // Threshold links
-  vtkSmartPointer<vtkThreshold> thresholdEdgels =
-    vtkSmartPointer<vtkThreshold>::New();
+  vtkNew<vtkThreshold> thresholdEdgels;
   thresholdEdgels->SetInputConnection(imgLink->GetOutputPort());
   thresholdEdgels->ThresholdByUpper(10);
   thresholdEdgels->AllScalarsOff();
 
-  vtkSmartPointer<vtkGeometryFilter> gf =
-    vtkSmartPointer<vtkGeometryFilter>::New();
+  vtkNew<vtkGeometryFilter> gf;
   gf->SetInputConnection(thresholdEdgels->GetOutputPort());
 
-  vtkSmartPointer<vtkImageToStructuredPoints> i2sp =
-    vtkSmartPointer<vtkImageToStructuredPoints>::New();
+  vtkNew<vtkImageToStructuredPoints> i2sp;
   i2sp->SetInputConnection(imgMagnitude->GetOutputPort());
   pad->Update();
   i2sp->SetVectorInputData(pad->GetOutput());
 
   // Subpixel them
-  vtkSmartPointer<vtkSubPixelPositionEdgels> spe =
-    vtkSmartPointer<vtkSubPixelPositionEdgels>::New();
+  vtkNew<vtkSubPixelPositionEdgels> spe;
   spe->SetInputConnection(gf->GetOutputPort());
   i2sp->Update();
   spe->SetGradMapsData(i2sp->GetStructuredPointsOutput());
 
-  vtkSmartPointer<vtkStripper> strip =
-    vtkSmartPointer<vtkStripper>::New();
+  vtkNew<vtkStripper> strip;
   strip->SetInputConnection(spe->GetOutputPort());
 
-  vtkSmartPointer<vtkPolyDataMapper> dsm =
-    vtkSmartPointer<vtkPolyDataMapper>::New();
+  vtkNew<vtkPolyDataMapper> dsm;
   dsm->SetInputConnection(strip->GetOutputPort());
   dsm->ScalarVisibilityOff();
 
-  vtkSmartPointer<vtkActor> planeActor =
-    vtkSmartPointer<vtkActor>::New();
+  vtkNew<vtkActor> planeActor;
   planeActor->SetMapper(dsm);
   planeActor->GetProperty()->SetAmbient(1.0);
   planeActor->GetProperty()->SetDiffuse(0.0);
+  planeActor->GetProperty()->SetColor(
+      colors->GetColor3d("GhostWhite").GetData());
 
   // Add the actors to the renderer, set the background and size
   edgeRenderer->AddActor(planeActor);
diff --git a/src/Cxx/Images/Cast.cxx b/src/Cxx/Images/Cast.cxx
index fb558281e9f192878eed904fc33d6bba8d658777..6a1a14830fc47e9135d43f0f72a67adf99cec447 100644
--- a/src/Cxx/Images/Cast.cxx
+++ b/src/Cxx/Images/Cast.cxx
@@ -1,50 +1,48 @@
-#include <vtkImageData.h>
-#include <vtkSmartPointer.h>
-#include <vtkImageCast.h>
-#include <vtkImageMapper3D.h>
 #include <vtkImageActor.h>
+#include <vtkImageCast.h>
+#include <vtkImageData.h>
 #include <vtkImageMandelbrotSource.h>
+#include <vtkImageMapper3D.h>
+#include <vtkInteractorStyleImage.h>
+#include <vtkNamedColors.h>
+#include <vtkNew.h>
 #include <vtkRenderWindow.h>
 #include <vtkRenderWindowInteractor.h>
 #include <vtkRenderer.h>
-#include <vtkInteractorStyleImage.h>
 
-int main(int, char *[])
+int main(int, char*[])
 {
+  vtkNew<vtkNamedColors> colors;
+
   // Create a float image
-  vtkSmartPointer<vtkImageMandelbrotSource> source =
-    vtkSmartPointer<vtkImageMandelbrotSource>::New();
+  vtkNew<vtkImageMandelbrotSource> source;
   source->Update();
 
   std::cout << source->GetOutput()->GetScalarTypeAsString() << std::endl;
 
-  vtkSmartPointer<vtkImageCast> castFilter =
-    vtkSmartPointer<vtkImageCast>::New();
+  vtkNew<vtkImageCast> castFilter;
   castFilter->SetInputConnection(source->GetOutputPort());
   castFilter->SetOutputScalarTypeToUnsignedChar();
   castFilter->Update();
 
   // Create an actor
-  vtkSmartPointer<vtkImageActor> actor =
-    vtkSmartPointer<vtkImageActor>::New();
+  vtkNew<vtkImageActor> actor;
   actor->GetMapper()->SetInputConnection(castFilter->GetOutputPort());
-  
+
   // Setup renderer
-  vtkSmartPointer<vtkRenderer> renderer =
-    vtkSmartPointer<vtkRenderer>::New();
+  vtkNew<vtkRenderer> renderer;
   renderer->AddActor(actor);
+  renderer->SetBackground(colors->GetColor3d("DarkSlateGray").GetData());
   renderer->ResetCamera();
 
   // Setup render window
-  vtkSmartPointer<vtkRenderWindow> renderWindow =
-    vtkSmartPointer<vtkRenderWindow>::New();
+  vtkNew<vtkRenderWindow> renderWindow;
   renderWindow->AddRenderer(renderer);
+  renderWindow->SetWindowName("Cast");
 
   // Setup render window interactor
-  vtkSmartPointer<vtkRenderWindowInteractor> renderWindowInteractor =
-    vtkSmartPointer<vtkRenderWindowInteractor>::New();
-  vtkSmartPointer<vtkInteractorStyleImage> style =
-    vtkSmartPointer<vtkInteractorStyleImage>::New();
+  vtkNew<vtkRenderWindowInteractor> renderWindowInteractor;
+  vtkNew<vtkInteractorStyleImage> style;
 
   renderWindowInteractor->SetInteractorStyle(style);
 
@@ -54,5 +52,6 @@ int main(int, char *[])
   renderWindowInteractor->Initialize();
 
   renderWindowInteractor->Start();
+
   return EXIT_SUCCESS;
 }
diff --git a/src/Cxx/Images/Cast.md b/src/Cxx/Images/Cast.md
index 9e2ad9757690f192f417cc26a33476359582a839..4aa164ee196c0f2455bcc11c40df1bb88079c011 100644
--- a/src/Cxx/Images/Cast.md
+++ b/src/Cxx/Images/Cast.md
@@ -1,2 +1,3 @@
 ### Description
+
 Cast an image to a different type.
diff --git a/src/Cxx/Images/CenterAnImage.cxx b/src/Cxx/Images/CenterAnImage.cxx
index bf4f3dc1e34d666b9dbeced261fd6aa211ceadf7..226a084207f16fc44ce6b5a2720d91313ec5c990 100644
--- a/src/Cxx/Images/CenterAnImage.cxx
+++ b/src/Cxx/Images/CenterAnImage.cxx
@@ -1,36 +1,44 @@
-#include <vtkSmartPointer.h>
-
 #include <vtkActor.h>
 #include <vtkBorderRepresentation.h>
 #include <vtkBorderWidget.h>
 #include <vtkCommand.h>
 #include <vtkImageActor.h>
-#include <vtkImageMapper3D.h>
 #include <vtkImageChangeInformation.h>
 #include <vtkImageClip.h>
 #include <vtkImageData.h>
-#include <vtkInteractorStyleImage.h>
-#include <vtkImageReader2Factory.h>
+#include <vtkImageMapper3D.h>
 #include <vtkImageReader2.h>
+#include <vtkImageReader2Factory.h>
+#include <vtkInteractorStyleImage.h>
 #include <vtkMath.h>
+#include <vtkNamedColors.h>
+#include <vtkNew.h>
 #include <vtkProperty2D.h>
 #include <vtkRenderWindow.h>
 #include <vtkRenderWindowInteractor.h>
 #include <vtkRenderer.h>
+#include <vtkSmartPointer.h>
 #include <vtkXMLPolyDataReader.h>
-#include <vtkNamedColors.h>
+
+#include <iomanip>
+#include <iostream>
+#include <sstream>
+
+namespace {
 
 class vtkBorderCallback : public vtkCommand
 {
 public:
-  vtkBorderCallback(){}
+  vtkBorderCallback()
+  {
+  }
 
-  static vtkBorderCallback *New()
+  static vtkBorderCallback* New()
   {
     return new vtkBorderCallback;
   }
 
-  virtual void Execute(vtkObject *caller, unsigned long, void*);
+  virtual void Execute(vtkObject* caller, unsigned long, void*);
 
   void SetRenderer(vtkSmartPointer<vtkRenderer> renderer)
   {
@@ -42,25 +50,27 @@ public:
   }
 
 private:
-  vtkSmartPointer<vtkRenderer>   Renderer;
+  vtkSmartPointer<vtkRenderer> Renderer;
   vtkSmartPointer<vtkImageActor> ImageActor;
 };
 
+} // namespace
+
 int main(int argc, char* argv[])
 {
-  if ( argc != 2 )
+  vtkNew<vtkNamedColors> colors;
+
+  if (argc != 2)
   {
     std::cerr << "Usage: " << argv[0]
-              << " Required parameters: Filename" << std::endl;
+              << " Required parameters: Filename e.g. Ox.jpg" << std::endl;
     return EXIT_FAILURE;
   }
 
   // Read the image
-  vtkSmartPointer<vtkImageReader2Factory> readerFactory =
-    vtkSmartPointer<vtkImageReader2Factory>::New();
+  vtkNew<vtkImageReader2Factory> readerFactory;
   vtkSmartPointer<vtkImageReader2> imageReader;
-  imageReader.TakeReference(
-    readerFactory->CreateImageReader2(argv[1]));
+  imageReader.TakeReference(readerFactory->CreateImageReader2(argv[1]));
   imageReader->SetFileName(argv[1]);
   imageReader->Update();
 
@@ -68,89 +78,83 @@ int main(int argc, char* argv[])
   int dims[3];
   imageReader->GetOutput()->GetDimensions(dims);
 
-  vtkSmartPointer<vtkImageChangeInformation> changeInformation =
-    vtkSmartPointer<vtkImageChangeInformation>::New();
+  vtkNew<vtkImageChangeInformation> changeInformation;
   changeInformation->SetInputConnection(imageReader->GetOutputPort());
   changeInformation->CenterImageOn();
   changeInformation->Update();
 
-  vtkSmartPointer<vtkImageData> image =
-    changeInformation->GetOutput();
+  vtkSmartPointer<vtkImageData> image = changeInformation->GetOutput();
 
-  vtkSmartPointer<vtkImageActor> imageActor =
-    vtkSmartPointer<vtkImageActor>::New();
+  vtkNew<vtkImageActor> imageActor;
   imageActor->GetMapper()->SetInputData(image);
 
-  vtkSmartPointer<vtkRenderWindow> renderWindow =
-    vtkSmartPointer<vtkRenderWindow>::New();
+  vtkNew<vtkRenderWindow> renderWindow;
 
-  vtkSmartPointer<vtkRenderWindowInteractor> interactor =
-    vtkSmartPointer<vtkRenderWindowInteractor>::New();
+  vtkNew<vtkRenderWindowInteractor> interactor;
 
-  vtkSmartPointer<vtkInteractorStyleImage> style =
-    vtkSmartPointer<vtkInteractorStyleImage>::New();
-  interactor->SetInteractorStyle( style );
+  vtkNew<vtkInteractorStyleImage> style;
+  interactor->SetInteractorStyle(style);
 
-  vtkSmartPointer<vtkBorderWidget> borderWidget =
-    vtkSmartPointer<vtkBorderWidget>::New();
+  vtkNew<vtkBorderWidget> borderWidget;
   borderWidget->SetInteractor(interactor);
   static_cast<vtkBorderRepresentation*>(borderWidget->GetRepresentation())
-    ->GetBorderProperty()->SetColor(0,1,0);
+      ->GetBorderProperty()
+      ->SetColor(colors->GetColor3d("Chartreuse").GetData());
   borderWidget->SelectableOff();
 
   interactor->SetRenderWindow(renderWindow);
 
   // Setup both renderers
-  vtkSmartPointer<vtkNamedColors> colors =
-    vtkSmartPointer<vtkNamedColors>::New();
-  vtkSmartPointer<vtkRenderer> renderer =
-    vtkSmartPointer<vtkRenderer>::New();
-  renderer->SetBackground(colors->GetColor3d("Wheat").GetData());
+  vtkNew<vtkRenderer> renderer;
+  renderer->SetBackground(colors->GetColor3d("Peru").GetData());
   renderWindow->AddRenderer(renderer);
 
   renderer->AddActor(imageActor);
 
   renderer->ResetCamera();
 
-  vtkSmartPointer<vtkBorderCallback> borderCallback =
-    vtkSmartPointer<vtkBorderCallback>::New();
+  vtkNew<vtkBorderCallback> borderCallback;
   borderCallback->SetRenderer(renderer);
   borderCallback->SetImageActor(imageActor);
 
-  borderWidget->AddObserver(vtkCommand::InteractionEvent,borderCallback);
+  borderWidget->AddObserver(vtkCommand::InteractionEvent, borderCallback);
   borderWidget->On();
+  renderWindow->SetWindowName("CenterAnImage");
   renderWindow->Render();
   interactor->Start();
 
   return EXIT_SUCCESS;
 }
 
-void vtkBorderCallback::Execute(vtkObject *caller, unsigned long, void*)
+namespace {
+
+void vtkBorderCallback::Execute(vtkObject* caller, unsigned long, void*)
 {
+  // Use this to format the output
+  auto fmt = [](const double& x) {
+    std::ostringstream os;
+    os << std::fixed << std::setprecision(2) << std::setw(8) << x;
+    return os.str();
+  };
 
-  vtkBorderWidget *borderWidget =
-    reinterpret_cast<vtkBorderWidget*>(caller);
+  vtkBorderWidget* borderWidget = reinterpret_cast<vtkBorderWidget*>(caller);
 
   // Get the world coordinates of the two corners of the box
   vtkCoordinate* lowerLeftCoordinate =
-    static_cast<vtkBorderRepresentation*>(
-      borderWidget->GetRepresentation())->GetPositionCoordinate();
+      static_cast<vtkBorderRepresentation*>(borderWidget->GetRepresentation())
+          ->GetPositionCoordinate();
   double* lowerLeft =
-    lowerLeftCoordinate->GetComputedWorldValue(this->Renderer);
-  std::cout << "Lower left coordinate: "
-            << lowerLeft[0] << ", "
-            << lowerLeft[1] << ", "
-            << lowerLeft[2] << std::endl;
+      lowerLeftCoordinate->GetComputedWorldValue(this->Renderer);
+  std::cout << "Lower left coordinate:  " << fmt(lowerLeft[0]) << ","
+            << fmt(lowerLeft[1]) << "," << fmt(lowerLeft[2]) << std::endl;
 
   vtkCoordinate* upperRightCoordinate =
-    static_cast<vtkBorderRepresentation*>(
-      borderWidget->GetRepresentation())->GetPosition2Coordinate();
+      static_cast<vtkBorderRepresentation*>(borderWidget->GetRepresentation())
+          ->GetPosition2Coordinate();
   double* upperRight =
-    upperRightCoordinate->GetComputedWorldValue(this->Renderer);
-  std::cout << "Upper right coordinate: "
-            << upperRight[0] << ", "
-            << upperRight[1] << ", "
-            << upperRight[2] << std::endl;
+      upperRightCoordinate->GetComputedWorldValue(this->Renderer);
+  std::cout << "Upper right coordinate: " << fmt(upperRight[0]) << ","
+            << fmt(upperRight[1]) << "," << fmt(upperRight[2]) << std::endl;
 
   double* bounds = this->ImageActor->GetBounds();
   double xmin = bounds[0];
@@ -158,16 +162,17 @@ void vtkBorderCallback::Execute(vtkObject *caller, unsigned long, void*)
   double ymin = bounds[2];
   double ymax = bounds[3];
 
-  if( (lowerLeft[0] > xmin) &&
-      (upperRight[0] < xmax) &&
-      (lowerLeft[1] > ymin) &&
-      (upperRight[1] < ymax) )
+  if ((lowerLeft[0] > xmin) && (upperRight[0] < xmax) &&
+      (lowerLeft[1] > ymin) && (upperRight[1] < ymax))
   {
-    //std::cout << "box is inside image" << std::endl;
-    //std::cout << "xmin: " << xmin << " xmax: " << xmax << " ymin: " << ymin << " ymax: " << ymax << std::endl;
+    // std::cout << "box is inside image" << std::endl;
+    // std::cout << "xmin: " << xmin << " xmax: " << xmax << " ymin: " << ymin
+    // << " ymax: " << ymax << std::endl;
   }
   else
   {
     std::cout << "box is NOT inside image" << std::endl;
   }
 }
+
+} // namespace
diff --git a/src/Cxx/Images/CenterAnImage.md b/src/Cxx/Images/CenterAnImage.md
index 0f7fbc9fbba4b37cd5cc4ba80c5ac8a58727b1c4..01c865cd617db206676f2b2cbd5cdeb87f80cf18 100644
--- a/src/Cxx/Images/CenterAnImage.md
+++ b/src/Cxx/Images/CenterAnImage.md
@@ -1,2 +1,3 @@
 ### Description
+
 This moves (0,0) from the bottom left corner of the image to the center of the image.
diff --git a/src/Cxx/Images/Colored2DImageFusion.cxx b/src/Cxx/Images/Colored2DImageFusion.cxx
index a9e11dd0095ca592766a8d6ec42ae1838df23090..158b3f1a98588cfe8e01b08985dc419548421f0d 100644
--- a/src/Cxx/Images/Colored2DImageFusion.cxx
+++ b/src/Cxx/Images/Colored2DImageFusion.cxx
@@ -1,90 +1,82 @@
-#include <vtkSmartPointer.h>
-
-#include <vtkImageReader2Factory.h>
-#include <vtkImageReader2.h>
 #include <vtkActor.h>
 #include <vtkDataSet.h>
 #include <vtkDataSetMapper.h>
 #include <vtkImageBlend.h>
 #include <vtkImageData.h>
 #include <vtkImageMapToColors.h>
+#include <vtkImageReader2.h>
+#include <vtkImageReader2Factory.h>
 #include <vtkLookupTable.h>
+#include <vtkNamedColors.h>
 #include <vtkRenderWindow.h>
 #include <vtkRenderWindowInteractor.h>
 #include <vtkRenderer.h>
+#include <vtkSmartPointer.h>
 
-int main(int argc, char *argv[])
+int main(int argc, char* argv[])
 {
+  vtkNew<vtkNamedColors> colors;
+
   // Parse input arguments
-  if ( argc < 3 )
+  if (argc < 3)
   {
     std::cerr << "Usage: " << argv[0]
-              << " Input1Filename Input2Filename" << std::endl;
+              << " Input1Filename Input2Filename e.g. Ox.jpg Gourds2.jpg"
+              << std::endl;
     return EXIT_FAILURE;
   }
 
-  vtkSmartPointer<vtkLookupTable> imgFirstColorMap =
-    vtkSmartPointer<vtkLookupTable>::New(); // hot color map
-  imgFirstColorMap->SetRange( 0.0, 255.0 );
-  imgFirstColorMap->SetHueRange( 0.0, 0.1 );
-  imgFirstColorMap->SetValueRange( 0.4, 0.8 );
+  vtkNew<vtkLookupTable> imgFirstColorMap;
+  imgFirstColorMap->SetRange(0.0, 255.0);
+  imgFirstColorMap->SetHueRange(0.0, 0.1);
+  imgFirstColorMap->SetValueRange(0.4, 0.8);
   imgFirstColorMap->Build();
 
-  vtkSmartPointer<vtkLookupTable> imgSecondColorMap =
-      vtkSmartPointer<vtkLookupTable>::New(); // cold color map
-  imgSecondColorMap->SetRange( 0.0, 255.0 );
-  imgSecondColorMap->SetHueRange( 0.67, 0.68 );
-  imgSecondColorMap->SetValueRange( 0.4, 0.8 );
+  vtkNew<vtkLookupTable> imgSecondColorMap;
+  imgSecondColorMap->SetRange(0.0, 255.0);
+  imgSecondColorMap->SetHueRange(0.67, 0.68);
+  imgSecondColorMap->SetValueRange(0.4, 0.8);
   imgSecondColorMap->Build();
 
-  vtkSmartPointer<vtkImageReader2Factory> readerFactory =
-    vtkSmartPointer<vtkImageReader2Factory>::New();
+  vtkNew<vtkImageReader2Factory> readerFactory;
   vtkSmartPointer<vtkImageReader2> imgReader;
-  imgReader.TakeReference(
-    readerFactory->CreateImageReader2(argv[1]));
+  imgReader.TakeReference(readerFactory->CreateImageReader2(argv[1]));
   imgReader->SetFileName(argv[1]);
 
   vtkSmartPointer<vtkImageReader2> imgReaderMoving;
-  imgReaderMoving.TakeReference(
-    readerFactory->CreateImageReader2(argv[2]));
+  imgReaderMoving.TakeReference(readerFactory->CreateImageReader2(argv[2]));
   imgReaderMoving->SetFileName(argv[2]);
 
-  vtkSmartPointer<vtkImageMapToColors> firstColorMapper =
-      vtkSmartPointer<vtkImageMapToColors>::New();
-  firstColorMapper->SetInputConnection( imgReader->GetOutputPort() );
-  firstColorMapper->SetLookupTable( imgFirstColorMap );
+  vtkNew<vtkImageMapToColors> firstColorMapper;
+  firstColorMapper->SetInputConnection(imgReader->GetOutputPort());
+  firstColorMapper->SetLookupTable(imgFirstColorMap);
 
-  vtkSmartPointer<vtkImageMapToColors> secondColorMapper =
-      vtkSmartPointer<vtkImageMapToColors>::New();
-  secondColorMapper->SetInputConnection( imgReaderMoving->GetOutputPort() );
-  secondColorMapper->SetLookupTable( imgSecondColorMap );
+  vtkNew<vtkImageMapToColors> secondColorMapper;
+  secondColorMapper->SetInputConnection(imgReaderMoving->GetOutputPort());
+  secondColorMapper->SetLookupTable(imgSecondColorMap);
 
-  vtkSmartPointer<vtkImageBlend> imgBlender =
-      vtkSmartPointer<vtkImageBlend>::New();
-  imgBlender->SetOpacity( 0, 0.5 );
-  imgBlender->SetOpacity( 1, 0.5 );
-  imgBlender->AddInputConnection( firstColorMapper->GetOutputPort() );
-  imgBlender->AddInputConnection( secondColorMapper->GetOutputPort() );
+  vtkNew<vtkImageBlend> imgBlender;
+  imgBlender->SetOpacity(0, 0.5);
+  imgBlender->SetOpacity(1, 0.5);
+  imgBlender->AddInputConnection(firstColorMapper->GetOutputPort());
+  imgBlender->AddInputConnection(secondColorMapper->GetOutputPort());
 
-  vtkSmartPointer<vtkDataSetMapper> imgDataSetMapper =
-      vtkSmartPointer<vtkDataSetMapper>::New();
+  vtkNew<vtkDataSetMapper> imgDataSetMapper;
   imgDataSetMapper->SetInputConnection(imgBlender->GetOutputPort());
 
-  vtkSmartPointer<vtkActor> imgActor =
-      vtkSmartPointer<vtkActor>::New();
-  imgActor->SetMapper( imgDataSetMapper );
+  vtkNew<vtkActor> imgActor;
+  imgActor->SetMapper(imgDataSetMapper);
 
-  vtkSmartPointer<vtkRenderer> imgRenderer =
-      vtkSmartPointer<vtkRenderer>::New();
-  imgRenderer->AddActor( imgActor );
+  vtkNew<vtkRenderer> imgRenderer;
+  imgRenderer->AddActor(imgActor);
+  imgRenderer->SetBackground(colors->GetColor3d("BurlyWood").GetData());
 
-  vtkSmartPointer<vtkRenderWindow> imgRenderWindow =
-      vtkSmartPointer<vtkRenderWindow>::New();
-  imgRenderWindow->AddRenderer( imgRenderer );
+  vtkNew<vtkRenderWindow> imgRenderWindow;
+  imgRenderWindow->AddRenderer(imgRenderer);
+  imgRenderWindow->SetWindowName("Colored2DImageFusion");
 
-  vtkSmartPointer<vtkRenderWindowInteractor> imgInteractor =
-      vtkSmartPointer<vtkRenderWindowInteractor>::New();
-  imgInteractor->SetRenderWindow( imgRenderWindow );
+  vtkNew<vtkRenderWindowInteractor> imgInteractor;
+  imgInteractor->SetRenderWindow(imgRenderWindow);
   imgRenderWindow->Render();
   imgInteractor->Initialize();
   imgInteractor->Start();
diff --git a/src/Cxx/Images/Colored2DImageFusion.md b/src/Cxx/Images/Colored2DImageFusion.md
index 17484e0898a52cf2393f66582dd0210acce315a3..7162ffee3dc7d8d31860b429c03ce7f8797c03fc 100644
--- a/src/Cxx/Images/Colored2DImageFusion.md
+++ b/src/Cxx/Images/Colored2DImageFusion.md
@@ -1,4 +1,5 @@
 ### Description
+
 This example use the vtkImageBlend class for a simple fusion of two 2D images with different color maps for each of the images.
 
 * Contributed by: Tim Hutz
diff --git a/src/Cxx/Images/CombineImages.cxx b/src/Cxx/Images/CombineImages.cxx
index 0df4dcbcaafe0b134b2c85e6274002c9935a3409..04e02ee347a0619601ad685dfb322f25a9be3f0f 100644
--- a/src/Cxx/Images/CombineImages.cxx
+++ b/src/Cxx/Images/CombineImages.cxx
@@ -1,61 +1,57 @@
 #include <vtkImageBlend.h>
-#include <vtkSmartPointer.h>
-
-#include <vtkImageReader2Factory.h>
+#include <vtkImageData.h>
 #include <vtkImageReader2.h>
+#include <vtkImageReader2Factory.h>
+#include <vtkImageViewer2.h>
+#include <vtkNamedColors.h>
+#include <vtkNew.h>
 #include <vtkRenderWindow.h>
 #include <vtkRenderWindowInteractor.h>
 #include <vtkRenderer.h>
-#include <vtkImageData.h>
-#include <vtkImageViewer2.h>
-#include <vtkNamedColors.h>
+#include <vtkSmartPointer.h>
 
 #include <string>
 
-int main ( int argc, char* argv[] )
+int main(int argc, char* argv[])
 {
+  vtkNew<vtkNamedColors> colors;
+
   // Parse input arguments
-  if ( argc != 3 )
+  if (argc != 3)
   {
     std::cerr << "Usage: " << argv[0]
-              << " Input1Filename Input2Filename" << std::endl;
+              << " Input1Filename Input2Filename  e.g. Ox.jpg Gourds2.jpg"
+              << std::endl;
     return EXIT_FAILURE;
   }
 
   // Read the images
-  vtkSmartPointer<vtkImageReader2Factory> readerFactory =
-    vtkSmartPointer<vtkImageReader2Factory>::New();
+  vtkNew<vtkImageReader2Factory> readerFactory;
   vtkSmartPointer<vtkImageReader2> imgReader1;
-  imgReader1.TakeReference(
-    readerFactory->CreateImageReader2(argv[1]));
+  imgReader1.TakeReference(readerFactory->CreateImageReader2(argv[1]));
   imgReader1->SetFileName(argv[1]);
 
   vtkSmartPointer<vtkImageReader2> imgReader2;
-  imgReader2.TakeReference(
-    readerFactory->CreateImageReader2(argv[2]));
+  imgReader2.TakeReference(readerFactory->CreateImageReader2(argv[2]));
   imgReader2->SetFileName(argv[2]);
 
   // Combine the images (blend takes multiple connections on the 0th input port)
-  vtkSmartPointer<vtkImageBlend> blend =
-    vtkSmartPointer<vtkImageBlend>::New();
+  vtkNew<vtkImageBlend> blend;
   blend->AddInputConnection(imgReader1->GetOutputPort());
   blend->AddInputConnection(imgReader2->GetOutputPort());
-  blend->SetOpacity(0,.5);
-  blend->SetOpacity(1,.5);
+  blend->SetOpacity(0, 0.5);
+  blend->SetOpacity(1, 0.5);
 
   // Display the result
-  vtkSmartPointer<vtkRenderWindowInteractor> renderWindowInteractor =
-    vtkSmartPointer<vtkRenderWindowInteractor>::New();
+  vtkNew<vtkRenderWindowInteractor> renderWindowInteractor;
 
-  vtkSmartPointer<vtkNamedColors> colors =
-    vtkSmartPointer<vtkNamedColors>::New();
-  vtkSmartPointer<vtkImageViewer2> imageViewer =
-    vtkSmartPointer<vtkImageViewer2>::New();
+  vtkNew<vtkImageViewer2> imageViewer;
   imageViewer->SetInputConnection(blend->GetOutputPort());
   imageViewer->SetupInteractor(renderWindowInteractor);
   imageViewer->GetRenderer()->ResetCamera();
   imageViewer->GetRenderer()->SetBackground(
-    colors->GetColor3d("Wheat").GetData());
+      colors->GetColor3d("Peru").GetData());
+  imageViewer->GetRenderWindow()->SetWindowName("CombineImages");
 
   imageViewer->GetRenderer()->Render();
   renderWindowInteractor->Initialize();
diff --git a/src/Cxx/Images/CombineImages.md b/src/Cxx/Images/CombineImages.md
index 6a94e8f0e044eb6ef6968bca8669c5beb1b6da6c..72bfc06b34754696f6da35b4c3eafaa76a972fea 100644
--- a/src/Cxx/Images/CombineImages.md
+++ b/src/Cxx/Images/CombineImages.md
@@ -1,2 +1,3 @@
 ### Description
-This example takes two images and super imposes them. The opacity of each image can be set to control how they are combined.
+
+This example takes two images and superimposes them. The opacity of each image can be set to control how they are combined.
diff --git a/src/Cxx/Images/CombiningRGBChannels.cxx b/src/Cxx/Images/CombiningRGBChannels.cxx
index 9395bd83a1e3c8939d64ae70beeaf24bdc3f3873..3f49e1c033b0d36864fbe3b2dc1d422d85d023c6 100644
--- a/src/Cxx/Images/CombiningRGBChannels.cxx
+++ b/src/Cxx/Images/CombiningRGBChannels.cxx
@@ -1,77 +1,84 @@
-#include <vtkSmartPointer.h>
+#include <vtkImageActor.h>
 #include <vtkImageAppendComponents.h>
-
+#include <vtkImageCanvasSource2D.h>
 #include <vtkImageData.h>
 #include <vtkImageMapper3D.h>
-#include <vtkImageCanvasSource2D.h>
+#include <vtkInteractorStyleImage.h>
+#include <vtkNamedColors.h>
+#include <vtkNew.h>
 #include <vtkRenderWindow.h>
 #include <vtkRenderWindowInteractor.h>
-#include <vtkInteractorStyleImage.h>
 #include <vtkRenderer.h>
-#include <vtkImageActor.h>
 
-#include <vtkNamedColors.h>
+#include <array>
 
-int main(int, char *[])
+int main(int, char*[])
 {
+  vtkNew<vtkNamedColors> colors;
+
+  std::array<double, 4> drawColor1{0, 0, 0, 0};
+  std::array<double, 4> drawColor2{0, 0, 0, 0};
+  auto color1 = colors->GetColor4ub("Black").GetData();
+  auto color2 = colors->GetColor4ub("Red").GetData();
+  for (auto i = 0; i < 4; ++i)
+  {
+    drawColor1[i] = color1[i];
+    drawColor2[i] = color2[i];
+  }
+  // Set the alpha to 0 (actually alpha doesn't seem to be used)
+  drawColor1[3] = 0;
+  drawColor2[3] = 0;
+
   // Create an image (will be used as the R channel)
-  vtkSmartPointer<vtkImageCanvasSource2D> red =
-    vtkSmartPointer<vtkImageCanvasSource2D>::New();
+  vtkNew<vtkImageCanvasSource2D> red;
   red->SetScalarTypeToUnsignedChar();
   red->SetNumberOfScalarComponents(1);
   red->SetExtent(0, 100, 0, 100, 0, 0);
-  red->SetDrawColor(0, 0, 0, 0);
-  red->FillBox(0,100,0,100);
-  red->SetDrawColor(255, 0, 0, 0);
-  red->FillBox(20,40,20,40);
+  red->SetDrawColor(drawColor1.data());
+  red->FillBox(0, 100, 0, 100);
+  red->SetDrawColor(drawColor2.data());
+  red->FillBox(20, 40, 20, 40);
   red->Update();
 
   // Create an image (will be used as the G channel)
-  vtkSmartPointer<vtkImageCanvasSource2D> green =
-    vtkSmartPointer<vtkImageCanvasSource2D>::New();
+  vtkNew<vtkImageCanvasSource2D> green;
   green->SetScalarTypeToUnsignedChar();
   green->SetNumberOfScalarComponents(1);
   green->SetExtent(0, 100, 0, 100, 0, 0);
-  green->SetDrawColor(0, 0, 0, 0);
-  green->FillBox(0,100,0,100);
-  green->SetDrawColor(255, 0, 0, 0);
-  green->FillBox(30,50,30,50);
+  green->SetDrawColor(drawColor1.data());
+  green->FillBox(0, 100, 0, 100);
+  green->SetDrawColor(drawColor2.data());
+  green->FillBox(30, 50, 30, 50);
   green->Update();
 
   // Create an image (will be used as the B channel)
-  vtkSmartPointer<vtkImageCanvasSource2D> blue =
-    vtkSmartPointer<vtkImageCanvasSource2D>::New();
+  vtkNew<vtkImageCanvasSource2D> blue;
   blue->SetScalarTypeToUnsignedChar();
   blue->SetNumberOfScalarComponents(1);
   blue->SetExtent(0, 100, 0, 100, 0, 0);
-  blue->SetDrawColor(0, 0, 0, 0);
-  blue->FillBox(0,100,0,100);
-  blue->SetDrawColor(255, 0, 0, 0);
-  blue->FillBox(40,60,40,60);
+  blue->SetDrawColor(drawColor1.data());
+  blue->FillBox(0, 100, 0, 100);
+  blue->SetDrawColor(drawColor2.data());
+  blue->FillBox(40, 60, 40, 60);
   blue->Update();
 
-  vtkSmartPointer<vtkImageAppendComponents> appendFilter =
-    vtkSmartPointer<vtkImageAppendComponents>::New();
+  vtkNew<vtkImageAppendComponents> appendFilter;
   appendFilter->SetInputConnection(0, red->GetOutputPort());
   appendFilter->AddInputConnection(0, green->GetOutputPort());
   appendFilter->AddInputConnection(0, blue->GetOutputPort());
   appendFilter->Update();
 
   // Create actors
-  vtkSmartPointer<vtkImageActor> redActor =
-    vtkSmartPointer<vtkImageActor>::New();
+  vtkNew<vtkImageActor> redActor;
   redActor->GetMapper()->SetInputConnection(red->GetOutputPort());
 
-  vtkSmartPointer<vtkImageActor> greenActor =
-    vtkSmartPointer<vtkImageActor>::New();
+  vtkNew<vtkImageActor> greenActor;
   greenActor->GetMapper()->SetInputConnection(green->GetOutputPort());
 
-  vtkSmartPointer<vtkImageActor> blueActor =
-    vtkSmartPointer<vtkImageActor>::New();
+  vtkNew<vtkImageActor> blueActor;
   blueActor->GetMapper()->SetInputConnection(blue->GetOutputPort());
 
-  vtkSmartPointer<vtkImageActor> combinedActor =
-    vtkSmartPointer<vtkImageActor>::New();
+  vtkNew<vtkImageActor> combinedActor;
   combinedActor->GetMapper()->SetInputConnection(appendFilter->GetOutputPort());
 
   // Define viewport ranges
@@ -80,53 +87,44 @@ int main(int, char *[])
   double greenViewport[4] = {0.25, 0.0, 0.5, 1.0};
   double blueViewport[4] = {0.5, 0.0, 0.75, 1.0};
   double combinedViewport[4] = {0.75, 0.0, 1.0, 1.0};
-  
-  vtkSmartPointer<vtkNamedColors> colors =
-    vtkSmartPointer<vtkNamedColors>::New();
 
   // Setup renderers
-  vtkSmartPointer<vtkRenderer> redRenderer =
-    vtkSmartPointer<vtkRenderer>::New();
+  vtkNew<vtkRenderer> redRenderer;
   redRenderer->SetViewport(redViewport);
   redRenderer->AddActor(redActor);
   redRenderer->ResetCamera();
   redRenderer->SetBackground(colors->GetColor3d("Tomato").GetData());
 
-  vtkSmartPointer<vtkRenderer> greenRenderer =
-    vtkSmartPointer<vtkRenderer>::New();
+  vtkNew<vtkRenderer> greenRenderer;
   greenRenderer->SetViewport(greenViewport);
   greenRenderer->AddActor(greenActor);
   greenRenderer->ResetCamera();
   greenRenderer->SetBackground(colors->GetColor3d("Mint").GetData());
-  
-  vtkSmartPointer<vtkRenderer> blueRenderer =
-    vtkSmartPointer<vtkRenderer>::New();
+
+  vtkNew<vtkRenderer> blueRenderer;
   blueRenderer->SetViewport(blueViewport);
   blueRenderer->AddActor(blueActor);
   blueRenderer->ResetCamera();
   blueRenderer->SetBackground(colors->GetColor3d("Peacock").GetData());
-  
-  vtkSmartPointer<vtkRenderer> combinedRenderer =
-    vtkSmartPointer<vtkRenderer>::New();
+
+  vtkNew<vtkRenderer> combinedRenderer;
   combinedRenderer->SetViewport(combinedViewport);
   combinedRenderer->AddActor(combinedActor);
   combinedRenderer->ResetCamera();
   combinedRenderer->SetBackground(colors->GetColor3d("Snow").GetData());
 
   // Setup render window
-  vtkSmartPointer<vtkRenderWindow> renderWindow =
-    vtkSmartPointer<vtkRenderWindow>::New();
+  vtkNew<vtkRenderWindow> renderWindow;
   renderWindow->SetSize(1000, 250);
   renderWindow->AddRenderer(redRenderer);
   renderWindow->AddRenderer(greenRenderer);
   renderWindow->AddRenderer(blueRenderer);
   renderWindow->AddRenderer(combinedRenderer);
+  renderWindow->SetWindowName("CombiningRGBChannels");
 
   // Setup render window interactor
-  vtkSmartPointer<vtkRenderWindowInteractor> renderWindowInteractor =
-    vtkSmartPointer<vtkRenderWindowInteractor>::New();
-  vtkSmartPointer<vtkInteractorStyleImage> style =
-    vtkSmartPointer<vtkInteractorStyleImage>::New();
+  vtkNew<vtkRenderWindowInteractor> renderWindowInteractor;
+  vtkNew<vtkInteractorStyleImage> style;
 
   renderWindowInteractor->SetInteractorStyle(style);
 
@@ -136,5 +134,6 @@ int main(int, char *[])
   renderWindowInteractor->Initialize();
 
   renderWindowInteractor->Start();
+
   return EXIT_SUCCESS;
 }
diff --git a/src/Python/Images/Actor2D.py b/src/Python/Images/Actor2D.py
index a0feb1615ec84da44c2fc4026903932236cf3673..3f14d559770bfc563fe541f114c977c5a703b8e1 100644
--- a/src/Python/Images/Actor2D.py
+++ b/src/Python/Images/Actor2D.py
@@ -2,52 +2,56 @@
 
 import vtk
 
+
 def main():
-    
     colors = vtk.vtkNamedColors()
     points = vtk.vtkPoints()
-    points.InsertNextPoint(10,10,0)
-    points.InsertNextPoint(100,100,0)
-    points.InsertNextPoint(200,200,0)
-    
+    points.InsertNextPoint(10, 10, 0)
+    points.InsertNextPoint(100, 100, 0)
+    points.InsertNextPoint(200, 200, 0)
+
     polydata = vtk.vtkPolyData()
     polydata.SetPoints(points)
-    
+
     glyphFilter = vtk.vtkVertexGlyphFilter()
     glyphFilter.SetInputData(polydata)
     glyphFilter.Update()
-    
+
     mapper = vtk.vtkPolyDataMapper2D()
     mapper.SetInputConnection(glyphFilter.GetOutputPort())
     mapper.Update()
-    
+
     actor = vtk.vtkActor2D()
     actor.SetMapper(mapper)
-    
+    actor.GetProperty().SetColor(colors.GetColor3d('Gold'))
+    actor.GetProperty().SetPointSize(8)
+
     # Create a renderer, render window, and interactor
     renderer = vtk.vtkRenderer()
     renderWindow = vtk.vtkRenderWindow()
     renderWindow.AddRenderer(renderer)
     renderWindowInteractor = vtk.vtkRenderWindowInteractor()
     renderWindowInteractor.SetRenderWindow(renderWindow)
-    
+
     # Add the actor to the scene
     renderer.AddActor(actor)
-    renderWindow.SetSize(300,300)
-    actor.GetProperty().SetColor(colors.GetColor3d("green")) 
-    actor.GetProperty().SetPointSize(6)
-    
+    renderWindow.SetSize(300, 300)
+    renderer.SetBackground(colors.GetColor3d('DarkSlateGray'))
+
+    renderWindow.SetWindowName('Actor2D')
+
     # Render and interact
     renderWindow.Render()
-    w2if = vtk.vtkWindowToImageFilter()
-    w2if.SetInput(renderWindow)
-    w2if.Update()
-    
-    writer = vtk.vtkPNGWriter()
-    writer.SetFileName("TestActor2D.png")
-    writer.SetInputConnection(w2if.GetOutputPort())
-    writer.Write()
+    # w2if = vtk.vtkWindowToImageFilter()
+    # w2if.SetInput(renderWindow)
+    # w2if.Update()
+    #
+    # writer = vtk.vtkPNGWriter()
+    # writer.SetFileName('TestActor2D.png')
+    # writer.SetInputConnection(w2if.GetOutputPort())
+    # writer.Write()
     renderWindowInteractor.Start()
 
+
 if __name__ == '__main__':
     main()
diff --git a/src/Python/Images/BackgroundImage.md b/src/Python/Images/BackgroundImage.md
index ce493c928b9a5e999b6c99a65fac5815a29bcde7..e939d00b8e73c38cafeaa2d25696f34d46b801a7 100644
--- a/src/Python/Images/BackgroundImage.md
+++ b/src/Python/Images/BackgroundImage.md
@@ -1,4 +1,5 @@
 ### Description
+
 This example displays an image as the "background" of a scene, and renders a superquadric in front of it.
 
 The example accepts a jpeg file on the command line to use as a background image. If there is no file, it generates a simple background.
diff --git a/src/Python/Images/BackgroundImage.py b/src/Python/Images/BackgroundImage.py
index 71a17e3543b587539e13985099cc521a191c577a..528c25064b8fcbb433350aca3e22f2b5c661e208 100755
--- a/src/Python/Images/BackgroundImage.py
+++ b/src/Python/Images/BackgroundImage.py
@@ -1,7 +1,5 @@
 #!/usr/bin/env python
 
-from __future__ import print_function
-
 import vtk
 
 
@@ -20,16 +18,13 @@ def get_program_parameters():
 def main():
     colors = vtk.vtkNamedColors()
 
-    colors.SetColor('light_cyan', [100, 255, 255, 255])
-    colors.SetColor('light_magenta', [255, 100, 255, 255])
-
     #  Verify input arguments
     fn = get_program_parameters()
     if fn:
         # Read the image
         jpeg_reader = vtk.vtkJPEGReader()
         if not jpeg_reader.CanReadFile(fn):
-            print("Error reading file:", fn)
+            print('Error reading file:', fn)
             return
 
         jpeg_reader.SetFileName(fn)
@@ -42,9 +37,9 @@ def main():
         canvas_source.SetNumberOfScalarComponents(3)
         canvas_source.SetDrawColor(colors.GetColor4ub('warm_grey'))
         canvas_source.FillBox(0, 100, 0, 100)
-        canvas_source.SetDrawColor(colors.GetColor4ub('light_cyan'))
+        canvas_source.SetDrawColor(colors.GetColor4ub('DarkCyan'))
         canvas_source.FillTriangle(10, 10, 25, 10, 25, 25)
-        canvas_source.SetDrawColor(colors.GetColor4ub('light_magenta'))
+        canvas_source.SetDrawColor(colors.GetColor4ub('LightCoral'))
         canvas_source.FillTube(75, 75, 0, 75, 5.0)
         canvas_source.Update()
         image_data = canvas_source.GetOutput()
@@ -67,6 +62,7 @@ def main():
 
     superquadric_actor = vtk.vtkActor()
     superquadric_actor.SetMapper(superquadric_mapper)
+    superquadric_actor.GetProperty().SetColor(colors.GetColor3d('NavajoWhite'))
 
     scene_renderer = vtk.vtkRenderer()
     render_window = vtk.vtkRenderWindow()
@@ -79,6 +75,7 @@ def main():
     render_window.SetNumberOfLayers(2)
     render_window.AddRenderer(background_renderer)
     render_window.AddRenderer(scene_renderer)
+    render_window.SetWindowName('BackgroundImage')
 
     render_window_interactor = vtk.vtkRenderWindowInteractor()
     render_window_interactor.SetRenderWindow(render_window)
diff --git a/src/Python/Images/Cast.md b/src/Python/Images/Cast.md
index f5e643b0bc79926a7fdcfeff5ce40a7711342e7d..4aa164ee196c0f2455bcc11c40df1bb88079c011 100644
--- a/src/Python/Images/Cast.md
+++ b/src/Python/Images/Cast.md
@@ -1 +1,3 @@
+### Description
+
 Cast an image to a different type.
diff --git a/src/Python/Images/Cast.py b/src/Python/Images/Cast.py
index a8f0906b299ea628cc157dc3061e04463a7a4fe2..5836f85f20556ef66eadfbe8c44e607d59d16ac1 100644
--- a/src/Python/Images/Cast.py
+++ b/src/Python/Images/Cast.py
@@ -2,42 +2,47 @@
 
 import vtk
 
+
 def main():
+    colors = vtk.vtkNamedColors()
 
     # Create a float image
     source = vtk.vtkImageMandelbrotSource()
     source.Update()
-    
-    print (source.GetOutput().GetScalarTypeAsString())
-    
+
+    print(source.GetOutput().GetScalarTypeAsString())
+
     castFilter = vtk.vtkImageCast()
     castFilter.SetInputConnection(source.GetOutputPort())
     castFilter.SetOutputScalarTypeToUnsignedChar()
     castFilter.Update()
-    
+
     # Create an actor
     actor = vtk.vtkImageActor()
     actor.GetMapper().SetInputConnection(castFilter.GetOutputPort())
-    
+
     # Setup renderer
     renderer = vtk.vtkRenderer()
     renderer.AddActor(actor)
+    renderer.SetBackground(colors.GetColor3d('DarkSlateGray'))
     renderer.ResetCamera()
-    
+
     # Setup render window
     renderWindow = vtk.vtkRenderWindow()
     renderWindow.AddRenderer(renderer)
-    
+    renderWindow.SetWindowName('Cast')
+
     # Setup render window interactor
     renderWindowInteractor = vtk.vtkRenderWindowInteractor()
     style = vtk.vtkInteractorStyleImage()
     renderWindowInteractor.SetInteractorStyle(style)
-    
+
     # Render and start interaction
     renderWindowInteractor.SetRenderWindow(renderWindow)
     renderWindow.Render()
     renderWindowInteractor.Initialize()
     renderWindowInteractor.Start()
 
+
 if __name__ == '__main__':
     main()