diff --git a/src/Cxx/IO/3DSImporter.cxx b/src/Cxx/IO/3DSImporter.cxx
index 248f59bcd9e7fadeaba15fdf6d325aaf54d28728..e76bb3d7e37f3e84eb0a0920e689b1eb231554d5 100644
--- a/src/Cxx/IO/3DSImporter.cxx
+++ b/src/Cxx/IO/3DSImporter.cxx
@@ -2,11 +2,11 @@
 #include <vtkActor.h>
 #include <vtkCamera.h>
 #include <vtkNamedColors.h>
+#include <vtkNew.h>
 #include <vtkProperty.h>
 #include <vtkRenderWindow.h>
 #include <vtkRenderWindowInteractor.h>
 #include <vtkRenderer.h>
-#include <vtkSmartPointer.h>
 
 int main(int argc, char* argv[])
 {
@@ -17,15 +17,15 @@ int main(int argc, char* argv[])
     return EXIT_FAILURE;
   }
 
-  auto importer = vtkSmartPointer<vtk3DSImporter>::New();
+  vtkNew<vtk3DSImporter> importer;
   importer->SetFileName(argv[1]);
   importer->ComputeNormalsOn();
 
-  auto colors = vtkSmartPointer<vtkNamedColors>::New();
+  vtkNew<vtkNamedColors> colors;
 
-  auto renderer = vtkSmartPointer<vtkRenderer>::New();
-  auto renWin = vtkSmartPointer<vtkRenderWindow>::New();
-  auto iren = vtkSmartPointer<vtkRenderWindowInteractor>::New();
+  vtkNew<vtkRenderer> renderer;
+  vtkNew<vtkRenderWindow> renWin;
+  vtkNew<vtkRenderWindowInteractor> iren;
 
   renWin->AddRenderer(renderer);
   renderer->SetBackground2(colors->GetColor3d("Gold").GetData());
@@ -37,11 +37,14 @@ int main(int argc, char* argv[])
   importer->Update();
 
   auto actors = renderer->GetActors();
-  std::cout << "There are " << actors->GetNumberOfItems() << " actors"
+  std::cout << "There are " << actors->GetNumberOfItems() << " actors."
             << std::endl;
 
+  renWin->SetWindowName("3DSImporter");
+
   renWin->Render();
-  auto camera = vtkSmartPointer<vtkCamera>::New();
+
+  vtkNew<vtkCamera> camera;
   camera->SetPosition(0, -1, 0);
   camera->SetFocalPoint(0, 0, 0);
   camera->SetViewUp(0, 0, 1);
diff --git a/src/Cxx/IO/3DSImporter.md b/src/Cxx/IO/3DSImporter.md
index 2167de5e31c97cfc25c20cdd84a8b5d94ef73b91..883ea728f5c4a2e33ed3ff239c327ead4ade672b 100644
--- a/src/Cxx/IO/3DSImporter.md
+++ b/src/Cxx/IO/3DSImporter.md
@@ -4,5 +4,3 @@ This example illustrates Importing files in VTK. An importer creates a vtkRender
 
 !!! info
     See [Figure 4-13](/VTKBook/04Chapter4/#Figure%204-13) in [Chapter 4](/VTKBook/04Chapter4) the [VTK Textbook](/VTKBook/01Chapter1).
-
-
diff --git a/src/Cxx/IO/CMakeLists.txt b/src/Cxx/IO/CMakeLists.txt
index c4ebb0541d5badb19e39f9ed5712f200d70039eb..b034dbb6623d409cb792b06e88228a8308d7e4ac 100644
--- a/src/Cxx/IO/CMakeLists.txt
+++ b/src/Cxx/IO/CMakeLists.txt
@@ -149,11 +149,8 @@ if (BUILD_TESTING)
   add_test(${KIT}-ExportPolyDataScene ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${KIT}CxxTests
     TestExportPolyDataScene ${DATA}/Bunny.vtp)
 
-  add_test(${KIT}-ImportPolyDataScene ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${KIT}CxxTests
-    TestImportPolyDataScene ${DATA}/ExportBunny.vtp)
-
   add_test(${KIT}-GenericDataObjectReader ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${KIT}CxxTests
-    TestGenericDataObjectReader ${DATA}/Bunny.vtp)
+    TestGenericDataObjectReader ${DATA}/blow.vtk)
 
   add_test(${KIT}-GLTFImporterExporter ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${KIT}CxxTests
      TestGLTFImporter ${TEMP}/GLTFExporter.gltf -V ${DATA}/../Baseline/Cxx/IO/TestGLTFImporterExporter.png)
@@ -166,6 +163,9 @@ if (BUILD_TESTING)
       TestGLTFImporter ${DATA}/glTF/FlightHelmet/glTF/FlightHelmet.gltf)
     endif()
 
+  add_test(${KIT}-ImportPolyDataScene ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${KIT}CxxTests
+    TestImportPolyDataScene ${DATA}/ExportBunny.vtp)
+
   add_test(${KIT}-ImportToExport ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${KIT}CxxTests
     TestImportToExport ${DATA}/iflamingo.3ds iflamingo.obj)
 
diff --git a/src/Cxx/IO/ConvertFile.cxx b/src/Cxx/IO/ConvertFile.cxx
index 806f5cd2def52e694f4bc3b99b14ad21ac7e234f..d5c8d3e56dce8bc546332d1e74c230d9ea20a7ef 100644
--- a/src/Cxx/IO/ConvertFile.cxx
+++ b/src/Cxx/IO/ConvertFile.cxx
@@ -1,24 +1,26 @@
-#include <vtkSmartPointer.h>
+#include <vtkNew.h>
+#include <vtkPLYWriter.h>
 #include <vtkPolyData.h>
 #include <vtkXMLPolyDataReader.h>
