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/Modelling/Python/DelMesh.py

@@ -0,0 +1,86 @@
+#!/usr/bin/env python
+
+# This example demonstrates how to use 2D Delaunay triangulation.
+# We create a fancy image of a 2D Delaunay triangulation. Points are
+# randomly generated.
+
+import vtk
+from vtk.util.colors import *
+
+# Generate some random points
+math = vtk.vtkMath()
+points = vtk.vtkPoints()
+for i in range(0, 50):
+    points.InsertPoint(i, math.Random(0, 1), math.Random(0, 1), 0.0)
+
+# Create a polydata with the points we just created.
+profile = vtk.vtkPolyData()
+profile.SetPoints(points)
+
+# Perform a 2D Delaunay triangulation on them.
+delny = vtk.vtkDelaunay2D()
+delny.SetInputData(profile)
+delny.SetTolerance(0.001)
+mapMesh = vtk.vtkPolyDataMapper()
+mapMesh.SetInputConnection(delny.GetOutputPort())
+meshActor = vtk.vtkActor()
+meshActor.SetMapper(mapMesh)
+meshActor.GetProperty().SetColor(.1, .2, .4)
+
+# We will now create a nice looking mesh by wrapping the edges in tubes,
+# and putting fat spheres at the points.
+extract = vtk.vtkExtractEdges()
+extract.SetInputConnection(delny.GetOutputPort())
+tubes = vtk.vtkTubeFilter()
+tubes.SetInputConnection(extract.GetOutputPort())
+tubes.SetRadius(0.01)
+tubes.SetNumberOfSides(6)
+mapEdges = vtk.vtkPolyDataMapper()
+mapEdges.SetInputConnection(tubes.GetOutputPort())
+edgeActor = vtk.vtkActor()
+edgeActor.SetMapper(mapEdges)
+edgeActor.GetProperty().SetColor(peacock)
+edgeActor.GetProperty().SetSpecularColor(1, 1, 1)
+edgeActor.GetProperty().SetSpecular(0.3)
+edgeActor.GetProperty().SetSpecularPower(20)
+edgeActor.GetProperty().SetAmbient(0.2)
+edgeActor.GetProperty().SetDiffuse(0.8)
+
+ball = vtk.vtkSphereSource()
+ball.SetRadius(0.025)
+ball.SetThetaResolution(12)
+ball.SetPhiResolution(12)
+balls = vtk.vtkGlyph3D()
+balls.SetInputConnection(delny.GetOutputPort())
+balls.SetSourceConnection(ball.GetOutputPort())
+mapBalls = vtk.vtkPolyDataMapper()
+mapBalls.SetInputConnection(balls.GetOutputPort())
+ballActor = vtk.vtkActor()
+ballActor.SetMapper(mapBalls)
+ballActor.GetProperty().SetColor(hot_pink)
+ballActor.GetProperty().SetSpecularColor(1, 1, 1)
+ballActor.GetProperty().SetSpecular(0.3)
+ballActor.GetProperty().SetSpecularPower(20)
+ballActor.GetProperty().SetAmbient(0.2)
+ballActor.GetProperty().SetDiffuse(0.8)
+
+# Create the rendering window, renderer, and interactive renderer
+ren = vtk.vtkRenderer()
+renWin = vtk.vtkRenderWindow()
+renWin.AddRenderer(ren)
+iren = vtk.vtkRenderWindowInteractor()
+iren.SetRenderWindow(renWin)
+
+# Add the actors to the renderer, set the background and size
+ren.AddActor(ballActor)
+ren.AddActor(edgeActor)
+ren.SetBackground(1, 1, 1)
+renWin.SetSize(150, 150)
+
+ren.ResetCamera()
+ren.GetActiveCamera().Zoom(1.5)
+
+# Interact with the data.
+iren.Initialize()
+renWin.Render()
+iren.Start()

ParaView-5.0.1/VTK/Examples/Modelling/Python/Delaunay3D.py

@@ -0,0 +1,60 @@
+#!/usr/bin/env python
+
+# This example shows how to use Delaunay3D with alpha shapes.
+
+import vtk
+
+# The points to be triangulated are generated randomly in the unit
+# cube located at the origin. The points are then associated with a
+# vtkPolyData.
+math = vtk.vtkMath()
+points = vtk.vtkPoints()
+for i in range(0, 25):
+    points.InsertPoint(i, math.Random(0, 1), math.Random(0, 1),
+                       math.Random(0, 1))
+
+profile = vtk.vtkPolyData()
+profile.SetPoints(points)
+
+# Delaunay3D is used to triangulate the points. The Tolerance is the
+# distance that nearly coincident points are merged
+# together. (Delaunay does better if points are well spaced.) The
+# alpha value is the radius of circumcircles, circumspheres. Any mesh
+# entity whose circumcircle is smaller than this value is output.
+delny = vtk.vtkDelaunay3D()
+delny.SetInputData(profile)
+delny.SetTolerance(0.01)
+delny.SetAlpha(0.2)
+delny.BoundingTriangulationOff()
+
+# Shrink the result to help see it better.
+shrink = vtk.vtkShrinkFilter()
+shrink.SetInputConnection(delny.GetOutputPort())
+shrink.SetShrinkFactor(0.9)
+
+map = vtk.vtkDataSetMapper()
+map.SetInputConnection(shrink.GetOutputPort())
+
+triangulation = vtk.vtkActor()
+triangulation.SetMapper(map)
+triangulation.GetProperty().SetColor(1, 0, 0)
+
+# Create graphics stuff
+ren = vtk.vtkRenderer()
+renWin = vtk.vtkRenderWindow()
+renWin.AddRenderer(ren)
+iren = vtk.vtkRenderWindowInteractor()
+iren.SetRenderWindow(renWin)
+
+# Add the actors to the renderer, set the background and size
+ren.AddActor(triangulation)
+ren.SetBackground(1, 1, 1)
+renWin.SetSize(250, 250)
+renWin.Render()
+
+cam1 = ren.GetActiveCamera()
+cam1.Zoom(1.5)
+
+iren.Initialize()
+renWin.Render()
+iren.Start()

