mirror of
https://github.com/OpenFOAM/ThirdParty-6.git
synced 2025-12-08 06:57:43 +00:00
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
This commit is contained in:
Henry Weller
89
ParaView-5.0.1/VTK/Examples/DataManipulation/Python/Arrays.py
Executable file
89
ParaView-5.0.1/VTK/Examples/DataManipulation/Python/Arrays.py
Executable file
@ -0,0 +1,89 @@
|
||||
#!/usr/bin/env python
|
||||
|
||||
# This example demonstrates the use of VTK data arrays as attribute
|
||||
# data as well as field data. It creates geometry (vtkPolyData) as
|
||||
# well as attribute data explicitly.
|
||||
|
||||
import vtk
|
||||
|
||||
# Create a float array which represents the points.
|
||||
pcoords = vtk.vtkFloatArray()
|
||||
# Note that by default, an array has 1 component.
|
||||
# We have to change it to 3 for points
|
||||
pcoords.SetNumberOfComponents(3)
|
||||
# We ask pcoords to allocate room for at least 4 tuples
|
||||
# and set the number of tuples to 4.
|
||||
pcoords.SetNumberOfTuples(4)
|
||||
# Assign each tuple. There are 5 specialized versions of SetTuple:
|
||||
# SetTuple1 SetTuple2 SetTuple3 SetTuple4 SetTuple9
|
||||
# These take 1, 2, 3, 4 and 9 components respectively.
|
||||
pcoords.SetTuple3(0, 0.0, 0.0, 0.0)
|
||||
pcoords.SetTuple3(1, 0.0, 1.0, 0.0)
|
||||
pcoords.SetTuple3(2, 1.0, 0.0, 0.0)
|
||||
pcoords.SetTuple3(3, 1.0, 1.0, 0.0)
|
||||
|
||||
# Create vtkPoints and assign pcoords as the internal data array.
|
||||
points = vtk.vtkPoints()
|
||||
points.SetData(pcoords)
|
||||
|
||||
# Create the cells. In this case, a triangle strip with 2 triangles
|
||||
# (which can be represented by 4 points)
|
||||
strips = vtk.vtkCellArray()
|
||||
strips.InsertNextCell(4)
|
||||
strips.InsertCellPoint(0)
|
||||
strips.InsertCellPoint(1)
|
||||
strips.InsertCellPoint(2)
|
||||
strips.InsertCellPoint(3)
|
||||
|
||||
# Create an integer array with 4 tuples. Note that when using
|
||||
# InsertNextValue (or InsertNextTuple1 which is equivalent in
|
||||
# this situation), the array will expand automatically
|
||||
temperature = vtk.vtkIntArray()
|
||||
temperature.SetName("Temperature")
|
||||
temperature.InsertNextValue(10)
|
||||
temperature.InsertNextValue(20)
|
||||
temperature.InsertNextValue(30)
|
||||
temperature.InsertNextValue(40)
|
||||
|
||||
# Create a double array.
|
||||
vorticity = vtk.vtkDoubleArray()
|
||||
vorticity.SetName("Vorticity")
|
||||
vorticity.InsertNextValue(2.7)
|
||||
vorticity.InsertNextValue(4.1)
|
||||
vorticity.InsertNextValue(5.3)
|
||||
vorticity.InsertNextValue(3.4)
|
||||
|
||||
# Create the dataset. In this case, we create a vtkPolyData
|
||||
polydata = vtk.vtkPolyData()
|
||||
# Assign points and cells
|
||||
polydata.SetPoints(points)
|
||||
polydata.SetStrips(strips)
|
||||
# Assign scalars
|
||||
polydata.GetPointData().SetScalars(temperature)
|
||||
# Add the vorticity array. In this example, this field
|
||||
# is not used.
|
||||
polydata.GetPointData().AddArray(vorticity)
|
||||
|
||||
# Create the mapper and set the appropriate scalar range
|
||||
# (default is (0,1)
|
||||
mapper = vtk.vtkPolyDataMapper()
|
||||
mapper.SetInputData(polydata)
|
||||
mapper.SetScalarRange(0, 40)
|
||||
|
||||
# Create an actor.
|
||||
actor = vtk.vtkActor()
|
||||
actor.SetMapper(mapper)
|
||||
|
||||
# Create the rendering objects.
|
||||
ren = vtk.vtkRenderer()
|
||||
ren.AddActor(actor)
|
||||
|
||||
renWin = vtk.vtkRenderWindow()
|
||||
renWin.AddRenderer(ren)
|
||||
|
||||
iren = vtk.vtkRenderWindowInteractor()
|
||||
iren.SetRenderWindow(renWin)
|
||||
|
||||
iren.Initialize()
|
||||
renWin.Render()
|
||||
iren.Start()
|
||||
386
ParaView-5.0.1/VTK/Examples/DataManipulation/Python/BuildUGrid.py
Executable file
386
ParaView-5.0.1/VTK/Examples/DataManipulation/Python/BuildUGrid.py
Executable file
@ -0,0 +1,386 @@
|
||||
#!/usr/bin/env python
|
||||
|
||||
# This example shows how to manually construct unstructured grids
|
||||
# using Python. Unstructured grids require explicit point and cell
|
||||
# representations, so every point and cell must be created, and then
|
||||
# added to the vtkUnstructuredGrid instance.
|
||||
|
||||
import vtk
|
||||
|
||||
# Create several unstructured grids each containing a cell of a
|
||||
# different type.
|
||||
voxelPoints = vtk.vtkPoints()
|
||||
voxelPoints.SetNumberOfPoints(8)
|
||||
voxelPoints.InsertPoint(0, 0, 0, 0)
|
||||
voxelPoints.InsertPoint(1, 1, 0, 0)
|
||||
voxelPoints.InsertPoint(2, 0, 1, 0)
|
||||
voxelPoints.InsertPoint(3, 1, 1, 0)
|
||||
voxelPoints.InsertPoint(4, 0, 0, 1)
|
||||
voxelPoints.InsertPoint(5, 1, 0, 1)
|
||||
voxelPoints.InsertPoint(6, 0, 1, 1)
|
||||
voxelPoints.InsertPoint(7, 1, 1, 1)
|
||||
aVoxel = vtk.vtkVoxel()
|
||||
aVoxel.GetPointIds().SetId(0, 0)
|
||||
aVoxel.GetPointIds().SetId(1, 1)
|
||||
aVoxel.GetPointIds().SetId(2, 2)
|
||||
aVoxel.GetPointIds().SetId(3, 3)
|
||||
aVoxel.GetPointIds().SetId(4, 4)
|
||||
aVoxel.GetPointIds().SetId(5, 5)
|
||||
aVoxel.GetPointIds().SetId(6, 6)
|
||||
aVoxel.GetPointIds().SetId(7, 7)
|
||||
aVoxelGrid = vtk.vtkUnstructuredGrid()
|
||||
aVoxelGrid.Allocate(1, 1)
|
||||
aVoxelGrid.InsertNextCell(aVoxel.GetCellType(), aVoxel.GetPointIds())
|
||||
aVoxelGrid.SetPoints(voxelPoints)
|
||||
aVoxelMapper = vtk.vtkDataSetMapper()
|
||||
aVoxelMapper.SetInputData(aVoxelGrid)
|
||||
aVoxelActor = vtk.vtkActor()
|
||||
aVoxelActor.SetMapper(aVoxelMapper)
|
||||
aVoxelActor.GetProperty().SetDiffuseColor(1, 0, 0)
|
||||
|
||||
hexahedronPoints = vtk.vtkPoints()
|
||||
hexahedronPoints.SetNumberOfPoints(8)
|
||||
hexahedronPoints.InsertPoint(0, 0, 0, 0)
|
||||
hexahedronPoints.InsertPoint(1, 1, 0, 0)
|
||||
hexahedronPoints.InsertPoint(2, 1, 1, 0)
|
||||
hexahedronPoints.InsertPoint(3, 0, 1, 0)
|
||||
hexahedronPoints.InsertPoint(4, 0, 0, 1)
|
||||
hexahedronPoints.InsertPoint(5, 1, 0, 1)
|
||||
hexahedronPoints.InsertPoint(6, 1, 1, 1)
|
||||
hexahedronPoints.InsertPoint(7, 0, 1, 1)
|
||||
aHexahedron = vtk.vtkHexahedron()
|
||||
aHexahedron.GetPointIds().SetId(0, 0)
|
||||
aHexahedron.GetPointIds().SetId(1, 1)
|
||||
aHexahedron.GetPointIds().SetId(2, 2)
|
||||
aHexahedron.GetPointIds().SetId(3, 3)
|
||||
aHexahedron.GetPointIds().SetId(4, 4)
|
||||
aHexahedron.GetPointIds().SetId(5, 5)
|
||||
aHexahedron.GetPointIds().SetId(6, 6)
|
||||
aHexahedron.GetPointIds().SetId(7, 7)
|
||||
aHexahedronGrid = vtk.vtkUnstructuredGrid()
|
||||
aHexahedronGrid.Allocate(1, 1)
|
||||
aHexahedronGrid.InsertNextCell(aHexahedron.GetCellType(),
|
||||
aHexahedron.GetPointIds())
|
||||
aHexahedronGrid.SetPoints(hexahedronPoints)
|
||||
aHexahedronMapper = vtk.vtkDataSetMapper()
|
||||
aHexahedronMapper.SetInputData(aHexahedronGrid)
|
||||
aHexahedronActor = vtk.vtkActor()
|
||||
aHexahedronActor.SetMapper(aHexahedronMapper)
|
||||
aHexahedronActor.AddPosition(2, 0, 0)
|
||||
aHexahedronActor.GetProperty().SetDiffuseColor(1, 1, 0)
|
||||
|
||||
tetraPoints = vtk.vtkPoints()
|
||||
tetraPoints.SetNumberOfPoints(4)
|
||||
tetraPoints.InsertPoint(0, 0, 0, 0)
|
||||
tetraPoints.InsertPoint(1, 1, 0, 0)
|
||||
tetraPoints.InsertPoint(2, .5, 1, 0)
|
||||
tetraPoints.InsertPoint(3, .5, .5, 1)
|
||||
aTetra = vtk.vtkTetra()
|
||||
aTetra.GetPointIds().SetId(0, 0)
|
||||
aTetra.GetPointIds().SetId(1, 1)
|
||||
aTetra.GetPointIds().SetId(2, 2)
|
||||
aTetra.GetPointIds().SetId(3, 3)
|
||||
aTetraGrid = vtk.vtkUnstructuredGrid()
|
||||
aTetraGrid.Allocate(1, 1)
|
||||
aTetraGrid.InsertNextCell(aTetra.GetCellType(), aTetra.GetPointIds())
|
||||
aTetraGrid.SetPoints(tetraPoints)
|
||||
aTetraMapper = vtk.vtkDataSetMapper()
|
||||
aTetraMapper.SetInputData(aTetraGrid)
|
||||
aTetraActor = vtk.vtkActor()
|
||||
aTetraActor.SetMapper(aTetraMapper)
|
||||
aTetraActor.AddPosition(4, 0, 0)
|
||||
aTetraActor.GetProperty().SetDiffuseColor(0, 1, 0)
|
||||
|
||||
wedgePoints = vtk.vtkPoints()
|
||||
wedgePoints.SetNumberOfPoints(6)
|
||||
wedgePoints.InsertPoint(0, 0, 1, 0)
|
||||
wedgePoints.InsertPoint(1, 0, 0, 0)
|
||||
wedgePoints.InsertPoint(2, 0, .5, .5)
|
||||
wedgePoints.InsertPoint(3, 1, 1, 0)
|
||||
wedgePoints.InsertPoint(4, 1, 0, 0)
|
||||
wedgePoints.InsertPoint(5, 1, .5, .5)
|
||||
aWedge = vtk.vtkWedge()
|
||||
aWedge.GetPointIds().SetId(0, 0)
|
||||
aWedge.GetPointIds().SetId(1, 1)
|
||||
aWedge.GetPointIds().SetId(2, 2)
|
||||
aWedge.GetPointIds().SetId(3, 3)
|
||||
aWedge.GetPointIds().SetId(4, 4)
|
||||
aWedge.GetPointIds().SetId(5, 5)
|
||||
aWedgeGrid = vtk.vtkUnstructuredGrid()
|
||||
aWedgeGrid.Allocate(1, 1)
|
||||
aWedgeGrid.InsertNextCell(aWedge.GetCellType(), aWedge.GetPointIds())
|
||||
aWedgeGrid.SetPoints(wedgePoints)
|
||||
aWedgeMapper = vtk.vtkDataSetMapper()
|
||||
aWedgeMapper.SetInputData(aWedgeGrid)
|
||||
aWedgeActor = vtk.vtkActor()
|
||||
aWedgeActor.SetMapper(aWedgeMapper)
|
||||
aWedgeActor.AddPosition(6, 0, 0)
|
||||
aWedgeActor.GetProperty().SetDiffuseColor(0, 1, 1)
|
||||
|
||||
pyramidPoints = vtk.vtkPoints()
|
||||
pyramidPoints.SetNumberOfPoints(5)
|
||||
pyramidPoints.InsertPoint(0, 0, 0, 0)
|
||||
pyramidPoints.InsertPoint(1, 1, 0, 0)
|
||||
pyramidPoints.InsertPoint(2, 1, 1, 0)
|
||||
pyramidPoints.InsertPoint(3, 0, 1, 0)
|
||||
pyramidPoints.InsertPoint(4, .5, .5, 1)
|
||||
aPyramid = vtk.vtkPyramid()
|
||||
aPyramid.GetPointIds().SetId(0, 0)
|
||||
aPyramid.GetPointIds().SetId(1, 1)
|
||||
aPyramid.GetPointIds().SetId(2, 2)
|
||||
aPyramid.GetPointIds().SetId(3, 3)
|
||||
aPyramid.GetPointIds().SetId(4, 4)
|
||||
aPyramidGrid = vtk.vtkUnstructuredGrid()
|
||||
aPyramidGrid.Allocate(1, 1)
|
||||
aPyramidGrid.InsertNextCell(aPyramid.GetCellType(), aPyramid.GetPointIds())
|
||||
aPyramidGrid.SetPoints(pyramidPoints)
|
||||
aPyramidMapper = vtk.vtkDataSetMapper()
|
||||
aPyramidMapper.SetInputData(aPyramidGrid)
|
||||
aPyramidActor = vtk.vtkActor()
|
||||
aPyramidActor.SetMapper(aPyramidMapper)
|
||||
aPyramidActor.AddPosition(8, 0, 0)
|
||||
aPyramidActor.GetProperty().SetDiffuseColor(1, 0, 1)
|
||||
|
||||
pixelPoints = vtk.vtkPoints()
|
||||
pixelPoints.SetNumberOfPoints(4)
|
||||
pixelPoints.InsertPoint(0, 0, 0, 0)
|
||||
pixelPoints.InsertPoint(1, 1, 0, 0)
|
||||
pixelPoints.InsertPoint(2, 0, 1, 0)
|
||||
pixelPoints.InsertPoint(3, 1, 1, 0)
|
||||
aPixel = vtk.vtkPixel()
|
||||
aPixel.GetPointIds().SetId(0, 0)
|
||||
aPixel.GetPointIds().SetId(1, 1)
|
||||
aPixel.GetPointIds().SetId(2, 2)
|
||||
aPixel.GetPointIds().SetId(3, 3)
|
||||
aPixelGrid = vtk.vtkUnstructuredGrid()
|
||||
aPixelGrid.Allocate(1, 1)
|
||||
aPixelGrid.InsertNextCell(aPixel.GetCellType(), aPixel.GetPointIds())
|
||||
aPixelGrid.SetPoints(pixelPoints)
|
||||
aPixelMapper = vtk.vtkDataSetMapper()
|
||||
aPixelMapper.SetInputData(aPixelGrid)
|
||||
aPixelActor = vtk.vtkActor()
|
||||
aPixelActor.SetMapper(aPixelMapper)
|
||||
aPixelActor.AddPosition(0, 0, 2)
|
||||
aPixelActor.GetProperty().SetDiffuseColor(0, 1, 1)
|
||||
|
||||
quadPoints = vtk.vtkPoints()
|
||||
quadPoints.SetNumberOfPoints(4)
|
||||
quadPoints.InsertPoint(0, 0, 0, 0)
|
||||
quadPoints.InsertPoint(1, 1, 0, 0)
|
||||
quadPoints.InsertPoint(2, 1, 1, 0)
|
||||
quadPoints.InsertPoint(3, 0, 1, 0)
|
||||
aQuad = vtk.vtkQuad()
|
||||
aQuad.GetPointIds().SetId(0, 0)
|
||||
aQuad.GetPointIds().SetId(1, 1)
|
||||
aQuad.GetPointIds().SetId(2, 2)
|
||||
aQuad.GetPointIds().SetId(3, 3)
|
||||
aQuadGrid = vtk.vtkUnstructuredGrid()
|
||||
aQuadGrid.Allocate(1, 1)
|
||||
aQuadGrid.InsertNextCell(aQuad.GetCellType(), aQuad.GetPointIds())
|
||||
aQuadGrid.SetPoints(quadPoints)
|
||||
aQuadMapper = vtk.vtkDataSetMapper()
|
||||
aQuadMapper.SetInputData(aQuadGrid)
|
||||
aQuadActor = vtk.vtkActor()
|
||||
aQuadActor.SetMapper(aQuadMapper)
|
||||
aQuadActor.AddPosition(2, 0, 2)
|
||||
aQuadActor.GetProperty().SetDiffuseColor(1, 0, 1)
|
||||
|
||||
trianglePoints = vtk.vtkPoints()
|
||||
trianglePoints.SetNumberOfPoints(3)
|
||||
trianglePoints.InsertPoint(0, 0, 0, 0)
|
||||
trianglePoints.InsertPoint(1, 1, 0, 0)
|
||||
trianglePoints.InsertPoint(2, .5, .5, 0)
|
||||
triangleTCoords = vtk.vtkFloatArray()
|
||||
triangleTCoords.SetNumberOfComponents(3)
|
||||
triangleTCoords.SetNumberOfTuples(3)
|
||||
triangleTCoords.InsertTuple3(0, 1, 1, 1)
|
||||
triangleTCoords.InsertTuple3(1, 2, 2, 2)
|
||||
triangleTCoords.InsertTuple3(2, 3, 3, 3)
|
||||
aTriangle = vtk.vtkTriangle()
|
||||
aTriangle.GetPointIds().SetId(0, 0)
|
||||
aTriangle.GetPointIds().SetId(1, 1)
|
||||
aTriangle.GetPointIds().SetId(2, 2)
|
||||
aTriangleGrid = vtk.vtkUnstructuredGrid()
|
||||
aTriangleGrid.Allocate(1, 1)
|
||||
aTriangleGrid.InsertNextCell(aTriangle.GetCellType(),
|
||||
aTriangle.GetPointIds())
|
||||
aTriangleGrid.SetPoints(trianglePoints)
|
||||
aTriangleGrid.GetPointData().SetTCoords(triangleTCoords)
|
||||
aTriangleMapper = vtk.vtkDataSetMapper()
|
||||
aTriangleMapper.SetInputData(aTriangleGrid)
|
||||
aTriangleActor = vtk.vtkActor()
|
||||
aTriangleActor.SetMapper(aTriangleMapper)
|
||||
aTriangleActor.AddPosition(4, 0, 2)
|
||||
aTriangleActor.GetProperty().SetDiffuseColor(.3, 1, .5)
|
||||
|
||||
polygonPoints = vtk.vtkPoints()
|
||||
polygonPoints.SetNumberOfPoints(4)
|
||||
polygonPoints.InsertPoint(0, 0, 0, 0)
|
||||
polygonPoints.InsertPoint(1, 1, 0, 0)
|
||||
polygonPoints.InsertPoint(2, 1, 1, 0)
|
||||
polygonPoints.InsertPoint(3, 0, 1, 0)
|
||||
aPolygon = vtk.vtkPolygon()
|
||||
aPolygon.GetPointIds().SetNumberOfIds(4)
|
||||
aPolygon.GetPointIds().SetId(0, 0)
|
||||
aPolygon.GetPointIds().SetId(1, 1)
|
||||
aPolygon.GetPointIds().SetId(2, 2)
|
||||
aPolygon.GetPointIds().SetId(3, 3)
|
||||
aPolygonGrid = vtk.vtkUnstructuredGrid()
|
||||
aPolygonGrid.Allocate(1, 1)
|
||||
aPolygonGrid.InsertNextCell(aPolygon.GetCellType(), aPolygon.GetPointIds())
|
||||
aPolygonGrid.SetPoints(polygonPoints)
|
||||
aPolygonMapper = vtk.vtkDataSetMapper()
|
||||
aPolygonMapper.SetInputData(aPolygonGrid)
|
||||
aPolygonActor = vtk.vtkActor()
|
||||
aPolygonActor.SetMapper(aPolygonMapper)
|
||||
aPolygonActor.AddPosition(6, 0, 2)
|
||||
aPolygonActor.GetProperty().SetDiffuseColor(1, .4, .5)
|
||||
|
||||
triangleStripPoints = vtk.vtkPoints()
|
||||
triangleStripPoints.SetNumberOfPoints(5)
|
||||
triangleStripPoints.InsertPoint(0, 0, 1, 0)
|
||||
triangleStripPoints.InsertPoint(1, 0, 0, 0)
|
||||
triangleStripPoints.InsertPoint(2, 1, 1, 0)
|
||||
triangleStripPoints.InsertPoint(3, 1, 0, 0)
|
||||
triangleStripPoints.InsertPoint(4, 2, 1, 0)
|
||||
triangleStripTCoords = vtk.vtkFloatArray()
|
||||
triangleStripTCoords.SetNumberOfComponents(3)
|
||||
triangleStripTCoords.SetNumberOfTuples(3)
|
||||
triangleStripTCoords.InsertTuple3(0, 1, 1, 1)
|
||||
triangleStripTCoords.InsertTuple3(1, 2, 2, 2)
|
||||
triangleStripTCoords.InsertTuple3(2, 3, 3, 3)
|
||||
triangleStripTCoords.InsertTuple3(3, 4, 4, 4)
|
||||
triangleStripTCoords.InsertTuple3(4, 5, 5, 5)
|
||||
aTriangleStrip = vtk.vtkTriangleStrip()
|
||||
aTriangleStrip.GetPointIds().SetNumberOfIds(5)
|
||||
aTriangleStrip.GetPointIds().SetId(0, 0)
|
||||
aTriangleStrip.GetPointIds().SetId(1, 1)
|
||||
aTriangleStrip.GetPointIds().SetId(2, 2)
|
||||
aTriangleStrip.GetPointIds().SetId(3, 3)
|
||||
aTriangleStrip.GetPointIds().SetId(4, 4)
|
||||
aTriangleStripGrid = vtk.vtkUnstructuredGrid()
|
||||
aTriangleStripGrid.Allocate(1, 1)
|
||||
aTriangleStripGrid.InsertNextCell(aTriangleStrip.GetCellType(),
|
||||
aTriangleStrip.GetPointIds())
|
||||
aTriangleStripGrid.SetPoints(triangleStripPoints)
|
||||
aTriangleStripGrid.GetPointData().SetTCoords(triangleStripTCoords)
|
||||
aTriangleStripMapper = vtk.vtkDataSetMapper()
|
||||
aTriangleStripMapper.SetInputData(aTriangleStripGrid)
|
||||
aTriangleStripActor = vtk.vtkActor()
|
||||
aTriangleStripActor.SetMapper(aTriangleStripMapper)
|
||||
aTriangleStripActor.AddPosition(8, 0, 2)
|
||||
aTriangleStripActor.GetProperty().SetDiffuseColor(.3, .7, 1)
|
||||
|
||||
linePoints = vtk.vtkPoints()
|
||||
linePoints.SetNumberOfPoints(2)
|
||||
linePoints.InsertPoint(0, 0, 0, 0)
|
||||
linePoints.InsertPoint(1, 1, 1, 0)
|
||||
aLine = vtk.vtkLine()
|
||||
aLine.GetPointIds().SetId(0, 0)
|
||||
aLine.GetPointIds().SetId(1, 1)
|
||||
aLineGrid = vtk.vtkUnstructuredGrid()
|
||||
aLineGrid.Allocate(1, 1)
|
||||
aLineGrid.InsertNextCell(aLine.GetCellType(), aLine.GetPointIds())
|
||||
aLineGrid.SetPoints(linePoints)
|
||||
aLineMapper = vtk.vtkDataSetMapper()
|
||||
aLineMapper.SetInputData(aLineGrid)
|
||||
aLineActor = vtk.vtkActor()
|
||||
aLineActor.SetMapper(aLineMapper)
|
||||
aLineActor.AddPosition(0, 0, 4)
|
||||
aLineActor.GetProperty().SetDiffuseColor(.2, 1, 1)
|
||||
|
||||
polyLinePoints = vtk.vtkPoints()
|
||||
polyLinePoints.SetNumberOfPoints(3)
|
||||
polyLinePoints.InsertPoint(0, 0, 0, 0)
|
||||
polyLinePoints.InsertPoint(1, 1, 1, 0)
|
||||
polyLinePoints.InsertPoint(2, 1, 0, 0)
|
||||
aPolyLine = vtk.vtkPolyLine()
|
||||
aPolyLine.GetPointIds().SetNumberOfIds(3)
|
||||
aPolyLine.GetPointIds().SetId(0, 0)
|
||||
aPolyLine.GetPointIds().SetId(1, 1)
|
||||
aPolyLine.GetPointIds().SetId(2, 2)
|
||||
aPolyLineGrid = vtk.vtkUnstructuredGrid()
|
||||
aPolyLineGrid.Allocate(1, 1)
|
||||
aPolyLineGrid.InsertNextCell(aPolyLine.GetCellType(),
|
||||
aPolyLine.GetPointIds())
|
||||
aPolyLineGrid.SetPoints(polyLinePoints)
|
||||
aPolyLineMapper = vtk.vtkDataSetMapper()
|
||||
aPolyLineMapper.SetInputData(aPolyLineGrid)
|
||||
aPolyLineActor = vtk.vtkActor()
|
||||
aPolyLineActor.SetMapper(aPolyLineMapper)
|
||||
aPolyLineActor.AddPosition(2, 0, 4)
|
||||
aPolyLineActor.GetProperty().SetDiffuseColor(1, 1, 1)
|
||||
|
||||
vertexPoints = vtk.vtkPoints()
|
||||
vertexPoints.SetNumberOfPoints(1)
|
||||
vertexPoints.InsertPoint(0, 0, 0, 0)
|
||||
aVertex = vtk.vtkVertex()
|
||||
aVertex.GetPointIds().SetId(0, 0)
|
||||
aVertexGrid = vtk.vtkUnstructuredGrid()
|
||||
aVertexGrid.Allocate(1, 1)
|
||||
aVertexGrid.InsertNextCell(aVertex.GetCellType(), aVertex.GetPointIds())
|
||||
aVertexGrid.SetPoints(vertexPoints)
|
||||
aVertexMapper = vtk.vtkDataSetMapper()
|
||||
aVertexMapper.SetInputData(aVertexGrid)
|
||||
aVertexActor = vtk.vtkActor()
|
||||
aVertexActor.SetMapper(aVertexMapper)
|
||||
aVertexActor.AddPosition(0, 0, 6)
|
||||
aVertexActor.GetProperty().SetDiffuseColor(1, 1, 1)
|
||||
|
||||
polyVertexPoints = vtk.vtkPoints()
|
||||
polyVertexPoints.SetNumberOfPoints(3)
|
||||
polyVertexPoints.InsertPoint(0, 0, 0, 0)
|
||||
polyVertexPoints.InsertPoint(1, 1, 0, 0)
|
||||
polyVertexPoints.InsertPoint(2, 1, 1, 0)
|
||||
aPolyVertex = vtk.vtkPolyVertex()
|
||||
aPolyVertex.GetPointIds().SetNumberOfIds(3)
|
||||
aPolyVertex.GetPointIds().SetId(0, 0)
|
||||
aPolyVertex.GetPointIds().SetId(1, 1)
|
||||
aPolyVertex.GetPointIds().SetId(2, 2)
|
||||
aPolyVertexGrid = vtk.vtkUnstructuredGrid()
|
||||
aPolyVertexGrid.Allocate(1, 1)
|
||||
aPolyVertexGrid.InsertNextCell(aPolyVertex.GetCellType(),
|
||||
aPolyVertex.GetPointIds())
|
||||
aPolyVertexGrid.SetPoints(polyVertexPoints)
|
||||
aPolyVertexMapper = vtk.vtkDataSetMapper()
|
||||
aPolyVertexMapper.SetInputData(aPolyVertexGrid)
|
||||
aPolyVertexActor = vtk.vtkActor()
|
||||
aPolyVertexActor.SetMapper(aPolyVertexMapper)
|
||||
aPolyVertexActor.AddPosition(2, 0, 6)
|
||||
aPolyVertexActor.GetProperty().SetDiffuseColor(1, 1, 1)
|
||||
|
||||
# Create the usual rendering stuff.
|
||||
ren = vtk.vtkRenderer()
|
||||
renWin = vtk.vtkRenderWindow()
|
||||
renWin.AddRenderer(ren)
|
||||
renWin.SetSize(300, 150)
|
||||
iren = vtk.vtkRenderWindowInteractor()
|
||||
iren.SetRenderWindow(renWin)
|
||||
|
||||
ren.SetBackground(.1, .2, .4)
|
||||
|
||||
ren.AddActor(aVoxelActor)
|
||||
ren.AddActor(aHexahedronActor)
|
||||
ren.AddActor(aTetraActor)
|
||||
ren.AddActor(aWedgeActor)
|
||||
ren.AddActor(aPyramidActor)
|
||||
ren.AddActor(aPixelActor)
|
||||
ren.AddActor(aQuadActor)
|
||||
ren.AddActor(aTriangleActor)
|
||||
ren.AddActor(aPolygonActor)
|
||||
ren.AddActor(aTriangleStripActor)
|
||||
ren.AddActor(aLineActor)
|
||||
ren.AddActor(aPolyLineActor)
|
||||
ren.AddActor(aVertexActor)
|
||||
ren.AddActor(aPolyVertexActor)
|
||||
|
||||
ren.ResetCamera()
|
||||
ren.GetActiveCamera().Azimuth(30)
|
||||
ren.GetActiveCamera().Elevation(20)
|
||||
ren.GetActiveCamera().Dolly(2.8)
|
||||
ren.ResetCameraClippingRange()
|
||||
|
||||
# Render the scene and start interaction.
|
||||
iren.Initialize()
|
||||
renWin.Render()
|
||||
iren.Start()
|
||||
59
ParaView-5.0.1/VTK/Examples/DataManipulation/Python/CreateStrip.py
Executable file
59
ParaView-5.0.1/VTK/Examples/DataManipulation/Python/CreateStrip.py
Executable file
@ -0,0 +1,59 @@
|
||||
#!/usr/bin/env python
|
||||
|
||||
# This script shows how to manually create a vtkPolyData with a
|
||||
# triangle strip.
|
||||
|
||||
import vtk
|
||||
|
||||
# First we'll create some points.
|
||||
points = vtk.vtkPoints()
|
||||
points.InsertPoint(0, 0.0, 0.0, 0.0)
|
||||
points.InsertPoint(1, 0.0, 1.0, 0.0)
|
||||
points.InsertPoint(2, 1.0, 0.0, 0.0)
|
||||
points.InsertPoint(3, 1.0, 1.0, 0.0)
|
||||
points.InsertPoint(4, 2.0, 0.0, 0.0)
|
||||
points.InsertPoint(5, 2.0, 1.0, 0.0)
|
||||
points.InsertPoint(6, 3.0, 0.0, 0.0)
|
||||
points.InsertPoint(7, 3.0, 1.0, 0.0)
|
||||
|
||||
# The cell array can be thought of as a connectivity list. Here we
|
||||
# specify the number of points followed by that number of point
|
||||
# ids. This can be repeated as many times as there are primitives in
|
||||
# the list.
|
||||
strips = vtk.vtkCellArray()
|
||||
strips.InsertNextCell(8) # number of points
|
||||
strips.InsertCellPoint(0)
|
||||
strips.InsertCellPoint(1)
|
||||
strips.InsertCellPoint(2)
|
||||
strips.InsertCellPoint(3)
|
||||
strips.InsertCellPoint(4)
|
||||
strips.InsertCellPoint(5)
|
||||
strips.InsertCellPoint(6)
|
||||
strips.InsertCellPoint(7)
|
||||
profile = vtk.vtkPolyData()
|
||||
profile.SetPoints(points)
|
||||
profile.SetStrips(strips)
|
||||
|
||||
map = vtk.vtkPolyDataMapper()
|
||||
map.SetInputData(profile)
|
||||
|
||||
strip = vtk.vtkActor()
|
||||
strip.SetMapper(map)
|
||||
strip.GetProperty().SetColor(0.3800, 0.7000, 0.1600)
|
||||
|
||||
# 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(strip)
|
||||
|
||||
ren.SetBackground(1, 1, 1)
|
||||
renWin.SetSize(250, 250)
|
||||
|
||||
iren.Initialize()
|
||||
renWin.Render()
|
||||
iren.Start()
|
||||
282
ParaView-5.0.1/VTK/Examples/DataManipulation/Python/FinancialField.py
Executable file
282
ParaView-5.0.1/VTK/Examples/DataManipulation/Python/FinancialField.py
Executable file
@ -0,0 +1,282 @@
|
||||
#!/usr/bin/env python
|
||||
|
||||
# This example demonstrates the use of fields and use of
|
||||
# vtkProgrammableDataObjectSource. It creates fields the hard way (as
|
||||
# compared to reading a vtk field file), but shows you how to
|
||||
# interface to your own raw data.
|
||||
|
||||
import os
|
||||
import re
|
||||
import vtk
|
||||
from vtk.util.misc import vtkGetDataRoot
|
||||
VTK_DATA_ROOT = vtkGetDataRoot()
|
||||
|
||||
xAxis = "INTEREST_RATE"
|
||||
yAxis = "MONTHLY_PAYMENT"
|
||||
zAxis = "MONTHLY_INCOME"
|
||||
scalar = "TIME_LATE"
|
||||
|
||||
def getNumberFromLine(line):
|
||||
patn = re.compile('[-+]{0,1}[\d.]+e?[-+\d]*', re.M)
|
||||
val = patn.findall(line)
|
||||
ret = []
|
||||
for i in val:
|
||||
ret.append(float(i))
|
||||
return ret
|
||||
|
||||
# Parse an ASCII file and manually create a field. Then construct a
|
||||
# dataset from the field.
|
||||
dos = vtk.vtkProgrammableDataObjectSource()
|
||||
|
||||
# First define the function that will parse the data.
|
||||
def parseFile():
|
||||
global VTK_DATA_ROOT, dos
|
||||
|
||||
# Use Python to read an ASCII file
|
||||
file = open(os.path.join(VTK_DATA_ROOT, "Data/financial.txt"), "r")
|
||||
|
||||
line = file.readline()
|
||||
numPts = int(getNumberFromLine(line)[0])
|
||||
|
||||
numLines = (numPts - 1)//8
|
||||
# Get the data object's field data and allocate
|
||||
# room for 4, fields
|
||||
fieldData = dos.GetOutput().GetFieldData()
|
||||
fieldData.AllocateArrays(4)
|
||||
|
||||
# read TIME_LATE - dependent variable
|
||||
# search the file until an array called TIME_LATE is found
|
||||
while file.readline()[:9] != "TIME_LATE":
|
||||
pass
|
||||
|
||||
# Create the corresponding float array
|
||||
timeLate = vtk.vtkFloatArray()
|
||||
timeLate.SetName("TIME_LATE")
|
||||
# Read the values
|
||||
for i in range(0, numLines):
|
||||
val = getNumberFromLine(file.readline())
|
||||
for j in range(0, 8):
|
||||
timeLate.InsertNextValue(val[j])
|
||||
# Add the array
|
||||
fieldData.AddArray(timeLate)
|
||||
|
||||
# MONTHLY_PAYMENT - independent variable
|
||||
while file.readline()[:15] != "MONTHLY_PAYMENT":
|
||||
pass
|
||||
|
||||
monthlyPayment = vtk.vtkFloatArray()
|
||||
monthlyPayment.SetName("MONTHLY_PAYMENT")
|
||||
for i in range(0, numLines):
|
||||
val = getNumberFromLine(file.readline())
|
||||
for j in range(0, 8):
|
||||
monthlyPayment.InsertNextValue(val[j])
|
||||
|
||||
fieldData.AddArray(monthlyPayment)
|
||||
|
||||
# UNPAID_PRINCIPLE - skip
|
||||
while file.readline()[:16] != "UNPAID_PRINCIPLE":
|
||||
pass
|
||||
for i in range(0, numLines):
|
||||
file.readline()
|
||||
|
||||
# LOAN_AMOUNT - skip
|
||||
while file.readline()[:11] != "LOAN_AMOUNT":
|
||||
pass
|
||||
for i in range(0, numLines):
|
||||
file.readline()
|
||||
|
||||
|
||||
# INTEREST_RATE - independent variable
|
||||
while file.readline()[:13] != "INTEREST_RATE":
|
||||
pass
|
||||
|
||||
interestRate = vtk.vtkFloatArray()
|
||||
interestRate.SetName("INTEREST_RATE")
|
||||
for i in range(0, numLines):
|
||||
val = getNumberFromLine(file.readline())
|
||||
for j in range(0, 8):
|
||||
interestRate.InsertNextValue(val[j])
|
||||
|
||||
fieldData.AddArray(interestRate)
|
||||
|
||||
# MONTHLY_INCOME - independent variable
|
||||
while file.readline()[:14] != "MONTHLY_INCOME":
|
||||
pass
|
||||
|
||||
monthlyIncome = vtk.vtkFloatArray()
|
||||
monthlyIncome.SetName("MONTHLY_INCOME")
|
||||
for i in range(0, numLines):
|
||||
val = getNumberFromLine(file.readline())
|
||||
for j in range(0, 8):
|
||||
monthlyIncome.InsertNextValue(val[j])
|
||||
|
||||
fieldData.AddArray(monthlyIncome)
|
||||
|
||||
# Arrange to call the parsing function when the programmable data
|
||||
# source is executed.
|
||||
dos.SetExecuteMethod(parseFile)
|
||||
|
||||
# Create the dataset.
|
||||
|
||||
# DataObjectToDataSetFilter can create geometry using fields from
|
||||
# DataObject's FieldData
|
||||
do2ds = vtk.vtkDataObjectToDataSetFilter()
|
||||
do2ds.SetInputConnection(dos.GetOutputPort())
|
||||
# We are generating polygonal data
|
||||
do2ds.SetDataSetTypeToPolyData()
|
||||
do2ds.DefaultNormalizeOn()
|
||||
# All we need is points. Assign them.
|
||||
do2ds.SetPointComponent(0, xAxis, 0)
|
||||
do2ds.SetPointComponent(1, yAxis, 0)
|
||||
do2ds.SetPointComponent(2, zAxis, 0)
|
||||
|
||||
# RearrangeFields is used to move fields between DataObject's
|
||||
# FieldData, PointData and CellData.
|
||||
rf = vtk.vtkRearrangeFields()
|
||||
rf.SetInputConnection(do2ds.GetOutputPort())
|
||||
# Add an operation to "move TIME_LATE from DataObject's FieldData to
|
||||
# PointData"
|
||||
rf.AddOperation("MOVE", scalar, "DATA_OBJECT", "POINT_DATA")
|
||||
# Force the filter to execute. This is need to force the pipeline
|
||||
# to execute so that we can find the range of the array TIME_LATE
|
||||
rf.Update()
|
||||
# Set max to the second (GetRange returns [min,max]) of the "range of the
|
||||
# array called scalar in the PointData of the output of rf"
|
||||
max = rf.GetOutput().GetPointData().GetArray(scalar).GetRange()[1]
|
||||
|
||||
|
||||
# Use an ArrayCalculator to normalize TIME_LATE
|
||||
calc = vtk.vtkArrayCalculator()
|
||||
calc.SetInputConnection(rf.GetOutputPort())
|
||||
# Working on point data
|
||||
calc.SetAttributeModeToUsePointData()
|
||||
# Map scalar to s. When setting function, we can use s to
|
||||
# represent the array scalar (TIME_LATE)
|
||||
calc.AddScalarVariable("s", scalar, 0)
|
||||
# Divide scalar by max (applies division to all components of the array)
|
||||
calc.SetFunction("s / %f"%max)
|
||||
# The output array will be called resArray
|
||||
calc.SetResultArrayName("resArray")
|
||||
|
||||
# Use AssignAttribute to make resArray the active scalar field
|
||||
aa = vtk.vtkAssignAttribute()
|
||||
aa.SetInputConnection(calc.GetOutputPort())
|
||||
aa.Assign("resArray", "SCALARS", "POINT_DATA")
|
||||
aa.Update()
|
||||
|
||||
# construct pipeline for original population
|
||||
# GaussianSplatter -> Contour -> Mapper -> Actor
|
||||
popSplatter = vtk.vtkGaussianSplatter()
|
||||
popSplatter.SetInputConnection(aa.GetOutputPort())
|
||||
popSplatter.SetSampleDimensions(50, 50, 50)
|
||||
popSplatter.SetRadius(0.05)
|
||||
popSplatter.ScalarWarpingOff()
|
||||
|
||||
popSurface = vtk.vtkContourFilter()
|
||||
popSurface.SetInputConnection(popSplatter.GetOutputPort())
|
||||
popSurface.SetValue(0, 0.01)
|
||||
|
||||
popMapper = vtk.vtkPolyDataMapper()
|
||||
popMapper.SetInputConnection(popSurface.GetOutputPort())
|
||||
popMapper.ScalarVisibilityOff()
|
||||
|
||||
popActor = vtk.vtkActor()
|
||||
popActor.SetMapper(popMapper)
|
||||
popActor.GetProperty().SetOpacity(0.3)
|
||||
popActor.GetProperty().SetColor(.9, .9, .9)
|
||||
|
||||
# This is for decoration only.
|
||||
def CreateAxes():
|
||||
global xAxis, yAxis, zAxis, popSplatter
|
||||
|
||||
# Create axes.
|
||||
popSplatter.Update()
|
||||
bounds = popSplatter.GetOutput().GetBounds()
|
||||
axes = vtk.vtkAxes()
|
||||
axes.SetOrigin(bounds[0], bounds[2], bounds[4])
|
||||
axes.SetScaleFactor(popSplatter.GetOutput().GetLength()/5.0)
|
||||
|
||||
axesTubes = vtk.vtkTubeFilter()
|
||||
axesTubes.SetInputConnection(axes.GetOutputPort())
|
||||
axesTubes.SetRadius(axes.GetScaleFactor()/25.0)
|
||||
axesTubes.SetNumberOfSides(6)
|
||||
|
||||
axesMapper = vtk.vtkPolyDataMapper()
|
||||
axesMapper.SetInputConnection(axesTubes.GetOutputPort())
|
||||
|
||||
axesActor = vtk.vtkActor()
|
||||
axesActor.SetMapper(axesMapper)
|
||||
|
||||
# Label the axes.
|
||||
XText = vtk.vtkVectorText()
|
||||
XText.SetText(xAxis)
|
||||
|
||||
XTextMapper = vtk.vtkPolyDataMapper()
|
||||
XTextMapper.SetInputConnection(XText.GetOutputPort())
|
||||
|
||||
XActor = vtk.vtkFollower()
|
||||
XActor.SetMapper(XTextMapper)
|
||||
XActor.SetScale(0.02, .02, .02)
|
||||
XActor.SetPosition(0.35, -0.05, -0.05)
|
||||
XActor.GetProperty().SetColor(0, 0, 0)
|
||||
|
||||
YText = vtk.vtkVectorText()
|
||||
YText.SetText(yAxis)
|
||||
|
||||
YTextMapper = vtk.vtkPolyDataMapper()
|
||||
YTextMapper.SetInputConnection(YText.GetOutputPort())
|
||||
|
||||
YActor = vtk.vtkFollower()
|
||||
YActor.SetMapper(YTextMapper)
|
||||
YActor.SetScale(0.02, .02, .02)
|
||||
YActor.SetPosition(-0.05, 0.35, -0.05)
|
||||
YActor.GetProperty().SetColor(0, 0, 0)
|
||||
|
||||
ZText = vtk.vtkVectorText()
|
||||
ZText.SetText(zAxis)
|
||||
|
||||
ZTextMapper = vtk.vtkPolyDataMapper()
|
||||
ZTextMapper.SetInputConnection(ZText.GetOutputPort())
|
||||
|
||||
ZActor = vtk.vtkFollower()
|
||||
ZActor.SetMapper(ZTextMapper)
|
||||
ZActor.SetScale(0.02, .02, .02)
|
||||
ZActor.SetPosition(-0.05, -0.05, 0.35)
|
||||
ZActor.GetProperty().SetColor(0, 0, 0)
|
||||
return axesActor, XActor, YActor, ZActor
|
||||
|
||||
axesActor, XActor, YActor, ZActor = CreateAxes()
|
||||
|
||||
# Create the render window, renderer, interactor
|
||||
ren = vtk.vtkRenderer()
|
||||
renWin = vtk.vtkRenderWindow()
|
||||
renWin.AddRenderer(ren)
|
||||
renWin.SetWindowName("vtk - Field Data")
|
||||
renWin.SetSize(500, 500)
|
||||
|
||||
iren = vtk.vtkRenderWindowInteractor()
|
||||
iren.SetRenderWindow(renWin)
|
||||
|
||||
# Add the actors to the renderer, set the background and size
|
||||
ren.AddActor(axesActor)
|
||||
ren.AddActor(XActor)
|
||||
ren.AddActor(YActor)
|
||||
ren.AddActor(ZActor)
|
||||
ren.AddActor(popActor)
|
||||
ren.SetBackground(1, 1, 1)
|
||||
|
||||
# Set the default camera position
|
||||
camera = vtk.vtkCamera()
|
||||
camera.SetClippingRange(.274, 13.72)
|
||||
camera.SetFocalPoint(0.433816, 0.333131, 0.449)
|
||||
camera.SetPosition(-1.96987, 1.15145, 1.49053)
|
||||
camera.SetViewUp(0.378927, 0.911821, 0.158107)
|
||||
ren.SetActiveCamera(camera)
|
||||
# Assign the camera to the followers.
|
||||
XActor.SetCamera(camera)
|
||||
YActor.SetCamera(camera)
|
||||
ZActor.SetCamera(camera)
|
||||
|
||||
iren.Initialize()
|
||||
renWin.Render()
|
||||
iren.Start()
|
||||
215
ParaView-5.0.1/VTK/Examples/DataManipulation/Python/marching.py
Executable file
215
ParaView-5.0.1/VTK/Examples/DataManipulation/Python/marching.py
Executable file
@ -0,0 +1,215 @@
|
||||
#!/usr/bin/env python
|
||||
|
||||
# This example demonstrates the use of the vtkTransformPolyDataFilter
|
||||
# to reposition a 3D text string.
|
||||
|
||||
import vtk
|
||||
from vtk.util.colors import *
|
||||
|
||||
# Define a Single Cube
|
||||
Scalars = vtk.vtkFloatArray()
|
||||
Scalars.InsertNextValue(1.0)
|
||||
Scalars.InsertNextValue(0.0)
|
||||
Scalars.InsertNextValue(0.0)
|
||||
Scalars.InsertNextValue(1.0)
|
||||
Scalars.InsertNextValue(0.0)
|
||||
Scalars.InsertNextValue(0.0)
|
||||
Scalars.InsertNextValue(0.0)
|
||||
Scalars.InsertNextValue(0.0)
|
||||
|
||||
Points = vtk.vtkPoints()
|
||||
Points.InsertNextPoint(0, 0, 0)
|
||||
Points.InsertNextPoint(1, 0, 0)
|
||||
Points.InsertNextPoint(1, 1, 0)
|
||||
Points.InsertNextPoint(0, 1, 0)
|
||||
Points.InsertNextPoint(0, 0, 1)
|
||||
Points.InsertNextPoint(1, 0, 1)
|
||||
Points.InsertNextPoint(1, 1, 1)
|
||||
Points.InsertNextPoint(0, 1, 1)
|
||||
|
||||
Ids = vtk.vtkIdList()
|
||||
Ids.InsertNextId(0)
|
||||
Ids.InsertNextId(1)
|
||||
Ids.InsertNextId(2)
|
||||
Ids.InsertNextId(3)
|
||||
Ids.InsertNextId(4)
|
||||
Ids.InsertNextId(5)
|
||||
Ids.InsertNextId(6)
|
||||
Ids.InsertNextId(7)
|
||||
|
||||
Grid = vtk.vtkUnstructuredGrid()
|
||||
Grid.Allocate(10, 10)
|
||||
Grid.InsertNextCell(12, Ids)
|
||||
Grid.SetPoints(Points)
|
||||
Grid.GetPointData().SetScalars(Scalars)
|
||||
|
||||
# Find the triangles that lie along the 0.5 contour in this cube.
|
||||
Marching = vtk.vtkContourFilter()
|
||||
Marching.SetInputData(Grid)
|
||||
Marching.SetValue(0, 0.5)
|
||||
Marching.Update()
|
||||
|
||||
# Extract the edges of the triangles just found.
|
||||
triangleEdges = vtk.vtkExtractEdges()
|
||||
triangleEdges.SetInputConnection(Marching.GetOutputPort())
|
||||
# Draw the edges as tubes instead of lines. Also create the associated
|
||||
# mapper and actor to display the tubes.
|
||||
triangleEdgeTubes = vtk.vtkTubeFilter()
|
||||
triangleEdgeTubes.SetInputConnection(triangleEdges.GetOutputPort())
|
||||
triangleEdgeTubes.SetRadius(.005)
|
||||
triangleEdgeTubes.SetNumberOfSides(6)
|
||||
triangleEdgeTubes.UseDefaultNormalOn()
|
||||
triangleEdgeTubes.SetDefaultNormal(.577, .577, .577)
|
||||
triangleEdgeMapper = vtk.vtkPolyDataMapper()
|
||||
triangleEdgeMapper.SetInputConnection(triangleEdgeTubes.GetOutputPort())
|
||||
triangleEdgeMapper.ScalarVisibilityOff()
|
||||
triangleEdgeActor = vtk.vtkActor()
|
||||
triangleEdgeActor.SetMapper(triangleEdgeMapper)
|
||||
triangleEdgeActor.GetProperty().SetDiffuseColor(lamp_black)
|
||||
triangleEdgeActor.GetProperty().SetSpecular(.4)
|
||||
triangleEdgeActor.GetProperty().SetSpecularPower(10)
|
||||
|
||||
# Shrink the triangles we found earlier. Create the associated mapper
|
||||
# and actor. Set the opacity of the shrunken triangles.
|
||||
aShrinker = vtk.vtkShrinkPolyData()
|
||||
aShrinker.SetShrinkFactor(1)
|
||||
aShrinker.SetInputConnection(Marching.GetOutputPort())
|
||||
aMapper = vtk.vtkPolyDataMapper()
|
||||
aMapper.ScalarVisibilityOff()
|
||||
aMapper.SetInputConnection(aShrinker.GetOutputPort())
|
||||
Triangles = vtk.vtkActor()
|
||||
Triangles.SetMapper(aMapper)
|
||||
Triangles.GetProperty().SetDiffuseColor(banana)
|
||||
Triangles.GetProperty().SetOpacity(.6)
|
||||
|
||||
# Draw a cube the same size and at the same position as the one
|
||||
# created previously. Extract the edges because we only want to see
|
||||
# the outline of the cube. Pass the edges through a vtkTubeFilter so
|
||||
# they are displayed as tubes rather than lines.
|
||||
CubeModel = vtk.vtkCubeSource()
|
||||
CubeModel.SetCenter(.5, .5, .5)
|
||||
Edges = vtk.vtkExtractEdges()
|
||||
Edges.SetInputConnection(CubeModel.GetOutputPort())
|
||||
Tubes = vtk.vtkTubeFilter()
|
||||
Tubes.SetInputConnection(Edges.GetOutputPort())
|
||||
Tubes.SetRadius(.01)
|
||||
Tubes.SetNumberOfSides(6)
|
||||
Tubes.UseDefaultNormalOn()
|
||||
Tubes.SetDefaultNormal(.577, .577, .577)
|
||||
# Create the mapper and actor to display the cube edges.
|
||||
TubeMapper = vtk.vtkPolyDataMapper()
|
||||
TubeMapper.SetInputConnection(Tubes.GetOutputPort())
|
||||
CubeEdges = vtk.vtkActor()
|
||||
CubeEdges.SetMapper(TubeMapper)
|
||||
CubeEdges.GetProperty().SetDiffuseColor(khaki)
|
||||
CubeEdges.GetProperty().SetSpecular(.4)
|
||||
CubeEdges.GetProperty().SetSpecularPower(10)
|
||||
|
||||
# Create a sphere to use as a glyph source for vtkGlyph3D.
|
||||
Sphere = vtk.vtkSphereSource()
|
||||
Sphere.SetRadius(0.04)
|
||||
Sphere.SetPhiResolution(20)
|
||||
Sphere.SetThetaResolution(20)
|
||||
# Remove the part of the cube with data values below 0.5.
|
||||
ThresholdIn = vtk.vtkThresholdPoints()
|
||||
ThresholdIn.SetInputData(Grid)
|
||||
ThresholdIn.ThresholdByUpper(.5)
|
||||
# Display spheres at the vertices remaining in the cube data set after
|
||||
# it was passed through vtkThresholdPoints.
|
||||
Vertices = vtk.vtkGlyph3D()
|
||||
Vertices.SetInputConnection(ThresholdIn.GetOutputPort())
|
||||
Vertices.SetSourceConnection(Sphere.GetOutputPort())
|
||||
# Create a mapper and actor to display the glyphs.
|
||||
SphereMapper = vtk.vtkPolyDataMapper()
|
||||
SphereMapper.SetInputConnection(Vertices.GetOutputPort())
|
||||
SphereMapper.ScalarVisibilityOff()
|
||||
CubeVertices = vtk.vtkActor()
|
||||
CubeVertices.SetMapper(SphereMapper)
|
||||
CubeVertices.GetProperty().SetDiffuseColor(tomato)
|
||||
CubeVertices.GetProperty().SetDiffuseColor(tomato)
|
||||
|
||||
# Define the text for the label
|
||||
caseLabel = vtk.vtkVectorText()
|
||||
caseLabel.SetText("Case 1")
|
||||
|
||||
# Set up a transform to move the label to a new position.
|
||||
aLabelTransform = vtk.vtkTransform()
|
||||
aLabelTransform.Identity()
|
||||
aLabelTransform.Translate(-0.2, 0, 1.25)
|
||||
aLabelTransform.Scale(.05, .05, .05)
|
||||
|
||||
# Move the label to a new position.
|
||||
labelTransform = vtk.vtkTransformPolyDataFilter()
|
||||
labelTransform.SetTransform(aLabelTransform)
|
||||
labelTransform.SetInputConnection(caseLabel.GetOutputPort())
|
||||
|
||||
# Create a mapper and actor to display the text.
|
||||
labelMapper = vtk.vtkPolyDataMapper()
|
||||
labelMapper.SetInputConnection(labelTransform.GetOutputPort())
|
||||
|
||||
labelActor = vtk.vtkActor()
|
||||
labelActor.SetMapper(labelMapper)
|
||||
|
||||
# Define the base that the cube sits on. Create its associated mapper
|
||||
# and actor. Set the position of the actor.
|
||||
baseModel = vtk.vtkCubeSource()
|
||||
baseModel.SetXLength(1.5)
|
||||
baseModel.SetYLength(.01)
|
||||
baseModel.SetZLength(1.5)
|
||||
baseMapper = vtk.vtkPolyDataMapper()
|
||||
baseMapper.SetInputConnection(baseModel.GetOutputPort())
|
||||
base = vtk.vtkActor()
|
||||
base.SetMapper(baseMapper)
|
||||
base.SetPosition(.5, -0.09, .5)
|
||||
|
||||
# Create the Renderer, RenderWindow, and RenderWindowInteractor
|
||||
ren = vtk.vtkRenderer()
|
||||
renWin = vtk.vtkRenderWindow()
|
||||
renWin.AddRenderer(ren)
|
||||
renWin.SetSize(640, 480)
|
||||
iren = vtk.vtkRenderWindowInteractor()
|
||||
iren.SetRenderWindow(renWin)
|
||||
|
||||
# Add the actors to the renderer
|
||||
ren.AddActor(triangleEdgeActor)
|
||||
ren.AddActor(base)
|
||||
ren.AddActor(labelActor)
|
||||
ren.AddActor(CubeEdges)
|
||||
ren.AddActor(CubeVertices)
|
||||
ren.AddActor(Triangles)
|
||||
|
||||
# Set the background color.
|
||||
ren.SetBackground(slate_grey)
|
||||
|
||||
# This sets up the right values for case12 of the marching cubes
|
||||
# algorithm (routine translated from vtktesting/mccases.tcl).
|
||||
def case12(scalars, caselabel, IN, OUT):
|
||||
scalars.InsertValue(0, OUT)
|
||||
scalars.InsertValue(1, IN)
|
||||
scalars.InsertValue(2, OUT)
|
||||
scalars.InsertValue(3, IN)
|
||||
scalars.InsertValue(4, IN)
|
||||
scalars.InsertValue(5, IN)
|
||||
scalars.InsertValue(6, OUT)
|
||||
scalars.InsertValue(7, OUT)
|
||||
if IN == 1:
|
||||
caselabel.SetText("Case 12 - 00111010")
|
||||
else:
|
||||
caselabel.SetText("Case 12 - 11000101")
|
||||
|
||||
# Set the scalar values for this case of marching cubes.
|
||||
case12(Scalars, caseLabel, 0, 1)
|
||||
|
||||
# Force the grid to update.
|
||||
Grid.Modified()
|
||||
|
||||
# Position the camera.
|
||||
ren.ResetCamera()
|
||||
ren.GetActiveCamera().Dolly(1.2)
|
||||
ren.GetActiveCamera().Azimuth(30)
|
||||
ren.GetActiveCamera().Elevation(20)
|
||||
ren.ResetCameraClippingRange()
|
||||
|
||||
iren.Initialize()
|
||||
renWin.Render()
|
||||
iren.Start()
|
||||
99
ParaView-5.0.1/VTK/Examples/DataManipulation/Python/pointToCellData.py
Executable file
99
ParaView-5.0.1/VTK/Examples/DataManipulation/Python/pointToCellData.py
Executable file
@ -0,0 +1,99 @@
|
||||
#!/usr/bin/env python
|
||||
|
||||
# This example demonstrates the conversion of point data to cell data.
|
||||
# The conversion is necessary because we want to threshold data based
|
||||
# on cell scalar values.
|
||||
|
||||
import vtk
|
||||
from vtk.util.misc import vtkGetDataRoot
|
||||
VTK_DATA_ROOT = vtkGetDataRoot()
|
||||
|
||||
# Read some data with point data attributes. The data is from a
|
||||
# plastic blow molding process (e.g., to make plastic bottles) and
|
||||
# consists of two logical components: a mold and a parison. The
|
||||
# parison is the hot plastic that is being molded, and the mold is
|
||||
# clamped around the parison to form its shape.
|
||||
reader = vtk.vtkUnstructuredGridReader()
|
||||
reader.SetFileName(VTK_DATA_ROOT + "/Data/blow.vtk")
|
||||
reader.SetScalarsName("thickness9")
|
||||
reader.SetVectorsName("displacement9")
|
||||
|
||||
# Convert the point data to cell data. The point data is passed
|
||||
# through the filter so it can be warped. The vtkThresholdFilter then
|
||||
# thresholds based on cell scalar values and extracts a portion of the
|
||||
# parison whose cell scalar values lie between 0.25 and 0.75.
|
||||
p2c = vtk.vtkPointDataToCellData()
|
||||
p2c.SetInputConnection(reader.GetOutputPort())
|
||||
p2c.PassPointDataOn()
|
||||
warp = vtk.vtkWarpVector()
|
||||
warp.SetInputConnection(p2c.GetOutputPort())
|
||||
thresh = vtk.vtkThreshold()
|
||||
thresh.SetInputConnection(warp.GetOutputPort())
|
||||
thresh.ThresholdBetween(0.25, 0.75)
|
||||
thresh.SetInputArrayToProcess(1, 0, 0, 0, "thickness9")
|
||||
#thresh.SetAttributeModeToUseCellData()
|
||||
|
||||
# This is used to extract the mold from the parison.
|
||||
connect = vtk.vtkConnectivityFilter()
|
||||
connect.SetInputConnection(thresh.GetOutputPort())
|
||||
connect.SetExtractionModeToSpecifiedRegions()
|
||||
connect.AddSpecifiedRegion(0)
|
||||
connect.AddSpecifiedRegion(1)
|
||||
moldMapper = vtk.vtkDataSetMapper()
|
||||
moldMapper.SetInputConnection(reader.GetOutputPort())
|
||||
moldMapper.ScalarVisibilityOff()
|
||||
moldActor = vtk.vtkActor()
|
||||
moldActor.SetMapper(moldMapper)
|
||||
moldActor.GetProperty().SetColor(.2, .2, .2)
|
||||
moldActor.GetProperty().SetRepresentationToWireframe()
|
||||
|
||||
# The threshold filter has been used to extract the parison.
|
||||
connect2 = vtk.vtkConnectivityFilter()
|
||||
connect2.SetInputConnection(thresh.GetOutputPort())
|
||||
parison = vtk.vtkGeometryFilter()
|
||||
parison.SetInputConnection(connect2.GetOutputPort())
|
||||
normals2 = vtk.vtkPolyDataNormals()
|
||||
normals2.SetInputConnection(parison.GetOutputPort())
|
||||
normals2.SetFeatureAngle(60)
|
||||
lut = vtk.vtkLookupTable()
|
||||
lut.SetHueRange(0.0, 0.66667)
|
||||
parisonMapper = vtk.vtkPolyDataMapper()
|
||||
parisonMapper.SetInputConnection(normals2.GetOutputPort())
|
||||
parisonMapper.SetLookupTable(lut)
|
||||
parisonMapper.SetScalarRange(0.12, 1.0)
|
||||
parisonActor = vtk.vtkActor()
|
||||
parisonActor.SetMapper(parisonMapper)
|
||||
|
||||
# We generate some contour lines on the parison.
|
||||
cf = vtk.vtkContourFilter()
|
||||
cf.SetInputConnection(connect2.GetOutputPort())
|
||||
cf.SetValue(0, .5)
|
||||
contourMapper = vtk.vtkPolyDataMapper()
|
||||
contourMapper.SetInputConnection(cf.GetOutputPort())
|
||||
contours = vtk.vtkActor()
|
||||
contours.SetMapper(contourMapper)
|
||||
|
||||
# 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(moldActor)
|
||||
ren.AddActor(parisonActor)
|
||||
ren.AddActor(contours)
|
||||
|
||||
ren.ResetCamera()
|
||||
ren.GetActiveCamera().Azimuth(60)
|
||||
ren.GetActiveCamera().Roll(-90)
|
||||
ren.GetActiveCamera().Dolly(2)
|
||||
ren.ResetCameraClippingRange()
|
||||
|
||||
ren.SetBackground(1, 1, 1)
|
||||
renWin.SetSize(750, 400)
|
||||
|
||||
iren.Initialize()
|
||||
renWin.Render()
|
||||
iren.Start()
|
||||
Reference in New Issue
Block a user