ParaView-5.0.1: Added the source-tree to ThirdParty-dev and patched as described in the README file

Resolves bug-report http://bugs.openfoam.org/view.php?id=2098

ParaView-5.0.1/VTK/Examples/Tutorial/README.txt

@@ -0,0 +1,19 @@
+These examples demonstrate some basic VTK concepts. They are organized in
+increasing order of complexity. These examples are described in more detail
+in the textbook "The Visualization Toolkit An Object-Oriented Approach to 3D
+Graphics" Third Edition available for purchase from Kitware. The examples are
+implemented in the programming languages C++, Tcl, Python, and Java. (Note:
+in order to use Tcl, Python, and/or Java, you will need to compile with
+wrapping on.)
+
+Step1 - A "Hello World" style example of a simple visualization pipeline
+Step2 - Adding observers to Step1 (i.e., processing events)
+Step3 - Rendering with multiple renderers
+Step4 - Modifying properties and transformations
+Step5 - Specifying a particular interaction style
+Step6 - Adding a 3D widget
+
+Once you finish this mini-tutorial, you may wish to explore the other
+VTK/Examples/ subdirectories. In particular, the VTK/Examples/Rendering
+and VTK/Examples/VisualizationAlgorithms are worth exploring. The
+subdirectory VTK/Examples/GUI has other 3D widget examples.

ParaView-5.0.1/VTK/Examples/Tutorial/Step1/Cxx/CMakeLists.txt

@@ -0,0 +1,19 @@
+cmake_minimum_required(VERSION 2.8.5 FATAL_ERROR)
+if(POLICY CMP0025)
+  cmake_policy(SET CMP0025 NEW) # CMake 3.0
+endif()
+if(POLICY CMP0053)
+  cmake_policy(SET CMP0053 NEW) # CMake 3.1
+endif()
+
+project (Step1)
+
+find_package(VTK COMPONENTS
+  vtkFiltersSources
+  vtkInteractionStyle
+  vtkRendering${VTK_RENDERING_BACKEND}
+)
+include(${VTK_USE_FILE})
+
+add_executable(Cone MACOSX_BUNDLE Cone.cxx)
+target_link_libraries(Cone ${VTK_LIBRARIES})

ParaView-5.0.1/VTK/Examples/Tutorial/Step1/Cxx/Cone.cxx

@@ -0,0 +1,107 @@
+/*=========================================================================
+
+  Program:   Visualization Toolkit
+  Module:    Cone.cxx
+
+  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
+  All rights reserved.
+  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
+
+     This software is distributed WITHOUT ANY WARRANTY; without even
+     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+     PURPOSE.  See the above copyright notice for more information.
+
+=========================================================================*/
+//
+// This example creates a polygonal model of a cone, and then renders it to
+// the screen. It will rotate the cone 360 degrees and then exit. The basic
+// setup of source -> mapper -> actor -> renderer -> renderwindow is
+// typical of most VTK programs.
+//
+
+// First include the required header files for the VTK classes we are using.
+#include "vtkConeSource.h"
+#include "vtkPolyDataMapper.h"
+#include "vtkRenderWindow.h"
+#include "vtkCamera.h"
+#include "vtkActor.h"
+#include "vtkRenderer.h"
+
+int main()
+{
+  //
+  // Next we create an instance of vtkConeSource and set some of its
+  // properties. The instance of vtkConeSource "cone" is part of a
+  // visualization pipeline (it is a source process object); it produces data
+  // (output type is vtkPolyData) which other filters may process.
+  //
+  vtkConeSource *cone = vtkConeSource::New();
+  cone->SetHeight( 3.0 );
+  cone->SetRadius( 1.0 );
+  cone->SetResolution( 10 );
+
+  //
+  // In this example we terminate the pipeline with a mapper process object.
+  // (Intermediate filters such as vtkShrinkPolyData could be inserted in
+  // between the source and the mapper.)  We create an instance of
+  // vtkPolyDataMapper to map the polygonal data into graphics primitives. We
+  // connect the output of the cone souece to the input of this mapper.
+  //
+  vtkPolyDataMapper *coneMapper = vtkPolyDataMapper::New();
+  coneMapper->SetInputConnection( cone->GetOutputPort() );
+
+  //
+  // Create an actor to represent the cone. The actor orchestrates rendering
+  // of the mapper's graphics primitives. An actor also refers to properties
+  // via a vtkProperty instance, and includes an internal transformation
+  // matrix. We set this actor's mapper to be coneMapper which we created
+  // above.
+  //
+  vtkActor *coneActor = vtkActor::New();
+  coneActor->SetMapper( coneMapper );
+
+  //
+  // Create the Renderer and assign actors to it. A renderer is like a
+  // viewport. It is part or all of a window on the screen and it is
+  // responsible for drawing the actors it has.  We also set the background
+  // color here.
+  //
+  vtkRenderer *ren1= vtkRenderer::New();
+  ren1->AddActor( coneActor );
+  ren1->SetBackground( 0.1, 0.2, 0.4 );
+
+  //
+  // Finally we create the render window which will show up on the screen.
+  // We put our renderer into the render window using AddRenderer. We also
+  // set the size to be 300 pixels by 300.
+  //
+  vtkRenderWindow *renWin = vtkRenderWindow::New();
+  renWin->AddRenderer( ren1 );
+  renWin->SetSize( 300, 300 );
+
+  //
+  // Now we loop over 360 degreeees and render the cone each time.
+  //
+  int i;
+  for (i = 0; i < 360; ++i)
+    {
+    // render the image
+    renWin->Render();
+    // rotate the active camera by one degree
+    ren1->GetActiveCamera()->Azimuth( 1 );
+    }
+
+  //
+  // Free up any objects we created. All instances in VTK are deleted by
+  // using the Delete() method.
+  //
+  cone->Delete();
+  coneMapper->Delete();
+  coneActor->Delete();
+  ren1->Delete();
+  renWin->Delete();
+
+  return 0;
+}
+
+

ParaView-5.0.1/VTK/Examples/Tutorial/Step1/Java/Cone.java

@@ -0,0 +1,91 @@
+//
+// This example creates a polygonal model of a cone, and then renders it to
+// the screen. It will rotate the cone 360 degrees and then exit. The basic
+// setup of source -> mapper -> actor -> renderer -> renderwindow is
+// typical of most VTK programs.
+//
+
+// We import the vtk wrapped classes first.
+import vtk.*;
+
+// Then we define our class.
+public class Cone {
+
+  // In the static contructor we load in the native code.
+  // The libraries must be in your path to work.
+  static {
+    System.loadLibrary("vtkCommonJava");
+    System.loadLibrary("vtkFilteringJava");
+    System.loadLibrary("vtkIOJava");
+    System.loadLibrary("vtkImagingJava");
+    System.loadLibrary("vtkGraphicsJava");
+    System.loadLibrary("vtkRenderingJava");
+  }
+
+  // now the main program
+  public static void main (String []args) {
+    //
+    // Next we create an instance of vtkConeSource and set some of its
+    // properties. The instance of vtkConeSource "cone" is part of a
+    // visualization pipeline (it is a source process object); it produces data
+    // (output type is vtkPolyData) which other filters may process.
+    //
+    vtkConeSource cone = new vtkConeSource();
+    cone.SetHeight( 3.0 );
+    cone.SetRadius( 1.0 );
+    cone.SetResolution( 10 );
+
+    //
+    // In this example we terminate the pipeline with a mapper process object.
+    // (Intermediate filters such as vtkShrinkPolyData could be inserted in
+    // between the source and the mapper.)  We create an instance of
+    // vtkPolyDataMapper to map the polygonal data into graphics primitives. We
+    // connect the output of the cone souece to the input of this mapper.
+    //
+    vtkPolyDataMapper coneMapper = new vtkPolyDataMapper();
+    coneMapper.SetInputConnection( cone.GetOutputPort() );
+
+    //
+    // Create an actor to represent the cone. The actor orchestrates rendering
+    // of the mapper's graphics primitives. An actor also refers to properties
+    // via a vtkProperty instance, and includes an internal transformation
+    // matrix. We set this actor's mapper to be coneMapper which we created
+    // above.
+    //
+    vtkActor coneActor = new vtkActor();
+    coneActor.SetMapper( coneMapper );
+
+    //
+    // Create the Renderer and assign actors to it. A renderer is like a
+    // viewport. It is part or all of a window on the screen and it is
+    // responsible for drawing the actors it has.  We also set the background
+    // color here
+    //
+    vtkRenderer ren1 = new vtkRenderer();
+    ren1.AddActor( coneActor );
+    ren1.SetBackground( 0.1, 0.2, 0.4 );
+
+    //
+    // Finally we create the render window which will show up on the screen
+    // We put our renderer into the render window using AddRenderer. We also
+    // set the size to be 300 pixels by 300
+    //
+    vtkRenderWindow renWin = new vtkRenderWindow();
+    renWin.AddRenderer( ren1 );
+    renWin.SetSize( 300, 300 );
+
+    //
+    // now we loop over 360 degreeees and render the cone each time
+    //
+    int i;
+    for (i = 0; i < 360; ++i)
+      {
+      // render the image
+      renWin.Render();
+      // rotate the active camera by one degree
+      ren1.GetActiveCamera().Azimuth( 1 );
+      }
+
+    }
+}
+

ParaView-5.0.1/VTK/Examples/Tutorial/Step1/Python/Cone.py

@@ -0,0 +1,72 @@
+#!/usr/bin/env python
+#
+# This example creates a polygonal model of a cone, and then renders it to
+# the screen. It will rotate the cone 360 degrees and then exit. The basic
+# setup of source -> mapper -> actor -> renderer -> renderwindow is
+# typical of most VTK programs.
+#
+
+#
+# First we include the VTK Python packages that will make available
+# all of the VTK commands to Python.
+#
+import vtk
+import time
+
+#
+# Next we create an instance of vtkConeSource and set some of its
+# properties. The instance of vtkConeSource "cone" is part of a visualization
+# pipeline (it is a source process object); it produces data (output type is
+# vtkPolyData) which other filters may process.
+#
+cone = vtk.vtkConeSource()
+cone.SetHeight( 3.0 )
+cone.SetRadius( 1.0 )
+cone.SetResolution( 10 )
+
+#
+# In this example we terminate the pipeline with a mapper process object.
+# (Intermediate filters such as vtkShrinkPolyData could be inserted in
+# between the source and the mapper.)  We create an instance of
+# vtkPolyDataMapper to map the polygonal data into graphics primitives. We
+# connect the output of the cone souece to the input of this mapper.
+#
+coneMapper = vtk.vtkPolyDataMapper()
+coneMapper.SetInputConnection( cone.GetOutputPort() )
+
+#
+# Create an actor to represent the cone. The actor orchestrates rendering of
+# the mapper's graphics primitives. An actor also refers to properties via a
+# vtkProperty instance, and includes an internal transformation matrix. We
+# set this actor's mapper to be coneMapper which we created above.
+#
+coneActor = vtk.vtkActor()
+coneActor.SetMapper( coneMapper )
+
+#
+# Create the Renderer and assign actors to it. A renderer is like a
+# viewport. It is part or all of a window on the screen and it is
+# responsible for drawing the actors it has.  We also set the background
+# color here
+#
+ren1= vtk.vtkRenderer()
+ren1.AddActor( coneActor )
+ren1.SetBackground( 0.1, 0.2, 0.4 )
+
+#
+# Finally we create the render window which will show up on the screen
+# We put our renderer into the render window using AddRenderer. We also
+# set the size to be 300 pixels by 300
+#
+renWin = vtk.vtkRenderWindow()
+renWin.AddRenderer( ren1 )
+renWin.SetSize( 300, 300 )
+
+#
+# now we loop over 360 degreeees and render the cone each time
+#
+for i in range(0,360):
+    time.sleep(0.03)
+
+    renWin.Render()
+    ren1.GetActiveCamera().Azimuth( 1 )

ParaView-5.0.1/VTK/Examples/Tutorial/Step1/Tcl/Cone.tcl