ParaView-5.0.1/VTK/Examples/Modelling/Python/PerlinTerrain.py

@@ -0,0 +1,67 @@
+#!/usr/bin/env python
+
+# This example demonstrates how to combine a "geometric" implicit
+# function with noise at different frequencies to produce the
+# appearance of a landscape.
+
+import vtk
+
+plane = vtk.vtkPlane()
+
+p1 = vtk.vtkPerlinNoise()
+p1.SetFrequency(1, 1, 0)
+
+p2 = vtk.vtkPerlinNoise()
+p2.SetFrequency(3, 5, 0)
+p2.SetPhase(0.5, 0.5, 0)
+
+p3 = vtk.vtkPerlinNoise()
+p3.SetFrequency(16, 16, 0)
+
+sum = vtk.vtkImplicitSum()
+sum.SetNormalizeByWeight(1)
+sum.AddFunction(plane)
+sum.AddFunction(p1, 0.2)
+sum.AddFunction(p2, 0.1)
+sum.AddFunction(p3, 0.02)
+
+sample = vtk.vtkSampleFunction()
+sample.SetImplicitFunction(sum)
+sample.SetSampleDimensions(65, 65, 20)
+sample.SetModelBounds(-1, 1, -1, 1, -0.5, 0.5)
+sample.ComputeNormalsOff()
+surface = vtk.vtkContourFilter()
+surface.SetInputConnection(sample.GetOutputPort())
+surface.SetValue(0, 0.0)
+
+smooth = vtk.vtkPolyDataNormals()
+smooth.SetInputConnection(surface.GetOutputPort())
+smooth.SetFeatureAngle(90)
+
+mapper = vtk.vtkPolyDataMapper()
+mapper.SetInputConnection(smooth.GetOutputPort())
+mapper.ScalarVisibilityOff()
+actor = vtk.vtkActor()
+actor.SetMapper(mapper)
+actor.GetProperty().SetColor(0.4, 0.2, 0.1)
+
+# Create the renderer etc.
+ren = vtk.vtkRenderer()
+renWin = vtk.vtkRenderWindow()
+renWin.AddRenderer(ren)
+iren = vtk.vtkRenderWindowInteractor()
+iren.SetRenderWindow(renWin)
+
+# Add the actors to the renderer, set the background and size
+ren.AddActor(actor)
+ren.SetBackground(1, 1, 1)
+renWin.SetSize(500, 500)
+ren.ResetCamera()
+ren.GetActiveCamera().Elevation(-45)
+ren.GetActiveCamera().Azimuth(10)
+ren.GetActiveCamera().Dolly(1.35)
+ren.ResetCameraClippingRange()
+
+iren.Initialize()
+renWin.Render()
+iren.Start()

ParaView-5.0.1/VTK/Examples/Modelling/Python/SpherePuzzle.py

@@ -0,0 +1,169 @@
+#!/usr/bin/env python
+
+# A game with VTK and tkinter. :)
+
+import sys
+if sys.hexversion < 0x03000000:
+    # for Python2
+    import Tkinter as tkinter
+else:
+    # for Python3
+    import tkinter
+import vtk
+from vtk.tk.vtkTkRenderWindowInteractor import vtkTkRenderWindowInteractor
+
+# Create the pipeline
+puzzle = vtk.vtkSpherePuzzle()
+mapper = vtk.vtkPolyDataMapper()
+mapper.SetInputConnection(puzzle.GetOutputPort())
+actor = vtk.vtkActor()
+actor.SetMapper(mapper)
+
+arrows = vtk.vtkSpherePuzzleArrows()
+mapper2 = vtk.vtkPolyDataMapper()
+mapper2.SetInputConnection(arrows.GetOutputPort())
+actor2 = vtk.vtkActor()
+actor2.SetMapper(mapper2)
+
+renWin = vtk.vtkRenderWindow()
+ren = vtk.vtkRenderer()
+renWin.AddRenderer(ren)
+
+# Add the actors to the renderer, set the background and size
+ren.AddActor(actor)
+ren.AddActor(actor2)
+ren.SetBackground(0.1, 0.2, 0.4)
+
+ren.ResetCamera()
+cam = ren.GetActiveCamera()
+cam.Elevation(-40)
+
+
+## Generate the GUI
+root = tkinter.Tk()
+root.withdraw()
+
+# Define a quit method that exits cleanly.
+def quit(obj=root):
+    obj.quit()
+
+# Create the toplevel window
+top = tkinter.Toplevel(root)
+top.title("Sphere Puzzle")
+top.protocol("WM_DELETE_WINDOW", quit)
+
+# Create some frames
+f1 = tkinter.Frame(top)
+f2 = tkinter.Frame(top)
+
+f1.pack(side="top", anchor="n", expand=1, fill="both")
+f2.pack(side="bottom", anchor="s", expand="t", fill="x")
+
+# Create the Tk render widget, and bind the events
+rw = vtkTkRenderWindowInteractor(f1, width=400, height=400, rw=renWin)
+rw.pack(expand="t", fill="both")
+
+def reset(evt=None):
+    puzzle.Reset()
+    renWin.Render()
+
+# Display some information
+l1 = tkinter.Label(f2, text="Position cursor over the rotation plane.")
+l2 = tkinter.Label(f2, text="Moving pieces will be highlighted.")
+l3 = tkinter.Label(f2, text="Press 'm' to make a move.")
+reset = tkinter.Button(f2, text="Reset", command=reset)
+
+b1 = tkinter.Button(f2, text="Quit", command=quit)
+
+for i in (l1, l2, l3, reset, b1):
+    i.pack(side="top", expand="t", fill="x")
+
+# Done with the GUI.  Create callback functions.
+
+in_piece_rotation = 0
+LastVal = None
+
+# Highlight pieces
+def MotionCallback(obj, event):
+    global in_piece_rotation
+    global LastVal
+    if in_piece_rotation:
+        return
+
+    iren = renWin.GetInteractor()
+    istyle = iren.GetInteractorStyle().GetCurrentStyle()
+
+    # Return if the user is performing interaction
+    if istyle.GetState():
+        return
+
+    # Get mouse position
+    pos = iren.GetEventPosition()
+    x, y = pos
+
+    # Get world point
+    ren.SetDisplayPoint(x, y, ren.GetZ(x, y))
+    ren.DisplayToWorld()
+    pt = ren.GetWorldPoint()
+    val = puzzle.SetPoint(pt[0], pt[1], pt[2])
+
+    if (not LastVal) or val != LastVal:
+        renWin.Render()
+        LastVal = val
+
+# Rotate the puzzle
+def CharCallback(obj, event):
+    iren = renWin.GetInteractor()
+
+    keycode = iren.GetKeyCode()
+    if keycode != "m" and keycode != "M":
+        return
+
+    pos = iren.GetEventPosition()
+    ButtonCallback(pos[0], pos[1])
+
+
+def ButtonCallback(x, y):
+    global in_piece_rotation
+    if in_piece_rotation:
+        return
+    in_piece_rotation = 1
+
+    # Get world point
+    ren.SetDisplayPoint(x, y, ren.GetZ(x,y))
+    ren.DisplayToWorld()
+    pt = ren.GetWorldPoint()
+    x, y, z = pt[:3]
+
+    for i in range(0, 101, 10):
+        puzzle.SetPoint(x, y, z)
+        puzzle.MovePoint(i)
+        renWin.Render()
+        root.update()
+
+    in_piece_rotation = 0
+
+root.update()
+
+# Modify some bindings, use the interactor style 'switch'
+iren = renWin.GetInteractor()
+istyle = vtk.vtkInteractorStyleSwitch()
+
+iren.SetInteractorStyle(istyle)
+istyle.SetCurrentStyleToTrackballCamera()
+
+iren.AddObserver("MouseMoveEvent", MotionCallback)
+iren.AddObserver("CharEvent", CharCallback)
+
+# Shuffle the puzzle
+ButtonCallback(218, 195)
+ButtonCallback(261, 128)
+ButtonCallback(213, 107)
+ButtonCallback(203, 162)
+ButtonCallback(134, 186)
+
+iren.Initialize()
+renWin.Render()
+iren.Start()
+
+root.mainloop()

