def __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(
self, module_manager,
vtk.vtkBYUReader(), 'Reading vtkBYU.',
(), ('vtkBYU',),
replaceDoc=True,
inputFunctions=None, outputFunctions=None)
def loadPolyData(filename):
'''Load a file and return a vtkPolyData object (not a vtkActor).'''
if not os.path.exists(filename):
colors.printc('Error in loadPolyData: Cannot find', filename, c=1)
return None
fl = filename.lower()
if fl.endswith('.vtk') or fl.endswith('.vtp'):
reader = vtk.vtkPolyDataReader()
elif fl.endswith('.ply'):
reader = vtk.vtkPLYReader()
elif fl.endswith('.obj'):
reader = vtk.vtkOBJReader()
elif fl.endswith('.stl'):
reader = vtk.vtkSTLReader()
elif fl.endswith('.byu') or fl.endswith('.g'):
reader = vtk.vtkBYUReader()
elif fl.endswith('.vtp'):
reader = vtk.vtkXMLPolyDataReader()
elif fl.endswith('.vts'):
reader = vtk.vtkXMLStructuredGridReader()
elif fl.endswith('.vtu'):
reader = vtk.vtkXMLUnstructuredGridReader()
elif fl.endswith('.txt'):
reader = vtk.vtkParticleReader() # (x y z scalar)
elif fl.endswith('.xyz'):
reader = vtk.vtkParticleReader()
else:
reader = vtk.vtkDataReader()
reader.SetFileName(filename)
if fl.endswith('.vts'): # structured grid
reader.Update()
gf = vtk.vtkStructuredGridGeometryFilter()
gf.SetInputConnection(reader.GetOutputPort())
gf.Update()
poly = gf.GetOutput()
elif fl.endswith('.vtu'): # unstructured grid
reader.Update()
gf = vtk.vtkGeometryFilter()
gf.SetInputConnection(reader.GetOutputPort())
gf.Update()
poly = gf.GetOutput()
else:
try:
reader.Update()
poly = reader.GetOutput()
except:
poly = None
if not poly:
return None
cleanpd = vtk.vtkCleanPolyData()
cleanpd.SetInputData(poly)
cleanpd.Update()
return cleanpd.GetOutput()
def ReadPolyData(fileName):
polyData = vtk.vtkPolyData()
extension = fileName.split(".")[-1].lower()
if (extension == "ply"):
reader = vtk.vtkPLYReader()
reader.SetFileName(fileName)
reader.Update()
polyData = reader.GetOutput()
elif (extension == "vtp"):
reader = vtk.vtkXMLPolyDataReader()
reader.SetFileName(fileName)
reader.Update()
polyData = reader.GetOutput()
elif (extension == "vtk"):
reader = vtk.vtkPolyDataReader()
reader.SetFileName(fileName)
reader.Update()
polyData = reader.GetOutput()
elif (extension == "obj"):
reader = vtk.vtkOBJReader()
reader.SetFileName(fileName)
reader.Update()
polyData = reader.GetOutput()
elif (extension == "stl"):
reader = vtk.vtkSTLReader()
reader.SetFileName(fileName)
reader.Update()
polyData = reader.GetOutput()
elif (extension == "g"):
reader = vtk.vtkBYUReader()
reader.SetGeometryFileName(fileName)
reader.Update()
polyData = reader.GetOutput()
else:
randomSequence = vtk.vtkMinimalStandardRandomSequence()
randomSequence.SetSeed(8775070)
points = vtk.vtkPointSource()
points.SetNumberOfPoints(100000)
points.SetRadius(10.0)
# Random position
x = randomSequence.GetRangeValue(-100, 100)
randomSequence.Next()
y = randomSequence.GetRangeValue(-100, 100)
randomSequence.Next()
z = randomSequence.GetRangeValue(-100, 100)
randomSequence.Next()
points.SetCenter(x, y, z)
points.SetDistributionToShell()
points.Update()
polyData = points.GetOutput()
return polyData
def get_polydata(filename):
reader = None
ext = splitext(filename)[1].lower()
if ext == ".ply":
reader = vtk.vtkPLYReader()
elif ext == ".vtp":
reader = vtk.vtkXMLpoly_dataReader()
elif ext == ".obj":
reader = vtk.vtkOBJReader()
elif ext == ".stl":
reader = vtk.vtkSTLReader()
elif ext == ".vtk":
reader = vtk.vtkpoly_dataReader()
elif ext == ".g":
reader = vtk.vtkBYUReader()
if reader is not None:
reader.SetFileName(filename)
reader.Update()
else:
raise IOError("Could not read %s" % filename)
return reader.GetOutput()
def loadPoly(filename):
'''Return a vtkPolyData object, NOT a vtkActor'''
if not os.path.exists(filename):
vc.printc(('Error in loadPoly: Cannot find', filename), c=1)
return None
fl = filename.lower()
if '.vtk' in fl: reader = vtk.vtkPolyDataReader()
elif '.ply' in fl: reader = vtk.vtkPLYReader()
elif '.obj' in fl: reader = vtk.vtkOBJReader()
elif '.stl' in fl: reader = vtk.vtkSTLReader()
elif '.byu' in fl or '.g' in fl: reader = vtk.vtkBYUReader()
elif '.vtp' in fl: reader = vtk.vtkXMLPolyDataReader()
elif '.vts' in fl: reader = vtk.vtkXMLStructuredGridReader()
elif '.vtu' in fl: reader = vtk.vtkXMLUnstructuredGridReader()
elif '.txt' in fl: reader = vtk.vtkParticleReader() # (x y z scalar)
elif '.xyz' in fl: reader = vtk.vtkParticleReader()
else: reader = vtk.vtkDataReader()
reader.SetFileName(filename)
reader.Update()
if '.vts' in fl: # structured grid
gf = vtk.vtkStructuredGridGeometryFilter()
gf.SetInputConnection(reader.GetOutputPort())
gf.Update()
poly = gf.GetOutput()
elif '.vtu' in fl: # unstructured grid
gf = vtk.vtkGeometryFilter()
gf.SetInputConnection(reader.GetOutputPort())
gf.Update()
poly = gf.GetOutput()
else:
poly = reader.GetOutput()
if not poly:
vc.printc(('Unable to load', filename), c=1)
return False
cleanpd = vtk.vtkCleanPolyData()
vu.setInput(cleanpd, poly)
cleanpd.Update()
return cleanpd.GetOutput()
def ReadPolyData(file_name):
import os
path, extension = os.path.splitext(file_name)
extension = extension.lower()
if extension == '.ply':
reader = vtk.vtkPLYReader()
reader.SetFileName(file_name)
reader.Update()
poly_data = reader.GetOutput()
elif extension == '.vtp':
reader = vtk.vtkXMLpoly_dataReader()
reader.SetFileName(file_name)
reader.Update()
poly_data = reader.GetOutput()
elif extension == '.obj':
reader = vtk.vtkOBJReader()
reader.SetFileName(file_name)
reader.Update()
poly_data = reader.GetOutput()
elif extension == '.stl':
reader = vtk.vtkSTLReader()
reader.SetFileName(file_name)
reader.Update()
poly_data = reader.GetOutput()
elif extension == '.vtk':
reader = vtk.vtkpoly_dataReader()
reader.SetFileName(file_name)
reader.Update()
poly_data = reader.GetOutput()
elif extension == '.g':
reader = vtk.vtkBYUReader()
reader.SetGeometryFileName(file_name)
reader.Update()
poly_data = reader.GetOutput()
else:
# Return a sphere if the extension is unknown.
source = vtk.vtkSphereSource()
source.Update()
poly_data = source.GetOutput()
return poly_data
def ReadPolyData(file_name):
import os
extension = os.path.splitext(file_name)[1]
extension = extension.lower()
if extension == ".ply":
reader = vtk.vtkPLYReader()
reader.SetFileName(file_name)
reader.Update()
poly_data = reader.GetOutput()
elif extension == ".vtp":
reader = vtk.vtkXMLpoly_dataReader()
reader.SetFileName(file_name)
reader.Update()
poly_data = reader.GetOutput()
elif extension == ".obj":
reader = vtk.vtkOBJReader()
reader.SetFileName(file_name)
reader.Update()
poly_data = reader.GetOutput()
elif extension == ".stl":
reader = vtk.vtkSTLReader()
reader.SetFileName(file_name)
reader.Update()
poly_data = reader.GetOutput()
elif extension == ".vtk":
reader = vtk.vtkpoly_dataReader()
reader.SetFileName(file_name)
reader.Update()
poly_data = reader.GetOutput()
elif extension == ".g":
reader = vtk.vtkBYUReader()
reader.SetGeometryFileName(file_name)
reader.Update()
poly_data = reader.GetOutput()
else:
# Return a None if the extension is unknown.
poly_data = None
return poly_data
points.InsertPoint(0, 0.0, 0.0, 0.0)
norms.InsertTuple3(0, 0.0, 0.0, 1.0)
points.InsertPoint(1, 0.0, 0.0, 0.0)
norms.InsertTuple3(1, -1.0, 0.0, 0.0)
planes.SetPoints(points)
planes.SetNormals(norms)
# texture
texReader = vtk.vtkStructuredPointsReader()
texReader.SetFileName("" + str(VTK_DATA_ROOT) + "/Data/texThres2.vtk")
texture = vtk.vtkTexture()
texture.SetInputConnection(texReader.GetOutputPort())
texture.InterpolateOff()
texture.RepeatOff()
# read motor parts...each part colored separately
#
byu = vtk.vtkBYUReader()
byu.SetGeometryFileName("" + str(VTK_DATA_ROOT) + "/Data/motor.g")
byu.SetPartNumber(1)
normals = vtk.vtkPolyDataNormals()
normals.SetInputConnection(byu.GetOutputPort())
tex1 = vtk.vtkImplicitTextureCoords()
tex1.SetInputConnection(normals.GetOutputPort())
tex1.SetRFunction(planes)
# tex1 FlipTextureOn
byuMapper = vtk.vtkDataSetMapper()
byuMapper.SetInputConnection(tex1.GetOutputPort())
byuActor = vtk.vtkActor()
byuActor.SetMapper(byuMapper)
byuActor.SetTexture(texture)
byuActor.GetProperty().SetColor(cold_grey)
byu2 = vtk.vtkBYUReader()
def walk_cow(file_name, figure):
figure = abs(figure)
if figure > 2:
figure = 0
colors = vtk.vtkNamedColors()
# Set the background color.
colors.SetColor("BkgColor1", [60, 93, 144, 255])
colors.SetColor("BkgColor2", [26, 51, 102, 255])
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# The cow pipeline.
cow = vtk.vtkBYUReader()
cow.SetGeometryFileName(file_name)
cow.Update()
cowMapper = vtk.vtkPolyDataMapper()
cowMapper.SetInputConnection(cow.GetOutputPort())
cowMapper.ScalarVisibilityOff()
cowActor = vtk.vtkActor()
cowActor.SetMapper(cowMapper)
cowActor.GetProperty().SetColor(colors.GetColor3d("Wheat"))
ren.AddActor(cowActor)
# Axes pipeline.
cowAxesSource = vtk.vtkAxes()
cowAxesSource.SetScaleFactor(10.0)
cowAxesSource.SetOrigin(0, 0, 0)
cowAxesMapper = vtk.vtkPolyDataMapper()
cowAxesMapper.SetInputConnection(cowAxesSource.GetOutputPort())
cowAxes = vtk.vtkActor()
cowAxes.SetMapper(cowAxesMapper)
cowAxes.VisibilityOff()
ren.AddActor(cowAxes)
ren.SetBackground(colors.GetColor3d("BkgColor1"))
renWin.SetSize(600, 480)
iren.Initialize()
cowAxes.VisibilityOn()
renWin.Render()
# Activate this if you want to see the Position and Focal point.
# ren.GetActiveCamera().AddObserver('ModifiedEvent', CameraModifiedCallback)
# These four walks use the same camera position.
Rotate_X(cowActor, ren, renWin)
Rotate_Y(cowActor, ren, renWin)
Rotate_Z(cowActor, ren, renWin)
Rotate_XY(cowActor, ren, renWin)
ren.SetBackground(colors.GetColor3d("BkgColor2"))
if figure == 1:
Rotate_V_0(cowActor, ren, renWin)
elif figure == 2:
Rotate_V_V(cowActor, ren, renWin)
else:
Rotate_V_0(cowActor, ren, renWin)
Rotate_V_V(cowActor, ren, renWin)
# Walk() needs to go after Rotate_V_0() or Rotate_V_V().
Walk(cowActor, ren, renWin)
# Interact with data.
renWin.EraseOff()
iren.Start()
#!/usr/bin/env python # This example demonstrates the use of vtkCubeAxesActor2D to indicate # the position in space that the camera is currently viewing. The # vtkCubeAxesActor2D draws axes on the bounding box of the data set # and labels the axes with x-y-z coordinates. import vtk from vtk.util.misc import vtkGetDataRoot VTK_DATA_ROOT = vtkGetDataRoot() # Create a vtkBYUReader and read in a data set. fohe = vtk.vtkBYUReader() fohe.SetGeometryFileName(VTK_DATA_ROOT + "/Data/teapot.g") # Create a vtkPolyDataNormals filter to calculate the normals of the # data set. normals = vtk.vtkPolyDataNormals() normals.SetInputConnection(fohe.GetOutputPort()) # Set up the associated mapper and actor. foheMapper = vtk.vtkPolyDataMapper() foheMapper.SetInputConnection(normals.GetOutputPort()) foheActor = vtk.vtkLODActor() foheActor.SetMapper(foheMapper) # Create a vtkOutlineFilter to draw the bounding box of the data set. # Also create the associated mapper and actor. outline = vtk.vtkOutlineFilter() outline.SetInputConnection(normals.GetOutputPort()) mapOutline = vtk.vtkPolyDataMapper() mapOutline.SetInputConnection(outline.GetOutputPort())
def _load_file(filename, c, alpha, threshold, spacing, unpack):
fl = filename.lower()
################################################################# other formats:
if fl.endswith(".xml") or fl.endswith(".xml.gz") or fl.endswith(".xdmf"):
# Fenics tetrahedral file
actor = loadDolfin(filename)
elif fl.endswith(".neutral") or fl.endswith(".neu"): # neutral tetrahedral file
actor = loadNeutral(filename)
elif fl.endswith(".gmsh"): # gmesh file
actor = loadGmesh(filename)
elif fl.endswith(".pcd"): # PCL point-cloud format
actor = loadPCD(filename)
actor.GetProperty().SetPointSize(2)
elif fl.endswith(".off"):
actor = loadOFF(filename)
elif fl.endswith(".3ds"): # 3ds format
actor = load3DS(filename)
elif fl.endswith(".wrl"):
importer = vtk.vtkVRMLImporter()
importer.SetFileName(filename)
importer.Read()
importer.Update()
actors = importer.GetRenderer().GetActors() #vtkActorCollection
actors.InitTraversal()
wacts = []
for i in range(actors.GetNumberOfItems()):
act = actors.GetNextActor()
wacts.append(act)
actor = Assembly(wacts)
################################################################# volumetric:
elif fl.endswith(".tif") or fl.endswith(".slc") or fl.endswith(".vti") \
or fl.endswith(".mhd") or fl.endswith(".nrrd") or fl.endswith(".nii") \
or fl.endswith(".dem"):
img = loadImageData(filename, spacing)
if threshold is False:
if c is None and alpha == 1:
c = ['b','lb','lg','y','r'] # good for blackboard background
alpha = (0.0, 0.0, 0.2, 0.4, 0.8, 1)
actor = Volume(img, c, alpha)
else:
actor = Volume(img).isosurface(threshold=threshold)
actor.color(c).alpha(alpha)
################################################################# 2D images:
elif fl.endswith(".png") or fl.endswith(".jpg") or fl.endswith(".bmp") or fl.endswith(".jpeg"):
if ".png" in fl:
picr = vtk.vtkPNGReader()
elif ".jpg" in fl or ".jpeg" in fl:
picr = vtk.vtkJPEGReader()
elif ".bmp" in fl:
picr = vtk.vtkBMPReader()
picr.SetFileName(filename)
picr.Update()
actor = Picture() # object derived from vtk.vtkImageActor()
actor.SetInputData(picr.GetOutput())
if alpha is None:
alpha = 1
actor.SetOpacity(alpha)
################################################################# multiblock:
elif fl.endswith(".vtm") or fl.endswith(".vtmb"):
read = vtk.vtkXMLMultiBlockDataReader()
read.SetFileName(filename)
read.Update()
mb = read.GetOutput()
if unpack:
acts = []
for i in range(mb.GetNumberOfBlocks()):
b = mb.GetBlock(i)
if isinstance(b, (vtk.vtkPolyData,
vtk.vtkImageData,
vtk.vtkUnstructuredGrid,
vtk.vtkStructuredGrid,
vtk.vtkRectilinearGrid)):
acts.append(b)
return acts
else:
return mb
################################################################# numpy:
elif fl.endswith(".npy"):
acts = loadNumpy(filename)
if unpack == False:
return Assembly(acts)
return acts
elif fl.endswith(".geojson") or fl.endswith(".geojson.gz"):
return loadGeoJSON(fl)
################################################################# polygonal mesh:
else:
if fl.endswith(".vtk"): # read all legacy vtk types
#output can be:
# PolyData, StructuredGrid, StructuredPoints, UnstructuredGrid, RectilinearGrid
reader = vtk.vtkDataSetReader()
reader.ReadAllScalarsOn()
reader.ReadAllVectorsOn()
reader.ReadAllTensorsOn()
reader.ReadAllFieldsOn()
reader.ReadAllNormalsOn()
reader.ReadAllColorScalarsOn()
elif fl.endswith(".ply"):
reader = vtk.vtkPLYReader()
elif fl.endswith(".obj"):
reader = vtk.vtkOBJReader()
elif fl.endswith(".stl"):
reader = vtk.vtkSTLReader()
elif fl.endswith(".byu") or fl.endswith(".g"):
reader = vtk.vtkBYUReader()
elif fl.endswith(".foam"): # OpenFoam
reader = vtk.vtkOpenFOAMReader()
elif fl.endswith(".pvd"):
reader = vtk.vtkXMLGenericDataObjectReader()
elif fl.endswith(".vtp"):
reader = vtk.vtkXMLPolyDataReader()
elif fl.endswith(".vts"):
reader = vtk.vtkXMLStructuredGridReader()
elif fl.endswith(".vtu"):
reader = vtk.vtkXMLUnstructuredGridReader()
elif fl.endswith(".vtr"):
reader = vtk.vtkXMLRectilinearGridReader()
elif fl.endswith(".pvtk"):
reader = vtk.vtkPDataSetReader()
elif fl.endswith(".pvtr"):
reader = vtk.vtkXMLPRectilinearGridReader()
elif fl.endswith("pvtu"):
reader = vtk.vtkXMLPUnstructuredGridReader()
elif fl.endswith(".txt") or fl.endswith(".xyz"):
reader = vtk.vtkParticleReader() # (format is x, y, z, scalar)
elif fl.endswith(".facet"):
reader = vtk.vtkFacetReader()
else:
return None
reader.SetFileName(filename)
reader.Update()
routput = reader.GetOutput()
if not routput:
colors.printc("~noentry Unable to load", filename, c=1)
return None
actor = Actor(routput, c, alpha)
if fl.endswith(".txt") or fl.endswith(".xyz"):
actor.GetProperty().SetPointSize(4)
actor.filename = filename
return actor
# In this example vtkClipPolyData is used to cut a polygonal model
# of a cow in half. In addition, the open clip is closed by triangulating
# the resulting complex polygons.
import vtk
import wizi
from vtk.util.misc import vtkGetDataRoot
from vtk.util.colors import peacock, tomato
# VTK_DATA_ROOT = vtkGetDataRoot()
# First start by reading a cow model. We also generate surface normals for
# prettier rendering.
cow = vtk.vtkBYUReader()
cow.SetGeometryFileName("../VTKData/Data/Viewpoint/cow.g")
cowNormals = vtk.vtkPolyDataNormals()
cowNormals.SetInputConnection(cow.GetOutputPort())
# We clip with an implicit function. Here we use a plane positioned near
# the center of the cow model and oriented at an arbitrary angle.
plane = vtk.vtkPlane()
plane.SetOrigin(0.25, 0, 0)
plane.SetNormal(-1, -1, 0)
# vtkClipPolyData requires an implicit function to define what it is to
# clip with. Any implicit function, including complex boolean combinations
# can be used. Notice that we can specify the value of the implicit function
# with the SetValue method.
clipper = vtk.vtkClipPolyData()
#!/usr/bin/env python # This example demonstrates the use of vtkCubeAxesActor2D to indicate # the position in space that the camera is currently viewing. The # vtkCubeAxesActor2D draws axes on the bounding box of the data set # and labels the axes with x-y-z coordinates. import vtk from vtk.util.misc import vtkGetDataRoot VTK_DATA_ROOT = vtkGetDataRoot() # Create a vtkBYUReader and read in a data set. fohe = vtk.vtkBYUReader() fohe.SetGeometryFileName(VTK_DATA_ROOT + "/Data/teapot.g") # Create a vtkPolyDataNormals filter to calculate the normals of the # data set. normals = vtk.vtkPolyDataNormals() normals.SetInputConnection(fohe.GetOutputPort()) # Set up the associated mapper and actor. foheMapper = vtk.vtkPolyDataMapper() foheMapper.SetInputConnection(normals.GetOutputPort()) foheActor = vtk.vtkLODActor() foheActor.SetMapper(foheMapper) # Create a vtkOutlineFilter to draw the bounding box of the data set. # Also create the associated mapper and actor. outline = vtk.vtkOutlineFilter() outline.SetInputConnection(normals.GetOutputPort()) mapOutline = vtk.vtkPolyDataMapper() mapOutline.SetInputConnection(outline.GetOutputPort())
points.InsertPoint(1, 0.0, 0.0, 0.0) norms.InsertTuple3(1, -1.0, 0.0, 0.0) planes.SetPoints(points) planes.SetNormals(norms) # texture texReader = vtk.vtkStructuredPointsReader() texReader.SetFileName(VTK_DATA_ROOT + "/Data/texThres2.vtk") texture = vtk.vtkTexture() texture.SetInputConnection(texReader.GetOutputPort()) texture.InterpolateOff() texture.RepeatOff() # read motor parts...each part colored separately # byu = vtk.vtkBYUReader() byu.SetGeometryFileName(VTK_DATA_ROOT + "/Data/motor.g") byu.SetPartNumber(1) normals = vtk.vtkPolyDataNormals() normals.SetInputConnection(byu.GetOutputPort()) tex1 = vtk.vtkImplicitTextureCoords() tex1.SetInputConnection(normals.GetOutputPort()) tex1.SetRFunction(planes) # tex1.FlipTextureOn() byuMapper = vtk.vtkDataSetMapper() byuMapper.SetInputConnection(tex1.GetOutputPort()) byuActor = vtk.vtkActor()
#!/usr/bin/env python
# In this example vtkClipPolyData is used to cut a polygonal model
# of a cow in half. In addition, the open clip is closed by triangulating
# the resulting complex polygons.
import vtk
from vtk.util.misc import vtkGetDataRoot
from vtk.util.colors import peacock, tomato, green
VTK_DATA_ROOT = vtkGetDataRoot()
# First start by reading a cow model. We also generate surface normals for
# prettier rendering.
cow = vtk.vtkBYUReader() # Data Source
cow.SetGeometryFileName("cow.g")
print(cow)
#Compute Normals
cowNormals = vtk.vtkPolyDataNormals()
cowNormals.SetInputConnection(cow.GetOutputPort())
# We clip with an implicit function. Here we use a plane positioned near
# the center of the cow model and oriented at an arbitrary angle.
plane = vtk.vtkPlane()
plane.SetOrigin(0.25, 0, 0)
plane.SetNormal(0, 1, 0)
# vtkClipPolyData requires an implicit function to define what it is to
# clip with. Any implicit function, including complex boolean combinations
# can be used. Notice that we can specify the value of the implicit function
import vtk
from vtk.util.colors import brown_ochre, tomato, banana
cow = vtk.vtkBYUReader()
cow.SetGeometryFileName("cow.g")
normals = vtk.vtkPolyDataNormals()
normals.SetInputConnection(cow.GetOutputPort())
plane = vtk.vtkPlane()
plane.SetOrigin(0, 0, 0)
plane.SetNormal(-1, -1, 0)
clipper = vtk.vtkClipPolyData()
clipper.SetInputConnection(normals.GetOutputPort())
clipper.SetClipFunction(plane)
clipper.GenerateClipScalarsOn()
clipper.GenerateClippedOutputOn()
clipper.SetValue(0)
clipMapper = vtk.vtkPolyDataMapper()
clipMapper.SetInputConnection(clipper.GetOutputPort())
clipMapper.ScalarVisibilityOff()
backProp = vtk.vtkProperty()
backProp.SetDiffuseColor(tomato)
clipActor = vtk.vtkActor()
clipActor.SetMapper(clipMapper)
clipActor.GetProperty().SetColor(brown_ochre)
clipActor.SetBackfaceProperty(backProp)
cutEdges = vtk.vtkCutter()
cutEdges.SetInputConnection(normals.GetOutputPort())
cutEdges.SetCutFunction(plane)
import vtk
from vtk.test import Testing
from vtk.util.misc import vtkGetDataRoot
VTK_DATA_ROOT = vtkGetDataRoot()
# Create the RenderWindow, Renderer and both Actors
#
ren1 = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.SetMultiSamples(0)
renWin.AddRenderer(ren1)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
byuReader = vtk.vtkBYUReader()
byuReader.SetGeometryFileName(VTK_DATA_ROOT + "/Data/teapot.g")
byuMapper = vtk.vtkPolyDataMapper()
byuMapper.SetInputConnection(byuReader.GetOutputPort())
i = 0
while i < 9:
idx = str(i)
exec("byuActor" + idx + " = vtk.vtkActor()")
eval("byuActor" + idx).SetMapper(byuMapper)
ren1.AddActor(eval("byuActor" + idx))
exec("hull" + idx + " = vtk.vtkHull()")
eval("hull" + idx).SetInputConnection(byuReader.GetOutputPort())
def main():
colors = vtk.vtkNamedColors()
textureFile, motorFile = get_program_parameters()
# Create the Renderer, RenderWindow and RenderWindowInteractor.
ren = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
# Create the cutting planes.
planes = vtk.vtkPlanes()
points = vtk.vtkPoints()
norms = vtk.vtkFloatArray()
norms.SetNumberOfComponents(3)
points.InsertPoint(0, 0.0, 0.0, 0.0)
norms.InsertTuple3(0, 0.0, 0.0, 1.0)
points.InsertPoint(1, 0.0, 0.0, 0.0)
norms.InsertTuple3(1, -1.0, 0.0, 0.0)
planes.SetPoints(points)
planes.SetNormals(norms)
# Get the texture.
texReader = vtk.vtkStructuredPointsReader()
texReader.SetFileName(textureFile)
texture = vtk.vtkTexture()
texture.SetInputConnection(texReader.GetOutputPort())
texture.InterpolateOff()
texture.RepeatOff()
# Set up the pipelines for the parts of the motor.
# We will use lists of pipeline objects.
numberOfParts = 5
byu = list()
normals = list()
tex = list()
byuMapper = list()
byuActor = list()
partColours = [
'cold_grey', 'peacock', 'raw_sienna', 'banana', 'peach_puff'
]
# Use this to control which parts to display.
displayParts = [True] * numberOfParts
# If displayParts[2] = False then an image like that in the VTK tests is produced.
# Build the pipelines.
for i in range(0, numberOfParts):
byu.append(vtk.vtkBYUReader())
byu[i].SetGeometryFileName(motorFile)
byu[i].SetPartNumber(i + 1)
normals.append(vtk.vtkPolyDataNormals())
normals[i].SetInputConnection(byu[i].GetOutputPort())
tex.append(vtk.vtkImplicitTextureCoords())
tex[i].SetInputConnection(normals[i].GetOutputPort())
tex[i].SetRFunction(planes)
# tex[i].FlipTextureOn()
byuMapper.append(vtk.vtkDataSetMapper())
byuMapper[i].SetInputConnection(tex[i].GetOutputPort())
byuActor.append(vtk.vtkActor())
byuActor[i].SetMapper(byuMapper[i])
byuActor[i].SetTexture(texture)
byuActor[i].GetProperty().SetColor(colors.GetColor3d(partColours[i]))
ren.AddActor(byuActor[i])
if displayParts[i]:
byuActor[i].VisibilityOn()
else:
byuActor[i].VisibilityOff()
ren.SetBackground(colors.GetColor3d('AliceBlue'))
renWin.SetSize(512, 512)
renWin.SetWindowName('Motor')
camera = vtk.vtkCamera()
camera.SetFocalPoint(0.0286334, 0.0362996, 0.0379685)
camera.SetPosition(1.37067, 1.08629, -1.30349)
camera.SetViewAngle(17.673)
camera.SetClippingRange(1, 10)
camera.SetViewUp(-0.376306, -0.5085, -0.774482)
ren.SetActiveCamera(camera)
# Render the image.
iren.Initialize()
iren.Start()
#!/usr/bin/env python
import vtk
from vtk.util.misc import vtkGetDataRoot
VTK_DATA_ROOT = vtkGetDataRoot()
# Create the RenderWindow, Renderer and both Actors
#
ren1 = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.SetMultiSamples(0)
renWin.AddRenderer(ren1)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
byuReader = vtk.vtkBYUReader()
byuReader.SetGeometryFileName(VTK_DATA_ROOT + "/Data/teapot.g")
byuMapper = vtk.vtkPolyDataMapper()
byuMapper.SetInputConnection(byuReader.GetOutputPort())
i = 0
while i < 9:
idx = str(i)
exec("byuActor" + idx + " = vtk.vtkActor()")
eval("byuActor" + idx).SetMapper(byuMapper)
ren1.AddActor(eval("byuActor" + idx))
exec("hull" + idx + " = vtk.vtkHull()")
eval("hull" + idx).SetInputConnection(byuReader.GetOutputPort())