@@ -0,0 +1,84 @@
+#
+# This example creates a polygonal model of a cone, and then renders it to
+# the screen. It will rotate the cone 360 degrees and then exit. The basic
+# setup of source -> mapper -> actor -> renderer -> renderwindow is
+# typical of most VTK programs.
+#
+
+#
+# First we include the VTK Tcl packages which will make available
+# all of the VTK commands to Tcl.
+#
+package require vtk
+
+#
+# Next we create an instance of vtkConeSource and set some of its
+# properties. The instance of vtkConeSource "cone" is part of a visualization
+# pipeline (it is a source process object); it produces data (output type is
+# vtkPolyData) which other filters may process.
+#
+vtkConeSource cone
+cone SetHeight 3.0
+cone SetRadius 1.0
+cone SetResolution 10
+
+#
+# In this example we terminate the pipeline with a mapper process object.
+# (Intermediate filters such as vtkShrinkPolyData could be inserted in
+# between the source and the mapper.)  We create an instance of
+# vtkPolyDataMapper to map the polygonal data into graphics primitives. We
+# connect the output of the cone souece to the input of this mapper.
+#
+vtkPolyDataMapper coneMapper
+coneMapper SetInputConnection [cone GetOutputPort]
+
+#
+# Create an actor to represent the cone. The actor orchestrates rendering of
+# the mapper's graphics primitives. An actor also refers to properties via a
+# vtkProperty instance, and includes an internal transformation matrix. We
+# set this actor's mapper to be coneMapper which we created above.
+#
+vtkActor coneActor
+coneActor SetMapper coneMapper
+
+#
+# Create the Renderer and assign actors to it. A renderer is like a
+# viewport. It is part or all of a window on the screen and it is responsible
+# for drawing the actors it has.  We also set the background color here.
+#
+vtkRenderer ren1
+ren1 AddActor coneActor
+ren1 SetBackground 0.1 0.2 0.4
+
+#
+# Finally we create the render window which will show up on the screen
+# We put our renderer into the render window using AddRenderer. We also
+# set the size to be 300 pixels by 300.
+#
+vtkRenderWindow renWin
+renWin AddRenderer ren1
+renWin SetSize 300 300
+
+#
+# Now we loop over 360 degreeees and render the cone each time.
+#
+for {set i 0} {$i < 360} {incr i} {
+   after 10
+   # render the image
+   renWin Render
+   # rotate the active camera by one degree
+   [ren1 GetActiveCamera] Azimuth 1
+}
+
+#
+# Free up any objects we created.
+#
+vtkCommand DeleteAllObjects
+
+#
+# Exit the application.
+#
+exit
+
+
+

ParaView-5.0.1/VTK/Examples/Tutorial/Step2/Cxx/CMakeLists.txt

@@ -0,0 +1,20 @@
+cmake_minimum_required(VERSION 2.8.5 FATAL_ERROR)
+if(POLICY CMP0025)
+  cmake_policy(SET CMP0025 NEW) # CMake 3.0
+endif()
+if(POLICY CMP0053)
+  cmake_policy(SET CMP0053 NEW) # CMake 3.1
+endif()
+
+project (Step2)
+
+find_package(VTK COMPONENTS
+  vtkCommonCore
+  vtkFiltersSources
+  vtkInteractionStyle
+  vtkRendering${VTK_RENDERING_BACKEND}
+)
+include(${VTK_USE_FILE})
+
+add_executable(Cone2 MACOSX_BUNDLE Cone2.cxx)
+target_link_libraries(Cone2 ${VTK_LIBRARIES})

ParaView-5.0.1/VTK/Examples/Tutorial/Step2/Cxx/Cone2.cxx

@@ -0,0 +1,105 @@
+/*=========================================================================
+
+  Program:   Visualization Toolkit
+  Module:    Cone2.cxx
+
+  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
+  All rights reserved.
+  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
+
+     This software is distributed WITHOUT ANY WARRANTY; without even
+     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+     PURPOSE.  See the above copyright notice for more information.
+
+=========================================================================*/
+//
+// This example shows how to add an observer to a C++ program. It extends
+// the Step1/Cxx/Cone.cxx C++ example (see that example for information on
+// the basic setup).
+//
+// VTK uses a command/observer design pattern. That is, observers watch for
+// particular events that any vtkObject (or subclass) may invoke on
+// itself. For example, the vtkRenderer invokes a "StartEvent" as it begins
+// to render. Here we add an observer that invokes a command when this event
+// is observed.
+//
+
+// first include the required header files for the vtk classes we are using
+#include "vtkConeSource.h"
+#include "vtkPolyDataMapper.h"
+#include "vtkRenderWindow.h"
+#include "vtkCommand.h"
+#include "vtkCamera.h"
+#include "vtkActor.h"
+#include "vtkRenderer.h"
+
+// Callback for the interaction
+class vtkMyCallback : public vtkCommand
+{
+public:
+  static vtkMyCallback *New()
+    { return new vtkMyCallback; }
+  virtual void Execute(vtkObject *caller, unsigned long, void*)
+    {
+      vtkRenderer *renderer = reinterpret_cast<vtkRenderer*>(caller);
+      cout << renderer->GetActiveCamera()->GetPosition()[0] << " "
+           << renderer->GetActiveCamera()->GetPosition()[1] << " "
+           << renderer->GetActiveCamera()->GetPosition()[2] << "\n";
+    }
+};
+
+int main()
+{
+  //
+  // The pipeline creation is documented in Step1
+  //
+  vtkConeSource *cone = vtkConeSource::New();
+  cone->SetHeight( 3.0 );
+  cone->SetRadius( 1.0 );
+  cone->SetResolution( 10 );
+
+  vtkPolyDataMapper *coneMapper = vtkPolyDataMapper::New();
+  coneMapper->SetInputConnection( cone->GetOutputPort() );
+  vtkActor *coneActor = vtkActor::New();
+  coneActor->SetMapper( coneMapper );
+
+  vtkRenderer *ren1= vtkRenderer::New();
+  ren1->AddActor( coneActor );
+  ren1->SetBackground( 0.1, 0.2, 0.4 );
+  ren1->ResetCamera();
+
+  vtkRenderWindow *renWin = vtkRenderWindow::New();
+  renWin->AddRenderer( ren1 );
+  renWin->SetSize( 300, 300 );
+
+  // Here is where we setup the observer, we do a new and ren1 will
+  // eventually free the observer
+  vtkMyCallback *mo1 = vtkMyCallback::New();
+  ren1->AddObserver(vtkCommand::StartEvent,mo1);
+  mo1->Delete();
+
+  //
+  // now we loop over 360 degrees and render the cone each time
+  //
+  int i;
+  for (i = 0; i < 360; ++i)
+    {
+    // render the image
+    renWin->Render();
+    // rotate the active camera by one degree
+    ren1->GetActiveCamera()->Azimuth( 1 );
+    }
+
+  //
+  // Free up any objects we created
+  //
+  cone->Delete();
+  coneMapper->Delete();
+  coneActor->Delete();
+  ren1->Delete();
+  renWin->Delete();
+
+  return 0;
+}
+
+

ParaView-5.0.1/VTK/Examples/Tutorial/Step2/Java/Cone2.java

@@ -0,0 +1,82 @@
+//
+// This example shows how to add an observer to a Java program. It extends
+// the Step1/Java/Cone.java Java example (see that example for information on
+// the basic setup).
+//
+// VTK uses a command/observer design pattern. That is, observers watch for
+// particular events that any vtkObject (or subclass) may invoke on
+// itself. For example, the vtkRenderer invokes a "StartEvent" as it begins
+// to render. Here we add an observer that invokes a command when this event
+// is observed.
+//
+//
+// Show how to add an observer to the Cone example
+//
+
+// we import the vtk wrapped classes forst
+import vtk.*;
+
+// then we define our class
+public class Cone2 {
+  // in the static contructor we load in the native code
+  // The libraries must be in your path to work
+  static {
+    System.loadLibrary("vtkCommonJava");
+    System.loadLibrary("vtkFilteringJava");
+    System.loadLibrary("vtkIOJava");
+    System.loadLibrary("vtkImagingJava");
+    System.loadLibrary("vtkGraphicsJava");
+    System.loadLibrary("vtkRenderingJava");
+  }
+
+  // Define the callback
+  public void myCallback()
+  {
+    System.out.println("Starting a render");
+  }
+
+  // now the main program
+  public static void main (String []args) {
+    //
+    // Now we create the pipeline as usual, see Cone.java in Step1 for details
+    //
+    vtkConeSource cone = new vtkConeSource();
+    cone.SetHeight( 3.0 );
+    cone.SetRadius( 1.0 );
+    cone.SetResolution( 10 );
+
+    vtkPolyDataMapper coneMapper = new vtkPolyDataMapper();
+    coneMapper.SetInputConnection( cone.GetOutputPort() );
+    vtkActor coneActor = new vtkActor();
+    coneActor.SetMapper( coneMapper );
+
+    vtkRenderer ren1 = new vtkRenderer();
+    ren1.AddActor( coneActor );
+    ren1.SetBackground( 0.1, 0.2, 0.4 );
+
+    // Add the observer here, the first argument is the event name
+    // the second argument is the instance to invoke the method on
+    // the third argument is which method to invoke
+    Cone2 me = new Cone2();
+    ren1.AddObserver("StartEvent",me,"myCallback");
+
+    // setup the window
+    vtkRenderWindow renWin = new vtkRenderWindow();
+    renWin.AddRenderer( ren1 );
+    renWin.SetSize( 300, 300 );
+
+    //
+    // now we loop over 360 degreeees and render the cone each time
+    //
+    int i;
+    for (i = 0; i < 360; ++i)
+      {
+      // render the image
+      renWin.Render();
+      // rotate the active camera by one degree
+      ren1.GetActiveCamera().Azimuth( 1 );
+      }
+
+    }
+}
+

ParaView-5.0.1/VTK/Examples/Tutorial/Step2/Python/Cone2.py

@@ -0,0 +1,59 @@
+#!/usr/bin/env python
+#
+#
+# This example shows how to add an observer to a Python program. It extends
+# the Step1/Python/Cone.py Python example (see that example for information on
+# the basic setup).
+#
+# VTK uses a command/observer design pattern. That is, observers watch for
+# particular events that any vtkObject (or subclass) may invoke on
+# itself. For example, the vtkRenderer invokes a "StartEvent" as it begins
+# to render. Here we add an observer that invokes a command when this event
+# is observed.
+#
+
+from __future__ import print_function
+import vtk
+import time
+
+#
+# define the callback
+#
+def myCallback(obj,string):
+    print("Starting a render")
+
+
+#
+# create the basic pipeline as in Step1
+#
+cone = vtk.vtkConeSource()
+cone.SetHeight( 3.0 )
+cone.SetRadius( 1.0 )
+cone.SetResolution( 10 )
+
+coneMapper = vtk.vtkPolyDataMapper()
+coneMapper.SetInputConnection( cone.GetOutputPort() )
+coneActor = vtk.vtkActor()
+coneActor.SetMapper( coneMapper )
+
+ren1= vtk.vtkRenderer()
+ren1.AddActor( coneActor )
+ren1.SetBackground( 0.1, 0.2, 0.4 )
+
+#
+# Add the observer here
+#
+ren1.AddObserver("StartEvent", myCallback)
+
+renWin = vtk.vtkRenderWindow()
+renWin.AddRenderer( ren1 )
+renWin.SetSize( 300, 300 )
+
+#
+# now we loop over 360 degreeees and render the cone each time
+#
+for i in range(0,360):
+    time.sleep(0.03)
+    renWin.Render()
+    ren1.GetActiveCamera().Azimuth( 1 )
+

ParaView-5.0.1/VTK/Examples/Tutorial/Step2/Tcl/Cone2.tcl