ParaView-5.0.1/VTK/Examples/Modelling/Python/constrainedDelaunay.py

@@ -0,0 +1,150 @@
+#!/usr/bin/env python
+
+# This example demonstrates how to use a constraint polygon in
+# Delaunay triangulation.
+
+import vtk
+from vtk.util.colors import peacock
+
+# Generate the input points and constrained edges/polygons.
+points = vtk.vtkPoints()
+points.InsertPoint(0, 1, 4, 0)
+points.InsertPoint(1, 3, 4, 0)
+points.InsertPoint(2, 7, 4, 0)
+points.InsertPoint(3, 11, 4, 0)
+points.InsertPoint(4, 13, 4, 0)
+points.InsertPoint(5, 13, 8, 0)
+points.InsertPoint(6, 13, 12, 0)
+points.InsertPoint(7, 10, 12, 0)
+points.InsertPoint(8, 7, 12, 0)
+points.InsertPoint(9, 4, 12, 0)
+points.InsertPoint(10, 1, 12, 0)
+points.InsertPoint(11, 1, 8, 0)
+points.InsertPoint(12, 3.5, 5, 0)
+points.InsertPoint(13, 4.5, 5, 0)
+points.InsertPoint(14, 5.5, 8, 0)
+points.InsertPoint(15, 6.5, 8, 0)
+points.InsertPoint(16, 6.5, 5, 0)
+points.InsertPoint(17, 7.5, 5, 0)
+points.InsertPoint(18, 7.5, 8, 0)
+points.InsertPoint(19, 9, 8, 0)
+points.InsertPoint(20, 9, 5, 0)
+points.InsertPoint(21, 10, 5, 0)
+points.InsertPoint(22, 10, 7, 0)
+points.InsertPoint(23, 11, 5, 0)
+points.InsertPoint(24, 12, 5, 0)
+points.InsertPoint(25, 10.5, 8, 0)
+points.InsertPoint(26, 12, 11, 0)
+points.InsertPoint(27, 11, 11, 0)
+points.InsertPoint(28, 10, 9, 0)
+points.InsertPoint(29, 10, 11, 0)
+points.InsertPoint(30, 9, 11, 0)
+points.InsertPoint(31, 9, 9, 0)
+points.InsertPoint(32, 7.5, 9, 0)
+points.InsertPoint(33, 7.5, 11, 0)
+points.InsertPoint(34, 6.5, 11, 0)
+points.InsertPoint(35, 6.5, 9, 0)
+points.InsertPoint(36, 5, 9, 0)
+points.InsertPoint(37, 4, 6, 0)
+points.InsertPoint(38, 3, 9, 0)
+points.InsertPoint(39, 2, 9, 0)
+polys = vtk.vtkCellArray()
+polys.InsertNextCell(12)
+polys.InsertCellPoint(0)
+polys.InsertCellPoint(1)
+polys.InsertCellPoint(2)
+polys.InsertCellPoint(3)
+polys.InsertCellPoint(4)
+polys.InsertCellPoint(5)
+polys.InsertCellPoint(6)
+polys.InsertCellPoint(7)
+polys.InsertCellPoint(8)
+polys.InsertCellPoint(9)
+polys.InsertCellPoint(10)
+polys.InsertCellPoint(11)
+polys.InsertNextCell(28)
+polys.InsertCellPoint(39)
+polys.InsertCellPoint(38)
+polys.InsertCellPoint(37)
+polys.InsertCellPoint(36)
+polys.InsertCellPoint(35)
+polys.InsertCellPoint(34)
+polys.InsertCellPoint(33)
+polys.InsertCellPoint(32)
+polys.InsertCellPoint(31)
+polys.InsertCellPoint(30)
+polys.InsertCellPoint(29)
+polys.InsertCellPoint(28)
+polys.InsertCellPoint(27)
+polys.InsertCellPoint(26)
+polys.InsertCellPoint(25)
+polys.InsertCellPoint(24)
+polys.InsertCellPoint(23)
+polys.InsertCellPoint(22)
+polys.InsertCellPoint(21)
+polys.InsertCellPoint(20)
+polys.InsertCellPoint(19)
+polys.InsertCellPoint(18)
+polys.InsertCellPoint(17)
+polys.InsertCellPoint(16)
+polys.InsertCellPoint(15)
+polys.InsertCellPoint(14)
+polys.InsertCellPoint(13)
+polys.InsertCellPoint(12)
+
+polyData = vtk.vtkPolyData()
+polyData.SetPoints(points)
+polyData.SetPolys(polys)
+
+# Notice this trick. The SetInput() method accepts a vtkPolyData that
+# is also the input to the Delaunay filter. The points of the
+# vtkPolyData are used to generate the triangulation; the polygons are
+# used to create a constraint region. The polygons are very carefully
+# created and ordered in the right direction to indicate inside and
+# outside of the polygon.
+delny = vtk.vtkDelaunay2D()
+delny.SetInputData(polyData)
+delny.SetSourceData(polyData)
+mapMesh = vtk.vtkPolyDataMapper()
+mapMesh.SetInputConnection(delny.GetOutputPort())
+meshActor = vtk.vtkActor()
+meshActor.SetMapper(mapMesh)
+
+# Now we just pretty the mesh up with tubed edges and balls at the
+# vertices.
+extract = vtk.vtkExtractEdges()
+extract.SetInputConnection(delny.GetOutputPort())
+tubes = vtk.vtkTubeFilter()
+tubes.SetInputConnection(extract.GetOutputPort())
+tubes.SetRadius(0.1)
+tubes.SetNumberOfSides(6)
+mapEdges = vtk.vtkPolyDataMapper()
+mapEdges.SetInputConnection(tubes.GetOutputPort())
+edgeActor = vtk.vtkActor()
+edgeActor.SetMapper(mapEdges)
+edgeActor.GetProperty().SetColor(peacock)
+edgeActor.GetProperty().SetSpecularColor(1, 1, 1)
+edgeActor.GetProperty().SetSpecular(0.3)
+edgeActor.GetProperty().SetSpecularPower(20)
+edgeActor.GetProperty().SetAmbient(0.2)
+edgeActor.GetProperty().SetDiffuse(0.8)
+
+# Create the rendering window, renderer, and interactive renderer
+ren = vtk.vtkRenderer()
+renWin = vtk.vtkRenderWindow()
+renWin.AddRenderer(ren)
+iren = vtk.vtkRenderWindowInteractor()
+iren.SetRenderWindow(renWin)
+
+# Add the actors to the renderer, set the background and size
+ren.AddActor(meshActor)
+ren.AddActor(edgeActor)
+ren.SetBackground(0, 0, 0)
+renWin.SetSize(450, 300)
+
+ren.ResetCamera()
+ren.GetActiveCamera().Zoom(2)
+
+iren.Initialize()
+renWin.Render()
+iren.Start()

