diff --git a/src/Python/Meshes/BoundaryEdges.py b/src/Python/Meshes/BoundaryEdges.py
index 3bb6b33303c28f566643fb41014ed8502b4eb69e..c0f38a6c6aa0f9d0122f60abf07d032240dbe131 100755
--- a/src/Python/Meshes/BoundaryEdges.py
+++ b/src/Python/Meshes/BoundaryEdges.py
@@ -1,14 +1,27 @@
#!/usr/bin/env python
-import vtkmodules.all as vtk
+# noinspection PyUnresolvedReferences
+import vtkmodules.vtkInteractionStyle
+# noinspection PyUnresolvedReferences
+import vtkmodules.vtkRenderingOpenGL2
+from vtkmodules.vtkCommonColor import vtkNamedColors
+from vtkmodules.vtkFiltersCore import vtkFeatureEdges
+from vtkmodules.vtkFiltersSources import vtkDiskSource
+from vtkmodules.vtkRenderingCore import (
+ vtkActor,
+ vtkPolyDataMapper,
+ vtkRenderWindow,
+ vtkRenderWindowInteractor,
+ vtkRenderer
+)
def main():
- colors = vtk.vtkNamedColors()
- diskSource = vtk.vtkDiskSource()
+ colors = vtkNamedColors()
+ diskSource = vtkDiskSource()
diskSource.Update()
- featureEdges = vtk.vtkFeatureEdges()
+ featureEdges = vtkFeatureEdges()
featureEdges.SetInputConnection(diskSource.GetOutputPort())
featureEdges.BoundaryEdgesOn()
featureEdges.FeatureEdgesOff()
@@ -18,24 +31,24 @@ def main():
featureEdges.Update()
# Visualize
- edgeMapper = vtk.vtkPolyDataMapper()
+ edgeMapper = vtkPolyDataMapper()
edgeMapper.SetInputConnection(featureEdges.GetOutputPort())
- edgeActor = vtk.vtkActor()
+ edgeActor = vtkActor()
edgeActor.SetMapper(edgeMapper)
- diskMapper = vtk.vtkPolyDataMapper()
+ diskMapper = vtkPolyDataMapper()
diskMapper.SetInputConnection(diskSource.GetOutputPort())
- diskActor = vtk.vtkActor()
+ diskActor = vtkActor()
diskActor.SetMapper(diskMapper)
diskActor.GetProperty().SetColor(colors.GetColor3d('Gray'))
# Create a renderer, render window, and interactor
- renderer = vtk.vtkRenderer()
- renderWindow = vtk.vtkRenderWindow()
+ renderer = vtkRenderer()
+ renderWindow = vtkRenderWindow()
renderWindow.SetWindowName('BoundaryEdges')
renderWindow.AddRenderer(renderer)
- renderWindowInteractor = vtk.vtkRenderWindowInteractor()
+ renderWindowInteractor = vtkRenderWindowInteractor()
renderWindowInteractor.SetRenderWindow(renderWindow)
renderer.AddActor(edgeActor)
diff --git a/src/Python/Meshes/CapClip.py b/src/Python/Meshes/CapClip.py
index 51ba802d2417c5447340c2e7a26a15d38f6d747f..c8f5a406fe9366aef40e0492d96eb61ba92adcfa 100755
--- a/src/Python/Meshes/CapClip.py
+++ b/src/Python/Meshes/CapClip.py
@@ -2,7 +2,35 @@
import os.path
-import vtkmodules.all as vtk
+# noinspection PyUnresolvedReferences
+import vtkmodules.vtkInteractionStyle
+# noinspection PyUnresolvedReferences
+import vtkmodules.vtkRenderingOpenGL2
+from vtkmodules.vtkCommonColor import vtkNamedColors
+from vtkmodules.vtkCommonDataModel import (
+ vtkPlane,
+ vtkPolyData
+)
+from vtkmodules.vtkFiltersCore import (
+ vtkClipPolyData,
+ vtkFeatureEdges,
+ vtkStripper
+)
+from vtkmodules.vtkFiltersSources import vtkSphereSource
+from vtkmodules.vtkIOGeometry import (
+ vtkBYUReader,
+ vtkOBJReader,
+ vtkSTLReader
+)
+from vtkmodules.vtkIOPLY import vtkPLYReader
+from vtkmodules.vtkRenderingCore import (
+ vtkActor,
+ vtkDataSetMapper,
+ vtkPolyDataMapper,
+ vtkRenderWindow,
+ vtkRenderWindowInteractor,
+ vtkRenderer
+)
def get_program_parameters():
@@ -21,7 +49,7 @@ def main():
filePath = get_program_parameters()
# Define colors
- colors = vtk.vtkNamedColors()
+ colors = vtkNamedColors()
backgroundColor = colors.GetColor3d('steel_blue')
boundaryColor = colors.GetColor3d('Banana')
clipColor = colors.GetColor3d('Tomato')
@@ -33,11 +61,11 @@ def main():
else:
polyData = GetSpherePD()
- plane = vtk.vtkPlane()
+ plane = vtkPlane()
plane.SetOrigin(polyData.GetCenter())
plane.SetNormal(1.0, -1.0, -1.0)
- clipper = vtk.vtkClipPolyData()
+ clipper = vtkClipPolyData()
clipper.SetInputData(polyData)
clipper.SetClipFunction(plane)
clipper.SetValue(0)
@@ -45,44 +73,44 @@ def main():
polyData = clipper.GetOutput()
- clipMapper = vtk.vtkDataSetMapper()
+ clipMapper = vtkDataSetMapper()
clipMapper.SetInputData(polyData)
- clipActor = vtk.vtkActor()
+ clipActor = vtkActor()
clipActor.SetMapper(clipMapper)
clipActor.GetProperty().SetDiffuseColor(clipColor)
clipActor.GetProperty().SetInterpolationToFlat()
clipActor.GetProperty().EdgeVisibilityOn()
# Now extract feature edges
- boundaryEdges = vtk.vtkFeatureEdges()
+ boundaryEdges = vtkFeatureEdges()
boundaryEdges.SetInputData(polyData)
boundaryEdges.BoundaryEdgesOn()
boundaryEdges.FeatureEdgesOff()
boundaryEdges.NonManifoldEdgesOff()
boundaryEdges.ManifoldEdgesOff()
- boundaryStrips = vtk.vtkStripper()
+ boundaryStrips = vtkStripper()
boundaryStrips.SetInputConnection(boundaryEdges.GetOutputPort())
boundaryStrips.Update()
# Change the polylines into polygons
- boundaryPoly = vtk.vtkPolyData()
+ boundaryPoly = vtkPolyData()
boundaryPoly.SetPoints(boundaryStrips.GetOutput().GetPoints())
boundaryPoly.SetPolys(boundaryStrips.GetOutput().GetLines())
- boundaryMapper = vtk.vtkPolyDataMapper()
+ boundaryMapper = vtkPolyDataMapper()
boundaryMapper.SetInputData(boundaryPoly)
- boundaryActor = vtk.vtkActor()
+ boundaryActor = vtkActor()
boundaryActor.SetMapper(boundaryMapper)
boundaryActor.GetProperty().SetDiffuseColor(boundaryColor)
# create renderer render window, and interactor
- renderer = vtk.vtkRenderer()
- renderWindow = vtk.vtkRenderWindow()
+ renderer = vtkRenderer()
+ renderWindow = vtkRenderWindow()
renderWindow.AddRenderer(renderer)
- interactor = vtk.vtkRenderWindowInteractor()
+ interactor = vtkRenderWindowInteractor()
interactor.SetRenderWindow(renderWindow)
# set background color and size
@@ -112,32 +140,32 @@ def ReadPolyData(file_name):
path, extension = os.path.splitext(file_name)
extension = extension.lower()
if extension == '.ply':
- reader = vtk.vtkPLYReader()
+ reader = vtkPLYReader()
reader.SetFileName(file_name)
reader.Update()
poly_data = reader.GetOutput()
elif extension == '.vtp':
- reader = vtk.vtkXMLpoly_dataReader()
+ reader = vtkXMLpoly_dataReader()
reader.SetFileName(file_name)
reader.Update()
poly_data = reader.GetOutput()
elif extension == '.obj':
- reader = vtk.vtkOBJReader()
+ reader = vtkOBJReader()
reader.SetFileName(file_name)
reader.Update()
poly_data = reader.GetOutput()
elif extension == '.stl':
- reader = vtk.vtkSTLReader()
+ reader = vtkSTLReader()
reader.SetFileName(file_name)
reader.Update()
poly_data = reader.GetOutput()
elif extension == '.vtk':
- reader = vtk.vtkpoly_dataReader()
+ reader = vtkpoly_dataReader()
reader.SetFileName(file_name)
reader.Update()
poly_data = reader.GetOutput()
elif extension == '.g':
- reader = vtk.vtkBYUReader()
+ reader = vtkBYUReader()
reader.SetGeometryFileName(file_name)
reader.Update()
poly_data = reader.GetOutput()
@@ -151,7 +179,7 @@ def GetSpherePD():
'''
:return: The PolyData representation of a sphere.
'''
- source = vtk.vtkSphereSource()
+ source = vtkSphereSource()
source.SetThetaResolution(20)
source.SetPhiResolution(11)
source.Update()
diff --git a/src/Python/Meshes/ClipDataSetWithPolyData.py b/src/Python/Meshes/ClipDataSetWithPolyData.py
index 3087445c4488a32765a3dea64910f712c2a6807b..749cba89f63421e55b6fbfe87aa2ab23a5241e2b 100755
--- a/src/Python/Meshes/ClipDataSetWithPolyData.py
+++ b/src/Python/Meshes/ClipDataSetWithPolyData.py
@@ -1,14 +1,37 @@
+#!/usr/bin/env python
+
import numpy as np
-import vtkmodules.all as vtk
+# noinspection PyUnresolvedReferences
+import vtkmodules.vtkInteractionStyle
+# noinspection PyUnresolvedReferences
+import vtkmodules.vtkRenderingOpenGL2
+from vtkmodules.vtkCommonColor import vtkNamedColors
+from vtkmodules.vtkCommonCore import vtkFloatArray
+from vtkmodules.vtkCommonDataModel import (
+ vtkCellTypes,
+ vtkRectilinearGrid
+)
+from vtkmodules.vtkFiltersCore import vtkImplicitPolyDataDistance
+from vtkmodules.vtkFiltersGeneral import vtkClipDataSet
+from vtkmodules.vtkFiltersGeometry import vtkRectilinearGridGeometryFilter
+from vtkmodules.vtkFiltersSources import vtkConeSource
+from vtkmodules.vtkRenderingCore import (
+ vtkActor,
+ vtkDataSetMapper,
+ vtkPolyDataMapper,
+ vtkRenderWindow,
+ vtkRenderWindowInteractor,
+ vtkRenderer
+)
def main():
- colors = vtk.vtkNamedColors()
+ colors = vtkNamedColors()
# Create polydata to slice the grid with. In this case, use a cone. This
# could
# be any polydata including a stl file.
- cone = vtk.vtkConeSource()
+ cone = vtkConeSource()
cone.SetResolution(50)
cone.SetDirection(0, 0, -1)
cone.SetHeight(3.0)
@@ -16,41 +39,41 @@ def main():
cone.Update()
# Implicit function that will be used to slice the mesh
- implicitPolyDataDistance = vtk.vtkImplicitPolyDataDistance()
+ implicitPolyDataDistance = vtkImplicitPolyDataDistance()
implicitPolyDataDistance.SetInput(cone.GetOutput())
# create a grid
dimension = 51
- xCoords = vtk.vtkFloatArray()
+ xCoords = vtkFloatArray()
for x, i in enumerate(np.linspace(-1.0, 1.0, dimension)):
xCoords.InsertNextValue(i)
- yCoords = vtk.vtkFloatArray()
+ yCoords = vtkFloatArray()
for y, i in enumerate(np.linspace(-1.0, 1.0, dimension)):
yCoords.InsertNextValue(i)
- zCoords = vtk.vtkFloatArray()
+ zCoords = vtkFloatArray()
for z, i in enumerate(np.linspace(-1.0, 1.0, dimension)):
zCoords.InsertNextValue(i)
# # create a grid - if not using numpy
# dimension = 51
- # xCoords = vtk.vtkFloatArray()
+ # xCoords = vtkFloatArray()
# for i in range(0, dimension):
# xCoords.InsertNextValue(-1.0 + i * 2.0 / (dimension - 1))
#
- # yCoords = vtk.vtkFloatArray()
+ # yCoords = vtkFloatArray()
# for i in range(0, dimension):
# yCoords.InsertNextValue(-1.0 + i * 2.0 / (dimension - 1))
#
- # zCoords = vtk.vtkFloatArray()
+ # zCoords = vtkFloatArray()
# for i in range(0, dimension):
# zCoords.InsertNextValue(-1.0 + i * 2.0 / (dimension - 1))
# The coordinates are assigned to the rectilinear grid. Make sure that
# the number of values in each of the XCoordinates, YCoordinates,
# and ZCoordinates is equal to what is defined in SetDimensions().
- rgrid = vtk.vtkRectilinearGrid()
+ rgrid = vtkRectilinearGrid()
rgrid.SetDimensions(xCoords.GetNumberOfTuples(),
yCoords.GetNumberOfTuples(),
zCoords.GetNumberOfTuples())
@@ -59,7 +82,7 @@ def main():
rgrid.SetZCoordinates(zCoords)
# Create an array to hold distance information
- signedDistances = vtk.vtkFloatArray()
+ signedDistances = vtkFloatArray()
signedDistances.SetNumberOfComponents(1)
signedDistances.SetName('SignedDistances')
@@ -73,7 +96,7 @@ def main():
rgrid.GetPointData().SetScalars(signedDistances)
# Use vtkClipDataSet to slice the grid with the polydata
- clipper = vtk.vtkClipDataSet()
+ clipper = vtkClipDataSet()
clipper.SetInputData(rgrid)
clipper.InsideOutOn()
clipper.SetValue(0.0)
@@ -82,40 +105,40 @@ def main():
# --- mappers, actors, render, etc. ---
# mapper and actor to view the cone
- coneMapper = vtk.vtkPolyDataMapper()
+ coneMapper = vtkPolyDataMapper()
coneMapper.SetInputConnection(cone.GetOutputPort())
- coneActor = vtk.vtkActor()
+ coneActor = vtkActor()
coneActor.SetMapper(coneMapper)
# geometry filter to view the background grid
- geometryFilter = vtk.vtkRectilinearGridGeometryFilter()
+ geometryFilter = vtkRectilinearGridGeometryFilter()
geometryFilter.SetInputData(rgrid)
geometryFilter.SetExtent(0, dimension, 0, dimension, int(dimension / 2), int(dimension / 2))
geometryFilter.Update()
- rgridMapper = vtk.vtkPolyDataMapper()
+ rgridMapper = vtkPolyDataMapper()
rgridMapper.SetInputConnection(geometryFilter.GetOutputPort())
rgridMapper.SetScalarRange(
rgrid.GetPointData().GetArray('SignedDistances').GetRange())
- wireActor = vtk.vtkActor()
+ wireActor = vtkActor()
wireActor.SetMapper(rgridMapper)
wireActor.GetProperty().SetRepresentationToWireframe()
# mapper and actor to view the clipped mesh
- clipperMapper = vtk.vtkDataSetMapper()
+ clipperMapper = vtkDataSetMapper()
clipperMapper.SetInputConnection(clipper.GetOutputPort())
clipperMapper.ScalarVisibilityOff()
- clipperOutsideMapper = vtk.vtkDataSetMapper()
+ clipperOutsideMapper = vtkDataSetMapper()
clipperOutsideMapper.SetInputConnection(clipper.GetOutputPort(1))
clipperOutsideMapper.ScalarVisibilityOff()
- clipperActor = vtk.vtkActor()
+ clipperActor = vtkActor()
clipperActor.SetMapper(clipperMapper)
clipperActor.GetProperty().SetColor(colors.GetColor3d('Banana'))
- clipperOutsideActor = vtk.vtkActor()
+ clipperOutsideActor = vtkActor()
clipperOutsideActor.SetMapper(clipperOutsideMapper)
clipperOutsideActor.GetProperty().SetColor(
colors.GetColor3d('Banana'))
@@ -123,12 +146,12 @@ def main():
# A renderer and render window
# Create a renderer, render window, and interactor
leftViewport = [0.0, 0.0, 0.5, 1.0]
- leftRenderer = vtk.vtkRenderer()
+ leftRenderer = vtkRenderer()
leftRenderer.SetViewport(leftViewport)
leftRenderer.SetBackground(colors.GetColor3d('SteelBlue'))
rightViewport = [0.5, 0.0, 1.0, 1.0]
- rightRenderer = vtk.vtkRenderer()
+ rightRenderer = vtkRenderer()
rightRenderer.SetViewport(rightViewport)
rightRenderer.SetBackground(colors.GetColor3d('CadetBlue'))
@@ -137,14 +160,14 @@ def main():
leftRenderer.AddActor(clipperActor)
rightRenderer.AddActor(clipperOutsideActor)
- renwin = vtk.vtkRenderWindow()
+ renwin = vtkRenderWindow()
renwin.SetSize(640, 480)
renwin.AddRenderer(leftRenderer)
renwin.AddRenderer(rightRenderer)
renwin.SetWindowName('ClipDataSetWithPolyData')
# An interactor
- interactor = vtk.vtkRenderWindowInteractor()
+ interactor = vtkRenderWindowInteractor()
interactor.SetRenderWindow(renwin)
# Share the camera
@@ -161,7 +184,7 @@ def main():
interactor.Start()
# Generate a report
- ct = vtk.vtkCellTypes()
+ ct = vtkCellTypes()
numberOfCells = clipper.GetOutput().GetNumberOfCells()
print('------------------------')
@@ -173,7 +196,7 @@ def main():
for k, v in cellMap.items():
print('\tCell type ', ct.GetClassNameFromTypeId(k), 'occurs', v, 'times.')
-
+
numberOfCells = clipper.GetClippedOutput().GetNumberOfCells()
print('------------------------')
print('The clipped dataset(outside) contains a\n', clipper.GetClippedOutput().GetClassName(), 'that has',
diff --git a/src/Python/Meshes/ClipDataSetWithPolyData1.py b/src/Python/Meshes/ClipDataSetWithPolyData1.py
index 2742cfa735e82ae09267672c375ccec0bb28826b..dcb8fbde9efb56d12e6d619f3abc215425afc861 100755
--- a/src/Python/Meshes/ClipDataSetWithPolyData1.py
+++ b/src/Python/Meshes/ClipDataSetWithPolyData1.py
@@ -1,44 +1,64 @@
+#!/usr/bin/env python
+
import numpy as np
-import vtkmodules.all as vtk
+# noinspection PyUnresolvedReferences
+import vtkmodules.vtkInteractionStyle
+# noinspection PyUnresolvedReferences
+import vtkmodules.vtkRenderingOpenGL2
+from vtkmodules.vtkCommonColor import vtkNamedColors
+from vtkmodules.vtkCommonCore import vtkFloatArray
+from vtkmodules.vtkCommonDataModel import vtkRectilinearGrid
+from vtkmodules.vtkFiltersCore import vtkImplicitPolyDataDistance
+from vtkmodules.vtkFiltersGeneral import vtkClipDataSet
+from vtkmodules.vtkFiltersGeometry import vtkRectilinearGridGeometryFilter
+from vtkmodules.vtkFiltersSources import vtkConeSource
+from vtkmodules.vtkRenderingCore import (
+ vtkActor,
+ vtkDataSetMapper,
+ vtkPolyDataMapper,
+ vtkRenderWindow,
+ vtkRenderWindowInteractor,
+ vtkRenderer
+)
def main():
- colors = vtk.vtkNamedColors()
+ colors = vtkNamedColors()
# Create polydata to slice the grid with. In this case, use a cone. This could
# be any polydata including a stl file.
- cone = vtk.vtkConeSource()
+ cone = vtkConeSource()
cone.SetResolution(20)
cone.Update()
# implicit function that will be used to slice the mesh
- implicitPolyDataDistance = vtk.vtkImplicitPolyDataDistance()
+ implicitPolyDataDistance = vtkImplicitPolyDataDistance()
implicitPolyDataDistance.SetInput(cone.GetOutput())
# create a grid
- xCoords = vtk.vtkFloatArray()
+ xCoords = vtkFloatArray()
for x, i in enumerate(np.linspace(-1.0, 1.0, 15)):
xCoords.InsertNextValue(i)
- yCoords = vtk.vtkFloatArray()
+ yCoords = vtkFloatArray()
for y, i in enumerate(np.linspace(-1.0, 1.0, 15)):
yCoords.InsertNextValue(i)
- zCoords = vtk.vtkFloatArray()
+ zCoords = vtkFloatArray()
for z, i in enumerate(np.linspace(-1.0, 1.0, 15)):
zCoords.InsertNextValue(i)
# The coordinates are assigned to the rectilinear grid. Make sure that
# the number of values in each of the XCoordinates, YCoordinates,
# and ZCoordinates is equal to what is defined in SetDimensions().
- rgrid = vtk.vtkRectilinearGrid()
+ rgrid = vtkRectilinearGrid()
rgrid.SetDimensions(x + 1, y + 1, z + 1)
rgrid.SetXCoordinates(xCoords)
rgrid.SetYCoordinates(yCoords)
rgrid.SetZCoordinates(zCoords)
# Create an array to hold distance information
- signedDistances = vtk.vtkFloatArray()
+ signedDistances = vtkFloatArray()
signedDistances.SetNumberOfComponents(1)
signedDistances.SetName('SignedDistances')
@@ -52,7 +72,7 @@ def main():
rgrid.GetPointData().SetScalars(signedDistances)
# use vtkClipDataSet to slice the grid with the polydata
- clipper = vtk.vtkClipDataSet()
+ clipper = vtkClipDataSet()
clipper.SetInputData(rgrid)
clipper.InsideOutOn()
clipper.SetValue(0.0)
@@ -60,36 +80,36 @@ def main():
# --- mappers, actors, render, etc. ---
# mapper and actor to view the cone
- coneMapper = vtk.vtkPolyDataMapper()
+ coneMapper = vtkPolyDataMapper()
coneMapper.SetInputConnection(cone.GetOutputPort())
- coneActor = vtk.vtkActor()
+ coneActor = vtkActor()
coneActor.SetMapper(coneMapper)
# geometry filter to view the background grid
- geometryFilter = vtk.vtkRectilinearGridGeometryFilter()
+ geometryFilter = vtkRectilinearGridGeometryFilter()
geometryFilter.SetInputData(rgrid)
geometryFilter.SetExtent(0, x + 1, 0, y + 1, (z + 1) // 2, (z + 1) // 2)
geometryFilter.Update()
- rgridMapper = vtk.vtkPolyDataMapper()
+ rgridMapper = vtkPolyDataMapper()
rgridMapper.SetInputConnection(geometryFilter.GetOutputPort())
- wireActor = vtk.vtkActor()
+ wireActor = vtkActor()
wireActor.SetMapper(rgridMapper)
wireActor.GetProperty().SetRepresentationToWireframe()
wireActor.GetProperty().SetColor(colors.GetColor3d('Black'))
# mapper and actor to view the clipped mesh
- clipperMapper = vtk.vtkDataSetMapper()
+ clipperMapper = vtkDataSetMapper()
clipperMapper.SetInputConnection(clipper.GetOutputPort())
- clipperActor = vtk.vtkActor()
+ clipperActor = vtkActor()
clipperActor.SetMapper(clipperMapper)
clipperActor.GetProperty().SetRepresentationToWireframe()
clipperActor.GetProperty().SetColor(colors.GetColor3d('Black'))
# A renderer and render window
- renderer = vtk.vtkRenderer()
+ renderer = vtkRenderer()
renderer.SetBackground(colors.GetColor3d('Snow'))
# add the actors
@@ -97,12 +117,12 @@ def main():
renderer.AddActor(wireActor)
renderer.AddActor(clipperActor)
- renwin = vtk.vtkRenderWindow()
+ renwin = vtkRenderWindow()
renwin.AddRenderer(renderer)
renwin.SetWindowName('ClipDataSetWithPolyData')
# An interactor
- interactor = vtk.vtkRenderWindowInteractor()
+ interactor = vtkRenderWindowInteractor()
interactor.SetRenderWindow(renwin)
# Start
diff --git a/src/Python/Meshes/ColoredElevationMap.py b/src/Python/Meshes/ColoredElevationMap.py
index 3bd4b4006c923576601fd7b1fdae276d135e535b..ebdb83cba85959b686ca982397a235aa57408854 100755
--- a/src/Python/Meshes/ColoredElevationMap.py
+++ b/src/Python/Meshes/ColoredElevationMap.py
@@ -1,71 +1,90 @@
#!/usr/bin/env python
-import vtkmodules.all as vtk
+# noinspection PyUnresolvedReferences
+import vtkmodules.vtkInteractionStyle
+# noinspection PyUnresolvedReferences
+import vtkmodules.vtkRenderingOpenGL2
+from vtkmodules.vtkCommonColor import vtkNamedColors
+from vtkmodules.vtkCommonCore import (
+ vtkLookupTable,
+ vtkMinimalStandardRandomSequence,
+ vtkPoints,
+ vtkUnsignedCharArray
+)
+from vtkmodules.vtkCommonDataModel import vtkPolyData
+from vtkmodules.vtkFiltersCore import vtkDelaunay2D
+from vtkmodules.vtkRenderingCore import (
+ vtkActor,
+ vtkPolyDataMapper,
+ vtkRenderWindow,
+ vtkRenderWindowInteractor,
+ vtkRenderer
+)
+
def main():
- named_colors = vtk.vtkNamedColors()
+ named_colors = vtkNamedColors()
# Create a grid points
- points = vtk.vtkPoints()
+ points = vtkPoints()
GridSize = 20;
- xx=0.0
- yy=0.0
- zz=0.0
- rng = vtk.vtkMinimalStandardRandomSequence()
+ xx = 0.0
+ yy = 0.0
+ zz = 0.0
+ rng = vtkMinimalStandardRandomSequence()
rng.SetSeed(8775586) # For testing.
for x in range(0, GridSize):
for y in range(0, GridSize):
- rng.Next()
- xx = x + rng.GetRangeValue(-0.2, 0.2)
- rng.Next()
- yy = y + rng.GetRangeValue(-0.2, 0.2)
- rng.Next()
- zz = rng.GetRangeValue(-0.5, 0.5)
- points.InsertNextPoint(xx, yy, zz)
-
-
+ rng.Next()
+ xx = x + rng.GetRangeValue(-0.2, 0.2)
+ rng.Next()
+ yy = y + rng.GetRangeValue(-0.2, 0.2)
+ rng.Next()
+ zz = rng.GetRangeValue(-0.5, 0.5)
+ points.InsertNextPoint(xx, yy, zz)
+
# Add the grid points to a polydata object
- inputPolyData = vtk.vtkPolyData()
+ inputPolyData = vtkPolyData()
inputPolyData.SetPoints(points)
-
+
# Triangulate the grid points
- delaunay = vtk.vtkDelaunay2D()
+ delaunay = vtkDelaunay2D()
delaunay.SetInputData(inputPolyData)
delaunay.Update()
outputPolyData = delaunay.GetOutput()
-
- bounds= 6*[0.0]
+
+ bounds = 6 * [0.0]
outputPolyData.GetBounds(bounds)
-
+
# Find min and max z
minz = bounds[4]
maxz = bounds[5]
-
+
print('minz: {:< 6.3}'.format(minz))
print('maxz: {:< 6.3}'.format(maxz))
-
+
# Create the color map
- colorLookupTable = vtk.vtkLookupTable()
+ colorLookupTable = vtkLookupTable()
colorLookupTable.SetTableRange(minz, maxz)
colorLookupTable.Build()
-
+
# Generate the colors for each point based on the color map
- colors = vtk.vtkUnsignedCharArray()
+ colors = vtkUnsignedCharArray()
colors.SetNumberOfComponents(3)
colors.SetName('Colors')
-
- print( 'There are '+str(outputPolyData.GetNumberOfPoints())+' points.')
-
+
+ print('There are ' + str(outputPolyData.GetNumberOfPoints()) + ' points.')
+
for i in range(0, outputPolyData.GetNumberOfPoints()):
- p= 3*[0.0]
- outputPolyData.GetPoint(i,p)
-
- dcolor = 3*[0.0]
+ p = 3 * [0.0]
+ outputPolyData.GetPoint(i, p)
+
+ dcolor = 3 * [0.0]
colorLookupTable.GetColor(p[2], dcolor);
# print( 'dcolor: {:<8.6} {:<8.6} {:<8.6}'.format(*dcolor))
- color=3*[0.0]
- for j in range(0,3):
- color[j] = int(255.0 * dcolor[j])
+ color = 3 * [0.0]
+ for j in range(0, 3):
+ color[j] = int(255.0 * dcolor[j])
# print('color: {:<8} {:<8} {:<8}'.format(*color))
try:
@@ -73,35 +92,33 @@ def main():
except AttributeError:
# For compatibility with new VTK generic data arrays.
colors.InsertNextTypedTuple(color)
-
-
+
outputPolyData.GetPointData().SetScalars(colors)
-
+
# Create a mapper and actor
- mapper = vtk.vtkPolyDataMapper()
+ mapper = vtkPolyDataMapper()
mapper.SetInputData(outputPolyData)
- actor = vtk.vtkActor()
+ actor = vtkActor()
actor.SetMapper(mapper)
-
+
# Create a renderer, render window, and interactor
- renderer = vtk.vtkRenderer()
- renderWindow = vtk.vtkRenderWindow()
+ renderer = vtkRenderer()
+ renderWindow = vtkRenderWindow()
renderWindow.AddRenderer(renderer)
renderWindow.SetWindowName('ColoredElevationMap')
- renderWindowInteractor = vtk.vtkRenderWindowInteractor()
+ renderWindowInteractor = vtkRenderWindowInteractor()
renderWindowInteractor.SetRenderWindow(renderWindow)
-
+
# Add the actor to the scene
renderer.AddActor(actor)
renderer.SetBackground(named_colors.GetColor3d('DarkSlateGray'))
-
+
# Render and interact
renderWindow.Render()
renderWindowInteractor.Start()
-
+
if __name__ == '__main__':
main()
-
diff --git a/src/Python/Meshes/Decimation.py b/src/Python/Meshes/Decimation.py
index b53d1bff19ea9081366ef1cf7def90ea07bd2772..65902e08a4ff501a308b6fff8ba9dd5b40911f7d 100755
--- a/src/Python/Meshes/Decimation.py
+++ b/src/Python/Meshes/Decimation.py
@@ -2,7 +2,33 @@
import os.path
-import vtkmodules.all as vtk
+# noinspection PyUnresolvedReferences
+import vtkmodules.vtkInteractionStyle
+# noinspection PyUnresolvedReferences
+import vtkmodules.vtkRenderingOpenGL2
+from vtkmodules.vtkCommonColor import vtkNamedColors
+from vtkmodules.vtkCommonDataModel import vtkPolyData
+from vtkmodules.vtkFiltersCore import (
+ vtkDecimatePro,
+ vtkTriangleFilter
+)
+from vtkmodules.vtkFiltersSources import vtkSphereSource
+from vtkmodules.vtkIOGeometry import (
+ vtkBYUReader,
+ vtkOBJReader,
+ vtkSTLReader
+)
+from vtkmodules.vtkIOPLY import vtkPLYReader
+from vtkmodules.vtkIOXML import vtkXMLPolyDataReader
+from vtkmodules.vtkRenderingCore import (
+ vtkActor,
+ vtkCamera,
+ vtkPolyDataMapper,
+ vtkProperty,
+ vtkRenderWindow,
+ vtkRenderWindowInteractor,
+ vtkRenderer
+)
def get_program_parameters():
@@ -23,7 +49,7 @@ def main():
filePath, reduction = get_program_parameters()
# Define colors
- colors = vtk.vtkNamedColors()
+ colors = vtkNamedColors()
backFaceColor = colors.GetColor3d('Gold')
inputActorColor = colors.GetColor3d('NavajoWhite')
decimatedActorColor = colors.GetColor3d('NavajoWhite')
@@ -35,7 +61,7 @@ def main():
if not readerPD:
inputPolyData = GetSpherePD()
else:
- triangles = vtk.vtkTriangleFilter()
+ triangles = vtkTriangleFilter()
triangles.SetInputData(readerPD)
triangles.Update()
inputPolyData = triangles.GetOutput()
@@ -46,13 +72,13 @@ def main():
print(f'There are {inputPolyData.GetNumberOfPoints()} points.')
print(f'There are {inputPolyData.GetNumberOfPolys()} polygons.')
- decimate = vtk.vtkDecimatePro()
+ decimate = vtkDecimatePro()
decimate.SetInputData(inputPolyData)
decimate.SetTargetReduction(reduction)
decimate.PreserveTopologyOn()
decimate.Update()
- decimated = vtk.vtkPolyData()
+ decimated = vtkPolyData()
decimated.ShallowCopy(decimate.GetOutput())
print('After decimation')
@@ -61,34 +87,34 @@ def main():
print(
f'Reduction: {(inputPolyData.GetNumberOfPolys() - decimated.GetNumberOfPolys()) / inputPolyData.GetNumberOfPolys()}')
- inputMapper = vtk.vtkPolyDataMapper()
+ inputMapper = vtkPolyDataMapper()
inputMapper.SetInputData(inputPolyData)
- backFace = vtk.vtkProperty()
+ backFace = vtkProperty()
backFace.SetColor(backFaceColor)
- inputActor = vtk.vtkActor()
+ inputActor = vtkActor()
inputActor.SetMapper(inputMapper)
inputActor.GetProperty().SetInterpolationToFlat()
inputActor.GetProperty().SetColor(inputActorColor)
inputActor.SetBackfaceProperty(backFace)
- decimatedMapper = vtk.vtkPolyDataMapper()
+ decimatedMapper = vtkPolyDataMapper()
decimatedMapper.SetInputData(decimated)
- decimatedActor = vtk.vtkActor()
+ decimatedActor = vtkActor()
decimatedActor.SetMapper(decimatedMapper)
decimatedActor.GetProperty().SetColor(decimatedActorColor)
decimatedActor.GetProperty().SetInterpolationToFlat()
decimatedActor.SetBackfaceProperty(backFace)
# There will be one render window
- renderWindow = vtk.vtkRenderWindow()
+ renderWindow = vtkRenderWindow()
renderWindow.SetSize(600, 300)
renderWindow.SetWindowName('Decimation');
# And one interactor
- interactor = vtk.vtkRenderWindowInteractor()
+ interactor = vtkRenderWindowInteractor()
interactor.SetRenderWindow(renderWindow)
# Define viewport ranges
@@ -97,13 +123,13 @@ def main():
rightViewport = [0.5, 0.0, 1.0, 1.0]
# Setup both renderers
- leftRenderer = vtk.vtkRenderer()
+ leftRenderer = vtkRenderer()
renderWindow.AddRenderer(leftRenderer)
leftRenderer.SetViewport(leftViewport)
# leftRenderer.SetBackground((colors.GetColor3d('leftBkg')))
leftRenderer.SetBackground((colors.GetColor3d('Peru')))
- rightRenderer = vtk.vtkRenderer()
+ rightRenderer = vtkRenderer()
renderWindow.AddRenderer(rightRenderer)
rightRenderer.SetViewport(rightViewport)
# rightRenderer.SetBackground((colors.GetColor3d('rightBkg')))
@@ -115,7 +141,7 @@ def main():
# Shared camera
# Shared camera looking down the -y axis
- camera = vtk.vtkCamera()
+ camera = vtkCamera()
camera.SetPosition(0, -1, 0)
camera.SetFocalPoint(0, 0, 0)
camera.SetViewUp(0, 0, 1)
@@ -139,32 +165,32 @@ def ReadPolyData(file_name):
path, extension = os.path.splitext(file_name)
extension = extension.lower()
if extension == '.ply':
- reader = vtk.vtkPLYReader()
+ reader = vtkPLYReader()
reader.SetFileName(file_name)
reader.Update()
poly_data = reader.GetOutput()
elif extension == '.vtp':
- reader = vtk.vtkXMLPolyDataReader()
+ reader = vtkXMLPolyDataReader()
reader.SetFileName(file_name)
reader.Update()
poly_data = reader.GetOutput()
elif extension == '.obj':
- reader = vtk.vtkOBJReader()
+ reader = vtkOBJReader()
reader.SetFileName(file_name)
reader.Update()
poly_data = reader.GetOutput()
elif extension == '.stl':
- reader = vtk.vtkSTLReader()
+ reader = vtkSTLReader()
reader.SetFileName(file_name)
reader.Update()
poly_data = reader.GetOutput()
elif extension == '.vtk':
- reader = vtk.vtkpoly_dataReader()
+ reader = vtkpoly_dataReader()
reader.SetFileName(file_name)
reader.Update()
poly_data = reader.GetOutput()
elif extension == '.g':
- reader = vtk.vtkBYUReader()
+ reader = vtkBYUReader()
reader.SetGeometryFileName(file_name)
reader.Update()
poly_data = reader.GetOutput()
@@ -178,7 +204,7 @@ def GetSpherePD():
'''
:return: The PolyData representation of a sphere.
'''
- source = vtk.vtkSphereSource()
+ source = vtkSphereSource()
source.SetThetaResolution(30)
source.SetPhiResolution(15)
source.Update()
diff --git a/src/Python/Meshes/DeformPointSet.py b/src/Python/Meshes/DeformPointSet.py
index 2fb5f157ede98f8374925eca448a02189d26b373..a41b5b238007192a82c5d619c674f52055e8570e 100755
--- a/src/Python/Meshes/DeformPointSet.py
+++ b/src/Python/Meshes/DeformPointSet.py
@@ -1,24 +1,45 @@
-import vtkmodules.all as vtk
+#!/usr/bin/env python
+
+# noinspection PyUnresolvedReferences
+import vtkmodules.vtkInteractionStyle
+# noinspection PyUnresolvedReferences
+import vtkmodules.vtkRenderingOpenGL2
+from vtkmodules.vtkCommonColor import vtkNamedColors
+from vtkmodules.vtkCommonCore import vtkPoints
+from vtkmodules.vtkCommonDataModel import (
+ vtkCellArray,
+ vtkPolyData
+)
+from vtkmodules.vtkFiltersCore import vtkElevationFilter
+from vtkmodules.vtkFiltersGeneral import vtkDeformPointSet
+from vtkmodules.vtkFiltersSources import vtkSphereSource
+from vtkmodules.vtkRenderingCore import (
+ vtkActor,
+ vtkPolyDataMapper,
+ vtkRenderWindow,
+ vtkRenderWindowInteractor,
+ vtkRenderer
+)
def main():
- colors = vtk.vtkNamedColors()
-
+ colors = vtkNamedColors()
+
# Set the background color.
# colors.SetColor('bkg', [0.2, 0.3, 0.4, 1.0])
# Create a sphere to deform
- sphere = vtk.vtkSphereSource()
+ sphere = vtkSphereSource()
sphere.SetThetaResolution(51)
sphere.SetPhiResolution(17)
sphere.Update()
bounds = sphere.GetOutput().GetBounds()
# Create a filter to color the sphere
- ele = vtk.vtkElevationFilter()
+ ele = vtkElevationFilter()
ele.SetInputConnection(sphere.GetOutputPort())
- ele.SetLowPoint(0,0,-0.5);
- ele.SetHighPoint(0,0,0.5);
+ ele.SetLowPoint(0, 0, -0.5);
+ ele.SetHighPoint(0, 0, 0.5);
ele.SetLowPoint((bounds[1] + bounds[0]) / 2.0,
(bounds[3] + bounds[2]) / 2.0,
-bounds[5]);
@@ -28,7 +49,7 @@ def main():
ele.Update()
# Create a mesh to deform the sphere
- pts = vtk.vtkPoints()
+ pts = vtkPoints()
pts.SetNumberOfPoints(6)
pts.SetPoint(0,
bounds[0] - 0.1 * (bounds[1] - bounds[0]),
@@ -54,7 +75,7 @@ def main():
(bounds[1] + bounds[0]) / 2.0,
(bounds[3] + bounds[2]) / 2.0,
bounds[5] + 0.1 * (bounds[5] - bounds[4]))
- tris = vtk.vtkCellArray()
+ tris = vtkCellArray()
cells = [[2, 0, 4], [1, 2, 4], [3, 1, 4], [0, 3, 4], [0, 2, 5], [2, 1, 5], [1, 3, 5], [3, 0, 5]]
@@ -63,18 +84,18 @@ def main():
for c in cell:
tris.InsertCellPoint(c)
- pd = vtk.vtkPolyData()
+ pd = vtkPolyData()
pd.SetPoints(pts)
pd.SetPolys(tris)
- meshMapper = vtk.vtkPolyDataMapper()
+ meshMapper = vtkPolyDataMapper()
meshMapper.SetInputData(pd)
- meshActor = vtk.vtkActor()
+ meshActor = vtkActor()
meshActor.SetMapper(meshMapper)
meshActor.GetProperty().SetRepresentationToWireframe()
meshActor.GetProperty().SetColor(colors.GetColor3d('Black'))
- deform = vtk.vtkDeformPointSet()
+ deform = vtkDeformPointSet()
deform.SetInputData(ele.GetOutput())
deform.SetControlMeshData(pd)
deform.Update()
@@ -85,29 +106,30 @@ def main():
bounds[5] + .8 * (bounds[5] - bounds[4]))
pts.Modified()
- polyMapper = vtk.vtkPolyDataMapper()
+ polyMapper = vtkPolyDataMapper()
polyMapper.SetInputConnection(deform.GetOutputPort())
- polyActor = vtk.vtkActor()
+ polyActor = vtkActor()
polyActor.SetMapper(polyMapper)
- renderer = vtk.vtkRenderer()
- renWin = vtk.vtkRenderWindow()
+ renderer = vtkRenderer()
+ renWin = vtkRenderWindow()
renWin.AddRenderer(renderer)
- iren = vtk.vtkRenderWindowInteractor()
+ iren = vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
renderer.AddActor(polyActor)
renderer.AddActor(meshActor)
- renderer.GetActiveCamera().SetPosition(1,1,1)
+ renderer.GetActiveCamera().SetPosition(1, 1, 1)
renderer.ResetCamera()
renderer.SetBackground(colors.GetColor3d('DarkSlateGray'))
- renWin.SetSize(300,300)
+ renWin.SetSize(300, 300)
renWin.SetWindowName('DeformPointSet')
renWin.Render()
iren.Start()
+
if __name__ == '__main__':
main()
diff --git a/src/Python/Meshes/PointInterpolator.py b/src/Python/Meshes/PointInterpolator.py
index 77e14adfe8d080e5bbdc534aebbcf8a867efb2e1..9ea0d2acb6d3fb8beeb7ac19703bae5606dfb48d 100755
--- a/src/Python/Meshes/PointInterpolator.py
+++ b/src/Python/Meshes/PointInterpolator.py
@@ -1,8 +1,28 @@
#!/usr/bin/env python
import numpy as np
-
-import vtkmodules.all as vtk
+# noinspection PyUnresolvedReferences
+import vtkmodules.vtkInteractionStyle
+# noinspection PyUnresolvedReferences
+import vtkmodules.vtkRenderingOpenGL2
+from vtkmodules.vtkCommonColor import vtkNamedColors
+from vtkmodules.vtkCommonDataModel import vtkImageData
+from vtkmodules.vtkFiltersCore import vtkResampleWithDataSet
+from vtkmodules.vtkFiltersGeneral import vtkTableToPolyData
+from vtkmodules.vtkFiltersPoints import (
+ vtkGaussianKernel,
+ vtkPointInterpolator
+)
+from vtkmodules.vtkIOGeometry import vtkSTLReader
+from vtkmodules.vtkIOInfovis import vtkDelimitedTextReader
+from vtkmodules.vtkRenderingCore import (
+ vtkActor,
+ vtkPointGaussianMapper,
+ vtkPolyDataMapper,
+ vtkRenderWindow,
+ vtkRenderWindowInteractor,
+ vtkRenderer
+)
def get_program_parameters():
@@ -24,15 +44,15 @@ This example uses vtkPointInterpolator with a Gaussian Kernel (or other kernel)
def main():
points_fn, probe_fn = get_program_parameters()
- colors = vtk.vtkNamedColors()
+ colors = vtkNamedColors()
- points_reader = vtk.vtkDelimitedTextReader()
+ points_reader = vtkDelimitedTextReader()
points_reader.SetFileName(points_fn)
points_reader.DetectNumericColumnsOn()
points_reader.SetFieldDelimiterCharacters('\t')
points_reader.SetHaveHeaders(True)
- table_points = vtk.vtkTableToPolyData()
+ table_points = vtkTableToPolyData()
table_points.SetInputConnection(points_reader.GetOutputPort())
table_points.SetXColumn('x')
table_points.SetYColumn('y')
@@ -44,7 +64,7 @@ def main():
range = points.GetPointData().GetScalars().GetRange()
# Read a probe surface
- stl_reader = vtk.vtkSTLReader()
+ stl_reader = vtkSTLReader()
stl_reader.SetFileName(probe_fn)
stl_reader.Update()
@@ -52,33 +72,33 @@ def main():
bounds = np.array(surface.GetBounds())
dims = np.array([101, 101, 101])
- box = vtk.vtkImageData()
+ box = vtkImageData()
box.SetDimensions(dims)
box.SetSpacing((bounds[1::2] - bounds[:-1:2]) / (dims - 1))
box.SetOrigin(bounds[::2])
# Gaussian kernel
- gaussian_kernel = vtk.vtkGaussianKernel()
+ gaussian_kernel = vtkGaussianKernel()
gaussian_kernel.SetSharpness(2)
gaussian_kernel.SetRadius(12)
- interpolator = vtk.vtkPointInterpolator()
+ interpolator = vtkPointInterpolator()
interpolator.SetInputData(box)
interpolator.SetSourceData(points)
interpolator.SetKernel(gaussian_kernel)
- resample = vtk.vtkResampleWithDataSet()
+ resample = vtkResampleWithDataSet()
resample.SetInputData(surface)
resample.SetSourceConnection(interpolator.GetOutputPort())
- mapper = vtk.vtkPolyDataMapper()
+ mapper = vtkPolyDataMapper()
mapper.SetInputConnection(resample.GetOutputPort())
mapper.SetScalarRange(range)
- actor = vtk.vtkActor()
+ actor = vtkActor()
actor.SetMapper(mapper)
- point_mapper = vtk.vtkPointGaussianMapper()
+ point_mapper = vtkPointGaussianMapper()
point_mapper.SetInputData(points)
point_mapper.SetScalarRange(range)
point_mapper.SetScaleFactor(0.6)
@@ -95,13 +115,13 @@ def main():
"}\n"
)
- point_actor = vtk.vtkActor()
+ point_actor = vtkActor()
point_actor.SetMapper(point_mapper)
- renderer = vtk.vtkRenderer()
- renWin = vtk.vtkRenderWindow()
+ renderer = vtkRenderer()
+ renWin = vtkRenderWindow()
renWin.AddRenderer(renderer)
- iren = vtk.vtkRenderWindowInteractor()
+ iren = vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
renderer.AddActor(actor)
diff --git a/src/Python/Meshes/SolidClip.py b/src/Python/Meshes/SolidClip.py
index 3ce24fe40b5bc39f5a748144603a40cd90b70195..2d1dd706ed695d86783bbd67e4129674b47caf61 100755
--- a/src/Python/Meshes/SolidClip.py
+++ b/src/Python/Meshes/SolidClip.py
@@ -1,40 +1,55 @@
# !/usr/bin/env python
# -*- coding: utf-8 -*-
-import vtkmodules.all as vtk
+# noinspection PyUnresolvedReferences
+import vtkmodules.vtkInteractionStyle
+# noinspection PyUnresolvedReferences
+import vtkmodules.vtkRenderingOpenGL2
+from vtkmodules.vtkCommonColor import vtkNamedColors
+from vtkmodules.vtkCommonDataModel import vtkPlane
+from vtkmodules.vtkFiltersCore import vtkClipPolyData
+from vtkmodules.vtkFiltersSources import vtkSuperquadricSource
+from vtkmodules.vtkRenderingCore import (
+ vtkActor,
+ vtkPolyDataMapper,
+ vtkProperty,
+ vtkRenderWindow,
+ vtkRenderWindowInteractor,
+ vtkRenderer
+)
def main():
# Create a superquadric
- superquadric_source = vtk.vtkSuperquadricSource()
+ superquadric_source = vtkSuperquadricSource()
superquadric_source.SetPhiRoundness(3.1)
superquadric_source.SetThetaRoundness(2.2)
# Define a clipping plane
- clip_plane = vtk.vtkPlane()
+ clip_plane = vtkPlane()
clip_plane.SetNormal(1.0, -1.0, -1.0)
clip_plane.SetOrigin(0.0, 0.0, 0.0)
# Clip the source with the plane
- clipper = vtk.vtkClipPolyData()
+ clipper = vtkClipPolyData()
clipper.SetInputConnection(superquadric_source.GetOutputPort())
clipper.SetClipFunction(clip_plane)
# This will give us the polygonal data that is clipped away
clipper.GenerateClippedOutputOn()
# Create a mapper and actor
- superquadric_mapper = vtk.vtkPolyDataMapper()
+ superquadric_mapper = vtkPolyDataMapper()
superquadric_mapper.SetInputConnection(clipper.GetOutputPort())
- superquadric_actor = vtk.vtkActor()
+ superquadric_actor = vtkActor()
superquadric_actor.SetMapper(superquadric_mapper)
- colors = vtk.vtkNamedColors()
+ colors = vtkNamedColors()
# Create a property to be used for the back faces. Turn off all
# shading by specifying 0 weights for specular and diffuse. Max the
# ambient.
- back_faces = vtk.vtkProperty()
+ back_faces = vtkProperty()
back_faces.SetSpecular(0.0)
back_faces.SetDiffuse(0.0)
back_faces.SetAmbient(1.0)
@@ -43,25 +58,25 @@ def main():
superquadric_actor.SetBackfaceProperty(back_faces)
# Here we get the the polygonal data that is clipped away
- clipped_away_mapper = vtk.vtkPolyDataMapper()
+ clipped_away_mapper = vtkPolyDataMapper()
clipped_away_mapper.SetInputData(clipper.GetClippedOutput())
clipped_away_mapper.ScalarVisibilityOff()
# Let us display it as a faint object
- clipped_away_actor = vtk.vtkActor()
+ clipped_away_actor = vtkActor()
clipped_away_actor.SetMapper(clipped_away_mapper)
clipped_away_actor.GetProperty().SetDiffuseColor(colors.GetColor3d("Silver"))
clipped_away_actor.GetProperty().SetOpacity(0.1)
# Create a renderer
- renderer = vtk.vtkRenderer()
+ renderer = vtkRenderer()
renderer.SetBackground(colors.GetColor3d('SlateGray'))
- render_window = vtk.vtkRenderWindow()
+ render_window = vtkRenderWindow()
render_window.AddRenderer(renderer)
- render_window_interactor = vtk.vtkRenderWindowInteractor()
+ render_window_interactor = vtkRenderWindowInteractor()
render_window_interactor.SetRenderWindow(render_window)
# Add the actor to the renderer