@@ -0,0 +1,72 @@
+#
+# This example shows how to add an observer to a Tcl program. It extends
+# the Step1/Tcl/Cone.tcl Tcl example (see that example for information on
+# the basic setup).
+#
+# VTK uses a command/observer design pattern. That is, observers watch for
+# particular events that any vtkObject (or subclass) may invoke on
+# itself. For example, the vtkRenderer invokes a "StartEvent" as it begins
+# to render. Here we add an observer that invokes a command when this event
+# is observed.
+#
+
+#
+# First we include the VTK Tcl packages which will make available
+# all of the vtk commands to Tcl
+#
+package require vtk
+
+#
+# Here we define our callback
+#
+proc myCallback {} {
+    puts "Starting to render"
+}
+
+#
+# Next we create the pipelinne
+#
+vtkConeSource cone
+cone SetHeight 3.0
+cone SetRadius 1.0
+cone SetResolution 10
+
+vtkPolyDataMapper coneMapper
+coneMapper SetInputConnection [cone GetOutputPort]
+vtkActor coneActor
+coneActor SetMapper coneMapper
+
+vtkRenderer ren1
+ren1 AddActor coneActor
+ren1 SetBackground 0.1 0.2 0.4
+
+# here we setup the callback
+ren1 AddObserver StartEvent myCallback
+
+vtkRenderWindow renWin
+renWin AddRenderer ren1
+renWin SetSize 300 300
+
+#
+# now we loop over 360 degreeees and render the cone each time
+#
+for {set i 0} {$i < 360} {incr i} {
+   after 10
+   # render the image
+   renWin Render
+   # rotate the active camera by one degree
+   [ren1 GetActiveCamera] Azimuth 1
+}
+
+#
+# Free up any objects we created
+#
+vtkCommand DeleteAllObjects
+
+#
+# exit the application
+#
+exit
+
+
+

ParaView-5.0.1/VTK/Examples/Tutorial/Step3/Cxx/CMakeLists.txt

@@ -0,0 +1,19 @@
+cmake_minimum_required(VERSION 2.8.5 FATAL_ERROR)
+if(POLICY CMP0025)
+  cmake_policy(SET CMP0025 NEW) # CMake 3.0
+endif()
+if(POLICY CMP0053)
+  cmake_policy(SET CMP0053 NEW) # CMake 3.1
+endif()
+
+project (Step3)
+
+find_package(VTK COMPONENTS
+  vtkFiltersSources
+  vtkInteractionStyle
+  vtkRendering${VTK_RENDERING_BACKEND}
+)
+include(${VTK_USE_FILE})
+
+add_executable(Cone3 MACOSX_BUNDLE Cone3.cxx)
+target_link_libraries(Cone3 ${VTK_LIBRARIES})

ParaView-5.0.1/VTK/Examples/Tutorial/Step3/Cxx/Cone3.cxx

@@ -0,0 +1,121 @@
+/*=========================================================================
+
+  Program:   Visualization Toolkit
+  Module:    Cone3.cxx
+
+  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
+  All rights reserved.
+  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
+
+     This software is distributed WITHOUT ANY WARRANTY; without even
+     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+     PURPOSE.  See the above copyright notice for more information.
+
+=========================================================================*/
+//
+// This example demonstrates how to use multiple renderers within a
+// render window. It is a variation of the Cone.cxx example. Please
+// refer to that example for additional documentation.
+//
+
+// First include the required header files for the VTK classes we are using.
+#include "vtkConeSource.h"
+#include "vtkPolyDataMapper.h"
+#include "vtkRenderWindow.h"
+#include "vtkCamera.h"
+#include "vtkActor.h"
+#include "vtkRenderer.h"
+
+int main()
+{
+  //
+  // Next we create an instance of vtkConeSource and set some of its
+  // properties. The instance of vtkConeSource "cone" is part of a
+  // visualization pipeline (it is a source process object); it produces data
+  // (output type is vtkPolyData) which other filters may process.
+  //
+  vtkConeSource *cone = vtkConeSource::New();
+  cone->SetHeight( 3.0 );
+  cone->SetRadius( 1.0 );
+  cone->SetResolution( 10 );
+
+  //
+  // In this example we terminate the pipeline with a mapper process object.
+  // (Intermediate filters such as vtkShrinkPolyData could be inserted in
+  // between the source and the mapper.)  We create an instance of
+  // vtkPolyDataMapper to map the polygonal data into graphics primitives. We
+  // connect the output of the cone souece to the input of this mapper.
+  //
+  vtkPolyDataMapper *coneMapper = vtkPolyDataMapper::New();
+  coneMapper->SetInputConnection( cone->GetOutputPort() );
+
+  //
+  // Create an actor to represent the cone. The actor orchestrates rendering
+  // of the mapper's graphics primitives. An actor also refers to properties
+  // via a vtkProperty instance, and includes an internal transformation
+  // matrix. We set this actor's mapper to be coneMapper which we created
+  // above.
+  //
+  vtkActor *coneActor = vtkActor::New();
+  coneActor->SetMapper( coneMapper );
+
+  //
+  // Create two renderers and assign actors to them. A renderer renders into
+  // a viewport within the vtkRenderWindow. It is part or all of a window on
+  // the screen and it is responsible for drawing the actors it has.  We also
+  // set the background color here. In this example we are adding the same
+  // actor to two different renderers; it is okay to add different actors to
+  // different renderers as well.
+  //
+  vtkRenderer *ren1= vtkRenderer::New();
+  ren1->AddActor( coneActor );
+  ren1->SetBackground( 0.1, 0.2, 0.4 );
+  ren1->SetViewport(0.0, 0.0, 0.5, 1.0);
+
+  vtkRenderer *ren2= vtkRenderer::New();
+  ren2->AddActor( coneActor );
+  ren2->SetBackground( 0.2, 0.3, 0.5 );
+  ren2->SetViewport(0.5, 0.0, 1.0, 1.0);
+
+  //
+  // Finally we create the render window which will show up on the screen.
+  // We put our renderer into the render window using AddRenderer. We also
+  // set the size to be 300 pixels by 300.
+  //
+  vtkRenderWindow *renWin = vtkRenderWindow::New();
+  renWin->AddRenderer( ren1 );
+  renWin->AddRenderer( ren2 );
+  renWin->SetSize( 600, 300 );
+
+  //
+  // Make one view 90 degrees from other.
+  //
+  ren1->ResetCamera();
+  ren1->GetActiveCamera()->Azimuth(90);
+
+  //
+  // Now we loop over 360 degreeees and render the cone each time.
+  //
+  int i;
+  for (i = 0; i < 360; ++i)
+    {
+    // render the image
+    renWin->Render();
+    // rotate the active camera by one degree
+    ren1->GetActiveCamera()->Azimuth( 1 );
+    ren2->GetActiveCamera()->Azimuth( 1 );
+    }
+
+  //
+  // Free up any objects we created. All instances in VTK are deleted by
+  // using the Delete() method.
+  //
+  cone->Delete();
+  coneMapper->Delete();
+  coneActor->Delete();
+  ren1->Delete();
+  ren2->Delete();
+  renWin->Delete();
+
+  return 0;
+}

ParaView-5.0.1/VTK/Examples/Tutorial/Step3/Java/Cone3.java

@@ -0,0 +1,105 @@
+//
+// This example demonstrates how to use multiple renderers within a
+// render window. It is a variation of the Cone.py example. Please
+// refer to that example for additional documentation.
+//
+
+import java.lang.Thread;
+
+// we import the vtk wrapped classes forst
+import vtk.*;
+
+// then we define our class
+public class Cone3 {
+  // in the static contructor we load in the native code
+  // The libraries must be in your path to work
+  static {
+    System.loadLibrary("vtkCommonJava");
+    System.loadLibrary("vtkFilteringJava");
+    System.loadLibrary("vtkIOJava");
+    System.loadLibrary("vtkImagingJava");
+    System.loadLibrary("vtkGraphicsJava");
+    System.loadLibrary("vtkRenderingJava");
+  }
+
+  // now the main program
+  public static void main (String []args) throws Exception {
+    //
+    // Next we create an instance of vtkConeSource and set some of its
+    // properties. The instance of vtkConeSource "cone" is part of a
+    // visualization pipeline (it is a source process object); it produces
+    // data (output type is vtkPolyData) which other filters may process.
+    //
+    vtkConeSource cone = new vtkConeSource();
+    cone.SetHeight( 3.0 );
+    cone.SetRadius( 1.0 );
+    cone.SetResolution( 10 );
+
+    //
+    // In this example we terminate the pipeline with a mapper process object.
+    // (Intermediate filters such as vtkShrinkPolyData could be inserted in
+    // between the source and the mapper.)  We create an instance of
+    // vtkPolyDataMapper to map the polygonal data into graphics primitives. We
+    // connect the output of the cone souece to the input of this mapper.
+    //
+    vtkPolyDataMapper coneMapper = new vtkPolyDataMapper();
+    coneMapper.SetInputConnection(cone.GetOutputPort());
+
+    //
+    // Create an actor to represent the cone. The actor orchestrates rendering of
+    // the mapper's graphics primitives. An actor also refers to properties via a
+    // vtkProperty instance, and includes an internal transformation matrix. We
+    // set this actor's mapper to be coneMapper which we created above.
+    //
+    vtkActor coneActor = new vtkActor();
+    coneActor.SetMapper(coneMapper);
+
+    //
+    // Create two renderers and assign actors to them. A renderer renders into a
+    // viewport within the vtkRenderWindow. It is part or all of a window on the
+    // screen and it is responsible for drawing the actors it has.  We also set
+    // the background color here. In this example we are adding the same actor
+    // to two different renderers; it is okay to add different actors to
+    // different renderers as well.
+    //
+    vtkRenderer ren1 = new vtkRenderer();
+    ren1.AddActor(coneActor);
+    ren1.SetBackground(0.1, 0.2, 0.4);
+    ren1.SetViewport(0.0, 0.0, 0.5, 1.0);
+
+    vtkRenderer ren2 = new vtkRenderer();
+    ren2.AddActor(coneActor);
+    ren2.SetBackground(0.1, 0.2, 0.4);
+    ren2.SetViewport(0.5, 0.0, 1.0, 1.0);
+
+    //
+    // Finally we create the render window which will show up on the screen.
+    // We add our two renderers into the render window using AddRenderer. We also
+    // set the size to be 600 pixels by 300.
+    //
+    vtkRenderWindow renWin = new vtkRenderWindow();
+    renWin.AddRenderer( ren1 );
+    renWin.AddRenderer( ren2 );
+    renWin.SetSize(600, 300);
+
+    //
+    // Make one camera view 90 degrees from other.
+    //
+    ren1.ResetCamera();
+    ren1.GetActiveCamera().Azimuth(90);
+
+    //
+    // now we loop over 360 degreeees and render the cone each time
+    //
+    int i;
+    for (i = 0; i < 360; ++i)
+      {
+      Thread.sleep(10);
+      // render the image
+      renWin.Render();
+      // rotate the active camera by one degree
+      ren1.GetActiveCamera().Azimuth( 1 );
+      ren2.GetActiveCamera().Azimuth( 1 );
+      }
+    }
+}

ParaView-5.0.1/VTK/Examples/Tutorial/Step3/Python/Cone3.py