ParaView-5.0.1/VTK/Examples/Modelling/Python/expCos.py

@@ -0,0 +1,81 @@
+#!/usr/bin/env python
+
+# This example demonstrates how to use a programmable filter and how
+# to use the special vtkDataSetToDataSet::GetOutputPort() methods
+
+import vtk
+from math import *
+
+# We create a 100 by 100 point plane to sample
+plane = vtk.vtkPlaneSource()
+plane.SetXResolution(100)
+plane.SetYResolution(100)
+
+# We transform the plane by a factor of 10 on X and Y
+transform = vtk.vtkTransform()
+transform.Scale(10, 10, 1)
+transF = vtk.vtkTransformPolyDataFilter()
+transF.SetInputConnection(plane.GetOutputPort())
+transF.SetTransform(transform)
+
+# Compute Bessel function and derivatives. We'll use a programmable filter
+# for this. Note the unusual GetPolyDataInput() & GetOutputPort() methods.
+besselF = vtk.vtkProgrammableFilter()
+besselF.SetInputConnection(transF.GetOutputPort())
+
+# The SetExecuteMethod takes a Python function as an argument
+# In here is where all the processing is done.
+def bessel():
+    input = besselF.GetPolyDataInput()
+    numPts = input.GetNumberOfPoints()
+    newPts = vtk.vtkPoints()
+    derivs = vtk.vtkFloatArray()
+
+    for i in range(0, numPts):
+        x = input.GetPoint(i)
+        x0, x1 = x[:2]
+
+        r = sqrt(x0*x0+x1*x1)
+        x2 = exp(-r)*cos(10.0*r)
+        deriv = -exp(-r)*(cos(10.0*r)+10.0*sin(10.0*r))
+
+        newPts.InsertPoint(i, x0, x1, x2)
+        derivs.InsertValue(i, deriv)
+
+    besselF.GetPolyDataOutput().CopyStructure(input)
+    besselF.GetPolyDataOutput().SetPoints(newPts)
+    besselF.GetPolyDataOutput().GetPointData().SetScalars(derivs)
+
+besselF.SetExecuteMethod(bessel)
+
+# We warp the plane based on the scalar values calculated above
+warp = vtk.vtkWarpScalar()
+warp.SetInputConnection(besselF.GetOutputPort())
+warp.XYPlaneOn()
+warp.SetScaleFactor(0.5)
+
+
+# We create a mapper and actor as usual. In the case we adjust the
+# scalar range of the mapper to match that of the computed scalars
+mapper = vtk.vtkPolyDataMapper()
+mapper.SetInputConnection(warp.GetOutputPort())
+mapper.SetScalarRange(besselF.GetPolyDataOutput().GetScalarRange())
+carpet = vtk.vtkActor()
+carpet.SetMapper(mapper)
+
+# Create the RenderWindow, Renderer
+ren = vtk.vtkRenderer()
+renWin = vtk.vtkRenderWindow()
+renWin.AddRenderer(ren)
+iren = vtk.vtkRenderWindowInteractor()
+iren.SetRenderWindow(renWin)
+
+ren.AddActor(carpet)
+renWin.SetSize(500, 500)
+
+ren.ResetCamera()
+ren.GetActiveCamera().Zoom(1.5)
+
+iren.Initialize()
+renWin.Render()
+iren.Start()

