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()
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())