@@ -0,0 +1,83 @@
+#!/usr/bin/env python
+#
+# This example demonstrates how to use multiple renderers within a
+# render window. It is a variation of the Cone.py example. Please
+# refer to that example for additional documentation.
+#
+
+import vtk
+import time
+
+#
+# Next we create an instance of vtkConeSource and set some of its
+# properties. The instance of vtkConeSource "cone" is part of a visualization
+# pipeline (it is a source process object); it produces data (output type is
+# vtkPolyData) which other filters may process.
+#
+cone = vtk.vtkConeSource()
+cone.SetHeight( 3.0 )
+cone.SetRadius( 1.0 )
+cone.SetResolution( 10 )
+
+#
+# In this example we terminate the pipeline with a mapper process object.
+# (Intermediate filters such as vtkShrinkPolyData could be inserted in
+# between the source and the mapper.)  We create an instance of
+# vtkPolyDataMapper to map the polygonal data into graphics primitives. We
+# connect the output of the cone souece to the input of this mapper.
+#
+coneMapper = vtk.vtkPolyDataMapper()
+coneMapper.SetInputConnection(cone.GetOutputPort())
+
+#
+# Create an actor to represent the cone. The actor orchestrates rendering of
+# the mapper's graphics primitives. An actor also refers to properties via a
+# vtkProperty instance, and includes an internal transformation matrix. We
+# set this actor's mapper to be coneMapper which we created above.
+#
+coneActor = vtk.vtkActor()
+coneActor.SetMapper(coneMapper)
+
+#
+# Create two renderers and assign actors to them. A renderer renders into a
+# viewport within the vtkRenderWindow. It is part or all of a window on the
+# screen and it is responsible for drawing the actors it has.  We also set
+# the background color here. In this example we are adding the same actor
+# to two different renderers; it is okay to add different actors to
+# different renderers as well.
+#
+ren1 = vtk.vtkRenderer()
+ren1.AddActor(coneActor)
+ren1.SetBackground(0.1, 0.2, 0.4)
+ren1.SetViewport(0.0, 0.0, 0.5, 1.0)
+
+ren2 = vtk.vtkRenderer()
+ren2.AddActor(coneActor)
+ren2.SetBackground(0.1, 0.2, 0.4)
+ren2.SetViewport(0.5, 0.0, 1.0, 1.0)
+
+#
+# Finally we create the render window which will show up on the screen.
+# We add our two renderers into the render window using AddRenderer. We also
+# set the size to be 600 pixels by 300.
+#
+renWin = vtk.vtkRenderWindow()
+renWin.AddRenderer( ren1 )
+renWin.AddRenderer( ren2 )
+renWin.SetSize(600, 300)
+
+#
+# Make one camera view 90 degrees from other.
+#
+ren1.ResetCamera()
+ren1.GetActiveCamera().Azimuth(90)
+
+#
+# Now we loop over 360 degreeees and render the cone each time.
+#
+for i in range(0,360):
+    time.sleep(0.03)
+
+    renWin.Render()
+    ren1.GetActiveCamera().Azimuth( 1 )
+    ren2.GetActiveCamera().Azimuth( 1 )

ParaView-5.0.1/VTK/Examples/Tutorial/Step3/Tcl/Cone3.tcl

@@ -0,0 +1,97 @@
+#
+# This example demonstrates how to use multiple renderers within a
+# render window. It is a variation of the Cone.tcl example. Please
+# refer to that example for additional documentation.
+#
+
+#
+# First we include the VTK Tcl packages which will make available
+# all of the VTK commands to Tcl.
+#
+package require vtk
+
+#
+# Next we create an instance of vtkConeSource and set some of its
+# properties. The instance of vtkConeSource "cone" is part of a visualization
+# pipeline (it is a source process object); it produces data (output type is
+# vtkPolyData) which other filters may process.
+#
+vtkConeSource cone
+cone SetHeight 3.0
+cone SetRadius 1.0
+cone SetResolution 10
+
+#
+# In this example we terminate the pipeline with a mapper process object.
+# (Intermediate filters such as vtkShrinkPolyData could be inserted in
+# between the source and the mapper.)  We create an instance of
+# vtkPolyDataMapper to map the polygonal data into graphics primitives. We
+# connect the output of the cone souece to the input of this mapper.
+#
+vtkPolyDataMapper coneMapper
+coneMapper SetInputConnection [cone GetOutputPort]
+
+#
+# Create an actor to represent the cone. The actor orchestrates rendering of
+# the mapper's graphics primitives. An actor also refers to properties via a
+# vtkProperty instance, and includes an internal transformation matrix. We
+# set this actor's mapper to be coneMapper which we created above.
+#
+vtkActor coneActor
+coneActor SetMapper coneMapper
+
+#
+# Create two renderers and assign actors to them. A renderer renders into a
+# viewport within the vtkRenderWindow. It is part or all of a window on the
+# screen and it is responsible for drawing the actors it has.  We also set
+# the background color here. In this example we are adding the same actor
+# to two different renderers; it is okay to add different actors to
+# different renderers as well.
+#
+vtkRenderer ren1
+ren1 AddActor coneActor
+ren1 SetBackground 0.1 0.2 0.4
+ren1 SetViewport 0.0 0.0 0.5 1.0
+
+vtkRenderer ren2
+ren2 AddActor coneActor
+ren2 SetBackground 0.1 0.2 0.4
+ren2 SetViewport 0.5 0.0 1.0 1.0
+
+#
+# Finally we create the render window which will show up on the screen.
+# We add our two renderers into the render window using AddRenderer. We also
+# set the size to be 600 pixels by 300.
+#
+vtkRenderWindow renWin
+renWin AddRenderer ren1
+renWin AddRenderer ren2
+renWin SetSize 600 300
+
+#
+# Make one camera view 90 degrees from other.
+#
+ren1 ResetCamera
+[ren1 GetActiveCamera] Azimuth 90
+
+#
+# Now we loop over 360 degreeees and render the cone each time.
+#
+for {set i 0} {$i < 360} {incr i} {
+   after 10
+   # render the image
+   renWin Render
+   # rotate the active camera by one degree
+   [ren1 GetActiveCamera] Azimuth 1
+   [ren2 GetActiveCamera] Azimuth 1
+}
+
+#
+# Free up any objects we created.
+#
+vtkCommand DeleteAllObjects
+
+#
+# Exit the application.
+#
+exit

ParaView-5.0.1/VTK/Examples/Tutorial/Step4/Cxx/CMakeLists.txt

@@ -0,0 +1,19 @@
+cmake_minimum_required(VERSION 2.8.5 FATAL_ERROR)
+if(POLICY CMP0025)
+  cmake_policy(SET CMP0025 NEW) # CMake 3.0
+endif()
+if(POLICY CMP0053)
+  cmake_policy(SET CMP0053 NEW) # CMake 3.1
+endif()
+
+project (Step4)
+
+find_package(VTK COMPONENTS
+  vtkFiltersSources
+  vtkInteractionStyle
+  vtkRendering${VTK_RENDERING_BACKEND}
+)
+include(${VTK_USE_FILE})
+
+add_executable(Cone4 MACOSX_BUNDLE Cone4.cxx)
+target_link_libraries(Cone4 ${VTK_LIBRARIES})

ParaView-5.0.1/VTK/Examples/Tutorial/Step4/Cxx/Cone4.cxx

@@ -0,0 +1,134 @@
+/*=========================================================================
+
+  Program:   Visualization Toolkit
+  Module:    Cone4.cxx
+
+  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
+  All rights reserved.
+  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
+
+     This software is distributed WITHOUT ANY WARRANTY; without even
+     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+     PURPOSE.  See the above copyright notice for more information.
+
+=========================================================================*/
+//
+// This example demonstrates the creation of multiple actors and the
+// manipulation of their properties and transformations. It is a
+// derivative of Cone.tcl, see that example for more information.
+//
+
+// First include the required header files for the VTK classes we are using.
+#include "vtkConeSource.h"
+#include "vtkPolyDataMapper.h"
+#include "vtkRenderWindow.h"
+#include "vtkCamera.h"
+#include "vtkActor.h"
+#include "vtkRenderer.h"
+#include "vtkProperty.h"
+
+int main()
+{
+  //
+  // Next we create an instance of vtkConeSource and set some of its
+  // properties. The instance of vtkConeSource "cone" is part of a
+  // visualization pipeline (it is a source process object); it produces data
+  // (output type is vtkPolyData) which other filters may process.
+  //
+  vtkConeSource *cone = vtkConeSource::New();
+  cone->SetHeight( 3.0 );
+  cone->SetRadius( 1.0 );
+  cone->SetResolution( 10 );
+
+  //
+  // In this example we terminate the pipeline with a mapper process object.
+  // (Intermediate filters such as vtkShrinkPolyData could be inserted in
+  // between the source and the mapper.)  We create an instance of
+  // vtkPolyDataMapper to map the polygonal data into graphics primitives. We
+  // connect the output of the cone souece to the input of this mapper.
+  //
+  vtkPolyDataMapper *coneMapper = vtkPolyDataMapper::New();
+  coneMapper->SetInputConnection( cone->GetOutputPort() );
+
+  //
+  // Create an actor to represent the first cone. The actor's properties are
+  // modified to give it different surface properties. By default, an actor
+  // is create with a property so the GetProperty() method can be used.
+  //
+  vtkActor *coneActor = vtkActor::New();
+  coneActor->SetMapper( coneMapper );
+  coneActor->GetProperty()->SetColor(0.2, 0.63, 0.79);
+  coneActor->GetProperty()->SetDiffuse(0.7);
+  coneActor->GetProperty()->SetSpecular(0.4);
+  coneActor->GetProperty()->SetSpecularPower(20);
+
+  //
+  // Create a property and directly manipulate it. Assign it to the
+  // second actor.
+  //
+  vtkProperty *property = vtkProperty::New();
+  property->SetColor(1.0, 0.3882, 0.2784);
+  property->SetDiffuse(0.7);
+  property->SetSpecular(0.4);
+  property->SetSpecularPower(20);
+
+  //
+  // Create a second actor and a property. The property is directly
+  // manipulated and then assigned to the actor. In this way, a single
+  // property can be shared among many actors. Note also that we use the
+  // same mapper as the first actor did. This way we avoid duplicating
+  // geometry, which may save lots of memory if the geoemtry is large.
+  vtkActor *coneActor2 = vtkActor::New();
+  coneActor2->SetMapper(coneMapper);
+  coneActor2->GetProperty()->SetColor(0.2, 0.63, 0.79);
+  coneActor2->SetProperty(property);
+  coneActor2->SetPosition(0, 2, 0);
+
+  //
+  // Create the Renderer and assign actors to it. A renderer is like a
+  // viewport. It is part or all of a window on the screen and it is
+  // responsible for drawing the actors it has.  We also set the background
+  // color here.
+  //
+  vtkRenderer *ren1= vtkRenderer::New();
+  ren1->AddActor( coneActor );
+  ren1->AddActor( coneActor2 );
+  ren1->SetBackground( 0.1, 0.2, 0.4 );
+
+  //
+  // Finally we create the render window which will show up on the screen.
+  // We put our renderer into the render window using AddRenderer. We also
+  // set the size to be 300 pixels by 300.
+  //
+  vtkRenderWindow *renWin = vtkRenderWindow::New();
+  renWin->AddRenderer( ren1 );
+  renWin->SetSize( 300, 300 );
+
+  //
+  // Now we loop over 360 degreeees and render the cone each time.
+  //
+  int i;
+  for (i = 0; i < 360; ++i)
+    {
+    // render the image
+    renWin->Render();
+    // rotate the active camera by one degree
+    ren1->GetActiveCamera()->Azimuth( 1 );
+    }
+
+  //
+  // Free up any objects we created. All instances in VTK are deleted by
+  // using the Delete() method.
+  //
+  cone->Delete();
+  coneMapper->Delete();
+  coneActor->Delete();
+  property->Delete();
+  coneActor2->Delete();
+  ren1->Delete();
+  renWin->Delete();
+
+  return 0;
+}
+
+

ParaView-5.0.1/VTK/Examples/Tutorial/Step4/Java/Cone4.java