ParaView-5.0.1/VTK/Examples/Modelling/Python/faultLines.py

@@ -0,0 +1,71 @@
+#!/usr/bin/env python
+
+# Create a constrained Delaunay triangulation following fault lines. The
+# fault lines serve as constraint edges in the Delaunay triangulation.
+
+import vtk
+from vtk.util.misc import vtkGetDataRoot
+from vtk.util.colors import *
+VTK_DATA_ROOT = vtkGetDataRoot()
+
+# Generate some points by reading a VTK data file. The data file also
+# has edges that represent constraint lines. This is originally from a
+# geologic horizon.
+reader = vtk.vtkPolyDataReader()
+reader.SetFileName(VTK_DATA_ROOT + "/Data/faults.vtk")
+
+# Perform a 2D triangulation with constraint edges.
+delny = vtk.vtkDelaunay2D()
+delny.SetInputConnection(reader.GetOutputPort())
+delny.SetSourceConnection(reader.GetOutputPort())
+delny.SetTolerance(0.00001)
+normals = vtk.vtkPolyDataNormals()
+normals.SetInputConnection(delny.GetOutputPort())
+mapMesh = vtk.vtkPolyDataMapper()
+mapMesh.SetInputConnection(normals.GetOutputPort())
+meshActor = vtk.vtkActor()
+meshActor.SetMapper(mapMesh)
+meshActor.GetProperty().SetColor(beige)
+
+# Now pretty up the mesh with tubed edges and balls at the vertices.
+tuber = vtk.vtkTubeFilter()
+tuber.SetInputConnection(reader.GetOutputPort())
+tuber.SetRadius(25)
+mapLines = vtk.vtkPolyDataMapper()
+mapLines.SetInputConnection(tuber.GetOutputPort())
+linesActor = vtk.vtkActor()
+linesActor.SetMapper(mapLines)
+linesActor.GetProperty().SetColor(1, 0, 0)
+linesActor.GetProperty().SetColor(tomato)
+
+# Create graphics objects
+# Create the rendering window, renderer, and interactive renderer
+ren = vtk.vtkRenderer()
+renWin = vtk.vtkRenderWindow()
+renWin.AddRenderer(ren)
+iren = vtk.vtkRenderWindowInteractor()
+iren.SetRenderWindow(renWin)
+
+# Add the actors to the renderer, set the background and size
+ren.AddActor(linesActor)
+ren.AddActor(meshActor)
+ren.SetBackground(1, 1, 1)
+renWin.SetSize(350, 250)
+
+cam1 = vtk.vtkCamera()
+cam1.SetClippingRange(2580, 129041)
+cam1.SetFocalPoint(461550, 6.58e+006, 2132)
+cam1.SetPosition(463960, 6.559e+06, 16982)
+cam1.SetViewUp(-0.321899, 0.522244, 0.78971)
+light = vtk.vtkLight()
+light.SetPosition(0, 0, 1)
+light.SetFocalPoint(0, 0, 0)
+ren.SetActiveCamera(cam1)
+ren.AddLight(light)
+
+ren.GetActiveCamera().Zoom(1.5)
+iren.LightFollowCameraOff()
+
+iren.Initialize()
+renWin.Render()
+iren.Start()

ParaView-5.0.1/VTK/Examples/Modelling/Python/hello.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python
+
+# This example demonstrates how to use implicit modelling.
+
+import vtk
+from vtk.util.misc import vtkGetDataRoot
+from vtk.util.colors import red, peacock
+VTK_DATA_ROOT = vtkGetDataRoot()
+
+# Create lines which serve as the "seed" geometry. The lines spell the
+# word "hello".
+reader = vtk.vtkPolyDataReader()
+reader.SetFileName(VTK_DATA_ROOT + "/Data/hello.vtk")
+lineMapper = vtk.vtkPolyDataMapper()
+lineMapper.SetInputConnection(reader.GetOutputPort())
+lineActor = vtk.vtkActor()
+lineActor.SetMapper(lineMapper)
+lineActor.GetProperty().SetColor(red)
+
+# Create implicit model with vtkImplicitModeller. This computes a
+# scalar field which is the distance from the generating geometry. The
+# contour filter then extracts the geoemtry at the distance value 0.25
+# from the generating geometry.
+imp = vtk.vtkImplicitModeller()
+imp.SetInputConnection(reader.GetOutputPort())
+imp.SetSampleDimensions(110, 40, 20)
+imp.SetMaximumDistance(0.25)
+imp.SetModelBounds(-1.0, 10.0, -1.0, 3.0, -1.0, 1.0)
+contour = vtk.vtkContourFilter()
+contour.SetInputConnection(imp.GetOutputPort())
+contour.SetValue(0, 0.25)
+impMapper = vtk.vtkPolyDataMapper()
+impMapper.SetInputConnection(contour.GetOutputPort())
+impMapper.ScalarVisibilityOff()
+impActor = vtk.vtkActor()
+impActor.SetMapper(impMapper)
+impActor.GetProperty().SetColor(peacock)
+impActor.GetProperty().SetOpacity(0.5)
+
+# Create the usual graphics stuff.
+# Create the RenderWindow, Renderer and both Actors
+ren = vtk.vtkRenderer()
+renWin = vtk.vtkRenderWindow()
+renWin.AddRenderer(ren)
+iren = vtk.vtkRenderWindowInteractor()
+iren.SetRenderWindow(renWin)
+
+# Add the actors to the renderer, set the background and size
+ren.AddActor(lineActor)
+ren.AddActor(impActor)
+ren.SetBackground(1, 1, 1)
+renWin.SetSize(600, 250)
+
+camera = vtk.vtkCamera()
+camera.SetClippingRange(1.81325, 90.6627)
+camera.SetFocalPoint(4.5, 1, 0)
+camera.SetPosition(4.5, 1.0, 6.73257)
+camera.SetViewUp(0, 1, 0)
+camera.Zoom(0.8)
+ren.SetActiveCamera(camera)
+
+iren.Initialize()
+renWin.Render()
+iren.Start()