-#include <vtkPLYWriter.h>
-	
-int main(int argc, char *argv[])
+
+int main(int argc, char* argv[])
 {
-  if(argc < 3)
+  if (argc < 3)
   {
-    std::cerr << "Required arguments: input.vtp output.ply" << std::endl;
+    std::cerr << "Required arguments: input.vtp output.ply e.g. Bunny.vtp "
+                 "ConvertFile.ply"
+              << std::endl;
     return EXIT_FAILURE;
   }
 
   std::string inputFileName = argv[1];
   std::string outputFileName = argv[2];
 
-  vtkSmartPointer<vtkXMLPolyDataReader> reader = vtkSmartPointer<vtkXMLPolyDataReader>::New();
+  vtkNew<vtkXMLPolyDataReader> reader;
   reader->SetFileName(inputFileName.c_str());
   reader->Update();
 
-  vtkSmartPointer<vtkPLYWriter> writer = vtkSmartPointer<vtkPLYWriter>::New();
+  vtkNew<vtkPLYWriter> writer;
   writer->SetFileName(outputFileName.c_str());
   writer->SetInputConnection(reader->GetOutputPort());
   writer->Update();
diff --git a/src/Cxx/IO/ConvertFile.md b/src/Cxx/IO/ConvertFile.md
index 6ca2f8cc89c52b741799942c3f68a2c57c5c2911..8e6931c065d024fff78aa81b1e888a299a14fde2 100644
--- a/src/Cxx/IO/ConvertFile.md
+++ b/src/Cxx/IO/ConvertFile.md
@@ -1,2 +1,3 @@
 ### Description
+
 This example demonstrates how to read a file and then write it to a different type of file. In this example, we read a vtp file and write a ply file, but simply by changing the reader/writer classes instantiated, different behavior can be achieved.
diff --git a/src/Cxx/IO/DEMReader.cxx b/src/Cxx/IO/DEMReader.cxx
index ac73fd7f175ead23b021156c3ccd6937e888f653..9c6fbbb01c189bcaca24c85edd63f35dad2a6134 100644
--- a/src/Cxx/IO/DEMReader.cxx
+++ b/src/Cxx/IO/DEMReader.cxx
@@ -1,64 +1,62 @@
-#include <vtkSmartPointer.h>
-#include <vtkImageActor.h>
-#include <vtkImageMapToColors.h>
-#include <vtkLookupTable.h>
 #include <vtkDEMReader.h>
+#include <vtkImageActor.h>
 #include <vtkImageData.h>
+#include <vtkImageMapToColors.h>
 #include <vtkImageMapper3D.h>
+#include <vtkInteractorStyleImage.h>
+#include <vtkLookupTable.h>
+#include <vtkNamedColors.h>
+#include <vtkNew.h>
+#include <vtkProperty.h>
 #include <vtkRenderWindow.h>
 #include <vtkRenderWindowInteractor.h>
-#include <vtkInteractorStyleImage.h>
 #include <vtkRenderer.h>
 
 int main(int argc, char* argv[])
 {
+  vtkNew<vtkNamedColors> colors;
+
   // Verify arguments
-  if(argc < 2)
+  if (argc < 2)
   {
     std::cerr << "Required: filename.dem e.g. SainteHelens.dem" << std::endl;
     return EXIT_FAILURE;
   }
 
   // Read the file
-  vtkSmartPointer<vtkDEMReader> reader =
-    vtkSmartPointer<vtkDEMReader>::New();
+  vtkNew<vtkDEMReader> reader;
   reader->SetFileName(argv[1]);
   reader->Update();
 
-  vtkSmartPointer<vtkLookupTable> lut =
-    vtkSmartPointer<vtkLookupTable>::New();
+  vtkNew<vtkLookupTable> lut;
   lut->SetHueRange(0.6, 0);
   lut->SetSaturationRange(1.0, 0);
   lut->SetValueRange(0.5, 1.0);
   lut->SetTableRange(reader->GetOutput()->GetScalarRange());
 
   // Visualize
-  vtkSmartPointer<vtkImageMapToColors> mapColors =
-    vtkSmartPointer<vtkImageMapToColors>::New();
+  vtkNew<vtkImageMapToColors> mapColors;
   mapColors->SetLookupTable(lut);
   mapColors->SetInputConnection(reader->GetOutputPort());
 
   // Create an actor
-  vtkSmartPointer<vtkImageActor> actor =
-    vtkSmartPointer<vtkImageActor>::New();
+  vtkNew<vtkImageActor> actor;
   actor->GetMapper()->SetInputConnection(mapColors->GetOutputPort());
 
   // Setup renderer
-  vtkSmartPointer<vtkRenderer> renderer =
-    vtkSmartPointer<vtkRenderer>::New();
+  vtkNew<vtkRenderer> renderer;
   renderer->AddActor(actor);
   renderer->ResetCamera();
+  renderer->SetBackground(colors->GetColor3d("SlateGray").GetData());
 
   // Setup render window
-  vtkSmartPointer<vtkRenderWindow> renderWindow =
-    vtkSmartPointer<vtkRenderWindow>::New();
+  vtkNew<vtkRenderWindow> renderWindow;
   renderWindow->AddRenderer(renderer);
+  renderWindow->SetWindowName("DEMReader");
 
   // 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);
 
diff --git a/src/Cxx/IO/DumpXMLFile.cxx b/src/Cxx/IO/DumpXMLFile.cxx
index fe5f561615800675abc504612cda879d93710f21..dc08d2d67c76e2c8d20cbf9fa5d43b670f50ce1d 100644
--- a/src/Cxx/IO/DumpXMLFile.cxx
+++ b/src/Cxx/IO/DumpXMLFile.cxx
@@ -5,41 +5,44 @@
 //         XMLFile is a vtk XML file of type .vtu, .vtp, .vts, .vtr,
 //         .vti, .vto
 //
-#include <vtkSmartPointer.h>
-#include <vtkXMLReader.h>
-#include <vtkXMLUnstructuredGridReader.h>
-#include <vtkXMLPolyDataReader.h>
-#include <vtkXMLStructuredGridReader.h>
-#include <vtkXMLRectilinearGridReader.h>
-#include <vtkXMLCompositeDataReader.h>
-#include <vtkXMLStructuredGridReader.h>
-#include <vtkXMLImageDataReader.h>
-#include <vtkDataSetReader.h>
+#include <vtkCellData.h>
+#include <vtkCellTypes.h>
 #include <vtkDataSet.h>
-#include <vtkUnstructuredGrid.h>
-#include <vtkRectilinearGrid.h>
+#include <vtkDataSetReader.h>
+#include <vtkFieldData.h>
 #include <vtkImageData.h>
+#include <vtkNew.h>
+#include <vtkPointData.h>
 #include <vtkPolyData.h>
+#include <vtkRectilinearGrid.h>
+#include <vtkSmartPointer.h>
 #include <vtkStructuredGrid.h>
-#include <vtkPointData.h>
-#include <vtkCellData.h>
-#include <vtkFieldData.h>
-#include <vtkCellTypes.h>
+#include <vtkUnstructuredGrid.h>
+#include <vtkXMLCompositeDataReader.h>
+#include <vtkXMLImageDataReader.h>
+#include <vtkXMLPolyDataReader.h>
+#include <vtkXMLReader.h>
+#include <vtkXMLRectilinearGridReader.h>
+#include <vtkXMLStructuredGridReader.h>
+#include <vtkXMLUnstructuredGridReader.h>
 #include <vtksys/SystemTools.hxx>
 
 #include <map>
 
-template<class TReader> vtkDataSet *ReadAnXMLFile(const char*fileName)
+namespace {
+
+template <class TReader> vtkDataSet* ReadAnXMLFile(const char* fileName)
 {
-  vtkSmartPointer<TReader> reader =
-    vtkSmartPointer<TReader>::New();
+  vtkNew<TReader> reader;
   reader->SetFileName(fileName);
   reader->Update();
   reader->GetOutput()->Register(reader);
   return dynamic_cast<vtkDataSet*>(reader->GetOutput());
 }
 
-int main (int argc, char *argv[])
+} // namespace
+
+int main(int argc, char* argv[])
 {
   if (argc < 2)
   {
@@ -53,31 +56,31 @@ int main (int argc, char *argv[])
   {
     vtkSmartPointer<vtkDataSet> dataSet;
     std::string extension =
-      vtksys::SystemTools::GetFilenameLastExtension(argv[f]);
+        vtksys::SystemTools::GetFilenameLastExtension(argv[f]);
     // Dispatch based on the file extension
     if (extension == ".vtu")
     {
-      dataSet = ReadAnXMLFile<vtkXMLUnstructuredGridReader> (argv[f]);
+      dataSet = ReadAnXMLFile<vtkXMLUnstructuredGridReader>(argv[f]);
     }
     else if (extension == ".vtp")
     {
-      dataSet = ReadAnXMLFile<vtkXMLPolyDataReader> (argv[f]);
+      dataSet = ReadAnXMLFile<vtkXMLPolyDataReader>(argv[f]);
     }
     else if (extension == ".vts")
     {
-      dataSet = ReadAnXMLFile<vtkXMLStructuredGridReader> (argv[f]);
+      dataSet = ReadAnXMLFile<vtkXMLStructuredGridReader>(argv[f]);
     }
     else if (extension == ".vtr")
     {
-      dataSet = ReadAnXMLFile<vtkXMLRectilinearGridReader> (argv[f]);
+      dataSet = ReadAnXMLFile<vtkXMLRectilinearGridReader>(argv[f]);
     }
     else if (extension == ".vti")
     {
-      dataSet = ReadAnXMLFile<vtkXMLImageDataReader> (argv[f]);
+      dataSet = ReadAnXMLFile<vtkXMLImageDataReader>(argv[f]);
     }
     else if (extension == ".vtk")
     {
-      dataSet = ReadAnXMLFile<vtkDataSetReader> (argv[f]);
+      dataSet = ReadAnXMLFile<vtkDataSetReader>(argv[f]);
     }
     else
     {
@@ -91,11 +94,11 @@ int main (int argc, char *argv[])
     // Generate a report
     std::cout << "------------------------" << std::endl;
     std::cout << argv[f] << std::endl
-         << " contains a " << std::endl
-         << dataSet->GetClassName()
-         <<  " that has " << numberOfCells << " cells"
-         << " and " << numberOfPoints << " points." << std::endl;
-    typedef std::map<int,int> CellContainer;
+              << " contains a " << std::endl
+              << dataSet->GetClassName() << " that has " << numberOfCells
+              << " cells"
+              << " and " << numberOfPoints << " points." << std::endl;
+    typedef std::map<int, int> CellContainer;
     CellContainer cellMap;
     for (int i = 0; i < numberOfCells; i++)
     {
@@ -106,62 +109,66 @@ int main (int argc, char *argv[])
     while (it != cellMap.end())
     {
       std::cout << "\tCell type "
-           << vtkCellTypes::GetClassNameFromTypeId(it->first)
-           << " occurs " << it->second << " times." << std::endl;
+                << vtkCellTypes::GetClassNameFromTypeId(it->first) << " occurs "
+                << it->second << " times." << std::endl;
       ++it;
     }
 
     // Now check for point data
-    vtkPointData *pd = dataSet->GetPointData();
+    vtkPointData* pd = dataSet->GetPointData();
     if (pd)
     {
-      std::cout << " contains point data with "
-           << pd->GetNumberOfArrays()
-           << " arrays." << std::endl;
+      std::cout << " contains point data with " << pd->GetNumberOfArrays()
+                << " arrays." << std::endl;
       for (int i = 0; i < pd->GetNumberOfArrays(); i++)
       {
-        std::cout << "\tArray " << i
-                  << " is named "
+        std::cout << "\tArray " << i << " is named "
                   << (pd->GetArrayName(i) ? pd->GetArrayName(i) : "NULL")
-                  << " has " << pd->GetArray(i)->GetNumberOfTuples() << " tuples"
-                  << " with " << pd->GetArray(i)->GetNumberOfComponents() << " components"
+                  << " has " << pd->GetArray(i)->GetNumberOfTuples()
+                  << " tuples"
+                  << " with " << pd->GetArray(i)->GetNumberOfComponents()
+                  << " components"
                   << " of type " << pd->GetArray(i)->GetClassName()
                   << std::endl;
       }
     }
+
     // Now check for cell data
-    vtkCellData *cd = dataSet->GetCellData();
+    vtkCellData* cd = dataSet->GetCellData();
     if (cd)
     {
-      std::cout << " contains cell data with "
-           << cd->GetNumberOfArrays()
-           << " arrays." << std::endl;
+      std::cout << " contains cell data with " << cd->GetNumberOfArrays()
+                << " arrays." << std::endl;
       for (int i = 0; i < cd->GetNumberOfArrays(); i++)
       {
-        std::cout << "\tArray " << i
-             << " is named "
-             << (cd->GetArrayName(i) ? cd->GetArrayName(i) : "NULL")
-             << std::endl;
+        std::cout << "\tArray " << i << " is named "
+                  << (cd->GetArrayName(i) ? cd->GetArrayName(i) : "NULL")
+                  << std::endl;
       }
     }
+
     // Now check for field data
     if (dataSet->GetFieldData())
     {
       std::cout << " contains field data with "
-           << dataSet->GetFieldData()->GetNumberOfArrays()
-           << " arrays." << std::endl;
+                << dataSet->GetFieldData()->GetNumberOfArrays() << " arrays."
+                << std::endl;
       for (int i = 0; i < dataSet->GetFieldData()->GetNumberOfArrays(); i++)
       {
-        std::cout << "\tArray " << i
-                  << " is named " << dataSet->GetFieldData()->GetArray(i)->GetName()
-                  << " has " << dataSet->GetFieldData()->GetArray(i)->GetNumberOfTuples() << " tuples"
-                  << " with " << dataSet->GetFieldData()->GetArray(i)->GetNumberOfComponents() << " components"
-                  << " of type " << dataSet->GetFieldData()->GetArray(i)->GetClassName()
-             << std::endl;
+        std::cout
+            << "\tArray " << i << " is named "
+            << dataSet->GetFieldData()->GetArray(i)->GetName() << " has "
+            << dataSet->GetFieldData()->GetArray(i)->GetNumberOfTuples()
+            << " tuples"
+            << " with "
+            << dataSet->GetFieldData()->GetArray(i)->GetNumberOfComponents()
+            << " components"
+            << " of type "
+            << dataSet->GetFieldData()->GetArray(i)->GetClassName()
+            << std::endl;
       }
-   }
-    dataSet->Delete();
+    }
     f++;
-   }
+  }
   return EXIT_SUCCESS;
 }
diff --git a/src/Cxx/IO/DumpXMLFile.md b/src/Cxx/IO/DumpXMLFile.md
index 3bc4b87b5393b3e73c67987710762c9d9f38118b..432c6e67b8f6fea0130cbf5c6f9239b26be74f66 100644
--- a/src/Cxx/IO/DumpXMLFile.md
+++ b/src/Cxx/IO/DumpXMLFile.md
@@ -1,4 +1,5 @@
 ### Description
+
 This example reports the cell, cell data and point data contained within a VTK XML or legacy file.
 
 !!! note
diff --git a/src/Cxx/IO/ExportPolyDataScene.cxx b/src/Cxx/IO/ExportPolyDataScene.cxx
index 5e748c09538629a8fd47b69476c841ceffb512f3..ce4eb3439927712a83bdc14933926705999577da 100644
--- a/src/Cxx/IO/ExportPolyDataScene.cxx
+++ b/src/Cxx/IO/ExportPolyDataScene.cxx
@@ -9,6 +9,7 @@
 #include <vtkLookupTable.h>
 #include <vtkMultiBlockDataSet.h>
 #include <vtkNamedColors.h>
+#include <vtkNew.h>
 #include <vtkPolyData.h>
 #include <vtkPolyDataMapper.h>
 #include <vtkProperty.h>
@@ -55,13 +56,12 @@ int main(int argc, char* argv[])
   auto polyData = ReadPolyData(argc > 1 ? argv[1] : "");
 
   // Visualize
-  auto colors = vtkSmartPointer<vtkNamedColors>::New();
+  vtkNew<vtkNamedColors> colors;
 
-  auto renderer = vtkSmartPointer<vtkRenderer>::New();
-  auto renderWindow = vtkSmartPointer<vtkRenderWindow>::New();
+  vtkNew<vtkRenderer> renderer;
+  vtkNew<vtkRenderWindow> renderWindow;
   renderWindow->AddRenderer(renderer);
-  auto renderWindowInteractor =
-      vtkSmartPointer<vtkRenderWindowInteractor>::New();
+  vtkNew<vtkRenderWindowInteractor> renderWindowInteractor;
   renderWindowInteractor->SetRenderWindow(renderWindow);
 
   double bounds[6];
@@ -76,13 +76,13 @@ int main(int argc, char* argv[])
     {
       for (int a = 0; a < 4; ++a)
       {
-        auto mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
+        vtkNew<vtkPolyDataMapper> mapper;
         mapper->SetInputData(polyData);
 
-        auto backProperty = vtkSmartPointer<vtkProperty>::New();
+        vtkNew<vtkProperty> backProperty;
         backProperty->SetColor(colors->GetColor3d("peacock").GetData());
 
-        auto actor = vtkSmartPointer<vtkActor>::New();
+        vtkNew<vtkActor> actor;
         actor->SetMapper(mapper);
         actor->SetBackfaceProperty(backProperty);
         if (b == 1)
@@ -133,7 +133,7 @@ int main(int argc, char* argv[])
         }
         if (c == 3)
         {
-          auto rotateTransform = vtkSmartPointer<vtkTransform>::New();
+          vtkNew<vtkTransform> rotateTransform;
           rotateTransform->RotateZ(30.0);
           actor->GetProperty()->SetInterpolationToGouraud();
           actor->SetUserTransform(rotateTransform);
@@ -156,6 +156,7 @@ int main(int argc, char* argv[])
   renderer->ResetCamera();
   renderer->SetBackground(colors->GetColor3d("Silver").GetData());
   renderWindow->SetSize(640, 480);
+  renderWindow->SetWindowName("ExportPolyDataScene");
   renderWindow->Render();
   renderWindowInteractor->Start();
 
@@ -187,7 +188,7 @@ void ExportMultiBlockScene(vtkRenderer* renderer, std::string fileName,
             << std::endl;
   actors->InitTraversal();
   // Initialize dataset to write
-  auto multiBlockDataset = vtkSmartPointer<vtkMultiBlockDataSet>::New();
+  vtkNew<vtkMultiBlockDataSet> multiBlockDataset;
   multiBlockDataset->SetNumberOfBlocks(actors->GetNumberOfItems());
 
   for (vtkIdType a = 0; a < actors->GetNumberOfItems(); ++a)
@@ -195,7 +196,7 @@ void ExportMultiBlockScene(vtkRenderer* renderer, std::string fileName,
     vtkActor* actor = actors->GetNextActor();
 
     // Deep copy the polydata because it may be shared with other actors
-    auto pd = vtkSmartPointer<vtkPolyData>::New();
+    vtkNew<vtkPolyData> pd;
     pd->DeepCopy(dynamic_cast<vtkPolyData*>(actor->GetMapper()->GetInput()));
 
     // Set metadata for block
@@ -217,7 +218,7 @@ void ExportMultiBlockScene(vtkRenderer* renderer, std::string fileName,
   }
 
   // Write multiblock dataset to disk
-  auto writer = vtkSmartPointer<vtkXMLMultiBlockDataWriter>::New();
+  vtkNew<vtkXMLMultiBlockDataWriter> writer;
   if (binary)
   {
     writer->SetDataModeToBinary();
@@ -384,42 +385,42 @@ vtkSmartPointer<vtkPolyData> ReadPolyData(std::string const& fileName)
                  ::tolower);
   if (extension == ".ply")
   {
-    auto reader = vtkSmartPointer<vtkPLYReader>::New();
+    vtkNew<vtkPLYReader> reader;
     reader->SetFileName(fileName.c_str());
     reader->Update();
     polyData = reader->GetOutput();
   }
   else if (extension == ".vtp")
   {
-    auto reader = vtkSmartPointer<vtkXMLPolyDataReader>::New();
+    vtkNew<vtkXMLPolyDataReader> reader;
     reader->SetFileName(fileName.c_str());
     reader->Update();
     polyData = reader->GetOutput();
   }
   else if (extension == ".obj")
   {
-    auto reader = vtkSmartPointer<vtkOBJReader>::New();
+    vtkNew<vtkOBJReader> reader;
     reader->SetFileName(fileName.c_str());
     reader->Update();
     polyData = reader->GetOutput();
   }
   else if (extension == ".stl")
   {
-    auto reader = vtkSmartPointer<vtkSTLReader>::New();
+    vtkNew<vtkSTLReader> reader;
     reader->SetFileName(fileName.c_str());
     reader->Update();
     polyData = reader->GetOutput();
   }
   else if (extension == ".vtk")
   {
-    auto reader = vtkSmartPointer<vtkPolyDataReader>::New();
+    vtkNew<vtkPolyDataReader> reader;
     reader->SetFileName(fileName.c_str());
     reader->Update();
     polyData = reader->GetOutput();
   }
   else if (extension == ".g")
   {
-    auto reader = vtkSmartPointer<vtkBYUReader>::New();
+    vtkNew<vtkBYUReader> reader;
     reader->SetGeometryFileName(fileName.c_str());
     reader->Update();
     polyData = reader->GetOutput();
@@ -427,7 +428,7 @@ vtkSmartPointer<vtkPolyData> ReadPolyData(std::string const& fileName)
   else
   {
     // Return a polydata sphere if the extension is unknown.
-    auto source = vtkSmartPointer<vtkSphereSource>::New();
+    vtkNew<vtkSphereSource> source;
     source->SetThetaResolution(20);
     source->SetPhiResolution(11);
     source->Update();
diff --git a/src/Cxx/IO/ExportPolyDataScene.md b/src/Cxx/IO/ExportPolyDataScene.md
index fb5eceb3f4a9ca2cd255d683d5ab1a639bf4e858..032aa7a59acccf2bd30a34f354a1333c4ffe886b 100644
--- a/src/Cxx/IO/ExportPolyDataScene.md
+++ b/src/Cxx/IO/ExportPolyDataScene.md
@@ -1,4 +1,5 @@
 ### Description
+
 !!! danger
     This example is a work in progress.
 
diff --git a/src/Cxx/IO/FindAllArrayNames.cxx b/src/Cxx/IO/FindAllArrayNames.cxx
index ff5dc040fbfc78b3a8da83a85a1b133a6800b6f6..805e7e3d59db65e421ffa8526804cd3363a30e7e 100644
--- a/src/Cxx/IO/FindAllArrayNames.cxx
+++ b/src/Cxx/IO/FindAllArrayNames.cxx
@@ -1,5 +1,6 @@
 #include <vtkCellData.h>
 #include <vtkCubeSource.h>
+#include <vtkNew.h>
 #include <vtkPointData.h>
 #include <vtkPolyData.h>
 #include <vtkSmartPointer.h>
@@ -10,16 +11,18 @@
 #include <string>
 #include <vector>
 
+namespace {
 void FindAllData(vtkPolyData* polydata);
+}
 
 int main(int argc, char* argv[])
 {
   vtkSmartPointer<vtkPolyData> polydata;
   if (argc < 2)
   {
-    auto sphereSource = vtkSmartPointer<vtkSphereSource>::New();
+    vtkNew<vtkSphereSource> sphereSource;
     sphereSource->Update();
-    auto writer = vtkSmartPointer<vtkXMLPolyDataWriter>::New();
+    vtkNew<vtkXMLPolyDataWriter> writer;
     writer->SetFileName("test.vtp");
     writer->SetInputConnection(sphereSource->GetOutputPort());
     writer->Write();
@@ -28,7 +31,7 @@ int main(int argc, char* argv[])
   }
   else
   {
-    auto reader = vtkSmartPointer<vtkXMLPolyDataReader>::New();
+    vtkNew<vtkXMLPolyDataReader> reader;
     reader->SetFileName(argv[1]);
     reader->Update();
     polydata = reader->GetOutput();
@@ -39,6 +42,7 @@ int main(int argc, char* argv[])
   return EXIT_SUCCESS;
 }
 
+namespace {
 void FindAllData(vtkPolyData* polydata)
 {
   std::cout << "Normals: " << polydata->GetPointData()->GetNormals()
@@ -81,3 +85,4 @@ void FindAllData(vtkPolyData* polydata)
               << " (type: " << dataTypeID << ")" << std::endl;
   }
 }
+} // namespace
diff --git a/src/Cxx/IO/FindAllArrayNames.md b/src/Cxx/IO/FindAllArrayNames.md
index 3552deb8db2313269bbcd34a37cd6f3ccb640b6d..8ab600491c415685d2839c0f1c220b91cef13ee4 100644
--- a/src/Cxx/IO/FindAllArrayNames.md
+++ b/src/Cxx/IO/FindAllArrayNames.md
@@ -1,2 +1,3 @@
 ### Description
+
 This example shows how to find out the names of all of the data arrays stored in a vtkPolyData.
diff --git a/src/Cxx/IO/GLTFExporter.cxx b/src/Cxx/IO/GLTFExporter.cxx
index 84cae025a7135950b1b8425ca4c228ee253d5d7f..c06ab0026d6dc9e5706f3188c7b3c6b8c191223a 100644
--- a/src/Cxx/IO/GLTFExporter.cxx
+++ b/src/Cxx/IO/GLTFExporter.cxx
@@ -6,13 +6,13 @@
 #include <vtkMath.h>
 #include <vtkMinimalStandardRandomSequence.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>
-#include <vtkSmartPointer.h>
 #include <vtkSphereSource.h>
 #include <vtkTransform.h>
 #include <vtkTransformPolyDataFilter.h>
@@ -23,24 +23,22 @@ int main(int argc, char* argv[])
 {
   if (argc < 2)
   {
-    std::cout << "Uaage: GLTFExporter file.gltf" << std::endl;
+    std::cout << "Usage: GLTFExporter file.gltf e.g. GLTFExporter.gltf"
+              << std::endl;
     return EXIT_FAILURE;
   }
-  vtkSmartPointer<vtkNamedColors> colors =
-      vtkSmartPointer<vtkNamedColors>::New();
+  vtkNew<vtkNamedColors> colors;
 
   // Set the background color.
   vtkColor3d backgroundColor = colors->GetColor3d("SlateGray");
 
   // Create an arrow.
-  vtkSmartPointer<vtkArrowSource> arrowSource =
-      vtkSmartPointer<vtkArrowSource>::New();
+  vtkNew<vtkArrowSource> arrowSource;
 
   // Generate a random start and end point
   double startPoint[3];
   double endPoint[3];
-  vtkSmartPointer<vtkMinimalStandardRandomSequence> rng =
-      vtkSmartPointer<vtkMinimalStandardRandomSequence>::New();
+  vtkNew<vtkMinimalStandardRandomSequence> rng;
   rng->SetSeed(8775070); // For testing.
   for (auto i = 0; i < 3; ++i)
   {
@@ -72,7 +70,7 @@ int main(int argc, char* argv[])
 
   // The Y axis is Z cross X
   vtkMath::Cross(normalizedZ, normalizedX, normalizedY);
-  vtkSmartPointer<vtkMatrix4x4> matrix = vtkSmartPointer<vtkMatrix4x4>::New();
+  vtkNew<vtkMatrix4x4> matrix;
 
   // Create the direction cosine matrix
   matrix->Identity();
@@ -84,22 +82,19 @@ int main(int argc, char* argv[])
   }
 
   // Apply the transforms
-  vtkSmartPointer<vtkTransform> transform =
-      vtkSmartPointer<vtkTransform>::New();
+  vtkNew<vtkTransform> transform;
   transform->Translate(startPoint);
   transform->Concatenate(matrix);
   transform->Scale(length, length, length);
 
   // Transform the polydata
-  vtkSmartPointer<vtkTransformPolyDataFilter> transformPD =
-      vtkSmartPointer<vtkTransformPolyDataFilter>::New();
+  vtkNew<vtkTransformPolyDataFilter> transformPD;
   transformPD->SetTransform(transform);
   transformPD->SetInputConnection(arrowSource->GetOutputPort());
 
   // Create a mapper and actor for the arrow
-  vtkSmartPointer<vtkPolyDataMapper> mapper =
-      vtkSmartPointer<vtkPolyDataMapper>::New();
-  vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
+  vtkNew<vtkPolyDataMapper> mapper;
+  vtkNew<vtkActor> actor;
 #ifdef USER_MATRIX
   mapper->SetInputConnection(arrowSource->GetOutputPort());
   actor->SetUserMatrix(transform->GetMatrix());
@@ -110,39 +105,33 @@ int main(int argc, char* argv[])
   actor->GetProperty()->SetColor(colors->GetColor3d("Cyan").GetData());
 
   // Create spheres for start and end point
-  vtkSmartPointer<vtkSphereSource> sphereStartSource =
-      vtkSmartPointer<vtkSphereSource>::New();
+  vtkNew<vtkSphereSource> sphereStartSource;
   sphereStartSource->SetCenter(startPoint);
   sphereStartSource->SetRadius(0.8);
-  vtkSmartPointer<vtkPolyDataMapper> sphereStartMapper =
-      vtkSmartPointer<vtkPolyDataMapper>::New();
+  vtkNew<vtkPolyDataMapper> sphereStartMapper;
   sphereStartMapper->SetInputConnection(sphereStartSource->GetOutputPort());
-  vtkSmartPointer<vtkActor> sphereStart = vtkSmartPointer<vtkActor>::New();
+  vtkNew<vtkActor> sphereStart;
   sphereStart->SetMapper(sphereStartMapper);
   sphereStart->GetProperty()->SetColor(colors->GetColor3d("Yellow").GetData());
 
-  vtkSmartPointer<vtkSphereSource> sphereEndSource =
-      vtkSmartPointer<vtkSphereSource>::New();
+  vtkNew<vtkSphereSource> sphereEndSource;
   sphereEndSource->SetCenter(endPoint);
   sphereEndSource->SetRadius(0.8);
-  vtkSmartPointer<vtkPolyDataMapper> sphereEndMapper =
-      vtkSmartPointer<vtkPolyDataMapper>::New();
+  vtkNew<vtkPolyDataMapper> sphereEndMapper;
   sphereEndMapper->SetInputConnection(sphereEndSource->GetOutputPort());
-  vtkSmartPointer<vtkActor> sphereEnd = vtkSmartPointer<vtkActor>::New();
+  vtkNew<vtkActor> sphereEnd;
   sphereEnd->SetMapper(sphereEndMapper);
   sphereEnd->GetProperty()->SetColor(colors->GetColor3d("Magenta").GetData());
 
   // 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);
   renderWindow->SetSize(640, 480);
-  renderWindow->SetWindowName("Oriented Arrow");
+  renderWindow->SetWindowName("GLTFExporter");
 
-  auto style = vtkSmartPointer<vtkInteractorStyleTrackballCamera>::New();
-  vtkSmartPointer<vtkRenderWindowInteractor> renderWindowInteractor =
-      vtkSmartPointer<vtkRenderWindowInteractor>::New();
+  vtkNew<vtkInteractorStyleTrackballCamera> style;
+  vtkNew<vtkRenderWindowInteractor> renderWindowInteractor;
   renderWindowInteractor->SetRenderWindow(renderWindow);
   renderWindowInteractor->SetInteractorStyle(style);
 
@@ -161,7 +150,7 @@ int main(int argc, char* argv[])
 
   renderWindowInteractor->Start();
 
-  auto writer = vtkSmartPointer<vtkGLTFExporter>::New();
+  vtkNew<vtkGLTFExporter> writer;
   writer->SetFileName(argv[1]);
   writer->InlineDataOn();
   writer->SetRenderWindow(renderWindow);
diff --git a/src/Cxx/IO/GLTFImporter.cxx b/src/Cxx/IO/GLTFImporter.cxx
index 4b5f5d45911cde36e63721f62201db6e109d43b1..17b548705ad7ad726b6b41432aca6005329e60e7 100644
--- a/src/Cxx/IO/GLTFImporter.cxx
+++ b/src/Cxx/IO/GLTFImporter.cxx
@@ -1,53 +1,47 @@
-#include <vtkSmartPointer.h>
-#include <vtkGLTFImporter.h>
-
 #include <vtkCamera.h>
+#include <vtkGLTFImporter.h>
+#include <vtkInteractorStyleTrackballCamera.h>
 #include <vtkLight.h>
+#include <vtkNamedColors.h>
+#include <vtkNew.h>
 #include <vtkRenderWindow.h>
 #include <vtkRenderWindowInteractor.h>
-#include <vtkInteractorStyleTrackballCamera.h>
 #include <vtkRenderer.h>
-#include <vtkNamedColors.h>
 
 int main(int argc, char* argv[])
 {
   if (argc <= 1)
   {
-    std::cout << "Usage: " << argv[0] << " <gltf file>" << std::endl;
+    std::cout << "Usage: " << argv[0] << " <gltf file> e.g. FlightHelmet.gltf"
+              << std::endl;
     return EXIT_FAILURE;
   }
 
-  auto colors =
-    vtkSmartPointer<vtkNamedColors>::New();
+  vtkNew<vtkNamedColors> colors;
 
   vtkColor3d backgroundColor = colors->GetColor3d("SlateGray");
 
-  auto importer =
-    vtkSmartPointer<vtkGLTFImporter>::New();
+  vtkNew<vtkGLTFImporter> importer;
   importer->SetFileName(argv[1]);
 
-  auto renderer =
-    vtkSmartPointer<vtkRenderer>::New();
+  vtkNew<vtkRenderer> renderer;
   renderer->SetBackground(backgroundColor.GetData());
   renderer->UseHiddenLineRemovalOn();
 
-  auto renderWindow =
-    vtkSmartPointer<vtkRenderWindow>::New();
+  vtkNew<vtkRenderWindow> renderWindow;
   renderWindow->SetSize(640, 512);
   renderWindow->AddRenderer(renderer);
+  renderWindow->SetWindowName("GLTFImporter");
 
-  auto renderWindowInteractor =
-    vtkSmartPointer<vtkRenderWindowInteractor>::New();
+  vtkNew<vtkRenderWindowInteractor> renderWindowInteractor;
   renderWindowInteractor->SetRenderWindow(renderWindow);
-  auto style =
-    vtkSmartPointer<vtkInteractorStyleTrackballCamera>::New();
+  vtkNew<vtkInteractorStyleTrackballCamera> style;
   renderWindowInteractor->SetInteractorStyle(style);
 
   importer->SetRenderWindow(renderWindow);
   importer->Update();
 
-  auto headLight =
-    vtkSmartPointer<vtkLight>::New();
+  vtkNew<vtkLight> headLight;
   headLight->SetLightTypeToHeadlight();
   headLight->SwitchOn();
   renderer->AddLight(headLight);
diff --git a/src/Cxx/IO/GenericDataObjectReader.cxx b/src/Cxx/IO/GenericDataObjectReader.cxx
index 12cc784af94b6505d19b700d8a685bb44628381e..d9713b9a501c504c8e8e021265e5211f963be466 100644
--- a/src/Cxx/IO/GenericDataObjectReader.cxx
+++ b/src/Cxx/IO/GenericDataObjectReader.cxx
@@ -1,15 +1,16 @@
+#include <string>
 #include <vtkGenericDataObjectReader.h>
-#include <vtkStructuredGrid.h>
-#include <vtkSmartPointer.h>
+#include <vtkNew.h>
 #include <vtkPolyData.h>
-#include <string>
+#include <vtkStructuredGrid.h>
+#include <vtkUnstructuredGrid.h>
 
-int main ( int argc, char *argv[] )
+int main(int argc, char* argv[])
 {
   // Ensure a filename was specified
-  if(argc != 2)
+  if (argc != 2)
   {
-    std::cerr << "Usage: " << argv[0] << " InputFilename" << endl;
+    std::cerr << "Usage: " << argv[0] << " InputFilename e.g. blow.vtk" << endl;
     return EXIT_FAILURE;
   }
 
@@ -17,17 +18,25 @@ int main ( int argc, char *argv[] )
   std::string inputFilename = argv[1];
 
   // Get all data from the file
-  vtkSmartPointer<vtkGenericDataObjectReader> reader =
-      vtkSmartPointer<vtkGenericDataObjectReader>::New();
+  vtkNew<vtkGenericDataObjectReader> reader;
   reader->SetFileName(inputFilename.c_str());
   reader->Update();
 
   // All of the standard data types can be checked and obtained like this:
-  if(reader->IsFilePolyData())
+  if (reader->IsFilePolyData())
+  {
+    std::cout << "output is polydata," << std::endl;
+    auto output = reader->GetPolyDataOutput();
+    std::cout << "   output has " << output->GetNumberOfPoints() << " points."
+              << std::endl;
+  }
+
+  if (reader->IsFileUnstructuredGrid())
   {
-    std::cout << "output is a polydata" << std::endl;
-    vtkPolyData* output = reader->GetPolyDataOutput();
-    std::cout << "output has " << output->GetNumberOfPoints() << " points." << std::endl;
+    std::cout << "output is unstructured grid," << std::endl;
+    auto output = reader->GetUnstructuredGridOutput();
+    std::cout << "   output has " << output->GetNumberOfPoints() << " points."
+              << std::endl;
   }
 
   return EXIT_SUCCESS;
diff --git a/src/Cxx/IO/ImageReader2Factory.cxx b/src/Cxx/IO/ImageReader2Factory.cxx
index a27558ada0c2dae24da388124621b31cd02508c1..c4bbb4e403835b6d304de9ce26c1c4153155c744 100644
--- a/src/Cxx/IO/ImageReader2Factory.cxx
+++ b/src/Cxx/IO/ImageReader2Factory.cxx
@@ -1,22 +1,21 @@
-#include <vtkSmartPointer.h>
-#include <vtkImageReader2Factory.h>
-#include <vtkImageReader2.h>
+#include <vtkImageActor.h>
 #include <vtkImageData.h>
 #include <vtkImageMapper3D.h>
+#include <vtkImageReader2.h>
+#include <vtkImageReader2Factory.h>
+#include <vtkInteractorStyleImage.h>
+#include <vtkNamedColors.h>
 #include <vtkRenderWindow.h>
 #include <vtkRenderWindowInteractor.h>
-#include <vtkInteractorStyleImage.h>
 #include <vtkRenderer.h>
-#include <vtkImageActor.h>
-#include <vtkNamedColors.h>
+#include <vtkSmartPointer.h>
 
-int main(int argc, char *argv[])
+int main(int argc, char* argv[])
 {
   // Verify command line arguments
-  if(argc < 2)
+  if (argc < 2)
   {
-    std::cout << "Usage: " << argv[0]
-              << " InputFilename" << std::endl;
+    std::cout << "Usage: " << argv[0] << " InputFilename" << std::endl;
     return EXIT_FAILURE;
   }
 
@@ -24,40 +23,33 @@ int main(int argc, char *argv[])
   std::string inputFilename = argv[1];
 
   // Read file
-  vtkSmartPointer<vtkImageReader2Factory> readerFactory =
-    vtkSmartPointer<vtkImageReader2Factory>::New();
+  vtkNew<vtkImageReader2Factory> readerFactory;
   vtkSmartPointer<vtkImageReader2> imageReader;
   imageReader.TakeReference(
-    readerFactory->CreateImageReader2(inputFilename.c_str()));
+      readerFactory->CreateImageReader2(inputFilename.c_str()));
   imageReader->SetFileName(inputFilename.c_str());
   imageReader->Update();
 
   // Create an actor
-  vtkSmartPointer<vtkImageActor> actor =
-    vtkSmartPointer<vtkImageActor>::New();
-  actor->GetMapper()->SetInputConnection(
-    imageReader->GetOutputPort());
+  vtkNew<vtkImageActor> actor;
+  actor->GetMapper()->SetInputConnection(imageReader->GetOutputPort());
 
   // Setup renderer
-  vtkSmartPointer<vtkNamedColors> colors =
-    vtkSmartPointer<vtkNamedColors>::New();
+  vtkNew<vtkNamedColors> colors;
 
-  vtkSmartPointer<vtkRenderer> renderer =
-    vtkSmartPointer<vtkRenderer>::New();
+  vtkNew<vtkRenderer> renderer;
   renderer->AddActor(actor);
   renderer->ResetCamera();
- renderer->SetBackground(colors->GetColor3d("Slate_grey").GetData());
+  renderer->SetBackground(colors->GetColor3d("Slate_grey").GetData());
 
   // Setup render window
-  vtkSmartPointer<vtkRenderWindow> renderWindow =
-    vtkSmartPointer<vtkRenderWindow>::New();
+  vtkNew<vtkRenderWindow> renderWindow;
   renderWindow->AddRenderer(renderer);
+  renderWindow->SetWindowName("ImageReader2Factory");
 
   // 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);
 
diff --git a/src/Cxx/IO/ImageWriter.cxx b/src/Cxx/IO/ImageWriter.cxx
index b26058b9e79cf732f177ac09895dbb905eacd5ab..345b9f077b0bdd6b35c534ba4c38a68e7da9e3f7 100644
--- a/src/Cxx/IO/ImageWriter.cxx
+++ b/src/Cxx/IO/ImageWriter.cxx
@@ -1,5 +1,6 @@
 #include <vtkActor.h>
 #include <vtkNamedColors.h>
+#include <vtkNew.h>
 #include <vtkPolyDataMapper.h>
 #include <vtkProperty.h>
 #include <vtkRenderWindow.h>
@@ -42,30 +43,30 @@ void WriteImage(std::string const& fileName, vtkRenderWindow* renWin,
 int main(int, char*[])
 {
 
-  auto colors = vtkSmartPointer<vtkNamedColors>::New();
+  vtkNew<vtkNamedColors> colors;
 
   // Set the background color.
   std::array<unsigned char, 4> bkg{{26, 51, 102, 255}};
   colors->SetColor("BkgColor", bkg.data());
 
   // Create the rendering window, renderer, and interactive renderer.
-  auto ren = vtkSmartPointer<vtkRenderer>::New();
-  auto renWin = vtkSmartPointer<vtkRenderWindow>::New();
+  vtkNew<vtkRenderer> ren;
+  vtkNew<vtkRenderWindow> renWin;
   renWin->AddRenderer(ren);
-  auto iren = vtkSmartPointer<vtkRenderWindowInteractor>::New();
+  vtkNew<vtkRenderWindowInteractor> iren;
   iren->SetRenderWindow(renWin);
 
   // Create the source.
-  auto source = vtkSmartPointer<vtkSphereSource>::New();
+  vtkNew<vtkSphereSource> source;
   source->SetCenter(0, 0, 0);
   source->SetRadius(5.0);
 
   // mapper
-  auto mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
+  vtkNew<vtkPolyDataMapper> mapper;
   mapper->SetInputConnection(source->GetOutputPort());
 
   // actor
-  auto actor = vtkSmartPointer<vtkActor>::New();
+  vtkNew<vtkActor> actor;
   actor->SetMapper(mapper);
 
   // color the actor
@@ -75,6 +76,7 @@ int main(int, char*[])
   ren->AddActor(actor);
   ren->SetBackground(colors->GetColor3d("BkgColor").GetData());
 
+  renWin->SetWindowName("ImageWriter");
   renWin->Render();
 
   std::vector<std::string> ext = {{""},      {".png"}, {".jpg"}, {".ps"},
@@ -144,8 +146,7 @@ void WriteImage(std::string const& fileName, vtkRenderWindow* renWin, bool rgba)
     {
       writer = vtkSmartPointer<vtkPNGWriter>::New();
     }
-    auto window_to_image_filter =
-        vtkSmartPointer<vtkWindowToImageFilter>::New();
+    vtkNew<vtkWindowToImageFilter> window_to_image_filter;
     window_to_image_filter->SetInput(renWin);
     window_to_image_filter->SetScale(1); // image quality
     if (rgba)
diff --git a/src/Cxx/IO/ImageWriter.md b/src/Cxx/IO/ImageWriter.md
index 6558deeef85f5ebf675a2cfaa5ed6e8f57e98db2..b7f1eb6b84b9e42a3a30297fbb9300fcfef5cce7 100644
--- a/src/Cxx/IO/ImageWriter.md
+++ b/src/Cxx/IO/ImageWriter.md
@@ -4,4 +4,4 @@ A generic function `WriteImage()` is provided that selects what image writer to
 
 If no file extension is specified, **PNG** is assumed.
 
-The function `WriteImage()` is also available in the Snippets.
\ No newline at end of file
+The function `WriteImage()` is also available in the Snippets.
diff --git a/src/Cxx/IO/ImportPolyDataScene.cxx b/src/Cxx/IO/ImportPolyDataScene.cxx
index 85da29bca13c8817f65c33bcbcc6e69122bd3c14..91bde2b7be591bbea686e2cbaffa66b63cd09274 100644
--- a/src/Cxx/IO/ImportPolyDataScene.cxx
+++ b/src/Cxx/IO/ImportPolyDataScene.cxx
@@ -5,13 +5,13 @@
 #include <vtkFieldData.h>
 #include <vtkMultiBlockDataSet.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>
-#include <vtkSmartPointer.h>
 #include <vtkVersion.h>
 #include <vtkXMLMultiBlockDataReader.h>
 
@@ -23,28 +23,32 @@
 namespace {
 void ImportMultiBlockScene(vtkRenderer* renderer, std::string fileName);
 void RestoreCameraFromFieldData(std::string const&, vtkCamera*, vtkPolyData*);
-void RestorePropertyFromFieldData(std::string const&, vtkProperty*, vtkPolyData*);
+void RestorePropertyFromFieldData(std::string const&, vtkProperty*,
+                                  vtkPolyData*);
 void RestoreActorFromFieldData(std::string const&, vtkActor*, vtkPolyData*);
-// void RestoreMapperFromFieldData(std::string const&, vtkPolyDataMapper *, vtkPolyData
-// *); void RestoreLookupTableFromFieldData(std::string const&, vtkScalarsToColors *,
-// vtkPolyData *);
+// These functions need to be written.
+// void RestoreMapperFromFieldData(std::string const&, vtkPolyDataMapper*,
+//                                vtkPolyData*);
+// void RestoreLookupTableFromFieldData(std::string const&, vtkScalarsToColors*,
+//                                     vtkPolyData*);
 } // namespace
 
 int main(int argc, char* argv[])
 {
   if (argc < 2)
   {
-    std::cout << "Usage: " << argv[0] << " file.vtp" << std::endl;
+    std::cout << "Usage: " << argv[0] << " file.vtp e.g ExportBunny.vtp"
+              << std::endl;
     return EXIT_FAILURE;
   }
 
   // Visualization
-  auto colors = vtkSmartPointer<vtkNamedColors>::New();
-  auto renderer = vtkSmartPointer<vtkRenderer>::New();
-  auto renderWindow = vtkSmartPointer<vtkRenderWindow>::New();
+  vtkNew<vtkNamedColors> colors;
+  vtkNew<vtkRenderer> renderer;
+  vtkNew<vtkRenderWindow> renderWindow;
   renderWindow->AddRenderer(renderer);
-  auto renderWindowInteractor =
-      vtkSmartPointer<vtkRenderWindowInteractor>::New();
+  renderWindow->SetWindowName("ImportPolyDataScene");
+  vtkNew<vtkRenderWindowInteractor> renderWindowInteractor;
   renderWindowInteractor->SetRenderWindow(renderWindow);
 
   ImportMultiBlockScene(renderer.GetPointer(), std::string(argv[1]));
@@ -65,11 +69,13 @@ void ImportMultiBlockScene(vtkRenderer* renderer, std::string fileName)
   vtkCamera* camera = renderer->GetActiveCamera();
 
   // Read the multiblock data
-  auto reader = vtkSmartPointer<vtkXMLMultiBlockDataReader>::New();
+  // auto reader = vtkSmartPointer<vtkXMLMultiBlockDataReader>::New();
+  vtkNew<vtkXMLMultiBlockDataReader> reader;
   reader->SetFileName(fileName.c_str());
   reader->Update();
   std::cout << "Importing "
-            << dynamic_cast<vtkMultiBlockDataSet*>(reader->GetOutput())->GetNumberOfBlocks()
+            << dynamic_cast<vtkMultiBlockDataSet*>(reader->GetOutput())
+                   ->GetNumberOfBlocks()
             << " actors" << std::endl;
 
 #if VTK890
@@ -82,13 +88,13 @@ void ImportMultiBlockScene(vtkRenderer* renderer, std::string fileName)
   {
     vtkPolyData* pd = dynamic_cast<vtkPolyData*>(dso);
     RestoreCameraFromFieldData("Camera", camera, pd);
-    auto mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
+    vtkNew<vtkPolyDataMapper> mapper;
     mapper->SetInputData(pd);
 
-    auto actor = vtkSmartPointer<vtkActor>::New();
+    vtkNew<vtkActor> actor;
     actor->SetMapper(mapper);
     RestorePropertyFromFieldData("Property", actor->GetProperty(), pd);
-    auto backProperty = vtkSmartPointer<vtkProperty>::New();
+    vtkNew<vtkProperty> backProperty;
     actor->SetBackfaceProperty(backProperty);
     RestorePropertyFromFieldData("BackfaceProperty",
                                  actor->GetBackfaceProperty(), pd);
@@ -99,7 +105,7 @@ void ImportMultiBlockScene(vtkRenderer* renderer, std::string fileName)
   vtkCompositeDataSet* input =
       dynamic_cast<vtkCompositeDataSet*>(reader->GetOutput());
 
-  auto iter = vtkSmartPointer<vtkDataObjectTreeIterator>::New();
+  vtkNew<vtkDataObjectTreeIterator> iter;
   iter->SetDataSet(input);
   iter->SkipEmptyNodesOn();
   iter->VisitOnlyLeavesOn();
@@ -109,13 +115,13 @@ void ImportMultiBlockScene(vtkRenderer* renderer, std::string fileName)
     vtkDataObject* dso = iter->GetCurrentDataObject();
     vtkPolyData* pd = dynamic_cast<vtkPolyData*>(dso);
     RestoreCameraFromFieldData("Camera", camera, pd);
-    auto mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
+    vtkNew<vtkPolyDataMapper> mapper;
     mapper->SetInputData(pd);
 
-    auto actor = vtkSmartPointer<vtkActor>::New();
+    vtkNew<vtkActor> actor;
     actor->SetMapper(mapper);
     RestorePropertyFromFieldData("Property", actor->GetProperty(), pd);
-    auto backProperty = vtkSmartPointer<vtkProperty>::New();
+    vtkNew<vtkProperty> backProperty;
     actor->SetBackfaceProperty(backProperty);
     RestorePropertyFromFieldData("BackfaceProperty",
                                  actor->GetBackfaceProperty(), pd);
@@ -124,8 +130,8 @@ void ImportMultiBlockScene(vtkRenderer* renderer, std::string fileName)
   }
 #endif
 }
-void RestoreCameraFromFieldData(std::string const& arrayPrefix, vtkCamera* camera,
-                                vtkPolyData* pd)
+void RestoreCameraFromFieldData(std::string const& arrayPrefix,
+                                vtkCamera* camera, vtkPolyData* pd)
 {
   vtkFieldData* fd = pd->GetFieldData();
   camera->SetFocalPoint(
diff --git a/src/Cxx/IO/ImportToExport.cxx b/src/Cxx/IO/ImportToExport.cxx
index bb1c7438c48b5b6b93f526bef2688aeab0714364..60b4b9f3ead80b3ffa03f3d8c41429db62ea7948 100644
--- a/src/Cxx/IO/ImportToExport.cxx
+++ b/src/Cxx/IO/ImportToExport.cxx
@@ -1,3 +1,4 @@
+#include <vtkNew.h>
 #include <vtkRenderWindow.h>
 #include <vtkRenderer.h>
 #include <vtkSmartPointer.h>
@@ -32,7 +33,8 @@ int main(int argc, char* argv[])
 
   if (argc < 3)
   {
-    std::cerr << "Expects input file name(s) and an output filename."
+    std::cerr << "Expects input file name(s) and an output filename e.g. "
+                 "iflamingo.3ds iflamingo.obj"
               << std::endl;
     return EXIT_FAILURE;
   }
@@ -83,7 +85,7 @@ int main(int argc, char* argv[])
 
   if (extension == "wrl")
   {
-    auto importer = vtkSmartPointer<vtkVRMLImporter>::New();
+    vtkNew<vtkVRMLImporter> importer;
     importer->SetFileName(argv[1]);
     importer->SetRenderWindow(renderWindow);
     renderWindow = importer->GetRenderWindow();
@@ -93,7 +95,7 @@ int main(int argc, char* argv[])
   }
   else if (extension == "3ds")
   {
-    auto importer = vtkSmartPointer<vtk3DSImporter>::New();
+    vtkNew<vtk3DSImporter> importer;
     importer->SetFileName(argv[1]);
     importer->SetRenderWindow(renderWindow);
     importer->ComputeNormalsOn();
@@ -104,7 +106,7 @@ int main(int argc, char* argv[])
   }
   else if (extension == "gltf" || extension == "glb")
   {
-    auto importer = vtkSmartPointer<vtkGLTFImporter>::New();
+    vtkNew<vtkGLTFImporter> importer;
     importer->SetFileName(argv[1]);
     importer->SetRenderWindow(renderWindow);
     renderWindow = importer->GetRenderWindow();
@@ -114,7 +116,7 @@ int main(int argc, char* argv[])
   }
   else if (extension == "obj")
   {
-    auto importer = vtkSmartPointer<vtkOBJImporter>::New();
+    vtkNew<vtkOBJImporter> importer;
     importer->SetFileName(argv[1]);
     importer->SetFileNameMTL(argv[2]);
     importer->SetTexturePath(argv[3]);
@@ -163,7 +165,7 @@ int main(int argc, char* argv[])
   {
     std::string exportFileName;
     exportFileName = outputFileName + "." + outputExtension;
-    auto exporter = vtkSmartPointer<vtkOBJExporter>::New();
+    vtkNew<vtkOBJExporter> exporter;
     std::stringstream comment;
     comment << "Converted by ImportExport from " << fileName;
     exporter->SetOBJFileComment(comment.str().c_str());
@@ -178,7 +180,7 @@ int main(int argc, char* argv[])
   {
     std::string exportFileName;
     exportFileName = outputFileName + "." + outputExtension;
-    auto exporter = vtkSmartPointer<vtkVRMLExporter>::New();
+    vtkNew<vtkVRMLExporter> exporter;
     exporter->SetFileName(exportFileName.c_str());
     exporter->SetActiveRenderer(renderer);
     exporter->SetRenderWindow(renderWindow);
@@ -189,7 +191,7 @@ int main(int argc, char* argv[])
   {
     std::string exportFileName;
     exportFileName = outputFileName + "." + "gltf";
-    auto exporter = vtkSmartPointer<vtkGLTFExporter>::New();
+    vtkNew<vtkGLTFExporter> exporter;
     exporter->SetFileName(exportFileName.c_str());
     exporter->SetActiveRenderer(renderer);
     exporter->SetRenderWindow(renderWindow);
@@ -200,12 +202,13 @@ int main(int argc, char* argv[])
   {
     std::string exportFileName;
     exportFileName = outputFileName + "." + outputExtension;
-    auto exporter = vtkSmartPointer<vtkX3DExporter>::New();
+    vtkNew<vtkX3DExporter> exporter;
     exporter->SetFileName(exportFileName.c_str());
     exporter->SetActiveRenderer(renderer);
     exporter->SetRenderWindow(renderWindow);
     std::cout << "Writing " << exportFileName << std::endl;
     exporter->Write();
   }
+
   return EXIT_SUCCESS;
 }
diff --git a/src/Cxx/IO/IndividualVRML.cxx b/src/Cxx/IO/IndividualVRML.cxx
index 756ea987b2d10e961bc00c1c174bb348288ebbd4..46726385defa8402842a9d3340be13b907c2dd1b 100644
--- a/src/Cxx/IO/IndividualVRML.cxx
+++ b/src/Cxx/IO/IndividualVRML.cxx
@@ -1,35 +1,41 @@
-#include <vtkRenderer.h>
-#include <vtkRenderWindow.h>
-#include <vtkRenderWindowInteractor.h>
-#include <vtkVRMLImporter.h>
+#include <vtkAxesActor.h>
+#include <vtkCamera.h>
 #include <vtkDataSet.h>
+#include <vtkNamedColors.h>
+#include <vtkNew.h>
 #include <vtkPolyData.h>
-#include <vtkSmartPointer.h>
 #include <vtkProperty.h>
+#include <vtkRenderWindow.h>
+#include <vtkRenderWindowInteractor.h>
+#include <vtkRenderer.h>
 #include <vtkTransform.h>
-#include <vtkAxesActor.h>
+#include <vtkVRMLImporter.h>
 
-int main ( int argc, char *argv[])
+int main(int argc, char* argv[])
 {
-  if(argc != 3)
+  vtkNew<vtkNamedColors> colors;
+
+  if (argc != 3)
   {
-    std::cout << "Required arguments: Filename Actorname" << std::endl;
+    std::cout << "Required arguments: Filename Actorname e.g. teapot.wrl teapot"
+              << std::endl;
     return EXIT_FAILURE;
   }
 
   std::string filename = argv[1];
   std::cout << "Showing " << argv[2] << " from " << filename << std::endl;
 
-  vtkSmartPointer<vtkRenderer> renderer = vtkSmartPointer<vtkRenderer>::New();
-  vtkSmartPointer<vtkRenderWindow> renderWindow = vtkSmartPointer<vtkRenderWindow>::New();
+  vtkNew<vtkRenderer> renderer;
+  vtkNew<vtkRenderWindow> renderWindow;
   renderWindow->AddRenderer(renderer);
+  renderWindow->SetWindowName("IndividualVRML");
 
-  vtkSmartPointer<vtkRenderWindowInteractor> renderWindowInteractor = vtkSmartPointer<vtkRenderWindowInteractor>::New();
+  vtkNew<vtkRenderWindowInteractor> renderWindowInteractor;
   renderWindowInteractor->SetRenderWindow(renderWindow);
 
   // VRML Import
-  vtkSmartPointer<vtkVRMLImporter> importer = vtkSmartPointer<vtkVRMLImporter>::New();
-  importer->SetFileName ( filename.c_str() );
+  vtkNew<vtkVRMLImporter> importer;
+  importer->SetFileName(filename.c_str());
   importer->Read();
   importer->SetRenderWindow(renderWindow);
   importer->Update();
@@ -38,25 +44,23 @@ int main ( int argc, char *argv[])
   vtkObject* defActor = importer->GetVRMLDEFObject(argv[2]);
   if (defActor == NULL)
   {
-    std::cout << "Cannot locate actor " << argv[2]
-              << " in " << filename << std::endl;
+    std::cout << "Cannot locate actor " << argv[2] << " in " << filename
+              << std::endl;
     importer->Print(std::cout);
     return EXIT_FAILURE;
   }
 
-  vtkActor* actor = static_cast <vtkActor*> (defActor);
-  double color[3] = {0.89,0.81,0.34};
-  actor->GetProperty()->SetColor(color);
+  vtkActor* actor = static_cast<vtkActor*>(defActor);
+  double color[3] = {0.89, 0.81, 0.34};
+  actor->GetProperty()->SetColor(colors->GetColor3d("Gold").GetData());
   actor->GetProperty()->SetRepresentationToWireframe();
 
-  vtkSmartPointer<vtkTransform> transform =
-    vtkSmartPointer<vtkTransform>::New();
+  vtkNew<vtkTransform> transform;
 
-  transform->Translate(actor->GetCenter()[0],
-                       actor->GetCenter()[1],
+  transform->Translate(actor->GetCenter()[0], actor->GetCenter()[1],
                        actor->GetCenter()[2]);
   // axes
-  vtkSmartPointer<vtkAxesActor> axes = vtkSmartPointer<vtkAxesActor>::New();
+  vtkNew<vtkAxesActor> axes;
 
   double l[3];
   l[0] = (actor->GetBounds()[1] - actor->GetBounds()[0]) * 1.5;
@@ -66,7 +70,14 @@ int main ( int argc, char *argv[])
   axes->SetTotalLength(l);
   axes->SetUserTransform(transform);
   renderer->AddActor(axes);
-  renderer->SetBackground( .2, .3, .7);
+  renderer->SetBackground(colors->GetColor3d("MidnightBlue").GetData());
+  renderWindow->Render();
+
+  renderer->GetActiveCamera()->SetPosition(-14.8296, 18.1304, 12.3352);
+  renderer->GetActiveCamera()->SetFocalPoint(2.09905, 0.0832915, 2.47961);
+  renderer->GetActiveCamera()->SetViewUp(0.262918, -0.260671, 0.928937);
+  renderer->GetActiveCamera()->SetDistance(26.6348);
+  renderer->ResetCameraClippingRange();
 
   renderWindow->Render();
   renderWindowInteractor->Start();
diff --git a/src/Cxx/IO/IndividualVRML.md b/src/Cxx/IO/IndividualVRML.md
index 3d997ec02f440ec1b24d198f90e0c4f1f1ff293b..272d3aa528869c85da25f994c77c95984400ee17 100644
--- a/src/Cxx/IO/IndividualVRML.md
+++ b/src/Cxx/IO/IndividualVRML.md
@@ -1,7 +1,9 @@
 ### Description
-This example shows how to obtain each object of a scene and get it's initial transformation.
-The selected actor is represented in wireframe. To run this example,
 
+This example shows how to obtain each object of a scene and get it's initial transformation. The selected actor is represented in wireframe. To run this example:
+
+``` bash
 IndividualVRML filename actorname
+```
 
 The .wrl file must contain a Shape with a DEF name.
diff --git a/src/Cxx/IO/JPEGReader.cxx b/src/Cxx/IO/JPEGReader.cxx
index 3de121e863b328816c1bb4fda366eb6a34e2c401..355289588704953c689efd845eec5c182c1b03b0 100644
--- a/src/Cxx/IO/JPEGReader.cxx
+++ b/src/Cxx/IO/JPEGReader.cxx
@@ -1,34 +1,38 @@
-#include <vtkSmartPointer.h>
 #include <vtkImageViewer2.h>
 #include <vtkJPEGReader.h>
+#include <vtkNamedColors.h>
+#include <vtkNew.h>
+#include <vtkProperty.h>
 #include <vtkRenderWindow.h>
 #include <vtkRenderWindowInteractor.h>
 #include <vtkRenderer.h>
 
 int main(int argc, char* argv[])
 {
-  //Verify input arguments
-  if ( argc != 2 )
+  vtkNew<vtkNamedColors> colors;
+
+  // Verify input arguments
+  if (argc != 2)
   {
     std::cout << "Usage: " << argv[0]
               << " Filename(.jpeg/jpg) e.g. Pileated.jpg " << std::endl;
     return EXIT_FAILURE;
   }
 
-  //Read the image
-  vtkSmartPointer<vtkJPEGReader> jpegReader =
-    vtkSmartPointer<vtkJPEGReader>::New();
-  jpegReader->SetFileName ( argv[1] );
+  // Read the image
+  vtkNew<vtkJPEGReader> jpegReader;
+  jpegReader->SetFileName(argv[1]);
 
   // Visualize
-  vtkSmartPointer<vtkImageViewer2> imageViewer =
-    vtkSmartPointer<vtkImageViewer2>::New();
-  imageViewer->SetInputConnection( jpegReader->GetOutputPort() );
-  vtkSmartPointer<vtkRenderWindowInteractor> renderWindowInteractor =
-    vtkSmartPointer<vtkRenderWindowInteractor>::New();
+  vtkNew<vtkImageViewer2> imageViewer;
+  imageViewer->SetInputConnection(jpegReader->GetOutputPort());
+  vtkNew<vtkRenderWindowInteractor> renderWindowInteractor;
   imageViewer->SetupInteractor(renderWindowInteractor);
   imageViewer->Render();
   imageViewer->GetRenderer()->ResetCamera();
+  imageViewer->GetRenderer()->SetBackground(
+      colors->GetColor3d("DarkSlateGray").GetData());
+  imageViewer->GetRenderWindow()->SetWindowName("JPEGReader");
   imageViewer->Render();
 
   renderWindowInteractor->Start();
diff --git a/src/Cxx/IO/JPEGWriter.cxx b/src/Cxx/IO/JPEGWriter.cxx
index 936de5bab2a1612d7ee01e3fb1999a8cf8a10db2..ad12e40da6282ba37f7c185bef8a99341d727028 100644
--- a/src/Cxx/IO/JPEGWriter.cxx
+++ b/src/Cxx/IO/JPEGWriter.cxx
@@ -1,31 +1,47 @@
-#include <vtkSmartPointer.h>
 #include <vtkImageCanvasSource2D.h>
 #include <vtkJPEGWriter.h>
+#include <vtkNamedColors.h>
+#include <vtkNew.h>
+#include <vtkSmartPointer.h>
+
+#include <array>
 
 int main(int vtkNotUsed(argc), char* vtkNotUsed(argv)[])
 {
   std::string outputFilename = "output.jpg";
 
+  vtkNew<vtkNamedColors> colors;
+
+  std::array<double, 3> drawColor1{0, 0, 0};
+  std::array<double, 3> drawColor2{0, 0, 0};
+  auto color1 = colors->GetColor3ub("DeepSkyBlue").GetData();
+  auto color2 = colors->GetColor3ub("PaleGoldenrod").GetData();
+  for (auto i = 0; i < 3; ++i)
+  {
+    drawColor1[i] = color1[i];
+    drawColor2[i] = color2[i];
+  }
+
   // Create a 100x100 image to save into the jpeg file
-  int extent[6] = { 0, 99, 0, 99, 0, 0 };
-  vtkSmartPointer<vtkImageCanvasSource2D> imageSource =
-    vtkSmartPointer<vtkImageCanvasSource2D>::New();
-  imageSource->SetExtent( extent );
-  imageSource->SetScalarTypeToUnsignedChar(); // vtkJPEGWriter only accepts unsigned char input
-  imageSource->SetNumberOfScalarComponents( 3 ); // 3 color channels: Red, Green and Blue
-
-  // Fill the whole image with a blue background
-  imageSource->SetDrawColor( 0, 127, 255 );
-  imageSource->FillBox( extent[0], extent[1], extent[2], extent[3] );
-
-  // Paint a 30x30 white square into the image
-  imageSource->SetDrawColor( 255, 255, 255 );
-  imageSource->FillBox( 40, 70, 20, 50 );
-
-  vtkSmartPointer<vtkJPEGWriter> writer =
-    vtkSmartPointer<vtkJPEGWriter>::New();
-  writer->SetFileName( outputFilename.c_str() );
-  writer->SetInputConnection( imageSource->GetOutputPort() );
+  int extent[6] = {0, 99, 0, 99, 0, 0};
+  vtkNew<vtkImageCanvasSource2D> imageSource;
+  imageSource->SetExtent(extent);
+  imageSource->SetScalarTypeToUnsignedChar(); // vtkJPEGWriter only accepts
+                                              // unsigned char input
+  imageSource->SetNumberOfScalarComponents(
+      3); // 3 color channels: Red, Green and Blue
+
+  // Fill the whole image with a bluish background
+  imageSource->SetDrawColor(drawColor1.data());
+  imageSource->FillBox(extent[0], extent[1], extent[2], extent[3]);
+
+  // Paint a 30x30 yellowish square into the image
+  imageSource->SetDrawColor(drawColor2.data());
+  imageSource->FillBox(40, 70, 20, 50);
+
+  vtkNew<vtkJPEGWriter> writer;
+  writer->SetFileName(outputFilename.c_str());
+  writer->SetInputConnection(imageSource->GetOutputPort());
   writer->Write();
 
   return EXIT_SUCCESS;
diff --git a/src/Cxx/IO/MetaImageReader.cxx b/src/Cxx/IO/MetaImageReader.cxx
index a7a6cd34dbab3ca8704a10864b078107d64c7adb..f7728f58f330e14dce720a0d5d5cbd8752be9c3e 100644
--- a/src/Cxx/IO/MetaImageReader.cxx
+++ b/src/Cxx/IO/MetaImageReader.cxx
@@ -1,48 +1,48 @@
-#include <vtkImageData.h>
-#include <vtkMetaImageReader.h>
-#include <vtkSmartPointer.h>
-#include <vtkInteractorStyleImage.h>
-#include <vtkRenderer.h>
 #include <vtkImageActor.h>
+#include <vtkImageData.h>
 #include <vtkImageMapper3D.h>
+#include <vtkInteractorStyleImage.h>
+#include <vtkMetaImageReader.h>
+#include <vtkNamedColors.h>
+#include <vtkNew.h>
+#include <vtkProperty.h>
 #include <vtkRenderWindow.h>
 #include <vtkRenderWindowInteractor.h>
+#include <vtkRenderer.h>
 
-int main(int argc, char *argv[])
+int main(int argc, char* argv[])
 {
+  vtkNew<vtkNamedColors> colors;
+
   std::string inputFilename;
 
-  if(argc < 2)
+  if (argc < 2)
   {
-    std::cerr << "Required arguments: image.mha" << std::endl;
+    std::cerr << "Required arguments: image.mha e.g. Gourds.mha" << std::endl;
     return EXIT_FAILURE;
   }
 
   inputFilename = argv[1];
 
-  vtkSmartPointer<vtkMetaImageReader> reader =
-    vtkSmartPointer<vtkMetaImageReader>::New();
+  vtkNew<vtkMetaImageReader> reader;
   reader->SetFileName(inputFilename.c_str());
   reader->Update();
 
   // Visualize
-  vtkSmartPointer<vtkImageActor> actor =
-    vtkSmartPointer<vtkImageActor>::New();
+  vtkNew<vtkImageActor> actor;
   actor->GetMapper()->SetInputConnection(reader->GetOutputPort());
 
-  vtkSmartPointer<vtkRenderer> renderer =
-    vtkSmartPointer<vtkRenderer>::New();
+  vtkNew<vtkRenderer> renderer;
   renderer->AddActor(actor);
+  renderer->SetBackground(colors->GetColor3d("DarkSlateGray").GetData());
   renderer->ResetCamera();
 
-  vtkSmartPointer<vtkRenderWindow> renderWindow =
-    vtkSmartPointer<vtkRenderWindow>::New();
+  vtkNew<vtkRenderWindow> renderWindow;
   renderWindow->AddRenderer(renderer);
+  renderWindow->SetWindowName("MetaImageReader");
 
-  vtkSmartPointer<vtkRenderWindowInteractor> renderWindowInteractor =
-    vtkSmartPointer<vtkRenderWindowInteractor>::New();
-  vtkSmartPointer<vtkInteractorStyleImage> style =
-    vtkSmartPointer<vtkInteractorStyleImage>::New();
+  vtkNew<vtkRenderWindowInteractor> renderWindowInteractor;
+  vtkNew<vtkInteractorStyleImage> style;
 
   renderWindowInteractor->SetInteractorStyle(style);
 
@@ -51,6 +51,6 @@ int main(int argc, char *argv[])
   renderWindowInteractor->Initialize();
 
   renderWindowInteractor->Start();
-  
+
   return EXIT_SUCCESS;
 }
diff --git a/src/Cxx/IO/MetaImageWriter.cxx b/src/Cxx/IO/MetaImageWriter.cxx
index 270c87c5d9e8e2f9582a3e7f190d345bd9201fc9..6cf77a8faef082c5f04e4f626ca51584e9939148 100644
--- a/src/Cxx/IO/MetaImageWriter.cxx
+++ b/src/Cxx/IO/MetaImageWriter.cxx
@@ -1,10 +1,7 @@
-// some standard vtk headers
-#include <vtkSmartPointer.h>
+#include <vtkNew.h>
 #include <vtkRenderWindow.h>
 #include <vtkRenderWindowInteractor.h>
 #include <vtkRenderer.h>
-
-// headers needed for this example
 #include <vtkImageData.h>
 #include <vtkImageMapper3D.h>
 #include <vtkImageCast.h>
@@ -12,53 +9,50 @@
 #include <vtkMetaImageReader.h>
 #include <vtkImageMandelbrotSource.h>
 #include <vtkImageActor.h>
+#include <vtkNamedColors.h>
+#include <vtkNew.h>
 
 int main(int, char *[])
 {
-   // adapt path !
-   std::string filePath = "julia_mha.mhd";
-   std::string filePathRaw = "julia_mha.raw";
-   // Create an image
-   vtkSmartPointer<vtkImageMandelbrotSource> source =
-      vtkSmartPointer<vtkImageMandelbrotSource>::New();
-
-   vtkSmartPointer<vtkImageCast> castFilter = 
-      vtkSmartPointer<vtkImageCast>::New();
-   castFilter->SetOutputScalarTypeToUnsignedChar();
-   castFilter->SetInputConnection(source->GetOutputPort());
-   castFilter->Update();
-
-   vtkSmartPointer<vtkMetaImageWriter> writer =
-      vtkSmartPointer<vtkMetaImageWriter>::New();
-   writer->SetInputConnection(castFilter->GetOutputPort());
-   writer->SetFileName(filePath.c_str());
-   writer->SetRAWFileName(filePathRaw.c_str());
-   writer->Write();
-
-   // Read and display file for verification that it was written correctly
-   vtkSmartPointer<vtkMetaImageReader> reader = 
-      vtkSmartPointer<vtkMetaImageReader>::New();
-   reader->SetFileName(filePath.c_str());
-   reader->Update();
-
-   vtkSmartPointer<vtkImageActor> actor =
-      vtkSmartPointer<vtkImageActor>::New();
-   actor->GetMapper()->SetInputConnection(reader->GetOutputPort());
-
-   vtkSmartPointer<vtkRenderer> renderer =
-      vtkSmartPointer<vtkRenderer>::New();
-   vtkSmartPointer<vtkRenderWindow> renderWindow =
-      vtkSmartPointer<vtkRenderWindow>::New();
-   renderWindow->AddRenderer(renderer);
-   vtkSmartPointer<vtkRenderWindowInteractor> renderWindowInteractor =
-      vtkSmartPointer<vtkRenderWindowInteractor>::New();
-   renderWindowInteractor->SetRenderWindow(renderWindow);
-
-   renderer->AddActor(actor);
-   renderer->SetBackground(.2, .3, .4);
-
-   renderWindow->Render();
-   renderWindowInteractor->Start();
+  vtkNew<vtkNamedColors> colors;
+
+  // adapt path !
+  std::string filePath = "julia_mha.mhd";
+  std::string filePathRaw = "julia_mha.raw";
+  // Create an image
+  vtkNew<vtkImageMandelbrotSource> source;
+
+  vtkNew<vtkImageCast> castFilter;
+  castFilter->SetOutputScalarTypeToUnsignedChar();
+  castFilter->SetInputConnection(source->GetOutputPort());
+  castFilter->Update();
+
+  vtkNew<vtkMetaImageWriter> writer;
+  writer->SetInputConnection(castFilter->GetOutputPort());
+  writer->SetFileName(filePath.c_str());
+  writer->SetRAWFileName(filePathRaw.c_str());
+  writer->Write();
+
+  // Read and display file for verification that it was written correctly
+  vtkNew<vtkMetaImageReader> reader;
+  reader->SetFileName(filePath.c_str());
+  reader->Update();
+
+  vtkNew<vtkImageActor> actor;
+  actor->GetMapper()->SetInputConnection(reader->GetOutputPort());
+
+  vtkNew<vtkRenderer> renderer;
+  vtkNew<vtkRenderWindow> renderWindow;
+  renderWindow->AddRenderer(renderer);
+  vtkNew<vtkRenderWindowInteractor> renderWindowInteractor;
+  renderWindowInteractor->SetRenderWindow(renderWindow);
+
+  renderer->AddActor(actor);
+  renderer->SetBackground(colors->GetColor3d("SteelBlue").GetData());
+
+  renderWindow->SetWindowName("MetaImageWriter");
+  renderWindow->Render();
+  renderWindowInteractor->Start();
 
    return EXIT_SUCCESS;
 }
diff --git a/src/Cxx/IO/OBJImporter.cxx b/src/Cxx/IO/OBJImporter.cxx
index 31d30b0bb2c006e5a47eb3ab8ed3e68c9c8adcc9..ecc0b5f2467c6bad12e7685cd2fbfcda08a96a07 100644
--- a/src/Cxx/IO/OBJImporter.cxx
+++ b/src/Cxx/IO/OBJImporter.cxx
@@ -1,31 +1,33 @@
 #include <vtkNamedColors.h>
+#include <vtkNew.h>
 #include <vtkOBJImporter.h>
 #include <vtkPolyData.h>
 #include <vtkPolyDataMapper.h>
 #include <vtkRenderWindow.h>
 #include <vtkRenderWindowInteractor.h>
 #include <vtkRenderer.h>
-#include <vtkSmartPointer.h>
 #include <vtkTexture.h>
 
 int main(int argc, char* argv[])
 {
   if (argc < 4)
   {
-    std::cout << "Usage: " << argv[0] << " objfile mtlfile texturepath"
-              << std::endl;
+    std::cout
+        << "Usage: " << argv[0]
+        << " objfile mtlfile texturepath e.g. doorman.obj doorman.mtl doorman"
+        << std::endl;
     return EXIT_FAILURE;
   }
-  auto importer = vtkSmartPointer<vtkOBJImporter>::New();
+  vtkNew<vtkOBJImporter> importer;
   importer->SetFileName(argv[1]);
   importer->SetFileNameMTL(argv[2]);
   importer->SetTexturePath(argv[3]);
 
-  auto colors = vtkSmartPointer<vtkNamedColors>::New();
+  vtkNew<vtkNamedColors> colors;
 
-  auto renderer = vtkSmartPointer<vtkRenderer>::New();
-  auto renWin = vtkSmartPointer<vtkRenderWindow>::New();
-  auto iren = vtkSmartPointer<vtkRenderWindowInteractor>::New();
+  vtkNew<vtkRenderer> renderer;
+  vtkNew<vtkRenderWindow> renWin;
+  vtkNew<vtkRenderWindowInteractor> iren;
 
   renderer->SetBackground2(colors->GetColor3d("Silver").GetData());
   renderer->SetBackground(colors->GetColor3d("Gold").GetData());
@@ -34,6 +36,7 @@ int main(int argc, char* argv[])
   renderer->UseHiddenLineRemovalOn();
   renWin->AddRenderer(renderer);
   renWin->SetSize(640, 480);
+  renWin->SetWindowName("OBJImporter");
 
   iren->SetRenderWindow(renWin);
   importer->SetRenderWindow(renWin);
diff --git a/src/Cxx/IO/PNGReader.cxx b/src/Cxx/IO/PNGReader.cxx
index 4f22e97df2a9e096364623121d3d8fc4ab349915..e8ac22bde79dd5461b53c3f20b749df98c7f1291 100644
--- a/src/Cxx/IO/PNGReader.cxx
+++ b/src/Cxx/IO/PNGReader.cxx
@@ -1,5 +1,6 @@
-#include <vtkSmartPointer.h>
 #include <vtkImageViewer2.h>
+#include <vtkNamedColors.h>
+#include <vtkNew.h>
 #include <vtkPNGReader.h>
 #include <vtkRenderWindow.h>
 #include <vtkRenderWindowInteractor.h>
@@ -7,28 +8,30 @@
 
 int main(int argc, char* argv[])
 {
+  vtkNew<vtkNamedColors> colors;
+
   // Verify input arguments
-  if ( argc < 2 )
+  if (argc < 2)
   {
-    std::cout << "Usage: " << argv[0]
-              << " Filename(.png) e.g. Gourds.png" << std::endl;
+    std::cout << "Usage: " << argv[0] << " Filename(.png) e.g. Gourds.png"
+              << std::endl;
     return EXIT_FAILURE;
   }
 
   // Read the image
-  vtkSmartPointer<vtkPNGReader> reader =
-    vtkSmartPointer<vtkPNGReader>::New();
+  vtkNew<vtkPNGReader> reader;
   reader->SetFileName(argv[1]);
 
   // Visualize
-  vtkSmartPointer<vtkImageViewer2> imageViewer =
-    vtkSmartPointer<vtkImageViewer2>::New();
+  vtkNew<vtkImageViewer2> imageViewer;
   imageViewer->SetInputConnection(reader->GetOutputPort());
-  vtkSmartPointer<vtkRenderWindowInteractor> renderWindowInteractor =
-    vtkSmartPointer<vtkRenderWindowInteractor>::New();
+  vtkNew<vtkRenderWindowInteractor> renderWindowInteractor;
   imageViewer->SetupInteractor(renderWindowInteractor);
   imageViewer->Render();
   imageViewer->GetRenderer()->ResetCamera();
+  imageViewer->GetRenderer()->SetBackground(
+      colors->GetColor3d("DarkSlateGray").GetData());
+  imageViewer->GetRenderWindow()->SetWindowName("PNGReader");
   imageViewer->Render();
 
   renderWindowInteractor->Start();
diff --git a/src/Cxx/IO/PNGReader.md b/src/Cxx/IO/PNGReader.md
index 8c73068eb3aeb61ea2b4398c7fcdd5423fb10359..b9fc3151aab2a1146b2327f4fe1f6e22881bfe7b 100644
--- a/src/Cxx/IO/PNGReader.md
+++ b/src/Cxx/IO/PNGReader.md
@@ -1,2 +1,3 @@
 ### Description
+
 This example demonstrates how to read a PNG image file.
diff --git a/src/Cxx/IO/PNGWriter.cxx b/src/Cxx/IO/PNGWriter.cxx
index f78ac419da79b8fb373c4e4139316b3df67f896b..f1266f8b67545ac5499f934d1e7d22ecac64d8fd 100644
--- a/src/Cxx/IO/PNGWriter.cxx
+++ b/src/Cxx/IO/PNGWriter.cxx
@@ -1,13 +1,16 @@
-#include <vtkImageData.h>
-#include <vtkPNGWriter.h>
-#include <vtkSmartPointer.h>
 #include <vtkImageCanvasSource2D.h>
 #include <vtkImageCast.h>
+#include <vtkImageData.h>
+#include <vtkNamedColors.h>
+#include <vtkNew.h>
+#include <vtkPNGWriter.h>
+
+#include <array>
 
-int main(int argc, char *argv[])
+int main(int argc, char* argv[])
 {
   std::string outputFilename;
-  if( argc > 1)
+  if (argc > 1)
   {
     outputFilename = argv[1];
   }
@@ -16,26 +19,35 @@ int main(int argc, char *argv[])
     outputFilename = "output.png";
   }
 
+  vtkNew<vtkNamedColors> colors;
+
+  std::array<double, 3> drawColor1{0, 0, 0};
+  std::array<double, 3> drawColor2{0, 0, 0};
+  auto color1 = colors->GetColor3ub("MediumOrchid").GetData();
+  auto color2 = colors->GetColor3ub("DarkGreen").GetData();
+  for (auto i = 0; i < 3; ++i)
+  {
+    drawColor1[i] = color1[i];
+    drawColor2[i] = color2[i];
+  }
+
   int extent[6] = {0, 99, 0, 99, 0, 0};
-  vtkSmartPointer<vtkImageCanvasSource2D> imageSource =
-    vtkSmartPointer<vtkImageCanvasSource2D>::New();
+  vtkNew<vtkImageCanvasSource2D> imageSource;
   imageSource->SetExtent(extent);
   imageSource->SetScalarTypeToUnsignedChar();
   imageSource->SetNumberOfScalarComponents(3);
-  imageSource->SetDrawColor(127, 45, 255);
+  imageSource->SetDrawColor(drawColor1.data());
   imageSource->FillBox(0, 99, 0, 99);
-  imageSource->SetDrawColor(255,255,255);
+  imageSource->SetDrawColor(drawColor2.data());
   imageSource->FillBox(40, 70, 20, 50);
   imageSource->Update();
 
-  vtkSmartPointer<vtkImageCast> castFilter =
-    vtkSmartPointer<vtkImageCast>::New();
-  castFilter->SetOutputScalarTypeToUnsignedChar ();
+  vtkNew<vtkImageCast> castFilter;
+  castFilter->SetOutputScalarTypeToUnsignedChar();
   castFilter->SetInputConnection(imageSource->GetOutputPort());
   castFilter->Update();
 
-  vtkSmartPointer<vtkPNGWriter> writer =
-    vtkSmartPointer<vtkPNGWriter>::New();
+  vtkNew<vtkPNGWriter> writer;
   writer->SetFileName(outputFilename.c_str());
   writer->SetInputConnection(castFilter->GetOutputPort());
   writer->Write();
diff --git a/src/Cxx/IO/ParticleReader.cxx b/src/Cxx/IO/ParticleReader.cxx
index 16aa0016352f903bd92c8180047fc3fbd4d162c2..e548ad1ffbbaed6b24b55e354d1eae354a7b84de 100644
--- a/src/Cxx/IO/ParticleReader.cxx
+++ b/src/Cxx/IO/ParticleReader.cxx
@@ -1,70 +1,67 @@
 //
-// This example reads ascii files where each line consists of points with its position (x,y,z) 
-// and (optionally) one scalar or binary files in RAW 3d file format.
+// This example reads ascii files where each line consists of points with its
+// position (x,y,z) and (optionally) one scalar or binary files in RAW 3d file
+// format.
 //
 // some standard vtk headers
-#include <vtkSmartPointer.h>
-#include <vtkRenderWindow.h>
-#include <vtkRenderWindowInteractor.h>
-#include <vtkRenderer.h>
 #include <vtkActor.h>
-#include <vtkProperty.h>
-
-// headers needed for this example
+#include <vtkNamedColors.h>
+#include <vtkNew.h>
 #include <vtkParticleReader.h>
 #include <vtkPolyDataMapper.h>
-
+#include <vtkProperty.h>
+#include <vtkRenderWindow.h>
+#include <vtkRenderWindowInteractor.h>
+#include <vtkRenderer.h>
 
 // needed to easily convert int to std::string
 int main(int argc, char* argv[])
 {
-   // Verify input arguments
-   if ( argc != 2 )
-   {
-      std::cout << "Usage: " << argv[0]
-      << " Filename(.raw) e.g. Particles.raw" << std::endl;
-      return EXIT_FAILURE;
-   }
+  vtkNew<vtkNamedColors> colors;
+
+  // Verify input arguments
+  if (argc != 2)
+  {
+    std::cout << "Usage: " << argv[0] << " Filename(.raw) e.g. Particles.raw"
+              << std::endl;
+    return EXIT_FAILURE;
+  }
+
+  std::string filePath = argv[1];
+  // Particles.raw supplied by VTK is big endian encoded
+  // std::string filePath = "C:\\VTK\\vtkdata-5.8.0\\Data\\Particles.raw";
+  // Read the file
+  vtkNew<vtkParticleReader> reader;
 
-   std::string filePath = argv[1];
-   // Particles.raw supplied by VTK is big endian encoded
-   //std::string filePath = "C:\\VTK\\vtkdata-5.8.0\\Data\\Particles.raw";
-   // Read the file
-   vtkSmartPointer<vtkParticleReader> reader =
-      vtkSmartPointer<vtkParticleReader>::New();
+  reader->SetFileName(filePath.c_str());
+  // if nothing gets displayed or totally wrong, swap the endianness
+  reader->SetDataByteOrderToBigEndian();
+  reader->Update();
 
-   reader->SetFileName ( filePath.c_str() );
-   // if nothing gets displayed or totally wrong, swap the endianness
-   reader->SetDataByteOrderToBigEndian();
-   reader->Update();
+  // Visualize
+  vtkNew<vtkPolyDataMapper> mapper;
+  mapper->SetInputConnection(reader->GetOutputPort());
+  std::cout << "number of pieces: " << mapper->GetNumberOfPieces() << std::endl;
+  mapper->SetScalarRange(4, 9);
 
-   // Visualize
-   vtkSmartPointer<vtkPolyDataMapper> mapper =
-      vtkSmartPointer<vtkPolyDataMapper>::New();
-   mapper->SetInputConnection(reader->GetOutputPort());
-   std::cout << "number of pieces: " << mapper->GetNumberOfPieces() << std::endl;
-   mapper->SetScalarRange(4, 9);
+  vtkNew<vtkActor> actor;
 
-   vtkSmartPointer<vtkActor> actor =
-      vtkSmartPointer<vtkActor>::New();
+  actor->SetMapper(mapper);
+  actor->GetProperty()->SetPointSize(4);
 
-   actor->SetMapper(mapper);
-   actor->GetProperty()->SetPointSize(4);
+  vtkNew<vtkRenderer> renderer;
+  vtkNew<vtkRenderWindow> renderWindow;
+  renderWindow->AddRenderer(renderer);
+  renderWindow->SetWindowName("ParticleReader");
 
-   vtkSmartPointer<vtkRenderer> renderer =
-      vtkSmartPointer<vtkRenderer>::New();
-   vtkSmartPointer<vtkRenderWindow> renderWindow =
-      vtkSmartPointer<vtkRenderWindow>::New();
-   renderWindow->AddRenderer(renderer);
-   vtkSmartPointer<vtkRenderWindowInteractor> renderWindowInteractor =
-      vtkSmartPointer<vtkRenderWindowInteractor>::New();
-   renderWindowInteractor->SetRenderWindow(renderWindow);
+  vtkNew<vtkRenderWindowInteractor> renderWindowInteractor;
+  renderWindowInteractor->SetRenderWindow(renderWindow);
 
-   renderer->AddActor(actor);
-   renderer->SetBackground(.2, .3, .4);
+  renderer->AddActor(actor);
+  renderer->SetBackground(colors->GetColor3d("DarkSlateGray").GetData());
 
-   renderWindow->Render();
-   renderWindowInteractor->Start();
+  renderWindow->Render();
+  renderWindowInteractor->Start();
 
-   return EXIT_SUCCESS;
+  return EXIT_SUCCESS;
 }
diff --git a/src/Cxx/IO/ParticleReader.md b/src/Cxx/IO/ParticleReader.md
index 2739efb490d90165c65d90842f0b016de4592f8c..ba4fdd773dba6cc1ed4fd7dcbfeb4bd630958acd 100644
--- a/src/Cxx/IO/ParticleReader.md
+++ b/src/Cxx/IO/ParticleReader.md
@@ -1,3 +1,4 @@
 ### Description
+
 This example reads ascii files where each line consists of points with its position (x,y,z) and (optionally) <u>one</u> scalar
 or binary files in RAW 3d file format.
diff --git a/src/Cxx/IO/ReadAllPolyDataTypes.cxx b/src/Cxx/IO/ReadAllPolyDataTypes.cxx
index 79b5cca1575414ff0918f825a5280c80b9f3d861..35579b601cbfd3d3eaeba62877919e4308dfb0a2 100644
--- a/src/Cxx/IO/ReadAllPolyDataTypes.cxx
+++ b/src/Cxx/IO/ReadAllPolyDataTypes.cxx
@@ -1,54 +1,54 @@
-#include <vtkSmartPointer.h>
-
 #include <vtkBYUReader.h>
 #include <vtkOBJReader.h>
 #include <vtkPLYReader.h>
 #include <vtkPolyDataReader.h>
 #include <vtkSTLReader.h>
 #include <vtkXMLPolyDataReader.h>
-#include <vtkSphereSource.h>
 
 #include <vtkActor.h>
+#include <vtkCamera.h>
+#include <vtkNamedColors.h>
 #include <vtkPolyDataMapper.h>
 #include <vtkProperty.h>
 #include <vtkRenderWindow.h>
 #include <vtkRenderWindowInteractor.h>
 #include <vtkRenderer.h>
-#include <vtkCamera.h>
-
-#include <vtkNamedColors.h>
+#include <vtkSmartPointer.h>
+#include <vtkSphereSource.h>
 #include <vtkTimerLog.h>
 #include <vtksys/SystemTools.hxx>
 
-#include <string>
 #include <algorithm>
-#include <random>
 #include <array>
+#include <random>
+#include <string>
 
-namespace
-{
-vtkSmartPointer<vtkPolyData> ReadPolyData(const char *fileName);
+namespace {
+vtkSmartPointer<vtkPolyData> ReadPolyData(const char* fileName);
 }
 
-int main (int argc, char *argv[])
+int main(int argc, char* argv[])
 {
   // Vis Pipeline
-  auto colors = vtkSmartPointer<vtkNamedColors>::New();
+  vtkNew<vtkNamedColors> colors;
 
-  auto renderer = vtkSmartPointer<vtkRenderer>::New();
+  vtkNew<vtkRenderer> renderer;
 
-  auto renderWindow = vtkSmartPointer<vtkRenderWindow>::New();
+  vtkNew<vtkRenderWindow> renderWindow;
   renderWindow->SetSize(640, 480);
   renderWindow->AddRenderer(renderer);
 
-  auto interactor = vtkSmartPointer<vtkRenderWindowInteractor>::New();
+  vtkNew<vtkRenderWindowInteractor> interactor;
   interactor->SetRenderWindow(renderWindow);
 
   renderer->SetBackground(colors->GetColor3d("Wheat").GetData());
   renderer->UseHiddenLineRemovalOn();
 
-  std::mt19937 mt(4355412); //Standard mersenne_twister_engine
-  std::uniform_real_distribution<double> distribution(.6, 1.0);
+  // Note: If a Python version is written, it is probably best to use
+  //       vtkMinimalStandardRandomSequence in it and here, to ensure
+  //       that the randomnumber generation is the same.
+  std::mt19937 mt(4355412); // Standard mersenne_twister_engine
+  std::uniform_real_distribution<double> distribution(0.6, 1.0);
 
   // PolyData file pipeline
   for (int i = 1; i < argc; ++i)
@@ -57,93 +57,94 @@ int main (int argc, char *argv[])
     auto polyData = ReadPolyData(argv[i]);
 
     // Visualize
-    auto mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
+    vtkNew<vtkPolyDataMapper> mapper;
     mapper->SetInputData(polyData);
 
     std::array<double, 3> randomColor;
     randomColor[0] = distribution(mt);
     randomColor[1] = distribution(mt);
     randomColor[2] = distribution(mt);
-    auto backProp = vtkSmartPointer<vtkProperty>::New();
+    vtkNew<vtkProperty> backProp;
     backProp->SetDiffuseColor(colors->GetColor3d("Banana").GetData());
-    backProp->SetSpecular(.6);
+    backProp->SetSpecular(0.6);
     backProp->SetSpecularPower(30);
 
-    auto actor = vtkSmartPointer<vtkActor>::New();
+    vtkNew<vtkActor> actor;
     actor->SetMapper(mapper);
     actor->SetBackfaceProperty(backProp);
     actor->GetProperty()->SetDiffuseColor(randomColor.data());
-    actor->GetProperty()->SetSpecular(.3);
+    actor->GetProperty()->SetSpecular(0.3);
     actor->GetProperty()->SetSpecularPower(30);
     renderer->AddActor(actor);
   }
 
+  renderWindow->SetWindowName("ReadAllPolyDataTypes");
   renderWindow->Render();
   interactor->Start();
 
   return EXIT_SUCCESS;
 }
 
-namespace
-{
-vtkSmartPointer<vtkPolyData> ReadPolyData(const char *fileName)
+namespace {
+vtkSmartPointer<vtkPolyData> ReadPolyData(const char* fileName)
 {
   vtkSmartPointer<vtkPolyData> polyData;
   std::string extension =
-    vtksys::SystemTools::GetFilenameLastExtension(std::string(fileName));
+      vtksys::SystemTools::GetFilenameLastExtension(std::string(fileName));
 
   // Drop the case of the extension
-  std::transform(extension.begin(), extension.end(),
-                 extension.begin(), ::tolower);
+  std::transform(extension.begin(), extension.end(), extension.begin(),
+                 ::tolower);
 
   if (extension == ".ply")
   {
-    auto reader = vtkSmartPointer<vtkPLYReader>::New();
-    reader->SetFileName (fileName);
+    vtkNew<vtkPLYReader> reader;
+    reader->SetFileName(fileName);
     reader->Update();
     polyData = reader->GetOutput();
   }
   else if (extension == ".vtp")
   {
-    auto reader = vtkSmartPointer<vtkXMLPolyDataReader>::New();
-    reader->SetFileName (fileName);
+    vtkNew<vtkXMLPolyDataReader> reader;
+    reader->SetFileName(fileName);
     reader->Update();
     polyData = reader->GetOutput();
   }
   else if (extension == ".obj")
   {
-    auto reader = vtkSmartPointer<vtkOBJReader>::New();
-    reader->SetFileName (fileName);
+    vtkNew<vtkOBJReader> reader;
+    reader->SetFileName(fileName);
     reader->Update();
     polyData = reader->GetOutput();
   }
   else if (extension == ".stl")
   {
-    auto reader = vtkSmartPointer<vtkSTLReader>::New();
-    reader->SetFileName (fileName);
+    vtkNew<vtkSTLReader> reader;
+    reader->SetFileName(fileName);
     reader->Update();
     polyData = reader->GetOutput();
   }
   else if (extension == ".vtk")
   {
-    auto reader = vtkSmartPointer<vtkPolyDataReader>::New();
-    reader->SetFileName (fileName);
+    vtkNew<vtkPolyDataReader> reader;
+    reader->SetFileName(fileName);
     reader->Update();
     polyData = reader->GetOutput();
   }
   else if (extension == ".g")
   {
-    auto reader = vtkSmartPointer<vtkBYUReader>::New();
-    reader->SetGeometryFileName (fileName);
+    vtkNew<vtkBYUReader> reader;
+    reader->SetGeometryFileName(fileName);
     reader->Update();
     polyData = reader->GetOutput();
   }
   else
   {
-    auto source = vtkSmartPointer<vtkSphereSource>::New();
+    vtkNew<vtkSphereSource> source;
     source->Update();
     polyData = source->GetOutput();
   }
+
   return polyData;
 }
-}
+} // namespace
diff --git a/src/Cxx/IO/ReadAllPolyDataTypes.md b/src/Cxx/IO/ReadAllPolyDataTypes.md
index 50e529973cf8d2158db15e965315bcff80da7190..33278495a27b00ba790d7a694b42a15b15fba922 100644
--- a/src/Cxx/IO/ReadAllPolyDataTypes.md
+++ b/src/Cxx/IO/ReadAllPolyDataTypes.md
@@ -1,4 +1,5 @@
 ###Description
+
 This example selects the vtkPolyData reader by inspecting the extension of the file. The example processes every file passed as an argument. This assumes all of the files are modeled in the same coordinate system.
 
 
diff --git a/src/Cxx/IO/ReadAllPolyDataTypesDemo.cxx b/src/Cxx/IO/ReadAllPolyDataTypesDemo.cxx
index 10ac86811127ce6b9d81d72e9fc39eae1dff0157..068c8a087c39ced734b8838eb38da3af8ab8e200 100644
--- a/src/Cxx/IO/ReadAllPolyDataTypesDemo.cxx
+++ b/src/Cxx/IO/ReadAllPolyDataTypesDemo.cxx
@@ -2,19 +2,26 @@
 #include <vtkActor2D.h>
 #include <vtkBYUReader.h>
 #include <vtkCamera.h>
+#include <vtkCellArray.h>
 #include <vtkCoordinate.h>
 #include <vtkNamedColors.h>
+#include <vtkNew.h>
 #include <vtkOBJReader.h>
 #include <vtkPLYReader.h>
+#include <vtkPoints.h>
+#include <vtkPolyData.h>
 #include <vtkPolyDataMapper.h>
+#include <vtkPolyDataMapper2D.h>
 #include <vtkPolyDataReader.h>
+#include <vtkPolyLine.h>
 #include <vtkProperty.h>
-#include <vtkRenderer.h>
+#include <vtkProperty2D.h>
 #include <vtkRenderWindow.h>
 #include <vtkRenderWindowInteractor.h>
+#include <vtkRenderer.h>
+#include <vtkSTLReader.h>
 #include <vtkSmartPointer.h>
 #include <vtkSphereSource.h>
-#include <vtkSTLReader.h>
 #include <vtkTextMapper.h>
 #include <vtkTextProperty.h>
 #include <vtkTimerLog.h>
@@ -22,57 +29,54 @@
 
 #include <vtksys/SystemTools.hxx>
 
-#include <string>
 #include <algorithm>
+#include <string>
 
-namespace
-{
-vtkSmartPointer<vtkPolyData> ReadPolyData(const char *fileName);
-}
+namespace {
+vtkSmartPointer<vtkPolyData> ReadPolyData(const char* fileName);
 
-namespace
-{
-void ViewportBorder(vtkSmartPointer<vtkRenderer> &renderer,
-                    double *color,
+void ViewportBorder(vtkSmartPointer<vtkRenderer>& renderer, double* color,
                     bool last = false);
-}
-int main (int argc, char *argv[])
+} // namespace
+
+int main(int argc, char* argv[])
 {
   // Visualize
-  auto colors = vtkSmartPointer<vtkNamedColors>::New();
+  vtkNew<vtkNamedColors> colors;
 
   // Create one text property for all
-  auto textProperty = vtkSmartPointer<vtkTextProperty>::New();
+  vtkNew<vtkTextProperty> textProperty;
   textProperty->SetFontSize(16);
   textProperty->SetColor(0.3, 0.3, 0.3);
 
   // Setup render window
-  auto renderWindow = vtkSmartPointer<vtkRenderWindow>::New();
+  vtkNew<vtkRenderWindow> renderWindow;
   std::vector<vtkSmartPointer<vtkRenderer>> renderers;
   for (auto i = 1; i < argc; ++i)
   {
     std::cout << argv[i] << std::endl;
     auto polyData = ReadPolyData(argv[i]);
-    auto mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
+    vtkNew<vtkPolyDataMapper> mapper;
     mapper->SetInputData(polyData);
 
-    auto actor = vtkSmartPointer<vtkActor>::New();
+    vtkNew<vtkActor> actor;
     actor->SetMapper(mapper);
-    actor->GetProperty()->SetDiffuseColor(colors->GetColor3d("Light_salmon").GetData());
-    actor->GetProperty()->SetSpecular(.6);
+    actor->GetProperty()->SetDiffuseColor(
+        colors->GetColor3d("Light_salmon").GetData());
+    actor->GetProperty()->SetSpecular(0.6);
     actor->GetProperty()->SetSpecularPower(30);
 
     // Create textActors
-    auto textMapper = vtkSmartPointer<vtkTextMapper>::New();
+    vtkNew<vtkTextMapper> textMapper;
     textMapper->SetTextProperty(textProperty);
     textMapper->SetInput(vtksys::SystemTools::GetFilenameName(argv[i]).c_str());
 
-    auto textActor = vtkSmartPointer<vtkActor2D>::New();
+    vtkNew<vtkActor2D> textActor;
     textActor->SetMapper(textMapper);
     textActor->SetPosition(20, 20);
 
     // Setup renderer
-    auto renderer = vtkSmartPointer<vtkRenderer>::New();
+    vtkNew<vtkRenderer> renderer;
     renderer->AddActor(actor);
     renderer->AddActor(textActor);
     renderer->SetBackground(colors->GetColor3d("mint").GetData());
@@ -85,12 +89,12 @@ int main (int argc, char *argv[])
   auto xGridDimensions = 3;
   auto yGridDimensions = 2;
   yGridDimensions = argc / xGridDimensions;
-  renderWindow->SetSize(
-    rendererSize * xGridDimensions, rendererSize * yGridDimensions);
+  renderWindow->SetSize(rendererSize * xGridDimensions,
+                        rendererSize * yGridDimensions);
   auto blank = argc - 1 + ((argc - 1) % xGridDimensions);
   for (auto i = argc; i < blank; ++i)
   {
-    auto renderer = vtkSmartPointer<vtkRenderer>::New();
+    vtkNew<vtkRenderer> renderer;
     renderer->SetBackground(colors->GetColor3d("White").GetData());
     renderers.push_back(renderer);
     renderWindow->AddRenderer(renderer);
@@ -103,112 +107,100 @@ int main (int argc, char *argv[])
       auto index = row * xGridDimensions + col;
 
       // (xmin, ymin, xmax, ymax)
-      double viewport[4] = {
-        static_cast<double>(col) * rendererSize /
-        (xGridDimensions * rendererSize),
-        static_cast<double>(yGridDimensions - (row + 1)) * rendererSize /
-        (yGridDimensions * rendererSize),
-        static_cast<double>(col + 1) * rendererSize /
-        (xGridDimensions * rendererSize),
-        static_cast<double>(yGridDimensions - row) * rendererSize /
-        (yGridDimensions * rendererSize)};
+      double viewport[4] = {static_cast<double>(col) * rendererSize /
+                                (xGridDimensions * rendererSize),
+                            static_cast<double>(yGridDimensions - (row + 1)) *
+                                rendererSize / (yGridDimensions * rendererSize),
+                            static_cast<double>(col + 1) * rendererSize /
+                                (xGridDimensions * rendererSize),
+                            static_cast<double>(yGridDimensions - row) *
+                                rendererSize /
+                                (yGridDimensions * rendererSize)};
       renderers[index]->SetViewport(viewport);
       ViewportBorder(renderers[index],
                      colors->GetColor3d("SlateGray").GetData(),
                      col == static_cast<int>(xGridDimensions));
     }
   }
-  auto interactor = vtkSmartPointer<vtkRenderWindowInteractor>::New();
+  vtkNew<vtkRenderWindowInteractor> interactor;
   interactor->SetRenderWindow(renderWindow);
 
+  renderWindow->SetWindowName("ReadAllPolyDataTypesDemo");
   renderWindow->Render();
   interactor->Start();
 
   return EXIT_SUCCESS;
 }
 
+namespace {
 
-namespace
-{
-vtkSmartPointer<vtkPolyData> ReadPolyData(const char *fileName)
+vtkSmartPointer<vtkPolyData> ReadPolyData(const char* fileName)
 {
   vtkSmartPointer<vtkPolyData> polyData;
   std::string extension =
-    vtksys::SystemTools::GetFilenameLastExtension(std::string(fileName));
+      vtksys::SystemTools::GetFilenameLastExtension(std::string(fileName));
 
   // Drop the case of the extension
-  std::transform(extension.begin(), extension.end(),
-                 extension.begin(), ::tolower);
+  std::transform(extension.begin(), extension.end(), extension.begin(),
+                 ::tolower);
 
   if (extension == ".ply")
   {
-    auto reader = vtkSmartPointer<vtkPLYReader>::New();
-    reader->SetFileName (fileName);
+    vtkNew<vtkPLYReader> reader;
+    reader->SetFileName(fileName);
     reader->Update();
     polyData = reader->GetOutput();
   }
   else if (extension == ".vtp")
   {
-    auto reader = vtkSmartPointer<vtkXMLPolyDataReader>::New();
-    reader->SetFileName (fileName);
+    vtkNew<vtkXMLPolyDataReader> reader;
+    reader->SetFileName(fileName);
     reader->Update();
     polyData = reader->GetOutput();
   }
   else if (extension == ".obj")
   {
-    auto reader = vtkSmartPointer<vtkOBJReader>::New();
-    reader->SetFileName (fileName);
+    vtkNew<vtkOBJReader> reader;
+    reader->SetFileName(fileName);
     reader->Update();
     polyData = reader->GetOutput();
   }
   else if (extension == ".stl")
   {
-    auto reader = vtkSmartPointer<vtkSTLReader>::New();
-    reader->SetFileName (fileName);
+    vtkNew<vtkSTLReader> reader;
+    reader->SetFileName(fileName);
     reader->Update();
     polyData = reader->GetOutput();
   }
   else if (extension == ".vtk")
   {
-    auto reader = vtkSmartPointer<vtkPolyDataReader>::New();
-    reader->SetFileName (fileName);
+    vtkNew<vtkPolyDataReader> reader;
+    reader->SetFileName(fileName);
     reader->Update();
     polyData = reader->GetOutput();
   }
   else if (extension == ".g")
   {
-    auto reader = vtkSmartPointer<vtkBYUReader>::New();
-    reader->SetGeometryFileName (fileName);
+    vtkNew<vtkBYUReader> reader;
+    reader->SetGeometryFileName(fileName);
     reader->Update();
     polyData = reader->GetOutput();
   }
   else
   {
-    auto source = vtkSmartPointer<vtkSphereSource>::New();
+    vtkNew<vtkSphereSource> source;
     source->Update();
     polyData = source->GetOutput();
   }
   return polyData;
 }
-}
-#include <vtkRenderer.h>
-#include <vtkPoints.h>
-#include <vtkCellArray.h>
-#include <vtkPolyData.h>
-#include <vtkPolyLine.h>
-#include <vtkPolyDataMapper2D.h>
-#include <vtkCoordinate.h>
-#include <vtkActor2D.h>
-#include <vtkProperty2D.h>
-namespace
-{
+
 // draw the borders of a renderer's viewport
-void ViewportBorder(vtkSmartPointer<vtkRenderer> &renderer,
-                    double *color,
+void ViewportBorder(vtkSmartPointer<vtkRenderer>& renderer, double* color,
                     bool last)
 {
   // points start at upper right and proceed anti-clockwise
-  auto points = vtkSmartPointer<vtkPoints>::New();
+  vtkNew<vtkPoints> points;
   points->SetNumberOfPoints(4);
   points->InsertPoint(0, 1, 1, 0);
   points->InsertPoint(1, 0, 1, 0);
@@ -216,10 +208,10 @@ void ViewportBorder(vtkSmartPointer<vtkRenderer> &renderer,
   points->InsertPoint(3, 1, 0, 0);
 
   // create cells, and lines
-  auto cells = vtkSmartPointer<vtkCellArray>::New();
+  vtkNew<vtkCellArray> cells;
   cells->Initialize();
 
-  auto lines = vtkSmartPointer<vtkPolyLine>::New();
+  vtkNew<vtkPolyLine> lines;
 
   // only draw last line if this is the last viewport
   // this prevents double vertical lines at right border
@@ -233,9 +225,9 @@ void ViewportBorder(vtkSmartPointer<vtkRenderer> &renderer,
   {
     lines->GetPointIds()->SetNumberOfIds(4);
   }
-  for(unsigned int i = 0; i < 4; ++i)
+  for (unsigned int i = 0; i < 4; ++i)
   {
-    lines->GetPointIds()->SetId(i,i);
+    lines->GetPointIds()->SetId(i, i);
   }
   if (last)
   {
@@ -243,22 +235,22 @@ void ViewportBorder(vtkSmartPointer<vtkRenderer> &renderer,
   }
   cells->InsertNextCell(lines);
 
-  // now make tge polydata and display it
-  auto poly = vtkSmartPointer<vtkPolyData>::New();
+  // now make the polydata and display it
+  vtkNew<vtkPolyData> poly;
   poly->Initialize();
   poly->SetPoints(points);
   poly->SetLines(cells);
 
   // use normalized viewport coordinates since
   // they are independent of window size
-  auto coordinate = vtkSmartPointer<vtkCoordinate>::New();
+  vtkNew<vtkCoordinate> coordinate;
   coordinate->SetCoordinateSystemToNormalizedViewport();
 
-  auto mapper = vtkSmartPointer<vtkPolyDataMapper2D>::New();
+  vtkNew<vtkPolyDataMapper2D> mapper;
   mapper->SetInputData(poly);
   mapper->SetTransformCoordinate(coordinate);
 
-  auto actor = vtkSmartPointer<vtkActor2D>::New();
+  vtkNew<vtkActor2D> actor;
   actor->SetMapper(mapper);
   actor->GetProperty()->SetColor(color);
 
@@ -267,4 +259,5 @@ void ViewportBorder(vtkSmartPointer<vtkRenderer> &renderer,
 
   renderer->AddViewProp(actor);
 }
-}
+
+} // namespace
diff --git a/src/Cxx/IO/ReadAllPolyDataTypesDemo.md b/src/Cxx/IO/ReadAllPolyDataTypesDemo.md
index 11adffa3313c1c6c194e72b30dd3c9ad0e1eb0ba..621413fdf9da0b979a4335fbb935a9b2e2171589 100644
--- a/src/Cxx/IO/ReadAllPolyDataTypesDemo.md
+++ b/src/Cxx/IO/ReadAllPolyDataTypesDemo.md
@@ -3,4 +3,4 @@
 This example displays a model from each of the supported vtkPolyData readers.
 
 !!! info
-    The example reuses two procedures: *ReadPolyData* introduced in [ReadAllPolyDataTypes](/Cxx/IO/ReadAllPolyDataTypes) and *ViewportBorder* inriduced in [ViewportBorders](/Cxx/Utilities/ViewportBorders).
+    The example reuses two procedures: *ReadPolyData* introduced in [ReadAllPolyDataTypes](/Cxx/IO/ReadAllPolyDataTypes) and *ViewportBorder* introduced in [ViewportBorders](/Cxx/Utilities/ViewportBorders).
diff --git a/src/Cxx/IO/ReadAllUnstructuredGridTypes.cxx b/src/Cxx/IO/ReadAllUnstructuredGridTypes.cxx
index 5adf74d47db6438d94364c086d9af62709ab509b..03910f473db2837eb97dce4d16f4e85c572fbccc 100644
--- a/src/Cxx/IO/ReadAllUnstructuredGridTypes.cxx
+++ b/src/Cxx/IO/ReadAllUnstructuredGridTypes.cxx
@@ -1,43 +1,41 @@
-#include <vtkSmartPointer.h>
-
+#include <vtkAppendFilter.h>
+#include <vtkSphereSource.h>
+#include <vtkUnstructuredGrid.h>
 #include <vtkUnstructuredGridReader.h>
 #include <vtkXMLUnstructuredGridReader.h>
-#include <vtkUnstructuredGrid.h>
-#include <vtkSphereSource.h>
-#include <vtkAppendFilter.h>
 
 #include <vtkActor.h>
 #include <vtkCamera.h>
 #include <vtkDataSetMapper.h>
+#include <vtkNamedColors.h>
+#include <vtkNew.h>
 #include <vtkProperty.h>
 #include <vtkRenderWindow.h>
 #include <vtkRenderWindowInteractor.h>
 #include <vtkRenderer.h>
-#include <vtkCamera.h>
-
-#include <vtkNamedColors.h>
+#include <vtkSmartPointer.h>
 
-#include <string>
 #include <algorithm>
 #include <array>
+#include <string>
 
-namespace
-{
-vtkSmartPointer<vtkUnstructuredGrid> ReadUnstructuredGrid(std::string const& fileName);
+namespace {
+vtkSmartPointer<vtkUnstructuredGrid>
+ReadUnstructuredGrid(std::string const& fileName);
 }
 
-int main (int argc, char *argv[])
+int main(int argc, char* argv[])
 {
   // Vis Pipeline
-  auto colors = vtkSmartPointer<vtkNamedColors>::New();
+  vtkNew<vtkNamedColors> colors;
 
-  auto renderer = vtkSmartPointer<vtkRenderer>::New();
+  vtkNew<vtkRenderer> renderer;
 
-  auto renderWindow = vtkSmartPointer<vtkRenderWindow>::New();
+  vtkNew<vtkRenderWindow> renderWindow;
   renderWindow->SetSize(640, 480);
   renderWindow->AddRenderer(renderer);
 
-  auto interactor = vtkSmartPointer<vtkRenderWindowInteractor>::New();
+  vtkNew<vtkRenderWindowInteractor> interactor;
   interactor->SetRenderWindow(renderWindow);
 
   renderer->SetBackground(colors->GetColor3d("Wheat").GetData());
@@ -47,16 +45,16 @@ int main (int argc, char *argv[])
   auto unstructuredGrid = ReadUnstructuredGrid(std::string(argv[1]));
 
   // Visualize
-  auto mapper = vtkSmartPointer<vtkDataSetMapper>::New();
+  vtkNew<vtkDataSetMapper> mapper;
   mapper->SetInputData(unstructuredGrid);
   mapper->ScalarVisibilityOff();
 
-  auto backProp = vtkSmartPointer<vtkProperty>::New();
+  vtkNew<vtkProperty> backProp;
   backProp->SetDiffuseColor(colors->GetColor3d("Banana").GetData());
   backProp->SetSpecular(.6);
   backProp->SetSpecularPower(30);
 
-  auto actor = vtkSmartPointer<vtkActor>::New();
+  vtkNew<vtkActor> actor;
   actor->SetMapper(mapper);
   actor->SetBackfaceProperty(backProp);
   actor->GetProperty()->SetDiffuseColor(colors->GetColor3d("Tomato").GetData());
@@ -67,15 +65,16 @@ int main (int argc, char *argv[])
   renderer->GetActiveCamera()->Azimuth(45);
   renderer->GetActiveCamera()->Elevation(45);
   renderer->ResetCamera();
+  renderWindow->SetWindowName("ReadAllUnstructuredGridTypes");
   renderWindow->Render();
   interactor->Start();
 
   return EXIT_SUCCESS;
 }
 
-namespace
-{
-vtkSmartPointer<vtkUnstructuredGrid> ReadUnstructuredGrid(std::string const& fileName)
+namespace {
+vtkSmartPointer<vtkUnstructuredGrid>
+ReadUnstructuredGrid(std::string const& fileName)
 {
   vtkSmartPointer<vtkUnstructuredGrid> unstructuredGrid;
   std::string extension = "";
@@ -85,33 +84,34 @@ vtkSmartPointer<vtkUnstructuredGrid> ReadUnstructuredGrid(std::string const& fil
   }
 
   // Drop the case of the extension
-  std::transform(extension.begin(), extension.end(),
-                 extension.begin(), ::tolower);
+  std::transform(extension.begin(), extension.end(), extension.begin(),
+                 ::tolower);
 
   if (extension == ".vtu")
   {
-    auto reader = vtkSmartPointer<vtkXMLUnstructuredGridReader>::New();
-    reader->SetFileName (fileName.c_str());
+    vtkNew<vtkXMLUnstructuredGridReader> reader;
+    reader->SetFileName(fileName.c_str());
     reader->Update();
     unstructuredGrid = reader->GetOutput();
   }
   else if (extension == ".vtk")
   {
-    auto reader = vtkSmartPointer<vtkUnstructuredGridReader>::New();
-    reader->SetFileName (fileName.c_str());
+    vtkNew<vtkUnstructuredGridReader> reader;
+    reader->SetFileName(fileName.c_str());
     reader->Update();
     unstructuredGrid = reader->GetOutput();
   }
   else
   {
-    auto source = vtkSmartPointer<vtkSphereSource>::New();
+    vtkNew<vtkSphereSource> source;
     source->Update();
-    auto appendFilter =
-      vtkSmartPointer<vtkAppendFilter>::New();
+    vtkNew<vtkAppendFilter> appendFilter;
     appendFilter->AddInputData(source->GetOutput());
     appendFilter->Update();
     unstructuredGrid = appendFilter->GetOutput();
   }
+
   return unstructuredGrid;
 }
-}
+
+} // namespace
diff --git a/src/Cxx/IO/ReadBMP.cxx b/src/Cxx/IO/ReadBMP.cxx
index 6ab50cbad9adebca18c002984e54e8b32a2b8925..28a3488984e0aedd13c2de4e2eb31c3cdbf85a2a 100644
--- a/src/Cxx/IO/ReadBMP.cxx
+++ b/src/Cxx/IO/ReadBMP.cxx
@@ -1,33 +1,36 @@
-#include <vtkSmartPointer.h>
-#include <vtkImageViewer2.h>
 #include <vtkBMPReader.h>
+#include <vtkImageViewer2.h>
+#include <vtkNamedColors.h>
+#include <vtkNew.h>
 #include <vtkRenderWindow.h>
 #include <vtkRenderWindowInteractor.h>
 #include <vtkRenderer.h>
 
 int main(int argc, char* argv[])
 {
-  //Verify input arguments
-  if ( argc != 2 )
+  vtkNew<vtkNamedColors> colors;
+
+  // Verify input arguments
+  if (argc != 2)
   {
-    std::cout << "Usage: " << argv[0]
-              << " Filename(.bmp) e.g. masonry.bmp" << std::endl;
+    std::cout << "Usage: " << argv[0] << " Filename(.bmp) e.g. masonry.bmp"
+              << std::endl;
     return EXIT_FAILURE;
   }
 
-  //Read the image
-  vtkSmartPointer<vtkBMPReader> reader =
-    vtkSmartPointer<vtkBMPReader>::New();
-  reader->SetFileName ( argv[1] );
+  // Read the image
+  vtkNew<vtkBMPReader> reader;
+  reader->SetFileName(argv[1]);
 
   // Visualize
-  vtkSmartPointer<vtkImageViewer2> imageViewer =
-    vtkSmartPointer<vtkImageViewer2>::New();
+  vtkNew<vtkImageViewer2> imageViewer;
   imageViewer->SetInputConnection(reader->GetOutputPort());
-  vtkSmartPointer<vtkRenderWindowInteractor> renderWindowInteractor =
-    vtkSmartPointer<vtkRenderWindowInteractor>::New();
+  vtkNew<vtkRenderWindowInteractor> renderWindowInteractor;
   imageViewer->SetupInteractor(renderWindowInteractor);
   imageViewer->Render();
+  imageViewer->GetRenderer()->SetBackground(
+      colors->GetColor3d("DarkSlateGray").GetData());
+  imageViewer->GetRenderWindow()->SetWindowName("ReadBMP");
   imageViewer->GetRenderer()->ResetCamera();
   imageViewer->Render();
 
diff --git a/src/Cxx/IO/ReadCML.cxx b/src/Cxx/IO/ReadCML.cxx
index e31bfd3ad2f4fceb0f80391dd8f660c2c8742827..d4de8efcb7bd46e6fa2c96d1a713c6eb1f96bcc7 100644
--- a/src/Cxx/IO/ReadCML.cxx
+++ b/src/Cxx/IO/ReadCML.cxx
@@ -1,6 +1,5 @@
 #include <vtkNew.h>
 #include <vtkCMLMoleculeReader.h>
-
 #include <vtkActor.h>
 #include <vtkProperty.h>
 #include <vtkCamera.h>
@@ -9,7 +8,6 @@
 #include <vtkRenderWindowInteractor.h>
 #include <vtkRenderWindow.h>
 #include <vtkRenderer.h>
-
 #include <vtkNamedColors.h>
 
 int main(int argc, char *argv[])
@@ -28,19 +26,20 @@ int main(int argc, char *argv[])
 
   vtkNew<vtkActor> actor;
   actor->SetMapper(molmapper);
-  actor->GetProperty()->SetDiffuse(.7);
-  actor->GetProperty()->SetSpecular(.5);
+  actor->GetProperty()->SetDiffuse(0.7);
+  actor->GetProperty()->SetSpecular(0.5);
   actor->GetProperty()->SetSpecularPower(20.0);
 
   vtkNew<vtkRenderer> ren;
   vtkNew<vtkRenderWindow> renderWindow;
   renderWindow->AddRenderer(ren);
+  renderWindow->SetWindowName("ReadCML");
+
   vtkNew<vtkRenderWindowInteractor> iren;
   iren->SetRenderWindow(renderWindow);
 
   ren->AddActor(actor);
 
-  ren->SetBackground(0.0,0.0,0.0);
   renderWindow->SetSize(640, 480);
   renderWindow->Render();
   ren->GetActiveCamera()->Zoom(2.0);
diff --git a/src/Cxx/IO/ReadDICOM.cxx b/src/Cxx/IO/ReadDICOM.cxx
index daf6eba9082f4711fba7ffb21a8ef4d91f91c546..599324d0d62fc7afe3568b7e39aa6ca84e455059 100644
--- a/src/Cxx/IO/ReadDICOM.cxx
+++ b/src/Cxx/IO/ReadDICOM.cxx
@@ -1,36 +1,40 @@
-#include <vtkSmartPointer.h>
-#include <vtkImageViewer2.h>
 #include <vtkDICOMImageReader.h>
+#include <vtkImageViewer2.h>
+#include <vtkNamedColors.h>
+#include <vtkNew.h>
 #include <vtkRenderWindow.h>
 #include <vtkRenderWindowInteractor.h>
 #include <vtkRenderer.h>
+#include <vtkSmartPointer.h>
 
 int main(int argc, char* argv[])
 {
+  vtkNew<vtkNamedColors> colors;
+
   // Verify input arguments
-  if ( argc != 2 )
+  if (argc != 2)
   {
-    std::cout << "Usage: " << argv[0]
-              << " Filename(.img) e.g. prostate.img" << std::endl;
+    std::cout << "Usage: " << argv[0] << " Filename(.img) e.g. prostate.img"
+              << std::endl;
     return EXIT_FAILURE;
   }
 
   std::string inputFilename = argv[1];
 
   // Read all the DICOM files in the specified directory.
-  vtkSmartPointer<vtkDICOMImageReader> reader =
-    vtkSmartPointer<vtkDICOMImageReader>::New();
+  vtkNew<vtkDICOMImageReader> reader;
   reader->SetFileName(inputFilename.c_str());
   reader->Update();
 
   // Visualize
-  vtkSmartPointer<vtkImageViewer2> imageViewer =
-    vtkSmartPointer<vtkImageViewer2>::New();
+  vtkNew<vtkImageViewer2> imageViewer;
   imageViewer->SetInputConnection(reader->GetOutputPort());
-  vtkSmartPointer<vtkRenderWindowInteractor> renderWindowInteractor =
-    vtkSmartPointer<vtkRenderWindowInteractor>::New();
+  vtkNew<vtkRenderWindowInteractor> renderWindowInteractor;
   imageViewer->SetupInteractor(renderWindowInteractor);
   imageViewer->Render();
+  imageViewer->GetRenderer()->SetBackground(
+      colors->GetColor3d("SlateGray").GetData());
+  imageViewer->GetRenderWindow()->SetWindowName("ReadDICOM");
   imageViewer->GetRenderer()->ResetCamera();
   imageViewer->Render();
 
diff --git a/src/Cxx/IO/ReadDICOMSeries.cxx b/src/Cxx/IO/ReadDICOMSeries.cxx
index e7274a08bfa3447709326279e3e27c6f73df1c69..041734c09ffc6ec2332290cfc0fe3f0cc8e611b4 100644
--- a/src/Cxx/IO/ReadDICOMSeries.cxx
+++ b/src/Cxx/IO/ReadDICOMSeries.cxx
@@ -4,208 +4,226 @@
 // through all slices
 //
 // some standard vtk headers
-#include <vtkSmartPointer.h>
+#include <vtkActor.h>
+#include <vtkNamedColors.h>
+#include <vtkNew.h>
 #include <vtkObjectFactory.h>
 #include <vtkRenderWindow.h>
 #include <vtkRenderWindowInteractor.h>
 #include <vtkRenderer.h>
-#include <vtkActor.h>
 // headers needed for this example
-#include <vtkImageViewer2.h>
+#include <vtkActor2D.h>
 #include <vtkDICOMImageReader.h>
+#include <vtkImageViewer2.h>
 #include <vtkInteractorStyleImage.h>
-#include <vtkActor2D.h>
-#include <vtkTextProperty.h>
 #include <vtkTextMapper.h>
+#include <vtkTextProperty.h>
+
 // needed to easily convert int to std::string
 #include <sstream>
 
+namespace {
 
 // helper class to format slice status message
-class StatusMessage {
+class StatusMessage
+{
 public:
-   static std::string Format(int slice, int maxSlice) {
-      std::stringstream tmp;
-      tmp << "Slice Number  " << slice + 1 << "/" << maxSlice + 1;
-      return tmp.str();
-   }
+  static std::string Format(int slice, int maxSlice)
+  {
+    std::stringstream tmp;
+    tmp << "Slice Number  " << slice + 1 << "/" << maxSlice + 1;
+    return tmp.str();
+  }
 };
 
-
 // Define own interaction style
 class myVtkInteractorStyleImage : public vtkInteractorStyleImage
 {
 public:
-   static myVtkInteractorStyleImage* New();
-   vtkTypeMacro(myVtkInteractorStyleImage, vtkInteractorStyleImage);
+  static myVtkInteractorStyleImage* New();
+  vtkTypeMacro(myVtkInteractorStyleImage, vtkInteractorStyleImage);
 
 protected:
-   vtkImageViewer2* _ImageViewer;
-   vtkTextMapper* _StatusMapper;
-   int _Slice;
-   int _MinSlice;
-   int _MaxSlice;
+  vtkImageViewer2* _ImageViewer;
+  vtkTextMapper* _StatusMapper;
+  int _Slice;
+  int _MinSlice;
+  int _MaxSlice;
 
 public:
-   void SetImageViewer(vtkImageViewer2* imageViewer) {
-      _ImageViewer = imageViewer;
-      _MinSlice = imageViewer->GetSliceMin();
-      _MaxSlice = imageViewer->GetSliceMax();
-      _Slice = _MinSlice;
-      cout << "Slicer: Min = " << _MinSlice << ", Max = " << _MaxSlice << std::endl;
-   }
-
-   void SetStatusMapper(vtkTextMapper* statusMapper) {
-      _StatusMapper = statusMapper;
-   }
-
+  void SetImageViewer(vtkImageViewer2* imageViewer)
+  {
+    _ImageViewer = imageViewer;
+    _MinSlice = imageViewer->GetSliceMin();
+    _MaxSlice = imageViewer->GetSliceMax();
+    _Slice = _MinSlice;
+    cout << "Slicer: Min = " << _MinSlice << ", Max = " << _MaxSlice
+         << std::endl;
+  }
+
+  void SetStatusMapper(vtkTextMapper* statusMapper)
+  {
+    _StatusMapper = statusMapper;
+  }
 
 protected:
-   void MoveSliceForward() {
-      if(_Slice < _MaxSlice) {
-         _Slice += 1;
-         cout << "MoveSliceForward::Slice = " << _Slice << std::endl;
-         _ImageViewer->SetSlice(_Slice);
-         std::string msg = StatusMessage::Format(_Slice, _MaxSlice);
-         _StatusMapper->SetInput(msg.c_str());
-         _ImageViewer->Render();
-      }
-   }
-
-   void MoveSliceBackward() {
-      if(_Slice > _MinSlice) {
-         _Slice -= 1;
-         cout << "MoveSliceBackward::Slice = " << _Slice << std::endl;
-         _ImageViewer->SetSlice(_Slice);
-         std::string msg = StatusMessage::Format(_Slice, _MaxSlice);
-         _StatusMapper->SetInput(msg.c_str());
-         _ImageViewer->Render();
-      }
-   }
-
-
-   virtual void OnKeyDown() {
-      std::string key = this->GetInteractor()->GetKeySym();
-      if(key.compare("Up") == 0) {
-         //cout << "Up arrow key was pressed." << endl;
-         MoveSliceForward();
-      }
-      else if(key.compare("Down") == 0) {
-         //cout << "Down arrow key was pressed." << endl;
-         MoveSliceBackward();
-      }
-      // forward event
-      vtkInteractorStyleImage::OnKeyDown();
-   }
-
-
-   virtual void OnMouseWheelForward() {
-      //std::cout << "Scrolled mouse wheel forward." << std::endl;
+  void MoveSliceForward()
+  {
+    if (_Slice < _MaxSlice)
+    {
+      _Slice += 1;
+      cout << "MoveSliceForward::Slice = " << _Slice << std::endl;
+      _ImageViewer->SetSlice(_Slice);
+      std::string msg = StatusMessage::Format(_Slice, _MaxSlice);
+      _StatusMapper->SetInput(msg.c_str());
+      _ImageViewer->Render();
+    }
+  }
+
+  void MoveSliceBackward()
+  {
+    if (_Slice > _MinSlice)
+    {
+      _Slice -= 1;
+      cout << "MoveSliceBackward::Slice = " << _Slice << std::endl;
+      _ImageViewer->SetSlice(_Slice);
+      std::string msg = StatusMessage::Format(_Slice, _MaxSlice);
+      _StatusMapper->SetInput(msg.c_str());
+      _ImageViewer->Render();
+    }
+  }
+
+  virtual void OnKeyDown()
+  {
+    std::string key = this->GetInteractor()->GetKeySym();
+    if (key.compare("Up") == 0)
+    {
+      // cout << "Up arrow key was pressed." << endl;
       MoveSliceForward();
-      // don't forward events, otherwise the image will be zoomed 
-      // in case another interactorstyle is used (e.g. trackballstyle, ...)
-      // vtkInteractorStyleImage::OnMouseWheelForward();
-   }
-
-
-   virtual void OnMouseWheelBackward() {
-      //std::cout << "Scrolled mouse wheel backward." << std::endl;
-      if(_Slice > _MinSlice) {
-         MoveSliceBackward();
-      }
-      // don't forward events, otherwise the image will be zoomed 
-      // in case another interactorstyle is used (e.g. trackballstyle, ...)
-      // vtkInteractorStyleImage::OnMouseWheelBackward();
-   }
+    }
+    else if (key.compare("Down") == 0)
+    {
+      // cout << "Down arrow key was pressed." << endl;
+      MoveSliceBackward();
+    }
+    // forward event
+    vtkInteractorStyleImage::OnKeyDown();
+  }
+
+  virtual void OnMouseWheelForward()
+  {
+    // std::cout << "Scrolled mouse wheel forward." << std::endl;
+    MoveSliceForward();
+    // don't forward events, otherwise the image will be zoomed
+    // in case another interactorstyle is used (e.g. trackballstyle, ...)
+    // vtkInteractorStyleImage::OnMouseWheelForward();
+  }
+
+  virtual void OnMouseWheelBackward()
+  {
+    // std::cout << "Scrolled mouse wheel backward." << std::endl;
+    if (_Slice > _MinSlice)
+    {
+      MoveSliceBackward();
+    }
+    // don't forward events, otherwise the image will be zoomed
+    // in case another interactorstyle is used (e.g. trackballstyle, ...)
+    // vtkInteractorStyleImage::OnMouseWheelBackward();
+  }
 };
 
 vtkStandardNewMacro(myVtkInteractorStyleImage);
 
+} // namespace
 
 int main(int argc, char* argv[])
 {
-   // Verify input arguments
-   if ( argc != 2 )
-   {
-      std::cout << "Usage: " << argv[0]
-      << " FolderName" << std::endl;
-      return EXIT_FAILURE;
-   }
-
-   std::string folder = argv[1];
-   //std::string folder = "C:\\VTK\\vtkdata-5.8.0\\Data\\DicomTestImages";
-
-   // Read all the DICOM files in the specified directory.
-   vtkSmartPointer<vtkDICOMImageReader> reader =
-      vtkSmartPointer<vtkDICOMImageReader>::New();
-   reader->SetDirectoryName(folder.c_str());
-   reader->Update();
-
-   // Visualize
-   vtkSmartPointer<vtkImageViewer2> imageViewer =
-      vtkSmartPointer<vtkImageViewer2>::New();
-   imageViewer->SetInputConnection(reader->GetOutputPort());
-
-   // slice status message
-   vtkSmartPointer<vtkTextProperty> sliceTextProp = vtkSmartPointer<vtkTextProperty>::New();
-   sliceTextProp->SetFontFamilyToCourier();
-   sliceTextProp->SetFontSize(20);
-   sliceTextProp->SetVerticalJustificationToBottom();
-   sliceTextProp->SetJustificationToLeft();
-
-   vtkSmartPointer<vtkTextMapper> sliceTextMapper = vtkSmartPointer<vtkTextMapper>::New();
-   std::string msg = StatusMessage::Format(imageViewer->GetSliceMin(), imageViewer->GetSliceMax());
-   sliceTextMapper->SetInput(msg.c_str());
-   sliceTextMapper->SetTextProperty(sliceTextProp);
-
-   vtkSmartPointer<vtkActor2D> sliceTextActor = vtkSmartPointer<vtkActor2D>::New();
-   sliceTextActor->SetMapper(sliceTextMapper);
-   sliceTextActor->SetPosition(15, 10);
-
-   // usage hint message
-   vtkSmartPointer<vtkTextProperty> usageTextProp = vtkSmartPointer<vtkTextProperty>::New();
-   usageTextProp->SetFontFamilyToCourier();
-   usageTextProp->SetFontSize(14);
-   usageTextProp->SetVerticalJustificationToTop();
-   usageTextProp->SetJustificationToLeft();
-
-   vtkSmartPointer<vtkTextMapper> usageTextMapper = vtkSmartPointer<vtkTextMapper>::New();
-   usageTextMapper->SetInput("- Slice with mouse wheel\n  or Up/Down-Key\n- Zoom with pressed right\n  mouse button while dragging");
-   usageTextMapper->SetTextProperty(usageTextProp);
-
-   vtkSmartPointer<vtkActor2D> usageTextActor = vtkSmartPointer<vtkActor2D>::New();
-   usageTextActor->SetMapper(usageTextMapper);
-   usageTextActor->GetPositionCoordinate()->SetCoordinateSystemToNormalizedDisplay();
-   usageTextActor->GetPositionCoordinate()->SetValue( 0.05, 0.95);
-
-   // create an interactor with our own style (inherit from vtkInteractorStyleImage)
-   // in order to catch mousewheel and key events
-   vtkSmartPointer<vtkRenderWindowInteractor> renderWindowInteractor =
-      vtkSmartPointer<vtkRenderWindowInteractor>::New();
-
-   vtkSmartPointer<myVtkInteractorStyleImage> myInteractorStyle =
-      vtkSmartPointer<myVtkInteractorStyleImage>::New();
-
-   // make imageviewer2 and sliceTextMapper visible to our interactorstyle
-   // to enable slice status message updates when scrolling through the slices
-   myInteractorStyle->SetImageViewer(imageViewer);
-   myInteractorStyle->SetStatusMapper(sliceTextMapper);
-
-   imageViewer->SetupInteractor(renderWindowInteractor);
-   // make the interactor use our own interactorstyle
-   // cause SetupInteractor() is defining it's own default interatorstyle 
-   // this must be called after SetupInteractor()
-   renderWindowInteractor->SetInteractorStyle(myInteractorStyle);
-   // add slice status message and usage hint message to the renderer
-   imageViewer->GetRenderer()->AddActor2D(sliceTextActor);
-   imageViewer->GetRenderer()->AddActor2D(usageTextActor);
-
-   // initialize rendering and interaction
-   //imageViewer->GetRenderWindow()->SetSize(400, 300);
-   //imageViewer->GetRenderer()->SetBackground(0.2, 0.3, 0.4);
-   imageViewer->Render();
-   imageViewer->GetRenderer()->ResetCamera();
-   imageViewer->Render();
-   renderWindowInteractor->Start();
-   return EXIT_SUCCESS;
+  vtkNew<vtkNamedColors> colors;
+
+  // Verify input arguments
+  if (argc != 2)
+  {
+    std::cout << "Usage: " << argv[0] << " FolderName" << std::endl;
+    return EXIT_FAILURE;
+  }
+
+  std::string folder = argv[1];
+  // std::string folder = "C:\\VTK\\vtkdata-5.8.0\\Data\\DicomTestImages";
+
+  // Read all the DICOM files in the specified directory.
+  vtkNew<vtkDICOMImageReader> reader;
+  reader->SetDirectoryName(folder.c_str());
+  reader->Update();
+
+  // Visualize
+  vtkNew<vtkImageViewer2> imageViewer;
+  imageViewer->SetInputConnection(reader->GetOutputPort());
+
+  // slice status message
+  vtkNew<vtkTextProperty> sliceTextProp;
+  sliceTextProp->SetFontFamilyToCourier();
+  sliceTextProp->SetFontSize(20);
+  sliceTextProp->SetVerticalJustificationToBottom();
+  sliceTextProp->SetJustificationToLeft();
+
+  vtkNew<vtkTextMapper> sliceTextMapper;
+  std::string msg = StatusMessage::Format(imageViewer->GetSliceMin(),
+                                          imageViewer->GetSliceMax());
+  sliceTextMapper->SetInput(msg.c_str());
+  sliceTextMapper->SetTextProperty(sliceTextProp);
+
+  vtkNew<vtkActor2D> sliceTextActor;
+  sliceTextActor->SetMapper(sliceTextMapper);
+  sliceTextActor->SetPosition(15, 10);
+
+  // usage hint message
+  vtkNew<vtkTextProperty> usageTextProp;
+  usageTextProp->SetFontFamilyToCourier();
+  usageTextProp->SetFontSize(14);
+  usageTextProp->SetVerticalJustificationToTop();
+  usageTextProp->SetJustificationToLeft();
+
+  vtkNew<vtkTextMapper> usageTextMapper;
+  usageTextMapper->SetInput(
+      "- Slice with mouse wheel\n  or Up/Down-Key\n- Zoom with pressed right\n "
+      " mouse button while dragging");
+  usageTextMapper->SetTextProperty(usageTextProp);
+
+  vtkNew<vtkActor2D> usageTextActor;
+  usageTextActor->SetMapper(usageTextMapper);
+  usageTextActor->GetPositionCoordinate()
+      ->SetCoordinateSystemToNormalizedDisplay();
+  usageTextActor->GetPositionCoordinate()->SetValue(0.05, 0.95);
+
+  // create an interactor with our own style (inherit from
+  // vtkInteractorStyleImage) in order to catch mousewheel and key events
+  vtkNew<vtkRenderWindowInteractor> renderWindowInteractor;
+
+  vtkNew<myVtkInteractorStyleImage> myInteractorStyle;
+
+  // make imageviewer2 and sliceTextMapper visible to our interactorstyle
+  // to enable slice status message updates when scrolling through the slices
+  myInteractorStyle->SetImageViewer(imageViewer);
+  myInteractorStyle->SetStatusMapper(sliceTextMapper);
+
+  imageViewer->SetupInteractor(renderWindowInteractor);
+  // make the interactor use our own interactorstyle
+  // cause SetupInteractor() is defining it's own default interatorstyle
+  // this must be called after SetupInteractor()
+  renderWindowInteractor->SetInteractorStyle(myInteractorStyle);
+  // add slice status message and usage hint message to the renderer
+  imageViewer->GetRenderer()->AddActor2D(sliceTextActor);
+  imageViewer->GetRenderer()->AddActor2D(usageTextActor);
+
+  // initialize rendering and interaction
+  imageViewer->Render();
+  imageViewer->GetRenderer()->ResetCamera();
+  imageViewer->GetRenderer()->SetBackground(
+      colors->GetColor3d("SlateGray").GetData());
+  imageViewer->GetRenderWindow()->SetSize(800, 800);
+  imageViewer->GetRenderWindow()->SetWindowName("ReadDICOMSeries");
+  imageViewer->Render();
+  renderWindowInteractor->Start();
+
+  return EXIT_SUCCESS;
 }
diff --git a/src/Cxx/IO/ReadExodusData.cxx b/src/Cxx/IO/ReadExodusData.cxx
index 570343db4cea77cac35872dc4d2fdbc836fc5982..3166227c624e3a5357621c58cbce149c461a4643 100644
--- a/src/Cxx/IO/ReadExodusData.cxx
+++ b/src/Cxx/IO/ReadExodusData.cxx
@@ -1,22 +1,22 @@
-#include <vtkNew.h>
-#include <vtkNamedColors.h>
-#include <vtkExodusIIReader.h>
-#include <vtkCompositeDataGeometryFilter.h>
-#include <vtkPolyDataMapper.h>
 #include <vtkActor.h>
 #include <vtkCamera.h>
-#include <vtkRenderer.h>
+#include <vtkCompositeDataGeometryFilter.h>
+#include <vtkExodusIIReader.h>
+#include <vtkNamedColors.h>
+#include <vtkNew.h>
+#include <vtkPolyDataMapper.h>
 #include <vtkRenderWindow.h>
 #include <vtkRenderWindowInteractor.h>
-#include <vtkCompositeDataGeometryFilter.h>
+#include <vtkRenderer.h>
 
-int main (int argc, char *argv[])
+int main(int argc, char* argv[])
 {
-  vtkNew<vtkNamedColors>  colors;
+  vtkNew<vtkNamedColors> colors;
 
   if (argc < 3)
   {
-    std::cout << "Ysage: " << argv[0] << " exodus_file.e nodal_variable";
+    std::cout << "Usage: " << argv[0]
+              << " exodus_file.e nodal_variable e.g mug.e convected";
     return EXIT_FAILURE;
   }
 
@@ -25,7 +25,8 @@ int main (int argc, char *argv[])
   reader->SetFileName(argv[1]);
   reader->UpdateInformation();
   reader->SetTimeStep(10);
-  reader->SetAllArrayStatus(vtkExodusIIReader::NODAL, 1);  // enables all NODAL variables
+  reader->SetAllArrayStatus(vtkExodusIIReader::NODAL,
+                            1); // enables all NODAL variables
 
   // Create Geometry
   vtkNew<vtkCompositeDataGeometryFilter> geometry;
@@ -53,9 +54,10 @@ int main (int argc, char *argv[])
   renderer->GetActiveCamera()->SetDistance(14.5);
 
   // Window and Interactor
-  vtkNew<vtkRenderWindow>  window;
+  vtkNew<vtkRenderWindow> window;
   window->AddRenderer(renderer);
   window->SetSize(600, 600);
+  window->SetWindowName("ReadExodusData");
 
   vtkNew<vtkRenderWindowInteractor> interactor;
   interactor->SetRenderWindow(window);
diff --git a/src/Cxx/IO/ReadImageData.cxx b/src/Cxx/IO/ReadImageData.cxx
index a90ff2db9cd92fa47e11042a9c8fea336c428cdd..2c253cc591defd029a1a976d41e19be58fd51cab 100644
--- a/src/Cxx/IO/ReadImageData.cxx
+++ b/src/Cxx/IO/ReadImageData.cxx
@@ -1,52 +1,51 @@
-#include <vtkSmartPointer.h>
-#include <vtkNamedColors.h>
-#include <vtkProperty.h>
 #include <vtkDataSetMapper.h>
 #include <vtkImageActor.h>
 #include <vtkImageViewer2.h>
-#include <vtkXMLImageDataReader.h>
+#include <vtkNamedColors.h>
+#include <vtkNew.h>
+#include <vtkProperty.h>
 #include <vtkRenderWindow.h>
 #include <vtkRenderWindowInteractor.h>
-#include <vtkNamedColors.h>
 #include <vtkRenderer.h>
+#include <vtkXMLImageDataReader.h>
 
 int main(int argc, char* argv[])
 {
   // Verify input arguments
-  if(argc != 2)
+  if (argc != 2)
   {
-    std::cout << "Usage: " << argv[0]
-              << " Filename.vti" << std::endl;
+    std::cout << "Usage: " << argv[0] << " Filename.vti e.g. vase.vti"
+              << std::endl;
     return EXIT_FAILURE;
   }
 
   std::string inputFilename = argv[1];
 
-  auto colors = vtkSmartPointer<vtkNamedColors>::New();
+  vtkNew<vtkNamedColors> colors;
 
   // Read the file
-  auto reader = vtkSmartPointer<vtkXMLImageDataReader>::New();
+  vtkNew<vtkXMLImageDataReader> reader;
   reader->SetFileName(inputFilename.c_str());
   reader->Update();
 
   // Visualize
-   auto mapper = vtkSmartPointer<vtkDataSetMapper>::New();
+  vtkNew<vtkDataSetMapper> mapper;
   mapper->SetInputConnection(reader->GetOutputPort());
 
-  auto actor = vtkSmartPointer<vtkActor>::New();
+  vtkNew<vtkActor> actor;
   actor->SetMapper(mapper);
   actor->GetProperty()->SetRepresentationToWireframe();
-  actor->GetProperty()->SetColor(colors->GetColor3d("DarkSalmon").GetData());
 
-  auto renderer = vtkSmartPointer<vtkRenderer>::New();
+  vtkNew<vtkRenderer> renderer;
   renderer->AddActor(actor);
   renderer->ResetCamera();
   renderer->SetBackground(colors->GetColor3d("Silver").GetData());
 
-  auto renderWindow = vtkSmartPointer<vtkRenderWindow>::New();
+  vtkNew<vtkRenderWindow> renderWindow;
   renderWindow->AddRenderer(renderer);
+  renderWindow->SetWindowName("ReadImageData");
 
-  auto renderWindowInteractor = vtkSmartPointer<vtkRenderWindowInteractor>::New();
+  vtkNew<vtkRenderWindowInteractor> renderWindowInteractor;
   renderWindowInteractor->SetRenderWindow(renderWindow);
   renderWindow->Render();
   renderWindowInteractor->Initialize();
diff --git a/src/Cxx/IO/ReadImageData.md b/src/Cxx/IO/ReadImageData.md
index 7fab1e9164453b8d984b85fd3a54077be6326fc5..7a5803a784e7c8a6e4d8cdaa3b37b77998c0cc0c 100644
--- a/src/Cxx/IO/ReadImageData.md
+++ b/src/Cxx/IO/ReadImageData.md
@@ -1,2 +1,3 @@
 ### Description
+
 This example reads an image data (.vti) file.
diff --git a/src/Cxx/IO/ReadLegacyUnstructuredGrid.cxx b/src/Cxx/IO/ReadLegacyUnstructuredGrid.cxx
index dfe40456570f70482475514e89261ce5202fd89a..9763ce946316ea105c71b0d34cbf99b7b17d1445 100644
--- a/src/Cxx/IO/ReadLegacyUnstructuredGrid.cxx
+++ b/src/Cxx/IO/ReadLegacyUnstructuredGrid.cxx
@@ -1,28 +1,23 @@
-#include <vtkUnstructuredGridReader.h>
-#include <vtkUnstructuredGrid.h>
-
-#include <vtkGenericCell.h>
-
-#include <vtkExtractEdges.h>
-#include <vtkTubeFilter.h>
-#include <vtkPolyDataMapper.h>
-
-#include <vtkGlyph3DMapper.h>
-#include <vtkSphereSource.h>
-#include <vtkPolyData.h>
-
-#include <vtkTextMapper.h>
-#include <vtkShrinkFilter.h>
-
-#include <vtkCategoryLegend.h>
 #include <vtkBrush.h>
+#include <vtkCategoryLegend.h>
 #include <vtkCellData.h>
 #include <vtkColor.h>
 #include <vtkContextScene.h>
 #include <vtkContextTransform.h>
 #include <vtkContextView.h>
+#include <vtkExtractEdges.h>
+#include <vtkGenericCell.h>
+#include <vtkGlyph3DMapper.h>
 #include <vtkLookupTable.h>
+#include <vtkPolyData.h>
+#include <vtkPolyDataMapper.h>
 #include <vtkScalarsToColors.h>
+#include <vtkShrinkFilter.h>
+#include <vtkSphereSource.h>
+#include <vtkTextMapper.h>
+#include <vtkTubeFilter.h>
+#include <vtkUnstructuredGrid.h>
+#include <vtkUnstructuredGridReader.h>
 #include <vtkVariant.h>
 #include <vtkVariantArray.h>
 
@@ -31,47 +26,44 @@
 #include <vtkCamera.h>
 #include <vtkDataSetMapper.h>
 #include <vtkNamedColors.h>
+#include <vtkNew.h>
 #include <vtkProperty.h>
 #include <vtkRenderWindow.h>
 #include <vtkRenderWindowInteractor.h>
 #include <vtkRenderer.h>
+#include <vtkSmartPointer.h>
 
 #include <vtkCellIterator.h>
 #include <vtkCellTypes.h>
 #include <vtkLabeledDataMapper.h>
 
-int main (int argc, char *argv[])
+int main(int argc, char* argv[])
 {
   if (argc < 2)
   {
     std::cout << "Usage: " << argv[0] << " filename.vtk" << std::endl;
     return EXIT_FAILURE;
   }
-  vtkSmartPointer<vtkNamedColors> colors =
-    vtkSmartPointer<vtkNamedColors>::New();
+  vtkNew<vtkNamedColors> colors;
 
   // Create the reader for the data.
   std::string filename = argv[1];
   std::cout << "Loading " << filename.c_str() << std::endl;
-  vtkSmartPointer<vtkUnstructuredGridReader> reader =
-    vtkSmartPointer<vtkUnstructuredGridReader>::New();
+  vtkNew<vtkUnstructuredGridReader> reader;
   reader->SetFileName(filename.c_str());
   reader->Update();
 
-  vtkSmartPointer<vtkExtractEdges> extractEdges =
-    vtkSmartPointer<vtkExtractEdges>::New();
+  vtkNew<vtkExtractEdges> extractEdges;
   extractEdges->SetInputConnection(reader->GetOutputPort());
 
-  vtkSmartPointer<vtkVariantArray> legendValues =
-    vtkSmartPointer<vtkVariantArray>::New();
-  auto it =
-    reader->GetOutput()->NewCellIterator();
+  vtkNew<vtkVariantArray> legendValues;
+  auto it = reader->GetOutput()->NewCellIterator();
   for (it->InitTraversal(); !it->IsDoneWithTraversal(); it->GoToNextCell())
   {
-    vtkSmartPointer<vtkGenericCell> cell =
-      vtkSmartPointer<vtkGenericCell>::New();
+    vtkNew<vtkGenericCell> cell;
     it->GetCell(cell);
-    std::string cellName = vtkCellTypes::GetClassNameFromTypeId(cell->GetCellType());
+    std::string cellName =
+        vtkCellTypes::GetClassNameFromTypeId(cell->GetCellType());
 #if 0
     std::cout << cellName
               << " NumberOfPoints: " << cell->GetNumberOfPoints()
@@ -83,115 +75,99 @@ int main (int argc, char *argv[])
   it->Delete();
 
   // Tube the edges
-  vtkSmartPointer<vtkTubeFilter> tubes =
-    vtkSmartPointer<vtkTubeFilter>::New();
+  vtkNew<vtkTubeFilter> tubes;
   tubes->SetInputConnection(extractEdges->GetOutputPort());
   tubes->SetRadius(.05);
   tubes->SetNumberOfSides(21);
 
-  vtkSmartPointer<vtkPolyDataMapper> edgeMapper =
-    vtkSmartPointer<vtkPolyDataMapper>::New();
+  vtkNew<vtkPolyDataMapper> edgeMapper;
   edgeMapper->SetInputConnection(tubes->GetOutputPort());
   edgeMapper->SetScalarRange(0, 26);
 
-  vtkSmartPointer<vtkActor> edgeActor =
-    vtkSmartPointer<vtkActor>::New();
+  vtkNew<vtkActor> edgeActor;
   edgeActor->SetMapper(edgeMapper);
-  edgeActor->GetProperty()->SetSpecular(.6);
+  edgeActor->GetProperty()->SetSpecular(0.6);
   edgeActor->GetProperty()->SetSpecularPower(30);
-;
+  ;
 
   // Glyph the points
-  vtkSmartPointer<vtkSphereSource> sphere =
-    vtkSmartPointer<vtkSphereSource>::New();
+  vtkNew<vtkSphereSource> sphere;
   sphere->SetPhiResolution(21);
   sphere->SetThetaResolution(21);
-  sphere->SetRadius(.08);
+  sphere->SetRadius(0.08);
 
-  vtkSmartPointer<vtkGlyph3DMapper> pointMapper =
-    vtkSmartPointer<vtkGlyph3DMapper>::New();
+  vtkNew<vtkGlyph3DMapper> pointMapper;
   pointMapper->SetInputConnection(reader->GetOutputPort());
   pointMapper->SetSourceConnection(sphere->GetOutputPort());
   pointMapper->ScalingOff();
   pointMapper->ScalarVisibilityOff();
 
-  vtkSmartPointer<vtkActor> pointActor =
-    vtkSmartPointer<vtkActor>::New();
+  vtkNew<vtkActor> pointActor;
   pointActor->SetMapper(pointMapper);
-  pointActor->GetProperty()->SetDiffuseColor(colors->GetColor3d("Banana").GetData());
-  pointActor->GetProperty()->SetSpecular(.6);
-  pointActor->GetProperty()->SetSpecularColor(1.0,1.0,1.0);
+  pointActor->GetProperty()->SetDiffuseColor(
+      colors->GetColor3d("Banana").GetData());
+  pointActor->GetProperty()->SetSpecular(0.6);
+  pointActor->GetProperty()->SetSpecularColor(1.0, 1.0, 1.0);
   pointActor->GetProperty()->SetSpecularPower(100);
-;
+  ;
 
-// Label the points
-  vtkSmartPointer<vtkLabeledDataMapper> labelMapper = 
-    vtkSmartPointer<vtkLabeledDataMapper>::New();
+  // Label the points
+  vtkNew<vtkLabeledDataMapper> labelMapper;
   labelMapper->SetInputConnection(reader->GetOutputPort());
-  vtkSmartPointer<vtkActor2D> labelActor = 
-    vtkSmartPointer<vtkActor2D>::New();
+  vtkNew<vtkActor2D> labelActor;
   labelActor->SetMapper(labelMapper);
 
-// The geometry
-  vtkSmartPointer<vtkShrinkFilter> geometryShrink = 
-    vtkSmartPointer<vtkShrinkFilter>::New();
+  // The geometry
+  vtkNew<vtkShrinkFilter> geometryShrink;
   geometryShrink->SetInputConnection(reader->GetOutputPort());
   geometryShrink->SetShrinkFactor(.8);
 
-// NOTE: We must copy the originalLut because the CategorialLegend
-// needs an indexed lookup table, but the geometryMapper uses a
-// non-index lookup table
-  vtkSmartPointer<vtkLookupTable> categoricalLut =
-    vtkSmartPointer<vtkLookupTable>::New();
+  // NOTE: We must copy the originalLut because the CategorialLegend
+  // needs an indexed lookup table, but the geometryMapper uses a
+  // non-index lookup table
+  vtkNew<vtkLookupTable> categoricalLut;
   vtkSmartPointer<vtkLookupTable> originalLut =
-    reader->GetOutput()->GetCellData()->GetScalars()->GetLookupTable();
+      reader->GetOutput()->GetCellData()->GetScalars()->GetLookupTable();
 
   categoricalLut->DeepCopy(originalLut);
   categoricalLut->IndexedLookupOn();
 
-  vtkSmartPointer<vtkDataSetMapper> geometryMapper = 
-    vtkSmartPointer<vtkDataSetMapper>::New();
+  vtkNew<vtkDataSetMapper> geometryMapper;
   geometryMapper->SetInputConnection(geometryShrink->GetOutputPort());
   geometryMapper->SetScalarModeToUseCellData();
-  geometryMapper->SetScalarRange(0,11);
+  geometryMapper->SetScalarRange(0, 11);
 
-  vtkSmartPointer<vtkActor> geometryActor = 
-    vtkSmartPointer<vtkActor>::New();
+  vtkNew<vtkActor> geometryActor;
   geometryActor->SetMapper(geometryMapper);
-  geometryActor->GetProperty()->SetLineWidth(3);  
+  geometryActor->GetProperty()->SetLineWidth(3);
   geometryActor->GetProperty()->EdgeVisibilityOn();
-  geometryActor->GetProperty()->SetEdgeColor(0,0,0);
+  geometryActor->GetProperty()->SetEdgeColor(0, 0, 0);
 
   // Legend
   for (int v = 0; v < legendValues->GetNumberOfTuples(); ++v)
   {
     categoricalLut->SetAnnotation(legendValues->GetValue(v),
-                       legendValues->GetValue(v).ToString());
+                                  legendValues->GetValue(v).ToString());
   }
-  vtkSmartPointer<vtkCategoryLegend> legend =
-    vtkSmartPointer<vtkCategoryLegend>::New();
+  vtkNew<vtkCategoryLegend> legend;
   legend->SetScalarsToColors(categoricalLut);
   legend->SetValues(legendValues);
   legend->SetTitle("Cell Type");
   legend->GetBrush()->SetColor(colors->GetColor4ub("Silver").GetData());
 
-  vtkSmartPointer<vtkContextTransform> placeLegend =
-    vtkSmartPointer<vtkContextTransform>::New();
+  vtkNew<vtkContextTransform> placeLegend;
   placeLegend->AddItem(legend);
   placeLegend->Translate(640 - 20, 480 - 12 * 16);
 
-  vtkSmartPointer<vtkContextView> contextView =
-    vtkSmartPointer<vtkContextView>::New();
+  vtkNew<vtkContextView> contextView;
   contextView->GetScene()->AddItem(placeLegend);
 
-  vtkSmartPointer<vtkRenderer> renderer =
-    contextView->GetRenderer();
+  vtkSmartPointer<vtkRenderer> renderer = contextView->GetRenderer();
 
   vtkSmartPointer<vtkRenderWindow> renderWindow =
-    contextView->GetRenderWindow();
+      contextView->GetRenderWindow();
 
-  vtkSmartPointer<vtkRenderWindowInteractor> renderWindowInteractor =
-    vtkSmartPointer<vtkRenderWindowInteractor>::New();
+  vtkNew<vtkRenderWindowInteractor> renderWindowInteractor;
   renderWindowInteractor->SetRenderWindow(renderWindow);
 
   renderer->AddActor(geometryActor);
@@ -200,18 +176,18 @@ int main (int argc, char *argv[])
   renderer->AddActor(pointActor);
   renderer->SetBackground(colors->GetColor3d("SlateGray").GetData());
 
-  vtkSmartPointer<vtkCamera> aCamera =
-    vtkSmartPointer<vtkCamera>::New();
+  vtkNew<vtkCamera> aCamera;
   aCamera->Azimuth(-40.0);
   aCamera->Elevation(50.0);
 
   renderer->SetActiveCamera(aCamera);
-  renderer->ResetCamera ();
+  renderer->ResetCamera();
 
   renderWindow->SetSize(640, 480);
+  renderWindow->SetWindowName("ReadLegacyUnstructuredGrid");
   renderWindow->Render();
 
   renderWindowInteractor->Start();
-  
+
   return EXIT_SUCCESS;
 }
diff --git a/src/Cxx/IO/ReadLegacyUnstructuredGrid.md b/src/Cxx/IO/ReadLegacyUnstructuredGrid.md
index d4549991c830c7a40d62644d210ad90a75034f9b..b1c025dfa08ad790382e67cbe624032215e18480 100644
--- a/src/Cxx/IO/ReadLegacyUnstructuredGrid.md
+++ b/src/Cxx/IO/ReadLegacyUnstructuredGrid.md
@@ -1,4 +1,5 @@
 ### Description
+
 This example displays a vtkUnstructuredGrid that contains eleven linear cells. We use a number of techniques to visualize the cells.
 
 1. vtkUnstructuredGridReader reads the file [VTKCellTypes.vtk](https://raw.githubusercontent.com/lorensen/VTKExamples/master/src/Testing/Data/VTKCellTypes.vtk).
diff --git a/src/Python/IO/3DSImporter.md b/src/Python/IO/3DSImporter.md
new file mode 100644
index 0000000000000000000000000000000000000000..883ea728f5c4a2e33ed3ff239c327ead4ade672b
--- /dev/null
+++ b/src/Python/IO/3DSImporter.md
@@ -0,0 +1,6 @@
+### Description
+
+This example illustrates Importing files in VTK. An importer creates a vtkRenderWindow that describes the scene.
+
+!!! info
+    See [Figure 4-13](/VTKBook/04Chapter4/#Figure%204-13) in [Chapter 4](/VTKBook/04Chapter4) the [VTK Textbook](/VTKBook/01Chapter1).
diff --git a/src/Python/IO/3DSImporter.py b/src/Python/IO/3DSImporter.py
index 53732dd2bc21590218324f30c489a6451de8e0fb..102c49a52a0d15fd620708ba542827bf8f414b16 100755
--- a/src/Python/IO/3DSImporter.py
+++ b/src/Python/IO/3DSImporter.py
@@ -17,8 +17,8 @@ def main():
     iren = vtk.vtkRenderWindowInteractor()
 
     renWin.AddRenderer(renderer)
-    renderer.SetBackground2(colors.GetColor3d("Gold"))
-    renderer.SetBackground(colors.GetColor3d("Wheat"))
+    renderer.SetBackground2(colors.GetColor3d('Gold'))
+    renderer.SetBackground(colors.GetColor3d('Wheat'))
     renderer.GradientBackgroundOn()
 
     iren.SetRenderWindow(renWin)
@@ -27,8 +27,9 @@ def main():
 
     # actors = vtk.vtkActorCollection()
     actors = renderer.GetActors()
-    print("There are", actors.GetNumberOfItems(), "actors")
+    print('There are', actors.GetNumberOfItems(), 'actors.')
 
+    renWin.SetWindowName('3DSImporter')
     renWin.Render()
     camera = vtk.vtkCamera()
     camera.SetPosition(0, -1, 0)
diff --git a/src/Python/IO/ImageWriter.md b/src/Python/IO/ImageWriter.md
index 6558deeef85f5ebf675a2cfaa5ed6e8f57e98db2..b7f1eb6b84b9e42a3a30297fbb9300fcfef5cce7 100644
--- a/src/Python/IO/ImageWriter.md
+++ b/src/Python/IO/ImageWriter.md
@@ -4,4 +4,4 @@ A generic function `WriteImage()` is provided that selects what image writer to
 
 If no file extension is specified, **PNG** is assumed.
 
-The function `WriteImage()` is also available in the Snippets.
\ No newline at end of file
+The function `WriteImage()` is also available in the Snippets.
diff --git a/src/Python/IO/ImageWriter.py b/src/Python/IO/ImageWriter.py
index 882d68f2563bc6e96264c4c2e5480ac096424033..23ff1817293328486d90bfea47940f9476ed0df1 100755
--- a/src/Python/IO/ImageWriter.py
+++ b/src/Python/IO/ImageWriter.py
@@ -7,7 +7,7 @@ def main():
     colors = vtk.vtkNamedColors()
 
     # Set the background color.
-    colors.SetColor("BkgColor", [26, 51, 102, 255])
+    colors.SetColor('BkgColor', [26, 51, 102, 255])
 
     # create a rendering window and renderer
     ren = vtk.vtkRenderer()
@@ -32,13 +32,15 @@ def main():
     actor.SetMapper(mapper)
 
     # color the actor
-    actor.GetProperty().SetColor(colors.GetColor3d("Yellow"))
+    actor.GetProperty().SetColor(colors.GetColor3d('Yellow'))
 
     # assign actor to the renderer
     ren.AddActor(actor)
-    ren.SetBackground(colors.GetColor3d("BkgColor"))
+    ren.SetBackground(colors.GetColor3d('BkgColor'))
 
+    renWin.SetWindowName('ImageWriter')
     renWin.Render()
+
     ext = ['', '.png', '.jpg', '.ps', '.tiff', '.bmp', '.pnm']
     filenames = list(map(lambda x: 'ImageWriter' + x, ext))
     filenames[0] = filenames[0] + '1'
@@ -50,7 +52,7 @@ def main():
 
 
 def WriteImage(fileName, renWin, rgba=True):
-    """
+    '''
     Write the render window view to an image file.
 
     Image types supported are:
@@ -61,7 +63,7 @@ def WriteImage(fileName, renWin, rgba=True):
     :param renWin: The render window.
     :param rgba: Used to set the buffer type.
     :return:
-    """
+    '''
 
     import os
 
diff --git a/src/Python/IO/ReadExodusData.md b/src/Python/IO/ReadExodusData.md
index 42d39ac5a42b4089222e5f19886e0a019b8a2ebc..577224c2df9f72f872184d9ea6be43e2ceee7896 100644
--- a/src/Python/IO/ReadExodusData.md
+++ b/src/Python/IO/ReadExodusData.md
@@ -1,3 +1,3 @@
 ### Description
 
-A simple Python script for reading and displaying ExodusII data with VTK.
+The exmaple uses vtkExodusIIReader to read an ExodusII file. The nodal variable to read is the second argument. The nodal variable is displayed with a color map.
diff --git a/src/Python/IO/ReadExodusData.py b/src/Python/IO/ReadExodusData.py
index 8837b420cacb57bce6fc71f7d3a119d3b5edbe30..072545ad4dc1d2adfaf22bafecb6694e014c3088 100755
--- a/src/Python/IO/ReadExodusData.py
+++ b/src/Python/IO/ReadExodusData.py
@@ -49,7 +49,7 @@ def main():
     # Renderer
     renderer = vtk.vtkRenderer()
     renderer.AddViewProp(actor)
-    renderer.SetBackground(colors.GetColor3d("DimGray"))
+    renderer.SetBackground(colors.GetColor3d('DimGray'))
 
     renderer.GetActiveCamera().SetPosition(9.0, 9.0, 7.0)
     renderer.GetActiveCamera().SetFocalPoint(0, 0, 0)
@@ -60,6 +60,7 @@ def main():
     window = vtk.vtkRenderWindow()
     window.AddRenderer(renderer)
     window.SetSize(600, 600)
+    window.SetWindowName('ReadExodusData')
 
     interactor = vtk.vtkRenderWindowInteractor()
     interactor.SetRenderWindow(window)
diff --git a/src/Python/IO/ReadImageData.md b/src/Python/IO/ReadImageData.md
index 55d04a2cedb637c60da67a63c676ead429ed7d93..7a5803a784e7c8a6e4d8cdaa3b37b77998c0cc0c 100644
--- a/src/Python/IO/ReadImageData.md
+++ b/src/Python/IO/ReadImageData.md
@@ -1,2 +1,3 @@
 ### Description
-This example reads an image data (.vti) file. Example data would be [vase.vti](https://raw.githubusercontent.com/lorensen/VTKExamples/master/src/Testing/Data/vase.vti).
+
+This example reads an image data (.vti) file.
diff --git a/src/Python/IO/ReadImageData.py b/src/Python/IO/ReadImageData.py
index 0639c4b191d1652b1ea637043d5ad4fe01704655..61fa3110abc787495315ec3dd72fc7d057450e2b 100644
--- a/src/Python/IO/ReadImageData.py
+++ b/src/Python/IO/ReadImageData.py
@@ -33,17 +33,18 @@ def main():
     actor.SetMapper(mapper)
     # show the edges of the image grid
     actor.GetProperty().SetRepresentationToWireframe()
-    actor.GetProperty().SetColor(colors.GetColor3d("DarkSalmon"))
 
     # Create the Renderer
     renderer = vtk.vtkRenderer()
     renderer.AddActor(actor)
     renderer.ResetCamera()
-    renderer.SetBackground(colors.GetColor3d("Silver"))
+    renderer.SetBackground(colors.GetColor3d('Silver'))
 
     # Create the RendererWindow
     renderer_window = vtk.vtkRenderWindow()
     renderer_window.AddRenderer(renderer)
+    renderer_window.SetWindowName('ReadImageData')
+
 
     # Create the RendererWindowInteractor and display the vti file
     interactor = vtk.vtkRenderWindowInteractor()
diff --git a/src/Python/IO/ReadLegacyUnstructuredGrid.md b/src/Python/IO/ReadLegacyUnstructuredGrid.md
index d4549991c830c7a40d62644d210ad90a75034f9b..b1c025dfa08ad790382e67cbe624032215e18480 100644
--- a/src/Python/IO/ReadLegacyUnstructuredGrid.md
+++ b/src/Python/IO/ReadLegacyUnstructuredGrid.md
@@ -1,4 +1,5 @@
 ### Description
+
 This example displays a vtkUnstructuredGrid that contains eleven linear cells. We use a number of techniques to visualize the cells.
 
 1. vtkUnstructuredGridReader reads the file [VTKCellTypes.vtk](https://raw.githubusercontent.com/lorensen/VTKExamples/master/src/Testing/Data/VTKCellTypes.vtk).
diff --git a/src/Python/IO/ReadLegacyUnstructuredGrid.py b/src/Python/IO/ReadLegacyUnstructuredGrid.py
index 70e46690dd7cf427c0b523a6b1dc3143b928a452..f6d6120eecda9ce9817718670532070bf9d7f022 100755
--- a/src/Python/IO/ReadLegacyUnstructuredGrid.py
+++ b/src/Python/IO/ReadLegacyUnstructuredGrid.py
@@ -10,7 +10,7 @@ def main():
     filename = get_program_parameters()
 
     # Create the reader for the data.
-    print("Loading ", filename)
+    print('Loading ', filename)
     reader = vtk.vtkUnstructuredGridReader()
     reader.SetFileName(filename)
     reader.Update()
@@ -25,7 +25,7 @@ def main():
         cell = vtk.vtkGenericCell()
         it.GetCell(cell)
         cellName = vtk.vtkCellTypes.GetClassNameFromTypeId(cell.GetCellType())
-        print(cellName, "NumberOfPoints:", cell.GetNumberOfPoints(), "CellDimension:", cell.GetCellDimension())
+        print(cellName, 'NumberOfPoints:', cell.GetNumberOfPoints(), 'CellDimension:', cell.GetCellDimension())
         legendValues.InsertNextValue(cellName)
         it.GoToNextCell()
 
@@ -41,14 +41,14 @@ def main():
 
     edgeActor = vtk.vtkActor()
     edgeActor.SetMapper(edgeMapper)
-    edgeActor.GetProperty().SetSpecular(.6)
+    edgeActor.GetProperty().SetSpecular(0.6)
     edgeActor.GetProperty().SetSpecularPower(30)
 
     # Glyph the points
     sphere = vtk.vtkSphereSource()
     sphere.SetPhiResolution(21)
     sphere.SetThetaResolution(21)
-    sphere.SetRadius(.08)
+    sphere.SetRadius(0.08)
 
     pointMapper = vtk.vtkGlyph3DMapper()
     pointMapper.SetInputConnection(reader.GetOutputPort())
@@ -58,8 +58,8 @@ def main():
 
     pointActor = vtk.vtkActor()
     pointActor.SetMapper(pointMapper)
-    pointActor.GetProperty().SetDiffuseColor(colors.GetColor3d("Banana"))
-    pointActor.GetProperty().SetSpecular(.6)
+    pointActor.GetProperty().SetDiffuseColor(colors.GetColor3d('Banana'))
+    pointActor.GetProperty().SetSpecular(0.6)
     pointActor.GetProperty().SetSpecularColor(1.0, 1.0, 1.0)
     pointActor.GetProperty().SetSpecularPower(100)
 
@@ -72,7 +72,7 @@ def main():
     # The geometry
     geometryShrink = vtk.vtkShrinkFilter()
     geometryShrink.SetInputConnection(reader.GetOutputPort())
-    geometryShrink.SetShrinkFactor(.8)
+    geometryShrink.SetShrinkFactor(0.8)
 
     # NOTE: We must copy the originalLut because the CategoricalLegend
     # needs an indexed lookup table, but the geometryMapper uses a
@@ -100,8 +100,8 @@ def main():
     legend = vtk.vtkCategoryLegend()
     legend.SetScalarsToColors(categoricalLut)
     legend.SetValues(legendValues)
-    legend.SetTitle("Cell Type")
-    legend.GetBrush().SetColor(colors.GetColor4ub("Silver"))
+    legend.SetTitle('Cell Type')
+    legend.GetBrush().SetColor(colors.GetColor4ub('Silver'))
 
     placeLegend = vtk.vtkContextTransform()
     placeLegend.AddItem(legend)
@@ -121,7 +121,7 @@ def main():
     renderer.AddActor(labelActor)
     renderer.AddActor(edgeActor)
     renderer.AddActor(pointActor)
-    renderer.SetBackground(colors.GetColor3d("SlateGray"))
+    renderer.SetBackground(colors.GetColor3d('SlateGray'))
 
     aCamera = vtk.vtkCamera()
     aCamera.Azimuth(-40.0)
@@ -131,6 +131,7 @@ def main():
     renderer.ResetCamera()
 
     renderWindow.SetSize(640, 480)
+    renderWindow.SetWindowName('ReadLegacyUnstructuredGrid')
     renderWindow.Render()
 
     renderWindowInteractor.Start()
diff --git a/src/Python/IO/ReadPolyData.py b/src/Python/IO/ReadPolyData.py
index 106e4cc04a07b7a9270f9500da3602e9b475ab28..d2b4fa8188ce8ef3e6ff26634426ff02a8086cef 100755
--- a/src/Python/IO/ReadPolyData.py
+++ b/src/Python/IO/ReadPolyData.py
@@ -30,7 +30,7 @@ def main():
 
     actor = vtk.vtkActor()
     actor.SetMapper(mapper)
-    actor.GetProperty().SetColor(colors.GetColor3d("BurlyWood"))
+    actor.GetProperty().SetColor(colors.GetColor3d('BurlyWood'))
 
     renderer = vtk.vtkRenderer()
     renderWindow = vtk.vtkRenderWindow()
diff --git a/src/Python/IO/ReadSLC.py b/src/Python/IO/ReadSLC.py
index b194e07ef26b5041c1d21390569fffc884aba6b0..7930dfc6eadd96f252b6077d5f98559befc7cc22 100644
--- a/src/Python/IO/ReadSLC.py
+++ b/src/Python/IO/ReadSLC.py
@@ -45,7 +45,7 @@ def main():
 
     # Assign actor to the renderer.
     renderer.AddActor(actor)
-    renderer.SetBackground(colors.GetColor3d("lemon_chiffon"))
+    renderer.SetBackground(colors.GetColor3d('lemon_chiffon'))
 
     # Pick a good view
     renderer.GetActiveCamera().SetPosition(-382.606608, -3.308563, 223.475751)
diff --git a/src/Python/IO/ReadSTL.py b/src/Python/IO/ReadSTL.py
index 034305197c8b8f0ec242f9a299c54c5221a1779a..16f4f688a61ea9e8be6dffe764b78fdc3d0b77d0 100755
--- a/src/Python/IO/ReadSTL.py
+++ b/src/Python/IO/ReadSTL.py
@@ -32,7 +32,7 @@ def main():
     ren = vtk.vtkRenderer()
     renWin = vtk.vtkRenderWindow()
     renWin.AddRenderer(ren)
-    ren.SetBackground(colors.GetColor3d("cobalt_green"))
+    ren.SetBackground(colors.GetColor3d('cobalt_green'))
 
     # Create a renderwindowinteractor
     iren = vtk.vtkRenderWindowInteractor()
diff --git a/src/Python/IO/ReadUnstructuredGrid.py b/src/Python/IO/ReadUnstructuredGrid.py
index 392a32fede8b2fc6b036d037a3e14c79d8fac2de..41134f81ef628f82633cd6fc0408ef032162410b 100755
--- a/src/Python/IO/ReadUnstructuredGrid.py
+++ b/src/Python/IO/ReadUnstructuredGrid.py
@@ -41,14 +41,14 @@ def main():
     actor.GetProperty().SetLineWidth(2.0)
 
     backface = vtk.vtkProperty()
-    backface.SetColor(colors.GetColor3d("tomato"))
+    backface.SetColor(colors.GetColor3d('tomato'))
     actor.SetBackfaceProperty(backface)
 
     # Create the Renderer
     renderer = vtk.vtkRenderer()
     renderer.AddActor(actor)
     renderer.SetBackground(1, 1, 1)  # Set background to white
-    renderer.SetBackground(colors.GetColor3d("Wheat"))
+    renderer.SetBackground(colors.GetColor3d('Wheat'))
 
     # Create the RendererWindow
     renderer_window = vtk.vtkRenderWindow()
diff --git a/src/Python/IO/TestScreenshot.png b/src/Python/IO/TestScreenshot.png
deleted file mode 100644
index d1b415fbdef3652fc2a22be57a78e6a54ba85f4e..0000000000000000000000000000000000000000
Binary files a/src/Python/IO/TestScreenshot.png and /dev/null differ
diff --git a/src/Python/IO/WriteLegacyLinearCells.py b/src/Python/IO/WriteLegacyLinearCells.py
index cc24eba7ec9d40ac29b407d18ce55794bba797f9..1cfecb716424fd68366def4eeb4b29c354c0e937 100755
--- a/src/Python/IO/WriteLegacyLinearCells.py
+++ b/src/Python/IO/WriteLegacyLinearCells.py
@@ -9,56 +9,56 @@ def main():
     uGrids = list()
 
     uGrids.append(MakeUnstructuredGrid(vtk.vtkVertex()))
-    filenames.append("Vertex.vtk")
+    filenames.append('Vertex.vtk')
 
     uGrids.append(MakePolyVertex())
-    filenames.append("PolyVertex.vtk")
+    filenames.append('PolyVertex.vtk')
 
     uGrids.append(MakeUnstructuredGrid(vtk.vtkLine()))
-    filenames.append("Line.vtk")
+    filenames.append('Line.vtk')
 
     uGrids.append(MakePolyLine())
-    filenames.append("PolyLine.vtk")
+    filenames.append('PolyLine.vtk')
 
     uGrids.append(MakeUnstructuredGrid(vtk.vtkTriangle()))
-    filenames.append("Triangle.vtk")
+    filenames.append('Triangle.vtk')
 
     uGrids.append(MakeTriangleStrip())
-    filenames.append("TriangleStrip.vtk")
+    filenames.append('TriangleStrip.vtk')
 
     uGrids.append(MakePolygon())
-    filenames.append("Polygon.vtk")
+    filenames.append('Polygon.vtk')
 
     uGrids.append(MakeUnstructuredGrid(vtk.vtkPixel()))
-    filenames.append("Pixel.vtk")
+    filenames.append('Pixel.vtk')
 
     uGrids.append(MakeUnstructuredGrid(vtk.vtkQuad()))
-    filenames.append("Quad.vtk")
+    filenames.append('Quad.vtk')
 
     uGrids.append(MakeUnstructuredGrid(vtk.vtkTetra()))
-    filenames.append("Tetra.vtk")
+    filenames.append('Tetra.vtk')
 
     uGrids.append(MakeUnstructuredGrid(vtk.vtkVoxel()))
-    filenames.append("Voxel.vtk")
+    filenames.append('Voxel.vtk')
 
     uGrids.append(MakeUnstructuredGrid(vtk.vtkHexahedron()))
-    filenames.append("Hexahedron.vtk")
+    filenames.append('Hexahedron.vtk')
 
     uGrids.append(MakeUnstructuredGrid(vtk.vtkWedge()))
-    filenames.append("Wedge.vtk")
+    filenames.append('Wedge.vtk')
 
     uGrids.append(MakeUnstructuredGrid(vtk.vtkPyramid()))
-    filenames.append("Pyramid.vtk")
+    filenames.append('Pyramid.vtk')
 
     uGrids.append(MakeUnstructuredGrid(vtk.vtkPentagonalPrism()))
-    filenames.append("PentagonalPrism.vtk")
+    filenames.append('PentagonalPrism.vtk')
 
     uGrids.append(MakeUnstructuredGrid(vtk.vtkHexagonalPrism()))
-    filenames.append("HexagonalPrism.vtk")
+    filenames.append('HexagonalPrism.vtk')
 
     # Write each grid into  a file
     for i in range(0, len(uGrids)):
-        print("Writing: ", filenames[i])
+        print('Writing: ', filenames[i])
         writer = vtk.vtkUnstructuredGridWriter()
         writer.SetFileName(filenames[i])
         writer.SetInputData(uGrids[i])
diff --git a/src/Python/IO/WriteXMLLinearCells.py b/src/Python/IO/WriteXMLLinearCells.py
index fec65312de0fdc7401b215fdc7fb2e9d8b123f9b..761e144dce01ad3e1f64f9a8fc42eb0b46b5890d 100755
--- a/src/Python/IO/WriteXMLLinearCells.py
+++ b/src/Python/IO/WriteXMLLinearCells.py
@@ -9,56 +9,56 @@ def main():
     uGrids = list()
 
     uGrids.append(MakeUnstructuredGrid(vtk.vtkVertex()))
-    filenames.append("Vertex.vtu")
+    filenames.append('Vertex.vtu')
 
     uGrids.append(MakePolyVertex())
-    filenames.append("PolyVertex.vtu")
+    filenames.append('PolyVertex.vtu')
 
     uGrids.append(MakeUnstructuredGrid(vtk.vtkLine()))
-    filenames.append("Line.vtu")
+    filenames.append('Line.vtu')
 
     uGrids.append(MakePolyLine())
-    filenames.append("PolyLine.vtu")
+    filenames.append('PolyLine.vtu')
 
     uGrids.append(MakeUnstructuredGrid(vtk.vtkTriangle()))
-    filenames.append("Triangle.vtu")
+    filenames.append('Triangle.vtu')
 
     uGrids.append(MakeTriangleStrip())
-    filenames.append("TriangleStrip.vtu")
+    filenames.append('TriangleStrip.vtu')
 
     uGrids.append(MakePolygon())
-    filenames.append("Polygon.vtu")
+    filenames.append('Polygon.vtu')
 
     uGrids.append(MakeUnstructuredGrid(vtk.vtkPixel()))
-    filenames.append("Pixel.vtu")
+    filenames.append('Pixel.vtu')
 
     uGrids.append(MakeUnstructuredGrid(vtk.vtkQuad()))
-    filenames.append("Quad.vtu")
+    filenames.append('Quad.vtu')
 
     uGrids.append(MakeUnstructuredGrid(vtk.vtkTetra()))
-    filenames.append("Tetra.vtu")
+    filenames.append('Tetra.vtu')
 
     uGrids.append(MakeUnstructuredGrid(vtk.vtkVoxel()))
-    filenames.append("Voxel.vtu")
+    filenames.append('Voxel.vtu')
 
     uGrids.append(MakeUnstructuredGrid(vtk.vtkHexahedron()))
-    filenames.append("Hexahedron.vtu")
+    filenames.append('Hexahedron.vtu')
 
     uGrids.append(MakeUnstructuredGrid(vtk.vtkWedge()))
-    filenames.append("Wedge.vtu")
+    filenames.append('Wedge.vtu')
 
     uGrids.append(MakeUnstructuredGrid(vtk.vtkPyramid()))
-    filenames.append("Pyramid.vtu")
+    filenames.append('Pyramid.vtu')
 
     uGrids.append(MakeUnstructuredGrid(vtk.vtkPentagonalPrism()))
-    filenames.append("PentagonalPrism.vtu")
+    filenames.append('PentagonalPrism.vtu')
 
     uGrids.append(MakeUnstructuredGrid(vtk.vtkHexagonalPrism()))
-    filenames.append("HexagonalPrism.vtu")
+    filenames.append('HexagonalPrism.vtu')
 
     # Write each grid into  a file
     for i in range(0, len(uGrids)):
-        print("Writing: ", filenames[i])
+        print('Writing: ', filenames[i])
         writer = vtk.vtkXMLDataSetWriter()
         writer.SetFileName(filenames[i])
         writer.SetInputData(uGrids[i])
diff --git a/src/Testing/Baseline/Cxx/IO/Test3DSImporter.png b/src/Testing/Baseline/Cxx/IO/Test3DSImporter.png
index fbb2e29e3f1f11c9d2508f6e7ce07f456bc6f2ef..3c56e7613437da2cdaa9193d8cb9ab2f373d0b0b 100644
--- a/src/Testing/Baseline/Cxx/IO/Test3DSImporter.png
+++ b/src/Testing/Baseline/Cxx/IO/Test3DSImporter.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:943640b004702700e871b0dab3f009c2b97baf3bf96f97ca66ceb071239e7445
-size 14599
+oid sha256:8f8c1b07bd64b972abadcf9515336868023c2efd407966d253de63c1c40ab55c
+size 17664
diff --git a/src/Testing/Baseline/Cxx/IO/TestDEMReader.png b/src/Testing/Baseline/Cxx/IO/TestDEMReader.png
index 4af081e57f7f3a813ef43907392227b080a63d7a..fbbdf3e058da217d5e665eebca29827869d80e83 100644
--- a/src/Testing/Baseline/Cxx/IO/TestDEMReader.png
+++ b/src/Testing/Baseline/Cxx/IO/TestDEMReader.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:e688406dc1753d9c07c6d72a98ec095dcb4a5a645f0d9336c7f7439650e2d38d
-size 43290
+oid sha256:c57fa35024808cf455be3c302eb9c598f96296f395dbebd432d219024c1f0ac2
+size 43853
diff --git a/src/Testing/Baseline/Cxx/IO/TestExportPolyDataScene-1.png b/src/Testing/Baseline/Cxx/IO/TestExportPolyDataScene-1.png
deleted file mode 100644
index db98aa1c75e77fe4ec27d7b1f445825867142823..0000000000000000000000000000000000000000
--- a/src/Testing/Baseline/Cxx/IO/TestExportPolyDataScene-1.png
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:25fd13b9c9eba04cd88c283c8c0822abcb38e0d43f0e6a1cee5e638ba5236a39
-size 146572
diff --git a/src/Testing/Baseline/Cxx/IO/TestExportPolyDataScene.png b/src/Testing/Baseline/Cxx/IO/TestExportPolyDataScene.png
index 6ec0dd86121ab4fea866cad1c47cadbf0ebeb2f5..44b72db95ae0b365a011ab70d28d7c2a62cee500 100644
--- a/src/Testing/Baseline/Cxx/IO/TestExportPolyDataScene.png
+++ b/src/Testing/Baseline/Cxx/IO/TestExportPolyDataScene.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:aa38b111970214b4c36f01028a8b5ee4b8e6cdd3d2ed5bd321494f413f9880b5
-size 115742
+oid sha256:d7c0640bc673d80ebf77e0b88ef795579371ba2c5d66a9da15795db4f0d80e2c
+size 146502
diff --git a/src/Testing/Baseline/Cxx/IO/TestGLTFImporter.png b/src/Testing/Baseline/Cxx/IO/TestGLTFImporter.png
index 6661c749a81233f4bea84ed01dc174f76c18fbdc..0fa2257505b35ee6b6d4056095c6fee4f2687e61 100644
--- a/src/Testing/Baseline/Cxx/IO/TestGLTFImporter.png
+++ b/src/Testing/Baseline/Cxx/IO/TestGLTFImporter.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:bd2024680b093684f6b490965fc3fcfaf2d5572f505dd43d63a27b7716061118
-size 85599
+oid sha256:fe7b3eb01bb5173018851b460ffef4c97c9a34d10a6cc47bd9357f724403a45c
+size 91250
diff --git a/src/Testing/Baseline/Cxx/IO/TestImageReader2Factory.png b/src/Testing/Baseline/Cxx/IO/TestImageReader2Factory.png
index 9c1df3d9711e82f0a076fad1ef543063e1975fe1..3156100fe7f2d0695fe0b7a079e5a146a9192a8d 100644
--- a/src/Testing/Baseline/Cxx/IO/TestImageReader2Factory.png
+++ b/src/Testing/Baseline/Cxx/IO/TestImageReader2Factory.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:e852989de641971837bdfbd63d2ec058bd1b480cc51c1564d9ede066279be341
-size 83650
+oid sha256:e8e7f547b75795c747da27107ca0830f2d55e4c50c05f3f2f288f78bb1805acf
+size 83581
diff --git a/src/Testing/Baseline/Cxx/IO/TestImageWriter.png b/src/Testing/Baseline/Cxx/IO/TestImageWriter.png
index b46594ee97f9aa45823fa1b2be23da365690759c..9602db020def566c3ac65b4bc6beba5dcdc5bf63 100644
--- a/src/Testing/Baseline/Cxx/IO/TestImageWriter.png
+++ b/src/Testing/Baseline/Cxx/IO/TestImageWriter.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:b427d55aae48febf04305752dfe0eb4e6040663549689e6b9441e9facc0e5e2e
-size 10204
+oid sha256:e111652ce93ca31662d73691ba6a4c334abccf1cd01265c8dd66d7ea05a1f2da
+size 10190
diff --git a/src/Testing/Baseline/Cxx/IO/TestImportPolyDataScene.png b/src/Testing/Baseline/Cxx/IO/TestImportPolyDataScene.png
index 965a321f03a10be718ee9dd6d3188ab9cd82452d..ca86cfd5d1b587a2aeea4aac1d249cf232f47109 100644
--- a/src/Testing/Baseline/Cxx/IO/TestImportPolyDataScene.png
+++ b/src/Testing/Baseline/Cxx/IO/TestImportPolyDataScene.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:7f42607ce851b868b034b69dfb7170de83c721e7caae3070c97d9c00cb383866
-size 167192
+oid sha256:808ea741f26b4866900a5154788c26388c0bb42964d3112d25efd8e640821329
+size 211923
diff --git a/src/Testing/Baseline/Cxx/IO/TestIndividualVRML.png b/src/Testing/Baseline/Cxx/IO/TestIndividualVRML.png
index f067e99e5dc57edb5a0a86ae66de4c4223afc347..fda7fb0c44924add961a42439e8537215e80b4f6 100644
--- a/src/Testing/Baseline/Cxx/IO/TestIndividualVRML.png
+++ b/src/Testing/Baseline/Cxx/IO/TestIndividualVRML.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:6b60a6589621f7158b3cd50a51033eebb25521306b2cf0fec530018e67f45fcd
-size 5827
+oid sha256:6720d2ad999b9c2b2a48bc6578ed49142facb000709bcd19bedba19cdb9f4788
+size 20986
diff --git a/src/Testing/Baseline/Cxx/IO/TestIndividualVRML_1.png b/src/Testing/Baseline/Cxx/IO/TestIndividualVRML_1.png
deleted file mode 100644
index a944004a05f335c1d35670301944a4e51f492771..0000000000000000000000000000000000000000
--- a/src/Testing/Baseline/Cxx/IO/TestIndividualVRML_1.png
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:03d8e7ae49ad2982245532931feea7841c42042633455cf0b938d69de39d159c
-size 6565
diff --git a/src/Testing/Baseline/Cxx/IO/TestIndividualVRML_2.png b/src/Testing/Baseline/Cxx/IO/TestIndividualVRML_2.png
deleted file mode 100644
index 2bc5f2f1496814e1ce161a53ba3fe610fd362354..0000000000000000000000000000000000000000
--- a/src/Testing/Baseline/Cxx/IO/TestIndividualVRML_2.png
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:de4cd423b357ce968430128e4aeb26dde465d6c07cf2e70f6626a0bc945a83a4
-size 8537
diff --git a/src/Testing/Baseline/Cxx/IO/TestIndividualVRML_3.png b/src/Testing/Baseline/Cxx/IO/TestIndividualVRML_3.png
deleted file mode 100644
index a9650672fb9be734cd0def6ce03322a6abab6510..0000000000000000000000000000000000000000
--- a/src/Testing/Baseline/Cxx/IO/TestIndividualVRML_3.png
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:3cd97c8d58dc5a6e3f1b9d2c2f57dd964d69eb36876d42d0aa8fbbe91bd5a694
-size 6738
diff --git a/src/Testing/Baseline/Cxx/IO/TestIndividualVRML_4.png b/src/Testing/Baseline/Cxx/IO/TestIndividualVRML_4.png
deleted file mode 100644
index 7c0f3686f5450492f45850eed24cdc3e22479b82..0000000000000000000000000000000000000000
--- a/src/Testing/Baseline/Cxx/IO/TestIndividualVRML_4.png
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:68afe8aa023840b0d4bf714ff00442c5419678b6ff074c1bd81f7f1c7d97d1c9
-size 6831
diff --git a/src/Testing/Baseline/Cxx/IO/TestJPEGReader.png b/src/Testing/Baseline/Cxx/IO/TestJPEGReader.png
index 16204a96822f9acf387831101807a324b4037afb..8d1bad6b58acdc735a2baa57a223eb8b4901ea59 100644
--- a/src/Testing/Baseline/Cxx/IO/TestJPEGReader.png
+++ b/src/Testing/Baseline/Cxx/IO/TestJPEGReader.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:63b43cf508825fe7d40fd813bc02bd23ab2105debe6f25f61761649fbc1bac73
-size 87832
+oid sha256:567a31e084034dc8daf99be3653b72910cdcef4d1cbaaa2e08fdb98ed74d4aae
+size 90068
diff --git a/src/Testing/Baseline/Cxx/IO/TestMetaImageReader.png b/src/Testing/Baseline/Cxx/IO/TestMetaImageReader.png
index 436703706cabd62711a0b40ff798b1957d482e6a..cb631c87cada8fc42fcffcc118c5ed1ae6dae9e5 100644
--- a/src/Testing/Baseline/Cxx/IO/TestMetaImageReader.png
+++ b/src/Testing/Baseline/Cxx/IO/TestMetaImageReader.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:f491a6f725a43fb81e221954430fabf8b9b0f17bfad86eccc5bf289cd352f73b
-size 46981
+oid sha256:4aff5dae4726b15630602a487cf32073d9c088d0aa02642da8ab7e68f559374e
+size 56695
diff --git a/src/Testing/Baseline/Cxx/IO/TestMetaImageWriter.png b/src/Testing/Baseline/Cxx/IO/TestMetaImageWriter.png
index 7420db496988895c4cad6f91e2dbcd75daf579e1..a158e825f4967c34007f73c8d2b9729140ef6358 100644
--- a/src/Testing/Baseline/Cxx/IO/TestMetaImageWriter.png
+++ b/src/Testing/Baseline/Cxx/IO/TestMetaImageWriter.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:f53a79f1e0675b3c617d822f4f0d668e3fb5c73c087626be56de45e2e76a635f
-size 13725
+oid sha256:590138fa07ff9a9ce1225b48c5c2dc68b6ca0c14fe6be88aebdef14c2dbc2adb
+size 14581
diff --git a/src/Testing/Baseline/Cxx/IO/TestOBJImporter.png b/src/Testing/Baseline/Cxx/IO/TestOBJImporter.png
index d9889ac22f897ded4d596876eb1753e31cffa5cc..0d9cb855c487c03f87f65c40dae3973f8c5f3ee7 100644
--- a/src/Testing/Baseline/Cxx/IO/TestOBJImporter.png
+++ b/src/Testing/Baseline/Cxx/IO/TestOBJImporter.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:c3e892959666f0c7046ca6fb23651b524291d47eb92bcb9ee4e3eed8b14cea9f
-size 56604
+oid sha256:e69030e59cdba0c5b20b7a7de866a13221ce9a9d23dedec7fc5e804653f2ffe2
+size 56651
diff --git a/src/Testing/Baseline/Cxx/IO/TestPNGReader.png b/src/Testing/Baseline/Cxx/IO/TestPNGReader.png
index 0e46a53310370278448590c2e9e299d50d072e69..6e6ced13483e07799ad9078b5218e8d6c9099370 100644
--- a/src/Testing/Baseline/Cxx/IO/TestPNGReader.png
+++ b/src/Testing/Baseline/Cxx/IO/TestPNGReader.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:be37e32d1097a48ec75d5bbf4337ab4916ecfe2e722afa70437c128e75997f11
-size 204374
+oid sha256:b128243fa8c3ba55e62e3af5645a6dd1a8f420de0dfc9b74475b49fbe996c9ff
+size 205515
diff --git a/src/Testing/Baseline/Cxx/IO/TestParticleReader.png b/src/Testing/Baseline/Cxx/IO/TestParticleReader.png
index 022a018e0b0723c4b7a89453e68e6a89666bb968..7b687b9e6e0cea0a49669401280c95a0498d7e23 100644
--- a/src/Testing/Baseline/Cxx/IO/TestParticleReader.png
+++ b/src/Testing/Baseline/Cxx/IO/TestParticleReader.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:acb5c711b4e8e66dd8244ca1aeacfddf5a2832e193d90620cb0dd8b79b87cf29
-size 1949
+oid sha256:b103320bc166a950e838b6fd20c2704b5302698b1d73e9c5172a776ae32b397a
+size 4498
diff --git a/src/Testing/Baseline/Cxx/IO/TestReadAllPolyDataTypes.png b/src/Testing/Baseline/Cxx/IO/TestReadAllPolyDataTypes.png
index f5072fa9fc3ecb7bab63d6f69020da8f1f43f366..058026bb7d54129c03660ce884e5513c5afb1da1 100644
--- a/src/Testing/Baseline/Cxx/IO/TestReadAllPolyDataTypes.png
+++ b/src/Testing/Baseline/Cxx/IO/TestReadAllPolyDataTypes.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:b883888b45c4db504ec1df67610643316797bf0a445f444e9b18126a77faff5b
-size 36871
+oid sha256:a94192271c9aa565b201e5e575ca5e1e9c87eae595fc69a5e2b7019cac8878cd
+size 37155
diff --git a/src/Testing/Baseline/Cxx/IO/TestReadAllPolyDataTypesDemo.png b/src/Testing/Baseline/Cxx/IO/TestReadAllPolyDataTypesDemo.png
index b47a315fc22f584d8eca5e4c0946dacbaac02ff0..d60aa7bb30afd21334173347beae75c48dab0136 100644
--- a/src/Testing/Baseline/Cxx/IO/TestReadAllPolyDataTypesDemo.png
+++ b/src/Testing/Baseline/Cxx/IO/TestReadAllPolyDataTypesDemo.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:5d7c0d5c760a3636c73512d2e585e3a711b52ac1fff2ff1e50a441bb4d980b70
-size 156793
+oid sha256:49d6cab690d1deccd4835a39345ecaf51c71a9343c088505c63621a05b95c7ef
+size 158265
diff --git a/src/Testing/Baseline/Cxx/IO/TestReadAllPolyDataTypesDemo_1.png b/src/Testing/Baseline/Cxx/IO/TestReadAllPolyDataTypesDemo_1.png
deleted file mode 100644
index a4eeb22332c3394e6f4f0f8e006b64a02b598448..0000000000000000000000000000000000000000
--- a/src/Testing/Baseline/Cxx/IO/TestReadAllPolyDataTypesDemo_1.png
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:83a9b5e03b97b96c63e2364c7e4d2b5c6e2f2f765a2ffe16243304d8479fb5e5
-size 128638
diff --git a/src/Testing/Baseline/Cxx/IO/TestReadAllUnstructuredGridTypes.png b/src/Testing/Baseline/Cxx/IO/TestReadAllUnstructuredGridTypes.png
index 94925ca733a7f5fa4c20bd13ffa344232a8697e4..7e6f6f3af6c595bd65c7354ae6dc8de7d439a1d7 100644
--- a/src/Testing/Baseline/Cxx/IO/TestReadAllUnstructuredGridTypes.png
+++ b/src/Testing/Baseline/Cxx/IO/TestReadAllUnstructuredGridTypes.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:1ad9eedc0120cfe43e7cd1c97eb36a949c35a4d114c8de60f6e40fb701d5b1f6
-size 41064
+oid sha256:2c9dabf8ceb4eb529472785a625f113348907752589e1fde71d0486f09ccbfd7
+size 54195
diff --git a/src/Testing/Baseline/Cxx/IO/TestReadBMP.png b/src/Testing/Baseline/Cxx/IO/TestReadBMP.png
index d3220e59a53726b7cec42d6d4f756e478dc49d0e..ae800909c79b4d363f655fb64e06e313ad4536a1 100644
--- a/src/Testing/Baseline/Cxx/IO/TestReadBMP.png
+++ b/src/Testing/Baseline/Cxx/IO/TestReadBMP.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:c00b06b73bba6e1d12185e96be2b3edb895abf2b8553880dce061fa17228a2f5
-size 70927
+oid sha256:cee28275360e2b877fa242bd3e7e987bde634483cb691f366f16bab9b9d5fd27
+size 71326
diff --git a/src/Testing/Baseline/Cxx/IO/TestReadCML.png b/src/Testing/Baseline/Cxx/IO/TestReadCML.png
index 1297db3238c8d87ac0f86ef69a73b36f8b68b9f8..0b78e7d81f9544939c136bdaf304a70795e32ece 100644
--- a/src/Testing/Baseline/Cxx/IO/TestReadCML.png
+++ b/src/Testing/Baseline/Cxx/IO/TestReadCML.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:30784d7cf9852ae840c52789595a7b6a3eb80d74ac2e0b064e163ce8494bb18b
-size 64700
+oid sha256:b579a79fe20096bf8352c0ebaea0fb02da0aa4a34a24140b062714bc17fbd649
+size 64478
diff --git a/src/Testing/Baseline/Cxx/IO/TestReadDICOM.png b/src/Testing/Baseline/Cxx/IO/TestReadDICOM.png
index 0028311ee6c6ac9a84b8fab23de846ce444cf243..f23126e754d1112f8ffccd10bf6f7ba542c722f6 100644
--- a/src/Testing/Baseline/Cxx/IO/TestReadDICOM.png
+++ b/src/Testing/Baseline/Cxx/IO/TestReadDICOM.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:65be75e2e6c73d44ad4272feaf889b8295524754c8bcb450b43bce3706cb76e9
-size 27249
+oid sha256:c4e2a71f74bb61ad3559f69f9534463376711db7bb2984772e4a771b549c7bff
+size 31169
diff --git a/src/Testing/Baseline/Cxx/IO/TestReadDICOMSeries.png b/src/Testing/Baseline/Cxx/IO/TestReadDICOMSeries.png
index 498b760d77164ceca234c8bd99ddad21fe486f40..c10bf1d9d039aa494c43916cb13a27713d6b6cf9 100644
--- a/src/Testing/Baseline/Cxx/IO/TestReadDICOMSeries.png
+++ b/src/Testing/Baseline/Cxx/IO/TestReadDICOMSeries.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:9166b491daf98f1ea443d507446b05c06f628082b605c052cd06f62c71a15655
-size 22164
+oid sha256:9abfef71e88a2dc08e8d4097bda52a16a1758aaf8b6edf6df7031270e0a129fc
+size 128807
diff --git a/src/Testing/Baseline/Cxx/IO/TestReadDICOMSeries_1.png b/src/Testing/Baseline/Cxx/IO/TestReadDICOMSeries_1.png
deleted file mode 100644
index 9c081f37865d1f50003fdbef3cc31573bbc61476..0000000000000000000000000000000000000000
--- a/src/Testing/Baseline/Cxx/IO/TestReadDICOMSeries_1.png
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:b997279190f271582738888cd16e8b1b5b7ff2cae1846205491eecaa1c6ea305
-size 21878
diff --git a/src/Testing/Baseline/Cxx/IO/TestReadDICOMSeries_2.png b/src/Testing/Baseline/Cxx/IO/TestReadDICOMSeries_2.png
deleted file mode 100644
index 9c7ff65b499c4fef7236ec2b81706779b6e6a98b..0000000000000000000000000000000000000000
--- a/src/Testing/Baseline/Cxx/IO/TestReadDICOMSeries_2.png
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:00091e43754b652b2e1a7ad05b469168336fe6f10533471bdebac259409de9b8
-size 27212
diff --git a/src/Testing/Baseline/Cxx/IO/TestReadExodusData.png b/src/Testing/Baseline/Cxx/IO/TestReadExodusData.png
index d7f3c59a0bf67dca7dc70e85cfc880f9111a0b81..0d5661fc6146f229b4f99b76642b731a4b2449bf 100644
--- a/src/Testing/Baseline/Cxx/IO/TestReadExodusData.png
+++ b/src/Testing/Baseline/Cxx/IO/TestReadExodusData.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:b05e94a28c6ec2c8b0d7f21c97e842c1234628406d8e1363df30b7e6dbadb4a3
-size 74028
+oid sha256:401d1781141dc0185b891b294c75b7ee9e3b19dd62b15010304ddbe3a24db322
+size 88922
diff --git a/src/Testing/Baseline/Cxx/IO/TestReadImageData.png b/src/Testing/Baseline/Cxx/IO/TestReadImageData.png
index fd217e92419afc98e6b2cf5138d8b7532ec0ad4c..a0ba4067f81d33eff49f8fd499f290997b384983 100644
--- a/src/Testing/Baseline/Cxx/IO/TestReadImageData.png
+++ b/src/Testing/Baseline/Cxx/IO/TestReadImageData.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:34ecf82371d5d558a9f431376c2371013d8965a81f6af00063020da35ab26887
-size 5733
+oid sha256:848f9238a800752affd7dcc4b7eaa66a40bab3b06995c2c81d2cd8d851e6959d
+size 5626
diff --git a/src/Testing/Baseline/Cxx/IO/TestReadLegacyUnstructuredGrid.png b/src/Testing/Baseline/Cxx/IO/TestReadLegacyUnstructuredGrid.png
index 929934bd798dba878dff9d28a7fc2d719cb392b3..e02347cd6b3114fe1adeeee7cff1875cab60126e 100644
--- a/src/Testing/Baseline/Cxx/IO/TestReadLegacyUnstructuredGrid.png
+++ b/src/Testing/Baseline/Cxx/IO/TestReadLegacyUnstructuredGrid.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:62af481af118908551c5aaf53d8388d770cc83f093218d21ca858e332fed154d
-size 57671
+oid sha256:8403f5888cb4f126e6be52ad7c4a35f179147ffc7c2a8fe35b4fe722ae5c69ef
+size 73683
diff --git a/src/Testing/Baseline/Cxx/IO/TestReadLegacyUnstructuredGrid_1.png b/src/Testing/Baseline/Cxx/IO/TestReadLegacyUnstructuredGrid_1.png
deleted file mode 100644
index d0c59ab6ef56cbbd9a253b6d30aaa5da4ad3bb87..0000000000000000000000000000000000000000
--- a/src/Testing/Baseline/Cxx/IO/TestReadLegacyUnstructuredGrid_1.png
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:7c16c39a5ecfeb6b2016e84f4dfee3e6871982510962d8df3f36a61993442e8c
-size 67145
diff --git a/src/Testing/Baseline/Cxx/IO/TestReadPDB_1.png b/src/Testing/Baseline/Cxx/IO/TestReadPDB_1.png
deleted file mode 100644
index b0d2dc56b60cdce762da4ab1eb757ce5f3ac8667..0000000000000000000000000000000000000000
--- a/src/Testing/Baseline/Cxx/IO/TestReadPDB_1.png
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:9ea107d26802cd06e0ea6ca6afbb57b7716fa4de53e008e613c5ba3aa281ea6a
-size 16743
diff --git a/src/Testing/Baseline/Cxx/IO/TestReadPDB_2.png b/src/Testing/Baseline/Cxx/IO/TestReadPDB_2.png
deleted file mode 100644
index a26b6a51fc416b1109a4cabf2fac74cc6ce016eb..0000000000000000000000000000000000000000
--- a/src/Testing/Baseline/Cxx/IO/TestReadPDB_2.png
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:7cfa35497fe55b23a7692a5d2fc2c7f607c30bff9952af4212f304460b517d1e
-size 30512
diff --git a/src/Testing/Baseline/Cxx/IO/TestReadPDB_3.png b/src/Testing/Baseline/Cxx/IO/TestReadPDB_3.png
deleted file mode 100644
index 33095444cccb1759e219bc4a9d91acba3a18d068..0000000000000000000000000000000000000000
--- a/src/Testing/Baseline/Cxx/IO/TestReadPDB_3.png
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:f5ac5a4f52f1db7301db7940ba6e1df0903e309d2efdc8fc0f5a5b1d02fc13b9
-size 24768
diff --git a/src/Testing/Baseline/Cxx/IO/TestReadPDB_4.png b/src/Testing/Baseline/Cxx/IO/TestReadPDB_4.png
deleted file mode 100644
index 927b911bf7a9f5e69a8011407ccd8573880d6bf3..0000000000000000000000000000000000000000
--- a/src/Testing/Baseline/Cxx/IO/TestReadPDB_4.png
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:1116e8f853430653b6a998c83ab6cfdf2a4f28ea1c2ea63bfcd63431ad3238c3
-size 30699
diff --git a/src/Testing/Baseline/Cxx/IO/TestReadPLOT3D_1.png b/src/Testing/Baseline/Cxx/IO/TestReadPLOT3D_1.png
deleted file mode 100644
index 91d5df245d39b5e80b48c7d307affb9a33751655..0000000000000000000000000000000000000000
--- a/src/Testing/Baseline/Cxx/IO/TestReadPLOT3D_1.png
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:d8e0f460022b4571986f10557389115148d20a679138cc38ae3d672b4b8b80ac
-size 28008
diff --git a/src/Testing/Baseline/Cxx/IO/TestReadRectilinearGrid_1.png b/src/Testing/Baseline/Cxx/IO/TestReadRectilinearGrid_1.png
deleted file mode 100644
index f3396c3960d2a0ea245487237752e669d94cb938..0000000000000000000000000000000000000000
--- a/src/Testing/Baseline/Cxx/IO/TestReadRectilinearGrid_1.png
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:e12cc1893a1a2450e32bae653fb98944a64cc766ba43f2fdb637449421614625
-size 7893
diff --git a/src/Testing/Baseline/Cxx/IO/TestReadRectilinearGrid_2.png b/src/Testing/Baseline/Cxx/IO/TestReadRectilinearGrid_2.png
deleted file mode 100644
index 659687ad8ceab94e8da8751c30329e032248444c..0000000000000000000000000000000000000000
--- a/src/Testing/Baseline/Cxx/IO/TestReadRectilinearGrid_2.png
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:f03ef5824b81de89fcda7f075bc6caa1012b84cafa23cdd03166ea0d52d63a69
-size 7359
diff --git a/src/Testing/Baseline/Cxx/IO/TestStructuredGridReader_1.png b/src/Testing/Baseline/Cxx/IO/TestStructuredGridReader_1.png
deleted file mode 100644
index cdf4f04eae4689ea1c3c912ed08c5824cadc612f..0000000000000000000000000000000000000000
--- a/src/Testing/Baseline/Cxx/IO/TestStructuredGridReader_1.png
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:2cc441275726fae887ea5a1a8f993edcc5473f7e063a060a62c984b989eb9a28
-size 68726
diff --git a/src/Testing/Baseline/Cxx/IO/TestStructuredGridReader_2.png b/src/Testing/Baseline/Cxx/IO/TestStructuredGridReader_2.png
deleted file mode 100644
index ce65cbaeaa6a4b7cc4a88421d1d6cfc440a96a5e..0000000000000000000000000000000000000000
--- a/src/Testing/Baseline/Cxx/IO/TestStructuredGridReader_2.png
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:12a0742a533c369b28ff2e920f976d1c71c316f927639d8b627e3af53fcd4709
-size 104178
diff --git a/src/Testing/Baseline/Cxx/IO/TestVRMLImporterDemo_1.png b/src/Testing/Baseline/Cxx/IO/TestVRMLImporterDemo_1.png
deleted file mode 100644
index 41e5ce1399e3eca01459a5948c923f699e88c703..0000000000000000000000000000000000000000
--- a/src/Testing/Baseline/Cxx/IO/TestVRMLImporterDemo_1.png
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:e7f59d385838e06004db38ad32229639afcb3e2012ee66a6be47df3491357aa1
-size 69185
diff --git a/src/Testing/Baseline/Python/IO/Test3DSImporter.png b/src/Testing/Baseline/Python/IO/Test3DSImporter.png
index fbb2e29e3f1f11c9d2508f6e7ce07f456bc6f2ef..3c56e7613437da2cdaa9193d8cb9ab2f373d0b0b 100644
--- a/src/Testing/Baseline/Python/IO/Test3DSImporter.png
+++ b/src/Testing/Baseline/Python/IO/Test3DSImporter.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:943640b004702700e871b0dab3f009c2b97baf3bf96f97ca66ceb071239e7445
-size 14599
+oid sha256:8f8c1b07bd64b972abadcf9515336868023c2efd407966d253de63c1c40ab55c
+size 17664
diff --git a/src/Testing/Baseline/Python/IO/TestImageWriter.png b/src/Testing/Baseline/Python/IO/TestImageWriter.png
index b46594ee97f9aa45823fa1b2be23da365690759c..9602db020def566c3ac65b4bc6beba5dcdc5bf63 100644
--- a/src/Testing/Baseline/Python/IO/TestImageWriter.png
+++ b/src/Testing/Baseline/Python/IO/TestImageWriter.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:b427d55aae48febf04305752dfe0eb4e6040663549689e6b9441e9facc0e5e2e
-size 10204
+oid sha256:e111652ce93ca31662d73691ba6a4c334abccf1cd01265c8dd66d7ea05a1f2da
+size 10190
diff --git a/src/Testing/Baseline/Python/IO/TestReadExodusData.png b/src/Testing/Baseline/Python/IO/TestReadExodusData.png
index 6754ce8f25a0719ebcfeaa8e416294f3687ec080..0d5661fc6146f229b4f99b76642b731a4b2449bf 100644
--- a/src/Testing/Baseline/Python/IO/TestReadExodusData.png
+++ b/src/Testing/Baseline/Python/IO/TestReadExodusData.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:1f2b2277f2b9dd067f50382e767bd6eed92d6e8544e756b6244a11adcb1082c8
-size 86723
+oid sha256:401d1781141dc0185b891b294c75b7ee9e3b19dd62b15010304ddbe3a24db322
+size 88922
diff --git a/src/Testing/Baseline/Python/IO/TestReadImageData.png b/src/Testing/Baseline/Python/IO/TestReadImageData.png
index fd217e92419afc98e6b2cf5138d8b7532ec0ad4c..a0ba4067f81d33eff49f8fd499f290997b384983 100644
--- a/src/Testing/Baseline/Python/IO/TestReadImageData.png
+++ b/src/Testing/Baseline/Python/IO/TestReadImageData.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:34ecf82371d5d558a9f431376c2371013d8965a81f6af00063020da35ab26887
-size 5733
+oid sha256:848f9238a800752affd7dcc4b7eaa66a40bab3b06995c2c81d2cd8d851e6959d
+size 5626
diff --git a/src/Testing/Baseline/Python/IO/TestReadLegacyUnstructuredGrid.png b/src/Testing/Baseline/Python/IO/TestReadLegacyUnstructuredGrid.png
index 929934bd798dba878dff9d28a7fc2d719cb392b3..e02347cd6b3114fe1adeeee7cff1875cab60126e 100644
--- a/src/Testing/Baseline/Python/IO/TestReadLegacyUnstructuredGrid.png
+++ b/src/Testing/Baseline/Python/IO/TestReadLegacyUnstructuredGrid.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:62af481af118908551c5aaf53d8388d770cc83f093218d21ca858e332fed154d
-size 57671
+oid sha256:8403f5888cb4f126e6be52ad7c4a35f179147ffc7c2a8fe35b4fe722ae5c69ef
+size 73683