@@ -0,0 +1,122 @@
+//
+// This example demonstrates the creation of multiple actors and the
+// manipulation of their properties and transformations. It is a
+// derivative of Cone.py, see that example for more information.
+//
+
+import java.lang.Thread;
+
+// we import the vtk wrapped classes forst
+import vtk.*;
+
+// then we define our class
+public class Cone4 {
+  // in the static contructor we load in the native code
+  // The libraries must be in your path to work
+  static {
+    System.loadLibrary("vtkCommonJava");
+    System.loadLibrary("vtkFilteringJava");
+    System.loadLibrary("vtkIOJava");
+    System.loadLibrary("vtkImagingJava");
+    System.loadLibrary("vtkGraphicsJava");
+    System.loadLibrary("vtkRenderingJava");
+  }
+
+  // now the main program
+  public static void main (String []args) throws Exception {
+    //
+    // Next we create an instance of vtkConeSource and set some of its
+    // properties. The instance of vtkConeSource "cone" is part of a
+    // visualization pipeline (it is a source process object); it produces
+    // data (output type is vtkPolyData) which other filters may process.
+    //
+    vtkConeSource cone = new vtkConeSource();
+    cone.SetHeight( 3.0 );
+    cone.SetRadius( 1.0 );
+    cone.SetResolution( 10 );
+
+    //
+    // In this example we terminate the pipeline with a mapper process object.
+    // (Intermediate filters such as vtkShrinkPolyData could be inserted in
+    // between the source and the mapper.)  We create an instance of
+    // vtkPolyDataMapper to map the polygonal data into graphics primitives. We
+    // connect the output of the cone souece to the input of this mapper.
+    //
+    vtkPolyDataMapper coneMapper = new vtkPolyDataMapper();
+    coneMapper.SetInputConnection(cone.GetOutputPort());
+
+    //
+    // Create an actor to represent the first cone. The actor's properties are
+    // modified to give it different surface properties. By default, an actor
+    // is create with a property so the GetProperty() method can be used.
+    //
+    vtkActor coneActor = new vtkActor();
+    coneActor.SetMapper(coneMapper);
+    coneActor.GetProperty().SetColor(0.2, 0.63, 0.79);
+    coneActor.GetProperty().SetDiffuse(0.7);
+    coneActor.GetProperty().SetSpecular(0.4);
+    coneActor.GetProperty().SetSpecularPower(20);
+
+    //
+    // Create a property and directly manipulate it. Assign it to the
+    // second actor.
+    //
+    vtkProperty property = new vtkProperty();
+    property.SetColor(1.0, 0.3882, 0.2784);
+    property.SetDiffuse(0.7);
+    property.SetSpecular(0.4);
+    property.SetSpecularPower(20);
+
+    //
+    // Create a second actor and a property. The property is directly
+    // manipulated and then assigned to the actor. In this way, a single
+    // property can be shared among many actors. Note also that we use the
+    // same mapper as the first actor did. This way we avoid duplicating
+    // geometry, which may save lots of memory if the geoemtry is large.
+    vtkActor coneActor2 = new vtkActor();
+    coneActor2.SetMapper(coneMapper);
+    coneActor2.GetProperty().SetColor(0.2, 0.63, 0.79);
+    coneActor2.SetProperty(property);
+    coneActor2.SetPosition(0, 2, 0);
+
+    //
+    // Create the Renderer and assign actors to it. A renderer is like a
+    // viewport. It is part or all of a window on the screen and it is
+    // responsible for drawing the actors it has.  We also set the
+    // background color here.
+    //
+    vtkRenderer ren1 = new vtkRenderer();
+    ren1.AddActor(coneActor);
+    ren1.AddActor(coneActor2);
+    ren1.SetBackground(0.1, 0.2, 0.4);
+
+    //
+    // Finally we create the render window which will show up on the screen.
+    // We add our two renderers into the render window using AddRenderer. We also
+    // set the size to be 600 pixels by 300.
+    //
+    vtkRenderWindow renWin = new vtkRenderWindow();
+    renWin.AddRenderer( ren1 );
+    renWin.SetSize(300, 300);
+
+    //
+    // Make one camera view 90 degrees from other.
+    //
+    ren1.ResetCamera();
+    ren1.GetActiveCamera().Azimuth(90);
+
+    //
+    // now we loop over 360 degreeees and render the cone each time
+    //
+    int i;
+    for (i = 0; i < 360; ++i)
+      {
+      Thread.sleep(10);
+      // render the image
+      renWin.Render();
+      // rotate the active camera by one degree
+      ren1.GetActiveCamera().Azimuth( 1 );
+      }
+    }
+}
+

ParaView-5.0.1/VTK/Examples/Tutorial/Step4/Python/Cone4.py

@@ -0,0 +1,93 @@
+#!/usr/bin/env python
+#
+# This example demonstrates the creation of multiple actors and the
+# manipulation of their properties and transformations. It is a
+# derivative of Cone.py, see that example for more information.
+#
+
+import vtk
+import time
+
+#
+# Next we create an instance of vtkConeSource and set some of its
+# properties. The instance of vtkConeSource "cone" is part of a visualization
+# pipeline (it is a source process object); it produces data (output type is
+# vtkPolyData) which other filters may process.
+#
+cone = vtk.vtkConeSource ()
+cone.SetHeight( 3.0 )
+cone.SetRadius( 1.0 )
+cone.SetResolution( 10 )
+
+#
+# In this example we terminate the pipeline with a mapper process object.
+# (Intermediate filters such as vtkShrinkPolyData could be inserted in
+# between the source and the mapper.)  We create an instance of
+# vtkPolyDataMapper to map the polygonal data into graphics primitives. We
+# connect the output of the cone souece to the input of this mapper.
+#
+coneMapper = vtk.vtkPolyDataMapper()
+coneMapper.SetInputConnection(cone.GetOutputPort())
+
+#
+# Create an actor to represent the first cone. The actor's properties are
+# modified to give it different surface properties. By default, an actor
+# is create with a property so the GetProperty() method can be used.
+#
+coneActor = vtk.vtkActor()
+coneActor.SetMapper(coneMapper)
+coneActor.GetProperty().SetColor(0.2, 0.63, 0.79)
+coneActor.GetProperty().SetDiffuse(0.7)
+coneActor.GetProperty().SetSpecular(0.4)
+coneActor.GetProperty().SetSpecularPower(20)
+
+#
+# Create a property and directly manipulate it. Assign it to the
+# second actor.
+#
+property = vtk.vtkProperty()
+property.SetColor(1.0, 0.3882, 0.2784)
+property.SetDiffuse(0.7)
+property.SetSpecular(0.4)
+property.SetSpecularPower(20)
+
+#
+# Create a second actor and a property. The property is directly
+# manipulated and then assigned to the actor. In this way, a single
+# property can be shared among many actors. Note also that we use the
+# same mapper as the first actor did. This way we avoid duplicating
+# geometry, which may save lots of memory if the geoemtry is large.
+coneActor2 = vtk.vtkActor()
+coneActor2.SetMapper(coneMapper)
+coneActor2.GetProperty().SetColor(0.2, 0.63, 0.79)
+coneActor2.SetProperty(property)
+coneActor2.SetPosition(0, 2, 0)
+
+#
+# Create the Renderer and assign actors to it. A renderer is like a
+# viewport. It is part or all of a window on the screen and it is responsible
+# for drawing the actors it has.  We also set the background color here.
+#
+ren1 = vtk.vtkRenderer()
+ren1.AddActor(coneActor)
+ren1.AddActor(coneActor2)
+ren1.SetBackground(0.1, 0.2, 0.4)
+
+#
+# Finally we create the render window which will show up on the screen
+# We put our renderer into the render window using AddRenderer. We also
+# set the size to be 300 pixels by 300.
+#
+renWin = vtk.vtkRenderWindow()
+renWin.AddRenderer(ren1)
+renWin.SetSize(300, 300)
+
+#
+# Now we loop over 360 degreeees and render the cone each time.
+#
+for i in range(0,360):
+    time.sleep(0.03)
+
+    renWin.Render()
+    ren1.GetActiveCamera().Azimuth( 1 )
+

ParaView-5.0.1/VTK/Examples/Tutorial/Step4/Tcl/Cone4.tcl

@@ -0,0 +1,109 @@
+#
+# This example demonstrates the creation of multiple actors and the
+# manipulation of their properties and transformations. It is a
+# derivative of Cone.tcl, see that example for more information.
+#
+
+#
+# First we include the VTK Tcl packages which will make available
+# all of the VTK commands to Tcl.
+#
+package require vtk
+
+#
+# Next we create an instance of vtkConeSource and set some of its
+# properties. The instance of vtkConeSource "cone" is part of a visualization
+# pipeline (it is a source process object); it produces data (output type is
+# vtkPolyData) which other filters may process.
+#
+vtkConeSource cone
+cone SetHeight 3.0
+cone SetRadius 1.0
+cone SetResolution 10
+
+#
+# In this example we terminate the pipeline with a mapper process object.
+# (Intermediate filters such as vtkShrinkPolyData could be inserted in
+# between the source and the mapper.)  We create an instance of
+# vtkPolyDataMapper to map the polygonal data into graphics primitives. We
+# connect the output of the cone souece to the input of this mapper.
+#
+vtkPolyDataMapper coneMapper
+coneMapper SetInputConnection [cone GetOutputPort]
+
+#
+# Create an actor to represent the first cone. The actor's properties are
+# modified to give it different surface properties. By default, an actor
+# is create with a property so the GetProperty() method can be used.
+#
+vtkActor coneActor
+coneActor SetMapper coneMapper
+[coneActor GetProperty] SetColor 0.2 0.63 0.79
+[coneActor GetProperty] SetDiffuse 0.7
+[coneActor GetProperty] SetSpecular 0.4
+[coneActor GetProperty] SetSpecularPower 20
+
+#
+# Create a property and directly manipulate it. Assign it to the
+# second actor.
+#
+vtkProperty property
+property SetColor 1.0 0.3882 0.2784
+property SetDiffuse 0.7
+property SetSpecular 0.4
+property SetSpecularPower 20
+
+#
+# Create a second actor and a property. The property is directly
+# manipulated and then assigned to the actor. In this way, a single
+# property can be shared among many actors. Note also that we use the
+# same mapper as the first actor did. This way we avoid duplicating
+# geometry, which may save lots of memory if the geoemtry is large.
+vtkActor coneActor2
+coneActor2 SetMapper coneMapper
+[coneActor2 GetProperty] SetColor 0.2 0.63 0.79
+coneActor2 SetProperty property
+coneActor2 SetPosition 0 2 0
+
+#
+# Create the Renderer and assign actors to it. A renderer is like a
+# viewport. It is part or all of a window on the screen and it is responsible
+# for drawing the actors it has.  We also set the background color here.
+#
+vtkRenderer ren1
+ren1 AddActor coneActor
+ren1 AddActor coneActor2
+ren1 SetBackground 0.1 0.2 0.4
+
+#
+# Finally we create the render window which will show up on the screen
+# We put our renderer into the render window using AddRenderer. We also
+# set the size to be 300 pixels by 300.
+#
+vtkRenderWindow renWin
+renWin AddRenderer ren1
+renWin SetSize 300 300
+
+#
+# Now we loop over 360 degreeees and render the cone each time.
+#
+for {set i 0} {$i < 360} {incr i} {
+   after 10
+   # render the image
+   renWin Render
+   # rotate the active camera by one degree
+   [ren1 GetActiveCamera] Azimuth 1
+}
+
+#
+# Free up any objects we created.
+#
+vtkCommand DeleteAllObjects
+
+#
+# Exit the application.
+#
+exit
+
+
+

ParaView-5.0.1/VTK/Examples/Tutorial/Step5/Cxx/CMakeLists.txt

@@ -0,0 +1,20 @@
+cmake_minimum_required(VERSION 2.8.5 FATAL_ERROR)
+if(POLICY CMP0025)
+  cmake_policy(SET CMP0025 NEW) # CMake 3.0
+endif()
+if(POLICY CMP0053)
+  cmake_policy(SET CMP0053 NEW) # CMake 3.1
+endif()
+
+PROJECT (Step5)
+
+find_package(VTK COMPONENTS
+  vtkCommonCore
+  vtkFiltersSources
+  vtkInteractionStyle
+  vtkRendering${VTK_RENDERING_BACKEND}
+)
+include(${VTK_USE_FILE})
+
+add_executable(Cone5 MACOSX_BUNDLE Cone5.cxx)
+target_link_libraries(Cone5 ${VTK_LIBRARIES})

ParaView-5.0.1/VTK/Examples/Tutorial/Step5/Cxx/Cone5.cxx