ParaView-5.0.1/VTK/Examples/Modelling/Python/iceCream.py

@@ -0,0 +1,95 @@
+#!/usr/bin/env python
+
+# This example demonstrates how to use boolean combinations of implicit
+# functions to create a model of an ice cream cone.
+
+import vtk
+from vtk.util.colors import chocolate, mint
+
+# Create implicit function primitives. These have been carefully
+# placed to give the effect that we want. We are going to use various
+# combinations of these functions to create the shape we want; for
+# example, we use planes intersected with a cone (which is infinite in
+# extent) to get a finite cone.
+cone = vtk.vtkCone()
+cone.SetAngle(20)
+vertPlane = vtk.vtkPlane()
+vertPlane.SetOrigin(.1, 0, 0)
+vertPlane.SetNormal(-1, 0, 0)
+basePlane = vtk.vtkPlane()
+basePlane.SetOrigin(1.2, 0, 0)
+basePlane.SetNormal(1, 0, 0)
+iceCream = vtk.vtkSphere()
+iceCream.SetCenter(1.333, 0, 0)
+iceCream.SetRadius(0.5)
+bite = vtk.vtkSphere()
+bite.SetCenter(1.5, 0, 0.5)
+bite.SetRadius(0.25)
+
+# Combine primitives to build ice-cream cone. Clip the cone with planes.
+theCone = vtk.vtkImplicitBoolean()
+theCone.SetOperationTypeToIntersection()
+theCone.AddFunction(cone)
+theCone.AddFunction(vertPlane)
+theCone.AddFunction(basePlane)
+
+# Take a bite out of the ice cream.
+theCream = vtk.vtkImplicitBoolean()
+theCream.SetOperationTypeToDifference()
+theCream.AddFunction(iceCream)
+theCream.AddFunction(bite)
+
+# The sample function generates a distance function from the implicit
+# function (which in this case is the cone). This is then contoured to
+# get a polygonal surface.
+theConeSample = vtk.vtkSampleFunction()
+theConeSample.SetImplicitFunction(theCone)
+theConeSample.SetModelBounds(-1, 1.5, -1.25, 1.25, -1.25, 1.25)
+theConeSample.SetSampleDimensions(60, 60, 60)
+theConeSample.ComputeNormalsOff()
+theConeSurface = vtk.vtkContourFilter()
+theConeSurface.SetInputConnection(theConeSample.GetOutputPort())
+theConeSurface.SetValue(0, 0.0)
+coneMapper = vtk.vtkPolyDataMapper()
+coneMapper.SetInputConnection(theConeSurface.GetOutputPort())
+coneMapper.ScalarVisibilityOff()
+coneActor = vtk.vtkActor()
+coneActor.SetMapper(coneMapper)
+coneActor.GetProperty().SetColor(chocolate)
+
+# The same here for the ice cream.
+theCreamSample = vtk.vtkSampleFunction()
+theCreamSample.SetImplicitFunction(theCream)
+theCreamSample.SetModelBounds(0, 2.5, -1.25, 1.25, -1.25, 1.25)
+theCreamSample.SetSampleDimensions(60, 60, 60)
+theCreamSample.ComputeNormalsOff()
+theCreamSurface = vtk.vtkContourFilter()
+theCreamSurface.SetInputConnection(theCreamSample.GetOutputPort())
+theCreamSurface.SetValue(0, 0.0)
+creamMapper = vtk.vtkPolyDataMapper()
+creamMapper.SetInputConnection(theCreamSurface.GetOutputPort())
+creamMapper.ScalarVisibilityOff()
+creamActor = vtk.vtkActor()
+creamActor.SetMapper(creamMapper)
+creamActor.GetProperty().SetColor(mint)
+
+# Create the usual rendering stuff
+ren = vtk.vtkRenderer()
+renWin = vtk.vtkRenderWindow()
+renWin.AddRenderer(ren)
+iren = vtk.vtkRenderWindowInteractor()
+iren.SetRenderWindow(renWin)
+
+# Add the actors to the renderer, set the background and size
+ren.AddActor(coneActor)
+ren.AddActor(creamActor)
+ren.SetBackground(1, 1, 1)
+renWin.SetSize(250, 250)
+ren.ResetCamera()
+ren.GetActiveCamera().Roll(90)
+ren.GetActiveCamera().Dolly(1.5)
+ren.ResetCameraClippingRange()
+
+iren.Initialize()
+renWin.Render()
+iren.Start()

ParaView-5.0.1/VTK/Examples/Modelling/Python/procrustesAlignment.py