@@ -0,0 +1,136 @@
+/*=========================================================================
+
+  Program:   Visualization Toolkit
+  Module:    Cone5.cxx
+
+  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
+  All rights reserved.
+  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
+
+     This software is distributed WITHOUT ANY WARRANTY; without even
+     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+     PURPOSE.  See the above copyright notice for more information.
+
+=========================================================================*/
+//
+// This example introduces the concepts of interaction into the
+// C++ environment. A different interaction style (than
+// the default) is defined.
+//
+
+// First include the required header files for the VTK classes we are using.
+#include "vtkConeSource.h"
+#include "vtkPolyDataMapper.h"
+#include "vtkRenderWindow.h"
+#include "vtkRenderWindowInteractor.h"
+#include "vtkCamera.h"
+#include "vtkActor.h"
+#include "vtkRenderer.h"
+#include "vtkInteractorStyleTrackballCamera.h"
+
+int main()
+{
+  //
+  // Next we create an instance of vtkConeSource and set some of its
+  // properties. The instance of vtkConeSource "cone" is part of a
+  // visualization pipeline (it is a source process object); it produces data
+  // (output type is vtkPolyData) which other filters may process.
+  //
+  vtkConeSource *cone = vtkConeSource::New();
+  cone->SetHeight( 3.0 );
+  cone->SetRadius( 1.0 );
+  cone->SetResolution( 10 );
+
+  //
+  // In this example we terminate the pipeline with a mapper process object.
+  // (Intermediate filters such as vtkShrinkPolyData could be inserted in
+  // between the source and the mapper.)  We create an instance of
+  // vtkPolyDataMapper to map the polygonal data into graphics primitives. We
+  // connect the output of the cone souece to the input of this mapper.
+  //
+  vtkPolyDataMapper *coneMapper = vtkPolyDataMapper::New();
+  coneMapper->SetInputConnection( cone->GetOutputPort() );
+
+  //
+  // Create an actor to represent the cone. The actor orchestrates rendering
+  // of the mapper's graphics primitives. An actor also refers to properties
+  // via a vtkProperty instance, and includes an internal transformation
+  // matrix. We set this actor's mapper to be coneMapper which we created
+  // above.
+  //
+  vtkActor *coneActor = vtkActor::New();
+  coneActor->SetMapper( coneMapper );
+
+  //
+  // Create the Renderer and assign actors to it. A renderer is like a
+  // viewport. It is part or all of a window on the screen and it is
+  // responsible for drawing the actors it has.  We also set the background
+  // color here.
+  //
+  vtkRenderer *ren1= vtkRenderer::New();
+  ren1->AddActor( coneActor );
+  ren1->SetBackground( 0.1, 0.2, 0.4 );
+
+  //
+  // Finally we create the render window which will show up on the screen.
+  // We put our renderer into the render window using AddRenderer. We also
+  // set the size to be 300 pixels by 300.
+  //
+  vtkRenderWindow *renWin = vtkRenderWindow::New();
+  renWin->AddRenderer( ren1 );
+  renWin->SetSize( 300, 300 );
+
+  //
+  // The vtkRenderWindowInteractor class watches for events (e.g., keypress,
+  // mouse) in the vtkRenderWindow. These events are translated into
+  // event invocations that VTK understands (see VTK/Common/vtkCommand.h
+  // for all events that VTK processes). Then observers of these VTK
+  // events can process them as appropriate.
+  vtkRenderWindowInteractor *iren = vtkRenderWindowInteractor::New();
+  iren->SetRenderWindow(renWin);
+
+  //
+  // By default the vtkRenderWindowInteractor instantiates an instance
+  // of vtkInteractorStyle. vtkInteractorStyle translates a set of events
+  // it observes into operations on the camera, actors, and/or properties
+  // in the vtkRenderWindow associated with the vtkRenderWinodwInteractor.
+  // Here we specify a particular interactor style.
+  vtkInteractorStyleTrackballCamera *style =
+    vtkInteractorStyleTrackballCamera::New();
+  iren->SetInteractorStyle(style);
+
+  //
+  // Unlike the previous scripts where we performed some operations and then
+  // exited, here we leave an event loop running. The user can use the mouse
+  // and keyboard to perform the operations on the scene according to the
+  // current interaction style. When the user presses the "e" key, by default
+  // an ExitEvent is invoked by the vtkRenderWindowInteractor which is caught
+  // and drops out of the event loop (triggered by the Start() method that
+  // follows.
+  //
+  iren->Initialize();
+  iren->Start();
+
+  //
+  // Final note: recall that an observers can watch for particular events and
+  // take appropriate action. Pressing "u" in the render window causes the
+  // vtkRenderWindowInteractor to invoke a UserEvent. This can be caught to
+  // popup a GUI, etc. So the Tcl Cone5.tcl example for an idea of how this
+  // works.
+
+  //
+  // Free up any objects we created. All instances in VTK are deleted by
+  // using the Delete() method.
+  //
+  cone->Delete();
+  coneMapper->Delete();
+  coneActor->Delete();
+  ren1->Delete();
+  renWin->Delete();
+  iren->Delete();
+  style->Delete();
+
+  return 0;
+}
+
+

ParaView-5.0.1/VTK/Examples/Tutorial/Step5/Java/Cone5.java

@@ -0,0 +1,117 @@
+//
+// This example introduces the concepts of user interaction with VTK.
+// First, a different interaction style (than the default) is defined.
+// Second, the interaction is started.
+//
+//
+
+// we import the vtk wrapped classes forst
+import vtk.*;
+
+// then we define our class
+public class Cone5 {
+  // in the static contructor we load in the native code
+  // The libraries must be in your path to work
+  static {
+    System.loadLibrary("vtkCommonJava");
+    System.loadLibrary("vtkFilteringJava");
+    System.loadLibrary("vtkIOJava");
+    System.loadLibrary("vtkImagingJava");
+    System.loadLibrary("vtkGraphicsJava");
+    System.loadLibrary("vtkRenderingJava");
+  }
+
+  // now the main program
+  public static void main (String []args) throws Exception {
+    //
+    // Next we create an instance of vtkConeSource and set some of its
+    // properties. The instance of vtkConeSource "cone" is part of a
+    // visualization pipeline (it is a source process object); it produces
+    // data (output type is vtkPolyData) which other filters may process.
+    //
+    vtkConeSource cone = new vtkConeSource();
+    cone.SetHeight( 3.0 );
+    cone.SetRadius( 1.0 );
+    cone.SetResolution( 10 );
+
+    //
+    // In this example we terminate the pipeline with a mapper process object.
+    // (Intermediate filters such as vtkShrinkPolyData could be inserted in
+    // between the source and the mapper.)  We create an instance of
+    // vtkPolyDataMapper to map the polygonal data into graphics primitives. We
+    // connect the output of the cone souece to the input of this mapper.
+    //
+    vtkPolyDataMapper coneMapper = new vtkPolyDataMapper();
+    coneMapper.SetInputConnection(cone.GetOutputPort());
+
+    //
+    // Create an actor to represent the cone. The actor orchestrates rendering of
+    // the mapper's graphics primitives. An actor also refers to properties via a
+    // vtkProperty instance, and includes an internal transformation matrix. We
+    // set this actor's mapper to be coneMapper which we created above.
+    //
+    vtkActor coneActor = new vtkActor();
+    coneActor.SetMapper(coneMapper);
+
+    //
+    // Create the Renderer and assign actors to it. A renderer is like a
+    // viewport. It is part or all of a window on the screen and it is
+    // responsible for drawing the actors it has.  We also set the
+    // background color here.
+    //
+    vtkRenderer ren1 = new vtkRenderer();
+    ren1.AddActor(coneActor);
+    ren1.SetBackground(0.1, 0.2, 0.4);
+
+    //
+    // Finally we create the render window which will show up on the screen.
+    // We add our two renderers into the render window using AddRenderer. We also
+    // set the size to be 600 pixels by 300.
+    //
+    vtkRenderWindow renWin = new vtkRenderWindow();
+    renWin.AddRenderer( ren1 );
+    renWin.SetSize(300, 300);
+
+    //
+    // Make one camera view 90 degrees from other.
+    //
+    ren1.ResetCamera();
+    ren1.GetActiveCamera().Azimuth(90);
+
+    //
+    // The vtkRenderWindowInteractor class watches for events (e.g., keypress,
+    // mouse) in the vtkRenderWindow. These events are translated into event
+    // invocations that VTK understands (see VTK/Common/vtkCommand.h for all
+    // events that VTK processes). Then observers of these VTK events can
+    // process them as appropriate.
+    vtkRenderWindowInteractor iren = new vtkRenderWindowInteractor();
+    iren.SetRenderWindow(renWin);
+
+    //
+    // By default the vtkRenderWindowInteractor instantiates an instance
+    // of vtkInteractorStyle. vtkInteractorStyle translates a set of events
+    // it observes into operations on the camera, actors, and/or properties
+    // in the vtkRenderWindow associated with the vtkRenderWinodwInteractor.
+    // Here we specify a particular interactor style.
+    vtkInteractorStyleTrackballCamera style =
+        new vtkInteractorStyleTrackballCamera();
+    iren.SetInteractorStyle(style);
+
+    //
+    // Unlike the previous examples where we performed some operations and then
+    // exited, here we leave an event loop running. The user can use the mouse
+    // and keyboard to perform the operations on the scene according to the
+    // current interaction style.
+    //
+
+    //
+    // Initialize and start the event loop. Once the render window appears,
+    // mouse in the window to move the camera. The Start() method executes
+    // an event loop which listens to user mouse and keyboard events. Note
+    // that keypress-e exits the event loop. (Look in vtkInteractorStyle.h
+    // for a summary of events, or the appropriate Doxygen documentation.)
+    //
+    iren.Initialize();
+    iren.Start();
+  }
+}

ParaView-5.0.1/VTK/Examples/Tutorial/Step5/Python/Cone5.py

@@ -0,0 +1,93 @@
+#!/usr/bin/env python
+
+#
+# This example introduces the concepts of user interaction with VTK.
+# First, a different interaction style (than the default) is defined.
+# Second, the interaction is started.
+#
+#
+
+import vtk
+
+#
+# Next we create an instance of vtkConeSource and set some of its
+# properties. The instance of vtkConeSource "cone" is part of a visualization
+# pipeline (it is a source process object); it produces data (output type is
+# vtkPolyData) which other filters may process.
+#
+cone = vtk.vtkConeSource()
+cone.SetHeight( 3.0 )
+cone.SetRadius( 1.0 )
+cone.SetResolution( 10 )
+
+#
+# In this example we terminate the pipeline with a mapper process object.
+# (Intermediate filters such as vtkShrinkPolyData could be inserted in
+# between the source and the mapper.)  We create an instance of
+# vtkPolyDataMapper to map the polygonal data into graphics primitives. We
+# connect the output of the cone souece to the input of this mapper.
+#
+coneMapper = vtk.vtkPolyDataMapper()
+coneMapper.SetInputConnection(cone.GetOutputPort())
+
+#
+# Create an actor to represent the cone. The actor orchestrates rendering of
+# the mapper's graphics primitives. An actor also refers to properties via a
+# vtkProperty instance, and includes an internal transformation matrix. We
+# set this actor's mapper to be coneMapper which we created above.
+#
+coneActor = vtk.vtkActor()
+coneActor.SetMapper(coneMapper)
+
+#
+# Create the Renderer and assign actors to it. A renderer is like a
+# viewport. It is part or all of a window on the screen and it is responsible
+# for drawing the actors it has.  We also set the background color here.
+#
+ren1 = vtk.vtkRenderer()
+ren1.AddActor(coneActor)
+ren1.SetBackground(0.1, 0.2, 0.4)
+
+#
+# Finally we create the render window which will show up on the screen
+# We put our renderer into the render window using AddRenderer. We also
+# set the size to be 300 pixels by 300.
+#
+renWin = vtk.vtkRenderWindow()
+renWin.AddRenderer(ren1)
+renWin.SetSize(300, 300)
+
+#
+# The vtkRenderWindowInteractor class watches for events (e.g., keypress,
+# mouse) in the vtkRenderWindow. These events are translated into
+# event invocations that VTK understands (see VTK/Common/vtkCommand.h
+# for all events that VTK processes). Then observers of these VTK
+# events can process them as appropriate.
+iren = vtk.vtkRenderWindowInteractor()
+iren.SetRenderWindow(renWin)
+
+#
+# By default the vtkRenderWindowInteractor instantiates an instance
+# of vtkInteractorStyle. vtkInteractorStyle translates a set of events
+# it observes into operations on the camera, actors, and/or properties
+# in the vtkRenderWindow associated with the vtkRenderWinodwInteractor.
+# Here we specify a particular interactor style.
+style = vtk.vtkInteractorStyleTrackballCamera()
+iren.SetInteractorStyle(style)
+
+#
+# Unlike the previous scripts where we performed some operations and then
+# exited, here we leave an event loop running. The user can use the mouse
+# and keyboard to perform the operations on the scene according to the
+# current interaction style.
+#
+
+#
+# Initialize and start the event loop. Once the render window appears, mouse
+# in the window to move the camera. The Start() method executes an event
+# loop which listens to user mouse and keyboard events. Note that keypress-e
+# exits the event loop. (Look in vtkInteractorStyle.h for a summary of events, or
+# the appropriate Doxygen documentation.)
+#
+iren.Initialize()
+iren.Start()

ParaView-5.0.1/VTK/Examples/Tutorial/Step5/Tcl/Cone5.tcl

@@ -0,0 +1,121 @@
+#
+# This example introduces the concepts of interaction into the
+# Tcl environment. First, a different interaction style (than
+# the default) is defined. Second, because Tcl is an interpretive
+# language, the VTK Tcl interaction GUI is set up.
+#
+#
+#
+# First we include the VTK Tcl packages which will make available
+# all of the VTK commands to Tcl. Note that package vtkinteraction
+# is required; thios package defines the Tcl/Tk GUI widget .vtkInteract
+# that is referred to later.
+#
+package require vtk
+package require vtkinteraction
+
+#
+# Next we create an instance of vtkConeSource and set some of its
+# properties. The instance of vtkConeSource "cone" is part of a visualization
+# pipeline (it is a source process object); it produces data (output type is
+# vtkPolyData) which other filters may process.
+#
+vtkConeSource cone
+cone SetHeight 3.0
+cone SetRadius 1.0
+cone SetResolution 10
+
+#
+# In this example we terminate the pipeline with a mapper process object.
+# (Intermediate filters such as vtkShrinkPolyData could be inserted in
+# between the source and the mapper.)  We create an instance of
+# vtkPolyDataMapper to map the polygonal data into graphics primitives. We
+# connect the output of the cone souece to the input of this mapper.
+#
+vtkPolyDataMapper coneMapper
+coneMapper SetInputConnection [cone GetOutputPort]
+
+#
+# Create an actor to represent the cone. The actor orchestrates rendering of
+# the mapper's graphics primitives. An actor also refers to properties via a
+# vtkProperty instance, and includes an internal transformation matrix. We
+# set this actor's mapper to be coneMapper which we created above.
+#
+vtkActor coneActor
+coneActor SetMapper coneMapper
+
+#
+# Create the Renderer and assign actors to it. A renderer is like a
+# viewport. It is part or all of a window on the screen and it is responsible
+# for drawing the actors it has.  We also set the background color here.
+#
+vtkRenderer ren1
+ren1 AddActor coneActor
+ren1 SetBackground 0.1 0.2 0.4
+
+#
+# Finally we create the render window which will show up on the screen
+# We put our renderer into the render window using AddRenderer. We also
+# set the size to be 300 pixels by 300.
+#
+vtkRenderWindow renWin
+renWin AddRenderer ren1
+renWin SetSize 300 300
+
+#
+# The vtkRenderWindowInteractor class watches for events (e.g., keypress,
+# mouse) in the vtkRenderWindow. These events are translated into
+# event invocations that VTK understands (see VTK/Common/vtkCommand.h
+# for all events that VTK processes). Then observers of these VTK
+# events can process them as appropriate.
+vtkRenderWindowInteractor iren
+iren SetRenderWindow renWin
+
+#
+# By default the vtkRenderWindowInteractor instantiates an instance
+# of vtkInteractorStyle. vtkInteractorStyle translates a set of events
+# it observes into operations on the camera, actors, and/or properties
+# in the vtkRenderWindow associated with the vtkRenderWinodwInteractor.
+# Here we specify a particular interactor style.
+vtkInteractorStyleTrackballCamera style
+iren SetInteractorStyle style
+
+#
+# Unlike the previous scripts where we performed some operations and then
+# exited, here we leave an event loop running. The user can use the mouse
+# and keyboard to perform the operations on the scene according to the
+# current interaction style.
+#
+
+#
+# Another feature of Tcl/Tk is that in VTK a simple GUI for typing in
+# interpreted Tcl commands is provided. The so-called vtkInteractor appears
+# when the user types the "u" (for user) keypress. The "u" keypress is
+# translated into a UserEvent by the vtkRenderWindowInteractor. We observe
+# this event and invoke a commands to deiconify the vtkInteractor. (The
+# vtkInteractor is defined in the vtkinteraction package reference at the
+# beginning of this script.)
+#
+#
+iren AddObserver UserEvent {wm deiconify .vtkInteract}
+
+#
+# Initialize the event loop. The actual interaction starts after
+# wm withdraw . with the Tk event loop. Once the render window appears,
+# mouse in the window to move the camera. Note that keypress-e exits this
+# example. (Look in vtkInteractorStyle.h for a summary of events, or
+# the appropriate Doxygen documentation.)
+#
+iren Initialize
+
+#
+# Since we are in the Tcl/Tk environment, we prevent the empty "."
+# window from appearing with the Tk "withdraw" command.
+#
+wm withdraw .
+
+iren Start
+
+
+
+

ParaView-5.0.1/VTK/Examples/Tutorial/Step6/Cxx/CMakeLists.txt

@@ -0,0 +1,19 @@
+cmake_minimum_required(VERSION 2.8.5 FATAL_ERROR)
+if(POLICY CMP0025)
+  cmake_policy(SET CMP0025 NEW) # CMake 3.0
+endif()
+if(POLICY CMP0053)
+  cmake_policy(SET CMP0053 NEW) # CMake 3.1
+endif()
+
+PROJECT (Step6)
+
+find_package(VTK COMPONENTS
+  vtkFiltersSources
+  vtkInteractionWidgets
+  vtkRendering${VTK_RENDERING_BACKEND}
+)
+include(${VTK_USE_FILE})
+
+add_executable(Cone6 MACOSX_BUNDLE Cone6.cxx)
+target_link_libraries(Cone6 ${VTK_LIBRARIES})

ParaView-5.0.1/VTK/Examples/Tutorial/Step6/Cxx/Cone6.cxx

@@ -0,0 +1,183 @@
+/*=========================================================================
+
+  Program:   Visualization Toolkit
+  Module:    Cone6.cxx
+
+  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
+  All rights reserved.
+  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
+
+     This software is distributed WITHOUT ANY WARRANTY; without even
+     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+     PURPOSE.  See the above copyright notice for more information.
+
+=========================================================================*/
+//
+// This example introduces 3D widgets. 3D widgets take advantage of the
+// event/observer design pattern introduced previously. They typically
+// have a particular representation in the scene which can be interactively
+// selected and manipulated using the mouse and keyboard. As the widgets
+// are manipulated, they in turn invoke events such as StartInteractionEvent,
+// InteractionEvent, and EndInteractionEvent which can be used to manipulate
+// the scene that the widget is embedded in. 3D widgets work in the context
+// of the event loop which was set up in the previous example.
+//
+// Note: there are more 3D widget examples in VTK/Examples/GUI/.
+//
+
+// First include the required header files for the VTK classes we are using.
+#include "vtkConeSource.h"
+#include "vtkPolyDataMapper.h"
+#include "vtkRenderWindow.h"
+#include "vtkRenderWindowInteractor.h"
+#include "vtkCamera.h"
+#include "vtkActor.h"
+#include "vtkRenderer.h"
+#include "vtkCommand.h"
+#include "vtkBoxWidget.h"
+#include "vtkTransform.h"
+#include "vtkInteractorStyleTrackballCamera.h"
+
+//
+// Similar to Cone2.cxx, we define a callback for interaction.
+//
+class vtkMyCallback : public vtkCommand
+{
+public:
+  static vtkMyCallback *New()
+    { return new vtkMyCallback; }
+  virtual void Execute(vtkObject *caller, unsigned long, void*)
+    {
+      vtkTransform *t = vtkTransform::New();
+      vtkBoxWidget *widget = reinterpret_cast<vtkBoxWidget*>(caller);
+      widget->GetTransform(t);
+      widget->GetProp3D()->SetUserTransform(t);
+      t->Delete();
+    }
+};
+
+int main()
+{
+  //
+  // Next we create an instance of vtkConeSource and set some of its
+  // properties. The instance of vtkConeSource "cone" is part of a
+  // visualization pipeline (it is a source process object); it produces data
+  // (output type is vtkPolyData) which other filters may process.
+  //
+  vtkConeSource *cone = vtkConeSource::New();
+  cone->SetHeight( 3.0 );
+  cone->SetRadius( 1.0 );
+  cone->SetResolution( 10 );
+
+  //
+  // In this example we terminate the pipeline with a mapper process object.
+  // (Intermediate filters such as vtkShrinkPolyData could be inserted in
+  // between the source and the mapper.)  We create an instance of
+  // vtkPolyDataMapper to map the polygonal data into graphics primitives. We
+  // connect the output of the cone souece to the input of this mapper.
+  //
+  vtkPolyDataMapper *coneMapper = vtkPolyDataMapper::New();
+  coneMapper->SetInputConnection( cone->GetOutputPort() );
+
+  //
+  // Create an actor to represent the cone. The actor orchestrates rendering
+  // of the mapper's graphics primitives. An actor also refers to properties
+  // via a vtkProperty instance, and includes an internal transformation
+  // matrix. We set this actor's mapper to be coneMapper which we created
+  // above.
+  //
+  vtkActor *coneActor = vtkActor::New();
+  coneActor->SetMapper( coneMapper );
+
+  //
+  // Create the Renderer and assign actors to it. A renderer is like a
+  // viewport. It is part or all of a window on the screen and it is
+  // responsible for drawing the actors it has.  We also set the background
+  // color here.
+  //
+  vtkRenderer *ren1= vtkRenderer::New();
+  ren1->AddActor( coneActor );
+  ren1->SetBackground( 0.1, 0.2, 0.4 );
+
+  //
+  // Finally we create the render window which will show up on the screen.
+  // We put our renderer into the render window using AddRenderer. We also
+  // set the size to be 300 pixels by 300.
+  //
+  vtkRenderWindow *renWin = vtkRenderWindow::New();
+  renWin->AddRenderer( ren1 );
+  renWin->SetSize( 300, 300 );
+
+  //
+  // The vtkRenderWindowInteractor class watches for events (e.g., keypress,
+  // mouse) in the vtkRenderWindow. These events are translated into
+  // event invocations that VTK understands (see VTK/Common/vtkCommand.h
+  // for all events that VTK processes). Then observers of these VTK
+  // events can process them as appropriate.
+  vtkRenderWindowInteractor *iren = vtkRenderWindowInteractor::New();
+  iren->SetRenderWindow(renWin);
+
+  //
+  // By default the vtkRenderWindowInteractor instantiates an instance
+  // of vtkInteractorStyle. vtkInteractorStyle translates a set of events
+  // it observes into operations on the camera, actors, and/or properties
+  // in the vtkRenderWindow associated with the vtkRenderWinodwInteractor.
+  // Here we specify a particular interactor style.
+  vtkInteractorStyleTrackballCamera *style =
+    vtkInteractorStyleTrackballCamera::New();
+  iren->SetInteractorStyle(style);
+
+  //
+  // Here we use a vtkBoxWidget to transform the underlying coneActor (by
+  // manipulating its transformation matrix). Many other types of widgets
+  // are available for use, see the documentation for more details.
+  //
+  // The SetInteractor method is how 3D widgets are associated with the render
+  // window interactor. Internally, SetInteractor sets up a bunch of callbacks
+  // using the Command/Observer mechanism (AddObserver()). The place factor
+  // controls the initial size of the widget with respect to the bounding box
+  // of the input to the widget.
+  vtkBoxWidget *boxWidget = vtkBoxWidget::New();
+  boxWidget->SetInteractor(iren);
+  boxWidget->SetPlaceFactor(1.25);
+
+  //
+  // Place the interactor initially. The input to a 3D widget is used to
+  // initially position and scale the widget. The EndInteractionEvent is
+  // observed which invokes the SelectPolygons callback.
+  //
+  boxWidget->SetProp3D(coneActor);
+  boxWidget->PlaceWidget();
+  vtkMyCallback *callback = vtkMyCallback::New();
+  boxWidget->AddObserver(vtkCommand::InteractionEvent, callback);
+
+  //
+  // Normally the user presses the "i" key to bring a 3D widget to life. Here
+  // we will manually enable it so it appears with the cone.
+  //
+  boxWidget->On();
+
+  //
+  // Start the event loop.
+  //
+  iren->Initialize();
+  iren->Start();
+
+  //
+  // Free up any objects we created. All instances in VTK are deleted by
+  // using the Delete() method.
+  //
+  cone->Delete();
+  coneMapper->Delete();
+  coneActor->Delete();
+  callback->Delete();
+  boxWidget->Delete();
+  ren1->Delete();
+  renWin->Delete();
+  iren->Delete();
+  style->Delete();
+
+  return 0;
+}
+
+