@@ -0,0 +1,184 @@
+#!/usr/bin/env python
+
+# This example shows how to align a set of objects together using the
+# Procrustes algorithm.  We make three ellipsoids by distorting and
+# translating a sphere and then align them together, using the
+# different modes of Procrustes alignment: rigid-body, similarity and
+# affine.
+
+import vtk
+
+sphere = vtk.vtkSphereSource()
+
+# make two copies of the shape and distort them a little
+transform1 = vtk.vtkTransform()
+transform1.Translate(0.2, 0.1, 0.3)
+transform1.Scale(1.3, 1.1, 0.8)
+
+transform2 = vtk.vtkTransform()
+transform2.Translate(0.3, 0.7, 0.1)
+transform2.Scale(1.0, 0.1, 1.8)
+
+transformer1 = vtk.vtkTransformPolyDataFilter()
+transformer1.SetInputConnection(sphere.GetOutputPort())
+transformer1.SetTransform(transform1)
+
+transformer2 = vtk.vtkTransformPolyDataFilter()
+transformer2.SetInputConnection(sphere.GetOutputPort())
+transformer2.SetTransform(transform2)
+
+group = vtk.vtkMultiBlockDataGroupFilter()
+group.AddInputConnection(sphere.GetOutputPort())
+group.AddInputConnection(transformer1.GetOutputPort())
+group.AddInputConnection(transformer2.GetOutputPort())
+
+# map these three shapes into the first renderer
+map1a = vtk.vtkPolyDataMapper()
+map1a.SetInputConnection(sphere.GetOutputPort())
+Actor1a = vtk.vtkActor()
+Actor1a.SetMapper(map1a)
+Actor1a.GetProperty().SetDiffuseColor(1.0000, 0.3882, 0.2784)
+
+map1b = vtk.vtkPolyDataMapper()
+map1b.SetInputConnection(transformer1.GetOutputPort())
+Actor1b = vtk.vtkActor()
+Actor1b.SetMapper(map1b)
+Actor1b.GetProperty().SetDiffuseColor(0.3882, 1.0000, 0.2784)
+
+map1c = vtk.vtkPolyDataMapper()
+map1c.SetInputConnection(transformer2.GetOutputPort())
+Actor1c = vtk.vtkActor()
+Actor1c.SetMapper(map1c)
+Actor1c.GetProperty().SetDiffuseColor(0.3882, 0.2784, 1.0000)
+
+# -- align the shapes using Procrustes (using SetModeToRigidBody) --
+procrustes1 = vtk.vtkProcrustesAlignmentFilter()
+procrustes1.SetInputConnection(group.GetOutputPort())
+procrustes1.GetLandmarkTransform().SetModeToRigidBody()
+procrustes1.Update()
+
+# map the aligned shapes into the second renderer
+map2a = vtk.vtkPolyDataMapper()
+map2a.SetInputData(procrustes1.GetOutput().GetBlock(0))
+Actor2a = vtk.vtkActor()
+Actor2a.SetMapper(map2a)
+Actor2a.GetProperty().SetDiffuseColor(1.0000, 0.3882, 0.2784)
+
+map2b = vtk.vtkPolyDataMapper()
+map2b.SetInputData(procrustes1.GetOutput().GetBlock(1))
+Actor2b = vtk.vtkActor()
+Actor2b.SetMapper(map2b)
+Actor2b.GetProperty().SetDiffuseColor(0.3882, 1.0000, 0.2784)
+
+map2c = vtk.vtkPolyDataMapper()
+map2c.SetInputData(procrustes1.GetOutput().GetBlock(2))
+Actor2c = vtk.vtkActor()
+Actor2c.SetMapper(map2c)
+Actor2c.GetProperty().SetDiffuseColor(0.3882, 0.2784, 1.0000)
+
+# -- align the shapes using Procrustes (using SetModeToSimilarity
+# (default)) --
+procrustes2 = vtk.vtkProcrustesAlignmentFilter()
+procrustes2.SetInputConnection(group.GetOutputPort())
+procrustes2.Update()
+
+# map the aligned shapes into the third renderer
+map3a = vtk.vtkPolyDataMapper()
+map3a.SetInputData(procrustes2.GetOutput().GetBlock(0))
+Actor3a = vtk.vtkActor()
+Actor3a.SetMapper(map3a)
+Actor3a.GetProperty().SetDiffuseColor(1.0000, 0.3882, 0.2784)
+
+map3b = vtk.vtkPolyDataMapper()
+map3b.SetInputData(procrustes2.GetOutput().GetBlock(1))
+Actor3b = vtk.vtkActor()
+Actor3b.SetMapper(map3b)
+Actor3b.GetProperty().SetDiffuseColor(0.3882, 1.0000, 0.2784)
+
+map3c = vtk.vtkPolyDataMapper()
+map3c.SetInputData(procrustes2.GetOutput().GetBlock(2))
+Actor3c = vtk.vtkActor()
+Actor3c.SetMapper(map3c)
+Actor3c.GetProperty().SetDiffuseColor(0.3882, 0.2784, 1.0000)
+
+# -- align the shapes using Procrustes (using SetModeToAffine) --
+procrustes3 = vtk.vtkProcrustesAlignmentFilter()
+procrustes3.SetInputConnection(group.GetOutputPort())
+procrustes3.GetLandmarkTransform().SetModeToAffine()
+procrustes3.Update()
+
+# map the aligned shapes into the fourth renderer
+map4a = vtk.vtkPolyDataMapper()
+map4a.SetInputData(procrustes3.GetOutput().GetBlock(0))
+Actor4a = vtk.vtkActor()
+Actor4a.SetMapper(map4a)
+Actor4a.GetProperty().SetDiffuseColor(1.0000, 0.3882, 0.2784)
+
+map4b = vtk.vtkPolyDataMapper()
+map4b.SetInputData(procrustes3.GetOutput().GetBlock(1))
+Actor4b = vtk.vtkActor()
+Actor4b.SetMapper(map4b)
+Actor4b.GetProperty().SetDiffuseColor(0.3882, 1.0000, 0.2784)
+
+map4c = vtk.vtkPolyDataMapper()
+map4c.SetInputData(procrustes3.GetOutput().GetBlock(2))
+Actor4c = vtk.vtkActor()
+Actor4c.SetMapper(map4c)
+Actor4c.GetProperty().SetDiffuseColor(0.3882, 0.2784, 1.0000)
+
+# Create the RenderWindow and its four Renderers
+ren = vtk.vtkRenderer()
+ren2 = vtk.vtkRenderer()
+ren3 = vtk.vtkRenderer()
+ren4 = vtk.vtkRenderer()
+renWin = vtk.vtkRenderWindow()
+renWin.AddRenderer(ren)
+renWin.AddRenderer(ren2)
+renWin.AddRenderer(ren3)
+renWin.AddRenderer(ren4)
+renWin.SetSize(400, 100)
+iren = vtk.vtkRenderWindowInteractor()
+iren.SetRenderWindow(renWin)
+
+# Add the actors to the renderer
+ren.AddActor(Actor1a)
+ren.AddActor(Actor1b)
+ren.AddActor(Actor1c)
+
+ren2.AddActor(Actor2a)
+ren2.AddActor(Actor2b)
+ren2.AddActor(Actor2c)
+
+ren3.AddActor(Actor3a)
+ren3.AddActor(Actor3b)
+ren3.AddActor(Actor3c)
+
+ren4.AddActor(Actor4a)
+ren4.AddActor(Actor4b)
+ren4.AddActor(Actor4c)
+
+# set the properties of the renderers
+ren.SetBackground(1, 1, 1)
+ren.SetViewport(0.0, 0.0, 0.25, 1.0)
+ren.GetActiveCamera().SetPosition(1, -1, 0)
+ren.ResetCamera()
+
+ren2.SetBackground(1, 1, 1)
+ren2.SetViewport(0.25, 0.0, 0.5, 1.0)
+ren2.GetActiveCamera().SetPosition(1, -1, 0)
+ren2.ResetCamera()
+
+ren3.SetBackground(1, 1, 1)
+ren3.SetViewport(0.5, 0.0, 0.75, 1.0)
+ren3.GetActiveCamera().SetPosition(1, -1, 0)
+ren3.ResetCamera()
+
+ren4.SetBackground(1, 1, 1)
+ren4.SetViewport(0.75, 0.0, 1.0, 1.0)
+ren4.GetActiveCamera().SetPosition(1, -1, 0)
+ren4.ResetCamera()
+
+# Render the image and start interaction.
+iren.Initialize()
+renWin.Render()
+iren.Start()