ParaView-5.0.1/VTK/Examples/Tutorial/Step6/Python/Cone6.py

@@ -0,0 +1,117 @@
+#!/usr/bin/env python
+#
+# This example introduces 3D widgets. 3D widgets take advantage of the
+# event/observer design pattern introduced previously. They typically
+# have a particular representation in the scene which can be interactively
+# selected and manipulated using the mouse and keyboard. As the widgets
+# are manipulated, they in turn invoke events such as StartInteractionEvent,
+# InteractionEvent, and EndInteractionEvent which can be used to manipulate
+# the scene that the widget is embedded in. 3D widgets work in the context
+# of the event loop which was set up in the previous example.
+#
+# Note: there are more 3D widget examples in VTK/Examples/GUI/.
+#
+
+# First we import the VTK Python package that will make available all
+# of the VTK commands to Python.
+import vtk
+
+# Next we create an instance of vtkConeSource and set some of its
+# properties. The instance of vtkConeSource "cone" is part of a
+# visualization pipeline (it is a source process object); it produces
+# data (output type is vtkPolyData) which other filters may process.
+cone = vtk.vtkConeSource()
+cone.SetHeight(3.0)
+cone.SetRadius(1.0)
+cone.SetResolution(10)
+
+# In this example we terminate the pipeline with a mapper process object.
+# (Intermediate filters such as vtkShrinkPolyData could be inserted in
+# between the source and the mapper.)  We create an instance of
+# vtkPolyDataMapper to map the polygonal data into graphics primitives. We
+# connect the output of the cone souece to the input of this mapper.
+coneMapper = vtk.vtkPolyDataMapper()
+coneMapper.SetInputConnection(cone.GetOutputPort())
+
+# Create an actor to represent the cone. The actor orchestrates rendering of
+# the mapper's graphics primitives. An actor also refers to properties via a
+# vtkProperty instance, and includes an internal transformation matrix. We
+# set this actor's mapper to be coneMapper which we created above.
+coneActor = vtk.vtkActor()
+coneActor.SetMapper(coneMapper)
+
+# Create the Renderer and assign actors to it. A renderer is like a
+# viewport. It is part or all of a window on the screen and it is
+# responsible for drawing the actors it has.  We also set the
+# background color here.
+ren1 = vtk.vtkRenderer()
+ren1.AddActor(coneActor)
+ren1.SetBackground(0.1, 0.2, 0.4)
+
+# Finally we create the render window which will show up on the screen
+# We put our renderer into the render window using AddRenderer. We
+# also set the size to be 300 pixels by 300.
+renWin = vtk.vtkRenderWindow()
+renWin.AddRenderer(ren1)
+renWin.SetSize(300, 300)
+
+# The vtkRenderWindowInteractor class watches for events (e.g., keypress,
+# mouse) in the vtkRenderWindow. These events are translated into
+# event invocations that VTK understands (see VTK/Common/vtkCommand.h
+# for all events that VTK processes). Then observers of these VTK
+# events can process them as appropriate.
+iren = vtk.vtkRenderWindowInteractor()
+iren.SetRenderWindow(renWin)
+
+# By default the vtkRenderWindowInteractor instantiates an instance
+# of vtkInteractorStyle. vtkInteractorStyle translates a set of events
+# it observes into operations on the camera, actors, and/or properties
+# in the vtkRenderWindow associated with the vtkRenderWinodwInteractor.
+# Here we specify a particular interactor style.
+style = vtk.vtkInteractorStyleTrackballCamera()
+iren.SetInteractorStyle(style)
+
+
+# Here we use a vtkBoxWidget to transform the underlying coneActor (by
+# manipulating its transformation matrix). Many other types of widgets
+# are available for use, see the documentation for more details.
+#
+# The SetInteractor method is how 3D widgets are associated with the render
+# window interactor. Internally, SetInteractor sets up a bunch of callbacks
+# using the Command/Observer mechanism (AddObserver()). The place factor
+# controls the initial size of the widget with respect to the bounding box
+# of the input to the widget.
+boxWidget = vtk.vtkBoxWidget()
+boxWidget.SetInteractor(iren)
+boxWidget.SetPlaceFactor(1.25)
+
+# Place the interactor initially. The input to a 3D widget is used to
+# initially position and scale the widget. The EndInteractionEvent is
+# observed which invokes the SelectPolygons callback.
+boxWidget.SetProp3D(coneActor)
+boxWidget.PlaceWidget()
+
+# Similar to Step2/Python/Cone2.py, we define a callback for
+# interaction.  As can be seen the callback takes two arguments.  The
+# first being the object that generates the event and the second
+# argument the event name (which is a string).
+def myCallback(widget, event_string):
+    t = vtk.vtkTransform()
+    boxWidget.GetTransform(t)
+    boxWidget.GetProp3D().SetUserTransform(t)
+
+
+# Now for every interaction event that is generated by the boxWidget,
+# call our callback function.
+boxWidget.AddObserver("InteractionEvent", myCallback)
+
+# Normally the user presses the "i" key to bring a 3D widget to
+# life. Here we will manually enable it so it appears with the cone.
+boxWidget.On()
+
+# Start the event loop.
+iren.Initialize()
+iren.Start()
+
+# There is no explicit need to free any objects at this point.
+# Once Python exits, memory is automatically freed.

ParaView-5.0.1/VTK/Examples/Tutorial/Step6/Tcl/Cone6.tcl

@@ -0,0 +1,148 @@
+#
+# This example introduces 3D widgets. 3D widgets take advantage of the
+# event/observer design pattern introduced previously. They typically
+# have a particular representation in the scene which can be interactively
+# selected and manipulated using the mouse and keyboard. As the widgets
+# are manipulated, they in turn invoke events such as StartInteractionEvent,
+# InteractionEvent, and EndInteractionEvent which can be used to manipulate
+# the scene that the widget is embedded in. 3D widgets work in the context
+# of the event loop which was set up in the previous example.
+#
+# Note: there are more 3D widget examples in VTK/Examples/GUI/.
+#
+
+#
+# First we include the VTK Tcl packages which will make available
+# all of the VTK commands to Tcl.
+#
+package require vtk
+
+#
+# Next we create an instance of vtkConeSource and set some of its
+# properties. The instance of vtkConeSource "cone" is part of a visualization
+# pipeline (it is a source process object); it produces data (output type is
+# vtkPolyData) which other filters may process.
+#
+vtkConeSource cone
+cone SetHeight 3.0
+cone SetRadius 1.0
+cone SetResolution 10
+
+#
+# In this example we terminate the pipeline with a mapper process object.
+# (Intermediate filters such as vtkShrinkPolyData could be inserted in
+# between the source and the mapper.)  We create an instance of
+# vtkPolyDataMapper to map the polygonal data into graphics primitives. We
+# connect the output of the cone souece to the input of this mapper.
+#
+vtkPolyDataMapper coneMapper
+coneMapper SetInputConnection [cone GetOutputPort]
+
+#
+# Create an actor to represent the cone. The actor orchestrates rendering of
+# the mapper's graphics primitives. An actor also refers to properties via a
+# vtkProperty instance, and includes an internal transformation matrix. We
+# set this actor's mapper to be coneMapper which we created above.
+#
+vtkActor coneActor
+coneActor SetMapper coneMapper
+
+#
+# Create the Renderer and assign actors to it. A renderer is like a
+# viewport. It is part or all of a window on the screen and it is responsible
+# for drawing the actors it has.  We also set the background color here.
+#
+vtkRenderer ren1
+ren1 AddActor coneActor
+ren1 SetBackground 0.1 0.2 0.4
+
+#
+# Finally we create the render window which will show up on the screen
+# We put our renderer into the render window using AddRenderer. We also
+# set the size to be 300 pixels by 300.
+#
+vtkRenderWindow renWin
+renWin AddRenderer ren1
+renWin SetSize 300 300
+
+#
+# The vtkRenderWindowInteractor class watches for events (e.g., keypress,
+# mouse) in the vtkRenderWindow. These events are translated into
+# event invocations that VTK understands (see VTK/Common/vtkCommand.h
+# for all events that VTK processes). Then observers of these VTK
+# events can process them as appropriate.
+vtkRenderWindowInteractor iren
+iren SetRenderWindow renWin
+
+#
+# By default the vtkRenderWindowInteractor instantiates an instance
+# of vtkInteractorStyle. vtkInteractorStyle translates a set of events
+# it observes into operations on the camera, actors, and/or properties
+# in the vtkRenderWindow associated with the vtkRenderWinodwInteractor.
+# Here we specify a particular interactor style.
+vtkInteractorStyleTrackballCamera style
+iren SetInteractorStyle style
+
+#
+# Here we use a vtkBoxWidget to transform the underlying coneActor (by
+# manipulating its transformation matrix). Many other types of widgets
+# are available for use, see the documentation for more details.
+#
+# The SetInteractor method is how 3D widgets are associated with the render
+# window interactor. Internally, SetInteractor sets up a bunch of callbacks
+# using the Command/Observer mechanism (AddObserver()). The place factor
+# controls the initial size of the widget with respect to the bounding box
+# of the input to the widget.
+vtkBoxWidget boxWidget
+boxWidget SetInteractor iren
+boxWidget SetPlaceFactor 1.25
+
+#
+# Place the interactor initially. The input to a 3D widget is used to
+# initially position and scale the widget. The EndInteractionEvent is
+# observed which invokes the SelectPolygons callback.
+#
+boxWidget SetInputConnection [cone GetOutputPort]
+boxWidget PlaceWidget
+boxWidget AddObserver InteractionEvent TransformActor
+
+#
+# Normally the user presses the "i" key to bring a 3D widget to life. Here
+# we will manually enable it so it appears with the cone.
+#
+boxWidget On
+
+#
+# We can use the vtkInteract Tcl/Tk interactor at the same time as
+# the box widget.
+#
+iren AddObserver UserEvent {wm deiconify .vtkInteract}
+
+#
+# Initialize starts the event loop. Once the render window appears, mouse
+# in the window to move the camera. If you select the box widget,
+# depending on what is selected, the widget will change shape. As this
+# is happening, it will invoke InteractionEvents on itself. These are
+# caught by the observer which in turn invokes the Tcl proc TransformActor
+# (defined below). If you do not select the box widget, then the events
+# are received by the interactor style, which manipulates the camera as
+# usual. It is possible to have many widgets running simultaneously, and to
+# prioritize the processing of events.
+#
+iren Initialize
+
+#
+# Since we are in the Tcl/Tk environment, we prevent the empty "."
+# window from appearing with the Tk "withdraw" command.
+#
+wm withdraw .
+
+# As the box widget is interacted with, it produces a transformation
+# matrix that is set on the actor.
+vtkTransform t
+proc TransformActor {} {
+   boxWidget GetTransform t
+   coneActor SetUserTransform t
+}
+
+iren Start