ParaView-5.0.1/VTK/Examples/Modelling/Python/reconstructSurface.py

@@ -0,0 +1,85 @@
+#!/usr/bin/env python
+
+# This example shows how to construct a surface from a point cloud.
+# First we generate a volume using the
+# vtkSurfaceReconstructionFilter. The volume values are a distance
+# field. Once this is generated, the volume is countoured at a
+# distance value of 0.0.
+
+import os
+import string
+import vtk
+from vtk.util.misc import vtkGetDataRoot
+VTK_DATA_ROOT = vtkGetDataRoot()
+
+# Read some points. Use a programmable filter to read them.
+pointSource = vtk.vtkProgrammableSource()
+
+def readPoints():
+    output = pointSource.GetPolyDataOutput()
+    points = vtk.vtkPoints()
+    output.SetPoints(points)
+
+    file = open(os.path.normpath(os.path.join(VTK_DATA_ROOT, "Data/cactus.3337.pts")))
+
+    line = file.readline()
+    while line:
+        data = line.split()
+        if data and data[0] == 'p':
+            x, y, z = float(data[1]), float(data[2]), float(data[3])
+            points.InsertNextPoint(x, y, z)
+        line = file.readline()
+
+pointSource.SetExecuteMethod(readPoints)
+
+
+# Construct the surface and create isosurface.
+surf = vtk.vtkSurfaceReconstructionFilter()
+surf.SetInputConnection(pointSource.GetOutputPort())
+
+cf = vtk.vtkContourFilter()
+cf.SetInputConnection(surf.GetOutputPort())
+cf.SetValue(0, 0.0)
+
+# Sometimes the contouring algorithm can create a volume whose gradient
+# vector and ordering of polygon (using the right hand rule) are
+# inconsistent. vtkReverseSense cures this problem.
+reverse = vtk.vtkReverseSense()
+reverse.SetInputConnection(cf.GetOutputPort())
+reverse.ReverseCellsOn()
+reverse.ReverseNormalsOn()
+
+map = vtk.vtkPolyDataMapper()
+map.SetInputConnection(reverse.GetOutputPort())
+map.ScalarVisibilityOff()
+
+surfaceActor = vtk.vtkActor()
+surfaceActor.SetMapper(map)
+surfaceActor.GetProperty().SetDiffuseColor(1.0000, 0.3882, 0.2784)
+surfaceActor.GetProperty().SetSpecularColor(1, 1, 1)
+surfaceActor.GetProperty().SetSpecular(.4)
+surfaceActor.GetProperty().SetSpecularPower(50)
+
+# Create the RenderWindow, Renderer and both Actors
+ren = vtk.vtkRenderer()
+renWin = vtk.vtkRenderWindow()
+renWin.AddRenderer(ren)
+iren = vtk.vtkRenderWindowInteractor()
+iren.SetRenderWindow(renWin)
+
+# Add the actors to the renderer, set the background and size
+ren.AddActor(surfaceActor)
+ren.SetBackground(1, 1, 1)
+renWin.SetSize(400, 400)
+ren.GetActiveCamera().SetFocalPoint(0, 0, 0)
+ren.GetActiveCamera().SetPosition(1, 0, 0)
+ren.GetActiveCamera().SetViewUp(0, 0, 1)
+ren.ResetCamera()
+ren.GetActiveCamera().Azimuth(20)
+ren.GetActiveCamera().Elevation(30)
+ren.GetActiveCamera().Dolly(1.2)
+ren.ResetCameraClippingRange()
+
+iren.Initialize()
+renWin.Render()
+iren.Start()